elf/dl-close.c

   1 /* Close a shared object opened by `_dl_open'.
   2    Copyright (C) 1996-2005, 2006 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 <assert.h>
  21 #include <dlfcn.h>
  22 #include <errno.h>
  23 #include <libintl.h>
  24 #include <stddef.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <bits/libc-lock.h>
  30 #include <ldsodefs.h>
  31 #include <sys/types.h>
  32 #include <sys/mman.h>
  33 #include <sysdep-cancel.h>
  34
  35
  36 /* Type of the constructor functions.  */
  37 typedef void (*fini_t) (void);
  38
  39
  40 /* Special l_idx value used to indicate which objects remain loaded.  */
  41 #define IDX_STILL_USED -1
  42
  43
  44 #ifdef USE_TLS
  45 /* Returns true we an non-empty was found.  */
  46 static bool
  47 remove_slotinfo (size_t idx, struct dtv_slotinfo_list *listp, size_t disp,
  48                  bool should_be_there)
  49 {
  50   if (idx - disp >= listp->len)
  51     {
  52       if (listp->next == NULL)
  53         {
  54           /* The index is not actually valid in the slotinfo list,
  55              because this object was closed before it was fully set
  56              up due to some error.  */
  57           assert (! should_be_there);
  58         }
  59       else
  60         {
  61           if (remove_slotinfo (idx, listp->next, disp + listp->len,
  62                                should_be_there))
  63             return true;
  64
  65           /* No non-empty entry.  Search from the end of this element's
  66              slotinfo array.  */
  67           idx = disp + listp->len;
  68         }
  69     }
  70   else
  71     {
  72       struct link_map *old_map = listp->slotinfo[idx - disp].map;
  73
  74       /* The entry might still be in its unused state if we are closing an
  75          object that wasn't fully set up.  */
  76       if (__builtin_expect (old_map != NULL, 1))
  77         {
  78           assert (old_map->l_tls_modid == idx);
  79
  80           /* Mark the entry as unused. */
  81           listp->slotinfo[idx - disp].gen = GL(dl_tls_generation) + 1;
  82           listp->slotinfo[idx - disp].map = NULL;
  83         }
  84
  85       /* If this is not the last currently used entry no need to look
  86          further.  */
  87       if (idx != GL(dl_tls_max_dtv_idx))
  88         return true;
  89     }
  90
  91   while (idx - disp > (disp == 0 ? 1 + GL(dl_tls_static_nelem) : 0))
  92     {
  93       --idx;
  94
  95       if (listp->slotinfo[idx - disp].map != NULL)
  96         {
  97           /* Found a new last used index.  */
  98           GL(dl_tls_max_dtv_idx) = idx;
  99           return true;
 100         }
 101     }
 102
 103   /* No non-entry in this list element.  */
 104   return false;
 105 }
 106 #endif
 107
 108
 109 void
 110 _dl_close (void *_map)
 111 {
 112   struct link_map *map = _map;
 113   Lmid_t ns = map->l_ns;
 114   unsigned int i;
 115   /* First see whether we can remove the object at all.  */
 116   if (__builtin_expect (map->l_flags_1 & DF_1_NODELETE, 0)
 117       && map->l_init_called)
 118     /* Nope.  Do nothing.  */
 119     return;
 120
 121   if (__builtin_expect (map->l_direct_opencount, 1) == 0)
 122     GLRO(dl_signal_error) (0, map->l_name, NULL, N_("shared object not open"));
 123
 124   /* Acquire the lock.  */
 125   __rtld_lock_lock_recursive (GL(dl_load_lock));
 126
 127   /* One less direct use.  */
 128   --map->l_direct_opencount;
 129
 130   /* If _dl_close is called recursively (some destructor call dlclose),
 131      just record that the parent _dl_close will need to do garbage collection
 132      again and return.  */
 133   static enum { not_pending, pending, rerun } dl_close_state;
 134
 135   if (map->l_direct_opencount > 0 || map->l_type != lt_loaded
 136       || dl_close_state != not_pending)
 137     {
 138       if (map->l_direct_opencount == 0 && map->l_type == lt_loaded)
 139         dl_close_state = rerun;
 140
 141       /* There are still references to this object.  Do nothing more.  */
 142       if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 143         _dl_debug_printf ("\nclosing file=%s; direct_opencount=%u\n",
 144                           map->l_name, map->l_direct_opencount);
 145
 146       __rtld_lock_unlock_recursive (GL(dl_load_lock));
 147       return;
 148     }
 149
 150  retry:
 151   dl_close_state = pending;
 152
 153 #ifdef USE_TLS
 154   bool any_tls = false;
 155 #endif
 156   const unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
 157   char used[nloaded];
 158   char done[nloaded];
 159   struct link_map *maps[nloaded];
 160
 161   /* Run over the list and assign indexes to the link maps and enter
 162      them into the MAPS array.  */
 163   int idx = 0;
 164   for (struct link_map *l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
 165     {
 166       l->l_idx = idx;
 167       maps[idx] = l;
 168       ++idx;
 169     }
 170   assert (idx == nloaded);
 171
 172   /* Prepare the bitmaps.  */
 173   memset (used, '\0', sizeof (used));
 174   memset (done, '\0', sizeof (done));
 175
 176   /* Keep track of the lowest index link map we have covered already.  */
 177   int done_index = -1;
 178   while (++done_index < nloaded)
 179     {
 180       struct link_map *l = maps[done_index];
 181
 182       if (done[done_index])
 183         /* Already handled.  */
 184         continue;
 185
 186       /* Check whether this object is still used.  */
 187       if (l->l_type == lt_loaded
 188           && l->l_direct_opencount == 0
 189           && (l->l_flags_1 & DF_1_NODELETE) == 0
 190           && !used[done_index])
 191         continue;
 192
 193       /* We need this object and we handle it now.  */
 194       done[done_index] = 1;
 195       used[done_index] = 1;
 196       /* Signal the object is still needed.  */
 197       l->l_idx = IDX_STILL_USED;
 198
 199       /* Mark all dependencies as used.  */
 200       if (l->l_initfini != NULL)
 201         {
 202           struct link_map **lp = &l->l_initfini[1];
 203           while (*lp != NULL)
 204             {
 205               if ((*lp)->l_idx != IDX_STILL_USED)
 206                 {
 207                   assert ((*lp)->l_idx >= 0 && (*lp)->l_idx < nloaded);
 208
 209                   if (!used[(*lp)->l_idx])
 210                     {
 211                       used[(*lp)->l_idx] = 1;
 212                       if ((*lp)->l_idx - 1 < done_index)
 213                         done_index = (*lp)->l_idx - 1;
 214                     }
 215                 }
 216
 217               ++lp;
 218             }
 219         }
 220       /* And the same for relocation dependencies.  */
 221       if (l->l_reldeps != NULL)
 222         for (unsigned int j = 0; j < l->l_reldepsact; ++j)
 223           {
 224             struct link_map *jmap = l->l_reldeps[j];
 225
 226             if (jmap->l_idx != IDX_STILL_USED)
 227               {
 228                 assert (jmap->l_idx >= 0 && jmap->l_idx < nloaded);
 229
 230                 if (!used[jmap->l_idx])
 231                   {
 232                     used[jmap->l_idx] = 1;
 233                     if (jmap->l_idx - 1 < done_index)
 234                       done_index = jmap->l_idx - 1;
 235                   }
 236               }
 237           }
 238     }
 239
 240   /* Sort the entries.  */
 241   _dl_sort_fini (GL(dl_ns)[ns]._ns_loaded, maps, nloaded, used, ns);
 242
 243   /* Call all termination functions at once.  */
 244 #ifdef SHARED
 245   bool do_audit = GLRO(dl_naudit) > 0 && !GL(dl_ns)[ns]._ns_loaded->l_auditing;
 246 #endif
 247   bool unload_any = false;
 248   unsigned int first_loaded = ~0;
 249   for (i = 0; i < nloaded; ++i)
 250     {
 251       struct link_map *imap = maps[i];
 252
 253       /* All elements must be in the same namespace.  */
 254       assert (imap->l_ns == ns);
 255
 256       if (!used[i])
 257         {
 258           assert (imap->l_type == lt_loaded
 259                   && (imap->l_flags_1 & DF_1_NODELETE) == 0);
 260
 261           /* Call its termination function.  Do not do it for
 262              half-cooked objects.  */
 263           if (imap->l_init_called)
 264             {
 265               /* When debugging print a message first.  */
 266               if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS,
 267                                     0))
 268                 _dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
 269                                   imap->l_name, ns);
 270
 271               if (imap->l_info[DT_FINI_ARRAY] != NULL)
 272                 {
 273                   ElfW(Addr) *array =
 274                     (ElfW(Addr) *) (imap->l_addr
 275                                     + imap->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
 276                   unsigned int sz = (imap->l_info[DT_FINI_ARRAYSZ]->d_un.d_val
 277                                      / sizeof (ElfW(Addr)));
 278
 279                   while (sz-- > 0)
 280                     ((fini_t) array[sz]) ();
 281                 }
 282
 283               /* Next try the old-style destructor.  */
 284               if (imap->l_info[DT_FINI] != NULL)
 285                 (*(void (*) (void)) DL_DT_FINI_ADDRESS
 286                  (imap, ((void *) imap->l_addr
 287                          + imap->l_info[DT_FINI]->d_un.d_ptr))) ();
 288             }
 289
 290 #ifdef SHARED
 291           /* Auditing checkpoint: we have a new object.  */
 292           if (__builtin_expect (do_audit, 0))
 293             {
 294               struct audit_ifaces *afct = GLRO(dl_audit);
 295               for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 296                 {
 297                   if (afct->objclose != NULL)
 298                     /* Return value is ignored.  */
 299                     (void) afct->objclose (&imap->l_audit[cnt].cookie);
 300
 301                   afct = afct->next;
 302                 }
 303             }
 304 #endif
 305
 306           /* This object must not be used anymore.  */
 307           imap->l_removed = 1;
 308
 309           /* We indeed have an object to remove.  */
 310           unload_any = true;
 311
 312           /* Remember where the first dynamically loaded object is.  */
 313           if (i < first_loaded)
 314             first_loaded = i;
 315         }
 316       /* Else used[i].  */
 317       else if (imap->l_type == lt_loaded)
 318         {
 319           struct r_scope_elem *new_list = NULL;
 320
 321           if (imap->l_searchlist.r_list == NULL && imap->l_initfini != NULL)
 322             {
 323               /* The object is still used.  But one of the objects we are
 324                  unloading right now is responsible for loading it.  If
 325                  the current object does not have it's own scope yet we
 326                  have to create one.  This has to be done before running
 327                  the finalizers.
 328
 329                  To do this count the number of dependencies.  */
 330               unsigned int cnt;
 331               for (cnt = 1; imap->l_initfini[cnt] != NULL; ++cnt)
 332                 ;
 333
 334               /* We simply reuse the l_initfini list.  */
 335               imap->l_searchlist.r_list = &imap->l_initfini[cnt + 1];
 336               imap->l_searchlist.r_nlist = cnt;
 337
 338               new_list = &imap->l_searchlist;
 339             }
 340
 341           /* Count the number of scopes which remain after the unload.
 342              When we add the local search list count it.  Always add
 343              one for the terminating NULL pointer.  */
 344           size_t remain = (new_list != NULL) + 1;
 345           bool removed_any = false;
 346           for (size_t cnt = 0; imap->l_scope[cnt] != NULL; ++cnt)
 347             /* This relies on l_scope[] entries being always set either
 348                to its own l_symbolic_searchlist address, or some map's
 349                l_searchlist address.  */
 350             if (imap->l_scope[cnt] != &imap->l_symbolic_searchlist)
 351               {
 352                 struct link_map *tmap = (struct link_map *)
 353                   ((char *) imap->l_scope[cnt]
 354                    - offsetof (struct link_map, l_searchlist));
 355                 assert (tmap->l_ns == ns);
 356                 if (tmap->l_idx == IDX_STILL_USED)
 357                   ++remain;
 358                 else
 359                   removed_any = true;
 360               }
 361             else
 362               ++remain;
 363
 364           if (removed_any)
 365             {
 366               /* Always allocate a new array for the scope.  This is
 367                  necessary since we must be able to determine the last
 368                  user of the current array.  If possible use the link map's
 369                  memory.  */
 370               size_t new_size;
 371               struct r_scope_elem **newp;
 372
 373 #define SCOPE_ELEMS(imap) \
 374   (sizeof (imap->l_scope_mem) / sizeof (imap->l_scope_mem[0]))
 375
 376               if (imap->l_scope != imap->l_scope_mem
 377                   && remain < SCOPE_ELEMS (imap))
 378                 {
 379                   new_size = SCOPE_ELEMS (imap);
 380                   newp = imap->l_scope_mem;
 381                 }
 382               else
 383                 {
 384                   new_size = imap->l_scope_max;
 385                   newp = (struct r_scope_elem **)
 386                     malloc (new_size * sizeof (struct r_scope_elem *));
 387                   if (newp == NULL)
 388                     _dl_signal_error (ENOMEM, "dlclose", NULL,
 389                                       N_("cannot create scope list"));
 390                 }
 391
 392               /* Copy over the remaining scope elements.  */
 393               remain = 0;
 394               for (size_t cnt = 0; imap->l_scope[cnt] != NULL; ++cnt)
 395                 {
 396                   if (imap->l_scope[cnt] != &imap->l_symbolic_searchlist)
 397                     {
 398                       struct link_map *tmap = (struct link_map *)
 399                         ((char *) imap->l_scope[cnt]
 400                          - offsetof (struct link_map, l_searchlist));
 401                       if (tmap->l_idx != IDX_STILL_USED)
 402                         {
 403                           /* Remove the scope.  Or replace with own map's
 404                              scope.  */
 405                           if (new_list != NULL)
 406                             {
 407                               newp[remain++] = new_list;
 408                               new_list = NULL;
 409                             }
 410                           continue;
 411                         }
 412                     }
 413
 414                   newp[remain++] = imap->l_scope[cnt];
 415                 }
 416               newp[remain] = NULL;
 417
 418               struct r_scope_elem **old = imap->l_scope;
 419
 420               if (SINGLE_THREAD_P)
 421                 imap->l_scope = newp;
 422               else
 423                 {
 424                   __rtld_mrlock_change (imap->l_scope_lock);
 425                   imap->l_scope = newp;
 426                   __rtld_mrlock_done (imap->l_scope_lock);
 427                 }
 428
 429               /* No user anymore, we can free it now.  */
 430               if (old != imap->l_scope_mem)
 431                 free (old);
 432
 433               imap->l_scope_max = new_size;
 434             }
 435
 436           /* The loader is gone, so mark the object as not having one.
 437              Note: l_idx != IDX_STILL_USED -> object will be removed.  */
 438           if (imap->l_loader != NULL
 439               && imap->l_loader->l_idx != IDX_STILL_USED)
 440             imap->l_loader = NULL;
 441
 442           /* Remember where the first dynamically loaded object is.  */
 443           if (i < first_loaded)
 444             first_loaded = i;
 445         }
 446     }
 447
 448   /* If there are no objects to unload, do nothing further.  */
 449   if (!unload_any)
 450     goto out;
 451
 452 #ifdef SHARED
 453   /* Auditing checkpoint: we will start deleting objects.  */
 454   if (__builtin_expect (do_audit, 0))
 455     {
 456       struct link_map *head = GL(dl_ns)[ns]._ns_loaded;
 457       struct audit_ifaces *afct = GLRO(dl_audit);
 458       /* Do not call the functions for any auditing object.  */
 459       if (head->l_auditing == 0)
 460         {
 461           for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 462             {
 463               if (afct->activity != NULL)
 464                 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_DELETE);
 465
 466               afct = afct->next;
 467             }
 468         }
 469     }
 470 #endif
 471
 472   /* Notify the debugger we are about to remove some loaded objects.  */
 473   struct r_debug *r = _dl_debug_initialize (0, ns);
 474   r->r_state = RT_DELETE;
 475   _dl_debug_state ();
 476
 477 #ifdef USE_TLS
 478   size_t tls_free_start;
 479   size_t tls_free_end;
 480   tls_free_start = tls_free_end = NO_TLS_OFFSET;
 481 #endif
 482
 483   /* Check each element of the search list to see if all references to
 484      it are gone.  */
 485   for (i = first_loaded; i < nloaded; ++i)
 486     {
 487       struct link_map *imap = maps[i];
 488       if (!used[i])
 489         {
 490           assert (imap->l_type == lt_loaded);
 491
 492           /* That was the last reference, and this was a dlopen-loaded
 493              object.  We can unmap it.  */
 494           if (__builtin_expect (imap->l_global, 0))
 495             {
 496               /* This object is in the global scope list.  Remove it.  */
 497               unsigned int cnt = GL(dl_ns)[ns]._ns_main_searchlist->r_nlist;
 498
 499               do
 500                 --cnt;
 501               while (GL(dl_ns)[ns]._ns_main_searchlist->r_list[cnt] != imap);
 502
 503               /* The object was already correctly registered.  */
 504               while (++cnt
 505                      < GL(dl_ns)[ns]._ns_main_searchlist->r_nlist)
 506                 GL(dl_ns)[ns]._ns_main_searchlist->r_list[cnt - 1]
 507                   = GL(dl_ns)[ns]._ns_main_searchlist->r_list[cnt];
 508
 509               --GL(dl_ns)[ns]._ns_main_searchlist->r_nlist;
 510             }
 511
 512 #ifdef USE_TLS
 513           /* Remove the object from the dtv slotinfo array if it uses TLS.  */
 514           if (__builtin_expect (imap->l_tls_blocksize > 0, 0))
 515             {
 516               any_tls = true;
 517
 518               if (GL(dl_tls_dtv_slotinfo_list) != NULL
 519                   && ! remove_slotinfo (imap->l_tls_modid,
 520                                         GL(dl_tls_dtv_slotinfo_list), 0,
 521                                         imap->l_init_called))
 522                 /* All dynamically loaded modules with TLS are unloaded.  */
 523                 GL(dl_tls_max_dtv_idx) = GL(dl_tls_static_nelem);
 524
 525               if (imap->l_tls_offset != NO_TLS_OFFSET)
 526                 {
 527                   /* Collect a contiguous chunk built from the objects in
 528                      this search list, going in either direction.  When the
 529                      whole chunk is at the end of the used area then we can
 530                      reclaim it.  */
 531 # if TLS_TCB_AT_TP
 532                   if (tls_free_start == NO_TLS_OFFSET
 533                       || (size_t) imap->l_tls_offset == tls_free_start)
 534                     {
 535                       /* Extend the contiguous chunk being reclaimed.  */
 536                       tls_free_start
 537                         = imap->l_tls_offset - imap->l_tls_blocksize;
 538
 539                       if (tls_free_end == NO_TLS_OFFSET)
 540                         tls_free_end = imap->l_tls_offset;
 541                     }
 542                   else if (imap->l_tls_offset - imap->l_tls_blocksize
 543                            == tls_free_end)
 544                     /* Extend the chunk backwards.  */
 545                     tls_free_end = imap->l_tls_offset;
 546                   else
 547                     {
 548                       /* This isn't contiguous with the last chunk freed.
 549                          One of them will be leaked unless we can free
 550                          one block right away.  */
 551                       if (tls_free_end == GL(dl_tls_static_used))
 552                         {
 553                           GL(dl_tls_static_used) = tls_free_start;
 554                           tls_free_end = imap->l_tls_offset;
 555                           tls_free_start
 556                             = tls_free_end - imap->l_tls_blocksize;
 557                         }
 558                       else if ((size_t) imap->l_tls_offset
 559                                == GL(dl_tls_static_used))
 560                         GL(dl_tls_static_used)
 561                           = imap->l_tls_offset - imap->l_tls_blocksize;
 562                       else if (tls_free_end < (size_t) imap->l_tls_offset)
 563                         {
 564                           /* We pick the later block.  It has a chance to
 565                              be freed.  */
 566                           tls_free_end = imap->l_tls_offset;
 567                           tls_free_start
 568                             = tls_free_end - imap->l_tls_blocksize;
 569                         }
 570                     }
 571 # elif TLS_DTV_AT_TP
 572                   if ((size_t) imap->l_tls_offset == tls_free_end)
 573                     /* Extend the contiguous chunk being reclaimed.  */
 574                     tls_free_end -= imap->l_tls_blocksize;
 575                   else if (imap->l_tls_offset + imap->l_tls_blocksize
 576                            == tls_free_start)
 577                     /* Extend the chunk backwards.  */
 578                     tls_free_start = imap->l_tls_offset;
 579                   else
 580                     {
 581                       /* This isn't contiguous with the last chunk freed.
 582                          One of them will be leaked.  */
 583                       if (tls_free_end == GL(dl_tls_static_used))
 584                         GL(dl_tls_static_used) = tls_free_start;
 585                       tls_free_start = imap->l_tls_offset;
 586                       tls_free_end = tls_free_start + imap->l_tls_blocksize;
 587                     }
 588 # else
 589 #  error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
 590 # endif
 591                 }
 592             }
 593 #endif
 594
 595           /* We can unmap all the maps at once.  We determined the
 596              start address and length when we loaded the object and
 597              the `munmap' call does the rest.  */
 598           DL_UNMAP (imap);
 599
 600           /* Finally, unlink the data structure and free it.  */
 601           if (imap->l_prev != NULL)
 602             imap->l_prev->l_next = imap->l_next;
 603           else
 604             {
 605 #ifdef SHARED
 606               assert (ns != LM_ID_BASE);
 607 #endif
 608               GL(dl_ns)[ns]._ns_loaded = imap->l_next;
 609             }
 610
 611           --GL(dl_ns)[ns]._ns_nloaded;
 612           if (imap->l_next != NULL)
 613             imap->l_next->l_prev = imap->l_prev;
 614
 615           free (imap->l_versions);
 616           if (imap->l_origin != (char *) -1)
 617             free ((char *) imap->l_origin);
 618
 619           free (imap->l_reldeps);
 620
 621           /* Print debugging message.  */
 622           if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
 623             _dl_debug_printf ("\nfile=%s [%lu];  destroying link map\n",
 624                               imap->l_name, imap->l_ns);
 625
 626           /* This name always is allocated.  */
 627           free (imap->l_name);
 628           /* Remove the list with all the names of the shared object.  */
 629
 630           struct libname_list *lnp = imap->l_libname;
 631           do
 632             {
 633               struct libname_list *this = lnp;
 634               lnp = lnp->next;
 635               if (!this->dont_free)
 636                 free (this);
 637             }
 638           while (lnp != NULL);
 639
 640           /* Remove the searchlists.  */
 641           free (imap->l_initfini);
 642
 643           /* Remove the scope array if we allocated it.  */
 644           if (imap->l_scope != imap->l_scope_mem)
 645             free (imap->l_scope);
 646
 647           if (imap->l_phdr_allocated)
 648             free ((void *) imap->l_phdr);
 649
 650           if (imap->l_rpath_dirs.dirs != (void *) -1)
 651             free (imap->l_rpath_dirs.dirs);
 652           if (imap->l_runpath_dirs.dirs != (void *) -1)
 653             free (imap->l_runpath_dirs.dirs);
 654
 655           free (imap);
 656         }
 657     }
 658
 659 #ifdef USE_TLS
 660   /* If we removed any object which uses TLS bump the generation counter.  */
 661   if (any_tls)
 662     {
 663       if (__builtin_expect (++GL(dl_tls_generation) == 0, 0))
 664         _dl_fatal_printf ("TLS generation counter wrapped!  Please report as described in <http://www.gnu.org/software/libc/bugs.html>.\n");
 665
 666       if (tls_free_end == GL(dl_tls_static_used))
 667         GL(dl_tls_static_used) = tls_free_start;
 668     }
 669 #endif
 670
 671 #ifdef SHARED
 672   /* Auditing checkpoint: we have deleted all objects.  */
 673   if (__builtin_expect (do_audit, 0))
 674     {
 675       struct link_map *head = GL(dl_ns)[ns]._ns_loaded;
 676       /* Do not call the functions for any auditing object.  */
 677       if (head->l_auditing == 0)
 678         {
 679           struct audit_ifaces *afct = GLRO(dl_audit);
 680           for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
 681             {
 682               if (afct->activity != NULL)
 683                 afct->activity (&head->l_audit[cnt].cookie, LA_ACT_CONSISTENT);
 684
 685               afct = afct->next;
 686             }
 687         }
 688     }
 689 #endif
 690
 691   /* Notify the debugger those objects are finalized and gone.  */
 692   r->r_state = RT_CONSISTENT;
 693   _dl_debug_state ();
 694
 695   /* Recheck if we need to retry, release the lock.  */
 696  out:
 697   if (dl_close_state == rerun)
 698     goto retry;
 699
 700   dl_close_state = not_pending;
 701   __rtld_lock_unlock_recursive (GL(dl_load_lock));
 702 }
 703
 704
 705 #ifdef USE_TLS
 706 static bool __libc_freeres_fn_section
 707 free_slotinfo (struct dtv_slotinfo_list **elemp)
 708 {
 709   size_t cnt;
 710
 711   if (*elemp == NULL)
 712     /* Nothing here, all is removed (or there never was anything).  */
 713     return true;
 714
 715   if (!free_slotinfo (&(*elemp)->next))
 716     /* We cannot free the entry.  */
 717     return false;
 718
 719   /* That cleared our next pointer for us.  */
 720
 721   for (cnt = 0; cnt < (*elemp)->len; ++cnt)
 722     if ((*elemp)->slotinfo[cnt].map != NULL)
 723       /* Still used.  */
 724       return false;
 725
 726   /* We can remove the list element.  */
 727   free (*elemp);
 728   *elemp = NULL;
 729
 730   return true;
 731 }
 732 #endif
 733
 734
 735 libc_freeres_fn (free_mem)
 736 {
 737   for (Lmid_t ns = 0; ns < DL_NNS; ++ns)
 738     if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0
 739         && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist
 740             // XXX Check whether we need NS-specific initial_searchlist
 741             == GLRO(dl_initial_searchlist).r_nlist))
 742       {
 743         /* All object dynamically loaded by the program are unloaded.  Free
 744            the memory allocated for the global scope variable.  */
 745         struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list;
 746
 747         /* Put the old map in.  */
 748         GL(dl_ns)[ns]._ns_main_searchlist->r_list
 749           // XXX Check whether we need NS-specific initial_searchlist
 750           = GLRO(dl_initial_searchlist).r_list;
 751         /* Signal that the original map is used.  */
 752         GL(dl_ns)[ns]._ns_global_scope_alloc = 0;
 753
 754         /* Now free the old map.  */
 755         free (old);
 756       }
 757
 758 #ifdef USE_TLS
 759   if (USE___THREAD || GL(dl_tls_dtv_slotinfo_list) != NULL)
 760     {
 761       /* Free the memory allocated for the dtv slotinfo array.  We can do
 762          this only if all modules which used this memory are unloaded.  */
 763 # ifdef SHARED
 764       if (GL(dl_initial_dtv) == NULL)
 765         /* There was no initial TLS setup, it was set up later when
 766            it used the normal malloc.  */
 767         free_slotinfo (&GL(dl_tls_dtv_slotinfo_list));
 768       else
 769 # endif
 770         /* The first element of the list does not have to be deallocated.
 771            It was allocated in the dynamic linker (i.e., with a different
 772            malloc), and in the static library it's in .bss space.  */
 773         free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next);
 774     }
 775 #endif
 776 }