Fix: pid tracker should track "pgid"
[deliverable/lttng-modules.git] / lttng-statedump-impl.c
1 /*
2 * lttng-statedump.c
3 *
4 * Linux Trace Toolkit Next Generation Kernel State Dump
5 *
6 * Copyright 2005 Jean-Hugues Deschenes <jean-hugues.deschenes@polymtl.ca>
7 * Copyright 2006-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 *
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.
13 *
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.
18 *
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
22 *
23 * Changes:
24 * Eric Clement: Add listing of network IP interface
25 * 2006, 2007 Mathieu Desnoyers Fix kernel threads
26 * Various updates
27 */
28
29 #include <linux/init.h>
30 #include <linux/module.h>
31 #include <linux/netlink.h>
32 #include <linux/inet.h>
33 #include <linux/ip.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>
43 #include <linux/mm.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>
49
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>
60 #include <wrapper/time.h>
61
62 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
63 #include <linux/irq.h>
64 #endif
65
66 /* Define the tracepoints, but do not build the probes */
67 #define CREATE_TRACE_POINTS
68 #define TRACE_INCLUDE_PATH instrumentation/events/lttng-module
69 #define TRACE_INCLUDE_FILE lttng-statedump
70 #define LTTNG_INSTRUMENTATION
71 #include <instrumentation/events/lttng-module/lttng-statedump.h>
72
73 DEFINE_TRACE(lttng_statedump_block_device);
74 DEFINE_TRACE(lttng_statedump_end);
75 DEFINE_TRACE(lttng_statedump_interrupt);
76 DEFINE_TRACE(lttng_statedump_file_descriptor);
77 DEFINE_TRACE(lttng_statedump_start);
78 DEFINE_TRACE(lttng_statedump_process_state);
79 DEFINE_TRACE(lttng_statedump_network_interface);
80
81 struct lttng_fd_ctx {
82 char *page;
83 struct lttng_session *session;
84 struct task_struct *p;
85 struct files_struct *files;
86 };
87
88 /*
89 * Protected by the trace lock.
90 */
91 static struct delayed_work cpu_work[NR_CPUS];
92 static DECLARE_WAIT_QUEUE_HEAD(statedump_wq);
93 static atomic_t kernel_threads_to_run;
94
95 enum lttng_thread_type {
96 LTTNG_USER_THREAD = 0,
97 LTTNG_KERNEL_THREAD = 1,
98 };
99
100 enum lttng_execution_mode {
101 LTTNG_USER_MODE = 0,
102 LTTNG_SYSCALL = 1,
103 LTTNG_TRAP = 2,
104 LTTNG_IRQ = 3,
105 LTTNG_SOFTIRQ = 4,
106 LTTNG_MODE_UNKNOWN = 5,
107 };
108
109 enum lttng_execution_submode {
110 LTTNG_NONE = 0,
111 LTTNG_UNKNOWN = 1,
112 };
113
114 enum lttng_process_status {
115 LTTNG_UNNAMED = 0,
116 LTTNG_WAIT_FORK = 1,
117 LTTNG_WAIT_CPU = 2,
118 LTTNG_EXIT = 3,
119 LTTNG_ZOMBIE = 4,
120 LTTNG_WAIT = 5,
121 LTTNG_RUN = 6,
122 LTTNG_DEAD = 7,
123 };
124
125 static
126 int lttng_enumerate_block_devices(struct lttng_session *session)
127 {
128 struct class *ptr_block_class;
129 struct device_type *ptr_disk_type;
130 struct class_dev_iter iter;
131 struct device *dev;
132
133 ptr_block_class = wrapper_get_block_class();
134 if (!ptr_block_class)
135 return -ENOSYS;
136 ptr_disk_type = wrapper_get_disk_type();
137 if (!ptr_disk_type) {
138 return -ENOSYS;
139 }
140 class_dev_iter_init(&iter, ptr_block_class, NULL, ptr_disk_type);
141 while ((dev = class_dev_iter_next(&iter))) {
142 struct disk_part_iter piter;
143 struct gendisk *disk = dev_to_disk(dev);
144 struct hd_struct *part;
145
146 /*
147 * Don't show empty devices or things that have been
148 * suppressed
149 */
150 if (get_capacity(disk) == 0 ||
151 (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
152 continue;
153
154 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
155 while ((part = disk_part_iter_next(&piter))) {
156 char name_buf[BDEVNAME_SIZE];
157 char *p;
158
159 p = wrapper_disk_name(disk, part->partno, name_buf);
160 if (!p) {
161 disk_part_iter_exit(&piter);
162 class_dev_iter_exit(&iter);
163 return -ENOSYS;
164 }
165 trace_lttng_statedump_block_device(session,
166 part_devt(part), name_buf);
167 }
168 disk_part_iter_exit(&piter);
169 }
170 class_dev_iter_exit(&iter);
171 return 0;
172 }
173
174 #ifdef CONFIG_INET
175
176 static
177 void lttng_enumerate_device(struct lttng_session *session,
178 struct net_device *dev)
179 {
180 struct in_device *in_dev;
181 struct in_ifaddr *ifa;
182
183 if (dev->flags & IFF_UP) {
184 in_dev = in_dev_get(dev);
185 if (in_dev) {
186 for (ifa = in_dev->ifa_list; ifa != NULL;
187 ifa = ifa->ifa_next) {
188 trace_lttng_statedump_network_interface(
189 session, dev, ifa);
190 }
191 in_dev_put(in_dev);
192 }
193 } else {
194 trace_lttng_statedump_network_interface(
195 session, dev, NULL);
196 }
197 }
198
199 static
200 int lttng_enumerate_network_ip_interface(struct lttng_session *session)
201 {
202 struct net_device *dev;
203
204 read_lock(&dev_base_lock);
205 for_each_netdev(&init_net, dev)
206 lttng_enumerate_device(session, dev);
207 read_unlock(&dev_base_lock);
208
209 return 0;
210 }
211 #else /* CONFIG_INET */
212 static inline
213 int lttng_enumerate_network_ip_interface(struct lttng_session *session)
214 {
215 return 0;
216 }
217 #endif /* CONFIG_INET */
218
219 static
220 int lttng_dump_one_fd(const void *p, struct file *file, unsigned int fd)
221 {
222 const struct lttng_fd_ctx *ctx = p;
223 const char *s = d_path(&file->f_path, ctx->page, PAGE_SIZE);
224 unsigned int flags = file->f_flags;
225 struct fdtable *fdt;
226
227 /*
228 * We don't expose kernel internal flags, only userspace-visible
229 * flags.
230 */
231 flags &= ~FMODE_NONOTIFY;
232 fdt = files_fdtable(ctx->files);
233 /*
234 * We need to check here again whether fd is within the fdt
235 * max_fds range, because we might be seeing a different
236 * files_fdtable() than iterate_fd(), assuming only RCU is
237 * protecting the read. In reality, iterate_fd() holds
238 * file_lock, which should ensure the fdt does not change while
239 * the lock is taken, but we are not aware whether this is
240 * guaranteed or not, so play safe.
241 */
242 if (fd < fdt->max_fds && lttng_close_on_exec(fd, fdt))
243 flags |= O_CLOEXEC;
244 if (IS_ERR(s)) {
245 struct dentry *dentry = file->f_path.dentry;
246
247 /* Make sure we give at least some info */
248 spin_lock(&dentry->d_lock);
249 trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd,
250 dentry->d_name.name, flags, file->f_mode);
251 spin_unlock(&dentry->d_lock);
252 goto end;
253 }
254 trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd, s,
255 flags, file->f_mode);
256 end:
257 return 0;
258 }
259
260 static
261 void lttng_enumerate_task_fd(struct lttng_session *session,
262 struct task_struct *p, char *tmp)
263 {
264 struct lttng_fd_ctx ctx = { .page = tmp, .session = session, .p = p };
265 struct files_struct *files;
266
267 task_lock(p);
268 files = p->files;
269 if (!files)
270 goto end;
271 ctx.files = files;
272 lttng_iterate_fd(files, 0, lttng_dump_one_fd, &ctx);
273 end:
274 task_unlock(p);
275 }
276
277 static
278 int lttng_enumerate_file_descriptors(struct lttng_session *session)
279 {
280 struct task_struct *p;
281 char *tmp;
282
283 tmp = (char *) __get_free_page(GFP_KERNEL);
284 if (!tmp)
285 return -ENOMEM;
286
287 /* Enumerate active file descriptors */
288 rcu_read_lock();
289 for_each_process(p)
290 lttng_enumerate_task_fd(session, p, tmp);
291 rcu_read_unlock();
292 free_page((unsigned long) tmp);
293 return 0;
294 }
295
296 #if 0
297 /*
298 * FIXME: we cannot take a mmap_sem while in a RCU read-side critical section
299 * (scheduling in atomic). Normally, the tasklist lock protects this kind of
300 * iteration, but it is not exported to modules.
301 */
302 static
303 void lttng_enumerate_task_vm_maps(struct lttng_session *session,
304 struct task_struct *p)
305 {
306 struct mm_struct *mm;
307 struct vm_area_struct *map;
308 unsigned long ino;
309
310 /* get_task_mm does a task_lock... */
311 mm = get_task_mm(p);
312 if (!mm)
313 return;
314
315 map = mm->mmap;
316 if (map) {
317 down_read(&mm->mmap_sem);
318 while (map) {
319 if (map->vm_file)
320 ino = map->vm_file->lttng_f_dentry->d_inode->i_ino;
321 else
322 ino = 0;
323 trace_lttng_statedump_vm_map(session, p, map, ino);
324 map = map->vm_next;
325 }
326 up_read(&mm->mmap_sem);
327 }
328 mmput(mm);
329 }
330
331 static
332 int lttng_enumerate_vm_maps(struct lttng_session *session)
333 {
334 struct task_struct *p;
335
336 rcu_read_lock();
337 for_each_process(p)
338 lttng_enumerate_task_vm_maps(session, p);
339 rcu_read_unlock();
340 return 0;
341 }
342 #endif
343
344 #ifdef CONFIG_LTTNG_HAS_LIST_IRQ
345
346 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
347 #define irq_desc_get_chip(desc) get_irq_desc_chip(desc)
348 #endif
349
350 static
351 int lttng_list_interrupts(struct lttng_session *session)
352 {
353 unsigned int irq;
354 unsigned long flags = 0;
355 struct irq_desc *desc;
356
357 #define irq_to_desc wrapper_irq_to_desc
358 /* needs irq_desc */
359 for_each_irq_desc(irq, desc) {
360 struct irqaction *action;
361 const char *irq_chip_name =
362 irq_desc_get_chip(desc)->name ? : "unnamed_irq_chip";
363
364 local_irq_save(flags);
365 wrapper_desc_spin_lock(&desc->lock);
366 for (action = desc->action; action; action = action->next) {
367 trace_lttng_statedump_interrupt(session,
368 irq, irq_chip_name, action);
369 }
370 wrapper_desc_spin_unlock(&desc->lock);
371 local_irq_restore(flags);
372 }
373 return 0;
374 #undef irq_to_desc
375 }
376 #else
377 static inline
378 int lttng_list_interrupts(struct lttng_session *session)
379 {
380 return 0;
381 }
382 #endif
383
384 /*
385 * Called with task lock held.
386 */
387 static
388 void lttng_statedump_process_ns(struct lttng_session *session,
389 struct task_struct *p,
390 enum lttng_thread_type type,
391 enum lttng_execution_mode mode,
392 enum lttng_execution_submode submode,
393 enum lttng_process_status status)
394 {
395 struct nsproxy *proxy;
396 struct pid_namespace *pid_ns;
397
398 /*
399 * Back and forth on locking strategy within Linux upstream for nsproxy.
400 * See Linux upstream commit 728dba3a39c66b3d8ac889ddbe38b5b1c264aec3
401 * "namespaces: Use task_lock and not rcu to protect nsproxy"
402 * for details.
403 */
404 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0) || \
405 LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0) || \
406 LTTNG_UBUNTU_KERNEL_RANGE(3,16,1,11, 3,17,0,0) || \
407 LTTNG_RHEL_KERNEL_RANGE(3,10,0,229,13,0, 3,11,0,0,0,0))
408 proxy = p->nsproxy;
409 #else
410 rcu_read_lock();
411 proxy = task_nsproxy(p);
412 #endif
413 if (proxy) {
414 pid_ns = lttng_get_proxy_pid_ns(proxy);
415 do {
416 trace_lttng_statedump_process_state(session,
417 p, type, mode, submode, status, pid_ns);
418 pid_ns = pid_ns->parent;
419 } while (pid_ns);
420 } else {
421 trace_lttng_statedump_process_state(session,
422 p, type, mode, submode, status, NULL);
423 }
424 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0) || \
425 LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0) || \
426 LTTNG_UBUNTU_KERNEL_RANGE(3,16,1,11, 3,17,0,0) || \
427 LTTNG_RHEL_KERNEL_RANGE(3,10,0,229,13,0, 3,11,0,0,0,0))
428 /* (nothing) */
429 #else
430 rcu_read_unlock();
431 #endif
432 }
433
434 static
435 int lttng_enumerate_process_states(struct lttng_session *session)
436 {
437 struct task_struct *g, *p;
438
439 rcu_read_lock();
440 for_each_process(g) {
441 p = g;
442 do {
443 enum lttng_execution_mode mode =
444 LTTNG_MODE_UNKNOWN;
445 enum lttng_execution_submode submode =
446 LTTNG_UNKNOWN;
447 enum lttng_process_status status;
448 enum lttng_thread_type type;
449
450 task_lock(p);
451 if (p->exit_state == EXIT_ZOMBIE)
452 status = LTTNG_ZOMBIE;
453 else if (p->exit_state == EXIT_DEAD)
454 status = LTTNG_DEAD;
455 else if (p->state == TASK_RUNNING) {
456 /* Is this a forked child that has not run yet? */
457 if (list_empty(&p->rt.run_list))
458 status = LTTNG_WAIT_FORK;
459 else
460 /*
461 * All tasks are considered as wait_cpu;
462 * the viewer will sort out if the task
463 * was really running at this time.
464 */
465 status = LTTNG_WAIT_CPU;
466 } else if (p->state &
467 (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)) {
468 /* Task is waiting for something to complete */
469 status = LTTNG_WAIT;
470 } else
471 status = LTTNG_UNNAMED;
472 submode = LTTNG_NONE;
473
474 /*
475 * Verification of t->mm is to filter out kernel
476 * threads; Viewer will further filter out if a
477 * user-space thread was in syscall mode or not.
478 */
479 if (p->mm)
480 type = LTTNG_USER_THREAD;
481 else
482 type = LTTNG_KERNEL_THREAD;
483 lttng_statedump_process_ns(session,
484 p, type, mode, submode, status);
485 task_unlock(p);
486 } while_each_thread(g, p);
487 }
488 rcu_read_unlock();
489
490 return 0;
491 }
492
493 static
494 void lttng_statedump_work_func(struct work_struct *work)
495 {
496 if (atomic_dec_and_test(&kernel_threads_to_run))
497 /* If we are the last thread, wake up do_lttng_statedump */
498 wake_up(&statedump_wq);
499 }
500
501 static
502 int do_lttng_statedump(struct lttng_session *session)
503 {
504 int cpu, ret;
505
506 trace_lttng_statedump_start(session);
507 ret = lttng_enumerate_process_states(session);
508 if (ret)
509 return ret;
510 ret = lttng_enumerate_file_descriptors(session);
511 if (ret)
512 return ret;
513 /*
514 * FIXME
515 * ret = lttng_enumerate_vm_maps(session);
516 * if (ret)
517 * return ret;
518 */
519 ret = lttng_list_interrupts(session);
520 if (ret)
521 return ret;
522 ret = lttng_enumerate_network_ip_interface(session);
523 if (ret)
524 return ret;
525 ret = lttng_enumerate_block_devices(session);
526 switch (ret) {
527 case 0:
528 break;
529 case -ENOSYS:
530 printk(KERN_WARNING "LTTng: block device enumeration is not supported by kernel\n");
531 break;
532 default:
533 return ret;
534 }
535
536 /* TODO lttng_dump_idt_table(session); */
537 /* TODO lttng_dump_softirq_vec(session); */
538 /* TODO lttng_list_modules(session); */
539 /* TODO lttng_dump_swap_files(session); */
540
541 /*
542 * Fire off a work queue on each CPU. Their sole purpose in life
543 * is to guarantee that each CPU has been in a state where is was in
544 * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
545 */
546 get_online_cpus();
547 atomic_set(&kernel_threads_to_run, num_online_cpus());
548 for_each_online_cpu(cpu) {
549 INIT_DELAYED_WORK(&cpu_work[cpu], lttng_statedump_work_func);
550 schedule_delayed_work_on(cpu, &cpu_work[cpu], 0);
551 }
552 /* Wait for all threads to run */
553 __wait_event(statedump_wq, (atomic_read(&kernel_threads_to_run) == 0));
554 put_online_cpus();
555 /* Our work is done */
556 trace_lttng_statedump_end(session);
557 return 0;
558 }
559
560 /*
561 * Called with session mutex held.
562 */
563 int lttng_statedump_start(struct lttng_session *session)
564 {
565 return do_lttng_statedump(session);
566 }
567 EXPORT_SYMBOL_GPL(lttng_statedump_start);
568
569 static
570 int __init lttng_statedump_init(void)
571 {
572 /*
573 * Allow module to load even if the fixup cannot be done. This
574 * will allow seemless transition when the underlying issue fix
575 * is merged into the Linux kernel, and when tracepoint.c
576 * "tracepoint_module_notify" is turned into a static function.
577 */
578 (void) wrapper_lttng_fixup_sig(THIS_MODULE);
579 return 0;
580 }
581
582 module_init(lttng_statedump_init);
583
584 static
585 void __exit lttng_statedump_exit(void)
586 {
587 }
588
589 module_exit(lttng_statedump_exit);
590
591 MODULE_LICENSE("GPL and additional rights");
592 MODULE_AUTHOR("Jean-Hugues Deschenes");
593 MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Statedump");
594 MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
595 __stringify(LTTNG_MODULES_MINOR_VERSION) "."
596 __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
597 LTTNG_MODULES_EXTRAVERSION);
This page took 0.042697 seconds and 5 git commands to generate.