elf/dl-fini.c

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