musl/src/thread/pthread_join.c

#include "pthread_impl.h"
#include <sys/mman.h>

int __munmap(void *, size_t);

static void dummy(void *p)
{
}

int __pthread_join(pthread_t t, void **res)
{
	int tmp;
	pthread_testcancel();
	while ((tmp = t->tid)) __timedwait(&t->tid, tmp, 0, 0, dummy, 0, 0);
	if (res) *res = t->result;
	if (t->map_base) __munmap(t->map_base, t->map_size);
	return 0;
}

weak_alias(__pthread_join, pthread_join);
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`#include "pthread_impl.h"`
clean up sloppy nested inclusion from pthread_impl.h this mirrors the stdio_impl.h cleanup. one header which is not strictly needed, errno.h, is left in pthread_impl.h, because since pthread functions return their error codes rather than using errno, nearly every single pthread function needs the errno constants. in a few places, rather than bringing in string.h to use memset, the memset was replaced by direct assignment. this seems to generate much better code anyway, and makes many functions which were previously non-leaf functions into leaf functions (possibly eliminating a great deal of bloat on some platforms where non-leaf functions require ugly prologue and/or epilogue). 2012-11-08 17:04:20 -05:00			`#include <sys/mman.h>`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00
use weak symbols for the POSIX functions that will be used by C threads The intent of this is to avoid name space pollution of the C threads implementation. This has two sides to it. First we have to provide symbols that wouldn't pollute the name space for the C threads implementation. Second we have to clean up some internal uses of POSIX functions such that they don't implicitly drag in such symbols. 2014-09-01 00:46:23 +02:00			`int __munmap(void *, size_t);`

unify and overhaul timed futex waits new features: - FUTEX_WAIT_BITSET op will be used for timed waits if available. this saves a call to clock_gettime. - error checking for the timespec struct is now inside __timedwait so it doesn't need to be duplicated everywhere. cond_timedwait still needs to duplicate it to avoid unlocking the mutex, though. - pushing and popping the cancellation handler is delegated to __timedwait, and cancellable/non-cancellable waits are unified. 2011-08-02 21:11:36 -04:00			`static void dummy(void *p)`
			`{`
			`}`

use weak symbols for the POSIX functions that will be used by C threads The intent of this is to avoid name space pollution of the C threads implementation. This has two sides to it. First we have to provide symbols that wouldn't pollute the name space for the C threads implementation. Second we have to clean up some internal uses of POSIX functions such that they don't implicitly drag in such symbols. 2014-09-01 00:46:23 +02:00			`int __pthread_join(pthread_t t, void **res)`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`{`
fix serious bug in pthread_join on spurious wakeups/returns from __timedwait, pthread_join would "succeed" and unmap the thread's stack while it was still running. at best this would lead to SIGSEGV when the thread resumed execution, but in the worst case, the thread would later resume executing on top of another new thread's stack mapped at the same address. spent about 4 hours tracking this bug down, chasing rare difficult-to-reproduce stack corruption in a stress test program. still no idea what caused the spurious wakeups; i suspect it's a kernel bug. 2011-09-11 12:35:41 -04:00			`int tmp;`
make non-waiting paths of sem_[timed]wait and pthread_join cancelable per POSIX these functions are both cancellation points, so they must act on any cancellation request which is pending prior to the call. previously, only the code path where actual waiting took place could act on cancellation. 2014-09-05 03:22:52 -04:00			`pthread_testcancel();`
fix serious bug in pthread_join on spurious wakeups/returns from __timedwait, pthread_join would "succeed" and unmap the thread's stack while it was still running. at best this would lead to SIGSEGV when the thread resumed execution, but in the worst case, the thread would later resume executing on top of another new thread's stack mapped at the same address. spent about 4 hours tracking this bug down, chasing rare difficult-to-reproduce stack corruption in a stress test program. still no idea what caused the spurious wakeups; i suspect it's a kernel bug. 2011-09-11 12:35:41 -04:00			`while ((tmp = t->tid)) __timedwait(&t->tid, tmp, 0, 0, dummy, 0, 0);`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`if (res) *res = t->result;`
use weak symbols for the POSIX functions that will be used by C threads The intent of this is to avoid name space pollution of the C threads implementation. This has two sides to it. First we have to provide symbols that wouldn't pollute the name space for the C threads implementation. Second we have to clean up some internal uses of POSIX functions such that they don't implicitly drag in such symbols. 2014-09-01 00:46:23 +02:00			`if (t->map_base) __munmap(t->map_base, t->map_size);`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`return 0;`
			`}`
use weak symbols for the POSIX functions that will be used by C threads The intent of this is to avoid name space pollution of the C threads implementation. This has two sides to it. First we have to provide symbols that wouldn't pollute the name space for the C threads implementation. Second we have to clean up some internal uses of POSIX functions such that they don't implicitly drag in such symbols. 2014-09-01 00:46:23 +02:00
			`weak_alias(__pthread_join, pthread_join);`