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"
53 #include "wrapper/nsproxy.h"
54 #include "wrapper/irq.h"
56 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
57 #include <linux/irq.h>
60 /* Define the tracepoints, but do not build the probes */
61 #define CREATE_TRACE_POINTS
62 #define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
63 #define TRACE_INCLUDE_FILE lttng-statedump
64 #include "instrumentation/events/lttng-module/lttng-statedump.h"
68 struct lttng_session *session;
69 struct task_struct *p;
73 * Protected by the trace lock.
75 static struct delayed_work cpu_work[NR_CPUS];
76 static DECLARE_WAIT_QUEUE_HEAD(statedump_wq);
77 static atomic_t kernel_threads_to_run;
79 enum lttng_thread_type {
80 LTTNG_USER_THREAD = 0,
81 LTTNG_KERNEL_THREAD = 1,
84 enum lttng_execution_mode {
90 LTTNG_MODE_UNKNOWN = 5,
93 enum lttng_execution_submode {
98 enum lttng_process_status {
111 void lttng_enumerate_device(struct lttng_session *session,
112 struct net_device *dev)
114 struct in_device *in_dev;
115 struct in_ifaddr *ifa;
117 if (dev->flags & IFF_UP) {
118 in_dev = in_dev_get(dev);
120 for (ifa = in_dev->ifa_list; ifa != NULL;
121 ifa = ifa->ifa_next) {
122 trace_lttng_statedump_network_interface(
128 trace_lttng_statedump_network_interface(
134 int lttng_enumerate_network_ip_interface(struct lttng_session *session)
136 struct net_device *dev;
138 read_lock(&dev_base_lock);
139 for_each_netdev(&init_net, dev)
140 lttng_enumerate_device(session, dev);
141 read_unlock(&dev_base_lock);
145 #else /* CONFIG_INET */
147 int lttng_enumerate_network_ip_interface(struct lttng_session *session)
151 #endif /* CONFIG_INET */
154 int lttng_dump_one_fd(const void *p, struct file *file, unsigned int fd)
156 const struct lttng_fd_ctx *ctx = p;
157 const char *s = d_path(&file->f_path, ctx->page, PAGE_SIZE);
160 struct dentry *dentry = file->f_path.dentry;
162 /* Make sure we give at least some info */
163 spin_lock(&dentry->d_lock);
164 trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd,
165 dentry->d_name.name);
166 spin_unlock(&dentry->d_lock);
169 trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd, s);
175 void lttng_enumerate_task_fd(struct lttng_session *session,
176 struct task_struct *p, char *tmp)
178 struct lttng_fd_ctx ctx = { .page = tmp, .session = session, .p = p };
181 lttng_iterate_fd(p->files, 0, lttng_dump_one_fd, &ctx);
186 int lttng_enumerate_file_descriptors(struct lttng_session *session)
188 struct task_struct *p;
189 char *tmp = (char *) __get_free_page(GFP_KERNEL);
191 /* Enumerate active file descriptors */
194 lttng_enumerate_task_fd(session, p, tmp);
196 free_page((unsigned long) tmp);
202 * FIXME: we cannot take a mmap_sem while in a RCU read-side critical section
203 * (scheduling in atomic). Normally, the tasklist lock protects this kind of
204 * iteration, but it is not exported to modules.
207 void lttng_enumerate_task_vm_maps(struct lttng_session *session,
208 struct task_struct *p)
210 struct mm_struct *mm;
211 struct vm_area_struct *map;
214 /* get_task_mm does a task_lock... */
221 down_read(&mm->mmap_sem);
224 ino = map->vm_file->f_dentry->d_inode->i_ino;
227 trace_lttng_statedump_vm_map(session, p, map, ino);
230 up_read(&mm->mmap_sem);
236 int lttng_enumerate_vm_maps(struct lttng_session *session)
238 struct task_struct *p;
242 lttng_enumerate_task_vm_maps(session, p);
248 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
250 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
251 #define irq_desc_get_chip(desc) get_irq_desc_chip(desc)
255 void lttng_list_interrupts(struct lttng_session *session)
258 unsigned long flags = 0;
259 struct irq_desc *desc;
261 #define irq_to_desc wrapper_irq_to_desc
263 for_each_irq_desc(irq, desc) {
264 struct irqaction *action;
265 const char *irq_chip_name =
266 irq_desc_get_chip(desc)->name ? : "unnamed_irq_chip";
268 local_irq_save(flags);
269 wrapper_desc_spin_lock(&desc->lock);
270 for (action = desc->action; action; action = action->next) {
271 trace_lttng_statedump_interrupt(session,
272 irq, irq_chip_name, action);
274 wrapper_desc_spin_unlock(&desc->lock);
275 local_irq_restore(flags);
281 void lttng_list_interrupts(struct lttng_session *session)
287 void lttng_statedump_process_ns(struct lttng_session *session,
288 struct task_struct *p,
289 enum lttng_thread_type type,
290 enum lttng_execution_mode mode,
291 enum lttng_execution_submode submode,
292 enum lttng_process_status status)
294 struct nsproxy *proxy;
295 struct pid_namespace *pid_ns;
298 proxy = task_nsproxy(p);
300 pid_ns = lttng_get_proxy_pid_ns(proxy);
302 trace_lttng_statedump_process_state(session,
303 p, type, mode, submode, status, pid_ns);
304 pid_ns = pid_ns->parent;
307 trace_lttng_statedump_process_state(session,
308 p, type, mode, submode, status, NULL);
314 int lttng_enumerate_process_states(struct lttng_session *session)
316 struct task_struct *g, *p;
319 for_each_process(g) {
322 enum lttng_execution_mode mode =
324 enum lttng_execution_submode submode =
326 enum lttng_process_status status;
327 enum lttng_thread_type type;
330 if (p->exit_state == EXIT_ZOMBIE)
331 status = LTTNG_ZOMBIE;
332 else if (p->exit_state == EXIT_DEAD)
334 else if (p->state == TASK_RUNNING) {
335 /* Is this a forked child that has not run yet? */
336 if (list_empty(&p->rt.run_list))
337 status = LTTNG_WAIT_FORK;
340 * All tasks are considered as wait_cpu;
341 * the viewer will sort out if the task
342 * was really running at this time.
344 status = LTTNG_WAIT_CPU;
345 } else if (p->state &
346 (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)) {
347 /* Task is waiting for something to complete */
350 status = LTTNG_UNNAMED;
351 submode = LTTNG_NONE;
354 * Verification of t->mm is to filter out kernel
355 * threads; Viewer will further filter out if a
356 * user-space thread was in syscall mode or not.
359 type = LTTNG_USER_THREAD;
361 type = LTTNG_KERNEL_THREAD;
362 lttng_statedump_process_ns(session,
363 p, type, mode, submode, status);
365 } while_each_thread(g, p);
373 void lttng_statedump_work_func(struct work_struct *work)
375 if (atomic_dec_and_test(&kernel_threads_to_run))
376 /* If we are the last thread, wake up do_lttng_statedump */
377 wake_up(&statedump_wq);
381 int do_lttng_statedump(struct lttng_session *session)
385 trace_lttng_statedump_start(session);
386 lttng_enumerate_process_states(session);
387 lttng_enumerate_file_descriptors(session);
388 /* FIXME lttng_enumerate_vm_maps(session); */
389 lttng_list_interrupts(session);
390 lttng_enumerate_network_ip_interface(session);
392 /* TODO lttng_dump_idt_table(session); */
393 /* TODO lttng_dump_softirq_vec(session); */
394 /* TODO lttng_list_modules(session); */
395 /* TODO lttng_dump_swap_files(session); */
398 * Fire off a work queue on each CPU. Their sole purpose in life
399 * is to guarantee that each CPU has been in a state where is was in
400 * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
403 atomic_set(&kernel_threads_to_run, num_online_cpus());
404 for_each_online_cpu(cpu) {
405 INIT_DELAYED_WORK(&cpu_work[cpu], lttng_statedump_work_func);
406 schedule_delayed_work_on(cpu, &cpu_work[cpu], 0);
408 /* Wait for all threads to run */
409 __wait_event(statedump_wq, (atomic_read(&kernel_threads_to_run) == 0));
411 /* Our work is done */
412 trace_lttng_statedump_end(session);
417 * Called with session mutex held.
419 int lttng_statedump_start(struct lttng_session *session)
421 return do_lttng_statedump(session);
423 EXPORT_SYMBOL_GPL(lttng_statedump_start);
425 MODULE_LICENSE("GPL and additional rights");
426 MODULE_AUTHOR("Jean-Hugues Deschenes");
427 MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Statedump");