libdwfl/dwfl_module.c

   1 /* Maintenance of module list in libdwfl.
   2    Copyright (C) 2005, 2006, 2007, 2008 Red Hat, Inc.
   3    This file is part of Red Hat elfutils.
   4
   5    Red Hat elfutils is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; version 2 of the License.
   8
   9    Red Hat elfutils is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with Red Hat elfutils; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  17
  18    In addition, as a special exception, Red Hat, Inc. gives You the
  19    additional right to link the code of Red Hat elfutils with code licensed
  20    under any Open Source Initiative certified open source license
  21    (http://www.opensource.org/licenses/index.php) which requires the
  22    distribution of source code with any binary distribution and to
  23    distribute linked combinations of the two.  Non-GPL Code permitted under
  24    this exception must only link to the code of Red Hat elfutils through
  25    those well defined interfaces identified in the file named EXCEPTION
  26    found in the source code files (the "Approved Interfaces").  The files
  27    of Non-GPL Code may instantiate templates or use macros or inline
  28    functions from the Approved Interfaces without causing the resulting
  29    work to be covered by the GNU General Public License.  Only Red Hat,
  30    Inc. may make changes or additions to the list of Approved Interfaces.
  31    Red Hat's grant of this exception is conditioned upon your not adding
  32    any new exceptions.  If you wish to add a new Approved Interface or
  33    exception, please contact Red Hat.  You must obey the GNU General Public
  34    License in all respects for all of the Red Hat elfutils code and other
  35    code used in conjunction with Red Hat elfutils except the Non-GPL Code
  36    covered by this exception.  If you modify this file, you may extend this
  37    exception to your version of the file, but you are not obligated to do
  38    so.  If you do not wish to provide this exception without modification,
  39    you must delete this exception statement from your version and license
  40    this file solely under the GPL without exception.
  41
  42    Red Hat elfutils is an included package of the Open Invention Network.
  43    An included package of the Open Invention Network is a package for which
  44    Open Invention Network licensees cross-license their patents.  No patent
  45    license is granted, either expressly or impliedly, by designation as an
  46    included package.  Should you wish to participate in the Open Invention
  47    Network licensing program, please visit www.openinventionnetwork.com
  48    <http://www.openinventionnetwork.com>.  */
  49
  50 #include "libdwflP.h"
  51 #include <search.h>
  52 #include <unistd.h>
  53
  54 static void
  55 free_cu (struct dwfl_cu *cu)
  56 {
  57   if (cu->lines != NULL)
  58     free (cu->lines);
  59   free (cu);
  60 }
  61
  62 static void
  63 nofree (void *arg __attribute__ ((unused)))
  64 {
  65 }
  66
  67 static void
  68 free_file (struct dwfl_file *file)
  69 {
  70   free (file->name);
  71
  72   /* Close the fd only on the last reference.  */
  73   if (file->elf != NULL && elf_end (file->elf) == 0 && file->fd != -1)
  74     close (file->fd);
  75 }
  76
  77 void
  78 internal_function
  79 __libdwfl_module_free (Dwfl_Module *mod)
  80 {
  81   if (mod->lazy_cu_root != NULL)
  82     tdestroy (mod->lazy_cu_root, nofree);
  83
  84   if (mod->aranges != NULL)
  85     free (mod->aranges);
  86
  87   if (mod->cu != NULL)
  88     {
  89       for (size_t i = 0; i < mod->ncu; ++i)
  90         free_cu (mod->cu[i]);
  91       free (mod->cu);
  92     }
  93
  94   if (mod->dw != NULL)
  95     INTUSE(dwarf_end) (mod->dw);
  96
  97   if (mod->ebl != NULL)
  98     ebl_closebackend (mod->ebl);
  99
 100   if (mod->debug.elf != mod->main.elf)
 101     free_file (&mod->debug);
 102   free_file (&mod->main);
 103
 104   if (mod->build_id_bits != NULL)
 105     free (mod->build_id_bits);
 106
 107   free (mod->name);
 108   free (mod);
 109 }
 110
 111 void
 112 dwfl_report_begin_add (Dwfl *dwfl __attribute__ ((unused)))
 113 {
 114   /* The lookup table will be cleared on demand, there is nothing we need
 115      to do here.  */
 116 }
 117 INTDEF (dwfl_report_begin_add)
 118
 119 void
 120 dwfl_report_begin (Dwfl *dwfl)
 121 {
 122   /* Clear the segment lookup table.  */
 123   dwfl->lookup_elts = 0;
 124
 125   for (Dwfl_Module *m = dwfl->modulelist; m != NULL; m = m->next)
 126     m->gc = true;
 127
 128   dwfl->offline_next_address = OFFLINE_REDZONE;
 129 }
 130 INTDEF (dwfl_report_begin)
 131
 132 /* Report that a module called NAME spans addresses [START, END).
 133    Returns the module handle, either existing or newly allocated,
 134    or returns a null pointer for an allocation error.  */
 135 Dwfl_Module *
 136 dwfl_report_module (Dwfl *dwfl, const char *name,
 137                     GElf_Addr start, GElf_Addr end)
 138 {
 139   Dwfl_Module **tailp = &dwfl->modulelist, **prevp = tailp;
 140
 141   inline Dwfl_Module *use (Dwfl_Module *mod)
 142   {
 143     mod->next = *tailp;
 144     *tailp = mod;
 145
 146     if (unlikely (dwfl->lookup_module != NULL))
 147       {
 148         free (dwfl->lookup_module);
 149         dwfl->lookup_module = NULL;
 150       }
 151
 152     return mod;
 153   }
 154
 155   for (Dwfl_Module *m = *prevp; m != NULL; m = *(prevp = &m->next))
 156     {
 157       if (m->low_addr == start && m->high_addr == end
 158           && !strcmp (m->name, name))
 159         {
 160           /* This module is still here.  Move it to the place in the list
 161              after the last module already reported.  */
 162           *prevp = m->next;
 163           m->gc = false;
 164           return use (m);
 165         }
 166
 167       if (! m->gc)
 168         tailp = &m->next;
 169     }
 170
 171   Dwfl_Module *mod = calloc (1, sizeof *mod);
 172   if (mod == NULL)
 173     goto nomem;
 174
 175   mod->name = strdup (name);
 176   if (mod->name == NULL)
 177     {
 178       free (mod);
 179     nomem:
 180       __libdwfl_seterrno (DWFL_E_NOMEM);
 181       return NULL;
 182     }
 183
 184   mod->low_addr = start;
 185   mod->high_addr = end;
 186   mod->dwfl = dwfl;
 187
 188   return use (mod);
 189 }
 190 INTDEF (dwfl_report_module)
 191
 192
 193 /* Finish reporting the current set of modules to the library.
 194    If REMOVED is not null, it's called for each module that
 195    existed before but was not included in the current report.
 196    Returns a nonzero return value from the callback.
 197    DWFL cannot be used until this function has returned zero.  */
 198 int
 199 dwfl_report_end (Dwfl *dwfl,
 200                  int (*removed) (Dwfl_Module *, void *,
 201                                  const char *, Dwarf_Addr,
 202                                  void *arg),
 203                  void *arg)
 204 {
 205   Dwfl_Module **tailp = &dwfl->modulelist;
 206   while (*tailp != NULL)
 207     {
 208       Dwfl_Module *m = *tailp;
 209       if (m->gc && removed != NULL)
 210         {
 211           int result = (*removed) (MODCB_ARGS (m), arg);
 212           if (result != 0)
 213             return result;
 214         }
 215       if (m->gc)
 216         {
 217           *tailp = m->next;
 218           __libdwfl_module_free (m);
 219         }
 220       else
 221         tailp = &m->next;
 222     }
 223
 224   return 0;
 225 }
 226 INTDEF (dwfl_report_end)