rom/debug/enumeratesymbolsa.c

   1 /*
   2     Copyright © 2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7  */
   8
   9 #include <libraries/debug.h>
  10 #include <proto/kernel.h>
  11 #include <proto/exec.h>
  12 #include <aros/debug.h>
  13
  14 #include "debug_intern.h"
  15
  16 static void EnumerateLoadedModules(struct Hook * handler, struct Library * DebugBase);
  17 static void EnumerateKickstartModules(struct Hook * handler, struct Library * DebugBase);
  18
  19 /*****************************************************************************
  20
  21     NAME */
  22 #include <proto/debug.h>
  23
  24         AROS_LH2(void, EnumerateSymbolsA,
  25
  26 /*  SYNOPSIS */
  27         AROS_LHA(struct Hook *, handler, A0),
  28         AROS_LHA(struct TagItem *, tags, A1),
  29
  30 /*  LOCATION */
  31         struct Library *, DebugBase, 8, Debug)
  32
  33 /*  FUNCTION
  34     Function will call the handler hook for all symbols from kickstart and
  35     loaded modules that match the given search criteria.
  36
  37     The message that is passed to hook contains a pointer to struct SymbolInfo.
  38
  39     INPUTS
  40
  41     RESULT
  42
  43     NOTES
  44
  45     EXAMPLE
  46
  47     BUGS
  48
  49     SEE ALSO
  50
  51     INTERNALS
  52
  53 ******************************************************************************/
  54 {
  55     AROS_LIBFUNC_INIT
  56
  57     BOOL super;
  58
  59     EnumerateKickstartModules(handler, DebugBase);
  60
  61     /* We can be called in supervisor mode. No semaphores in the case! */
  62     super = KrnIsSuper();
  63     if (!super)
  64         ObtainSemaphoreShared(&DBGBASE(DebugBase)->db_ModSem);
  65
  66     EnumerateLoadedModules(handler, DebugBase);
  67
  68     if (!super)
  69         ReleaseSemaphore(&DBGBASE(DebugBase)->db_ModSem);
  70
  71     AROS_LIBFUNC_EXIT
  72 }
  73
  74 static inline void callhook(struct Hook * handler, CONST_STRPTR modname, CONST_STRPTR symname,
  75         APTR start, APTR end)
  76 {
  77     struct SymbolInfo sinfo = {0};
  78
  79     sinfo.si_Size           = sizeof(struct SymbolInfo);
  80     sinfo.si_ModuleName     = modname;
  81     sinfo.si_SymbolName     = symname;
  82     sinfo.si_SymbolStart    = start;
  83     sinfo.si_SymbolEnd      = end;
  84
  85     CALLHOOKPKT(handler, NULL, &sinfo);
  86 }
  87
  88 static void EnumerateLoadedModules(struct Hook * handler, struct Library * DebugBase)
  89 {
  90     module_t *mod;
  91
  92     ForeachNode(&DBGBASE(DebugBase)->db_LoadedModules, mod)
  93     {
  94         dbg_sym_t *sym = mod->m_symbols;
  95         ULONG i;
  96
  97         D(bug("[Debug] Checking module %s\n", mod->m_name));
  98
  99         for (i = 0; i < mod->m_symcnt; i++)
 100         {
 101             APTR highest = sym[i].s_highest;
 102
 103             /* Symbols with zero length have zero in s_highest */
 104             if (!highest)
 105                 highest = sym[i].s_lowest;
 106
 107             callhook(handler, mod->m_name, sym[i].s_name, sym[i].s_lowest, sym[i].s_highest);
 108         }
 109     }
 110 }
 111
 112 static void EnumerateKickstartModules(struct Hook * handler, struct Library * DebugBase)
 113 {
 114     struct ELF_ModuleInfo *kmod;
 115     for (kmod = DBGBASE(DebugBase)->db_KernelModules; kmod; kmod = kmod->Next)
 116     {
 117         /* We understand only ELF here */
 118         if (kmod->Type == DEBUG_ELF)
 119         {
 120             struct elfheader *eh = kmod->eh;
 121             struct sheader *sections = kmod->sh;
 122             ULONG int_shnum = eh->shnum;
 123             ULONG int_shstrndx = eh->shstrndx;
 124             ULONG shstr;
 125             ULONG i;
 126
 127             /* Get wider versions of shnum and shstrndx from first section header if needed */
 128             if (int_shnum == 0)
 129                 int_shnum = sections[0].size;
 130             if (int_shstrndx == SHN_XINDEX)
 131                 int_shstrndx = sections[0].link;
 132
 133             shstr = SHINDEX(int_shstrndx);
 134
 135             for (i = 0; i < int_shnum; i++)
 136             {
 137                 APTR s_lowest = sections[i].addr;
 138
 139                 /* Ignore all empty segments */
 140                 if (s_lowest && sections[i].size)
 141                 {
 142                     struct symbol *st = (struct symbol *) sections[i].addr;
 143                     ULONG symcnt = sections[i].size / sizeof(struct symbol);
 144                     ULONG j, z;
 145                     STRPTR m_str = NULL;
 146
 147                     /* Find symbols name table */
 148                     for (z = 0; z < int_shnum; z++)
 149                     {
 150                         if ((sections[z].type == SHT_STRTAB) && (z != shstr))
 151                         {
 152                             m_str = sections[z].addr;
 153                         }
 154                     }
 155
 156                     if (!(sections[i].addr && sections[i].type == SHT_SYMTAB))
 157                         continue;
 158
 159                     for (j = 0; j < symcnt; j++)
 160                     {
 161                         LONG idx = st[j].shindex;
 162                         APTR s_lowest, s_highest;
 163                         STRPTR s_name;
 164
 165                         /* Ignore these - they should not be here at all */
 166                         if ((idx == SHN_UNDEF) || (idx == SHN_COMMON))
 167                             continue;
 168                         /* TODO: perhaps XINDEX support is needed */
 169                         if (idx == SHN_XINDEX)
 170                             continue;
 171
 172                         s_name = (m_str) ? m_str + st[j].name : NULL;
 173
 174                         s_lowest = (APTR) st[j].value;
 175                         if (idx != SHN_ABS)
 176                             s_lowest += (IPTR) sections[idx].addr;
 177
 178                         if (st[j].size)
 179                             s_highest = s_lowest + st[j].size - 1;
 180                         else
 181                             s_highest = NULL;
 182
 183                         callhook(handler, kmod->Name, s_name, s_lowest, s_highest);
 184                     }
 185                 }
 186             }
 187         }
 188     }
 189 }