X-Git-Url: http://nsz.repo.hu/git/?p=musl;a=blobdiff_plain;f=src%2Fthread%2Fpthread_create.c;h=a782650420248683f9c94fc515edfd8e04a7e95a;hp=fccfa1914bc8febfb161e61fc577a34b79cda37b;hb=9beb6330c08839e8bb2ebcd129c97c395d9d327e;hpb=d00ff2950eacc375d57e44d65c7697f636c67625 diff --git a/src/thread/pthread_create.c b/src/thread/pthread_create.c index fccfa191..a7826504 100644 --- a/src/thread/pthread_create.c +++ b/src/thread/pthread_create.c @@ -1,29 +1,33 @@ #include "pthread_impl.h" +static void dummy_0() +{ +} +weak_alias(dummy_0, __rsyscall_lock); +weak_alias(dummy_0, __rsyscall_unlock); + +static void dummy_1(pthread_t self) +{ +} +weak_alias(dummy_1, __pthread_tsd_run_dtors); +weak_alias(dummy_1, __sigtimer_handler); + +#ifdef __pthread_unwind_next +#undef __pthread_unwind_next +#define __pthread_unwind_next __pthread_unwind_next_3 +#endif + void __pthread_unwind_next(struct __ptcb *cb) { - int i, j, not_finished; pthread_t self; if (cb->__next) longjmp((void *)cb->__next->__jb, 1); self = pthread_self(); - if (self->cancel) self->result = PTHREAD_CANCELLED; LOCK(&self->exitlock); - not_finished = self->tsd_used; - for (j=0; not_finished && jtsd[i] && libc.tsd_keys[i]) { - void *tmp = self->tsd[i]; - self->tsd[i] = 0; - libc.tsd_keys[i](tmp); - not_finished = 1; - } - } - } + __pthread_tsd_run_dtors(self); /* Mark this thread dead before decrementing count */ self->dead = 1; @@ -32,118 +36,35 @@ void __pthread_unwind_next(struct __ptcb *cb) exit(0); if (self->detached && self->map_base) { - syscall4(__NR_rt_sigprocmask, SIG_BLOCK, (long)(uint64_t[1]){-1},0,8); + __syscall(SYS_rt_sigprocmask, SIG_BLOCK, (long)(uint64_t[1]){-1},0,8); __unmapself(self->map_base, self->map_size); } - __syscall_exit(0); + __syscall(SYS_exit, 0); } static void docancel(struct pthread *self) { struct __ptcb cb = { .__next = self->cancelbuf }; + self->canceldisable = 1; + self->cancelasync = 0; __pthread_unwind_next(&cb); } static void cancel_handler(int sig, siginfo_t *si, void *ctx) { struct pthread *self = __pthread_self(); - if (si->si_code > 0 || si->si_pid != self->pid) return; - self->cancel = 1; - if (self->canceldisable || (!self->cancelasync && !self->cancelpoint)) - return; - docancel(self); + if (si->si_code == SI_TIMER) __sigtimer_handler(self); + if (self->cancel && !self->canceldisable && + (self->cancelasync || (self->cancelpoint==1 && PC_AT_SYS(ctx)))) + docancel(self); } static void cancelpt(int x) { struct pthread *self = __pthread_self(); - if (self->canceldisable) return; - self->cancelpoint = x; - if (self->cancel) docancel(self); -} - -/* "rsyscall" is a mechanism by which a thread can synchronously force all - * other threads to perform an arbitrary syscall. It is necessary to work - * around the non-conformant implementation of setuid() et al on Linux, - * which affect only the calling thread and not the whole process. This - * implementation performs some tricks with signal delivery to work around - * the fact that it does not keep any list of threads in userspace. */ - -static struct { - volatile int lock, hold, blocks, cnt; - unsigned long arg[6]; - int nr; - int err; -} rs; - -static void rsyscall_handler(int sig, siginfo_t *si, void *ctx) -{ - struct pthread *self = __pthread_self(); - - if (si->si_code > 0 || si->si_pid != self->pid || - rs.cnt == libc.threads_minus_1) return; - - /* Threads which have already decremented themselves from the - * thread count must not increment rs.cnt or otherwise act. */ - if (self->dead) { - __wait(&rs.hold, 0, 1, 1); - return; - } - - if (__syscall(rs.nr, rs.arg[0], rs.arg[1], rs.arg[2], - rs.arg[3], rs.arg[4], rs.arg[5]) < 0 && !rs.err) rs.err=errno; - - a_inc(&rs.cnt); - __wake(&rs.cnt, 1, 1); - while(rs.hold) - __wait(&rs.hold, 0, 1, 1); - a_dec(&rs.cnt); - if (!rs.cnt) __wake(&rs.cnt, 1, 1); -} - -static int rsyscall(int nr, long a, long b, long c, long d, long e, long f) -{ - int i, ret; - sigset_t set = { 0 }; - struct pthread *self = __pthread_self(); - sigaddset(&set, SIGSYSCALL); - - LOCK(&rs.lock); - while ((i=rs.blocks)) - __wait(&rs.blocks, 0, i, 1); - - __libc_sigprocmask(SIG_BLOCK, &set, 0); - - rs.nr = nr; - rs.arg[0] = a; rs.arg[1] = b; - rs.arg[2] = c; rs.arg[3] = d; - rs.arg[4] = d; rs.arg[5] = f; - rs.hold = 1; - rs.err = 0; - rs.cnt = 0; - - /* Dispatch signals until all threads respond */ - for (i=libc.threads_minus_1; i; i--) - sigqueue(self->pid, SIGSYSCALL, (union sigval){0}); - while ((i=rs.cnt) < libc.threads_minus_1) { - sigqueue(self->pid, SIGSYSCALL, (union sigval){0}); - __wait(&rs.cnt, 0, i, 1); - } - - /* Handle any lingering signals with no-op */ - __libc_sigprocmask(SIG_UNBLOCK, &set, 0); - - /* Resume other threads' signal handlers and wait for them */ - rs.hold = 0; - __wake(&rs.hold, -1, 0); - while((i=rs.cnt)) __wait(&rs.cnt, 0, i, 1); - - if (rs.err) errno = rs.err, ret = -1; - else ret = __syscall(nr, a, b, c, d, e, f); - - UNLOCK(&rs.lock); - return ret; + if ((self->cancelpoint+=x)==1 && self->cancel + && x<2U && !self->canceldisable) docancel(self); } static void init_threads() @@ -152,19 +73,25 @@ static void init_threads() libc.lock = __lock; libc.lockfile = __lockfile; libc.cancelpt = cancelpt; - libc.rsyscall = rsyscall; + + sigemptyset(&sa.sa_mask); sa.sa_sigaction = cancel_handler; __libc_sigaction(SIGCANCEL, &sa, 0); + sigaddset(&sa.sa_mask, SIGSYSCALL); sigaddset(&sa.sa_mask, SIGCANCEL); - sa.sa_sigaction = rsyscall_handler; - __libc_sigaction(SIGSYSCALL, &sa, 0); - sigprocmask(SIG_UNBLOCK, &sa.sa_mask, 0); + __libc_sigprocmask(SIG_UNBLOCK, &sa.sa_mask, 0); } static int start(void *p) { struct pthread *self = p; + if (self->unblock_cancel) { + sigset_t set; + sigemptyset(&set); + sigaddset(&set, SIGCANCEL); + __libc_sigprocmask(SIG_UNBLOCK, &set, 0); + } pthread_exit(self->start(self->start_arg)); return 0; } @@ -184,9 +111,9 @@ int pthread_create(pthread_t *res, const pthread_attr_t *attr, void *(*entry)(vo size_t size, guard; struct pthread *self = pthread_self(), *new; unsigned char *map, *stack, *tsd; - static const pthread_attr_t default_attr; + const pthread_attr_t default_attr = { 0 }; - if (!self) return errno = ENOSYS; + if (!self) return ENOSYS; if (!init && ++init) init_threads(); if (!attr) attr = &default_attr; @@ -209,20 +136,18 @@ int pthread_create(pthread_t *res, const pthread_attr_t *attr, void *(*entry)(vo new->tsd = (void *)tsd; new->detached = attr->_a_detach; new->attr = *attr; + new->unblock_cancel = self->cancel; + new->result = PTHREAD_CANCELED; memcpy(new->tlsdesc, self->tlsdesc, sizeof new->tlsdesc); new->tlsdesc[1] = (uintptr_t)new; stack = (void *)((uintptr_t)new-1 & ~(uintptr_t)15); - /* We must synchronize new thread creation with rsyscall - * delivery. This looks to be the least expensive way: */ - a_inc(&rs.blocks); - while (rs.lock) __wait(&rs.lock, 0, 1, 1); + __rsyscall_lock(); a_inc(&libc.threads_minus_1); ret = __uniclone(stack, start, new); - a_dec(&rs.blocks); - if (rs.lock) __wake(&rs.blocks, 1, 1); + __rsyscall_unlock(); if (ret < 0) { a_dec(&libc.threads_minus_1);