oweals/musl.git
5 years agoimplement inline 5- and 6-argument syscalls for mipsn32 and mips64
Rich Felker [Wed, 10 Apr 2019 23:51:47 +0000 (19:51 -0400)]
implement inline 5- and 6-argument syscalls for mipsn32 and mips64

n32 and n64 ABIs add new argument registers vs o32, so that passing on
the stack is not necessary, so it's not clear why the 5- and
6-argument versions were special-cased to begin with; it seems to have
been pattern-copying from arch/mips (o32).

i've treated the new argument registers like the first 4 in terms of
clobber status (non-clobbered). hopefully this is correct.

5 years agocleanup mips64 syscall_arch functions
Rich Felker [Wed, 10 Apr 2019 23:45:17 +0000 (19:45 -0400)]
cleanup mips64 syscall_arch functions

5 years agoimplement inline 5- and 6-argument syscalls for mips
Rich Felker [Wed, 10 Apr 2019 23:23:15 +0000 (19:23 -0400)]
implement inline 5- and 6-argument syscalls for mips

the OABI passes these on the stack, using the convention that their
position on the stack is as if the first four arguments (in registers)
also had stack slots. originally this was deemed too awkward to do
inline, falling back to external __syscall, but it's not that bad and
now that external __syscall is being removed, it's necessary.

5 years agouse inline syscalls for powerpc (32-bit)
Rich Felker [Wed, 10 Apr 2019 22:34:38 +0000 (18:34 -0400)]
use inline syscalls for powerpc (32-bit)

the inline syscall code is copied directly from powerpc64. the extent
of register clobber specifiers may be excessive on both; if that turns
out to be the case it can be fixed later.

5 years agoremove cruft for supposedly-buggy clang from or1k & microblaze syscall_arch
Rich Felker [Wed, 10 Apr 2019 22:07:51 +0000 (18:07 -0400)]
remove cruft for supposedly-buggy clang from or1k & microblaze syscall_arch

it was never demonstrated to me that this workaround was needed, and
seems likely that, if there ever was any clang version for which it
was needed, it's old enough to be unusably buggy in other ways. if it
turns out some compilers actually can't do the register allocation
right, we'll need to replace this with inline shuffling code, since
the external __syscall dependency is being removed.

5 years agooverhaul i386 syscall mechanism not to depend on external asm source
Rich Felker [Wed, 10 Apr 2019 21:10:36 +0000 (17:10 -0400)]
overhaul i386 syscall mechanism not to depend on external asm source

this is the first part of a series of patches intended to make
__syscall fully self-contained in the object file produced using
syscall.h, which will make it possible for crt1 code to perform
syscalls.

the (confusingly named) i386 __vsyscall mechanism, which this commit
removes, was introduced before the presence of a valid thread pointer
was mandatory; back then the thread pointer was setup lazily only if
threads were used. the intent was to be able to perform syscalls using
the kernel's fast entry point in the VDSO, which can use the sysenter
(Intel) or syscall (AMD) instruction instead of int $128, but without
inlining an access to the __syscall global at the point of each
syscall, which would incur a significant size cost from PIC setup
everywhere. the mechanism also shuffled registers/calling convention
around to avoid spills of call-saved registers, and to avoid
allocating ebx or ebp via asm constraints, since there are plenty of
broken-but-supported compiler versions which are incapable of
allocating ebx with -fPIC or ebp with -fno-omit-frame-pointer.

the new mechanism preserves the properties of avoiding spills and
avoiding allocation of ebx/ebp in constraints, but does it inline,
using some fairly simple register shuffling, and uses a field of the
thread structure rather than global data for the vdso-provided syscall
code address.

for now, the external __syscall function is refactored not to use the
old __vsyscall so it can be kept, but the intent is to remove it too.

5 years agorelease 1.1.22 v1.1.22
Rich Felker [Wed, 10 Apr 2019 00:39:21 +0000 (20:39 -0400)]
release 1.1.22

5 years agoin membarrier fallback, allow for possibility that sigaction fails
Rich Felker [Tue, 9 Apr 2019 21:51:54 +0000 (17:51 -0400)]
in membarrier fallback, allow for possibility that sigaction fails

this is a workaround to avoid a crashing regression on qemu-user when
dynamic TLS is installed at dlopen time. the sigaction syscall should
not be able to fail, but it does fail for implementation-internal
signals under qemu user-level emulation if the host libc qemu is
running under reserves the same signals for implementation-internal
use, since qemu makes no provision to redirect/emulate them. after
sigaction fails, the subsequent tkill would terminate the process
abnormally as the default action.

no provision to account for membarrier failing is made in the dynamic
linker code that installs new TLS. at the formal level, the missing
barrier in this case is incorrect, and perhaps we should fail the
dlopen operation, but in practice all the archs we support (and
probably all real-world archs except alpha, which isn't yet supported)
should give the right behavior with no barrier at all as a consequence
of consume-order properties.

in the long term, this workaround should be supplemented or replaced
by something better -- a different fallback approach to ensuring
memory consistency, or dynamic allocation of implementation-internal
signals. the latter is appealing in that it would allow cancellation
to work under qemu-user too, and would even allow many levels of
nested emulation.

5 years agofix the use of syscall result in dl_mmap
Ilya Matveychikov [Sat, 9 Feb 2019 14:56:17 +0000 (18:56 +0400)]
fix the use of syscall result in dl_mmap

5 years agofix signature of function accepted by makecontext
Bobby Bingham [Fri, 5 Apr 2019 17:26:17 +0000 (12:26 -0500)]
fix signature of function accepted by makecontext

This parameter was incorrectly declared to be a pointer to a function
accepting zero parameters.  The intent of makecontext is that it is
possible to pass integer parameters to the function, so this should
have been a pointer to a function accepting an unspecified set of
parameters.

5 years agofix unintended global symbols in atanl.c
Dan Gohman [Wed, 3 Apr 2019 12:48:50 +0000 (05:48 -0700)]
fix unintended global symbols in atanl.c

Mark atanhi, atanlo, and aT in atanl.c as static, as they're not
intended to be part of the public API.

These are already static in the LDBL_MANT_DIG == 64 code, so this
patch is just making the LDBL_MANT_DIG == 113 code do the same thing.

5 years agouse __strchrnul instead of strchr and strlen in execvpe
Frediano Ziglio [Tue, 26 Mar 2019 09:36:47 +0000 (09:36 +0000)]
use __strchrnul instead of strchr and strlen in execvpe

The result is the same but takes less code.
Note that __execvpe calls getenv which calls __strchrnul so even
using static output the size of the executable won't grow.

5 years agodelete a redundant if in dynamic linker ctor execution loop
Ray [Wed, 13 Mar 2019 10:12:17 +0000 (10:12 +0000)]
delete a redundant if in dynamic linker ctor execution loop

5 years agofix harmless-by-chance typo in priority inheritance mutex code
Rich Felker [Mon, 1 Apr 2019 22:51:50 +0000 (18:51 -0400)]
fix harmless-by-chance typo in priority inheritance mutex code

commit 54ca677983d47529bab8752315ac1a2b49888870 inadvertently
introduced bitwise and where logical and was intended. since the
right-hand operand is always 0 or -1 whenever the left-hand operand is
nonzero, the behavior happened to be equivalent.

5 years agoimplement priority inheritance mutexes
Rich Felker [Sun, 31 Mar 2019 22:03:27 +0000 (18:03 -0400)]
implement priority inheritance mutexes

priority inheritance is a feature to mitigate priority inversion
situations, where a execution of a medium-priority thread can
unboundedly block forward progress of a high-priority thread when a
lock it needs is held by a low-priority thread.

the natural way to do priority inheritance would be with a simple
futex flag to donate the calling thread's priority to a target thread
while it waits on the futex. unfortunately, linux does not offer such
an interface, but instead insists on implementing the whole locking
protocol in kernelspace with special futex commands that exist solely
for the purpose of doing PI mutexes. this would require the entire
"trylock" logic to be duplicated in the timedlock code path for PI
mutexes, since, once the previous lock holder releases the lock and
the futex call returns, the lock is already held by the caller.
obviously such code duplication is undesirable.

instead, I've made the PI timedlock success path set the mutex lock
count to -1, which can be thought of as "not yet complete", since a
lock count of 0 is "locked, with no recursive references". a simple
branch in a non-hot path of pthread_mutex_trylock can then see and act
on this state, skipping past the code that would check and take the
lock to the same code path that runs after the lock is obtained for a
non-PI mutex.

because we're forced to let the kernel perform the actual lock and
unlock operations whenever the mutex is contended, we have to patch
things up when it does the wrong thing:

1. the lock operation is not aware of whether the mutex is
   error-checking, so it will always fail with EDEADLK rather than
   deadlocking.

2. the lock operation is not aware of whether the mutex is robust, so
   it will successfully obtain mutexes in the owner-died state even if
   they're non-robust, whereas this operation should deadlock.

3. the unlock operation always sets the lock value to zero, whereas
   for robust mutexes, we want to set it to a special value indicating
   that the mutex obtained after its owner died was unlocked without
   marking it consistent, so that future operations all fail with
   ENOTRECOVERABLE.

the first of these is easy to solve, just by performing a futex wait
on a dummy futex address to simulate deadlock or ETIMEDOUT as
appropriate. but problems 2 and 3 interact in a nasty way. to solve
problem 2, we need to back out the spurious success. but if waiters
are present -- which we can't just ignore, because even if we don't
want to wake them, the calling thread is incorrectly inheriting their
priorities -- this requires using the kernel's unlock operation, which
will zero the lock value, thereby losing the "owner died with lock
held" state.

to solve these problems, we overload the mutex's waiters field, which
is unused for PI mutexes since they don't call the normal futex wait
functions, as an indicator that the PI mutex is permanently
non-lockable. originally I wanted to use the count field, but there is
one code path that needs to access this flag without synchronization:
trylock's CAS failure path needs to be able to decide whether to fail
with EBUSY or ENOTRECOVERABLE, the waiters field is already treated as
a relaxed-order atomic in our memory model, so this works out nicely.

5 years agoclean up access to mutex type in pthread_mutex_trylock
Rich Felker [Fri, 29 Mar 2019 19:49:14 +0000 (15:49 -0400)]
clean up access to mutex type in pthread_mutex_trylock

there was no point in masking off the pshared bit when first loading
the type, since every subsequent access involves a mask anyway. not
masking it may avoid a subsequent load to check the pshared flag, and
it's just simpler.

5 years agosupport archs with no renameat syscall, only renameat2
Drew DeVault [Thu, 21 Mar 2019 15:32:39 +0000 (11:32 -0400)]
support archs with no renameat syscall, only renameat2

5 years agosupport archs with no mlock syscall, only mlock2
Drew DeVault [Thu, 21 Mar 2019 15:32:38 +0000 (11:32 -0400)]
support archs with no mlock syscall, only mlock2

5 years agofix data race choosing next key slot in pthread_key_create
Rich Felker [Thu, 21 Mar 2019 17:58:12 +0000 (13:58 -0400)]
fix data race choosing next key slot in pthread_key_create

commit 84d061d5a31c9c773e29e1e2b1ffe8cb9557bc58 wrongly moved the
access to the global next_key outside of the scope of the lock. the
error manifested as spurious failure to find an available key slot
under concurrent calls to pthread_key_create, since the stopping
condition could be met after only a small number of slots were
examined.

5 years agofix crash/out-of-bound read in sscanf
Rich Felker [Fri, 15 Mar 2019 00:52:18 +0000 (20:52 -0400)]
fix crash/out-of-bound read in sscanf

commit d6c855caa88ddb1ab6e24e23a14b1e7baf4ba9c7 caused this
"regression", though the behavior was undefined before, overlooking
that f->shend=0 was being used as a sentinel for "EOF" status (actual
EOF or hitting the scanf field width) of the stream helper (shgetc)
functions.

obviously the shgetc macro could be adjusted to check for a null
pointer in addition to the != comparison, but it's the hot path, and
adding extra code/branches to it begins to defeat the purpose.

so instead of setting shend to a null pointer to block further reads,
which no longer works, set it to the current position (rpos). this
makes the shgetc macro work with no change, but it breaks shunget,
which can no longer look at the value of shend to determine whether to
back up. Szabolcs Nagy suggested a solution which I'm using here:
setting shlim to a negative value is inexpensive to test at shunget
time, and automatically re-trips the cnt>=shlim stop condition in
__shgetc no matter what the original limit was.

5 years agofix namespace violation in dependencies of mtx_lock
Rich Felker [Thu, 14 Mar 2019 03:23:26 +0000 (23:23 -0400)]
fix namespace violation in dependencies of mtx_lock

commit 2de29bc994029b903a366b8a4a9f8c3c3ee2be90 left behind one
reference to pthread_mutex_trylock. fixing this also improves code
generation due to the namespace-safe version being hidde.

5 years agoaarch64: add HWCAP_ definitions from linux v5.0
Szabolcs Nagy [Thu, 7 Mar 2019 21:58:12 +0000 (21:58 +0000)]
aarch64: add HWCAP_ definitions from linux v5.0

HWCAP_SB - speculation barrier instruction available added in linux
commit bd4fb6d270bc423a9a4098108784f7f9254c4e6d
HWCAP_PACA, HWCAP_PACG - pointer authentication instructions available
(address and generic) added in linux commit
7503197562567b57ec14feb3a9d5400ebc56812f

5 years agosys/prctl.h: add PR_PAC_RESET_KEYS from linux v5.0
Szabolcs Nagy [Thu, 7 Mar 2019 21:53:48 +0000 (21:53 +0000)]
sys/prctl.h: add PR_PAC_RESET_KEYS from linux v5.0

aarch64 pointer authentication code related prctl that allows
reinitializing the key for the thread, added in linux commit
ba830885656414101b2f8ca88786524d4bb5e8c1

5 years agoelf.h: add NT_ definitions from linux v5.0
Szabolcs Nagy [Thu, 7 Mar 2019 21:43:45 +0000 (21:43 +0000)]
elf.h: add NT_ definitions from linux v5.0

NT_MIPS_MSA for ptrace access to mips simd arch reg set, added in linux
commit 3cd640832894b85b5929d5bda74505452c800421
NT_ARM_PAC_MASK for ptrace access to pointer auth code mask, added in
commit ec6e822d1a22d0eef1d1fa260dff751dba9a4258

5 years agoelf.h: update with C-SKY definitions
Szabolcs Nagy [Thu, 7 Mar 2019 21:29:40 +0000 (21:29 +0000)]
elf.h: update with C-SKY definitions

C-SKY support was added to binutils 2.32 in commit
b8891f8d622a31306062065813fc278d8a94fe21
the elf.h change was added to glibc 2.29 in commit
4975f0c3d0131fdf697be0b1631c265e5fd39088

5 years agoaarch64, or1k: add kexec_file_load syscall number from linux v5.0
Szabolcs Nagy [Thu, 7 Mar 2019 21:07:45 +0000 (21:07 +0000)]
aarch64, or1k: add kexec_file_load syscall number from linux v5.0

added in linux commit 4e21565b7fd4d9045765f697887e74a704135fe2

5 years agonetinet/tcp.h: add TCP_NLA_SRTT from linux v5.0
Szabolcs Nagy [Wed, 6 Mar 2019 22:30:30 +0000 (22:30 +0000)]
netinet/tcp.h: add TCP_NLA_SRTT from linux v5.0

smoothed RTT for SCM_TIMESTAMPING_OPT_STATS control messages.
added in linux commit e8bd8fca6773ef49390269bd467bf940a0841ccf

5 years agonetinet/udp.h: add UDP_GRO from linux v5.0
Szabolcs Nagy [Wed, 6 Mar 2019 22:24:05 +0000 (22:24 +0000)]
netinet/udp.h: add UDP_GRO from linux v5.0

sockopt to enable gro for udp.
added in linux commit e20cf8d3f1f763ad28a9cb3b41305b8a8a42653e

5 years agopowerpc: add PTRACE_SYSEMU from linux v4.20
Szabolcs Nagy [Sun, 24 Feb 2019 17:54:33 +0000 (17:54 +0000)]
powerpc: add PTRACE_SYSEMU from linux v4.20

added in linux commit 5521eb4bca2db733952f068c37bdf3cd656ad23c

5 years agoaarch64: add HWCAP_SSBS from linux v4.20
Szabolcs Nagy [Sun, 24 Feb 2019 17:27:39 +0000 (17:27 +0000)]
aarch64: add HWCAP_SSBS from linux v4.20

for armv8.5 speculative store bypass PSTATE bit support,
added in linux commit d71be2b6c0e19180b5f80a6d42039cc074a693a2

5 years agobits/ioctl.h: add TIOC{G,S}ISO7816 from linux v4.20
Szabolcs Nagy [Wed, 23 Jan 2019 21:18:55 +0000 (21:18 +0000)]
bits/ioctl.h: add TIOC{G,S}ISO7816 from linux v4.20

ISO7816 smart cards ioctls.
linux commit ad8c0eaa0a418ae8ef3f9217638bb86439399eac

the actual kernel definitions are

 #define TIOCGISO7816 _IOR('T', 0x42, struct serial_iso7816)
 #define TIOCSISO7816 _IOWR('T', 0x43, struct serial_iso7816)

where struct serial_iso7816 is defined in linux/serial.h as

struct serial_iso7816 {
__u32   flags;
__u32   tg;
__u32   sc_fi;
__u32   sc_di;
__u32   clk;
__u32   reserved[5];
};

5 years agosys/prctl.h: add PR_SPEC_INDIRECT_BRANCH from linux v4.20
Szabolcs Nagy [Wed, 23 Jan 2019 20:50:55 +0000 (20:50 +0000)]
sys/prctl.h: add PR_SPEC_INDIRECT_BRANCH from linux v4.20

prctls to allow per task control of indirect branch speculation on x86.

added in linux commit 9137bb27e60e554dab694eafa4cca241fa3a694f

5 years agonetinet/in.h add IPV6_MULTICAST_ALL from linux v4.20
Szabolcs Nagy [Wed, 23 Jan 2019 20:41:29 +0000 (20:41 +0000)]
netinet/in.h add IPV6_MULTICAST_ALL from linux v4.20

ipv6 analogue of IP_MULTICAST_ALL sockopt.

added in linux commit 15033f0457dca569b284bef0c8d3ad55fb37eacb

5 years agoadd PACKET_IGNORE_OUTGOING sockopt from linux v4.20
Szabolcs Nagy [Tue, 22 Jan 2019 23:01:37 +0000 (23:01 +0000)]
add PACKET_IGNORE_OUTGOING sockopt from linux v4.20

new in linux commit fa788d986a3aac5069378ed04697bd06f83d3488

5 years agosys/mman.h: add new hugetlb mmap flags from linux v4.19
Szabolcs Nagy [Sat, 10 Nov 2018 21:00:06 +0000 (21:00 +0000)]
sys/mman.h: add new hugetlb mmap flags from linux v4.19

aarch64 supports 32MB and 512MB hugetlb page sizes too.
added in linux commit 20916d4636a9b3c1bf562b305f91d126771edaf9

5 years agoarm: add io_pgetevents syscall number from v4.19
Szabolcs Nagy [Sat, 10 Nov 2018 20:52:43 +0000 (20:52 +0000)]
arm: add io_pgetevents syscall number from v4.19

wired up in linux commit 73aeb2cbcdc9be391b3d32a55319a59ce425426f

5 years agoaarch64, or1k: define rseq syscall number following linux v4.19
Szabolcs Nagy [Sat, 10 Nov 2018 20:48:50 +0000 (20:48 +0000)]
aarch64, or1k: define rseq syscall number following linux v4.19

added in linux commit db7a2d1809a5b6b08d138ff68837f805fc073351

5 years agoelf.h: add new mips core dump note values from linux v4.19
Szabolcs Nagy [Sat, 10 Nov 2018 20:37:46 +0000 (20:37 +0000)]
elf.h: add new mips core dump note values from linux v4.19

NT_MIPS_FP_MODE is new in linux commit
1ae22a0e35636efceab83728ba30b013df761592

NT_MIPS_DSP is new in linux commit
44109c60176ae73924a42a6bef64ef151aba9095

5 years agonetinet/udp.h: add UDP_ENCAP_RXRPC from linux v4.19
Szabolcs Nagy [Wed, 6 Mar 2019 22:03:42 +0000 (22:03 +0000)]
netinet/udp.h: add UDP_ENCAP_RXRPC from linux v4.19

used for optimizing the rxrpc protocol
added in linux commit 5271953cad31b97dea80f848c16e96ad66401199

5 years agonetinet/tcp.h: add tcp_info fields from linux v4.19
Szabolcs Nagy [Sat, 10 Nov 2018 20:04:50 +0000 (20:04 +0000)]
netinet/tcp.h: add tcp_info fields from linux v4.19

new fields for RFC 4898 tcp stats in linux
tcpi_bytes_sent added in commit ba113c3aa79a7f941ac162d05a3620bdc985c58d
tcpi_bytes_retrans added in commit fb31c9b9f6c85b1bad569ecedbde78d9e37cd87b
tcpi_dsack_dups added in commit 7e10b6554ff2ce7f86d5d3eec3af5db8db482caa
tcpi_reord_seen added in commit 7ec65372ca534217b53fd208500cf7aac223a383

The new fields change the size of a public struct and thus an ABI break,
but this is how the getsockopt TCP_INFO api is designed: the tcp_info
type must only be used with a length parameter in extern interfaces.

5 years agosys/inotify.h: add IN_MASK_CREATE from linux v4.19
Szabolcs Nagy [Sat, 10 Nov 2018 19:25:28 +0000 (19:25 +0000)]
sys/inotify.h: add IN_MASK_CREATE from linux v4.19

inotify_add_watch flag to prevent modifying existing watch descriptors,
when used on an already watched inode it fails with EEXIST.
added in linux commit 4d97f7d53da7dc830dbf416a3d2a6778d267ae68

5 years agosys/socket.h: add SO_TXTIME from linux v4.19
Szabolcs Nagy [Sat, 10 Nov 2018 18:29:58 +0000 (18:29 +0000)]
sys/socket.h: add SO_TXTIME from linux v4.19

added in linux commit 80b14dee2bea128928537d61c333f24cb8cbb62f

5 years agohandle labels with 8-bit byte values in dn_skipname
Ryan Fairfax [Thu, 7 Mar 2019 21:20:54 +0000 (13:20 -0800)]
handle labels with 8-bit byte values in dn_skipname

The original logic considered each byte until it either found a 0
value or a value >= 192. This means if a string segment contained any
byte >= 192 it was interepretted as a compressed segment marker even
if it wasn't in a position where it should be interpretted as such.

The fix is to adjust dn_skipname to increment by each segments size
rather than look at each character. This avoids misinterpretting
string segment characters by not considering those bytes.

5 years agofix POSIX_FADV_DONTNEED/_NOREUSE on s390x
Jonathan Neuschäfer [Wed, 20 Feb 2019 18:07:12 +0000 (19:07 +0100)]
fix POSIX_FADV_DONTNEED/_NOREUSE on s390x

On s390x, POSIX_FADV_DONTNEED and POSIX_FADV_NOREUSE have different
values than on all other architectures that Linux supports.

Handle this difference by wrapping their definitions in
include/fcntl.h in #ifdef, so that arch/s390x/bits/fcntl.h can
override them.

5 years agoexpose TSVTX unconditionally in tar.h
Rich Felker [Wed, 13 Mar 2019 14:38:12 +0000 (10:38 -0400)]
expose TSVTX unconditionally in tar.h

as noted in Austin Group issue #1236, the XSI shading for TSVTX is
misplaced in the html version of the standard; it was only supposed to
be on the description text. the intent was that the definition always
be visible, which is reflected in the pdf version of the standard.

this reverts commits d93c0740d86aaf7043e79b942a6c0b3f576af4c8 and
729fef0a9358e2f6f1cd8c75a1a0f7ee48b08c95.

5 years agosetvbuf: return failure if mode is invalid
A. Wilcox [Tue, 12 Mar 2019 20:31:22 +0000 (15:31 -0500)]
setvbuf: return failure if mode is invalid

POSIX requires setvbuf to return non-zero if `mode` is not one of _IONBF,
_IOLBF, or _IOFBF.

5 years agomake FILE a complete type for pre-C11 standard profiles
Rich Felker [Tue, 12 Mar 2019 19:24:00 +0000 (15:24 -0400)]
make FILE a complete type for pre-C11 standard profiles

C11 removed the requirement that FILE be a complete type, which was
deemed erroneous, as part of the changes introduced by N1439 regarding
completeness of types (see footnote 6 for specific mention of FILE).
however the current version of POSIX is still based on C99 and
incorporates the old requirement that FILE be a complete type.

expose an arbitrary, useless complete type definition because the
actual object used to represent FILE streams cannot be public/ABI.

thanks to commit 13d1afa46f8098df290008c681816c9eb89ffbdb, we now have
a framework for suppressing the public complete-type definition of FILE
when stdio.h is included internally, so that a different internal
definition can be provided. this is perfectly well-defined, since the
same struct tag can refer to different types in different translation
units. it would be a problem if the implementation were accessing the
application's FILE objects or vice versa, but either would be
undefined behavior.

5 years agofix invalid-/double-/use-after-free in new dlopen ctor execution
Rich Felker [Sun, 10 Mar 2019 17:16:59 +0000 (13:16 -0400)]
fix invalid-/double-/use-after-free in new dlopen ctor execution

this affected the error path where dlopen successfully found and
loaded the requested dso and all its dependencies, but failed to
resolve one or more relocations, causing the operation to fail after
storage for the ctor queue was allocated.

commit 188759bbee057aa94db2bbb7cf7f5855f3b9ab53 wrongly put the free
for the ctor_queue array in the error path inside a loop over each
loaded dso that needed to be backed-out, rather than just doing it
once. in addition, the exit path also observed the ctor_queue pointer
still being nonzero, and would attempt to call ctors on the backed-out
dsos unless the double-free crashed the process first.

5 years agodon't reject unknown/future flags in sigaltstack, allow SS_AUTODISARM
Rich Felker [Tue, 5 Mar 2019 16:02:15 +0000 (11:02 -0500)]
don't reject unknown/future flags in sigaltstack, allow SS_AUTODISARM

historically, and likely accidentally, sigaltstack was specified to
fail with EINVAL if any flag bit other than SS_DISABLE was set. the
resolution of Austin Group issue 1187 fixes this so that the
requirement is only to fail for SS_ONSTACK (which cannot be set) or
"invalid" flags.

Linux fails on the kernel side for invalid flags, but historically
accepts SS_ONSTACK as a no-op, so it needs to be rejected in userspace
still.

with this change, the Linux-specific SS_AUTODISARM, provided since
commit 9680e1d03a794b0e0d5815c749478228ed40a36d but unusable due to
rejection at runtime, is now usable.

5 years agoavoid malloc of ctor queue for programs with no external deps
Rich Felker [Sun, 3 Mar 2019 18:24:23 +0000 (13:24 -0500)]
avoid malloc of ctor queue for programs with no external deps

together with the previous two commits, this completes restoration of
the property that dynamic-linked apps with no external deps and no tls
have no failure paths before entry.

5 years agoavoid malloc of deps arrays for ldso and vdso
Rich Felker [Sun, 3 Mar 2019 17:42:34 +0000 (12:42 -0500)]
avoid malloc of deps arrays for ldso and vdso

neither has or can have any dependencies, but since commit
403555690775f7c8806372644f543518e6664e3b, gratuitous zero-length deps
arrays were being allocated for them. use a dummy array instead.

5 years agoavoid malloc of deps array for programs with no external deps
Rich Felker [Sun, 3 Mar 2019 17:12:59 +0000 (12:12 -0500)]
avoid malloc of deps array for programs with no external deps

traditionally, we've provided a guarantee that dynamic-linked
applications with no external dependencies (nothing but libc) and no
thread-local storage have no failure paths before the entry point.
normally, thanks to reclaim_gaps, such a malloc will not require a
syscall anyway, but if segment alignment is unlucky, it might. use a
builtin array for this common special case.

5 years agofix malloc misuse for startup ctor queue, breakage on fdpic archs
Rich Felker [Sun, 3 Mar 2019 14:57:19 +0000 (09:57 -0500)]
fix malloc misuse for startup ctor queue, breakage on fdpic archs

in the case where malloc is being replaced, it's not valid to call
malloc between final relocations and main app's crt1 entry point; on
fdpic archs the main app's entry point will not yet have performed the
self-fixups necessary to call its code.

to fix, reorder queue_ctors before final relocations. an alternative
solution would be doing the allocation from __libc_start_init, after
the entry point but before any ctors run. this is less desirable,
since it would leave a call to malloc that might be provided by the
application happening at startup when doing so can be easily avoided.

5 years agosynchronize shared library dtor exec against concurrent loads/ctors
Rich Felker [Sat, 2 Mar 2019 03:47:29 +0000 (22:47 -0500)]
synchronize shared library dtor exec against concurrent loads/ctors

previously, going way back, there was simply no synchronization here.
a call to exit concurrent with ctor execution from dlopen could cause
a dtor to execute concurrently with its corresponding ctor, or could
cause dtors for newly-constructed libraries to be skipped.

introduce a shutting_down state that blocks further ctor execution,
producing the quiescence the dtor execution loop needs to ensure any
kind of consistency, and that blocks further calls to dlopen so that a
call into dlopen from a dtor cannot deadlock.

better approaches to some of this may be possible, but the changes
here at least make things safe.

5 years agooverhaul shared library ctor execution for dependency order, concurrency
Rich Felker [Sat, 2 Mar 2019 02:06:23 +0000 (21:06 -0500)]
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.

5 years agorecord preloaded libraries as direct pseudo-dependencies of main app
Rich Felker [Fri, 1 Mar 2019 20:09:16 +0000 (15:09 -0500)]
record preloaded libraries as direct pseudo-dependencies of main app

this makes calling dlsym on the main app more consistent with the
global symbol table (load order), and is a prerequisite for
dependency-order ctor execution to work correctly with LD_PRELOAD.

5 years agofix unsafety of new ldso dep tracking in presence of malloc replacement
Rich Felker [Fri, 1 Mar 2019 19:37:52 +0000 (14:37 -0500)]
fix unsafety of new ldso dep tracking in presence of malloc replacement

commit 403555690775f7c8806372644f543518e6664e3b introduced runtime
realloc of an array that may have been allocated before symbols were
resolved outside of libc, which is invalid if the allocator has been
replaced. track this condition and manually copy if needed.

5 years agofix and overhaul dlsym depedency order, always record direct deps
Rich Felker [Tue, 26 Feb 2019 23:05:19 +0000 (18:05 -0500)]
fix and overhaul dlsym depedency order, always record direct deps

dlsym with an explicit handle is specified to use "dependency order",
a breadth-first search rooted at the argument. this has always been
implemented by iterating a flattened dependency list built at dlopen
time. however, the logic for building this list was completely wrong
except in trivial cases; it simply used the list of libraries loaded
since a given library, and their direct dependencies, as that
library's dependencies, which could result in misordering, wrongful
omission of deep dependencies from the search, and wrongful inclusion
of unrelated libraries in the search.

further, libraries did not have any recorded list of resolved
dependencies until they were explicitly dlopened, meaning that
DT_NEEDED entries had to be resolved again whenever a library
participated as a dependency of more than one dlopened library.

with this overhaul, the resolved direct dependency list of each
library is always recorded when it is first loaded, and can be
extended to a full flattened breadth-first search list if dlopen is
called on the library. the extension is performed using the direct
dependency list as a queue and appending copies of the direct
dependency list of each dependency in the queue, excluding duplicates,
until the end of the queue is reached. the direct deps remain
available for future use as the initial subarray of the full deps
array.

first-load logic in dlopen is updated to match these changes, and
clarified.

5 years agofix crash/misbehavior from oob read in new dynamic tls installation
Rich Felker [Wed, 27 Feb 2019 17:02:49 +0000 (12:02 -0500)]
fix crash/misbehavior from oob read in new dynamic tls installation

code introduced in commit 9d44b6460ab603487dab4d916342d9ba4467e6b9
wrongly attempted to read past the end of the currently-installed dtv
to determine if a dso provides new, not-already-installed tls. this
logic was probably leftover from an earlier draft of the code that
wrongly installed the new dtv before populating it.

it would work if we instead queried the new, not-yet-installed dtv,
but instead, replace the incorrect check with a simple range check
against old_cnt. this also catches modules that have no tls at all
with a single condition.

5 years agofix crash in new dynamic tls installation when last dep lacks tls
Rich Felker [Mon, 25 Feb 2019 07:09:36 +0000 (02:09 -0500)]
fix crash in new dynamic tls installation when last dep lacks tls

code introduced in commit 9d44b6460ab603487dab4d916342d9ba4467e6b9
wrongly assumed the dso list tail was the right place to find new dtv
storage. however, this is only true if the last-loaded dependency has
tls. the correct place to get it is the dso corresponding to the tls
module list tail. introduce a container_of macro to get it, and use
it.

ultimately, dynamic tls allocation should be refactored so that this
is not an issue. there is no reason to be allocating new dtv space at
each load_library; instead it could happen after all new libraries
have been loaded but before they are committed. such changes may be
made later, but this commit fixes the present regression.

5 years agoadd membarrier syscall wrapper, refactor dynamic tls install to use it
Rich Felker [Fri, 22 Feb 2019 07:56:10 +0000 (02:56 -0500)]
add membarrier syscall wrapper, refactor dynamic tls install to use it

the motivation for this change is twofold. first, it gets the fallback
logic out of the dynamic linker, improving code readability and
organization. second, it provides application code that wants to use
the membarrier syscall, which depends on preregistration of intent
before the process becomes multithreaded unless unbounded latency is
acceptable, with a symbol that, when linked, ensures that this
registration happens.

5 years agomake thread list lock a recursive lock
Rich Felker [Fri, 22 Feb 2019 07:29:21 +0000 (02:29 -0500)]
make thread list lock a recursive lock

this is a prerequisite for factoring the membarrier fallback code into
a function that can be called from a context with the thread list
already locked or independently.

5 years agofix loop logic cruft in dynamic tls installation
Rich Felker [Fri, 22 Feb 2019 07:24:33 +0000 (02:24 -0500)]
fix loop logic cruft in dynamic tls installation

commit 9d44b6460ab603487dab4d916342d9ba4467e6b9 inadvertently
contained leftover logic from a previous approach to the fallback
signaling loop. it had no adverse effect, since j was always nonzero
if the loop body was reachable, but it makes no sense to be there with
the current approach to avoid signaling self.

5 years agofix spurious undefined behavior in getaddrinfo
Rich Felker [Wed, 20 Feb 2019 22:58:21 +0000 (17:58 -0500)]
fix spurious undefined behavior in getaddrinfo

addressing &out[k].sa was arguably undefined, despite &out[k] being
defined the slot one past the end of an array, since the member access
.sa is intervening between the [] operator and the & operator.

5 years agofix invalid free of partial addrinfo list with multiple services
Rich Felker [Wed, 20 Feb 2019 22:51:22 +0000 (17:51 -0500)]
fix invalid free of partial addrinfo list with multiple services

the backindex stored by getaddrinfo to allow freeaddrinfo to perform
partial-free wrongly used the address result index, rather than the
output slot index, and thus was only valid when they were equal
(nservs==1).

patch based on report with proposed fix by Markus Wichmann.

5 years agoinstall dynamic tls synchronously at dlopen, streamline access
Rich Felker [Mon, 18 Feb 2019 04:22:27 +0000 (23:22 -0500)]
install dynamic tls synchronously at dlopen, streamline access

previously, dynamic loading of new libraries with thread-local storage
allocated the storage needed for all existing threads at load-time,
precluding late failure that can't be handled, but left installation
in existing threads to take place lazily on first access. this imposed
an additional memory access and branch on every dynamic tls access,
and imposed a requirement, which was not actually met, that the
dynamic tlsdesc asm functions preserve all call-clobbered registers
before calling C code to to install new dynamic tls on first access.
the x86[_64] versions of this code wrongly omitted saving and
restoring of fpu/vector registers, assuming the compiler would not
generate anything using them in the called C code. the arm and aarch64
versions saved known existing registers, but failed to be future-proof
against expansion of the register file.

now that we track live threads in a list, it's possible to install the
new dynamic tls for each thread at dlopen time. for the most part,
synchronization is not needed, because if a thread has not
synchronized with completion of the dlopen, there is no way it can
meaningfully request access to a slot past the end of the old dtv,
which remains valid for accessing slots which already existed.
however, it is necessary to ensure that, if a thread sees its new dtv
pointer, it sees correct pointers in each of the slots that existed
prior to the dlopen. my understanding is that, on most real-world
coherency architectures including all the ones we presently support, a
built-in consume order guarantees this; however, don't rely on that.
instead, the SYS_membarrier syscall is used to ensure that all threads
see the stores to the slots of their new dtv prior to the installation
of the new dtv. if it is not supported, the same is implemented in
userspace via signals, using the same mechanism as __synccall.

the __tls_get_addr function, variants, and dynamic tlsdesc asm
functions are all updated to remove the fallback paths for claiming
new dynamic tls, and are now all branch-free.

5 years agofix data race between new pthread_key_delete and dtor execution
Rich Felker [Mon, 18 Feb 2019 02:46:14 +0000 (21:46 -0500)]
fix data race between new pthread_key_delete and dtor execution

access to clear the entry in each thread's tsd array for the key being
deleted was not synchronized with __pthread_tsd_run_dtors. I probably
made this mistake from a mistaken belief that the thread list lock was
held during the latter, which of course is not possible since it
executes application code in a still-live-thread context.

while we're at it, expand the interval during which signals are
blocked to cover taking the write lock on key_lock, so that a signal
at an inopportune time doesn't block forward progress of readers.

5 years agointroduce namespace-safe rwlock aliases; use in pthread_key_create
Rich Felker [Sat, 16 Feb 2019 16:44:07 +0000 (11:44 -0500)]
introduce namespace-safe rwlock aliases; use in pthread_key_create

commit 84d061d5a31c9c773e29e1e2b1ffe8cb9557bc58 inadvertently
introduced namespace violations by using the pthread-namespace rwlock
functions in pthread_key_create, which is in turn used for C11 tss.
fix that and possible future uses of rwlocks elsewhere.

5 years agorewrite pthread_key_delete to use global thread list
Rich Felker [Sat, 16 Feb 2019 15:13:31 +0000 (10:13 -0500)]
rewrite pthread_key_delete to use global thread list

with the availability of the thread list, there is no need to mark tsd
key slots dirty and clean them up only when a free slot can't be
found. instead, directly iterate threads and clear any value
associated with the key being deleted.

no synchronization is necessary for the clearing, since there is no
way the slot can be accessed without having synchronized with the
creation of a new key occupying the same slot, which is already
sequenced after and synchronized with the deletion of the old key.

5 years agorewrite __synccall in terms of global thread list
Rich Felker [Sat, 16 Feb 2019 14:13:45 +0000 (09:13 -0500)]
rewrite __synccall in terms of global thread list

the __synccall mechanism provides stop-the-world synchronous execution
of a callback in all threads of the process. it is used to implement
multi-threaded setuid/setgid operations, since Linux lacks them at the
kernel level, and for some other less-critical purposes.

this change eliminates dependency on /proc/self/task to determine the
set of live threads, which in addition to being an unwanted dependency
and a potential point of resource-exhaustion failure, turned out to be
inaccurate. test cases provided by Alexey Izbyshev showed that it
could fail to reflect newly created threads. due to how the
presignaling phase worked, this usually yielded a deadlock if hit, but
in the worst case it could also result in threads being silently
missed (allowed to continue running without executing the callback).

5 years agotrack all live threads in an AS-safe, fully-consistent linked list
Rich Felker [Sat, 16 Feb 2019 03:29:01 +0000 (22:29 -0500)]
track all live threads in an AS-safe, fully-consistent linked list

the hard problem here is unlinking threads from a list when they exit
without creating a window of inconsistency where the kernel task for a
thread still exists and is still executing instructions in userspace,
but is not reflected in the list. the magic solution here is getting
rid of per-thread exit futex addresses (set_tid_address), and instead
using the exit futex to unlock the global thread list.

since pthread_join can no longer see the thread enter a detach_state
of EXITED (which depended on the exit futex address pointing to the
detach_state), it must now observe the unlocking of the thread list
lock before it can unmap the joined thread and return. it doesn't
actually have to take the lock. for this, a __tl_sync primitive is
offered, with a signature that will allow it to be enhanced for quick
return even under contention on the lock, if needed. for now, the
exiting thread always performs a futex wake on its detach_state. a
future change could optimize this out except when there is already a
joiner waiting.

initial/dynamic variants of detached state no longer need to be
tracked separately, since the futex address is always set to the
global list lock, not a thread-local address that could become invalid
on detached thread exit. all detached threads, however, must perform a
second sigprocmask syscall to block implementation-internal signals,
since locking the thread list with them already blocked is not
permissible.

the arch-independent C version of __unmapself no longer needs to take
a lock or setup its own futex address to release the lock, since it
must necessarily be called with the thread list lock already held,
guaranteeing exclusive access to the temporary stack.

changes to libc.threads_minus_1 no longer need to be atomic, since
they are guarded by the thread list lock. it is largely vestigial at
this point, and can be replaced with a cheaper boolean indicating
whether the process is multithreaded at some point in the future.

5 years agoalways block signals for starting new threads, refactor start args
Rich Felker [Sat, 16 Feb 2019 00:58:09 +0000 (19:58 -0500)]
always block signals for starting new threads, refactor start args

whether signals need to be blocked at thread start, and whether
unblocking is necessary in the entry point function, has historically
depended on intricacies of the cancellation design and on whether
there are scheduling operations to perform on the new thread before
its successful creation can be committed. future changes to track an
AS-safe list of live threads will require signals to be blocked
whenever changes are made to the list, so ...

prior to commits b8742f32602add243ee2ce74d804015463726899 and
40bae2d32fd6f3ffea437fa745ad38a1fe77b27e, a signal mask for the entry
function to restore was part of the pthread structure. it was removed
to trim down the size of the structure, which both saved a small
amount of stack space and improved code generation on archs where
small immediate displacements are less costly than arbitrary ones, by
limiting the range of offsets between the base of the thread
structure, its members, and the thread pointer. these commits moved
the saved mask to a special structure used only when special
scheduling was needed, in which case the pthread_create caller and new
thread had to synchronize with each other and could use this memory to
pass a mask.

this commit partially reverts the above two commits, but instead of
putting the mask back in the pthread structure, it moves all "start
argument" members out of the pthread structure, trimming it down
further, and puts them in a separate structure passed on the new
thread's stack. the code path for explicit scheduling of the new
thread is also changed to synchronize with the calling thread in such
a way to avoid spurious futex wakes.

5 years agofor SIGEV_THREAD timer threads, replace signal handler with sigwaitinfo
Rich Felker [Fri, 15 Feb 2019 20:23:11 +0000 (15:23 -0500)]
for SIGEV_THREAD timer threads, replace signal handler with sigwaitinfo

this eliminates some ugly hacks that were repurposing the start
function and start argument fields in the pthread structure for timer
use, and the need to longjmp out of a signal handler.

5 years agodefer free of thread-local dlerror buffers from inconsistent context
Rich Felker [Fri, 15 Feb 2019 19:20:49 +0000 (14:20 -0500)]
defer free of thread-local dlerror buffers from inconsistent context

__dl_thread_cleanup is called from the context of an exiting thread
that is not in a consistent state valid for calling application code.
since commit c9f415d7ea2dace5bf77f6518b6afc36bb7a5732, it's possible
(and supported usage) for the allocator to have been replaced by the
application, so __dl_thread_cleanup can no longer call free. instead,
reuse the message buffer as a linked-list pointer, and queue it to be
freed the next time any dynamic linker error message is generated.

5 years agofix behavior of gets when input line contains a null byte
Rich Felker [Wed, 13 Feb 2019 23:48:04 +0000 (18:48 -0500)]
fix behavior of gets when input line contains a null byte

the way gets was implemented in terms of fgets, it used the location
of the null termination to determine where to find and remove the
newline, if any. an embedded null byte prevented this from working.

this also fixes a one-byte buffer overflow, whereby when gets read an
N-byte line (not counting newline), it would store two null
terminators for a total of N+2 bytes. it's unlikely that anyone would
care that a function whose use is pretty much inherently a buffer
overflow writes too much, but it could break the only possible correct
uses of this function, in conjunction with input of known format from
a trusted/same-privilege-domain source, where the buffer length may
have been selected to exactly match a line length contract.

there seems to be no correct way to implement gets in terms of a
single call to fgets or scanf, and using multiple calls would require
explicit locking, so we might as well just write the logic out
explicitly character-at-a-time. this isn't fast, but nobody cares if a
catastrophically unsafe function that's so bad it was removed from the
C language is fast.

5 years agoredesign robust mutex states to eliminate data races on type field
Rich Felker [Wed, 13 Feb 2019 00:56:49 +0000 (19:56 -0500)]
redesign robust mutex states to eliminate data races on type field

in order to implement ENOTRECOVERABLE, the implementation has
traditionally used a bit of the mutex type field to indicate that it's
recovered after EOWNERDEAD and will go into ENOTRECOVERABLE state if
pthread_mutex_consistent is not called before unlocking. while it's
only the thread that holds the lock that needs access to this
information (except possibly for the sake of pthread_mutex_consistent
choosing between EINVAL and EPERM for erroneous calls), the change to
the type field is formally a data race with all other threads that
perform any operation on the mutex. no individual bits race, and no
write races are possible, so things are "okay" in some sense, but it's
still not good.

this patch moves the recovery/consistency state to the mutex
owner/lock field which is rightfully mutable. bit 30, the same bit the
kernel uses with a zero owner to indicate that the previous owner died
holding the lock, is now used with a nonzero owner to indicate that
the mutex is held but has not yet been marked consistent. note that
the kernel ABI also reserves bit 29 not to appear in any tid, so the
sentinel value we use for ENOTRECOVERABLE, 0x7fffffff, does not clash
with any tid plus bit 30.

5 years agofail fdopendir for O_PATH file descriptors
Rich Felker [Thu, 7 Feb 2019 17:51:02 +0000 (12:51 -0500)]
fail fdopendir for O_PATH file descriptors

fdopendir is specified to fail with EBADF if the file descriptor
passed is not open for reading. while O_PATH is an extension and
arguably exempt from this requirement, it's used, albeit incompletely,
to implement O_SEARCH, and fdopendir should fail when passed an
O_SEARCH file descriptor.

the new check is performed after fstat so that we don't have to
consider the possibility that the fd is invalid.

an alternate solution would be attempting to pre-fill the buffer using
getdents, which would fail with EBADF for us, but that seems more
complex and error-prone and involves either code duplication or
refactoring, so the simple fix with an additional inexpensive syscall
is what I've made for now.

5 years agoupdate line discipline constants
Bobby Bingham [Mon, 28 Jan 2019 04:02:51 +0000 (22:02 -0600)]
update line discipline constants

5 years agomove arch-invariant definitions out of bits/ioctl.h
Bobby Bingham [Mon, 28 Jan 2019 04:02:50 +0000 (22:02 -0600)]
move arch-invariant definitions out of bits/ioctl.h

5 years agolocale: ensure dcngettext() preserves errno
A. Wilcox [Mon, 28 Jan 2019 03:34:57 +0000 (21:34 -0600)]
locale: ensure dcngettext() preserves errno

Some packages call gettext to format a message to be sent to perror.
If the currently set user locale points to a non-existent .mo file,
open via __map_file in dcngettext will set errno to ENOENT.

Maintainer's notes: Non-modification of errno is a documented part of
the interface contract for the GNU version of this function and likely
other versions. The issue being fixed here seems to be a regression
from commit 1b52863e244ecee5b5935b6d36bb9e6efe84c035, which enabled
setting of errno from __map_file.

5 years agorelease 1.1.21 v1.1.21
Rich Felker [Mon, 21 Jan 2019 17:30:25 +0000 (12:30 -0500)]
release 1.1.21

5 years agofix call to __pthread_tsd_run_dtors with too many arguments
Rich Felker [Mon, 21 Jan 2019 16:47:55 +0000 (11:47 -0500)]
fix call to __pthread_tsd_run_dtors with too many arguments

commit a6054e3c94aa0491d7366e4b05ae0d73f661bfe2 removed the argument,
making it a constraint violation to pass one. caught by cparser/firm;
other compilers seem to ignore it.

5 years agoconfigure: accept ppc[64] as alias for powerpc[64] in gcc tuples
Rich Felker [Sat, 19 Jan 2019 23:39:54 +0000 (18:39 -0500)]
configure: accept ppc[64] as alias for powerpc[64] in gcc tuples

apparently some distros use this form, and it seems to be supported in
the gcc build system.

5 years agofix unintended linking dependency of pthread_key_create on __synccall
Rich Felker [Thu, 17 Jan 2019 04:50:08 +0000 (23:50 -0500)]
fix unintended linking dependency of pthread_key_create on __synccall

commit 84d061d5a31c9c773e29e1e2b1ffe8cb9557bc58 attempted to do this
already, but omitted from pthread_key_create.c the weak definition of
__pthread_key_delete_synccall, so that the definition provided by
pthread_key_delete.c was always pulled in.

based on patch by Markus Wichmann, but with a weak alias rather than
weak reference for consistency/policy about dependence on tooling
features.

5 years agohalt getspnam[_r] search on error accessing TCB shadow
Rich Felker [Fri, 28 Dec 2018 21:54:13 +0000 (16:54 -0500)]
halt getspnam[_r] search on error accessing TCB shadow

fallback to /etc/shadow should happen only when the entry is not found
in the TCB shadow. otherwise transient errors or permission errors can
cause inconsistent results.

5 years agodon't set errno or return an error when getspnam[_r] finds no entry
Rich Felker [Fri, 28 Dec 2018 21:50:07 +0000 (16:50 -0500)]
don't set errno or return an error when getspnam[_r] finds no entry

this case is specified as success with a null result, rather than an
error, and errno is not to be set on success.

5 years agomake sem_wait and sem_timedwait interruptible by signals
Rich Felker [Thu, 20 Dec 2018 00:32:41 +0000 (19:32 -0500)]
make sem_wait and sem_timedwait interruptible by signals

this reverts commit c0ed5a201b2bdb6d1896064bec0020c9973db0a1, which
was based on a mistaken reading of POSIX due to inconsistency between
the description (which requires return upon interruption by a signal)
and the errors list (which wrongly lists EINTR as "may fail").

since the previously-introduced behavior was a workaround for an old
kernel bug to ensure safety of correct programs that were not hardened
against the bug, an effort has been made to preserve it for programs
which do not use interrupting signal handlers. the stage for this was
set in commit a63c0104e496f7ba78b64be3cd299b41e8cd427f, which makes
the futex __timedwait backend suppress EINTR if it's seen when no
interrupting signal handlers have been installed.

based loosely on a patch submitted by Orivej Desh, but with
unnecessary additional changes removed.

5 years agodon't fail pthread_sigmask/sigprocmask on invalid how when set is null
Rich Felker [Wed, 19 Dec 2018 01:01:20 +0000 (20:01 -0500)]
don't fail pthread_sigmask/sigprocmask on invalid how when set is null

the resolution of Austin Group issue #1132 changes the requirement to
fail so that it only applies when the set argument (new mask) is
non-null. this change was made for consistency with the description,
which specified "if set is a null pointer, the value of the argument
how is not significant".

5 years agoadd __timedwait backend workaround for old kernels where futex EINTRs
Rich Felker [Tue, 18 Dec 2018 17:17:33 +0000 (12:17 -0500)]
add __timedwait backend workaround for old kernels where futex EINTRs

prior to linux 2.6.22, futex wait could fail with EINTR even for
non-interrupting (SA_RESTART) signals. this was no problem provided
the caller simply restarted the wait, but sem_[timed]wait is required
by POSIX to return when interrupted by a signal. commit
a113434cd68ce30642c4995b1caadcd084be6f09 introduced this behavior, and
commit c0ed5a201b2bdb6d1896064bec0020c9973db0a1 reverted it based on a
mistaken belief that it was not required. this belief stems from a bug
in the specification: the description requires the function to return
when interrupted, but the errors section marks EINTR as a "may fail"
condition rather than a "shall fail" one.

since there does seem to be significant value in the change made in
commit c0ed5a201b2bdb6d1896064bec0020c9973db0a1, making it so that
programs that call sem_wait without checking for EINTR don't silently
make forward progress without obtaining the semaphore or treat it as a
fatal error and abort, add a behind-the-scenes mechanism in the
__timedwait backend to suppress EINTR in programs that have never
installed interrupting signal handlers, and have sigaction track and
report this state. this way the semaphore code is not cluttered by
workarounds and can be updated (to be done in next commit) to reflect
the high-level logic for conforming behavior.

these changes are based loosely on a patch by Markus Wichmann, with
the main changes being atomic update to flag object and moving the
workaround from sem_timedwait to the __timedwait futex backend.

5 years agoon failed aio submission, set aiocb error and return value
Rich Felker [Tue, 11 Dec 2018 21:55:31 +0000 (16:55 -0500)]
on failed aio submission, set aiocb error and return value

it's not clear whether this is required, but it seems arguable that it
should happen. for example aio_suspend is supposed to return
immediately if any of the operations has "completed", which includes
ending with an error status asynchonously and might also be
interpreted to include doing so synchronously.

5 years agodon't create aio queue/map structures for invalid file descriptors
Rich Felker [Tue, 11 Dec 2018 21:41:09 +0000 (16:41 -0500)]
don't create aio queue/map structures for invalid file descriptors

the map structures in particular are permanent once created, and thus
a large number of aio function calls with invalid file descriptors
could exhaust memory, whereas, assuming normal resource limits, only a
very small number of entries ever need to be allocated. check validity
of the fd before allocating anything new, so that allocation of large
amounts of memory is only possible when resource limits have been
increased and a large number of files are actually open.

this change also improves error reporting for bad file descriptors to
happen at the time the aio submission call is made, as opposed to
asynchronously.

5 years agomove aio queue allocation from io thread to submitting thread
Rich Felker [Tue, 11 Dec 2018 21:29:07 +0000 (16:29 -0500)]
move aio queue allocation from io thread to submitting thread

since commit c9f415d7ea2dace5bf77f6518b6afc36bb7a5732, it has been
possible that the allocator is application-provided code, which cannot
necessarily run safely on io thread stacks, and which should not be
able to see the existence of io threads, since they are an
implementation detail.

instead of having the io thread request and possibly allocate its
queue (and the map structures leading to it), make the submitting
thread responsible for this, and pass the queue pointer into the io
thread via its args structure. this eliminates the only early error
case in io threads, making it no longer necessary to pass an error
status back to the submitting thread via the args structure.

5 years agofix and future-proof against stack overflow in aio io threads
Rich Felker [Mon, 10 Dec 2018 04:28:47 +0000 (23:28 -0500)]
fix and future-proof against stack overflow in aio io threads

aio threads not using SIGEV_THREAD notification are created with small
stacks and no guard page, which is possible since they only run the
code for the requested io operation, not any application code. the
motivation is not creating a lot of VMAs. however, the io thread needs
to be able to receive a cancellation signal in case aio_cancel
(implemented via pthread_cancel) is called. this requires sufficient
stack space for a signal frame, which PTHREAD_STACK_MIN does not
necessarily include.

in principle MINSIGSTKSZ from signal.h should give us sufficient space
for a signal frame, but the value is incorrect on some existing archs
due to kernel addition of new vector register support without
consideration for impact on ABI. some powerpc models exceed
MINSIGSTKSZ by about 0.5k, and x86[_64] with AVX-512 can exceed it by
up to about 1.5k. so use MINSIGSTKSZ+2048 to allow for the discrepancy
plus some working space.

unfortunately, it's possible that signal frame sizes could continue to
grow, and some archs (aarch64) explicitly specify that they may.
passing of a runtime value for MINSIGSTKSZ via AT_MINSIGSTKSZ in the
aux vector was added to aarch64 linux, and presumably other archs will
use this mechanism to report if they further increase the signal frame
size. when AT_MINSIGSTKSZ is present, assume it's correct, so that we
only need a small amount of working space in addition to it; in this
case just add 512.

5 years agoadd namespace-safe version of getauxval for internal use
Rich Felker [Mon, 10 Dec 2018 03:40:52 +0000 (22:40 -0500)]
add namespace-safe version of getauxval for internal use

5 years agoadd NT_VMCOREDD to elf.h from linux v4.18
Szabolcs Nagy [Wed, 22 Aug 2018 17:56:59 +0000 (17:56 +0000)]
add NT_VMCOREDD to elf.h from linux v4.18

used for device driver dump in /proc/vmcore
new in linux commit 2724273e8fd00b512596a77ee063f49b25f36507

5 years agoadd AT_MINSIGSTKSZ to elf.h from linux v4.18
Szabolcs Nagy [Wed, 22 Aug 2018 17:51:25 +0000 (17:51 +0000)]
add AT_MINSIGSTKSZ to elf.h from linux v4.18

new in linux commit 94b07c1f8c39c6d839df35fa28ffd1785d385897

currently only supported on aarch64

5 years agoadd io_pgetevents and rseq syscall numbers from linux v4.18
Szabolcs Nagy [Wed, 22 Aug 2018 17:31:43 +0000 (17:31 +0000)]
add io_pgetevents and rseq syscall numbers from linux v4.18

io_pgetevents is new in linux commit
7a074e96dee62586c935c80cecd931431bfdd0be

rseq is new in linux commit
d7822b1e24f2df5df98c76f0e94a5416349ff759

5 years agoadd TRAP_UNK si_code to signal.h from linux v4.18
Szabolcs Nagy [Wed, 22 Aug 2018 17:10:55 +0000 (17:10 +0000)]
add TRAP_UNK si_code to signal.h from linux v4.18

used for undiagnosed trap exceptions where linux previously set si_code
to 0. new in linux commit db78e6a0a6f9f7d7277965600eeb1a5b3a6f55a8

5 years agoadd SIGSYS support to sys/signalfd.h from linux v4.18
Szabolcs Nagy [Wed, 22 Aug 2018 16:39:20 +0000 (16:39 +0000)]
add SIGSYS support to sys/signalfd.h from linux v4.18

new in linux commit 76b7f670730e87974f71df9f6129811e2769666e

in struct signalfd_siginfo the pad member is changed to __pad to keep
the namespace clean, it's not part of the public api.

5 years agoadd AF_XDP to sys/socket.h from linux v4.18
Szabolcs Nagy [Wed, 22 Aug 2018 16:28:31 +0000 (16:28 +0000)]
add AF_XDP to sys/socket.h from linux v4.18

new address family and related macros were added in linux commit
68e8b849b221b37a78a110a0307717d45e3593a0