Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset e16e0d59 in mainline


Ignore:
Timestamp:
2009-03-17T20:33:18Z (12 years ago)
Author:
Jiri Svoboda <jirik.svoboda@…>
Branches:
lfn, master
Children:
5eb90cb
Parents:
b1c8dc0
Message:

Make optionality of symbol information less intrusive per Jakub's request. Also, improve symtab function names and update their semantics.

Location:
kernel
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • kernel/Makefile

    rb1c8dc0 re16e0d59  
    160160        generic/src/ddi/irq.c \
    161161        generic/src/ddi/device.c \
     162        generic/src/debug/symtab.c \
    162163        generic/src/interrupt/interrupt.c \
    163164        generic/src/main/main.c \
     
    226227endif
    227228
    228 ## Kernel symbol information
    229 #
    230 
    231 ifeq ($(CONFIG_SYMTAB),y)
    232 GENERIC_SOURCES += \
    233         generic/src/debug/symtab.c
    234 endif
    235 
    236229## Udebug interface sources
    237230#
  • kernel/arch/amd64/src/debugger.c

    rb1c8dc0 re16e0d59  
    4444#include <func.h>
    4545#include <smp/ipi.h>
    46 
    47 #ifdef CONFIG_SYMTAB
    4846#include <symtab.h>
    49 #endif
    5047
    5148typedef struct  {
     
    234231        }
    235232
    236 #ifdef CONFIG_SYMTAB
    237         printf("Reached breakpoint %d:%lx(%s)\n", slot, getip(istate),
    238             get_symtab_entry(getip(istate)));
    239 #else
    240         printf("Reached breakpoint %d:%lx\n", slot, getip(istate));
    241 #endif
     233        printf("Reached breakpoint %d:%lx (%s)\n", slot, getip(istate),
     234            symtab_fmt_name_lookup(getip(istate)));
    242235
    243236#ifdef CONFIG_KCONSOLE
     
    364357        for (i = 0; i < BKPOINTS_MAX; i++)
    365358                if (breakpoints[i].address) {
    366 #ifdef CONFIG_SYMTAB
    367                         symbol = get_symtab_entry(breakpoints[i].address);
    368 #else
    369                         symbol = "n/a";
    370 #endif
     359                        symbol = symtab_fmt_name_lookup(
     360                            breakpoints[i].address);
    371361
    372362#ifdef __32_BITS__
  • kernel/arch/amd64/src/interrupt.c

    rb1c8dc0 re16e0d59  
    5252#include <interrupt.h>
    5353#include <ddi/irq.h>
    54 
    55 #ifdef CONFIG_SYMTAB
    5654#include <symtab.h>
    57 #endif
    5855
    5956/*
     
    6865{
    6966        char *symbol;
    70 /*      uint64_t *x = &istate->stack[0]; */
    71 
    72 #ifdef CONFIG_SYMTAB
    73         if (!(symbol = get_symtab_entry(istate->rip)))
    74                 symbol = "";
    75 #else
    76         symbol = "";
    77 #endif
     67
     68        symbol = symtab_fmt_name_lookup((istate->rip);
    7869
    7970        printf("-----EXCEPTION(%d) OCCURED----- ( %s )\n", n, __func__);
  • kernel/arch/ia32/src/interrupt.c

    rb1c8dc0 re16e0d59  
    5252#include <interrupt.h>
    5353#include <ddi/irq.h>
    54 
    55 #ifdef CONFIG_SYMTAB
    5654#include <symtab.h>
    57 #endif
    5855
    5956/*
     
    6966        char *symbol;
    7067
    71 #ifdef CONFIG_SYMTAB
    72         symbol = get_symtab_entry(istate->eip);
    73         if (!symbol)
    74                 symbol = "";
    75 #else
    76         symbol = "";
    77 #endif
     68        symbol = symtab_fmt_name_lookup(istate->eip);
    7869
    7970        if (CPU)
  • kernel/arch/ia64/src/interrupt.c

    rb1c8dc0 re16e0d59  
    5454#include <synch/spinlock.h>
    5555#include <mm/tlb.h>
    56 
    57 #ifdef CONFIG_SYMTAB
    5856#include <symtab.h>
    59 #endif
    6057
    6158#define VECTORS_64_BUNDLE       20
     
    141138        char *ifa, *iipa, *iip;
    142139
    143 #ifdef CONFIG_SYMTAB
    144         ifa = get_symtab_entry(istate->cr_ifa);
    145         iipa = get_symtab_entry(istate->cr_iipa);
    146         iip = get_symtab_entry(istate->cr_iip);
    147 #else
    148         ifa = iipa = iip = "n/a";
    149 #endif
     140        ifa = symtab_fmt_name_lookup(istate->cr_ifa);
     141        iipa = symtab_fmt_name_lookup(istate->cr_iipa);
     142        iip = symtab_fmt_name_lookup(istate->cr_iip);
    150143
    151144        putchar('\n');
  • kernel/arch/mips32/src/debugger.c

    rb1c8dc0 re16e0d59  
    4343#include <arch/cp0.h>
    4444#include <func.h>
    45 
    46 #ifdef CONFIG_SYMTAB
    4745#include <symtab.h>
    48 #endif
    4946
    5047bpinfo_t breakpoints[BKPOINTS_MAX];
     
    263260        for (i = 0; i < BKPOINTS_MAX; i++)
    264261                if (breakpoints[i].address) {
    265 #ifdef CONFIG_SYMTAB
    266                         symbol = get_symtab_entry(breakpoints[i].address);
    267 #else
    268                         symbol = "n/a";
    269 #endif
    270                        
     262                        symbol = symtab_fmt_name_lookup(
     263                            breakpoints[i].address);
     264
    271265                        printf("%-2u %-5d %#10zx %-6s %-7s %-8s %s\n", i,
    272266                            breakpoints[i].counter, breakpoints[i].address,
     
    357351               
    358352                if (!(cur->flags & BKPOINT_FUNCCALL)) {
    359 #ifdef CONFIG_SYMTAB
    360353                        printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
    361                             get_symtab_entry(istate->epc));
    362 #else
    363                         printf("***Breakpoint %d: %p.\n", i, fireaddr);
    364 #endif
     354                            symtab_fmt_name_lookup(istate->epc));
    365355                }
    366356
     
    376366                cur->flags |= BKPOINT_INPROG;
    377367        } else {
    378 #ifdef CONFIG_SYMTAB
    379                 printf("***Breakpoint %p in %s.\n", fireaddr,
    380                        get_symtab_entry(fireaddr));
    381 #else
    382                 printf("***Breakpoint %p.\n", fireaddr);       
    383 #endif
     368                printf("***Breakpoint %d: %p in %s.\n", i, fireaddr,
     369                    symtab_fmt_name_lookup(fireaddr));
     370
    384371                /* Move on to next instruction */
    385372                istate->epc += 4;
  • kernel/arch/mips32/src/exception.c

    rb1c8dc0 re16e0d59  
    4747#include <ddi/irq.h>
    4848#include <arch/debugger.h>
    49 
    50 #ifdef CONFIG_SYMTAB
    5149#include <symtab.h>
    52 #endif
    5350
    5451static char * exctable[] = {
     
    7774static void print_regdump(istate_t *istate)
    7875{
    79         char *pcsymbol = "";
    80         char *rasymbol = "";
     76        char *pcsymbol, *rasymbol;
    8177
    82 #ifdef CONFIG_SYMTAB
    83         char *s = get_symtab_entry(istate->epc);
    84         if (s)
    85                 pcsymbol = s;
    86         s = get_symtab_entry(istate->ra);
    87         if (s)
    88                 rasymbol = s;
    89 #endif
    90        
    91         printf("PC: %#x(%s) RA: %#x(%s), SP(%p)\n", istate->epc, pcsymbol, istate->ra, rasymbol, istate->sp);
     78        pcsymbol = symtab_fmt_name_lookup(istate->epc);
     79        rasymbol = symtab_fmt_name_lookup(istate->ra);
     80
     81        printf("PC: %#x(%s) RA: %#x(%s), SP(%p)\n", istate->epc, pcsymbol,
     82            istate->ra, rasymbol, istate->sp);
    9283}
    9384
  • kernel/arch/mips32/src/mm/tlb.c

    rb1c8dc0 re16e0d59  
    4646#include <align.h>
    4747#include <interrupt.h>
    48 
    49 #ifdef CONFIG_SYMTAB
    5048#include <symtab.h>
    51 #endif
    5249
    5350static void tlb_refill_fail(istate_t *);
     
    324321void tlb_refill_fail(istate_t *istate)
    325322{
    326         char *symbol = "";
    327         char *sym2 = "";
    328 
    329 #ifdef CONFIG_SYMTAB
    330         char *s = get_symtab_entry(istate->epc);
    331         if (s)
    332                 symbol = s;
    333         s = get_symtab_entry(istate->ra);
    334         if (s)
    335                 sym2 = s;
    336 #endif
    337 
     323        char *symbol, *sym2;
     324
     325        symbol = symtab_fmt_name_lookup(istate->epc);
     326        sym2 = symtab_fmt_name_lookup(istate->ra);
     327       
    338328        fault_if_from_uspace(istate, "TLB Refill Exception on %p.",
    339329            cp0_badvaddr_read());
    340         panic("%x: TLB Refill Exception at %x(%s<-%s).", cp0_badvaddr_read(),
     330        panic("%x: TLB Refill Exception at %x (%s<-%s).", cp0_badvaddr_read(),
    341331            istate->epc, symbol, sym2);
    342332}
     
    345335void tlb_invalid_fail(istate_t *istate)
    346336{
    347         char *symbol = "";
    348 
    349 #ifdef CONFIG_SYMTAB
    350         char *s = get_symtab_entry(istate->epc);
    351         if (s)
    352                 symbol = s;
    353 #endif
     337        char *symbol;
     338
     339        symbol = symtab_fmt_name_lookup(istate->epc);
    354340
    355341        fault_if_from_uspace(istate, "TLB Invalid Exception on %p.",
    356342            cp0_badvaddr_read());
    357         panic("%x: TLB Invalid Exception at %x(%s).", cp0_badvaddr_read(),
     343        panic("%x: TLB Invalid Exception at %x (%s).", cp0_badvaddr_read(),
    358344            istate->epc, symbol);
    359345}
     
    361347void tlb_modified_fail(istate_t *istate)
    362348{
    363         char *symbol = "";
    364 
    365 #ifdef CONFIG_SYMTAB
    366         char *s = get_symtab_entry(istate->epc);
    367         if (s)
    368                 symbol = s;
    369 #endif
     349        char *symbol;
     350
     351        symbol = symtab_fmt_name_lookup(istate->epc);
    370352
    371353        fault_if_from_uspace(istate, "TLB Modified Exception on %p.",
    372354            cp0_badvaddr_read());
    373         panic("%x: TLB Modified Exception at %x(%s).", cp0_badvaddr_read(),
     355        panic("%x: TLB Modified Exception at %x (%s).", cp0_badvaddr_read(),
    374356            istate->epc, symbol);
    375357}
  • kernel/arch/ppc32/src/mm/tlb.c

    rb1c8dc0 re16e0d59  
    4141#include <print.h>
    4242#include <macros.h>
    43 
    44 #ifdef CONFIG_SYMTAB
    4543#include <symtab.h>
    46 #endif
    4744
    4845static unsigned int seed = 10;
     
    121118static void pht_refill_fail(uintptr_t badvaddr, istate_t *istate)
    122119{
    123         char *symbol = "";
    124         char *sym2 = "";
    125 
    126 #ifdef CONFIG_SYMTAB
    127         char *str = get_symtab_entry(istate->pc);
    128         if (str)
    129                 symbol = str;
    130         str = get_symtab_entry(istate->lr);
    131         if (str)
    132                 sym2 = str;
    133 #endif
     120        char *symbol;
     121        char *sym2;
     122
     123        symbol = symtab_fmt_name_lookup(istate->pc);
     124        sym2 = symtab_fmt_name_lookup(istate->lr);
    134125
    135126        fault_if_from_uspace(istate,
  • kernel/arch/sparc64/src/trap/exception.c

    rb1c8dc0 re16e0d59  
    4242#include <debug.h>
    4343#include <print.h>
    44 
    45 #ifdef CONFIG_SYMTAB
    4644#include <symtab.h>
    47 #endif
    4845
    4946void dump_istate(istate_t *istate)
     
    5148        char *tpcs, *tnpcs;
    5249
    53 #ifdef CONFIG_SYMTAB
    54         tpcs = get_symtab_entry(istate->tpc);
    55         tnpcs = get_symtab_entry(istate->tnpc);
    56 #else
    57         tpcs = tnpcs = "n/a";
    58 #endif
     50        tpcs = symtab_fmt_name_lookup(istate->tpc);
     51        tnpcs = symtab_fmt_name_lookup(istate->tnpc);
     52
    5953        printf("TSTATE=%#" PRIx64 "\n", istate->tstate);
    6054        printf("TPC=%#" PRIx64 " (%s)\n", istate->tpc, tpcs);
  • kernel/generic/include/symtab.h

    rb1c8dc0 re16e0d59  
    4545};
    4646
    47 extern char * get_symtab_entry(unative_t addr);
    48 extern uintptr_t get_symbol_addr(const char *name);
     47extern int symtab_name_lookup(unative_t addr, char **name);
     48extern char *symtab_fmt_name_lookup(unative_t addr);
     49extern int symtab_addr_lookup(const char *name, uintptr_t *addr);
    4950extern void symtab_print_search(const char *name);
    5051extern int symtab_compl(char *name);
     52
     53#ifdef CONFIG_SYMTAB
    5154
    5255/* Symtable linked together by build process */
     
    5558#endif
    5659
     60#endif
     61
    5762/** @}
    5863 */
  • kernel/generic/src/console/cmd.c

    rb1c8dc0 re16e0d59  
    6565#include <ipc/ipc.h>
    6666#include <ipc/irq.h>
    67 
    68 #ifdef CONFIG_SYMTAB
    6967#include <symtab.h>
    70 #endif
     68#include <errno.h>
    7169
    7270#ifdef CONFIG_TEST
     
    171169};
    172170
    173 #ifdef CONFIG_SYMTAB
    174171/* Data and methods for 'symaddr' command. */
    175172static int cmd_symaddr(cmd_arg_t *argv);
     
    187184        .argv = &symaddr_argv
    188185};
    189 #endif
    190186
    191187static char set_buf[MAX_CMDLINE+1];
     
    464460        &set4_info,
    465461        &slabs_info,
    466 #ifdef CONFIG_SYMTAB
    467462        &symaddr_info,
    468 #endif
    469463        &sched_info,
    470464        &threads_info,
     
    613607}
    614608
    615 #ifdef CONFIG_SYMTAB
    616 
    617609/** Search symbol table */
    618610int cmd_symaddr(cmd_arg_t *argv)
     
    623615}
    624616
    625 #endif
    626 
    627617/** Call function with zero parameters */
    628618int cmd_call0(cmd_arg_t *argv)
    629619{
    630 #ifdef CONFIG_SYMTAB
    631620        uintptr_t symaddr;
     621        char *symbol;
    632622        unative_t (*fnc)(void);
    633623        fncptr_t fptr;
    634 
    635         symaddr = get_symbol_addr((char *) argv->buffer);
    636         if (!symaddr)
    637                 printf("Symbol %s not found.\n", argv->buffer);
    638         else if (symaddr == (uintptr_t) -1) {
    639                 symtab_print_search((char *) argv->buffer);
     624        int rc;
     625
     626        symbol = (char *) argv->buffer;
     627        rc = symtab_addr_lookup(symbol, &symaddr);
     628
     629        if (rc == ENOENT)
     630                printf("Symbol %s not found.\n", symbol);
     631        else if (rc == EOVERFLOW) {
     632                symtab_print_search(symbol);
    640633                printf("Duplicate symbol, be more specific.\n");
     634        } else if (rc == EOK) {
     635                fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
     636                    (void *) symaddr, (void *) cmd_call0);
     637                printf("Calling %s() (%p)\n", symbol, symaddr);
     638                printf("Result: %#" PRIxn "\n", fnc());
    641639        } else {
    642                 fnc = (unative_t (*)(void)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call0);
    643                 printf("Calling %s() (%p)\n", argv->buffer, symaddr);
    644                 printf("Result: %#" PRIxn "\n", fnc());
    645         }
    646 #endif
     640                printf("No symbol information available.\n");
     641        }
    647642        return 1;
    648643}
     
    680675int cmd_call1(cmd_arg_t *argv)
    681676{
    682 #ifdef CONFIG_SYMTAB
    683677        uintptr_t symaddr;
    684678        char *symbol;
     
    686680        unative_t arg1 = argv[1].intval;
    687681        fncptr_t fptr;
    688        
    689         symaddr = get_symbol_addr((char *) argv->buffer);
    690 
    691         if (!symaddr)
    692                 printf("Symbol %s not found.\n", argv->buffer);
    693         else if (symaddr == (uintptr_t) -1) {
    694                 symtab_print_search((char *) argv->buffer);
     682        int rc;
     683
     684        symbol = (char *) argv->buffer;
     685        rc = symtab_addr_lookup(symbol, &symaddr);
     686
     687        if (rc == ENOENT) {
     688                printf("Symbol %s not found.\n", symbol);
     689        } else if (rc == EOVERFLOW) {
     690                symtab_print_search(symbol);
    695691                printf("Duplicate symbol, be more specific.\n");
    696         } else {
    697                 symbol = get_symtab_entry(symaddr);
     692        } else if (rc == EOK) {
    698693                fnc = (unative_t (*)(unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call1);
    699694                printf("Calling f(%#" PRIxn "): %p: %s\n", arg1, symaddr, symbol);
    700695                printf("Result: %#" PRIxn "\n", fnc(arg1));
    701         }
    702 #endif
     696        } else {
     697                printf("No symbol information available.\n");
     698        }
     699
    703700        return 1;
    704701}
     
    707704int cmd_call2(cmd_arg_t *argv)
    708705{
    709 #ifdef CONFIG_SYMTAB
    710706        uintptr_t symaddr;
    711707        char *symbol;
     
    714710        unative_t arg2 = argv[2].intval;
    715711        fncptr_t fptr;
    716        
    717         symaddr = get_symbol_addr((char *) argv->buffer);
    718         if (!symaddr)
    719                 printf("Symbol %s not found.\n", argv->buffer);
    720         else if (symaddr == (uintptr_t) -1) {
    721                 symtab_print_search((char *) argv->buffer);
     712        int rc;
     713
     714        symbol = (char *) argv->buffer;
     715        rc = symtab_addr_lookup(symbol, &symaddr);
     716
     717        if (rc == ENOENT) {
     718                printf("Symbol %s not found.\n", symbol);
     719        } else if (rc == EOVERFLOW) {
     720                symtab_print_search(symbol);
    722721                printf("Duplicate symbol, be more specific.\n");
    723         } else {
    724                 symbol = get_symtab_entry(symaddr);
     722        } else if (rc == EOK) {
    725723                fnc = (unative_t (*)(unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call2);
    726724                printf("Calling f(%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    727725                       arg1, arg2, symaddr, symbol);
    728726                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2));
    729         }       
    730 #endif
     727        } else {
     728                printf("No symbol information available.\n");
     729        }
    731730        return 1;
    732731}
     
    735734int cmd_call3(cmd_arg_t *argv)
    736735{
    737 #ifdef CONFIG_SYMTAB
    738736        uintptr_t symaddr;
    739737        char *symbol;
     
    743741        unative_t arg3 = argv[3].intval;
    744742        fncptr_t fptr;
    745        
    746         symaddr = get_symbol_addr((char *) argv->buffer);
    747         if (!symaddr)
    748                 printf("Symbol %s not found.\n", argv->buffer);
    749         else if (symaddr == (uintptr_t) -1) {
    750                 symtab_print_search((char *) argv->buffer);
     743        int rc;
     744       
     745        symbol = (char *) argv->buffer;
     746        rc = symtab_addr_lookup(symbol, &symaddr);
     747
     748        if (rc == ENOENT) {
     749                printf("Symbol %s not found.\n", symbol);
     750        } else if (rc == EOVERFLOW) {
     751                symtab_print_search(symbol);
    751752                printf("Duplicate symbol, be more specific.\n");
    752         } else {
    753                 symbol = get_symtab_entry(symaddr);
     753        } else if (rc == EOK) {
    754754                fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...)) arch_construct_function(&fptr, (void *) symaddr, (void *) cmd_call3);
    755755                printf("Calling f(%#" PRIxn ",%#" PRIxn ", %#" PRIxn "): %p: %s\n",
    756756                       arg1, arg2, arg3, symaddr, symbol);
    757757                printf("Result: %#" PRIxn "\n", fnc(arg1, arg2, arg3));
    758         }
    759 #endif
     758        } else {
     759                printf("No symbol information available.\n");
     760        }
    760761        return 1;
    761762}
     
    807808int cmd_set4(cmd_arg_t *argv)
    808809{
    809         uint32_t *addr;
     810        uintptr_t addr;
    810811        uint32_t arg1 = argv[1].intval;
    811812        bool pointer = false;
     813        int rc;
    812814
    813815        if (((char *)argv->buffer)[0] == '*') {
    814 #ifdef CONFIG_SYMTAB
    815                 addr = (uint32_t *) get_symbol_addr((char *) argv->buffer + 1);
    816 #else
    817                 addr = 0;
    818 #endif
     816                rc = symtab_addr_lookup((char *) argv->buffer + 1, &addr);
    819817                pointer = true;
    820818        } else if (((char *) argv->buffer)[0] >= '0' &&
    821819                   ((char *)argv->buffer)[0] <= '9') {
    822                 addr = (uint32_t *)atoi((char *)argv->buffer);
     820                rc = EOK;
     821                addr = atoi((char *)argv->buffer);
    823822        } else {
    824 #ifdef CONFIG_SYMTAB
    825                 addr = (uint32_t *)get_symbol_addr((char *) argv->buffer);
    826 #else
    827                 addr = 0;
    828 #endif
    829         }
    830 
    831         if (!addr)
     823                rc = symtab_addr_lookup((char *) argv->buffer, &addr);
     824        }
     825
     826        if (rc == ENOENT)
    832827                printf("Symbol %s not found.\n", argv->buffer);
    833         else if (addr == (uint32_t *) -1) {
    834 #ifdef CONFIG_SYMTAB
     828        else if (rc == EOVERFLOW) {
    835829                symtab_print_search((char *) argv->buffer);
    836 #endif
    837830                printf("Duplicate symbol, be more specific.\n");
     831        } else if (rc == EOK) {
     832                if (pointer)
     833                        addr = *(uintptr_t *) addr;
     834                printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
     835                *(uint32_t *) addr = arg1;
    838836        } else {
    839                 if (pointer)
    840                         addr = (uint32_t *)(*(unative_t *)addr);
    841                 printf("Writing %#" PRIx64 " -> %p\n", arg1, addr);
    842                 *addr = arg1;
    843                
     837                printf("No symbol information available.\n");
    844838        }
    845839       
  • kernel/generic/src/console/kconsole.c

    rb1c8dc0 re16e0d59  
    5454#include <sysinfo/sysinfo.h>
    5555#include <ddi/device.h>
    56 
    57 #ifdef CONFIG_SYMTAB
    5856#include <symtab.h>
    59 #endif
     57#include <errno.h>
    6058
    6159/** Simple kernel console.
     
    350348                                found = cmdtab_compl(tmp);
    351349                        } else { /* Symtab completion */
    352 #ifdef CONFIG_SYMTAB
    353350                                found = symtab_compl(tmp);
    354 #else
    355                                 found = 0;
    356 #endif
    357351                        }
    358352
     
    525519        bool isaddr = false;
    526520        bool isptr = false;
    527 
    528 #ifdef CONFIG_SYMTAB
     521        int rc;
     522
    529523        static char symname[MAX_SYMBOL_NAME];
    530 #endif
    531524       
    532525        /* If we get a name, try to find it in symbol table */
     
    541534        }
    542535        if (text[0] < '0' || text[0] > '9') {
    543 #ifdef CONFIG_SYMTAB
    544536                strncpy(symname, text, min(len + 1, MAX_SYMBOL_NAME));
    545                 symaddr = get_symbol_addr(symname);
    546                 if (!symaddr) {
     537                rc = symtab_addr_lookup(symname, &symaddr);
     538                switch (rc) {
     539                case ENOENT:
    547540                        printf("Symbol %s not found.\n", symname);
    548541                        return -1;
    549                 }
    550                 if (symaddr == (uintptr_t) -1) {
     542                case EOVERFLOW:
    551543                        printf("Duplicate symbol %s.\n", symname);
    552544                        symtab_print_search(symname);
    553545                        return -1;
    554                 }
    555 #else
    556                 symaddr = 0;
    557 #endif
     546                default:
     547                        printf("No symbol information available.\n");
     548                        return -1;
     549                }
     550
    558551                if (isaddr)
    559552                        *result = (unative_t)symaddr;
  • kernel/generic/src/debug/symtab.c

    rb1c8dc0 re16e0d59  
    4242#include <arch/types.h>
    4343#include <typedefs.h>
    44 
    45 /** Return entry that seems most likely to correspond to argument.
    46  *
    47  * Return entry that seems most likely to correspond
    48  * to address passed in the argument.
    49  *
    50  * @param addr Address.
    51  *
    52  * @return Pointer to respective symbol string on success, NULL otherwise.
    53  */
    54 char * get_symtab_entry(unative_t addr)
    55 {
     44#include <errno.h>
     45
     46/** Get name of symbol that seems most likely to correspond to address.
     47 *
     48 * @param addr  Address.
     49 * @param name  Place to store pointer to the symbol name.
     50 *
     51 * @return      Zero on success or negative error code, ENOENT if not found,
     52 *              ENOTSUP if symbol table not available.
     53 */
     54int symtab_name_lookup(unative_t addr, char **name)
     55{
     56#ifdef CONFIG_SYMTAB
    5657        count_t i;
    5758
     
    6061                        break;
    6162        }
    62         if (addr >= uint64_t_le2host(symbol_table[i - 1].address_le))
    63                 return symbol_table[i - 1].symbol_name;
    64         return NULL;
    65 }
     63        if (addr >= uint64_t_le2host(symbol_table[i - 1].address_le)) {
     64                *name = symbol_table[i - 1].symbol_name;
     65                return EOK;
     66        }
     67
     68        *name = NULL;
     69        return ENOENT;
     70#else
     71        *name = NULL;
     72        return ENOTSUP;
     73#endif
     74}
     75
     76/** Lookup symbol by address and format for display.
     77 *
     78 * Returns name of closest corresponding symbol, "Not found" if none exists
     79 * or "N/A" if no symbol information is available.
     80 *
     81 * @param addr  Address.
     82 * @param name  Place to store pointer to the symbol name.
     83 *
     84 * @return      Pointer to a human-readable string.
     85 */
     86char *symtab_fmt_name_lookup(unative_t addr)
     87{
     88        int rc;
     89        char *name;
     90
     91        rc = symtab_name_lookup(addr, &name);
     92        switch (rc) {
     93        case EOK: return name;
     94        case ENOENT: return "Not found";
     95        default: return "N/A";
     96        }
     97}
     98
     99#ifdef CONFIG_SYMTAB
    66100
    67101/** Find symbols that match the parameter forward and print them.
     
    103137}
    104138
     139#endif
     140
    105141/** Return address that corresponds to the entry
    106142 *
    107143 * Search symbol table, and if there is one match, return it
    108144 *
    109  * @param name Name of the symbol
    110  * @return 0 - Not found, -1 - Duplicate symbol, other - address of symbol
    111  */
    112 uintptr_t get_symbol_addr(const char *name)
    113 {
     145 * @param name  Name of the symbol
     146 * @param addr  Place to store symbol address
     147 *
     148 * @return      Zero on success, ENOENT - not found, EOVERFLOW - duplicate
     149 *              symbol, ENOTSUP - no symbol information available.
     150 */
     151int symtab_addr_lookup(const char *name, uintptr_t *addr)
     152{
     153#ifdef CONFIG_SYMTAB
    114154        count_t found = 0;
    115         uintptr_t addr = NULL;
    116155        char *hint;
    117156        int i;
     
    120159        while ((hint = symtab_search_one(name, &i))) {
    121160                if (!strlen(hint)) {
    122                         addr =  uint64_t_le2host(symbol_table[i].address_le);
     161                        *addr =  uint64_t_le2host(symbol_table[i].address_le);
    123162                        found++;
    124163                }
     
    126165        }
    127166        if (found > 1)
    128                 return ((uintptr_t) -1);
    129         return addr;
     167                return EOVERFLOW;
     168        if (found < 1)
     169                return ENOENT;
     170        return EOK;
     171#else
     172        return ENOTSUP;
     173#endif
    130174}
    131175
     
    133177void symtab_print_search(const char *name)
    134178{
     179#ifdef CONFIG_SYMTAB
    135180        int i;
    136181        uintptr_t addr;
     
    145190                i++;
    146191        }
     192#else
     193        printf("No symbol information available.\n");
     194#endif
    147195}
    148196
     
    154202int symtab_compl(char *input)
    155203{
     204#ifdef CONFIG_SYMTAB
    156205        char output[MAX_SYMBOL_NAME + 1];
    157206        int startpos = 0;
     
    197246        strncpy(input, output, MAX_SYMBOL_NAME);
    198247        return found;
    199        
     248#else
     249        return 0;
     250#endif
    200251}
    201252
  • kernel/generic/src/interrupt/interrupt.c

    rb1c8dc0 re16e0d59  
    4646#include <panic.h>
    4747#include <print.h>
    48 
    49 #ifdef CONFIG_SYMTAB
    5048#include <symtab.h>
    51 #endif
    5249
    5350static struct {
     
    134131       
    135132        for (i = 0; i < IVT_ITEMS; i++) {
    136 #ifdef CONFIG_SYMTAB
    137                 symbol = get_symtab_entry((unative_t) exc_table[i].f);
    138                 if (!symbol)
    139                         symbol = "not found";
    140 #else
    141                 symbol = "n/a";
    142 #endif
     133                symbol = symtab_fmt_name_lookup((unative_t) exc_table[i].f);
    143134
    144135#ifdef __32_BITS__
  • kernel/generic/src/synch/spinlock.c

    rb1c8dc0 re16e0d59  
    4343#include <print.h>
    4444#include <debug.h>
    45 
    46 #ifdef CONFIG_SYMTAB
    4745#include <symtab.h>
    48 #endif
    4946
    5047#ifdef CONFIG_FB
     
    8178        count_t i = 0;
    8279        bool deadlock_reported = false;
    83 #ifdef CONFIG_SYMTAB
    84         char *symbol;
    85 #endif
    8680
    8781        preemption_disable();
     
    112106#endif
    113107                if (i++ > DEADLOCK_THRESHOLD) {
    114                         printf("cpu%u: looping on spinlock %" PRIp ":%s, caller=%" PRIp,
    115                                 CPU->id, sl, sl->name, CALLER);
    116 #ifdef CONFIG_SYMTAB
    117                         symbol = get_symtab_entry(CALLER);
    118                         if (symbol)
    119                                 printf("(%s)", symbol);
    120 #endif
    121                         printf("\n");
     108                        printf("cpu%u: looping on spinlock %" PRIp ":%s, "
     109                            "caller=%" PRIp "(%s)", CPU->id, sl, sl->name,
     110                            CALLER, symtab_fmt_name_lookup(CALLER));
     111
    122112                        i = 0;
    123113                        deadlock_reported = true;
Note: See TracChangeset for help on using the changeset viewer.