elf/dl-close.c

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