mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-21 20:40:05 +00:00
6985865bc3
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 commit 1df71d32fe ("elf: Implement
force_first handling in _dl_sort_maps_dfs (bug 28937)").
Reviewed-by: DJ Delorie <dj@redhat.com>
98 lines
3.4 KiB
C
98 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
|
|
}
|