diff options
author | Rich Felker <dalias@aerifal.cx> | 2020-11-11 00:22:34 -0500 |
---|---|---|
committer | Rich Felker <dalias@aerifal.cx> | 2020-11-11 11:38:21 -0500 |
commit | 8d37958d58cf36f53d5fcc7a8aa6d633da6071b2 (patch) | |
tree | b04e2052a928ff8df412a1ae52fc1c3489c75077 /src/time/__tz.c | |
parent | c1e5d243b7e39b2fbfb17144608ce045575d8e95 (diff) | |
download | musl-8d37958d58cf36f53d5fcc7a8aa6d633da6071b2.tar.gz musl-8d37958d58cf36f53d5fcc7a8aa6d633da6071b2.tar.bz2 musl-8d37958d58cf36f53d5fcc7a8aa6d633da6071b2.tar.xz musl-8d37958d58cf36f53d5fcc7a8aa6d633da6071b2.zip |
give libc access to its own malloc even if public malloc is interposed
allowing the application to replace malloc (since commit
c9f415d7ea2dace5bf77f6518b6afc36bb7a5732) has brought multiple
headaches where it's used from various critical sections in libc
components. for example:
- the thread-local message buffers allocated for dlerror can't be
freed at thread exit time because application code would then run in
the context of a non-existant thread. this was handled in commit
aa5a9d15e09851f7b4a1668e9dbde0f6234abada by queuing them for free
later.
- the dynamic linker has to be careful not to pass memory allocated at
early startup time (necessarily using its own malloc) to realloc or
free after redoing relocations with the application and all
libraries present. bugs in this area were fixed several times, at
least in commits 0c5c8f5da6e36fe4ab704bee0cd981837859e23f and
2f1f51ae7b2d78247568e7fdb8462f3c19e469a4 and possibly others.
- by calling the allocator from contexts where libc-internal locks are
held, we impose undocumented requirements on alternate malloc
implementations not to call into any libc function that might
attempt to take these locks; if they do, deadlock results.
- work to make fork of a multithreaded parent give the child an
unrestricted execution environment is blocked by lock order issues
as long as the application-provided allocator can be called with
libc-internal locks held.
these problems are all fixed by giving libc internals access to the
original, non-replaced allocator, for use where needed. it can't be
used everywhere, as some interfaces like str[n]dup, open_[w]memstream,
getline/getdelim, etc. are required to provide the called memory
obtained as if by (the public) malloc. and there are a number of libc
interfaces that are "pure library" code, not part of some internal
singleton, and where using the application's choice of malloc
implementation is preferable -- things like glob, regex, etc.
one might expect there to be significant cost to static-linked
programs, pulling in two malloc implementations, one of them
mostly-unused, if malloc is replaced. however, in almost all of the
places where malloc is used internally, care has been taken already
not to pull in realloc/free (i.e. to link with just the bump
allocator). this size optimization carries over automatically.
the newly-exposed internal allocator functions are obtained by
renaming the actual definitions, then adding new wrappers around them
with the public names. technically __libc_realloc and __libc_free
could be aliases rather than needing a layer of wrapper, but this
would almost surely break certain instrumentation (valgrind) and the
size and performance difference is negligible. __libc_calloc needs to
be handled specially since calloc is designed to work with either the
internal or the replaced malloc.
as a bonus, this change also eliminates the longstanding ugly
dependency of the static bump allocator on order of object files in
libc.a, by making it so there's only one definition of the malloc
function and having it in the same source file as the bump allocator.
Diffstat (limited to 'src/time/__tz.c')
0 files changed, 0 insertions, 0 deletions