musl/src/thread/pthread_join.c

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

int __munmap(void *, size_t);
void __pthread_testcancel(void);
int __pthread_setcancelstate(int, int *);

int __pthread_join(pthread_t t, void **res)
{
	int tmp, cs;
	__pthread_testcancel();
	__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
	if (cs == PTHREAD_CANCEL_ENABLE) __pthread_setcancelstate(cs, 0);
	while ((tmp = t->tid)) __timedwait_cp(&t->tid, tmp, 0, 0, 0);
	__pthread_setcancelstate(cs, 0);
	a_barrier();
	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);`
fix namespace issue in pthread_join affecting thrd_join pthread_testcancel is not in the ISO C reserved namespace and thus cannot be used here. use the namespace-protected version of the function instead. 2015-03-02 18:48:58 -05:00			`void __pthread_testcancel(void);`
suppress masked cancellation in pthread_join like close, pthread_join is a resource-deallocation function which is also a cancellation point. the intent of masked cancellation mode is to exempt such functions from failure with ECANCELED. 2015-03-02 18:52:31 -05:00			`int __pthread_setcancelstate(int, int *);`
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			`{`
suppress masked cancellation in pthread_join like close, pthread_join is a resource-deallocation function which is also a cancellation point. the intent of masked cancellation mode is to exempt such functions from failure with ECANCELED. 2015-03-02 18:52:31 -05:00			`int tmp, cs;`
fix namespace issue in pthread_join affecting thrd_join pthread_testcancel is not in the ISO C reserved namespace and thus cannot be used here. use the namespace-protected version of the function instead. 2015-03-02 18:48:58 -05:00			`__pthread_testcancel();`
suppress masked cancellation in pthread_join like close, pthread_join is a resource-deallocation function which is also a cancellation point. the intent of masked cancellation mode is to exempt such functions from failure with ECANCELED. 2015-03-02 18:52:31 -05:00			`__pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);`
			`if (cs == PTHREAD_CANCEL_ENABLE) __pthread_setcancelstate(cs, 0);`
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);`
suppress masked cancellation in pthread_join like close, pthread_join is a resource-deallocation function which is also a cancellation point. the intent of masked cancellation mode is to exempt such functions from failure with ECANCELED. 2015-03-02 18:52:31 -05:00			`__pthread_setcancelstate(cs, 0);`
add missing memory barrier to pthread_join POSIX requires pthread_join to synchronize memory on success. The futex wait inside __timedwait_cp cannot handle this because it's not called in all cases. Also, in the case of a spurious wake, tid can become zero between the wake and when the joining thread checks it. 2015-10-04 14:55:29 -05:00			`a_barrier();`
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);`