avoid set*id/setrlimit misbehavior and hang in vforked/cloned child

taking the deprecated/dropped vfork spec strictly, doing pretty much
anything but execve in the child is wrong and undefined. however,
these are commonly needed operations to setup the child state before
exec, and historical implementations tolerated them.

for single-threaded parents, these operations already worked as
expected in the vforked child. however, due to the need for __synccall
to synchronize id/resource limit changes among all threads, calling
these functions in the vforked child of a multithreaded parent caused
a misdirected broadcast signaling of all threads in the parent. these
signals could kill the parent entirely if the synccall signal handler
had never been installed in the parent, or could be ignored if it had,
or could signal/kill one or more utterly wrong processes if the parent
already terminated (due to vfork semantics, only possible via fatal
signal) and the parent tids were recycled. in any case, the expected
number of semaphore posts would never happen, so the child would
permanently hang (with all signals blocked) waiting for them.

to mitigate this, and also make the normal usage case work as
intended, treat the condition where the caller's actual tid does not
match the tid in its thread structure as single-threaded, and bypass
the entire synccall broadcast operation.

diff --git a/src/thread/synccall.c b/src/thread/synccall.c
index 648a6ad..d58c851 100644 (file)
--- a/src/thread/synccall.c
+++ b/src/thread/synccall.c
@@ -63,7 +63,8 @@ void __synccall(void (*func)(void *), void *ctx)
        sem_init(&target_sem, 0, 0);
        sem_init(&caller_sem, 0, 0);
 
-       if (!libc.threads_minus_1) goto single_threaded;
+       if (!libc.threads_minus_1 || __syscall(SYS_gettid) != self->tid)
+               goto single_threaded;
 
        callback = func;
        context = ctx;