elf/dl-fini.c

   1 /* Call the termination functions of loaded shared objects.
   2    Copyright (C) 1995-2017 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 _dl_fini (void)
 129 {
 130   /* Lots of fun ahead.  We have to call the destructors for all still
 131      loaded objects, in all namespaces.  The problem is that the ELF
 132      specification now demands that dependencies between the modules
 133      are taken into account.  I.e., the destructor for a module is
 134      called before the ones for any of its dependencies.
 135
 136      To make things more complicated, we cannot simply use the reverse
 137      order of the constructors.  Since the user might have loaded objects
 138      using `dlopen' there are possibly several other modules with its
 139      dependencies to be taken into account.  Therefore we have to start
 140      determining the order of the modules once again from the beginning.  */
 141
 142   /* We run the destructors of the main namespaces last.  As for the
 143      other namespaces, we pick run the destructors in them in reverse
 144      order of the namespace ID.  */
 145 #ifdef SHARED
 146   int do_audit = 0;
 147  again:
 148 #endif
 149   for (Lmid_t ns = GL(dl_nns) - 1; ns >= 0; --ns)
 150     {
 151       /* Protect against concurrent loads and unloads.  */
 152       __rtld_lock_lock_recursive (GL(dl_load_lock));
 153
 154       unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
 155       /* No need to do anything for empty namespaces or those used for
 156          auditing DSOs.  */
 157       if (nloaded == 0
 158 #ifdef SHARED
 159           || GL(dl_ns)[ns]._ns_loaded->l_auditing != do_audit
 160 #endif
 161           )
 162         __rtld_lock_unlock_recursive (GL(dl_load_lock));
 163       else
 164         {
 165           /* Now we can allocate an array to hold all the pointers and
 166              copy the pointers in.  */
 167           struct link_map *maps[nloaded];
 168
 169           unsigned int i;
 170           struct link_map *l;
 171           assert (nloaded != 0 || GL(dl_ns)[ns]._ns_loaded == NULL);
 172           for (l = GL(dl_ns)[ns]._ns_loaded, i = 0; l != NULL; l = l->l_next)
 173             /* Do not handle ld.so in secondary namespaces.  */
 174             if (l == l->l_real)
 175               {
 176                 assert (i < nloaded);
 177
 178                 maps[i] = l;
 179                 l->l_idx = i;
 180                 ++i;
 181
 182                 /* Bump l_direct_opencount of all objects so that they
 183                    are not dlclose()ed from underneath us.  */
 184                 ++l->l_direct_opencount;
 185               }
 186           assert (ns != LM_ID_BASE || i == nloaded);
 187           assert (ns == LM_ID_BASE || i == nloaded || i == nloaded - 1);
 188           unsigned int nmaps = i;
 189
 190           /* Now we have to do the sorting.  */
 191           _dl_sort_fini (maps, nmaps, NULL, ns);
 192
 193           /* We do not rely on the linked list of loaded object anymore
 194              from this point on.  We have our own list here (maps).  The
 195              various members of this list cannot vanish since the open
 196              count is too high and will be decremented in this loop.  So
 197              we release the lock so that some code which might be called
 198              from a destructor can directly or indirectly access the
 199              lock.  */
 200           __rtld_lock_unlock_recursive (GL(dl_load_lock));
 201
 202           /* 'maps' now contains the objects in the right order.  Now
 203              call the destructors.  We have to process this array from
 204              the front.  */
 205           for (i = 0; i < nmaps; ++i)
 206             {
 207               struct link_map *l = maps[i];
 208
 209               if (l->l_init_called)
 210                 {
 211                   /* Make sure nothing happens if we are called twice.  */
 212                   l->l_init_called = 0;
 213
 214                   /* Is there a destructor function?  */
 215                   if (l->l_info[DT_FINI_ARRAY] != NULL
 216                       || l->l_info[DT_FINI] != NULL)
 217                     {
 218                       /* When debugging print a message first.  */
 219                       if (__builtin_expect (GLRO(dl_debug_mask)
 220                                             & DL_DEBUG_IMPCALLS, 0))
 221                         _dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
 222                                           DSO_FILENAME (l->l_name),
 223                                           ns);
 224
 225                       /* First see whether an array is given.  */
 226                       if (l->l_info[DT_FINI_ARRAY] != NULL)
 227                         {
 228                           ElfW(Addr) *array =
 229                             (ElfW(Addr) *) (l->l_addr
 230                                             + l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
 231                           unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
 232                                             / sizeof (ElfW(Addr)));
 233                           while (i-- > 0)
 234                             ((fini_t) array[i]) ();
 235                         }
 236
 237                       /* Next try the old-style destructor.  */
 238                       if (l->l_info[DT_FINI] != NULL)
 239                         DL_CALL_DT_FINI
 240                           (l, l->l_addr + l->l_info[DT_FINI]->d_un.d_ptr);
 241                     }
 242
 243 #ifdef SHARED
 244                   /* Auditing checkpoint: another object closed.  */
 245                   if (!do_audit && __builtin_expect (GLRO(dl_naudit) > 0, 0))
 246                     {
 247                       struct audit_ifaces *afct = GLRO(dl_audit);
 248                       for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 249                         {
 250                           if (afct->objclose != NULL)
 251                             /* Return value is ignored.  */
 252                             (void) afct->objclose (&l->l_audit[cnt].cookie);
 253
 254                           afct = afct->next;
 255                         }
 256                     }
 257 #endif
 258                 }
 259
 260               /* Correct the previous increment.  */
 261               --l->l_direct_opencount;
 262             }
 263         }
 264     }
 265
 266 #ifdef SHARED
 267   if (! do_audit && GLRO(dl_naudit) > 0)
 268     {
 269       do_audit = 1;
 270       goto again;
 271     }
 272
 273   if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
 274     _dl_debug_printf ("\nruntime linker statistics:\n"
 275                       "           final number of relocations: %lu\n"
 276                       "final number of relocations from cache: %lu\n",
 277                       GL(dl_num_relocations),
 278                       GL(dl_num_cache_relocations));
 279 #endif
 280 }