/* Close a shared object opened by `_dl_open'.
- Copyright (C) 1996-2005, 2006 Free Software Foundation, Inc.
+ Copyright (C) 1996-2019 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
- License along with the GNU C Library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
- 02111-1307 USA. */
+ License along with the GNU C Library; if not, see
+ <https://www.gnu.org/licenses/>. */
#include <assert.h>
#include <dlfcn.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include <bits/libc-lock.h>
+#include <libc-lock.h>
#include <ldsodefs.h>
#include <sys/types.h>
#include <sys/mman.h>
+#include <sysdep-cancel.h>
+#include <tls.h>
+#include <stap-probe.h>
+
+#include <dl-unmap-segments.h>
/* Type of the constructor functions. */
#define IDX_STILL_USED -1
-#ifdef USE_TLS
/* Returns true we an non-empty was found. */
static bool
remove_slotinfo (size_t idx, struct dtv_slotinfo_list *listp, size_t disp,
/* The entry might still be in its unused state if we are closing an
object that wasn't fully set up. */
- if (__builtin_expect (old_map != NULL, 1))
+ if (__glibc_likely (old_map != NULL))
{
assert (old_map->l_tls_modid == idx);
/* No non-entry in this list element. */
return false;
}
-#endif
void
-_dl_close (void *_map)
+_dl_close_worker (struct link_map *map, bool force)
{
- struct link_map *map = _map;
- Lmid_t ns = map->l_ns;
- unsigned int i;
- /* First see whether we can remove the object at all. */
- if (__builtin_expect (map->l_flags_1 & DF_1_NODELETE, 0)
- && map->l_init_called)
- /* Nope. Do nothing. */
- return;
-
- if (__builtin_expect (map->l_direct_opencount, 1) == 0)
- GLRO(dl_signal_error) (0, map->l_name, NULL, N_("shared object not open"));
-
- /* Acquire the lock. */
- __rtld_lock_lock_recursive (GL(dl_load_lock));
-
/* One less direct use. */
--map->l_direct_opencount;
dl_close_state = rerun;
/* There are still references to this object. Do nothing more. */
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
_dl_debug_printf ("\nclosing file=%s; direct_opencount=%u\n",
map->l_name, map->l_direct_opencount);
- __rtld_lock_unlock_recursive (GL(dl_load_lock));
return;
}
+ Lmid_t nsid = map->l_ns;
+ struct link_namespaces *ns = &GL(dl_ns)[nsid];
+
retry:
dl_close_state = pending;
-#ifdef USE_TLS
bool any_tls = false;
-#endif
- const unsigned int nloaded = GL(dl_ns)[ns]._ns_nloaded;
+ const unsigned int nloaded = ns->_ns_nloaded;
char used[nloaded];
char done[nloaded];
struct link_map *maps[nloaded];
+ /* Clear DF_1_NODELETE to force object deletion. We don't need to touch
+ l_tls_dtor_count because forced object deletion only happens when an
+ error occurs during object load. Destructor registration for TLS
+ non-POD objects should not have happened till then for this
+ object. */
+ if (force)
+ map->l_flags_1 &= ~DF_1_NODELETE;
+
/* Run over the list and assign indexes to the link maps and enter
them into the MAPS array. */
int idx = 0;
- for (struct link_map *l = GL(dl_ns)[ns]._ns_loaded; l != NULL; l = l->l_next)
+ for (struct link_map *l = ns->_ns_loaded; l != NULL; l = l->l_next)
{
l->l_idx = idx;
maps[idx] = l;
++idx;
+
}
assert (idx == nloaded);
if (l->l_type == lt_loaded
&& l->l_direct_opencount == 0
&& (l->l_flags_1 & DF_1_NODELETE) == 0
+ /* See CONCURRENCY NOTES in cxa_thread_atexit_impl.c to know why
+ acquire is sufficient and correct. */
+ && atomic_load_acquire (&l->l_tls_dtor_count) == 0
&& !used[done_index])
continue;
/* Mark all dependencies as used. */
if (l->l_initfini != NULL)
{
+ /* We are always the zeroth entry, and since we don't include
+ ourselves in the dependency analysis start at 1. */
struct link_map **lp = &l->l_initfini[1];
while (*lp != NULL)
{
if (!used[(*lp)->l_idx])
{
used[(*lp)->l_idx] = 1;
+ /* If we marked a new object as used, and we've
+ already processed it, then we need to go back
+ and process again from that point forward to
+ ensure we keep all of its dependencies also. */
if ((*lp)->l_idx - 1 < done_index)
done_index = (*lp)->l_idx - 1;
}
}
/* And the same for relocation dependencies. */
if (l->l_reldeps != NULL)
- for (unsigned int j = 0; j < l->l_reldepsact; ++j)
+ for (unsigned int j = 0; j < l->l_reldeps->act; ++j)
{
- struct link_map *jmap = l->l_reldeps[j];
+ struct link_map *jmap = l->l_reldeps->list[j];
if (jmap->l_idx != IDX_STILL_USED)
{
}
}
- /* Sort the entries. */
- _dl_sort_fini (GL(dl_ns)[ns]._ns_loaded, maps, nloaded, used, ns);
+ /* Sort the entries. We can skip looking for the binary itself which is
+ at the front of the search list for the main namespace. */
+ _dl_sort_maps (maps + (nsid == LM_ID_BASE), nloaded - (nsid == LM_ID_BASE),
+ used + (nsid == LM_ID_BASE), true);
/* Call all termination functions at once. */
#ifdef SHARED
- bool do_audit = GLRO(dl_naudit) > 0 && !GL(dl_ns)[ns]._ns_loaded->l_auditing;
+ bool do_audit = GLRO(dl_naudit) > 0 && !ns->_ns_loaded->l_auditing;
#endif
bool unload_any = false;
+ bool scope_mem_left = false;
+ unsigned int unload_global = 0;
unsigned int first_loaded = ~0;
- for (i = 0; i < nloaded; ++i)
+ for (unsigned int i = 0; i < nloaded; ++i)
{
struct link_map *imap = maps[i];
/* All elements must be in the same namespace. */
- assert (imap->l_ns == ns);
+ assert (imap->l_ns == nsid);
if (!used[i])
{
if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_IMPCALLS,
0))
_dl_debug_printf ("\ncalling fini: %s [%lu]\n\n",
- imap->l_name, ns);
+ imap->l_name, nsid);
if (imap->l_info[DT_FINI_ARRAY] != NULL)
{
/* Next try the old-style destructor. */
if (imap->l_info[DT_FINI] != NULL)
- (*(void (*) (void)) DL_DT_FINI_ADDRESS
- (imap, ((void *) imap->l_addr
- + imap->l_info[DT_FINI]->d_un.d_ptr))) ();
+ DL_CALL_DT_FINI (imap, ((void *) imap->l_addr
+ + imap->l_info[DT_FINI]->d_un.d_ptr));
}
#ifdef SHARED
- /* Auditing checkpoint: we have a new object. */
- if (__builtin_expect (do_audit, 0))
+ /* Auditing checkpoint: we remove an object. */
+ if (__glibc_unlikely (do_audit))
{
struct audit_ifaces *afct = GLRO(dl_audit);
for (unsigned int cnt = 0; cnt < GLRO(dl_naudit); ++cnt)
/* We indeed have an object to remove. */
unload_any = true;
+ if (imap->l_global)
+ ++unload_global;
+
/* Remember where the first dynamically loaded object is. */
if (i < first_loaded)
first_loaded = i;
one for the terminating NULL pointer. */
size_t remain = (new_list != NULL) + 1;
bool removed_any = false;
- for (size_t cnt = 0; imap->l_scoperec->scope[cnt] != NULL; ++cnt)
+ for (size_t cnt = 0; imap->l_scope[cnt] != NULL; ++cnt)
/* This relies on l_scope[] entries being always set either
to its own l_symbolic_searchlist address, or some map's
l_searchlist address. */
- if (imap->l_scoperec->scope[cnt] != &imap->l_symbolic_searchlist)
+ if (imap->l_scope[cnt] != &imap->l_symbolic_searchlist)
{
struct link_map *tmap = (struct link_map *)
- ((char *) imap->l_scoperec->scope[cnt]
+ ((char *) imap->l_scope[cnt]
- offsetof (struct link_map, l_searchlist));
- assert (tmap->l_ns == ns);
+ assert (tmap->l_ns == nsid);
if (tmap->l_idx == IDX_STILL_USED)
++remain;
else
user of the current array. If possible use the link map's
memory. */
size_t new_size;
- struct r_scoperec *newp;
- if (imap->l_scoperec != &imap->l_scoperec_mem
- && remain < NINIT_SCOPE_ELEMS (imap)
- && imap->l_scoperec_mem.nusers == 0)
+ struct r_scope_elem **newp;
+
+#define SCOPE_ELEMS(imap) \
+ (sizeof (imap->l_scope_mem) / sizeof (imap->l_scope_mem[0]))
+
+ if (imap->l_scope != imap->l_scope_mem
+ && remain < SCOPE_ELEMS (imap))
{
- new_size = NINIT_SCOPE_ELEMS (imap);
- newp = &imap->l_scoperec_mem;
+ new_size = SCOPE_ELEMS (imap);
+ newp = imap->l_scope_mem;
}
else
{
new_size = imap->l_scope_max;
- newp = (struct r_scoperec *)
- malloc (sizeof (struct r_scoperec)
- + new_size * sizeof (struct r_scope_elem *));
+ newp = (struct r_scope_elem **)
+ malloc (new_size * sizeof (struct r_scope_elem *));
if (newp == NULL)
_dl_signal_error (ENOMEM, "dlclose", NULL,
N_("cannot create scope list"));
}
- newp->nusers = 0;
- newp->remove_after_use = false;
- newp->notify = false;
-
/* Copy over the remaining scope elements. */
remain = 0;
- for (size_t cnt = 0; imap->l_scoperec->scope[cnt] != NULL; ++cnt)
+ for (size_t cnt = 0; imap->l_scope[cnt] != NULL; ++cnt)
{
- if (imap->l_scoperec->scope[cnt]
- != &imap->l_symbolic_searchlist)
+ if (imap->l_scope[cnt] != &imap->l_symbolic_searchlist)
{
struct link_map *tmap = (struct link_map *)
- ((char *) imap->l_scoperec->scope[cnt]
+ ((char *) imap->l_scope[cnt]
- offsetof (struct link_map, l_searchlist));
if (tmap->l_idx != IDX_STILL_USED)
{
scope. */
if (new_list != NULL)
{
- newp->scope[remain++] = new_list;
+ newp[remain++] = new_list;
new_list = NULL;
}
continue;
}
}
- newp->scope[remain++] = imap->l_scoperec->scope[cnt];
+ newp[remain++] = imap->l_scope[cnt];
}
- newp->scope[remain] = NULL;
+ newp[remain] = NULL;
- struct r_scoperec *old = imap->l_scoperec;
+ struct r_scope_elem **old = imap->l_scope;
- __rtld_mrlock_change (imap->l_scoperec_lock);
- imap->l_scoperec = newp;
- __rtld_mrlock_done (imap->l_scoperec_lock);
+ imap->l_scope = newp;
- if (catomic_increment_val (&old->nusers) != 1)
+ /* No user anymore, we can free it now. */
+ if (old != imap->l_scope_mem)
{
- old->remove_after_use = true;
- old->notify = true;
- if (catomic_decrement_val (&old->nusers) != 0)
- __rtld_waitzero (old->nusers);
+ if (_dl_scope_free (old))
+ /* If _dl_scope_free used THREAD_GSCOPE_WAIT (),
+ no need to repeat it. */
+ scope_mem_left = false;
}
-
- /* No user anymore, we can free it now. */
- if (old != &imap->l_scoperec_mem)
- free (old);
+ else
+ scope_mem_left = true;
imap->l_scope_max = new_size;
}
+ else if (new_list != NULL)
+ {
+ /* We didn't change the scope array, so reset the search
+ list. */
+ imap->l_searchlist.r_list = NULL;
+ imap->l_searchlist.r_nlist = 0;
+ }
/* The loader is gone, so mark the object as not having one.
Note: l_idx != IDX_STILL_USED -> object will be removed. */
#ifdef SHARED
/* Auditing checkpoint: we will start deleting objects. */
- if (__builtin_expect (do_audit, 0))
+ if (__glibc_unlikely (do_audit))
{
- struct link_map *head = GL(dl_ns)[ns]._ns_loaded;
+ struct link_map *head = ns->_ns_loaded;
struct audit_ifaces *afct = GLRO(dl_audit);
/* Do not call the functions for any auditing object. */
if (head->l_auditing == 0)
#endif
/* Notify the debugger we are about to remove some loaded objects. */
- struct r_debug *r = _dl_debug_initialize (0, ns);
+ struct r_debug *r = _dl_debug_initialize (0, nsid);
r->r_state = RT_DELETE;
_dl_debug_state ();
+ LIBC_PROBE (unmap_start, 2, nsid, r);
+
+ if (unload_global)
+ {
+ /* Some objects are in the global scope list. Remove them. */
+ struct r_scope_elem *ns_msl = ns->_ns_main_searchlist;
+ unsigned int i;
+ unsigned int j = 0;
+ unsigned int cnt = ns_msl->r_nlist;
+
+ while (cnt > 0 && ns_msl->r_list[cnt - 1]->l_removed)
+ --cnt;
+
+ if (cnt + unload_global == ns_msl->r_nlist)
+ /* Speed up removing most recently added objects. */
+ j = cnt;
+ else
+ for (i = 0; i < cnt; i++)
+ if (ns_msl->r_list[i]->l_removed == 0)
+ {
+ if (i != j)
+ ns_msl->r_list[j] = ns_msl->r_list[i];
+ j++;
+ }
+ ns_msl->r_nlist = j;
+ }
+
+ if (!RTLD_SINGLE_THREAD_P
+ && (unload_global
+ || scope_mem_left
+ || (GL(dl_scope_free_list) != NULL
+ && GL(dl_scope_free_list)->count)))
+ {
+ THREAD_GSCOPE_WAIT ();
+
+ /* Now we can free any queued old scopes. */
+ struct dl_scope_free_list *fsl = GL(dl_scope_free_list);
+ if (fsl != NULL)
+ while (fsl->count > 0)
+ free (fsl->list[--fsl->count]);
+ }
-#ifdef USE_TLS
size_t tls_free_start;
size_t tls_free_end;
tls_free_start = tls_free_end = NO_TLS_OFFSET;
-#endif
+
+ /* We modify the list of loaded objects. */
+ __rtld_lock_lock_recursive (GL(dl_load_write_lock));
/* Check each element of the search list to see if all references to
it are gone. */
- for (i = first_loaded; i < nloaded; ++i)
+ for (unsigned int i = first_loaded; i < nloaded; ++i)
{
struct link_map *imap = maps[i];
if (!used[i])
/* That was the last reference, and this was a dlopen-loaded
object. We can unmap it. */
- if (__builtin_expect (imap->l_global, 0))
- {
- /* This object is in the global scope list. Remove it. */
- unsigned int cnt = GL(dl_ns)[ns]._ns_main_searchlist->r_nlist;
-
- do
- --cnt;
- while (GL(dl_ns)[ns]._ns_main_searchlist->r_list[cnt] != imap);
-
- /* The object was already correctly registered. */
- while (++cnt
- < GL(dl_ns)[ns]._ns_main_searchlist->r_nlist)
- GL(dl_ns)[ns]._ns_main_searchlist->r_list[cnt - 1]
- = GL(dl_ns)[ns]._ns_main_searchlist->r_list[cnt];
- --GL(dl_ns)[ns]._ns_main_searchlist->r_nlist;
- }
-
-#ifdef USE_TLS
/* Remove the object from the dtv slotinfo array if it uses TLS. */
- if (__builtin_expect (imap->l_tls_blocksize > 0, 0))
+ if (__glibc_unlikely (imap->l_tls_blocksize > 0))
{
any_tls = true;
/* All dynamically loaded modules with TLS are unloaded. */
GL(dl_tls_max_dtv_idx) = GL(dl_tls_static_nelem);
- if (imap->l_tls_offset != NO_TLS_OFFSET)
+ if (imap->l_tls_offset != NO_TLS_OFFSET
+ && imap->l_tls_offset != FORCED_DYNAMIC_TLS_OFFSET)
{
/* Collect a contiguous chunk built from the objects in
this search list, going in either direction. When the
whole chunk is at the end of the used area then we can
reclaim it. */
-# if TLS_TCB_AT_TP
+#if TLS_TCB_AT_TP
if (tls_free_start == NO_TLS_OFFSET
|| (size_t) imap->l_tls_offset == tls_free_start)
{
= tls_free_end - imap->l_tls_blocksize;
}
}
-# elif TLS_DTV_AT_TP
- if ((size_t) imap->l_tls_offset == tls_free_end)
+#elif TLS_DTV_AT_TP
+ if (tls_free_start == NO_TLS_OFFSET)
+ {
+ tls_free_start = imap->l_tls_firstbyte_offset;
+ tls_free_end = (imap->l_tls_offset
+ + imap->l_tls_blocksize);
+ }
+ else if (imap->l_tls_firstbyte_offset == tls_free_end)
/* Extend the contiguous chunk being reclaimed. */
- tls_free_end -= imap->l_tls_blocksize;
+ tls_free_end = imap->l_tls_offset + imap->l_tls_blocksize;
else if (imap->l_tls_offset + imap->l_tls_blocksize
== tls_free_start)
/* Extend the chunk backwards. */
- tls_free_start = imap->l_tls_offset;
- else
+ tls_free_start = imap->l_tls_firstbyte_offset;
+ /* This isn't contiguous with the last chunk freed.
+ One of them will be leaked unless we can free
+ one block right away. */
+ else if (imap->l_tls_offset + imap->l_tls_blocksize
+ == GL(dl_tls_static_used))
+ GL(dl_tls_static_used) = imap->l_tls_firstbyte_offset;
+ else if (tls_free_end == GL(dl_tls_static_used))
{
- /* This isn't contiguous with the last chunk freed.
- One of them will be leaked. */
- if (tls_free_end == GL(dl_tls_static_used))
- GL(dl_tls_static_used) = tls_free_start;
- tls_free_start = imap->l_tls_offset;
- tls_free_end = tls_free_start + imap->l_tls_blocksize;
+ GL(dl_tls_static_used) = tls_free_start;
+ tls_free_start = imap->l_tls_firstbyte_offset;
+ tls_free_end = imap->l_tls_offset + imap->l_tls_blocksize;
}
-# else
-# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
-# endif
+ else if (tls_free_end < imap->l_tls_firstbyte_offset)
+ {
+ /* We pick the later block. It has a chance to
+ be freed. */
+ tls_free_start = imap->l_tls_firstbyte_offset;
+ tls_free_end = imap->l_tls_offset + imap->l_tls_blocksize;
+ }
+#else
+# error "Either TLS_TCB_AT_TP or TLS_DTV_AT_TP must be defined"
+#endif
}
}
-#endif
+
+ /* Reset unique symbols if forced. */
+ if (force)
+ {
+ struct unique_sym_table *tab = &ns->_ns_unique_sym_table;
+ __rtld_lock_lock_recursive (tab->lock);
+ struct unique_sym *entries = tab->entries;
+ if (entries != NULL)
+ {
+ size_t idx, size = tab->size;
+ for (idx = 0; idx < size; ++idx)
+ {
+ /* Clear unique symbol entries that belong to this
+ object. */
+ if (entries[idx].name != NULL
+ && entries[idx].map == imap)
+ {
+ entries[idx].name = NULL;
+ entries[idx].hashval = 0;
+ tab->n_elements--;
+ }
+ }
+ }
+ __rtld_lock_unlock_recursive (tab->lock);
+ }
/* We can unmap all the maps at once. We determined the
start address and length when we loaded the object and
DL_UNMAP (imap);
/* Finally, unlink the data structure and free it. */
- if (imap->l_prev != NULL)
- imap->l_prev->l_next = imap->l_next;
- else
+#if DL_NNS == 1
+ /* The assert in the (imap->l_prev == NULL) case gives
+ the compiler license to warn that NS points outside
+ the dl_ns array bounds in that case (as nsid != LM_ID_BASE
+ is tantamount to nsid >= DL_NNS). That should be impossible
+ in this configuration, so just assert about it instead. */
+ assert (nsid == LM_ID_BASE);
+ assert (imap->l_prev != NULL);
+#else
+ if (imap->l_prev == NULL)
{
-#ifdef SHARED
- assert (ns != LM_ID_BASE);
-#endif
- GL(dl_ns)[ns]._ns_loaded = imap->l_next;
+ assert (nsid != LM_ID_BASE);
+ ns->_ns_loaded = imap->l_next;
+
+ /* Update the pointer to the head of the list
+ we leave for debuggers to examine. */
+ r->r_map = (void *) ns->_ns_loaded;
}
+ else
+#endif
+ imap->l_prev->l_next = imap->l_next;
- --GL(dl_ns)[ns]._ns_nloaded;
+ --ns->_ns_nloaded;
if (imap->l_next != NULL)
imap->l_next->l_prev = imap->l_prev;
free (imap->l_reldeps);
/* Print debugging message. */
- if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0))
+ if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_FILES))
_dl_debug_printf ("\nfile=%s [%lu]; destroying link map\n",
imap->l_name, imap->l_ns);
free (imap->l_initfini);
/* Remove the scope array if we allocated it. */
- if (imap->l_scoperec != &imap->l_scoperec_mem)
- free (imap->l_scoperec);
+ if (imap->l_scope != imap->l_scope_mem)
+ free (imap->l_scope);
if (imap->l_phdr_allocated)
free ((void *) imap->l_phdr);
}
}
-#ifdef USE_TLS
+ __rtld_lock_unlock_recursive (GL(dl_load_write_lock));
+
/* If we removed any object which uses TLS bump the generation counter. */
if (any_tls)
{
- if (__builtin_expect (++GL(dl_tls_generation) == 0, 0))
- _dl_fatal_printf ("TLS generation counter wrapped! Please report as described in <http://www.gnu.org/software/libc/bugs.html>.\n");
+ if (__glibc_unlikely (++GL(dl_tls_generation) == 0))
+ _dl_fatal_printf ("TLS generation counter wrapped! Please report as described in "REPORT_BUGS_TO".\n");
if (tls_free_end == GL(dl_tls_static_used))
GL(dl_tls_static_used) = tls_free_start;
}
-#endif
#ifdef SHARED
/* Auditing checkpoint: we have deleted all objects. */
- if (__builtin_expect (do_audit, 0))
+ if (__glibc_unlikely (do_audit))
{
- struct link_map *head = GL(dl_ns)[ns]._ns_loaded;
+ struct link_map *head = ns->_ns_loaded;
/* Do not call the functions for any auditing object. */
if (head->l_auditing == 0)
{
}
#endif
+ if (__builtin_expect (ns->_ns_loaded == NULL, 0)
+ && nsid == GL(dl_nns) - 1)
+ do
+ --GL(dl_nns);
+ while (GL(dl_ns)[GL(dl_nns) - 1]._ns_loaded == NULL);
+
/* Notify the debugger those objects are finalized and gone. */
r->r_state = RT_CONSISTENT;
_dl_debug_state ();
+ LIBC_PROBE (unmap_complete, 2, nsid, r);
/* Recheck if we need to retry, release the lock. */
out:
goto retry;
dl_close_state = not_pending;
- __rtld_lock_unlock_recursive (GL(dl_load_lock));
}
-#ifdef USE_TLS
-static bool __libc_freeres_fn_section
-free_slotinfo (struct dtv_slotinfo_list **elemp)
+void
+_dl_close (void *_map)
{
- size_t cnt;
-
- if (*elemp == NULL)
- /* Nothing here, all is removed (or there never was anything). */
- return true;
-
- if (!free_slotinfo (&(*elemp)->next))
- /* We cannot free the entry. */
- return false;
-
- /* That cleared our next pointer for us. */
-
- for (cnt = 0; cnt < (*elemp)->len; ++cnt)
- if ((*elemp)->slotinfo[cnt].map != NULL)
- /* Still used. */
- return false;
-
- /* We can remove the list element. */
- free (*elemp);
- *elemp = NULL;
+ struct link_map *map = _map;
- return true;
-}
-#endif
+ /* We must take the lock to examine the contents of map and avoid
+ concurrent dlopens. */
+ __rtld_lock_lock_recursive (GL(dl_load_lock));
+ /* At this point we are guaranteed nobody else is touching the list of
+ loaded maps, but a concurrent dlclose might have freed our map
+ before we took the lock. There is no way to detect this (see below)
+ so we proceed assuming this isn't the case. First see whether we
+ can remove the object at all. */
+ if (__glibc_unlikely (map->l_flags_1 & DF_1_NODELETE))
+ {
+ /* Nope. Do nothing. */
+ __rtld_lock_unlock_recursive (GL(dl_load_lock));
+ return;
+ }
-libc_freeres_fn (free_mem)
-{
- for (Lmid_t ns = 0; ns < DL_NNS; ++ns)
- if (__builtin_expect (GL(dl_ns)[ns]._ns_global_scope_alloc, 0) != 0
- && (GL(dl_ns)[ns]._ns_main_searchlist->r_nlist
- // XXX Check whether we need NS-specific initial_searchlist
- == GLRO(dl_initial_searchlist).r_nlist))
- {
- /* All object dynamically loaded by the program are unloaded. Free
- the memory allocated for the global scope variable. */
- struct link_map **old = GL(dl_ns)[ns]._ns_main_searchlist->r_list;
-
- /* Put the old map in. */
- GL(dl_ns)[ns]._ns_main_searchlist->r_list
- // XXX Check whether we need NS-specific initial_searchlist
- = GLRO(dl_initial_searchlist).r_list;
- /* Signal that the original map is used. */
- GL(dl_ns)[ns]._ns_global_scope_alloc = 0;
-
- /* Now free the old map. */
- free (old);
- }
-
-#ifdef USE_TLS
- if (USE___THREAD || GL(dl_tls_dtv_slotinfo_list) != NULL)
+ /* At present this is an unreliable check except in the case where the
+ caller has recursively called dlclose and we are sure the link map
+ has not been freed. In a non-recursive dlclose the map itself
+ might have been freed and this access is potentially a data race
+ with whatever other use this memory might have now, or worse we
+ might silently corrupt memory if it looks enough like a link map.
+ POSIX has language in dlclose that appears to guarantee that this
+ should be a detectable case and given that dlclose should be threadsafe
+ we need this to be a reliable detection.
+ This is bug 20990. */
+ if (__builtin_expect (map->l_direct_opencount, 1) == 0)
{
- /* Free the memory allocated for the dtv slotinfo array. We can do
- this only if all modules which used this memory are unloaded. */
-# ifdef SHARED
- if (GL(dl_initial_dtv) == NULL)
- /* There was no initial TLS setup, it was set up later when
- it used the normal malloc. */
- free_slotinfo (&GL(dl_tls_dtv_slotinfo_list));
- else
-# endif
- /* The first element of the list does not have to be deallocated.
- It was allocated in the dynamic linker (i.e., with a different
- malloc), and in the static library it's in .bss space. */
- free_slotinfo (&GL(dl_tls_dtv_slotinfo_list)->next);
+ __rtld_lock_unlock_recursive (GL(dl_load_lock));
+ _dl_signal_error (0, map->l_name, NULL, N_("shared object not open"));
}
-#endif
+
+ _dl_close_worker (map, false);
+
+ __rtld_lock_unlock_recursive (GL(dl_load_lock));
}
projects / thirdparty / glibc.git / blobdiff