diff options
author | Rich Felker <dalias@aerifal.cx> | 2019-03-01 21:06:23 -0500 |
---|---|---|
committer | Rich Felker <dalias@aerifal.cx> | 2019-03-03 12:06:22 -0500 |
commit | 188759bbee057aa94db2bbb7cf7f5855f3b9ab53 (patch) | |
tree | 59ebf2435dc6fb8ec23b922141a4ec0ffaf5a619 /crt/arm | |
parent | 88207361ea3ece1141af2adeac6069aa866e0de0 (diff) | |
download | musl-188759bbee057aa94db2bbb7cf7f5855f3b9ab53.tar.gz musl-188759bbee057aa94db2bbb7cf7f5855f3b9ab53.tar.bz2 musl-188759bbee057aa94db2bbb7cf7f5855f3b9ab53.tar.xz musl-188759bbee057aa94db2bbb7cf7f5855f3b9ab53.zip |
overhaul shared library ctor execution for dependency order, concurrency
previously, shared library constructors at program start and dlopen
time were executed in reverse load order. some libraries, however,
rely on a depth-first dependency order, which most other dynamic
linker implementations provide. this is a much more reasonable, less
arbitrary order, and it turns out to have much better properties with
regard to how slow-running ctors affect multi-threaded programs, and
how recursive dlopen behaves.
this commit builds on previous work tracking direct dependencies of
each dso (commit 403555690775f7c8806372644f543518e6664e3b), and
performs a topological sort on the dependency graph at load time while
the main ldso lock is held and before success is committed, producing
a queue of constructors needed by the newly-loaded dso (or main
application). in the case of circular dependencies, the dependency
chain is simply broken at points where it becomes circular.
when the ctor queue is run, the init_fini_lock is held only for
iteration purposes; it's released during execution of each ctor, so
that arbitrarily-long-running application code no longer runs with a
lock held in the caller. this prevents a dlopen with slow ctors in one
thread from arbitrarily delaying other threads that call dlopen.
fully-independent ctors can run concurrently; when multiple threads
call dlopen with a shared dependency, one will end up executing the
ctor while the other waits on a condvar for it to finish.
another corner case improved by these changes is recursive dlopen
(call from a ctor). previously, recursive calls to dlopen could cause
a ctor for a library to be executed before the ctor for its
dependency, even when there was no relation between the calling
library and the library it was loading, simply due to the naive
reverse-load-order traversal. now, we can guarantee that recursive
dlopen in non-circular-dependency usage preserves the desired ctor
execution order properties, and that even in circular usage, at worst
the libraries whose ctors call dlopen will fail to have completed
construction when ctors that depend on them run.
init_fini_lock is changed to a normal, non-recursive mutex, since it
is no longer held while calling back into application code.
Diffstat (limited to 'crt/arm')
0 files changed, 0 insertions, 0 deletions