elf/dl-fini.c

   1 /* Call the termination functions of loaded shared objects.
   2    Copyright (C) 1995-2014 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <alloca.h>
  20 #include <assert.h>
  21 #include <string.h>
  22 #include <ldsodefs.h>
  23
  24
  25 /* Type of the constructor functions.  */
  26 typedef void (*fini_t) (void);
  27
  28
  29 void
  30 internal_function
  31 _dl_sort_fini (struct link_map **maps, size_t nmaps, char *used, Lmid_t ns)
  32 {
  33   /* A list of one element need not be sorted.  */
  34   if (nmaps == 1)
  35     return;
  36
  37   /* We can skip looking for the binary itself which is at the front
  38      of the search list for the main namespace.  */
  39   unsigned int i = ns == LM_ID_BASE;
  40   uint16_t seen[nmaps];
  41   memset (seen, 0, nmaps * sizeof (seen[0]));
  42   while (1)
  43     {
  44       /* Keep track of which object we looked at this round.  */
  45       ++seen[i];
  46       struct link_map *thisp = maps[i];
  47
  48       /* Do not handle ld.so in secondary namespaces and object which
  49          are not removed.  */
  50       if (thisp != thisp->l_real || thisp->l_idx == -1)
  51         goto skip;
  52
  53       /* Find the last object in the list for which the current one is
  54          a dependency and move the current object behind the object
  55          with the dependency.  */
  56       unsigned int k = nmaps - 1;
  57       while (k > i)
  58         {
  59           struct link_map **runp = maps[k]->l_initfini;
  60           if (runp != NULL)
  61             /* Look through the dependencies of the object.  */
  62             while (*runp != NULL)
  63               if (__glibc_unlikely (*runp++ == thisp))
  64                 {
  65                 move:
  66                   /* Move the current object to the back past the last
  67                      object with it as the dependency.  */
  68                   memmove (&maps[i], &maps[i + 1],
  69                            (k - i) * sizeof (maps[0]));
  70                   maps[k] = thisp;
  71
  72                   if (used != NULL)
  73                     {
  74                       char here_used = used[i];
  75                       memmove (&used[i], &used[i + 1],
  76                                (k - i) * sizeof (used[0]));
  77                       used[k] = here_used;
  78                     }
  79
  80                   if (seen[i + 1] > nmaps - i)
  81                     {
  82                       ++i;
  83                       goto next_clear;
  84                     }
  85
  86                   uint16_t this_seen = seen[i];
  87                   memmove (&seen[i], &seen[i + 1], (k - i) * sizeof (seen[0]));
  88                   seen[k] = this_seen;
  89
  90                   goto next;
  91                 }
  92
  93           if (__glibc_unlikely (maps[k]->l_reldeps != NULL))
  94             {
  95               unsigned int m = maps[k]->l_reldeps->act;
  96               struct link_map **relmaps = &maps[k]->l_reldeps->list[0];
  97
  98               /* Look through the relocation dependencies of the object.  */
  99               while (m-- > 0)
 100                 if (__glibc_unlikely (relmaps[m] == thisp))
 101                   {
 102                     /* If a cycle exists with a link time dependency,
 103                        preserve the latter.  */
 104                     struct link_map **runp = thisp->l_initfini;
 105                     if (runp != NULL)
 106                       while (*runp != NULL)
 107                         if (__glibc_unlikely (*runp++ == maps[k]))
 108                           goto ignore;
 109                     goto move;
 110                   }
 111             ignore:;
 112             }
 113
 114           --k;
 115         }
 116
 117     skip:
 118       if (++i == nmaps)
 119         break;
 120     next_clear:
 121       memset (&seen[i], 0, (nmaps - i) * sizeof (seen[0]));
 122
 123     next:;
 124     }
 125 }
 126
 127
 128 void
 129 internal_function
 130 _dl_fini (void)
 131 {
 132   /* Lots of fun ahead.  We have to call the destructors for all still
 133      loaded objects, in all namespaces.  The problem is that the ELF
 134      specification now demands that dependencies between the modules
 135      are taken into account.  I.e., the destructor for a module is
 136      called before the ones for any of its dependencies.
 137
 138      To make things more complicated, we cannot simply use the reverse
 139      order of the constructors.  Since the user might have loaded objects
 140      using `dlopen' there are possibly several other modules with its
 141      dependencies to be taken into account.  Therefore we have to start
 142      determining the order of the modules once again from the beginning.  */
 143   struct link_map **maps = NULL;
 144   size_t maps_size = 0;
 145
 146   /* We run the destructors of the main namespaces last.  As for the
 147      other namespaces, we pick run the destructors in them in reverse
 148      order of the namespace ID.  */
 149 #ifdef SHARED
 150   int do_audit = 0;
 151  again:
 152 #endif
 153   for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns)
 154     {
 155       /* Protect against concurrent loads and unloads.  */
 156       __rtld_lock_lock_recursive (GL(dl_load_lock));
 157
 158       unsigned int nmaps = 0;
 159       unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
 160       /* No need to do anything for empty namespaces or those used for
 161          auditing DSOs.  */
 162       if (nloaded == 0
 163 #ifdef SHARED
 164           || GL(dl_ns)[ns]._ns_loaded->l_auditing != do_audit
 165 #endif
 166           )
 167         goto out;
 168
 169       /* XXX Could it be (in static binaries) that there is no object
 170          loaded?  */
 171       assert (ns != LM_ID_BASE || nloaded > 0);
 172
 173       /* Now we can allocate an array to hold all the pointers and copy
 174          the pointers in.  */
 175       if (maps_size < nloaded * sizeof (struct link_map *))
 176         {
 177           if (maps_size == 0)
 178             {
 179               maps_size = nloaded * sizeof (struct link_map *);
 180               maps = (struct link_map **) alloca (maps_size);
 181             }
 182           else
 183             maps = (struct link_map **)
 184               extend_alloca (maps, maps_size,
 185                              nloaded * sizeof (struct link_map *));
 186         }
 187
 188       unsigned int i;
 189       struct link_map *l;
 190       assert (nloaded != 0 || GL(dl_ns)[ns]._ns_loaded == NULL);
 191       for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next)
 192         /* Do not handle ld.so in secondary namespaces.  */
 193         if (l == l->l_real)
 194           {
 195             assert (i < nloaded);
 196
 197             maps[i] = l;
 198             l->l_idx = i;
 199             ++i;
 200
 201             /* Bump l_direct_opencount of all objects so that they are
 202                not dlclose()ed from underneath us.  */
 203             ++l->l_direct_opencount;
 204           }
 205       assert (ns != LM_ID_BASE || i == nloaded);
 206       assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
 207       nmaps = i;
 208
 209       /* Now we have to do the sorting.  */
 210       _dl_sort_fini (maps, nmaps, NULL, ns);
 211
 212       /* We do not rely on the linked list of loaded object anymore from
 213          this point on.  We have our own list here (maps).  The various
 214          members of this list cannot vanish since the open count is too
 215          high and will be decremented in this loop.  So we release the
 216          lock so that some code which might be called from a destructor
 217          can directly or indirectly access the lock.  */
 218     out:
 219       __rtld_lock_unlock_recursive (GL(dl_load_lock));
 220
 221       /* 'maps' now contains the objects in the right order.  Now call the
 222          destructors.  We have to process this array from the front.  */
 223       for (i = 0; i < nmaps; ++i)
 224         {
 225           l = maps[i];
 226
 227           if (l->l_init_called)
 228             {
 229               /* Make sure nothing happens if we are called twice.  */
 230               l->l_init_called = 0;
 231
 232               /* Is there a destructor function?  */
 233               if (l->l_info[DT_FINI_ARRAY] != NULL
 234                   || l->l_info[DT_FINI] != NULL)
 235                 {
 236                   /* When debugging print a message first.  */
 237                   if (__builtin_expect (GLRO(dl_debug_mask)
 238                                         & DL_DEBUG_IMPCALLS, 0))
 239                     _dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
 240                                       DSO_FILENAME (l->l_name),
 241                                       ns);
 242
 243                   /* First see whether an array is given.  */
 244                   if (l->l_info[DT_FINI_ARRAY] != NULL)
 245                     {
 246                       ElfW(Addr) *array =
 247                         (ElfW(Addr) *) (l->l_addr
 248                                         + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
 249                       unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
 250                                         / sizeof (ElfW(Addr)));
 251                       while (i-- > 0)
 252                         ((fini_t) array[i]) ();
 253                     }
 254
 255                   /* Next try the old-style destructor.  */
 256                   if (l->l_info[DT_FINI] != NULL)
 257                      DL_CALL_DT_FINI(l, l->l_addr + l->l_info[DT_FINI]->d_un.d_ptr);
 258                 }
 259
 260 #ifdef SHARED
 261               /* Auditing checkpoint: another object closed.  */
 262               if (!do_audit && __builtin_expect (GLRO(dl_naudit) > 0, 0))
 263                 {
 264                   struct audit_ifaces *afct = GLRO(dl_audit);
 265                   for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 266                     {
 267                       if (afct->objclose != NULL)
 268                         /* Return value is ignored.  */
 269                         (void) afct->objclose (&l->l_audit[cnt].cookie);
 270
 271                       afct = afct->next;
 272                     }
 273                 }
 274 #endif
 275             }
 276
 277           /* Correct the previous increment.  */
 278           --l->l_direct_opencount;
 279         }
 280     }
 281
 282 #ifdef SHARED
 283   if (! do_audit && GLRO(dl_naudit) > 0)
 284     {
 285       do_audit = 1;
 286       goto again;
 287     }
 288
 289   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
 290     _dl_debug_printf ("\nruntime linker statistics:\n"
 291                       "           final number of relocations: %lu\n"
 292                       "final number of relocations from cache: %lu\n",
 293                       GL(dl_num_relocations),
 294                       GL(dl_num_cache_relocations));
 295 #endif
 296 }