rom/debug/unregistermodule.c

   1 /*
   2     Copyright © 1995-2013, 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             mod = FindModule(segList, DebugBase);
  71
  72         if (mod)
  73         {
  74             if (rangestart == -1) /* Search for new index */
  75                 i = rangestart = FindIndex(mod, segList);
  76
  77             /* Optimization assumes order of segments is similar to order of DOS segments */
  78             if ((i >= mod->m_segcnt) || (mod->m_segments[i]->s_seg != segList))
  79             {
  80                 /* Order broken, clear ordered segments */
  81                 RemoveSegmentRange(mod, rangestart, (i - rangestart));
  82
  83                 /* Restart */
  84                 i = rangestart = FindIndex(mod, segList);
  85             }
  86
  87             i++;
  88         }
  89
  90         /* Advance to next DOS segment */
  91         segList = *(BPTR *)BADDR(segList);
  92     }
  93
  94     if (mod != NULL && rangestart > -1)
  95         RemoveSegmentRange(mod, rangestart, (i - rangestart));
  96
  97     ReleaseSemaphore(&DBGBASE(DebugBase)->db_ModSem);
  98
  99     AROS_LIBFUNC_EXIT
 100 }
 101
 102 static module_t * FindModule(BPTR segList, struct Library * DebugBase)
 103 {
 104     struct DebugBase *debugBase = DBGBASE(DebugBase);
 105     module_t *mod;
 106     LONG i;
 107
 108     ForeachNode(&debugBase->db_Modules, mod)
 109     {
 110        for (i = 0; i < mod->m_segcnt; i++)
 111        {
 112            if (mod->m_segments[i]->s_seg == segList)
 113            {
 114                return mod;
 115            }
 116        }
 117     }
 118
 119     return NULL;
 120 }
 121
 122 static LONG FindIndex(module_t * mod, BPTR segList)
 123 {
 124     LONG i;
 125
 126     for (i = 0; i < mod->m_segcnt; i++)
 127     {
 128         if (mod->m_segments[i]->s_seg == segList)
 129         {
 130             return i;
 131         }
 132     }
 133
 134     return -1;
 135 }
 136
 137 static VOID RemoveSegmentRange(module_t * mod, LONG firstidx, LONG count)
 138 {
 139     struct segment * seg;
 140     LONG i;
 141
 142     for (i = 0 ; i < count ; i++)
 143     {
 144         seg = mod->m_segments[i + firstidx];
 145
 146         FreeMem(seg, sizeof(struct segment));
 147
 148         /* If module's segment count reached 0, remove the whole
 149            module information */
 150         if (--mod->m_segcnt == 0)
 151         {
 152             D(bug("[Debug] Removing module %s\n", mod->m_name));
 153
 154             /* Free associated symbols */
 155             if (mod->m_symbols) {
 156                 D(bug("[Debug] Removing symbol table 0x%p\n", mod->m_symbols));
 157                 FreeVec(mod->m_symbols);
 158             }
 159
 160             /* Free associated string tables */
 161             if (mod->m_str) {
 162                 D(bug("[Debug] Removing symbol name table 0x%p\n", mod->m_str));
 163                 FreeVec(mod->m_str);
 164             }
 165             if (mod->m_shstr) {
 166                 D(bug("[Debug] Removing section name table 0x%p\n", mod->m_str));
 167                 FreeVec(mod->m_shstr);
 168             }
 169
 170             Remove((struct Node *)mod);
 171             FreeVec(mod->m_segments);
 172 #if AROS_MODULES_DEBUG
 173             FreeVec(mod->m_seggdbhlp);
 174 #endif
 175             /* Free module descriptor at last */
 176             FreeVec(mod);
 177
 178             return;
 179         }
 180     }
 181
 182     /* "Shrink" array of segments so that at any given time the array is valid for
 183      * binary search
 184      */
 185     for (i = firstidx;i < mod->m_segcnt; i++)
 186         mod->m_segments[i] = mod->m_segments[i + count];
 187
 188 }