ltt-modules/ltt-statedump.c

   1 /* ltt-state-dump.c
   2  *
   3  * Lunix Trace Toolkit Kernel State Dump
   4  *
   5  * Copyright 2005 -
   6  * Jean-Hugues Deschenes <jean-hugues.deschenes@polymtl.ca>
   7  *
   8  * Changes:
   9  *     Eric Clement:            add listing of network IP interface
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/ltt-core.h>
  16 #include <linux/netlink.h>
  17 #include <linux/inet.h>
  18 #include <linux/ip.h>
  19 #include <linux/kthread.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/file.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/irq.h>
  24 #include <linux/cpu.h>
  25 #include <linux/ltt/ltt-facility-statedump.h>
  26
  27 #define NB_PROC_CHUNK 20
  28
  29 #include <linux/netdevice.h>
  30 #include <linux/inetdevice.h>
  31
  32 /* in modules.c */
  33 extern int ltt_enumerate_modules(void);
  34
  35 static inline int ltt_enumerate_network_ip_interface(void)
  36 {
  37   struct net_device *list;
  38   struct in_device *in_dev = NULL;
  39   struct in_ifaddr *ifa = NULL;
  40
  41   read_lock(&dev_base_lock);
  42   for(list=dev_base; list != NULL; list=list->next) {
  43
  44     if(list->flags & IFF_UP) {
  45       in_dev = in_dev_get(list);
  46
  47       if(in_dev) {
  48         for (ifa = in_dev->ifa_list; ifa != NULL; ifa = ifa->ifa_next) {
  49           trace_statedump_enumerate_network_ip_interface(list->name,
  50                                                                                                                                                                                                                                 ifa->ifa_address,
  51                                                                                                                                                                                                                                         LTTNG_UP);
  52                                 }
  53                                 in_dev_put(in_dev);
  54       }
  55     } else {
  56       trace_statedump_enumerate_network_ip_interface(list->name,
  57                                                                                                                                                                                                                                         0,
  58                                                                                                                                                                                                                                         LTTNG_DOWN);
  59                 }
  60   }
  61   read_unlock(&dev_base_lock);
  62
  63   return 0;
  64 }
  65
  66 static inline int ltt_enumerate_file_descriptors(void)
  67 {
  68   struct task_struct * t = &init_task;
  69         unsigned int    i;
  70         struct file *           filp;
  71         char                            *tmp = (char*)__get_free_page(GFP_KERNEL), *path;
  72   struct fdtable *fdt;
  73
  74         /* Enumerate active file descriptors */
  75
  76         do {
  77           read_lock(&tasklist_lock);
  78     if(t != &init_task) atomic_dec(&t->usage);
  79           t = next_task(t);
  80     atomic_inc(&t->usage);
  81     read_unlock(&tasklist_lock);
  82
  83                 task_lock(t);
  84                 if (t->files) {
  85                         spin_lock(&t->files->file_lock);
  86                         fdt = files_fdtable(t->files);
  87                         for (i=0; i < fdt->max_fds; i++) {
  88                                 filp = fcheck_files(t->files, i);
  89                                 if (!filp)
  90                                  continue;
  91                                 path = d_path(filp->f_dentry, filp->f_vfsmnt, tmp, PAGE_SIZE);
  92
  93                                 /* Make sure we give at least some info */
  94                                 if(IS_ERR(path))
  95                                         trace_statedump_enumerate_file_descriptors(filp->f_dentry->d_name.name, t->pid, i);
  96                                 else
  97                                  trace_statedump_enumerate_file_descriptors(path, t->pid, i);
  98                  }
  99                  spin_unlock(&t->files->file_lock);
 100                 }
 101                 task_unlock(t);
 102
 103   } while( t != &init_task );
 104
 105         free_page((unsigned long)tmp);
 106
 107         return 0;
 108 }
 109
 110 static inline int ltt_enumerate_vm_maps(void)
 111 {
 112         struct mm_struct *mm;
 113   struct task_struct *  t = &init_task;
 114         struct vm_area_struct * map;
 115         unsigned long                   ino = 0;
 116
 117         do {
 118     read_lock(&tasklist_lock);
 119     if(t != &init_task) atomic_dec(&t->usage);
 120           t = next_task(t);
 121     atomic_inc(&t->usage);
 122     read_unlock(&tasklist_lock);
 123
 124                 /* get_task_mm does a task_lock... */
 125
 126                 mm = get_task_mm(t);
 127
 128                 if (mm)
 129                 {
 130                         map = mm->mmap;
 131
 132                         if(map)
 133                         {
 134                                 down_read(&mm->mmap_sem);
 135
 136                                 while (map) {
 137                                         if (map->vm_file) {
 138                                                 ino = map->vm_file->f_dentry->d_inode->i_ino;
 139                                         } else {
 140                                                 ino = 0;
 141                                         }
 142
 143                                         trace_statedump_enumerate_vm_maps(t->pid, (void *)map->vm_start, (void *)map->vm_end, map->vm_flags, map->vm_pgoff << PAGE_SHIFT, ino);
 144                                         map = map->vm_next;
 145                                 }
 146
 147                                 up_read(&mm->mmap_sem);
 148                         }
 149
 150                         mmput(mm);
 151                 }
 152
 153         } while( t != &init_task );
 154
 155         return 0;
 156 }
 157
 158 #if defined( CONFIG_ARM )
 159 /* defined in arch/arm/kernel/irq.c because of dependency on statically-defined lock & irq_desc */
 160 int ltt_enumerate_interrupts(void);
 161 #else
 162 static inline int ltt_enumerate_interrupts(void)
 163 {
 164   unsigned int i;
 165   unsigned long flags = 0;
 166
 167   /* needs irq_desc */
 168
 169   for(i = 0; i < NR_IRQS; i++)
 170   {
 171     struct irqaction * action;
 172
 173     spin_lock_irqsave(&irq_desc[i].lock, flags);
 174
 175
 176     for (action=irq_desc[i].action; action; action = action->next)
 177       trace_statedump_enumerate_interrupts(
 178         irq_desc[i].handler->typename,
 179         action->name,
 180         i );
 181
 182     spin_unlock_irqrestore(&irq_desc[i].lock, flags);
 183   }
 184
 185   return 0;
 186 }
 187 #endif
 188
 189 static inline int ltt_enumerate_process_states(void)
 190 {
 191   struct task_struct *          t = &init_task;
 192   struct task_struct *          p = t;
 193   enum lttng_process_status     status;
 194   enum lttng_thread_type        type;
 195   enum lttng_execution_mode     mode;
 196   enum lttng_execution_submode  submode;
 197
 198   do {
 199     mode = LTTNG_MODE_UNKNOWN;
 200     submode = LTTNG_UNKNOWN;
 201
 202     read_lock(&tasklist_lock);
 203     if(t != &init_task) {
 204       atomic_dec(&t->usage);
 205       t = next_thread(t);
 206     }
 207     if(t == p) {
 208       t = p = next_task(t);
 209     }
 210     atomic_inc(&t->usage);
 211     read_unlock(&tasklist_lock);
 212
 213     task_lock(t);
 214
 215     if(t->exit_state == EXIT_ZOMBIE)
 216       status = LTTNG_ZOMBIE;
 217     else if(t->exit_state == EXIT_DEAD)
 218       status = LTTNG_DEAD;
 219     else if(t->state == TASK_RUNNING)
 220     {
 221       /* Is this a forked child that has not run yet? */
 222       if( list_empty(&t->run_list) )
 223       {
 224         status = LTTNG_WAIT_FORK;
 225       }
 226       else
 227       {
 228         /* All tasks are considered as wait_cpu; the viewer will sort out if the task was relly running at this time. */
 229         status = LTTNG_WAIT_CPU;
 230       }
 231     }
 232     else if(t->state & (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE))
 233     {
 234       /* Task is waiting for something to complete */
 235       status = LTTNG_WAIT;
 236     }
 237     else
 238       status = LTTNG_UNNAMED;
 239
 240     submode = LTTNG_NONE;
 241
 242
 243     /* Verification of t->mm is to filter out kernel threads;
 244        Viewer will further filter out if a user-space thread was in syscall mode or not */
 245     if(t->mm)
 246       type = LTTNG_USER_THREAD;
 247     else
 248       type = LTTNG_KERNEL_THREAD;
 249
 250     trace_statedump_enumerate_process_state(t->pid, t->parent->pid, t->comm,
 251                                             type, mode, submode, status);
 252
 253     task_unlock(t);
 254
 255   } while( t != &init_task );
 256
 257   return 0;
 258 }
 259
 260 void ltt_statedump_work_func(void *sem)
 261 {
 262   /* Our job is just to release the semaphore so
 263      that we are sure that each CPU has been in syscall
 264      mode before the end of ltt_statedump_thread */
 265   up((struct semaphore *)sem);
 266 }
 267
 268 static struct work_struct cpu_work[NR_CPUS];
 269
 270 int ltt_statedump_thread(void *data)
 271 {
 272   struct semaphore work_sema4;
 273   int cpu;
 274
 275   printk("ltt_statedump_thread\n");
 276
 277         ltt_enumerate_process_states();
 278
 279   ltt_enumerate_file_descriptors();
 280
 281         ltt_enumerate_modules();
 282
 283         ltt_enumerate_vm_maps();
 284
 285         ltt_enumerate_interrupts();
 286
 287         ltt_enumerate_network_ip_interface();
 288
 289   /* Fire off a work queue on each CPU. Their sole purpose in life
 290    * is to guarantee that each CPU has been in a state where is was in syscall
 291    * mode (i.e. not in a trap, an IRQ or a soft IRQ) */
 292   sema_init(&work_sema4, 1 - num_online_cpus());
 293
 294   lock_cpu_hotplug();
 295   for_each_online_cpu(cpu)
 296   {
 297     INIT_WORK(&cpu_work[cpu], ltt_statedump_work_func, &work_sema4);
 298
 299     schedule_delayed_work_on(cpu,&cpu_work[cpu],0);
 300   }
 301   unlock_cpu_hotplug();
 302
 303   /* Wait for all work queues to have completed */
 304   down(&work_sema4);
 305
 306   /* Our work is done */
 307   printk("trace_statedump_statedump_end\n");
 308   trace_statedump_statedump_end();
 309
 310         do_exit(0);
 311
 312         return 0;
 313 }
 314
 315 int ltt_statedump_start(struct ltt_trace_struct *trace)
 316 {
 317         printk("ltt_statedump_start\n");
 318
 319         kthread_run(    ltt_statedump_thread,
 320                                                                 NULL,
 321                                                                 "ltt_statedump");
 322
 323         return 0;
 324 }
 325
 326
 327 /* Dynamic facility. */
 328
 329 static int __init statedump_init(void)
 330 {
 331         int ret;
 332         printk(KERN_INFO "LTT : ltt-facility-statedump init\n");
 333
 334         ret = ltt_module_register(LTT_FUNCTION_STATEDUMP,
 335                                                                                                                 ltt_statedump_start,THIS_MODULE);
 336
 337         return ret;
 338 }
 339
 340 static void __exit statedump_exit(void)
 341 {
 342         ltt_module_unregister(LTT_FUNCTION_STATEDUMP);
 343 }
 344
 345 module_init(statedump_init)
 346 module_exit(statedump_exit)
 347
 348
 349 MODULE_LICENSE("GPL");
 350 MODULE_AUTHOR("Jean-Hugues Deschenes");
 351 MODULE_DESCRIPTION("Linux Trace Toolkit Statedump");
 352