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: }