4 * Linux Trace Toolkit Next Generation Kernel State Dump
6 * Copyright 2005 Jean-Hugues Deschenes <jean-hugues.deschenes@polymtl.ca>
7 * Copyright 2006-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; only
12 * version 2.1 of the License.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * Eric Clement: Add listing of network IP interface
25 * 2006, 2007 Mathieu Desnoyers Fix kernel threads
29 #include <linux/init.h>
30 #include <linux/module.h>
31 #include <linux/netlink.h>
32 #include <linux/inet.h>
34 #include <linux/kthread.h>
35 #include <linux/proc_fs.h>
36 #include <linux/file.h>
37 #include <linux/interrupt.h>
38 #include <linux/irqnr.h>
39 #include <linux/cpu.h>
40 #include <linux/netdevice.h>
41 #include <linux/inetdevice.h>
42 #include <linux/sched.h>
44 #include <linux/fdtable.h>
45 #include <linux/swap.h>
46 #include <linux/wait.h>
47 #include <linux/mutex.h>
48 #include <linux/device.h>
50 #include "lttng-events.h"
51 #include "lttng-tracer.h"
52 #include "wrapper/irqdesc.h"
53 #include "wrapper/spinlock.h"
54 #include "wrapper/fdtable.h"
55 #include "wrapper/nsproxy.h"
56 #include "wrapper/irq.h"
57 #include "wrapper/tracepoint.h"
58 #include "wrapper/genhd.h"
59 #include "wrapper/file.h"
61 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
62 #include <linux/irq.h>
65 /* Define the tracepoints, but do not build the probes */
66 #define CREATE_TRACE_POINTS
67 #define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
68 #define TRACE_INCLUDE_FILE lttng-statedump
69 #define LTTNG_INSTRUMENTATION
70 #include "instrumentation/events/lttng-module/lttng-statedump.h"
72 DEFINE_TRACE(lttng_statedump_block_device
);
73 DEFINE_TRACE(lttng_statedump_end
);
74 DEFINE_TRACE(lttng_statedump_interrupt
);
75 DEFINE_TRACE(lttng_statedump_file_descriptor
);
76 DEFINE_TRACE(lttng_statedump_start
);
77 DEFINE_TRACE(lttng_statedump_process_state
);
78 DEFINE_TRACE(lttng_statedump_network_interface
);
82 struct lttng_session
*session
;
83 struct task_struct
*p
;
84 struct files_struct
*files
;
88 * Protected by the trace lock.
90 static struct delayed_work cpu_work
[NR_CPUS
];
91 static DECLARE_WAIT_QUEUE_HEAD(statedump_wq
);
92 static atomic_t kernel_threads_to_run
;
94 enum lttng_thread_type
{
95 LTTNG_USER_THREAD
= 0,
96 LTTNG_KERNEL_THREAD
= 1,
99 enum lttng_execution_mode
{
105 LTTNG_MODE_UNKNOWN
= 5,
108 enum lttng_execution_submode
{
113 enum lttng_process_status
{
125 int lttng_enumerate_block_devices(struct lttng_session
*session
)
127 struct class *ptr_block_class
;
128 struct device_type
*ptr_disk_type
;
129 struct class_dev_iter iter
;
132 ptr_block_class
= wrapper_get_block_class();
133 if (!ptr_block_class
)
135 ptr_disk_type
= wrapper_get_disk_type();
136 if (!ptr_disk_type
) {
139 class_dev_iter_init(&iter
, ptr_block_class
, NULL
, ptr_disk_type
);
140 while ((dev
= class_dev_iter_next(&iter
))) {
141 struct disk_part_iter piter
;
142 struct gendisk
*disk
= dev_to_disk(dev
);
143 struct hd_struct
*part
;
146 * Don't show empty devices or things that have been
149 if (get_capacity(disk
) == 0 ||
150 (disk
->flags
& GENHD_FL_SUPPRESS_PARTITION_INFO
))
153 disk_part_iter_init(&piter
, disk
, DISK_PITER_INCL_PART0
);
154 while ((part
= disk_part_iter_next(&piter
))) {
155 char name_buf
[BDEVNAME_SIZE
];
158 p
= wrapper_disk_name(disk
, part
->partno
, name_buf
);
160 disk_part_iter_exit(&piter
);
161 class_dev_iter_exit(&iter
);
164 trace_lttng_statedump_block_device(session
,
165 part_devt(part
), name_buf
);
167 disk_part_iter_exit(&piter
);
169 class_dev_iter_exit(&iter
);
176 void lttng_enumerate_device(struct lttng_session
*session
,
177 struct net_device
*dev
)
179 struct in_device
*in_dev
;
180 struct in_ifaddr
*ifa
;
182 if (dev
->flags
& IFF_UP
) {
183 in_dev
= in_dev_get(dev
);
185 for (ifa
= in_dev
->ifa_list
; ifa
!= NULL
;
186 ifa
= ifa
->ifa_next
) {
187 trace_lttng_statedump_network_interface(
193 trace_lttng_statedump_network_interface(
199 int lttng_enumerate_network_ip_interface(struct lttng_session
*session
)
201 struct net_device
*dev
;
203 read_lock(&dev_base_lock
);
204 for_each_netdev(&init_net
, dev
)
205 lttng_enumerate_device(session
, dev
);
206 read_unlock(&dev_base_lock
);
210 #else /* CONFIG_INET */
212 int lttng_enumerate_network_ip_interface(struct lttng_session
*session
)
216 #endif /* CONFIG_INET */
218 #ifdef FD_ISSET /* For old kernels lacking close_on_exec() */
219 static inline bool lttng_close_on_exec(int fd
, const struct fdtable
*fdt
)
221 return FD_ISSET(fd
, fdt
->close_on_exec
);
224 static inline bool lttng_close_on_exec(int fd
, const struct fdtable
*fdt
)
226 return close_on_exec(fd
, fdt
);
231 int lttng_dump_one_fd(const void *p
, struct file
*file
, unsigned int fd
)
233 const struct lttng_fd_ctx
*ctx
= p
;
234 const char *s
= d_path(&file
->f_path
, ctx
->page
, PAGE_SIZE
);
235 unsigned int flags
= file
->f_flags
;
239 * We don't expose kernel internal flags, only userspace-visible
242 flags
&= ~FMODE_NONOTIFY
;
243 fdt
= files_fdtable(ctx
->files
);
245 * We need to check here again whether fd is within the fdt
246 * max_fds range, because we might be seeing a different
247 * files_fdtable() than iterate_fd(), assuming only RCU is
248 * protecting the read. In reality, iterate_fd() holds
249 * file_lock, which should ensure the fdt does not change while
250 * the lock is taken, but we are not aware whether this is
251 * guaranteed or not, so play safe.
253 if (fd
< fdt
->max_fds
&& lttng_close_on_exec(fd
, fdt
))
256 struct dentry
*dentry
= file
->f_path
.dentry
;
258 /* Make sure we give at least some info */
259 spin_lock(&dentry
->d_lock
);
260 trace_lttng_statedump_file_descriptor(ctx
->session
, ctx
->p
, fd
,
261 dentry
->d_name
.name
, flags
, file
->f_mode
);
262 spin_unlock(&dentry
->d_lock
);
265 trace_lttng_statedump_file_descriptor(ctx
->session
, ctx
->p
, fd
, s
,
266 flags
, file
->f_mode
);
272 void lttng_enumerate_task_fd(struct lttng_session
*session
,
273 struct task_struct
*p
, char *tmp
)
275 struct lttng_fd_ctx ctx
= { .page
= tmp
, .session
= session
, .p
= p
};
276 struct files_struct
*files
;
283 lttng_iterate_fd(files
, 0, lttng_dump_one_fd
, &ctx
);
289 int lttng_enumerate_file_descriptors(struct lttng_session
*session
)
291 struct task_struct
*p
;
294 tmp
= (char *) __get_free_page(GFP_KERNEL
);
298 /* Enumerate active file descriptors */
301 lttng_enumerate_task_fd(session
, p
, tmp
);
303 free_page((unsigned long) tmp
);
309 * FIXME: we cannot take a mmap_sem while in a RCU read-side critical section
310 * (scheduling in atomic). Normally, the tasklist lock protects this kind of
311 * iteration, but it is not exported to modules.
314 void lttng_enumerate_task_vm_maps(struct lttng_session
*session
,
315 struct task_struct
*p
)
317 struct mm_struct
*mm
;
318 struct vm_area_struct
*map
;
321 /* get_task_mm does a task_lock... */
328 down_read(&mm
->mmap_sem
);
331 ino
= map
->vm_file
->lttng_f_dentry
->d_inode
->i_ino
;
334 trace_lttng_statedump_vm_map(session
, p
, map
, ino
);
337 up_read(&mm
->mmap_sem
);
343 int lttng_enumerate_vm_maps(struct lttng_session
*session
)
345 struct task_struct
*p
;
349 lttng_enumerate_task_vm_maps(session
, p
);
355 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
357 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
358 #define irq_desc_get_chip(desc) get_irq_desc_chip(desc)
362 int lttng_list_interrupts(struct lttng_session
*session
)
365 unsigned long flags
= 0;
366 struct irq_desc
*desc
;
368 #define irq_to_desc wrapper_irq_to_desc
370 for_each_irq_desc(irq
, desc
) {
371 struct irqaction
*action
;
372 const char *irq_chip_name
=
373 irq_desc_get_chip(desc
)->name
? : "unnamed_irq_chip";
375 local_irq_save(flags
);
376 wrapper_desc_spin_lock(&desc
->lock
);
377 for (action
= desc
->action
; action
; action
= action
->next
) {
378 trace_lttng_statedump_interrupt(session
,
379 irq
, irq_chip_name
, action
);
381 wrapper_desc_spin_unlock(&desc
->lock
);
382 local_irq_restore(flags
);
389 int lttng_list_interrupts(struct lttng_session
*session
)
396 * Called with task lock held.
399 void lttng_statedump_process_ns(struct lttng_session
*session
,
400 struct task_struct
*p
,
401 enum lttng_thread_type type
,
402 enum lttng_execution_mode mode
,
403 enum lttng_execution_submode submode
,
404 enum lttng_process_status status
)
406 struct nsproxy
*proxy
;
407 struct pid_namespace
*pid_ns
;
410 * Back and forth on locking strategy within Linux upstream for nsproxy.
411 * See Linux upstream commit 728dba3a39c66b3d8ac889ddbe38b5b1c264aec3
412 * "namespaces: Use task_lock and not rcu to protect nsproxy"
415 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0) || \
416 LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0) || \
417 LTTNG_UBUNTU_KERNEL_RANGE(3,16,0,11, 3,17,0,0))
421 proxy
= task_nsproxy(p
);
424 pid_ns
= lttng_get_proxy_pid_ns(proxy
);
426 trace_lttng_statedump_process_state(session
,
427 p
, type
, mode
, submode
, status
, pid_ns
);
428 pid_ns
= pid_ns
->parent
;
431 trace_lttng_statedump_process_state(session
,
432 p
, type
, mode
, submode
, status
, NULL
);
434 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0) || \
435 LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0) || \
436 LTTNG_UBUNTU_KERNEL_RANGE(3,16,0,11, 3,17,0,0))
444 int lttng_enumerate_process_states(struct lttng_session
*session
)
446 struct task_struct
*g
, *p
;
449 for_each_process(g
) {
452 enum lttng_execution_mode mode
=
454 enum lttng_execution_submode submode
=
456 enum lttng_process_status status
;
457 enum lttng_thread_type type
;
460 if (p
->exit_state
== EXIT_ZOMBIE
)
461 status
= LTTNG_ZOMBIE
;
462 else if (p
->exit_state
== EXIT_DEAD
)
464 else if (p
->state
== TASK_RUNNING
) {
465 /* Is this a forked child that has not run yet? */
466 if (list_empty(&p
->rt
.run_list
))
467 status
= LTTNG_WAIT_FORK
;
470 * All tasks are considered as wait_cpu;
471 * the viewer will sort out if the task
472 * was really running at this time.
474 status
= LTTNG_WAIT_CPU
;
475 } else if (p
->state
&
476 (TASK_INTERRUPTIBLE
| TASK_UNINTERRUPTIBLE
)) {
477 /* Task is waiting for something to complete */
480 status
= LTTNG_UNNAMED
;
481 submode
= LTTNG_NONE
;
484 * Verification of t->mm is to filter out kernel
485 * threads; Viewer will further filter out if a
486 * user-space thread was in syscall mode or not.
489 type
= LTTNG_USER_THREAD
;
491 type
= LTTNG_KERNEL_THREAD
;
492 lttng_statedump_process_ns(session
,
493 p
, type
, mode
, submode
, status
);
495 } while_each_thread(g
, p
);
503 void lttng_statedump_work_func(struct work_struct
*work
)
505 if (atomic_dec_and_test(&kernel_threads_to_run
))
506 /* If we are the last thread, wake up do_lttng_statedump */
507 wake_up(&statedump_wq
);
511 int do_lttng_statedump(struct lttng_session
*session
)
515 trace_lttng_statedump_start(session
);
516 ret
= lttng_enumerate_process_states(session
);
519 ret
= lttng_enumerate_file_descriptors(session
);
524 * ret = lttng_enumerate_vm_maps(session);
528 ret
= lttng_list_interrupts(session
);
531 ret
= lttng_enumerate_network_ip_interface(session
);
534 ret
= lttng_enumerate_block_devices(session
);
537 printk(KERN_WARNING
"LTTng: block device enumeration is not supported by kernel\n");
543 /* TODO lttng_dump_idt_table(session); */
544 /* TODO lttng_dump_softirq_vec(session); */
545 /* TODO lttng_list_modules(session); */
546 /* TODO lttng_dump_swap_files(session); */
549 * Fire off a work queue on each CPU. Their sole purpose in life
550 * is to guarantee that each CPU has been in a state where is was in
551 * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
554 atomic_set(&kernel_threads_to_run
, num_online_cpus());
555 for_each_online_cpu(cpu
) {
556 INIT_DELAYED_WORK(&cpu_work
[cpu
], lttng_statedump_work_func
);
557 schedule_delayed_work_on(cpu
, &cpu_work
[cpu
], 0);
559 /* Wait for all threads to run */
560 __wait_event(statedump_wq
, (atomic_read(&kernel_threads_to_run
) == 0));
562 /* Our work is done */
563 trace_lttng_statedump_end(session
);
568 * Called with session mutex held.
570 int lttng_statedump_start(struct lttng_session
*session
)
572 return do_lttng_statedump(session
);
574 EXPORT_SYMBOL_GPL(lttng_statedump_start
);
577 int __init
lttng_statedump_init(void)
580 * Allow module to load even if the fixup cannot be done. This
581 * will allow seemless transition when the underlying issue fix
582 * is merged into the Linux kernel, and when tracepoint.c
583 * "tracepoint_module_notify" is turned into a static function.
585 (void) wrapper_lttng_fixup_sig(THIS_MODULE
);
589 module_init(lttng_statedump_init
);
592 void __exit
lttng_statedump_exit(void)
596 module_exit(lttng_statedump_exit
);
598 MODULE_LICENSE("GPL and additional rights");
599 MODULE_AUTHOR("Jean-Hugues Deschenes");
600 MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Statedump");
601 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION
) "."
602 __stringify(LTTNG_MODULES_MINOR_VERSION
) "."
603 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION
)
604 LTTNG_MODULES_EXTRAVERSION
);