kern/src/kdebug.c

   1 /* Copyright (c) 2011 The Regents of the University of California
   2  * Barret Rhoden <brho@cs.berkeley.edu>
   3  * See LICENSE for details.
   4  *
   5  * Arch-independent kernel debugging */
   6
   7 #include <kdebug.h>
   8 #include <kmalloc.h>
   9 #include <string.h>
  10 #include <assert.h>
  11 #include <smp.h>
  12
  13 struct symtab_entry gbl_symtab[1] __attribute__((weak)) = {{0, 0}};
  14
  15 /* Returns a null-terminated string with the function name for a given PC /
  16  * instruction pointer.  kfree() the result. */
  17 char *get_fn_name(uintptr_t pc)
  18 {
  19         struct symtab_entry *i, *prev = 0, *found = 0;
  20         char *buf;
  21         size_t name_len;
  22         /* Table is in ascending order.  As soon as we get to an entry greater than
  23          * us, we were in the previous one.  This is only true if we were given a
  24          * good PC.  Random addresses will just find the previous symbol. */
  25         for (i = &gbl_symtab[0]; i->name; i++) {
  26                 if (i->addr > pc) {
  27                         found = prev;
  28                         break;
  29                 }
  30                 prev = i;
  31         }
  32         if (!found)
  33                 return 0;
  34         assert(found->name);
  35         name_len = strlen(found->name) + 1;
  36         buf = kmalloc(name_len, 0);
  37         if (!buf)
  38                 return 0;
  39         strncpy(buf, found->name, name_len);
  40         buf[name_len] = 0;
  41         return buf;
  42 }
  43
  44 uintptr_t get_symbol_addr(char *sym)
  45 {
  46         struct symtab_entry *i;
  47         for (i = &gbl_symtab[0]; i->name; i++) {
  48                 if (strcmp(i->name, sym) == 0)
  49                         return i->addr;
  50         }
  51         return 0;
  52 }
  53
  54 static const char *blacklist[] = {
  55         "addnode",
  56         "addqueue",
  57         "allocroute",
  58         "balancetree",
  59         "calcd",
  60         "freeroute",
  61         "genrandom",    /* not noisy, just never returns */
  62         "limborexmit",
  63         "rangecompare",
  64         "walkadd",
  65 };
  66
  67 static bool is_blacklisted(const char *s)
  68 {
  69         for (int i = 0; i < ARRAY_SIZE(blacklist); i++) {
  70                 if (!strcmp(blacklist[i], s))
  71                         return TRUE;
  72         }
  73         return FALSE;
  74 }
  75
  76 static int tab_depth = 0;
  77
  78 /* Call this via kfunc */
  79 void reset_print_func_depth(void)
  80 {
  81         tab_depth = 0;
  82 }
  83
  84 static spinlock_t lock = SPINLOCK_INITIALIZER_IRQSAVE;
  85
  86 static void __print_hdr(void)
  87 {
  88         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
  89         printd("Core %2d ", core_id()); /* may help with multicore output */
  90         if (in_irq_ctx(pcpui)) {
  91                 printk("IRQ       :");
  92         } else {
  93                 assert(pcpui->cur_kthread);
  94                 if (pcpui->cur_kthread->is_ktask) {
  95                         printk("%10s:", pcpui->cur_kthread->name);
  96                 } else {
  97                         printk("PID %3d   :", pcpui->cur_proc ? pcpui->cur_proc->pid : 0);
  98                 }
  99         }
 100 }
 101
 102 void __print_func_entry(const char *func, const char *file)
 103 {
 104         char tentabs[] = "\t\t\t\t\t\t\t\t\t\t"; // ten tabs and a \0
 105         char *ourtabs = &tentabs[10 - MIN(tab_depth, 10)];
 106         if (!printx_on)
 107                 return;
 108         if (is_blacklisted(func))
 109                 return;
 110         spin_lock_irqsave(&lock);
 111         __print_hdr();
 112         printk("%s%s() in %s\n", ourtabs, func, file);
 113         spin_unlock_irqsave(&lock);
 114         tab_depth++;
 115 }
 116
 117 void __print_func_exit(const char *func, const char *file)
 118 {
 119         char tentabs[] = "\t\t\t\t\t\t\t\t\t\t"; // ten tabs and a \0
 120         char *ourtabs;
 121         if (!printx_on)
 122                 return;
 123         if (is_blacklisted(func))
 124                 return;
 125         tab_depth--;
 126         ourtabs = &tentabs[10 - MIN(tab_depth, 10)];
 127         spin_lock_irqsave(&lock);
 128         __print_hdr();
 129         printk("%s---- %s()\n", ourtabs, func);
 130         spin_unlock_irqsave(&lock);
 131 }
 132
 133 bool printx_on = FALSE;
 134
 135 void set_printx(int mode)
 136 {
 137         switch (mode) {
 138                 case 0:
 139                         printx_on = FALSE;
 140                         break;
 141                 case 1:
 142                         printx_on = TRUE;
 143                         break;
 144                 case 2:
 145                         printx_on = !printx_on;
 146                         break;
 147         }
 148 }