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