kernel/kallsyms.c

   1 /*
   2  * kallsyms.c: in-kernel printing of symbolic oopses and stack traces.
   3  *
   4  * Rewritten and vastly simplified by Rusty Russell for in-kernel
   5  * module loader:
   6  *   Copyright 2002 Rusty Russell <rusty@rustcorp.com.au> IBM Corporation
   7  *
   8  * ChangeLog:
   9  *
  10  * (25/Aug/2004) Paulo Marques <pmarques@grupopie.com>
  11  *      Changed the compression method from stem compression to "table lookup"
  12  *      compression (see scripts/kallsyms.c for a more complete description)
  13  */
  14 #include <linux/kallsyms.h>
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/seq_file.h>
  18 #include <linux/fs.h>
  19 #include <linux/err.h>
  20 #include <linux/proc_fs.h>
  21 #include <linux/sched.h>        /* for cond_resched */
  22 #include <linux/mm.h>
  23 #include <linux/ctype.h>
  24
  25 #include <asm/sections.h>
  26
  27 #ifdef CONFIG_KALLSYMS_ALL
  28 #define all_var 1
  29 #else
  30 #define all_var 0
  31 #endif
  32
  33 /*
  34  * These will be re-linked against their real values
  35  * during the second link stage.
  36  */
  37 extern const unsigned long kallsyms_addresses[] __attribute__((weak));
  38 extern const u8 kallsyms_names[] __attribute__((weak));
  39
  40 /*
  41  * Tell the compiler that the count isn't in the small data section if the arch
  42  * has one (eg: FRV).
  43  */
  44 extern const unsigned long kallsyms_num_syms
  45 __attribute__((weak, section(".rodata")));
  46
  47 extern const u8 kallsyms_token_table[] __attribute__((weak));
  48 extern const u16 kallsyms_token_index[] __attribute__((weak));
  49
  50 extern const unsigned long kallsyms_markers[] __attribute__((weak));
  51
  52 static inline int is_kernel_inittext(unsigned long addr)
  53 {
  54         if (addr >= (unsigned long)_sinittext
  55             && addr <= (unsigned long)_einittext)
  56                 return 1;
  57         return 0;
  58 }
  59
  60 static inline int is_kernel_text(unsigned long addr)
  61 {
  62         if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) ||
  63             arch_is_kernel_text(addr))
  64                 return 1;
  65         return in_gate_area_no_task(addr);
  66 }
  67
  68 static inline int is_kernel(unsigned long addr)
  69 {
  70         if (addr >= (unsigned long)_stext && addr <= (unsigned long)_end)
  71                 return 1;
  72         return in_gate_area_no_task(addr);
  73 }
  74
  75 static int is_ksym_addr(unsigned long addr)
  76 {
  77         if (all_var)
  78                 return is_kernel(addr);
  79
  80         return is_kernel_text(addr) || is_kernel_inittext(addr);
  81 }
  82
  83 /*
  84  * Expand a compressed symbol data into the resulting uncompressed string,
  85  * given the offset to where the symbol is in the compressed stream.
  86  */
  87 static unsigned int kallsyms_expand_symbol(unsigned int off, char *result)
  88 {
  89         int len, skipped_first = 0;
  90         const u8 *tptr, *data;
  91
  92         /* Get the compressed symbol length from the first symbol byte. */
  93         data = &kallsyms_names[off];
  94         len = *data;
  95         data++;
  96
  97         /*
  98          * Update the offset to return the offset for the next symbol on
  99          * the compressed stream.
 100          */
 101         off += len + 1;
 102
 103         /*
 104          * For every byte on the compressed symbol data, copy the table
 105          * entry for that byte.
 106          */
 107         while (len) {
 108                 tptr = &kallsyms_token_table[kallsyms_token_index[*data]];
 109                 data++;
 110                 len--;
 111
 112                 while (*tptr) {
 113                         if (skipped_first) {
 114                                 *result = *tptr;
 115                                 result++;
 116                         } else
 117                                 skipped_first = 1;
 118                         tptr++;
 119                 }
 120         }
 121
 122         *result = '\0';
 123
 124         /* Return to offset to the next symbol. */
 125         return off;
 126 }
 127
 128 /*
 129  * Get symbol type information. This is encoded as a single char at the
 130  * beginning of the symbol name.
 131  */
 132 static char kallsyms_get_symbol_type(unsigned int off)
 133 {
 134         /*
 135          * Get just the first code, look it up in the token table,
 136          * and return the first char from this token.
 137          */
 138         return kallsyms_token_table[kallsyms_token_index[kallsyms_names[off + 1]]];
 139 }
 140
 141
 142 /*
 143  * Find the offset on the compressed stream given and index in the
 144  * kallsyms array.
 145  */
 146 static unsigned int get_symbol_offset(unsigned long pos)
 147 {
 148         const u8 *name;
 149         int i;
 150
 151         /*
 152          * Use the closest marker we have. We have markers every 256 positions,
 153          * so that should be close enough.
 154          */
 155         name = &kallsyms_names[kallsyms_markers[pos >> 8]];
 156
 157         /*
 158          * Sequentially scan all the symbols up to the point we're searching
 159          * for. Every symbol is stored in a [<len>][<len> bytes of data] format,
 160          * so we just need to add the len to the current pointer for every
 161          * symbol we wish to skip.
 162          */
 163         for (i = 0; i < (pos & 0xFF); i++)
 164                 name = name + (*name) + 1;
 165
 166         return name - kallsyms_names;
 167 }
 168
 169 /* Lookup the address for this symbol. Returns 0 if not found. */
 170 unsigned long kallsyms_lookup_name(const char *name)
 171 {
 172         char namebuf[KSYM_NAME_LEN];
 173         unsigned long i;
 174         unsigned int off;
 175
 176         for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
 177                 off = kallsyms_expand_symbol(off, namebuf);
 178
 179                 if (strcmp(namebuf, name) == 0)
 180                         return kallsyms_addresses[i];
 181         }
 182         return module_kallsyms_lookup_name(name);
 183 }
 184 EXPORT_SYMBOL_GPL(kallsyms_lookup_name);
 185
 186 int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *,
 187                                       unsigned long),
 188                             void *data)
 189 {
 190         char namebuf[KSYM_NAME_LEN];
 191         unsigned long i;
 192         unsigned int off;
 193         int ret;
 194
 195         for (i = 0, off = 0; i < kallsyms_num_syms; i++) {
 196                 off = kallsyms_expand_symbol(off, namebuf);
 197                 ret = fn(data, namebuf, NULL, kallsyms_addresses[i]);
 198                 if (ret != 0)
 199                         return ret;
 200         }
 201         return module_kallsyms_on_each_symbol(fn, data);
 202 }
 203 EXPORT_SYMBOL_GPL(kallsyms_on_each_symbol);
 204
 205 static unsigned long get_symbol_pos(unsigned long addr,
 206                                     unsigned long *symbolsize,
 207                                     unsigned long *offset)
 208 {
 209         unsigned long symbol_start = 0, symbol_end = 0;
 210         unsigned long i, low, high, mid;
 211
 212         /* This kernel should never had been booted. */
 213         BUG_ON(!kallsyms_addresses);
 214
 215         /* Do a binary search on the sorted kallsyms_addresses array. */
 216         low = 0;
 217         high = kallsyms_num_syms;
 218
 219         while (high - low > 1) {
 220                 mid = low + (high - low) / 2;
 221                 if (kallsyms_addresses[mid] <= addr)
 222                         low = mid;
 223                 else
 224                         high = mid;
 225         }
 226
 227         /*
 228          * Search for the first aliased symbol. Aliased
 229          * symbols are symbols with the same address.
 230          */
 231         while (low && kallsyms_addresses[low-1] == kallsyms_addresses[low])
 232                 --low;
 233
 234         symbol_start = kallsyms_addresses[low];
 235
 236         /* Search for next non-aliased symbol. */
 237         for (i = low + 1; i < kallsyms_num_syms; i++) {
 238                 if (kallsyms_addresses[i] > symbol_start) {
 239                         symbol_end = kallsyms_addresses[i];
 240                         break;
 241                 }
 242         }
 243
 244         /* If we found no next symbol, we use the end of the section. */
 245         if (!symbol_end) {
 246                 if (is_kernel_inittext(addr))
 247                         symbol_end = (unsigned long)_einittext;
 248                 else if (all_var)
 249                         symbol_end = (unsigned long)_end;
 250                 else
 251                         symbol_end = (unsigned long)_etext;
 252         }
 253
 254         if (symbolsize)
 255                 *symbolsize = symbol_end - symbol_start;
 256         if (offset)
 257                 *offset = addr - symbol_start;
 258
 259         return low;
 260 }
 261
 262 /*
 263  * Lookup an address but don't bother to find any names.
 264  */
 265 int kallsyms_lookup_size_offset(unsigned long addr, unsigned long *symbolsize,
 266                                 unsigned long *offset)
 267 {
 268         char namebuf[KSYM_NAME_LEN];
 269         if (is_ksym_addr(addr))
 270                 return !!get_symbol_pos(addr, symbolsize, offset);
 271
 272         return !!module_address_lookup(addr, symbolsize, offset, NULL, namebuf);
 273 }
 274
 275 /*
 276  * Lookup an address
 277  * - modname is set to NULL if it's in the kernel.
 278  * - We guarantee that the returned name is valid until we reschedule even if.
 279  *   It resides in a module.
 280  * - We also guarantee that modname will be valid until rescheduled.
 281  */
 282 const char *kallsyms_lookup(unsigned long addr,
 283                             unsigned long *symbolsize,
 284                             unsigned long *offset,
 285                             char **modname, char *namebuf)
 286 {
 287         namebuf[KSYM_NAME_LEN - 1] = 0;
 288         namebuf[0] = 0;
 289
 290         if (is_ksym_addr(addr)) {
 291                 unsigned long pos;
 292
 293                 pos = get_symbol_pos(addr, symbolsize, offset);
 294                 /* Grab name */
 295                 kallsyms_expand_symbol(get_symbol_offset(pos), namebuf);
 296                 if (modname)
 297                         *modname = NULL;
 298                 return namebuf;
 299         }
 300
 301         /* See if it's in a module. */
 302         return module_address_lookup(addr, symbolsize, offset, modname,
 303                                      namebuf);
 304 }
 305
 306 int lookup_symbol_name(unsigned long addr, char *symname)
 307 {
 308         symname[0] = '\0';
 309         symname[KSYM_NAME_LEN - 1] = '\0';
 310
 311         if (is_ksym_addr(addr)) {
 312                 unsigned long pos;
 313
 314                 pos = get_symbol_pos(addr, NULL, NULL);
 315                 /* Grab name */
 316                 kallsyms_expand_symbol(get_symbol_offset(pos), symname);
 317                 return 0;
 318         }
 319         /* See if it's in a module. */
 320         return lookup_module_symbol_name(addr, symname);
 321 }
 322
 323 int lookup_symbol_attrs(unsigned long addr, unsigned long *size,
 324                         unsigned long *offset, char *modname, char *name)
 325 {
 326         name[0] = '\0';
 327         name[KSYM_NAME_LEN - 1] = '\0';
 328
 329         if (is_ksym_addr(addr)) {
 330                 unsigned long pos;
 331
 332                 pos = get_symbol_pos(addr, size, offset);
 333                 /* Grab name */
 334                 kallsyms_expand_symbol(get_symbol_offset(pos), name);
 335                 modname[0] = '\0';
 336                 return 0;
 337         }
 338         /* See if it's in a module. */
 339         return lookup_module_symbol_attrs(addr, size, offset, modname, name);
 340 }
 341
 342 /* Look up a kernel symbol and return it in a text buffer. */
 343 int sprint_symbol(char *buffer, unsigned long address)
 344 {
 345         char *modname;
 346         const char *name;
 347         unsigned long offset, size;
 348         int len;
 349
 350         name = kallsyms_lookup(address, &size, &offset, &modname, buffer);
 351         if (!name)
 352                 return sprintf(buffer, "0x%lx", address);
 353
 354         if (name != buffer)
 355                 strcpy(buffer, name);
 356         len = strlen(buffer);
 357         buffer += len;
 358
 359         if (modname)
 360                 len += sprintf(buffer, "+%#lx/%#lx [%s]",
 361                                                 offset, size, modname);
 362         else
 363                 len += sprintf(buffer, "+%#lx/%#lx", offset, size);
 364
 365         return len;
 366 }
 367 EXPORT_SYMBOL_GPL(sprint_symbol);
 368
 369 /* Look up a kernel symbol and print it to the kernel messages. */
 370 void __print_symbol(const char *fmt, unsigned long address)
 371 {
 372         char buffer[KSYM_SYMBOL_LEN];
 373
 374         sprint_symbol(buffer, address);
 375
 376         printk(fmt, buffer);
 377 }
 378 EXPORT_SYMBOL(__print_symbol);
 379
 380 /* To avoid using get_symbol_offset for every symbol, we carry prefix along. */
 381 struct kallsym_iter {
 382         loff_t pos;
 383         unsigned long value;
 384         unsigned int nameoff; /* If iterating in core kernel symbols. */
 385         char type;
 386         char name[KSYM_NAME_LEN];
 387         char module_name[MODULE_NAME_LEN];
 388         int exported;
 389 };
 390
 391 static int get_ksymbol_mod(struct kallsym_iter *iter)
 392 {
 393         if (module_get_kallsym(iter->pos - kallsyms_num_syms, &iter->value,
 394                                 &iter->type, iter->name, iter->module_name,
 395                                 &iter->exported) < 0)
 396                 return 0;
 397         return 1;
 398 }
 399
 400 /* Returns space to next name. */
 401 static unsigned long get_ksymbol_core(struct kallsym_iter *iter)
 402 {
 403         unsigned off = iter->nameoff;
 404
 405         iter->module_name[0] = '\0';
 406         iter->value = kallsyms_addresses[iter->pos];
 407
 408         iter->type = kallsyms_get_symbol_type(off);
 409
 410         off = kallsyms_expand_symbol(off, iter->name);
 411
 412         return off - iter->nameoff;
 413 }
 414
 415 static void reset_iter(struct kallsym_iter *iter, loff_t new_pos)
 416 {
 417         iter->name[0] = '\0';
 418         iter->nameoff = get_symbol_offset(new_pos);
 419         iter->pos = new_pos;
 420 }
 421
 422 /* Returns false if pos at or past end of file. */
 423 static int update_iter(struct kallsym_iter *iter, loff_t pos)
 424 {
 425         /* Module symbols can be accessed randomly. */
 426         if (pos >= kallsyms_num_syms) {
 427                 iter->pos = pos;
 428                 return get_ksymbol_mod(iter);
 429         }
 430
 431         /* If we're not on the desired position, reset to new position. */
 432         if (pos != iter->pos)
 433                 reset_iter(iter, pos);
 434
 435         iter->nameoff += get_ksymbol_core(iter);
 436         iter->pos++;
 437
 438         return 1;
 439 }
 440
 441 static void *s_next(struct seq_file *m, void *p, loff_t *pos)
 442 {
 443         (*pos)++;
 444
 445         if (!update_iter(m->private, *pos))
 446                 return NULL;
 447         return p;
 448 }
 449
 450 static void *s_start(struct seq_file *m, loff_t *pos)
 451 {
 452         if (!update_iter(m->private, *pos))
 453                 return NULL;
 454         return m->private;
 455 }
 456
 457 static void s_stop(struct seq_file *m, void *p)
 458 {
 459 }
 460
 461 static int s_show(struct seq_file *m, void *p)
 462 {
 463         struct kallsym_iter *iter = m->private;
 464
 465         /* Some debugging symbols have no name.  Ignore them. */
 466         if (!iter->name[0])
 467                 return 0;
 468
 469         if (iter->module_name[0]) {
 470                 char type;
 471
 472                 /*
 473                  * Label it "global" if it is exported,
 474                  * "local" if not exported.
 475                  */
 476                 type = iter->exported ? toupper(iter->type) :
 477                                         tolower(iter->type);
 478                 seq_printf(m, "%0*lx %c %s\t[%s]\n",
 479                            (int)(2 * sizeof(void *)),
 480                            iter->value, type, iter->name, iter->module_name);
 481         } else
 482                 seq_printf(m, "%0*lx %c %s\n",
 483                            (int)(2 * sizeof(void *)),
 484                            iter->value, iter->type, iter->name);
 485         return 0;
 486 }
 487
 488 static const struct seq_operations kallsyms_op = {
 489         .start = s_start,
 490         .next = s_next,
 491         .stop = s_stop,
 492         .show = s_show
 493 };
 494
 495 static int kallsyms_open(struct inode *inode, struct file *file)
 496 {
 497         /*
 498          * We keep iterator in m->private, since normal case is to
 499          * s_start from where we left off, so we avoid doing
 500          * using get_symbol_offset for every symbol.
 501          */
 502         struct kallsym_iter *iter;
 503         int ret;
 504
 505         iter = kmalloc(sizeof(*iter), GFP_KERNEL);
 506         if (!iter)
 507                 return -ENOMEM;
 508         reset_iter(iter, 0);
 509
 510         ret = seq_open(file, &kallsyms_op);
 511         if (ret == 0)
 512                 ((struct seq_file *)file->private_data)->private = iter;
 513         else
 514                 kfree(iter);
 515         return ret;
 516 }
 517
 518 static const struct file_operations kallsyms_operations = {
 519         .open = kallsyms_open,
 520         .read = seq_read,
 521         .llseek = seq_lseek,
 522         .release = seq_release_private,
 523 };
 524
 525 static int __init kallsyms_init(void)
 526 {
 527         proc_create("kallsyms", 0444, NULL, &kallsyms_operations);
 528         return 0;
 529 }
 530 device_initcall(kallsyms_init);