rom/debug/unregistermodule.c

   1 /*
   2     Copyright © 1995-2016, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6 */
   7
   8 #include <aros/debug.h>
   9 #include <aros/kernel.h>
  10 #include <aros/libcall.h>
  11 #include <exec/lists.h>
  12 #include <proto/exec.h>
  13
  14 #include <string.h>
  15
  16 #include "debug_intern.h"
  17
  18 static module_t * FindModule(BPTR segList, struct Library * DebugBase);
  19 static LONG FindIndex(module_t * mod, BPTR segList);
  20 static VOID RemoveSegmentRange(module_t * mod, LONG firstidx, LONG count);
  21
  22 /*****************************************************************************
  23
  24     NAME */
  25 #include <proto/debug.h>
  26
  27         AROS_LH1(void, UnregisterModule,
  28
  29 /*  SYNOPSIS */
  30         AROS_LHA(BPTR, segList, A0),
  31
  32 /*  LOCATION */
  33         struct Library *, DebugBase, 6, Debug)
  34
  35 /*  FUNCTION
  36         Remove previously registered module from the debug information database
  37
  38     INPUTS
  39         segList - DOS segment list for the module to remove
  40
  41     RESULT
  42         None
  43
  44     NOTES
  45         The function correctly supports partial removal of the module
  46         (when an existing seglist is broken and only a part of the module
  47         is unloaded).
  48
  49     EXAMPLE
  50
  51     BUGS
  52
  53     SEE ALSO
  54
  55     INTERNALS
  56
  57 ******************************************************************************/
  58 {
  59     AROS_LIBFUNC_INIT
  60
  61     module_t *mod = NULL;
  62     LONG i = 0, rangestart = -1;
  63
  64     D(bug("[Debug] UnregisterModule(0x%p)\n", segList));
  65     ObtainSemaphore(&DBGBASE(DebugBase)->db_ModSem);
  66
  67     while (segList)
  68     {
  69         if (mod == NULL) /* Search for new module */
  70         {
  71             D(bug("[Debug] Looking for module matching seglist %p\n", segList));
  72             mod = FindModule(segList, DebugBase);
  73             D(if (mod) bug("[Debug] Found module '%s'\n", mod->m_name);
  74             else bug("[Debug] No module found!\n"));
  75         }
  76
  77         if (mod)
  78         {
  79             if (rangestart == -1) /* Search for new index */
  80                 i = rangestart = FindIndex(mod, segList);
  81
  82             /* Optimization assumes order of segments is similar to order of DOS segments */
  83             if ((i >= mod->m_segcnt) || (mod->m_segments[i]->s_seg != segList))
  84             {
  85                 /* Order broken, clear ordered segments */
  86                 RemoveSegmentRange(mod, rangestart, (i - rangestart));
  87
  88                 /* Restart */
  89                 i = rangestart = FindIndex(mod, segList);
  90             }
  91
  92             i++;
  93         }
  94
  95         /* Advance to next DOS segment */
  96         segList = *(BPTR *)BADDR(segList);
  97     }
  98
  99     if (mod != NULL && rangestart > -1)
 100         RemoveSegmentRange(mod, rangestart, (i - rangestart));
 101
 102     ReleaseSemaphore(&DBGBASE(DebugBase)->db_ModSem);
 103
 104     AROS_LIBFUNC_EXIT
 105 }
 106
 107 static module_t * FindModule(BPTR segList, struct Library * DebugBase)
 108 {
 109     struct DebugBase *debugBase = DBGBASE(DebugBase);
 110     module_t *mod;
 111     LONG i;
 112
 113     ForeachNode(&debugBase->db_Modules, mod)
 114     {
 115        for (i = 0; i < mod->m_segcnt; i++)
 116        {
 117            if (mod->m_segments[i]->s_seg == segList)
 118            {
 119                return mod;
 120            }
 121        }
 122     }
 123
 124     return NULL;
 125 }
 126
 127 static LONG FindIndex(module_t * mod, BPTR segList)
 128 {
 129     LONG i;
 130
 131     for (i = 0; i < mod->m_segcnt; i++)
 132     {
 133         if (mod->m_segments[i]->s_seg == segList)
 134         {
 135             return i;
 136         }
 137     }
 138
 139     return -1;
 140 }
 141
 142 static VOID RemoveSegmentRange(module_t * mod, LONG firstidx, LONG count)
 143 {
 144     struct segment * seg;
 145     LONG i;
 146
 147     D(bug("[Debug] RemoveSegmentRange('%s', %ld, %ld)\n", mod->m_name,
 148         firstidx, count));
 149     for (i = 0 ; i < count ; i++)
 150     {
 151         seg = mod->m_segments[i + firstidx];
 152
 153         FreeMem(seg, sizeof(struct segment));
 154
 155         /* If module's segment count reached 0, remove the whole
 156            module information */
 157         if (--mod->m_segcnt == 0)
 158         {
 159             D(bug("[Debug] Removing module %s\n", mod->m_name));
 160
 161             /* Free associated symbols */
 162             if (mod->m_symbols) {
 163                 D(bug("[Debug] Removing symbol table 0x%p\n", mod->m_symbols));
 164                 FreeVec(mod->m_symbols);
 165             }
 166
 167             /* Free associated string tables */
 168             if (mod->m_str) {
 169                 D(bug("[Debug] Removing symbol name table 0x%p\n", mod->m_str));
 170                 FreeVec(mod->m_str);
 171             }
 172             if (mod->m_shstr) {
 173                 D(bug("[Debug] Removing section name table 0x%p\n", mod->m_str));
 174                 FreeVec(mod->m_shstr);
 175             }
 176
 177             Remove((struct Node *)mod);
 178             FreeVec(mod->m_segments);
 179 #if AROS_MODULES_DEBUG
 180             FreeVec(mod->m_seggdbhlp);
 181 #endif
 182             /* Free module descriptor at last */
 183             FreeVec(mod);
 184
 185             return;
 186         }
 187     }
 188
 189     /* "Shrink" array of segments so that at any given time the array is valid for
 190      * binary search
 191      */
 192     for (i = firstidx;i < mod->m_segcnt; i++)
 193         mod->m_segments[i] = mod->m_segments[i + count];
 194
 195 }