1 /* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1)
5 * Linux Trace Toolkit Next Generation Kernel State Dump
7 * Copyright 2005 Jean-Hugues Deschenes <jean-hugues.deschenes@polymtl.ca>
8 * Copyright 2006-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
11 * Eric Clement: Add listing of network IP interface
12 * 2006, 2007 Mathieu Desnoyers Fix kernel threads
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/netlink.h>
19 #include <linux/inet.h>
21 #include <linux/kthread.h>
22 #include <linux/proc_fs.h>
23 #include <linux/file.h>
24 #include <linux/interrupt.h>
25 #include <linux/irqnr.h>
26 #include <linux/cpu.h>
27 #include <linux/netdevice.h>
28 #include <linux/inetdevice.h>
30 #include <linux/swap.h>
31 #include <linux/wait.h>
32 #include <linux/mutex.h>
33 #include <linux/device.h>
35 #include <lttng-events.h>
36 #include <lttng-tracer.h>
37 #include <wrapper/irqdesc.h>
38 #include <wrapper/spinlock.h>
39 #include <wrapper/fdtable.h>
40 #include <wrapper/irq.h>
41 #include <wrapper/tracepoint.h>
42 #include <wrapper/genhd.h>
43 #include <wrapper/file.h>
44 #include <wrapper/fdtable.h>
45 #include <wrapper/sched.h>
47 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
48 #include <linux/irq.h>
51 /* Define the tracepoints, but do not build the probes */
52 #define CREATE_TRACE_POINTS
53 #define TRACE_INCLUDE_PATH instrumentation/events/lttng-module
54 #define TRACE_INCLUDE_FILE lttng-statedump
55 #define LTTNG_INSTRUMENTATION
56 #include <instrumentation/events/lttng-module/lttng-statedump.h>
58 LTTNG_DEFINE_TRACE(lttng_statedump_block_device
,
59 TP_PROTO(struct lttng_session
*session
,
60 dev_t dev
, const char *diskname
),
61 TP_ARGS(session
, dev
, diskname
));
63 LTTNG_DEFINE_TRACE(lttng_statedump_end
,
64 TP_PROTO(struct lttng_session
*session
),
67 LTTNG_DEFINE_TRACE(lttng_statedump_interrupt
,
68 TP_PROTO(struct lttng_session
*session
,
69 unsigned int irq
, const char *chip_name
,
70 struct irqaction
*action
),
71 TP_ARGS(session
, irq
, chip_name
, action
));
73 LTTNG_DEFINE_TRACE(lttng_statedump_file_descriptor
,
74 TP_PROTO(struct lttng_session
*session
,
75 struct task_struct
*p
, int fd
, const char *filename
,
76 unsigned int flags
, fmode_t fmode
),
77 TP_ARGS(session
, p
, fd
, filename
, flags
, fmode
));
79 LTTNG_DEFINE_TRACE(lttng_statedump_start
,
80 TP_PROTO(struct lttng_session
*session
),
83 LTTNG_DEFINE_TRACE(lttng_statedump_process_state
,
84 TP_PROTO(struct lttng_session
*session
,
85 struct task_struct
*p
,
86 int type
, int mode
, int submode
, int status
,
87 struct pid_namespace
*pid_ns
),
88 TP_ARGS(session
, p
, type
, mode
, submode
, status
, pid_ns
));
90 LTTNG_DEFINE_TRACE(lttng_statedump_network_interface
,
91 TP_PROTO(struct lttng_session
*session
,
92 struct net_device
*dev
, struct in_ifaddr
*ifa
),
93 TP_ARGS(session
, dev
, ifa
));
97 struct lttng_session
*session
;
98 struct task_struct
*p
;
99 struct files_struct
*files
;
103 * Protected by the trace lock.
105 static struct delayed_work cpu_work
[NR_CPUS
];
106 static DECLARE_WAIT_QUEUE_HEAD(statedump_wq
);
107 static atomic_t kernel_threads_to_run
;
109 enum lttng_thread_type
{
110 LTTNG_USER_THREAD
= 0,
111 LTTNG_KERNEL_THREAD
= 1,
114 enum lttng_execution_mode
{
120 LTTNG_MODE_UNKNOWN
= 5,
123 enum lttng_execution_submode
{
128 enum lttng_process_status
{
140 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,11,0))
142 #define LTTNG_PART_STRUCT_TYPE struct block_device
145 int lttng_get_part_name(struct gendisk
*disk
, struct block_device
*part
, char *name_buf
)
149 p
= bdevname(part
, name_buf
);
157 dev_t
lttng_get_part_devt(struct block_device
*part
)
164 #define LTTNG_PART_STRUCT_TYPE struct hd_struct
167 int lttng_get_part_name(struct gendisk
*disk
, struct hd_struct
*part
, char *name_buf
)
170 struct block_device bdev
;
173 * Create a partial 'struct blockdevice' to use
174 * 'bdevname()' which is a simple wrapper over
175 * 'disk_name()' but has the honor to be EXPORT_SYMBOL.
180 p
= bdevname(&bdev
, name_buf
);
188 dev_t
lttng_get_part_devt(struct hd_struct
*part
)
190 return part_devt(part
);
194 #if (LTTNG_LINUX_VERSION_CODE >= LTTNG_KERNEL_VERSION(5,12,0))
196 int lttng_statedump_each_block_device(struct lttng_session
*session
, struct gendisk
*disk
)
198 struct block_device
*part
;
202 /* Include partition 0 */
206 xa_for_each(&disk
->part_tbl
, idx
, part
) {
207 char name_buf
[BDEVNAME_SIZE
];
209 /* Exclude non-partitions bdev and empty partitions. */
210 if (bdev_is_partition(part
) && !bdev_nr_sectors(part
))
213 if (lttng_get_part_name(disk
, part
, name_buf
) == -ENOSYS
) {
217 trace_lttng_statedump_block_device(session
, lttng_get_part_devt(part
),
226 int lttng_statedump_each_block_device(struct lttng_session
*session
, struct gendisk
*disk
)
228 struct disk_part_iter piter
;
229 LTTNG_PART_STRUCT_TYPE
*part
;
231 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_PART0
);
233 while ((part
= disk_part_iter_next(&piter
))) {
234 char name_buf
[BDEVNAME_SIZE
];
236 if (lttng_get_part_name(disk
, part
, name_buf
) == -ENOSYS
) {
237 disk_part_iter_exit(&piter
);
240 trace_lttng_statedump_block_device(session
, lttng_get_part_devt(part
),
243 disk_part_iter_exit(&piter
);
250 int lttng_enumerate_block_devices(struct lttng_session
*session
)
252 struct class *ptr_block_class
;
253 struct device_type
*ptr_disk_type
;
254 struct class_dev_iter iter
;
258 ptr_block_class
= wrapper_get_block_class();
259 if (!ptr_block_class
) {
263 ptr_disk_type
= wrapper_get_disk_type();
264 if (!ptr_disk_type
) {
268 class_dev_iter_init(&iter
, ptr_block_class
, NULL
, ptr_disk_type
);
269 while ((dev
= class_dev_iter_next(&iter
))) {
270 struct gendisk
*disk
= dev_to_disk(dev
);
273 * Don't show empty devices or things that have been
276 if (get_capacity(disk
) == 0 ||
277 (disk
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
))
280 ret
= lttng_statedump_each_block_device(session
, disk
);
282 class_dev_iter_exit(&iter
);
290 void lttng_enumerate_device(struct lttng_session
*session
,
291 struct net_device
*dev
)
293 struct in_device
*in_dev
;
294 struct in_ifaddr
*ifa
;
296 if (dev
->flags
& IFF_UP
) {
297 in_dev
= in_dev_get(dev
);
299 for (ifa
= in_dev
->ifa_list
; ifa
!= NULL
;
300 ifa
= ifa
->ifa_next
) {
301 trace_lttng_statedump_network_interface(
307 trace_lttng_statedump_network_interface(
313 int lttng_enumerate_network_ip_interface(struct lttng_session
*session
)
315 struct net_device
*dev
;
317 read_lock(&dev_base_lock
);
318 for_each_netdev(&init_net
, dev
)
319 lttng_enumerate_device(session
, dev
);
320 read_unlock(&dev_base_lock
);
324 #else /* CONFIG_INET */
326 int lttng_enumerate_network_ip_interface(struct lttng_session
*session
)
330 #endif /* CONFIG_INET */
333 int lttng_dump_one_fd(const void *p
, struct file
*file
, unsigned int fd
)
335 const struct lttng_fd_ctx
*ctx
= p
;
336 const char *s
= d_path(&file
->f_path
, ctx
->page
, PAGE_SIZE
);
337 unsigned int flags
= file
->f_flags
;
341 * We don't expose kernel internal flags, only userspace-visible
344 flags
&= ~FMODE_NONOTIFY
;
345 fdt
= files_fdtable(ctx
->files
);
347 * We need to check here again whether fd is within the fdt
348 * max_fds range, because we might be seeing a different
349 * files_fdtable() than iterate_fd(), assuming only RCU is
350 * protecting the read. In reality, iterate_fd() holds
351 * file_lock, which should ensure the fdt does not change while
352 * the lock is taken, but we are not aware whether this is
353 * guaranteed or not, so play safe.
355 if (fd
< fdt
->max_fds
&& lttng_close_on_exec(fd
, fdt
))
358 struct dentry
*dentry
= file
->f_path
.dentry
;
360 /* Make sure we give at least some info */
361 spin_lock(&dentry
->d_lock
);
362 trace_lttng_statedump_file_descriptor(ctx
->session
, ctx
->p
, fd
,
363 dentry
->d_name
.name
, flags
, file
->f_mode
);
364 spin_unlock(&dentry
->d_lock
);
367 trace_lttng_statedump_file_descriptor(ctx
->session
, ctx
->p
, fd
, s
,
368 flags
, file
->f_mode
);
374 void lttng_enumerate_task_fd(struct lttng_session
*session
,
375 struct task_struct
*p
, char *tmp
)
377 struct lttng_fd_ctx ctx
= { .page
= tmp
, .session
= session
, .p
= p
};
378 struct files_struct
*files
;
385 lttng_iterate_fd(files
, 0, lttng_dump_one_fd
, &ctx
);
391 int lttng_enumerate_file_descriptors(struct lttng_session
*session
)
393 struct task_struct
*p
;
396 tmp
= (char *) __get_free_page(GFP_KERNEL
);
400 /* Enumerate active file descriptors */
403 lttng_enumerate_task_fd(session
, p
, tmp
);
405 free_page((unsigned long) tmp
);
411 * FIXME: we cannot take a mmap_sem while in a RCU read-side critical section
412 * (scheduling in atomic). Normally, the tasklist lock protects this kind of
413 * iteration, but it is not exported to modules.
416 void lttng_enumerate_task_vm_maps(struct lttng_session
*session
,
417 struct task_struct
*p
)
419 struct mm_struct
*mm
;
420 struct vm_area_struct
*map
;
423 /* get_task_mm does a task_lock... */
430 down_read(&mm
->mmap_sem
);
433 ino
= map
->vm_file
->lttng_f_dentry
->d_inode
->i_ino
;
436 trace_lttng_statedump_vm_map(session
, p
, map
, ino
);
439 up_read(&mm
->mmap_sem
);
445 int lttng_enumerate_vm_maps(struct lttng_session
*session
)
447 struct task_struct
*p
;
451 lttng_enumerate_task_vm_maps(session
, p
);
457 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
459 #if (LTTNG_LINUX_VERSION_CODE < LTTNG_KERNEL_VERSION(2,6,39))
460 #define irq_desc_get_chip(desc) get_irq_desc_chip(desc)
464 int lttng_list_interrupts(struct lttng_session
*session
)
467 unsigned long flags
= 0;
468 struct irq_desc
*desc
;
470 #define irq_to_desc wrapper_irq_to_desc
472 for_each_irq_desc(irq
, desc
) {
473 struct irqaction
*action
;
474 const char *irq_chip_name
=
475 irq_desc_get_chip(desc
)->name
? : "unnamed_irq_chip";
477 local_irq_save(flags
);
478 wrapper_desc_spin_lock(&desc
->lock
);
479 for (action
= desc
->action
; action
; action
= action
->next
) {
480 trace_lttng_statedump_interrupt(session
,
481 irq
, irq_chip_name
, action
);
483 wrapper_desc_spin_unlock(&desc
->lock
);
484 local_irq_restore(flags
);
491 int lttng_list_interrupts(struct lttng_session
*session
)
498 * Called with task lock held.
501 void lttng_statedump_process_ns(struct lttng_session
*session
,
502 struct task_struct
*p
,
503 enum lttng_thread_type type
,
504 enum lttng_execution_mode mode
,
505 enum lttng_execution_submode submode
,
506 enum lttng_process_status status
)
508 struct pid_namespace
*pid_ns
;
510 pid_ns
= task_active_pid_ns(p
);
512 trace_lttng_statedump_process_state(session
,
513 p
, type
, mode
, submode
, status
, pid_ns
);
514 pid_ns
= pid_ns
? pid_ns
->parent
: NULL
;
519 int lttng_enumerate_process_states(struct lttng_session
*session
)
521 struct task_struct
*g
, *p
;
524 for_each_process(g
) {
527 enum lttng_execution_mode mode
=
529 enum lttng_execution_submode submode
=
531 enum lttng_process_status status
;
532 enum lttng_thread_type type
;
535 if (p
->exit_state
== EXIT_ZOMBIE
)
536 status
= LTTNG_ZOMBIE
;
537 else if (p
->exit_state
== EXIT_DEAD
)
539 else if (lttng_task_is_running(p
)) {
540 /* Is this a forked child that has not run yet? */
541 if (list_empty(&p
->rt
.run_list
))
542 status
= LTTNG_WAIT_FORK
;
545 * All tasks are considered as wait_cpu;
546 * the viewer will sort out if the task
547 * was really running at this time.
549 status
= LTTNG_WAIT_CPU
;
550 } else if (lttng_get_task_state(p
) &
551 (TASK_INTERRUPTIBLE
| TASK_UNINTERRUPTIBLE
)) {
552 /* Task is waiting for something to complete */
555 status
= LTTNG_UNNAMED
;
556 submode
= LTTNG_NONE
;
559 * Verification of t->mm is to filter out kernel
560 * threads; Viewer will further filter out if a
561 * user-space thread was in syscall mode or not.
564 type
= LTTNG_USER_THREAD
;
566 type
= LTTNG_KERNEL_THREAD
;
567 lttng_statedump_process_ns(session
,
568 p
, type
, mode
, submode
, status
);
570 } while_each_thread(g
, p
);
578 void lttng_statedump_work_func(struct work_struct
*work
)
580 if (atomic_dec_and_test(&kernel_threads_to_run
))
581 /* If we are the last thread, wake up do_lttng_statedump */
582 wake_up(&statedump_wq
);
586 int do_lttng_statedump(struct lttng_session
*session
)
590 trace_lttng_statedump_start(session
);
591 ret
= lttng_enumerate_process_states(session
);
594 ret
= lttng_enumerate_file_descriptors(session
);
599 * ret = lttng_enumerate_vm_maps(session);
603 ret
= lttng_list_interrupts(session
);
606 ret
= lttng_enumerate_network_ip_interface(session
);
609 ret
= lttng_enumerate_block_devices(session
);
614 printk(KERN_WARNING
"LTTng: block device enumeration is not supported by kernel\n");
620 /* TODO lttng_dump_idt_table(session); */
621 /* TODO lttng_dump_softirq_vec(session); */
622 /* TODO lttng_list_modules(session); */
623 /* TODO lttng_dump_swap_files(session); */
626 * Fire off a work queue on each CPU. Their sole purpose in life
627 * is to guarantee that each CPU has been in a state where is was in
628 * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
631 atomic_set(&kernel_threads_to_run
, num_online_cpus());
632 for_each_online_cpu(cpu
) {
633 INIT_DELAYED_WORK(&cpu_work
[cpu
], lttng_statedump_work_func
);
634 schedule_delayed_work_on(cpu
, &cpu_work
[cpu
], 0);
636 /* Wait for all threads to run */
637 __wait_event(statedump_wq
, (atomic_read(&kernel_threads_to_run
) == 0));
639 /* Our work is done */
640 trace_lttng_statedump_end(session
);
645 * Called with session mutex held.
647 int lttng_statedump_start(struct lttng_session
*session
)
649 return do_lttng_statedump(session
);
651 EXPORT_SYMBOL_GPL(lttng_statedump_start
);
654 int __init
lttng_statedump_init(void)
657 * Allow module to load even if the fixup cannot be done. This
658 * will allow seemless transition when the underlying issue fix
659 * is merged into the Linux kernel, and when tracepoint.c
660 * "tracepoint_module_notify" is turned into a static function.
662 (void) wrapper_lttng_fixup_sig(THIS_MODULE
);
666 module_init(lttng_statedump_init
);
669 void __exit
lttng_statedump_exit(void)
673 module_exit(lttng_statedump_exit
);
675 MODULE_LICENSE("GPL and additional rights");
676 MODULE_AUTHOR("Jean-Hugues Deschenes");
677 MODULE_DESCRIPTION("LTTng statedump provider");
678 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
679 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
680 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
681 LTTNG_MODULES_EXTRAVERSION
);