musl/src/thread/pthread_join.c

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

int __munmap(void *, size_t);

int __pthread_join(pthread_t t, void **res)
{
	int tmp;
	pthread_testcancel();
	while ((tmp = t->tid)) __timedwait_cp(&t->tid, tmp, 0, 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);`

			`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();`
factor cancellation cleanup push/pop out of futex __timedwait function previously, the __timedwait function was optionally a cancellation point depending on whether it was passed a pointer to a cleaup function and context to register. as of now, only one caller actually used such a cleanup function (and it may face removal soon); most callers either passed a null pointer to disable cancellation or a dummy cleanup function. now, __timedwait is never a cancellation point, and __timedwait_cp is the cancellable version. this makes the intent of the calling code more obvious and avoids ugly dummy functions and long argument lists. 2015-03-02 17:46:22 -05:00			`while ((tmp = t->tid)) __timedwait_cp(&t->tid, tmp, 0, 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);`