libelf/elf_end.c

   1 /* Free resources associated with Elf descriptor.
   2    Copyright (C) 1998,1999,2000,2001,2002,2004,2005,2007,2015 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 1998.
   5
   6    This file is free software; you can redistribute it and/or modify
   7    it under the terms of either
   8
   9      * the GNU Lesser General Public License as published by the Free
  10        Software Foundation; either version 3 of the License, or (at
  11        your option) any later version
  12
  13    or
  14
  15      * the GNU General Public License as published by the Free
  16        Software Foundation; either version 2 of the License, or (at
  17        your option) any later version
  18
  19    or both in parallel, as here.
  20
  21    elfutils is distributed in the hope that it will be useful, but
  22    WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24    General Public License for more details.
  25
  26    You should have received copies of the GNU General Public License and
  27    the GNU Lesser General Public License along with this program.  If
  28    not, see <http://www.gnu.org/licenses/>.  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include <config.h>
  32 #endif
  33
  34 #include <assert.h>
  35 #include <stddef.h>
  36 #include <stdlib.h>
  37 #include <sys/mman.h>
  38
  39 #include "libelfP.h"
  40
  41
  42 int
  43 elf_end (Elf *elf)
  44 {
  45   Elf *parent;
  46
  47   if (elf == NULL)
  48     /* This is allowed and is a no-op.  */
  49     return 0;
  50
  51   /* Make sure we are alone.  */
  52   rwlock_wrlock (elf->lock);
  53
  54   if (elf->ref_count != 0 && --elf->ref_count != 0)
  55     {
  56       /* Not yet the last activation.  */
  57       int result = elf->ref_count;
  58       rwlock_unlock (elf->lock);
  59       return result;
  60     }
  61
  62   if (elf->kind == ELF_K_AR)
  63     {
  64       /* We cannot remove the descriptor now since we still have some
  65          descriptors which depend on it.  But we can free the archive
  66          symbol table since this is only available via the archive ELF
  67          descriptor.  The long name table cannot be freed yet since
  68          the archive headers for the ELF files in the archive point
  69          into this array.  */
  70       if (elf->state.ar.ar_sym != (Elf_Arsym *) -1l)
  71         free (elf->state.ar.ar_sym);
  72       elf->state.ar.ar_sym = NULL;
  73
  74       if (elf->state.ar.children != NULL)
  75         return 0;
  76     }
  77
  78   /* Remove this structure from the children list.  */
  79   parent = elf->parent;
  80   if (parent != NULL)
  81     {
  82       /* This is tricky.  Lock must be acquire from the father to
  83          the child but here we already have the child lock.  We
  84          solve this problem by giving free the child lock.  The
  85          state of REF_COUNT==0 is handled all over the library, so
  86          this should be ok.  */
  87       rwlock_unlock (elf->lock);
  88       rwlock_rdlock (parent->lock);
  89       rwlock_wrlock (elf->lock);
  90
  91       if (parent->state.ar.children == elf)
  92         parent->state.ar.children = elf->next;
  93       else
  94         {
  95           struct Elf *child = parent->state.ar.children;
  96
  97           while (child->next != elf)
  98             child = child->next;
  99
 100           child->next = elf->next;
 101         }
 102
 103       rwlock_unlock (parent->lock);
 104     }
 105
 106   /* This was the last activation.  Free all resources.  */
 107   switch (elf->kind)
 108     {
 109     case ELF_K_AR:
 110       if (elf->state.ar.long_names != NULL)
 111         free (elf->state.ar.long_names);
 112       break;
 113
 114     case ELF_K_ELF:
 115       {
 116         Elf_Data_Chunk *rawchunks
 117           = (elf->class == ELFCLASS32
 118              || (offsetof (struct Elf, state.elf32.rawchunks)
 119                  == offsetof (struct Elf, state.elf64.rawchunks))
 120              ? elf->state.elf32.rawchunks
 121              : elf->state.elf64.rawchunks);
 122         while (rawchunks != NULL)
 123           {
 124             Elf_Data_Chunk *next = rawchunks->next;
 125             if (rawchunks->dummy_scn.flags & ELF_F_MALLOCED)
 126               free (rawchunks->data.d.d_buf);
 127             free (rawchunks);
 128             rawchunks = next;
 129           }
 130
 131         Elf_ScnList *list = (elf->class == ELFCLASS32
 132                              || (offsetof (struct Elf, state.elf32.scns)
 133                                  == offsetof (struct Elf, state.elf64.scns))
 134                              ? &elf->state.elf32.scns
 135                              : &elf->state.elf64.scns);
 136
 137         do
 138           {
 139             /* Free all separately allocated section headers.  */
 140             size_t cnt = list->max;
 141
 142             while (cnt-- > 0)
 143               {
 144                 /* These pointers can be NULL; it's safe to use
 145                    'free' since it will check for this.  */
 146                 Elf_Scn *scn = &list->data[cnt];
 147                 Elf_Data_List *runp;
 148
 149                 if ((scn->shdr_flags & ELF_F_MALLOCED) != 0)
 150                   /* It doesn't matter which pointer.  */
 151                   free (scn->shdr.e32);
 152
 153                 /* Free zdata if uncompressed, but not yet used as
 154                    rawdata_base.  If it is already used it will be
 155                    freed below.  */
 156                 if (scn->zdata_base != scn->rawdata_base)
 157                   free (scn->zdata_base);
 158
 159                 /* If the file has the same byte order and the
 160                    architecture doesn't require overly stringent
 161                    alignment the raw data buffer is the same as the
 162                    one used for presenting to the caller.  */
 163                 if (scn->data_base != scn->rawdata_base)
 164                   free (scn->data_base);
 165
 166                 /* The section data is allocated if we couldn't mmap
 167                    the file.  Or if we had to decompress.  */
 168                 if (elf->map_address == NULL
 169                     || scn->rawdata_base == scn->zdata_base)
 170                   free (scn->rawdata_base);
 171
 172                 /* Free the list of data buffers for the section.
 173                    We don't free the buffers themselves since this
 174                    is the users job.  */
 175                 runp = scn->data_list.next;
 176                 while (runp != NULL)
 177                   {
 178                     Elf_Data_List *oldp = runp;
 179                     runp = runp->next;
 180                     if ((oldp->flags & ELF_F_MALLOCED) != 0)
 181                       free (oldp);
 182                   }
 183               }
 184
 185             /* Free the memory for the array.  */
 186             Elf_ScnList *oldp = list;
 187             list = list->next;
 188             assert (list == NULL || oldp->cnt == oldp->max);
 189             if (oldp != (elf->class == ELFCLASS32
 190                          || (offsetof (struct Elf, state.elf32.scns)
 191                              == offsetof (struct Elf, state.elf64.scns))
 192                          ? &elf->state.elf32.scns
 193                          : &elf->state.elf64.scns))
 194               free (oldp);
 195           }
 196         while (list != NULL);
 197       }
 198
 199       /* Free the section header.  */
 200       if (elf->state.elf.shdr_malloced  != 0)
 201         free (elf->class == ELFCLASS32
 202               || (offsetof (struct Elf, state.elf32.shdr)
 203                   == offsetof (struct Elf, state.elf64.shdr))
 204               ? (void *) elf->state.elf32.shdr
 205               : (void *) elf->state.elf64.shdr);
 206
 207       /* Free the program header.  */
 208       if ((elf->state.elf.phdr_flags & ELF_F_MALLOCED) != 0)
 209         free (elf->class == ELFCLASS32
 210               || (offsetof (struct Elf, state.elf32.phdr)
 211                   == offsetof (struct Elf, state.elf64.phdr))
 212               ? (void *) elf->state.elf32.phdr
 213               : (void *) elf->state.elf64.phdr);
 214       break;
 215
 216     default:
 217       break;
 218     }
 219
 220   if (elf->map_address != NULL && parent == NULL)
 221     {
 222       /* The file was read or mapped for this descriptor.  */
 223       if ((elf->flags & ELF_F_MALLOCED) != 0)
 224         free (elf->map_address);
 225       else if ((elf->flags & ELF_F_MMAPPED) != 0)
 226         munmap (elf->map_address, elf->maximum_size);
 227     }
 228
 229   rwlock_unlock (elf->lock);
 230   rwlock_fini (elf->lock);
 231
 232   /* Finally the descriptor itself.  */
 233   free (elf);
 234
 235   return (parent != NULL && parent->ref_count == 0
 236           ? INTUSE(elf_end) (parent) : 0);
 237 }
 238 INTDEF(elf_end)