mirror of
git://sourceware.org/git/glibc.git
synced 2025-03-06 20:58:33 +01:00
a3189f66a5
The current implementation of dlclose (and process exit) re-sorts the link maps before calling ELF destructors. Destructor order is not the reverse of the constructor order as a result: The second sort takes relocation dependencies into account, and other differences can result from ambiguous inputs, such as cycles. (The force_first handling in _dl_sort_maps is not effective for dlclose.) After the changes in this commit, there is still a required difference due to dlopen/dlclose ordering by the application, but the previous discrepancies went beyond that. A new global (namespace-spanning) list of link maps, _dl_init_called_list, is updated right before ELF constructors are called from _dl_init. In dl_close_worker, the maps variable, an on-stack variable length array, is eliminated. (VLAs are problematic, and dlclose should not call malloc because it cannot readily deal with malloc failure.) Marking still-used objects uses the namespace list directly, with next and next_idx replacing the done_index variable. After marking, _dl_init_called_list is used to call the destructors of now-unused maps in reverse destructor order. These destructors can call dlopen. Previously, new objects do not have l_map_used set. This had to change: There is no copy of the link map list anymore, so processing would cover newly opened (and unmarked) mappings, unloading them. Now, _dl_init (indirectly) sets l_map_used, too. (dlclose is handled by the existing reentrancy guard.) After _dl_init_called_list traversal, two more loops follow. The processing order changes to the original link map order in the namespace. Previously, dependency order was used. The difference should not matter because relocation dependencies could already reorder link maps in the old code. The changes to _dl_fini remove the sorting step and replace it with a traversal of _dl_init_called_list. The l_direct_opencount decrement outside the loader lock is removed because it appears incorrect: the counter manipulation could race with other dynamic loader operations. tst-audit23 needs adjustments to the changes in LA_ACT_DELETE notifications. The new approach for checking la_activity should make it clearer that la_activty calls come in pairs around namespace updates. The dependency sorting test cases need updates because the destructor order is always the opposite order of constructor order, even with relocation dependencies or cycles present. There is a future cleanup opportunity to remove the now-constant force_first and for_fini arguments from the _dl_sort_maps function. Fixes commit1df71d32fe("elf: Implement force_first handling in _dl_sort_maps_dfs (bug 28937)"). Reviewed-by: DJ Delorie <dj@redhat.com> (cherry picked from commit6985865bc3)
97 lines
3.4 KiB
C
97 lines
3.4 KiB
C
/* Call the termination functions of loaded shared objects.
|
|
Copyright (C) 1995-2023 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
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
The GNU C Library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
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, see
|
|
<https://www.gnu.org/licenses/>. */
|
|
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <ldsodefs.h>
|
|
#include <elf-initfini.h>
|
|
|
|
void
|
|
_dl_fini (void)
|
|
{
|
|
/* Call destructors strictly in the reverse order of constructors.
|
|
This causes fewer surprises than some arbitrary reordering based
|
|
on new (relocation) dependencies. None of the objects are
|
|
unmapped, so applications can deal with this if their DSOs remain
|
|
in a consistent state after destructors have run. */
|
|
|
|
/* Protect against concurrent loads and unloads. */
|
|
__rtld_lock_lock_recursive (GL(dl_load_lock));
|
|
|
|
/* Ignore objects which are opened during shutdown. */
|
|
struct link_map *local_init_called_list = _dl_init_called_list;
|
|
|
|
for (struct link_map *l = local_init_called_list; l != NULL;
|
|
l = l->l_init_called_next)
|
|
/* Bump l_direct_opencount of all objects so that they
|
|
are not dlclose()ed from underneath us. */
|
|
++l->l_direct_opencount;
|
|
|
|
/* After this point, everything linked from local_init_called_list
|
|
cannot be unloaded because of the reference counter update. */
|
|
__rtld_lock_unlock_recursive (GL(dl_load_lock));
|
|
|
|
/* Perform two passes: One for non-audit modules, one for audit
|
|
modules. This way, audit modules receive unload notifications
|
|
for non-audit objects, and the destructors for audit modules
|
|
still run. */
|
|
#ifdef SHARED
|
|
int last_pass = GLRO(dl_naudit) > 0;
|
|
Lmid_t last_ns = -1;
|
|
for (int do_audit = 0; do_audit <= last_pass; ++do_audit)
|
|
#endif
|
|
for (struct link_map *l = local_init_called_list; l != NULL;
|
|
l = l->l_init_called_next)
|
|
{
|
|
#ifdef SHARED
|
|
if (GL(dl_ns)[l->l_ns]._ns_loaded->l_auditing != do_audit)
|
|
continue;
|
|
|
|
/* Avoid back-to-back calls of _dl_audit_activity_nsid for the
|
|
same namespace. */
|
|
if (last_ns != l->l_ns)
|
|
{
|
|
if (last_ns >= 0)
|
|
_dl_audit_activity_nsid (last_ns, LA_ACT_CONSISTENT);
|
|
_dl_audit_activity_nsid (l->l_ns, LA_ACT_DELETE);
|
|
last_ns = l->l_ns;
|
|
}
|
|
#endif
|
|
|
|
/* There is no need to re-enable exceptions because _dl_fini
|
|
is not called from a context where exceptions are caught. */
|
|
_dl_call_fini (l);
|
|
|
|
#ifdef SHARED
|
|
/* Auditing checkpoint: another object closed. */
|
|
_dl_audit_objclose (l);
|
|
#endif
|
|
}
|
|
|
|
#ifdef SHARED
|
|
if (last_ns >= 0)
|
|
_dl_audit_activity_nsid (last_ns, LA_ACT_CONSISTENT);
|
|
|
|
if (__glibc_unlikely (GLRO(dl_debug_mask) & DL_DEBUG_STATISTICS))
|
|
_dl_debug_printf ("\nruntime linker statistics:\n"
|
|
" final number of relocations: %lu\n"
|
|
"final number of relocations from cache: %lu\n",
|
|
GL(dl_num_relocations),
|
|
GL(dl_num_cache_relocations));
|
|
#endif
|
|
}
|