elf/dl-fini.c

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