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>
49 #include "lttng-events.h"
50 #include "wrapper/irqdesc.h"
51 #include "wrapper/spinlock.h"
52 #include "wrapper/fdtable.h"
54 #ifdef CONFIG_GENERIC_HARDIRQS
55 #include <linux/irq.h>
58 /* Define the tracepoints, but do not build the probes */
59 #define CREATE_TRACE_POINTS
60 #define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
61 #define TRACE_INCLUDE_FILE lttng-statedump
62 #include "instrumentation/events/lttng-module/lttng-statedump.h"
66 struct lttng_session
*session
;
67 struct task_struct
*p
;
71 * Protected by the trace lock.
73 static struct delayed_work cpu_work
[NR_CPUS
];
74 static DECLARE_WAIT_QUEUE_HEAD(statedump_wq
);
75 static atomic_t kernel_threads_to_run
;
77 enum lttng_thread_type
{
78 LTTNG_USER_THREAD
= 0,
79 LTTNG_KERNEL_THREAD
= 1,
82 enum lttng_execution_mode
{
88 LTTNG_MODE_UNKNOWN
= 5,
91 enum lttng_execution_submode
{
96 enum lttng_process_status
{
109 void lttng_enumerate_device(struct lttng_session
*session
,
110 struct net_device
*dev
)
112 struct in_device
*in_dev
;
113 struct in_ifaddr
*ifa
;
115 if (dev
->flags
& IFF_UP
) {
116 in_dev
= in_dev_get(dev
);
118 for (ifa
= in_dev
->ifa_list
; ifa
!= NULL
;
119 ifa
= ifa
->ifa_next
) {
120 trace_lttng_statedump_network_interface(
126 trace_lttng_statedump_network_interface(
132 int lttng_enumerate_network_ip_interface(struct lttng_session
*session
)
134 struct net_device
*dev
;
136 read_lock(&dev_base_lock
);
137 for_each_netdev(&init_net
, dev
)
138 lttng_enumerate_device(session
, dev
);
139 read_unlock(&dev_base_lock
);
143 #else /* CONFIG_INET */
145 int lttng_enumerate_network_ip_interface(struct lttng_session
*session
)
149 #endif /* CONFIG_INET */
152 int lttng_dump_one_fd(const void *p
, struct file
*file
, unsigned int fd
)
154 const struct lttng_fd_ctx
*ctx
= p
;
155 const char *s
= d_path(&file
->f_path
, ctx
->page
, PAGE_SIZE
);
158 struct dentry
*dentry
= file
->f_path
.dentry
;
160 /* Make sure we give at least some info */
161 spin_lock(&dentry
->d_lock
);
162 trace_lttng_statedump_file_descriptor(ctx
->session
, ctx
->p
, fd
,
163 dentry
->d_name
.name
);
164 spin_unlock(&dentry
->d_lock
);
167 trace_lttng_statedump_file_descriptor(ctx
->session
, ctx
->p
, fd
, s
);
173 void lttng_enumerate_task_fd(struct lttng_session
*session
,
174 struct task_struct
*p
, char *tmp
)
176 struct lttng_fd_ctx ctx
= { .page
= tmp
, .session
= session
, .p
= p
};
179 lttng_iterate_fd(p
->files
, 0, lttng_dump_one_fd
, &ctx
);
184 int lttng_enumerate_file_descriptors(struct lttng_session
*session
)
186 struct task_struct
*p
;
187 char *tmp
= (char *) __get_free_page(GFP_KERNEL
);
189 /* Enumerate active file descriptors */
192 lttng_enumerate_task_fd(session
, p
, tmp
);
194 free_page((unsigned long) tmp
);
200 * FIXME: we cannot take a mmap_sem while in a RCU read-side critical section
201 * (scheduling in atomic). Normally, the tasklist lock protects this kind of
202 * iteration, but it is not exported to modules.
205 void lttng_enumerate_task_vm_maps(struct lttng_session
*session
,
206 struct task_struct
*p
)
208 struct mm_struct
*mm
;
209 struct vm_area_struct
*map
;
212 /* get_task_mm does a task_lock... */
219 down_read(&mm
->mmap_sem
);
222 ino
= map
->vm_file
->f_dentry
->d_inode
->i_ino
;
225 trace_lttng_statedump_vm_map(session
, p
, map
, ino
);
228 up_read(&mm
->mmap_sem
);
234 int lttng_enumerate_vm_maps(struct lttng_session
*session
)
236 struct task_struct
*p
;
240 lttng_enumerate_task_vm_maps(session
, p
);
246 #ifdef CONFIG_GENERIC_HARDIRQS
248 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
249 #define irq_desc_get_chip(desc) get_irq_desc_chip(desc)
253 void lttng_list_interrupts(struct lttng_session
*session
)
256 unsigned long flags
= 0;
257 struct irq_desc
*desc
;
259 #define irq_to_desc wrapper_irq_to_desc
261 for_each_irq_desc(irq
, desc
) {
262 struct irqaction
*action
;
263 const char *irq_chip_name
=
264 irq_desc_get_chip(desc
)->name
? : "unnamed_irq_chip";
266 local_irq_save(flags
);
267 wrapper_desc_spin_lock(&desc
->lock
);
268 for (action
= desc
->action
; action
; action
= action
->next
) {
269 trace_lttng_statedump_interrupt(session
,
270 irq
, irq_chip_name
, action
);
272 wrapper_desc_spin_unlock(&desc
->lock
);
273 local_irq_restore(flags
);
279 void list_interrupts(struct lttng_session
*session
)
285 void lttng_statedump_process_ns(struct lttng_session
*session
,
286 struct task_struct
*p
,
287 enum lttng_thread_type type
,
288 enum lttng_execution_mode mode
,
289 enum lttng_execution_submode submode
,
290 enum lttng_process_status status
)
292 struct nsproxy
*proxy
;
293 struct pid_namespace
*pid_ns
;
296 proxy
= task_nsproxy(p
);
298 pid_ns
= proxy
->pid_ns
;
300 trace_lttng_statedump_process_state(session
,
301 p
, type
, mode
, submode
, status
, pid_ns
);
302 pid_ns
= pid_ns
->parent
;
305 trace_lttng_statedump_process_state(session
,
306 p
, type
, mode
, submode
, status
, NULL
);
312 int lttng_enumerate_process_states(struct lttng_session
*session
)
314 struct task_struct
*g
, *p
;
317 for_each_process(g
) {
320 enum lttng_execution_mode mode
=
322 enum lttng_execution_submode submode
=
324 enum lttng_process_status status
;
325 enum lttng_thread_type type
;
328 if (p
->exit_state
== EXIT_ZOMBIE
)
329 status
= LTTNG_ZOMBIE
;
330 else if (p
->exit_state
== EXIT_DEAD
)
332 else if (p
->state
== TASK_RUNNING
) {
333 /* Is this a forked child that has not run yet? */
334 if (list_empty(&p
->rt
.run_list
))
335 status
= LTTNG_WAIT_FORK
;
338 * All tasks are considered as wait_cpu;
339 * the viewer will sort out if the task
340 * was really running at this time.
342 status
= LTTNG_WAIT_CPU
;
343 } else if (p
->state
&
344 (TASK_INTERRUPTIBLE
| TASK_UNINTERRUPTIBLE
)) {
345 /* Task is waiting for something to complete */
348 status
= LTTNG_UNNAMED
;
349 submode
= LTTNG_NONE
;
352 * Verification of t->mm is to filter out kernel
353 * threads; Viewer will further filter out if a
354 * user-space thread was in syscall mode or not.
357 type
= LTTNG_USER_THREAD
;
359 type
= LTTNG_KERNEL_THREAD
;
360 lttng_statedump_process_ns(session
,
361 p
, type
, mode
, submode
, status
);
363 } while_each_thread(g
, p
);
371 void lttng_statedump_work_func(struct work_struct
*work
)
373 if (atomic_dec_and_test(&kernel_threads_to_run
))
374 /* If we are the last thread, wake up do_lttng_statedump */
375 wake_up(&statedump_wq
);
379 int do_lttng_statedump(struct lttng_session
*session
)
383 printk(KERN_DEBUG
"LTT state dump thread start\n");
384 trace_lttng_statedump_start(session
);
385 lttng_enumerate_process_states(session
);
386 lttng_enumerate_file_descriptors(session
);
387 /* FIXME lttng_enumerate_vm_maps(session); */
388 lttng_list_interrupts(session
);
389 lttng_enumerate_network_ip_interface(session
);
391 /* TODO lttng_dump_idt_table(session); */
392 /* TODO lttng_dump_softirq_vec(session); */
393 /* TODO lttng_list_modules(session); */
394 /* TODO lttng_dump_swap_files(session); */
397 * Fire off a work queue on each CPU. Their sole purpose in life
398 * is to guarantee that each CPU has been in a state where is was in
399 * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
402 atomic_set(&kernel_threads_to_run
, num_online_cpus());
403 for_each_online_cpu(cpu
) {
404 INIT_DELAYED_WORK(&cpu_work
[cpu
], lttng_statedump_work_func
);
405 schedule_delayed_work_on(cpu
, &cpu_work
[cpu
], 0);
407 /* Wait for all threads to run */
408 __wait_event(statedump_wq
, (atomic_read(&kernel_threads_to_run
) == 0));
410 /* Our work is done */
411 printk(KERN_DEBUG
"LTT state dump end\n");
412 trace_lttng_statedump_end(session
);
417 * Called with session mutex held.
419 int lttng_statedump_start(struct lttng_session
*session
)
421 printk(KERN_DEBUG
"LTTng: state dump begin\n");
422 return do_lttng_statedump(session
);
424 EXPORT_SYMBOL_GPL(lttng_statedump_start
);
426 MODULE_LICENSE("GPL and additional rights");
427 MODULE_AUTHOR("Jean-Hugues Deschenes");
428 MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Statedump");