src/pthread_cancelable.c

/*
 * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
 *              All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */
/*
 * MkLinux
 */

/*
 * POSIX Pthread Library
 */

#include "resolver.h"
#include "internal.h"

#include <stdio.h>	/* For printf(). */
#include <stdlib.h>
#include <errno.h>	/* For __mach_errno_addr() prototype. */
#include <signal.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/sysctl.h>
#include <sys/queue.h>
#include <sys/ulock.h>
#include <machine/vmparam.h>
#include <mach/vm_statistics.h>

extern int _pthread_cond_wait(pthread_cond_t *cond,
			pthread_mutex_t *mutex,
			const struct timespec *abstime,
			int isRelative,
			int isconforming);
extern int __sigwait(const sigset_t *set, int *sig);
extern int __pthread_sigmask(int, const sigset_t *, sigset_t *);
extern int __pthread_markcancel(mach_port_t);
extern int __pthread_canceled(int);
extern int __semwait_signal_nocancel(int, int, int, int, __int64_t, __int32_t);


PTHREAD_NOEXPORT
int _pthread_join(pthread_t thread, void **value_ptr, int conforming);

static inline int
_pthread_conformance(void)
{
#if __DARWIN_UNIX03
	if (__unix_conforming == 0)
		__unix_conforming = 1;
#ifdef VARIANT_CANCELABLE
	return PTHREAD_CONFORM_UNIX03_CANCELABLE;
#else /* !VARIANT_CANCELABLE */
	return PTHREAD_CONFORM_UNIX03_NOCANCEL;
#endif
#else /* __DARWIN_UNIX03 */
	return PTHREAD_CONFORM_DARWIN_LEGACY;
#endif /* __DARWIN_UNIX03 */
}

#ifndef VARIANT_CANCELABLE

PTHREAD_ALWAYS_INLINE
static inline int
_pthread_update_cancel_state(pthread_t thread, int mask, int state)
{
	int oldstate, newstate;
	os_atomic_rmw_loop2o(thread, cancel_state, oldstate, newstate, seq_cst, {
		newstate = oldstate;
		newstate &= ~mask;
		newstate |= state;
	});
	return oldstate;
}

/*
 * Cancel a thread
 */
PTHREAD_NOEXPORT_VARIANT
int
pthread_cancel(pthread_t thread)
{
#if __DARWIN_UNIX03
	if (__unix_conforming == 0)
		__unix_conforming = 1;
#endif /* __DARWIN_UNIX03 */

	if (!_pthread_is_valid(thread, NULL)) {
		return(ESRCH);
	}

	/* if the thread is a workqueue thread, then return error */
	if (thread->wqthread != 0) {
		return(ENOTSUP);
	}
#if __DARWIN_UNIX03
	int state = os_atomic_or2o(thread, cancel_state, _PTHREAD_CANCEL_PENDING, relaxed);
	if (state & PTHREAD_CANCEL_ENABLE) {
		mach_port_t kport = _pthread_kernel_thread(thread);
		if (kport) __pthread_markcancel(kport);
	}
#else /* __DARWIN_UNIX03 */
	thread->cancel_state |= _PTHREAD_CANCEL_PENDING;
#endif /* __DARWIN_UNIX03 */
	return (0);
}


void
pthread_testcancel(void)
{
	_pthread_testcancel(_pthread_conformance());
}

#ifndef BUILDING_VARIANT /* [ */

PTHREAD_NOEXPORT_VARIANT
void
_pthread_exit_if_canceled(int error)
{
	if (((error & 0xff) == EINTR) && __unix_conforming && (__pthread_canceled(0) == 0)) {
		pthread_t self = pthread_self();

		self->cancel_error = error;
		self->canceled = true;
		pthread_exit(PTHREAD_CANCELED);
	}
}


static inline bool
_pthread_is_canceled(pthread_t thread)
{
	const int flags = (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING);
	int state = os_atomic_load2o(thread, cancel_state, seq_cst);
	return (state & flags) == flags;
}

PTHREAD_NOEXPORT_VARIANT
void
_pthread_testcancel(int isconforming)
{
	pthread_t self = pthread_self();
	if (_pthread_is_canceled(self)) {
		// 4597450: begin
		self->canceled = (isconforming != PTHREAD_CONFORM_DARWIN_LEGACY);
		// 4597450: end
		pthread_exit(isconforming ? PTHREAD_CANCELED : NULL);
	}
}

PTHREAD_NOEXPORT
void
_pthread_markcancel_if_canceled(pthread_t thread, mach_port_t kport)
{
	const int flags = (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING);
	int state = os_atomic_or2o(thread, cancel_state,
			_PTHREAD_CANCEL_INITIALIZED, relaxed);
	if ((state & flags) == flags && __unix_conforming) {
		__pthread_markcancel(kport);
	}
}

/* When a thread exits set the cancellation state to DISABLE and DEFERRED */
PTHREAD_NOEXPORT
void
_pthread_setcancelstate_exit(pthread_t thread, void *value_ptr)
{
	_pthread_update_cancel_state(thread,
			_PTHREAD_CANCEL_STATE_MASK | _PTHREAD_CANCEL_TYPE_MASK,
			PTHREAD_CANCEL_DISABLE | PTHREAD_CANCEL_DEFERRED);
}

#endif /* !BUILDING_VARIANT ] */

/*
 * Query/update the cancelability 'state' of a thread
 */
PTHREAD_ALWAYS_INLINE
static inline int
_pthread_setcancelstate_internal(int state, int *oldstateptr, int conforming)
{
	pthread_t self = pthread_self();

	switch (state) {
	case PTHREAD_CANCEL_ENABLE:
		if (conforming) {
			__pthread_canceled(1);
		}
		break;
	case PTHREAD_CANCEL_DISABLE:
		if (conforming) {
			__pthread_canceled(2);
		}
		break;
	default:
		return EINVAL;
	}

	int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_STATE_MASK, state);
	if (oldstateptr) {
		*oldstateptr = oldstate & _PTHREAD_CANCEL_STATE_MASK;
	}
	if (!conforming) {
		/* See if we need to 'die' now... */
		_pthread_testcancel(PTHREAD_CONFORM_DARWIN_LEGACY);
	}
	return 0;
}

PTHREAD_NOEXPORT_VARIANT
int
pthread_setcancelstate(int state, int *oldstate)
{
#if __DARWIN_UNIX03
	if (__unix_conforming == 0) {
		__unix_conforming = 1;
	}
	return (_pthread_setcancelstate_internal(state, oldstate, 1));
#else /* __DARWIN_UNIX03 */
	return (_pthread_setcancelstate_internal(state, oldstate, 0));
#endif /* __DARWIN_UNIX03 */
}

/*
 * Query/update the cancelability 'type' of a thread
 */
PTHREAD_NOEXPORT_VARIANT
int
pthread_setcanceltype(int type, int *oldtype)
{
	pthread_t self;

#if __DARWIN_UNIX03
	if (__unix_conforming == 0)
		__unix_conforming = 1;
#endif /* __DARWIN_UNIX03 */

	if ((type != PTHREAD_CANCEL_DEFERRED) &&
	    (type != PTHREAD_CANCEL_ASYNCHRONOUS))
		return EINVAL;
	self = pthread_self();
	int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_TYPE_MASK, type);
	if (oldtype) {
		*oldtype = oldstate & _PTHREAD_CANCEL_TYPE_MASK;
	}
#if !__DARWIN_UNIX03
	/* See if we need to 'die' now... */
	_pthread_testcancel(PTHREAD_CONFORM_DARWIN_LEGACY);
#endif /* __DARWIN_UNIX03 */
	return (0);
}


int
pthread_sigmask(int how, const sigset_t * set, sigset_t * oset)
{
#if __DARWIN_UNIX03
	int err = 0;

	if (__pthread_sigmask(how, set, oset) == -1) {
		err = errno;
	}
	return(err);
#else /* __DARWIN_UNIX03 */
	return(__pthread_sigmask(how, set, oset));
#endif /* __DARWIN_UNIX03 */
}

#ifndef BUILDING_VARIANT /* [ */

typedef struct pthread_join_context_s {
	pthread_t   waiter;
	void      **value_ptr;
	mach_port_t kport;
	semaphore_t custom_stack_sema;
	bool        detached;
} pthread_join_context_s, *pthread_join_context_t;

static inline void *
_pthread_get_exit_value(pthread_t thread)
{
	if (__unix_conforming && _pthread_is_canceled(thread)) {
		return PTHREAD_CANCELED;
	}
	return thread->tl_exit_value;
}

// called with _pthread_list_lock held
PTHREAD_NOEXPORT
semaphore_t
_pthread_joiner_prepost_wake(pthread_t thread)
{
	pthread_join_context_t ctx = thread->tl_join_ctx;
	semaphore_t sema = MACH_PORT_NULL;

	if (thread->tl_joinable) {
		sema = ctx->custom_stack_sema;
		thread->tl_joinable = false;
	} else {
		ctx->detached = true;
		thread->tl_join_ctx = NULL;
	}
	if (ctx->value_ptr) *ctx->value_ptr = _pthread_get_exit_value(thread);
	return sema;
}

static inline bool
_pthread_joiner_abort_wait(pthread_t thread, pthread_join_context_t ctx)
{
	bool aborted = false;

	_PTHREAD_LOCK(_pthread_list_lock);
	if (!ctx->detached && thread->tl_exit_gate != MACH_PORT_DEAD) {
		/*
		 * _pthread_joiner_prepost_wake() didn't happen
		 * allow another thread to join
		 */
#if DEBUG
		PTHREAD_ASSERT(thread->tl_join_ctx == ctx);
#endif
		thread->tl_join_ctx = NULL;
		thread->tl_exit_gate = MACH_PORT_NULL;
		aborted = true;
	}
	_PTHREAD_UNLOCK(_pthread_list_lock);
	return aborted;
}

static int
_pthread_joiner_wait(pthread_t thread, pthread_join_context_t ctx, int conforming)
{
	uint32_t *exit_gate = &thread->tl_exit_gate;
	int ulock_op = UL_UNFAIR_LOCK | ULF_NO_ERRNO;

	if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
		ulock_op |= ULF_WAIT_CANCEL_POINT;
	}

	for (;;) {
		uint32_t cur = os_atomic_load(exit_gate, acquire);
		if (cur == MACH_PORT_DEAD) {
			break;
		}
		if (os_unlikely(cur != ctx->kport)) {
			PTHREAD_CLIENT_CRASH(cur, "pthread_join() state corruption");
		}
		int ret = __ulock_wait(ulock_op, exit_gate, ctx->kport, 0);
		switch (-ret) {
		case 0:
		case EFAULT:
			break;
		case EINTR:
			/*
			 * POSIX says:
			 *
			 *   As specified, either the pthread_join() call is canceled, or it
			 *   succeeds, but not both. The difference is obvious to the
			 *   application, since either a cancellation handler is run or
			 *   pthread_join() returns.
			 *
			 * When __ulock_wait() returns EINTR, we check if we have been
			 * canceled, and if we have, we try to abort the wait.
			 *
			 * If we can't, it means the other thread finished the join while we
			 * were being canceled and commited the waiter to return from
			 * pthread_join(). Returning from the join then takes precedence
			 * over the cancelation which will be acted upon at the next
			 * cancelation point.
			 */
			if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE &&
					_pthread_is_canceled(ctx->waiter)) {
				if (_pthread_joiner_abort_wait(thread, ctx)) {
					ctx->waiter->canceled = true;
					pthread_exit(PTHREAD_CANCELED);
				}
			}
			break;
		}
	}

	bool cleanup = false;

	_PTHREAD_LOCK(_pthread_list_lock);
	// If pthread_detach() was called, we can't safely dereference the thread,
	// else, decide who gets to deallocate the thread (see _pthread_terminate).
	if (!ctx->detached) {
#if DEBUG
		PTHREAD_ASSERT(thread->tl_join_ctx == ctx);
#endif
		thread->tl_join_ctx = NULL;
		cleanup = thread->tl_joiner_cleans_up;
	}
	_PTHREAD_UNLOCK(_pthread_list_lock);

	if (cleanup) {
		_pthread_deallocate(thread, false);
	}
	return 0;
}

PTHREAD_NOEXPORT PTHREAD_NOINLINE
int
_pthread_join(pthread_t thread, void **value_ptr, int conforming)
{
	pthread_t self = pthread_self();
	pthread_join_context_s ctx = {
		.waiter = self,
		.value_ptr = value_ptr,
		.kport = MACH_PORT_NULL,
		.custom_stack_sema = MACH_PORT_NULL,
	};
	int res = 0;
	kern_return_t kr;

	if (!_pthread_validate_thread_and_list_lock(thread)) {
		return ESRCH;
	}

	if (!thread->tl_joinable || (thread->tl_join_ctx != NULL)) {
		res = EINVAL;
	} else if (thread == self ||
			(self->tl_join_ctx && self->tl_join_ctx->waiter == thread)) {
		res = EDEADLK;
	} else if (thread->tl_exit_gate == MACH_PORT_DEAD) {
		TAILQ_REMOVE(&__pthread_head, thread, tl_plist);
#if DEBUG
		PTHREAD_ASSERT(thread->tl_joiner_cleans_up);
#endif
		thread->tl_joinable = false;
		if (value_ptr) *value_ptr = _pthread_get_exit_value(thread);
	} else {
		ctx.kport = _pthread_kernel_thread(thread);
		thread->tl_exit_gate = ctx.kport;
		thread->tl_join_ctx = &ctx;
		if (thread->tl_has_custom_stack) {
			ctx.custom_stack_sema = (semaphore_t)os_get_cached_semaphore();
		}
	}
	_PTHREAD_UNLOCK(_pthread_list_lock);

	if (res == 0) {
		if (ctx.kport == MACH_PORT_NULL) {
			_pthread_deallocate(thread, false);
		} else {
			res = _pthread_joiner_wait(thread, &ctx, conforming);
		}
	}
	if (res == 0 && ctx.custom_stack_sema && !ctx.detached) {
		// threads with a custom stack need to make sure _pthread_terminate
		// returned before the joiner is unblocked, the joiner may quickly
		// deallocate the stack with rather dire consequences.
		//
		// When we reach this point we know the pthread_join has to succeed
		// so this can't be a cancelation point.
		do {
			kr = __semwait_signal_nocancel(ctx.custom_stack_sema, 0, 0, 0, 0, 0);
		} while (kr != KERN_SUCCESS);
	}
	if (ctx.custom_stack_sema) {
		os_put_cached_semaphore(ctx.custom_stack_sema);
	}
	return res;
}

#endif /* !BUILDING_VARIANT ] */
#endif /* VARIANT_CANCELABLE */

/*
 * Wait for a thread to terminate and obtain its exit value.
 */
int
pthread_join(pthread_t thread, void **value_ptr)
{
	int conforming = _pthread_conformance();
	if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
		_pthread_testcancel(conforming);
	}
	return _pthread_join(thread, value_ptr, conforming);
}

int
pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
{
	return _pthread_cond_wait(cond, mutex, NULL, 0, _pthread_conformance());
}

int
pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
		const struct timespec *abstime)
{
	return _pthread_cond_wait(cond, mutex, abstime, 0, _pthread_conformance());
}

int
sigwait(const sigset_t * set, int * sig)
{
#if __DARWIN_UNIX03
	int err = 0, conformance = _pthread_conformance();

	if (__unix_conforming == 0)
		__unix_conforming = 1;

	if (conformance == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
		_pthread_testcancel(conformance);
	}

	if (__sigwait(set, sig) == -1) {
		err = errno;

		if (conformance == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
			_pthread_testcancel(conformance);
		}

		/*
		 * EINTR that isn't a result of pthread_cancel()
		 * is translated to 0.
		 */
		if (err == EINTR) {
			err = 0;
		}
	}
	return(err);
#else /* __DARWIN_UNIX03 */
	if (__sigwait(set, sig) == -1) {
		/*
		 * EINTR that isn't a result of pthread_cancel()
		 * is translated to 0.
		 */
		if (errno != EINTR) {
			return -1;
		}
	}

	return 0;
#endif /* __DARWIN_UNIX03 */
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2000-2013 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23	/*
	24	* Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
	25	* All Rights Reserved
	26	*
	27	* Permission to use, copy, modify, and distribute this software and
	28	* its documentation for any purpose and without fee is hereby granted,
	29	* provided that the above copyright notice appears in all copies and
	30	* that both the copyright notice and this permission notice appear in
	31	* supporting documentation.
	32	*
	33	* OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
	34	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	35	* FOR A PARTICULAR PURPOSE.
	36	*
	37	* IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
	38	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
	39	* LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
	40	* NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
	41	* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	42	*
	43	*/
	44	/*
	45	* MkLinux
	46	*/
	47
	48	/*
	49	* POSIX Pthread Library
	50	*/
	51
	52	#include "resolver.h"
	53	#include "internal.h"
	54
	55	#include <stdio.h> /* For printf(). */
	56	#include <stdlib.h>
	57	#include <errno.h> /* For __mach_errno_addr() prototype. */
	58	#include <signal.h>
	59	#include <sys/time.h>
	60	#include <sys/resource.h>
	61	#include <sys/sysctl.h>
	62	#include <sys/queue.h>
	63	#include <sys/ulock.h>
	64	#include <machine/vmparam.h>
	65	#include <mach/vm_statistics.h>
	66
	67	extern int _pthread_cond_wait(pthread_cond_t *cond,
	68	pthread_mutex_t *mutex,
	69	const struct timespec *abstime,
	70	int isRelative,
	71	int isconforming);
	72	extern int __sigwait(const sigset_t set, int sig);
	73	extern int __pthread_sigmask(int, const sigset_t , sigset_t );
	74	extern int __pthread_markcancel(mach_port_t);
	75	extern int __pthread_canceled(int);
	76	extern int __semwait_signal_nocancel(int, int, int, int, __int64_t, __int32_t);
	77
	78
	79	PTHREAD_NOEXPORT
	80	int _pthread_join(pthread_t thread, void **value_ptr, int conforming);
	81
	82	static inline int
	83	_pthread_conformance(void)
	84	{
	85	#if __DARWIN_UNIX03
	86	if (__unix_conforming == 0)
	87	__unix_conforming = 1;
	88	#ifdef VARIANT_CANCELABLE
	89	return PTHREAD_CONFORM_UNIX03_CANCELABLE;
	90	#else /* !VARIANT_CANCELABLE */
	91	return PTHREAD_CONFORM_UNIX03_NOCANCEL;
	92	#endif
	93	#else /* __DARWIN_UNIX03 */
	94	return PTHREAD_CONFORM_DARWIN_LEGACY;
	95	#endif /* __DARWIN_UNIX03 */
	96	}
	97
	98	#ifndef VARIANT_CANCELABLE
	99
	100	PTHREAD_ALWAYS_INLINE
	101	static inline int
	102	_pthread_update_cancel_state(pthread_t thread, int mask, int state)
	103	{
	104	int oldstate, newstate;
	105	os_atomic_rmw_loop2o(thread, cancel_state, oldstate, newstate, seq_cst, {
	106	newstate = oldstate;
	107	newstate &= ~mask;
	108	newstate \|= state;
	109	});
	110	return oldstate;
	111	}
	112
	113	/*
	114	* Cancel a thread
	115	*/
	116	PTHREAD_NOEXPORT_VARIANT
	117	int
	118	pthread_cancel(pthread_t thread)
	119	{
	120	#if __DARWIN_UNIX03
	121	if (__unix_conforming == 0)
	122	__unix_conforming = 1;
	123	#endif /* __DARWIN_UNIX03 */
	124
	125	if (!_pthread_is_valid(thread, NULL)) {
	126	return(ESRCH);
	127	}
	128
	129	/* if the thread is a workqueue thread, then return error */
	130	if (thread->wqthread != 0) {
	131	return(ENOTSUP);
	132	}
	133	#if __DARWIN_UNIX03
	134	int state = os_atomic_or2o(thread, cancel_state, _PTHREAD_CANCEL_PENDING, relaxed);
	135	if (state & PTHREAD_CANCEL_ENABLE) {
	136	mach_port_t kport = _pthread_kernel_thread(thread);
	137	if (kport) __pthread_markcancel(kport);
	138	}
	139	#else /* __DARWIN_UNIX03 */
	140	thread->cancel_state \|= _PTHREAD_CANCEL_PENDING;
	141	#endif /* __DARWIN_UNIX03 */
	142	return (0);
	143	}
	144
	145
	146	void
	147	pthread_testcancel(void)
	148	{
	149	_pthread_testcancel(_pthread_conformance());
	150	}
	151
	152	#ifndef BUILDING_VARIANT /* [ */
	153
	154	PTHREAD_NOEXPORT_VARIANT
	155	void
	156	_pthread_exit_if_canceled(int error)
	157	{
	158	if (((error & 0xff) == EINTR) && __unix_conforming && (__pthread_canceled(0) == 0)) {
	159	pthread_t self = pthread_self();
	160
	161	self->cancel_error = error;
	162	self->canceled = true;
	163	pthread_exit(PTHREAD_CANCELED);
	164	}
	165	}
	166
	167
	168	static inline bool
	169	_pthread_is_canceled(pthread_t thread)
	170	{
	171	const int flags = (PTHREAD_CANCEL_ENABLE\|_PTHREAD_CANCEL_PENDING);
	172	int state = os_atomic_load2o(thread, cancel_state, seq_cst);
	173	return (state & flags) == flags;
	174	}
	175
	176	PTHREAD_NOEXPORT_VARIANT
	177	void
	178	_pthread_testcancel(int isconforming)
	179	{
	180	pthread_t self = pthread_self();
	181	if (_pthread_is_canceled(self)) {
	182	// 4597450: begin
	183	self->canceled = (isconforming != PTHREAD_CONFORM_DARWIN_LEGACY);
	184	// 4597450: end
	185	pthread_exit(isconforming ? PTHREAD_CANCELED : NULL);
	186	}
	187	}
	188
	189	PTHREAD_NOEXPORT
	190	void
	191	_pthread_markcancel_if_canceled(pthread_t thread, mach_port_t kport)
	192	{
	193	const int flags = (PTHREAD_CANCEL_ENABLE\|_PTHREAD_CANCEL_PENDING);
	194	int state = os_atomic_or2o(thread, cancel_state,
	195	_PTHREAD_CANCEL_INITIALIZED, relaxed);
	196	if ((state & flags) == flags && __unix_conforming) {
	197	__pthread_markcancel(kport);
	198	}
	199	}
	200
	201	/* When a thread exits set the cancellation state to DISABLE and DEFERRED */
	202	PTHREAD_NOEXPORT
	203	void
	204	_pthread_setcancelstate_exit(pthread_t thread, void *value_ptr)
	205	{
	206	_pthread_update_cancel_state(thread,
	207	_PTHREAD_CANCEL_STATE_MASK \| _PTHREAD_CANCEL_TYPE_MASK,
	208	PTHREAD_CANCEL_DISABLE \| PTHREAD_CANCEL_DEFERRED);
	209	}
	210
	211	#endif /* !BUILDING_VARIANT ] */
	212
	213	/*
	214	* Query/update the cancelability 'state' of a thread
	215	*/
	216	PTHREAD_ALWAYS_INLINE
	217	static inline int
	218	_pthread_setcancelstate_internal(int state, int *oldstateptr, int conforming)
	219	{
	220	pthread_t self = pthread_self();
	221
	222	switch (state) {
	223	case PTHREAD_CANCEL_ENABLE:
	224	if (conforming) {
	225	__pthread_canceled(1);
	226	}
	227	break;
	228	case PTHREAD_CANCEL_DISABLE:
	229	if (conforming) {
	230	__pthread_canceled(2);
	231	}
	232	break;
	233	default:
	234	return EINVAL;
	235	}
	236
	237	int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_STATE_MASK, state);
	238	if (oldstateptr) {
	239	*oldstateptr = oldstate & _PTHREAD_CANCEL_STATE_MASK;
	240	}
	241	if (!conforming) {
	242	/* See if we need to 'die' now... */
	243	_pthread_testcancel(PTHREAD_CONFORM_DARWIN_LEGACY);
	244	}
	245	return 0;
	246	}
	247
	248	PTHREAD_NOEXPORT_VARIANT
	249	int
	250	pthread_setcancelstate(int state, int *oldstate)
	251	{
	252	#if __DARWIN_UNIX03
	253	if (__unix_conforming == 0) {
	254	__unix_conforming = 1;
	255	}
	256	return (_pthread_setcancelstate_internal(state, oldstate, 1));
	257	#else /* __DARWIN_UNIX03 */
	258	return (_pthread_setcancelstate_internal(state, oldstate, 0));
	259	#endif /* __DARWIN_UNIX03 */
	260	}
	261
	262	/*
	263	* Query/update the cancelability 'type' of a thread
	264	*/
	265	PTHREAD_NOEXPORT_VARIANT
	266	int
	267	pthread_setcanceltype(int type, int *oldtype)
	268	{
	269	pthread_t self;
	270
	271	#if __DARWIN_UNIX03
	272	if (__unix_conforming == 0)
	273	__unix_conforming = 1;
	274	#endif /* __DARWIN_UNIX03 */
	275
	276	if ((type != PTHREAD_CANCEL_DEFERRED) &&
	277	(type != PTHREAD_CANCEL_ASYNCHRONOUS))
	278	return EINVAL;
	279	self = pthread_self();
	280	int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_TYPE_MASK, type);
	281	if (oldtype) {
	282	*oldtype = oldstate & _PTHREAD_CANCEL_TYPE_MASK;
	283	}
	284	#if !__DARWIN_UNIX03
	285	/* See if we need to 'die' now... */
	286	_pthread_testcancel(PTHREAD_CONFORM_DARWIN_LEGACY);
	287	#endif /* __DARWIN_UNIX03 */
	288	return (0);
	289	}
	290
	291
	292	int
	293	pthread_sigmask(int how, const sigset_t * set, sigset_t * oset)
	294	{
	295	#if __DARWIN_UNIX03
	296	int err = 0;
	297
	298	if (__pthread_sigmask(how, set, oset) == -1) {
	299	err = errno;
	300	}
	301	return(err);
	302	#else /* __DARWIN_UNIX03 */
	303	return(__pthread_sigmask(how, set, oset));
	304	#endif /* __DARWIN_UNIX03 */
	305	}
	306
	307	#ifndef BUILDING_VARIANT /* [ */
	308
	309	typedef struct pthread_join_context_s {
	310	pthread_t waiter;
	311	void **value_ptr;
	312	mach_port_t kport;
	313	semaphore_t custom_stack_sema;
	314	bool detached;
	315	} pthread_join_context_s, *pthread_join_context_t;
	316
	317	static inline void *
	318	_pthread_get_exit_value(pthread_t thread)
	319	{
	320	if (__unix_conforming && _pthread_is_canceled(thread)) {
	321	return PTHREAD_CANCELED;
	322	}
	323	return thread->tl_exit_value;
	324	}
	325
	326	// called with _pthread_list_lock held
	327	PTHREAD_NOEXPORT
	328	semaphore_t
	329	_pthread_joiner_prepost_wake(pthread_t thread)
	330	{
	331	pthread_join_context_t ctx = thread->tl_join_ctx;
	332	semaphore_t sema = MACH_PORT_NULL;
	333
	334	if (thread->tl_joinable) {
	335	sema = ctx->custom_stack_sema;
	336	thread->tl_joinable = false;
	337	} else {
	338	ctx->detached = true;
	339	thread->tl_join_ctx = NULL;
	340	}
	341	if (ctx->value_ptr) *ctx->value_ptr = _pthread_get_exit_value(thread);
	342	return sema;
	343	}
	344
	345	static inline bool
	346	_pthread_joiner_abort_wait(pthread_t thread, pthread_join_context_t ctx)
	347	{
	348	bool aborted = false;
	349
	350	_PTHREAD_LOCK(_pthread_list_lock);
	351	if (!ctx->detached && thread->tl_exit_gate != MACH_PORT_DEAD) {
	352	/*
	353	* _pthread_joiner_prepost_wake() didn't happen
	354	* allow another thread to join
	355	*/
	356	#if DEBUG
	357	PTHREAD_ASSERT(thread->tl_join_ctx == ctx);
	358	#endif
	359	thread->tl_join_ctx = NULL;
	360	thread->tl_exit_gate = MACH_PORT_NULL;
	361	aborted = true;
	362	}
	363	_PTHREAD_UNLOCK(_pthread_list_lock);
	364	return aborted;
	365	}
	366
	367	static int
	368	_pthread_joiner_wait(pthread_t thread, pthread_join_context_t ctx, int conforming)
	369	{
	370	uint32_t *exit_gate = &thread->tl_exit_gate;
	371	int ulock_op = UL_UNFAIR_LOCK \| ULF_NO_ERRNO;
	372
	373	if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
	374	ulock_op \|= ULF_WAIT_CANCEL_POINT;
	375	}
	376
	377	for (;;) {
	378	uint32_t cur = os_atomic_load(exit_gate, acquire);
	379	if (cur == MACH_PORT_DEAD) {
	380	break;
	381	}
	382	if (os_unlikely(cur != ctx->kport)) {
	383	PTHREAD_CLIENT_CRASH(cur, "pthread_join() state corruption");
	384	}
	385	int ret = __ulock_wait(ulock_op, exit_gate, ctx->kport, 0);
	386	switch (-ret) {
	387	case 0:
	388	case EFAULT:
	389	break;
	390	case EINTR:
	391	/*
	392	* POSIX says:
	393	*
	394	* As specified, either the pthread_join() call is canceled, or it
	395	* succeeds, but not both. The difference is obvious to the
	396	* application, since either a cancellation handler is run or
	397	* pthread_join() returns.
	398	*
	399	* When __ulock_wait() returns EINTR, we check if we have been
	400	* canceled, and if we have, we try to abort the wait.
	401	*
	402	* If we can't, it means the other thread finished the join while we
	403	* were being canceled and commited the waiter to return from
	404	* pthread_join(). Returning from the join then takes precedence
	405	* over the cancelation which will be acted upon at the next
	406	* cancelation point.
	407	*/
	408	if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE &&
	409	_pthread_is_canceled(ctx->waiter)) {
	410	if (_pthread_joiner_abort_wait(thread, ctx)) {
	411	ctx->waiter->canceled = true;
	412	pthread_exit(PTHREAD_CANCELED);
	413	}
	414	}
	415	break;
	416	}
	417	}
	418
	419	bool cleanup = false;
	420
	421	_PTHREAD_LOCK(_pthread_list_lock);
	422	// If pthread_detach() was called, we can't safely dereference the thread,
	423	// else, decide who gets to deallocate the thread (see _pthread_terminate).
	424	if (!ctx->detached) {
	425	#if DEBUG
	426	PTHREAD_ASSERT(thread->tl_join_ctx == ctx);
	427	#endif
	428	thread->tl_join_ctx = NULL;
	429	cleanup = thread->tl_joiner_cleans_up;
	430	}
	431	_PTHREAD_UNLOCK(_pthread_list_lock);
	432
	433	if (cleanup) {
	434	_pthread_deallocate(thread, false);
	435	}
	436	return 0;
	437	}
	438
	439	PTHREAD_NOEXPORT PTHREAD_NOINLINE
	440	int
	441	_pthread_join(pthread_t thread, void **value_ptr, int conforming)
	442	{
	443	pthread_t self = pthread_self();
	444	pthread_join_context_s ctx = {
	445	.waiter = self,
	446	.value_ptr = value_ptr,
	447	.kport = MACH_PORT_NULL,
	448	.custom_stack_sema = MACH_PORT_NULL,
	449	};
	450	int res = 0;
	451	kern_return_t kr;
	452
	453	if (!_pthread_validate_thread_and_list_lock(thread)) {
	454	return ESRCH;
	455	}
	456
	457	if (!thread->tl_joinable \|\| (thread->tl_join_ctx != NULL)) {
	458	res = EINVAL;
	459	} else if (thread == self \|\|
	460	(self->tl_join_ctx && self->tl_join_ctx->waiter == thread)) {
	461	res = EDEADLK;
	462	} else if (thread->tl_exit_gate == MACH_PORT_DEAD) {
	463	TAILQ_REMOVE(&__pthread_head, thread, tl_plist);
	464	#if DEBUG
	465	PTHREAD_ASSERT(thread->tl_joiner_cleans_up);
	466	#endif
	467	thread->tl_joinable = false;
	468	if (value_ptr) *value_ptr = _pthread_get_exit_value(thread);
	469	} else {
	470	ctx.kport = _pthread_kernel_thread(thread);
	471	thread->tl_exit_gate = ctx.kport;
	472	thread->tl_join_ctx = &ctx;
	473	if (thread->tl_has_custom_stack) {
	474	ctx.custom_stack_sema = (semaphore_t)os_get_cached_semaphore();
	475	}
	476	}
	477	_PTHREAD_UNLOCK(_pthread_list_lock);
	478
	479	if (res == 0) {
	480	if (ctx.kport == MACH_PORT_NULL) {
	481	_pthread_deallocate(thread, false);
	482	} else {
	483	res = _pthread_joiner_wait(thread, &ctx, conforming);
	484	}
	485	}
	486	if (res == 0 && ctx.custom_stack_sema && !ctx.detached) {
	487	// threads with a custom stack need to make sure _pthread_terminate
	488	// returned before the joiner is unblocked, the joiner may quickly
	489	// deallocate the stack with rather dire consequences.
	490	//
	491	// When we reach this point we know the pthread_join has to succeed
	492	// so this can't be a cancelation point.
	493	do {
	494	kr = __semwait_signal_nocancel(ctx.custom_stack_sema, 0, 0, 0, 0, 0);
	495	} while (kr != KERN_SUCCESS);
	496	}
	497	if (ctx.custom_stack_sema) {
	498	os_put_cached_semaphore(ctx.custom_stack_sema);
	499	}
	500	return res;
	501	}
	502
	503	#endif /* !BUILDING_VARIANT ] */
	504	#endif /* VARIANT_CANCELABLE */
	505
	506	/*
	507	* Wait for a thread to terminate and obtain its exit value.
	508	*/
	509	int
	510	pthread_join(pthread_t thread, void **value_ptr)
	511	{
	512	int conforming = _pthread_conformance();
	513	if (conforming == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
	514	_pthread_testcancel(conforming);
	515	}
	516	return _pthread_join(thread, value_ptr, conforming);
	517	}
	518
	519	int
	520	pthread_cond_wait(pthread_cond_t cond, pthread_mutex_t mutex)
	521	{
	522	return _pthread_cond_wait(cond, mutex, NULL, 0, _pthread_conformance());
	523	}
	524
	525	int
	526	pthread_cond_timedwait(pthread_cond_t cond, pthread_mutex_t mutex,
	527	const struct timespec *abstime)
	528	{
	529	return _pthread_cond_wait(cond, mutex, abstime, 0, _pthread_conformance());
	530	}
	531
	532	int
	533	sigwait(const sigset_t * set, int * sig)
	534	{
	535	#if __DARWIN_UNIX03
	536	int err = 0, conformance = _pthread_conformance();
	537
	538	if (__unix_conforming == 0)
	539	__unix_conforming = 1;
	540
	541	if (conformance == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
	542	_pthread_testcancel(conformance);
	543	}
	544
	545	if (__sigwait(set, sig) == -1) {
	546	err = errno;
	547
	548	if (conformance == PTHREAD_CONFORM_UNIX03_CANCELABLE) {
	549	_pthread_testcancel(conformance);
	550	}
	551
	552	/*
	553	* EINTR that isn't a result of pthread_cancel()
	554	* is translated to 0.
	555	*/
	556	if (err == EINTR) {
	557	err = 0;
	558	}
	559	}
	560	return(err);
	561	#else /* __DARWIN_UNIX03 */
	562	if (__sigwait(set, sig) == -1) {
	563	/*
	564	* EINTR that isn't a result of pthread_cancel()
	565	* is translated to 0.
	566	*/
	567	if (errno != EINTR) {
	568	return -1;
	569	}
	570	}
	571
	572	return 0;
	573	#endif /* __DARWIN_UNIX03 */
	574	}
	575