lttng_statedump_process_state for each PID NS
[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
49 #include "lttng-events.h"
50 #include "wrapper/irqdesc.h"
51
52 #ifdef CONFIG_GENERIC_HARDIRQS
53 #include <linux/irq.h>
54 #endif
55
56 /* Define the tracepoints, but do not build the probes */
57 #define CREATE_TRACE_POINTS
58 #define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
59 #define TRACE_INCLUDE_FILE lttng-statedump
60 #include "instrumentation/events/lttng-module/lttng-statedump.h"
61
62 /*
63 * Protected by the trace lock.
64 */
65 static struct delayed_work cpu_work[NR_CPUS];
66 static DECLARE_WAIT_QUEUE_HEAD(statedump_wq);
67 static atomic_t kernel_threads_to_run;
68
69 enum lttng_thread_type {
70 LTTNG_USER_THREAD = 0,
71 LTTNG_KERNEL_THREAD = 1,
72 };
73
74 enum lttng_execution_mode {
75 LTTNG_USER_MODE = 0,
76 LTTNG_SYSCALL = 1,
77 LTTNG_TRAP = 2,
78 LTTNG_IRQ = 3,
79 LTTNG_SOFTIRQ = 4,
80 LTTNG_MODE_UNKNOWN = 5,
81 };
82
83 enum lttng_execution_submode {
84 LTTNG_NONE = 0,
85 LTTNG_UNKNOWN = 1,
86 };
87
88 enum lttng_process_status {
89 LTTNG_UNNAMED = 0,
90 LTTNG_WAIT_FORK = 1,
91 LTTNG_WAIT_CPU = 2,
92 LTTNG_EXIT = 3,
93 LTTNG_ZOMBIE = 4,
94 LTTNG_WAIT = 5,
95 LTTNG_RUN = 6,
96 LTTNG_DEAD = 7,
97 };
98
99 #ifdef CONFIG_INET
100 static
101 void lttng_enumerate_device(struct lttng_session *session,
102 struct net_device *dev)
103 {
104 struct in_device *in_dev;
105 struct in_ifaddr *ifa;
106
107 if (dev->flags & IFF_UP) {
108 in_dev = in_dev_get(dev);
109 if (in_dev) {
110 for (ifa = in_dev->ifa_list; ifa != NULL;
111 ifa = ifa->ifa_next) {
112 trace_lttng_statedump_network_interface(
113 session, dev, ifa);
114 }
115 in_dev_put(in_dev);
116 }
117 } else {
118 trace_lttng_statedump_network_interface(
119 session, dev, NULL);
120 }
121 }
122
123 static
124 int lttng_enumerate_network_ip_interface(struct lttng_session *session)
125 {
126 struct net_device *dev;
127
128 read_lock(&dev_base_lock);
129 for_each_netdev(&init_net, dev)
130 lttng_enumerate_device(session, dev);
131 read_unlock(&dev_base_lock);
132
133 return 0;
134 }
135 #else /* CONFIG_INET */
136 static inline
137 int lttng_enumerate_network_ip_interface(struct lttng_session *session)
138 {
139 return 0;
140 }
141 #endif /* CONFIG_INET */
142
143
144 static
145 void lttng_enumerate_task_fd(struct lttng_session *session,
146 struct task_struct *p, char *tmp)
147 {
148 struct fdtable *fdt;
149 struct file *filp;
150 unsigned int i;
151 const unsigned char *path;
152
153 task_lock(p);
154 if (!p->files)
155 goto unlock_task;
156 spin_lock(&p->files->file_lock);
157 fdt = files_fdtable(p->files);
158 for (i = 0; i < fdt->max_fds; i++) {
159 filp = fcheck_files(p->files, i);
160 if (!filp)
161 continue;
162 path = d_path(&filp->f_path, tmp, PAGE_SIZE);
163 /* Make sure we give at least some info */
164 trace_lttng_statedump_file_descriptor(session, p, i,
165 IS_ERR(path) ?
166 filp->f_dentry->d_name.name :
167 path);
168 }
169 spin_unlock(&p->files->file_lock);
170 unlock_task:
171 task_unlock(p);
172 }
173
174 static
175 int lttng_enumerate_file_descriptors(struct lttng_session *session)
176 {
177 struct task_struct *p;
178 char *tmp = (char *) __get_free_page(GFP_KERNEL);
179
180 /* Enumerate active file descriptors */
181 rcu_read_lock();
182 for_each_process(p)
183 lttng_enumerate_task_fd(session, p, tmp);
184 rcu_read_unlock();
185 free_page((unsigned long) tmp);
186 return 0;
187 }
188
189 #if 0
190 /*
191 * FIXME: we cannot take a mmap_sem while in a RCU read-side critical section
192 * (scheduling in atomic). Normally, the tasklist lock protects this kind of
193 * iteration, but it is not exported to modules.
194 */
195 static
196 void lttng_enumerate_task_vm_maps(struct lttng_session *session,
197 struct task_struct *p)
198 {
199 struct mm_struct *mm;
200 struct vm_area_struct *map;
201 unsigned long ino;
202
203 /* get_task_mm does a task_lock... */
204 mm = get_task_mm(p);
205 if (!mm)
206 return;
207
208 map = mm->mmap;
209 if (map) {
210 down_read(&mm->mmap_sem);
211 while (map) {
212 if (map->vm_file)
213 ino = map->vm_file->f_dentry->d_inode->i_ino;
214 else
215 ino = 0;
216 trace_lttng_statedump_vm_map(session, p, map, ino);
217 map = map->vm_next;
218 }
219 up_read(&mm->mmap_sem);
220 }
221 mmput(mm);
222 }
223
224 static
225 int lttng_enumerate_vm_maps(struct lttng_session *session)
226 {
227 struct task_struct *p;
228
229 rcu_read_lock();
230 for_each_process(p)
231 lttng_enumerate_task_vm_maps(session, p);
232 rcu_read_unlock();
233 return 0;
234 }
235 #endif
236
237 #ifdef CONFIG_GENERIC_HARDIRQS
238
239 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
240 #define irq_desc_get_chip(desc) get_irq_desc_chip(desc)
241 #endif
242
243 static
244 void lttng_list_interrupts(struct lttng_session *session)
245 {
246 unsigned int irq;
247 unsigned long flags = 0;
248 struct irq_desc *desc;
249
250 #define irq_to_desc wrapper_irq_to_desc
251 /* needs irq_desc */
252 for_each_irq_desc(irq, desc) {
253 struct irqaction *action;
254 const char *irq_chip_name =
255 irq_desc_get_chip(desc)->name ? : "unnamed_irq_chip";
256
257 local_irq_save(flags);
258 raw_spin_lock(&desc->lock);
259 for (action = desc->action; action; action = action->next) {
260 trace_lttng_statedump_interrupt(session,
261 irq, irq_chip_name, action);
262 }
263 raw_spin_unlock(&desc->lock);
264 local_irq_restore(flags);
265 }
266 #undef irq_to_desc
267 }
268 #else
269 static inline
270 void list_interrupts(struct lttng_session *session)
271 {
272 }
273 #endif
274
275 static
276 void lttng_statedump_process_ns(struct lttng_session *session,
277 struct task_struct *p,
278 enum lttng_thread_type type,
279 enum lttng_execution_mode mode,
280 enum lttng_execution_submode submode,
281 enum lttng_process_status status)
282 {
283 struct nsproxy *proxy;
284 struct pid_namespace *pid_ns;
285
286 rcu_read_lock();
287 proxy = task_nsproxy(p);
288 if (proxy) {
289 pid_ns = proxy->pid_ns;
290 do {
291 trace_lttng_statedump_process_state(session,
292 p, type, mode, submode, status, pid_ns);
293 } while (pid_ns);
294 } else {
295 trace_lttng_statedump_process_state(session,
296 p, type, mode, submode, status, NULL);
297 }
298 rcu_read_unlock();
299 }
300
301 static
302 int lttng_enumerate_process_states(struct lttng_session *session)
303 {
304 struct task_struct *g, *p;
305
306 rcu_read_lock();
307 for_each_process(g) {
308 p = g;
309 do {
310 enum lttng_execution_mode mode =
311 LTTNG_MODE_UNKNOWN;
312 enum lttng_execution_submode submode =
313 LTTNG_UNKNOWN;
314 enum lttng_process_status status;
315 enum lttng_thread_type type;
316
317 task_lock(p);
318 if (p->exit_state == EXIT_ZOMBIE)
319 status = LTTNG_ZOMBIE;
320 else if (p->exit_state == EXIT_DEAD)
321 status = LTTNG_DEAD;
322 else if (p->state == TASK_RUNNING) {
323 /* Is this a forked child that has not run yet? */
324 if (list_empty(&p->rt.run_list))
325 status = LTTNG_WAIT_FORK;
326 else
327 /*
328 * All tasks are considered as wait_cpu;
329 * the viewer will sort out if the task
330 * was really running at this time.
331 */
332 status = LTTNG_WAIT_CPU;
333 } else if (p->state &
334 (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)) {
335 /* Task is waiting for something to complete */
336 status = LTTNG_WAIT;
337 } else
338 status = LTTNG_UNNAMED;
339 submode = LTTNG_NONE;
340
341 /*
342 * Verification of t->mm is to filter out kernel
343 * threads; Viewer will further filter out if a
344 * user-space thread was in syscall mode or not.
345 */
346 if (p->mm)
347 type = LTTNG_USER_THREAD;
348 else
349 type = LTTNG_KERNEL_THREAD;
350 lttng_statedump_process_ns(session,
351 p, type, mode, submode, status);
352 task_unlock(p);
353 } while_each_thread(g, p);
354 }
355 rcu_read_unlock();
356
357 return 0;
358 }
359
360 static
361 void lttng_statedump_work_func(struct work_struct *work)
362 {
363 if (atomic_dec_and_test(&kernel_threads_to_run))
364 /* If we are the last thread, wake up do_lttng_statedump */
365 wake_up(&statedump_wq);
366 }
367
368 static
369 int do_lttng_statedump(struct lttng_session *session)
370 {
371 int cpu;
372
373 printk(KERN_DEBUG "LTT state dump thread start\n");
374 trace_lttng_statedump_start(session);
375 lttng_enumerate_process_states(session);
376 lttng_enumerate_file_descriptors(session);
377 /* FIXME lttng_enumerate_vm_maps(session); */
378 lttng_list_interrupts(session);
379 lttng_enumerate_network_ip_interface(session);
380
381 /* TODO lttng_dump_idt_table(session); */
382 /* TODO lttng_dump_softirq_vec(session); */
383 /* TODO lttng_list_modules(session); */
384 /* TODO lttng_dump_swap_files(session); */
385
386 /*
387 * Fire off a work queue on each CPU. Their sole purpose in life
388 * is to guarantee that each CPU has been in a state where is was in
389 * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
390 */
391 get_online_cpus();
392 atomic_set(&kernel_threads_to_run, num_online_cpus());
393 for_each_online_cpu(cpu) {
394 INIT_DELAYED_WORK(&cpu_work[cpu], lttng_statedump_work_func);
395 schedule_delayed_work_on(cpu, &cpu_work[cpu], 0);
396 }
397 /* Wait for all threads to run */
398 __wait_event(statedump_wq, (atomic_read(&kernel_threads_to_run) != 0));
399 put_online_cpus();
400 /* Our work is done */
401 printk(KERN_DEBUG "LTT state dump end\n");
402 trace_lttng_statedump_end(session);
403 return 0;
404 }
405
406 /*
407 * Called with session mutex held.
408 */
409 int lttng_statedump_start(struct lttng_session *session)
410 {
411 printk(KERN_DEBUG "LTTng: state dump begin\n");
412 return do_lttng_statedump(session);
413 }
414 EXPORT_SYMBOL_GPL(lttng_statedump_start);
415
416 MODULE_LICENSE("GPL and additional rights");
417 MODULE_AUTHOR("Jean-Hugues Deschenes");
418 MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Statedump");
This page took 0.042215 seconds and 4 git commands to generate.