#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 __unix_conforming;
-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);
-
-#ifdef VARIANT_CANCELABLE
-extern int __semwait_signal(int cond_sem, int mutex_sem, int timeout, int relative, __int64_t tv_sec, __int32_t tv_nsec);
-#else
-extern int __semwait_signal(int cond_sem, int mutex_sem, int timeout, int relative, __int64_t tv_sec, __int32_t tv_nsec) __asm__("___semwait_signal_nocancel");
-#endif
-
-PTHREAD_NOEXPORT
-int _pthread_join(pthread_t thread, void **value_ptr, int conforming,
- int (*_semwait_signal)(int, int, int, int, __int64_t, __int32_t));
-
-#ifndef VARIANT_CANCELABLE
+#ifndef BUILDING_VARIANT /* [ */
-PTHREAD_ALWAYS_INLINE
+OS_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, {
+ uint16_t oldstate, newstate;
+ os_atomic_rmw_loop(&thread->cancel_state, oldstate, newstate, relaxed, {
newstate = oldstate;
newstate &= ~mask;
newstate |= state;
return oldstate;
}
+/* When a thread exits set the cancellation state to DISABLE and DEFERRED */
+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 |
+ _PTHREAD_CANCEL_EXITING);
+}
+
/*
* Cancel a thread
*/
int
pthread_cancel(pthread_t thread)
{
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
-#endif /* __DARWIN_UNIX03 */
-
- if (!_pthread_is_valid(thread, 0, NULL)) {
+ if (!_pthread_is_valid(thread, NULL)) {
return(ESRCH);
}
if (thread->wqthread != 0) {
return(ENOTSUP);
}
-#if __DARWIN_UNIX03
- int state = os_atomic_or2o(thread, cancel_state, _PTHREAD_CANCEL_PENDING, relaxed);
+ int state = os_atomic_or(&thread->cancel_state, _PTHREAD_CANCEL_PENDING, relaxed);
if (state & PTHREAD_CANCEL_ENABLE) {
- mach_port_t kport = _pthread_kernel_thread(thread);
+ mach_port_t kport = _pthread_tsd_slot(thread, MACH_THREAD_SELF);
if (kport) __pthread_markcancel(kport);
}
-#else /* __DARWIN_UNIX03 */
- thread->cancel_state |= _PTHREAD_CANCEL_PENDING;
-#endif /* __DARWIN_UNIX03 */
return (0);
}
-
-void
-pthread_testcancel(void)
+/*
+ * Query/update the cancelability 'state' of a thread
+ */
+PTHREAD_NOEXPORT_VARIANT
+int
+pthread_setcancelstate(int state, int *oldstateptr)
{
pthread_t self = pthread_self();
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
- _pthread_testcancel(self, 1);
-#else /* __DARWIN_UNIX03 */
- _pthread_testcancel(self, 0);
-#endif /* __DARWIN_UNIX03 */
-}
+ _pthread_validate_signature(self);
-#ifndef BUILDING_VARIANT /* [ */
+ switch (state) {
+ case PTHREAD_CANCEL_ENABLE:
+ __pthread_canceled(1);
+ break;
+ case PTHREAD_CANCEL_DISABLE:
+ __pthread_canceled(2);
+ break;
+ default:
+ return EINVAL;
+ }
-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();
- if (self != NULL) {
- self->cancel_error = error;
- }
- pthread_exit(PTHREAD_CANCELED);
+ int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_STATE_MASK, state);
+ if (oldstateptr) {
+ *oldstateptr = oldstate & _PTHREAD_CANCEL_STATE_MASK;
}
+ return 0;
}
-
+/*
+ * Query/update the cancelability 'type' of a thread
+ */
PTHREAD_NOEXPORT_VARIANT
-void
-_pthread_testcancel(pthread_t thread, int isconforming)
+int
+pthread_setcanceltype(int type, int *oldtype)
{
- const int flags = (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING);
+ pthread_t self = pthread_self();
+
+ _pthread_validate_signature(self);
- int state = os_atomic_load2o(thread, cancel_state, seq_cst);
- if ((state & flags) == flags) {
- pthread_exit(isconforming ? PTHREAD_CANCELED : 0);
+ if ((type != PTHREAD_CANCEL_DEFERRED) &&
+ (type != PTHREAD_CANCEL_ASYNCHRONOUS))
+ return EINVAL;
+ int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_TYPE_MASK, type);
+ if (oldtype) {
+ *oldtype = oldstate & _PTHREAD_CANCEL_TYPE_MASK;
}
+ return (0);
}
-PTHREAD_NOEXPORT
-void
-_pthread_markcancel_if_canceled(pthread_t thread, mach_port_t kport)
+
+OS_ALWAYS_INLINE
+static inline bool
+_pthread_is_canceled(pthread_t thread)
{
const int flags = (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING);
+ int state = os_atomic_load(&thread->cancel_state, seq_cst);
+ return (state & flags) == flags;
+}
- int state = os_atomic_or2o(thread, cancel_state,
- _PTHREAD_CANCEL_INITIALIZED, relaxed);
- if ((state & flags) == flags && __unix_conforming) {
- __pthread_markcancel(kport);
+OS_ALWAYS_INLINE
+static inline void *
+_pthread_get_exit_value(pthread_t thread)
+{
+ if (os_unlikely(_pthread_is_canceled(thread))) {
+ return PTHREAD_CANCELED;
}
+ return thread->tl_exit_value;
}
-PTHREAD_NOEXPORT
-void *
-_pthread_get_exit_value(pthread_t thread, int conforming)
+void
+pthread_testcancel(void)
{
- const int flags = (PTHREAD_CANCEL_ENABLE|_PTHREAD_CANCEL_PENDING);
- void *value = thread->exit_value;
-
- if (conforming) {
- int state = os_atomic_load2o(thread, cancel_state, seq_cst);
- if ((state & flags) == flags) {
- value = PTHREAD_CANCELED;
- }
+ pthread_t self = pthread_self();
+ if (os_unlikely(_pthread_is_canceled(self))) {
+ _pthread_validate_signature(self);
+ // 4597450: begin
+ self->canceled = true;
+ // 4597450: end
+ pthread_exit(PTHREAD_CANCELED);
}
- return value;
}
-/* When a thread exits set the cancellation state to DISABLE and DEFERRED */
-PTHREAD_NOEXPORT
void
-_pthread_setcancelstate_exit(pthread_t thread, void *value_ptr, int conforming)
+_pthread_markcancel_if_canceled(pthread_t thread, mach_port_t kport)
{
- _pthread_update_cancel_state(thread,
- _PTHREAD_CANCEL_STATE_MASK | _PTHREAD_CANCEL_TYPE_MASK,
- PTHREAD_CANCEL_DISABLE | PTHREAD_CANCEL_DEFERRED);
- if (value_ptr == PTHREAD_CANCELED) {
- _PTHREAD_LOCK(thread->lock);
- thread->detached |= _PTHREAD_WASCANCEL; // 4597450
- _PTHREAD_UNLOCK(thread->lock);
+ if (os_unlikely(_pthread_is_canceled(thread))) {
+ __pthread_markcancel(kport);
}
}
-#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)
+void
+_pthread_exit_if_canceled(int error)
{
- pthread_t 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;
- }
+ if ((error & 0xff) == EINTR && __pthread_canceled(0) == 0) {
+ pthread_t self = pthread_self();
- self = pthread_self();
- int oldstate = _pthread_update_cancel_state(self, _PTHREAD_CANCEL_STATE_MASK, state);
- if (oldstateptr) {
- *oldstateptr = oldstate & _PTHREAD_CANCEL_STATE_MASK;
- }
- if (!conforming) {
- _pthread_testcancel(self, 0); /* See if we need to 'die' now... */
+ _pthread_validate_signature(self);
+ self->cancel_error = error;
+ self->canceled = true;
+ pthread_exit(PTHREAD_CANCELED);
}
- return 0;
}
-PTHREAD_NOEXPORT_VARIANT
int
-pthread_setcancelstate(int state, int *oldstate)
+pthread_sigmask(int how, const sigset_t * set, sigset_t * oset)
{
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0) {
- __unix_conforming = 1;
+ int err = 0;
+
+ if (__pthread_sigmask(how, set, oset) == -1) {
+ err = errno;
}
- return (_pthread_setcancelstate_internal(state, oldstate, 1));
-#else /* __DARWIN_UNIX03 */
- return (_pthread_setcancelstate_internal(state, oldstate, 0));
-#endif /* __DARWIN_UNIX03 */
+ return(err);
}
-/*
- * Query/update the cancelability 'type' of a thread
- */
-PTHREAD_NOEXPORT_VARIANT
-int
-pthread_setcanceltype(int type, int *oldtype)
+// called with _pthread_list_lock held
+semaphore_t
+_pthread_joiner_prepost_wake(pthread_t thread)
{
- pthread_t self;
-
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
-#endif /* __DARWIN_UNIX03 */
+ pthread_join_context_t ctx = thread->tl_join_ctx;
+ semaphore_t sema = MACH_PORT_NULL;
- 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 (thread->tl_joinable) {
+ sema = ctx->custom_stack_sema;
+ thread->tl_joinable = false;
+ } else {
+ ctx->detached = true;
+ thread->tl_join_ctx = NULL;
}
-#if !__DARWIN_UNIX03
- _pthread_testcancel(self, 0); /* See if we need to 'die' now... */
-#endif /* __DARWIN_UNIX03 */
- return (0);
+ if (ctx->value_ptr) *ctx->value_ptr = _pthread_get_exit_value(thread);
+ return sema;
}
-
-int
-pthread_sigmask(int how, const sigset_t * set, sigset_t * oset)
+static inline bool
+_pthread_joiner_abort_wait(pthread_t thread, pthread_join_context_t ctx)
{
-#if __DARWIN_UNIX03
- int err = 0;
+ bool aborted = false;
- if (__pthread_sigmask(how, set, oset) == -1) {
- err = errno;
+ _pthread_lock_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
+ */
+ PTHREAD_DEBUG_ASSERT(thread->tl_join_ctx == ctx);
+ thread->tl_join_ctx = NULL;
+ thread->tl_exit_gate = MACH_PORT_NULL;
+ aborted = true;
}
- return(err);
-#else /* __DARWIN_UNIX03 */
- return(__pthread_sigmask(how, set, oset));
-#endif /* __DARWIN_UNIX03 */
+ _pthread_lock_unlock(&_pthread_list_lock);
+ return aborted;
}
-#ifndef BUILDING_VARIANT /* [ */
-
-static void
-__posix_join_cleanup(void *arg)
+static int
+_pthread_joiner_wait(pthread_t thread, pthread_join_context_t ctx,
+ pthread_conformance_t conforming)
{
- pthread_t thread = (pthread_t)arg;
+ 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 (os_unlikely(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(thread->lock);
- /* leave another thread to join */
- thread->joiner = (struct _pthread *)NULL;
- _PTHREAD_UNLOCK(thread->lock);
+ _pthread_lock_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) {
+ PTHREAD_DEBUG_ASSERT(thread->tl_join_ctx == ctx);
+ thread->tl_join_ctx = NULL;
+ cleanup = thread->tl_joiner_cleans_up;
+ }
+ _pthread_lock_unlock(&_pthread_list_lock);
+
+ if (cleanup) {
+ _pthread_deallocate(thread, false);
+ }
+ return 0;
}
-PTHREAD_NOEXPORT PTHREAD_NOINLINE
+OS_NOINLINE
int
-_pthread_join(pthread_t thread, void **value_ptr, int conforming,
- int (*_semwait_signal)(int, int, int, int, __int64_t, __int32_t))
+_pthread_join(pthread_t thread, void **value_ptr, pthread_conformance_t conforming)
{
- int res = 0;
pthread_t self = pthread_self();
- kern_return_t kern_res;
- semaphore_t joinsem, death = (semaphore_t)os_get_cached_semaphore();
+ 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_is_valid(thread, PTHREAD_IS_VALID_LOCK_THREAD, NULL)) {
- res = ESRCH;
- goto out;
+ if (!_pthread_validate_thread_and_list_lock(thread)) {
+ return ESRCH;
}
- if (thread->sig != _PTHREAD_SIG) {
- res = ESRCH;
- } else if ((thread->detached & PTHREAD_CREATE_DETACHED) ||
- !(thread->detached & PTHREAD_CREATE_JOINABLE) ||
- (thread->joiner != NULL)) {
+ _pthread_validate_signature(self);
+
+ if (!thread->tl_joinable || (thread->tl_join_ctx != NULL)) {
res = EINVAL;
- } else if (thread == self || (self != NULL && self->joiner == thread)) {
+ } 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);
+ PTHREAD_DEBUG_ASSERT(thread->tl_joiner_cleans_up);
+ thread->tl_joinable = false;
+ if (value_ptr) *value_ptr = _pthread_get_exit_value(thread);
+ } else {
+ ctx.kport = _pthread_tsd_slot(thread, MACH_THREAD_SELF);
+ 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();
+ }
}
- if (res != 0) {
- _PTHREAD_UNLOCK(thread->lock);
- goto out;
- }
+ _pthread_lock_unlock(&_pthread_list_lock);
- joinsem = thread->joiner_notify;
- if (joinsem == SEMAPHORE_NULL) {
- thread->joiner_notify = joinsem = death;
- death = MACH_PORT_NULL;
+ if (res == 0) {
+ if (ctx.kport == MACH_PORT_NULL) {
+ _pthread_deallocate(thread, false);
+ } else {
+ res = _pthread_joiner_wait(thread, &ctx, conforming);
+ }
}
- thread->joiner = self;
- _PTHREAD_UNLOCK(thread->lock);
-
- if (conforming) {
- /* Wait for it to signal... */
- pthread_cleanup_push(__posix_join_cleanup, (void *)thread);
+ 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 {
- res = _semwait_signal(joinsem, 0, 0, 0, 0, 0);
- } while ((res < 0) && (errno == EINTR));
- pthread_cleanup_pop(0);
- } else {
- /* Wait for it to signal... */
- kern_return_t (*_semaphore_wait)(semaphore_t) =
- (void*)_semwait_signal;
- do {
- kern_res = _semaphore_wait(joinsem);
- } while (kern_res != KERN_SUCCESS);
+ kr = __semwait_signal_nocancel(ctx.custom_stack_sema, 0, 0, 0, 0, 0);
+ } while (kr != KERN_SUCCESS);
}
-
- os_put_cached_semaphore((os_semaphore_t)joinsem);
- res = _pthread_join_cleanup(thread, value_ptr, conforming);
-
-out:
- if (death) {
- os_put_cached_semaphore(death);
+ 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)
+static inline pthread_conformance_t
+_pthread_conformance(void)
{
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
-
#ifdef VARIANT_CANCELABLE
- _pthread_testcancel(pthread_self(), 1);
-#endif /* VARIANT_CANCELABLE */
- return _pthread_join(thread, value_ptr, 1, __semwait_signal);
-#else
- return _pthread_join(thread, value_ptr, 0, (void*)semaphore_wait);
-#endif /* __DARWIN_UNIX03 */
-
+ return PTHREAD_CONFORM_UNIX03_CANCELABLE;
+#else /* !VARIANT_CANCELABLE */
+ return PTHREAD_CONFORM_UNIX03_NOCANCEL;
+#endif
}
-int
-pthread_cond_wait(pthread_cond_t *cond,
- pthread_mutex_t *mutex)
+static inline void
+_pthread_testcancel_if_cancelable_variant(void)
{
- int conforming;
-#if __DARWIN_UNIX03
-
- if (__unix_conforming == 0)
- __unix_conforming = 1;
-
#ifdef VARIANT_CANCELABLE
- conforming = 1;
-#else /* !VARIANT_CANCELABLE */
- conforming = -1;
-#endif /* VARIANT_CANCELABLE */
-#else /* __DARWIN_UNIX03 */
- conforming = 0;
-#endif /* __DARWIN_UNIX03 */
- return (_pthread_cond_wait(cond, mutex, (struct timespec *)NULL, 0, conforming));
+ pthread_testcancel();
+#endif
}
int
-pthread_cond_timedwait(pthread_cond_t *cond,
- pthread_mutex_t *mutex,
- const struct timespec *abstime)
+pthread_join(pthread_t thread, void **value_ptr)
{
- int conforming;
-#if __DARWIN_UNIX03
- if (__unix_conforming == 0)
- __unix_conforming = 1;
+ _pthread_testcancel_if_cancelable_variant();
+ return _pthread_join(thread, value_ptr, _pthread_conformance());
+}
-#ifdef VARIANT_CANCELABLE
- conforming = 1;
-#else /* !VARIANT_CANCELABLE */
- conforming = -1;
-#endif /* VARIANT_CANCELABLE */
-#else /* __DARWIN_UNIX03 */
- conforming = 0;
-#endif /* __DARWIN_UNIX03 */
+int
+pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
+{
+ return _pthread_cond_wait(cond, mutex, NULL, 0, _pthread_conformance());
+}
- return (_pthread_cond_wait(cond, mutex, abstime, 0, conforming));
+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;
- if (__unix_conforming == 0)
- __unix_conforming = 1;
-
-#ifdef VARIANT_CANCELABLE
- _pthread_testcancel(pthread_self(), 1);
-#endif /* VARIANT_CANCELABLE */
+ _pthread_testcancel_if_cancelable_variant();
if (__sigwait(set, sig) == -1) {
err = errno;
-#ifdef VARIANT_CANCELABLE
- _pthread_testcancel(pthread_self(), 1);
-#endif /* VARIANT_CANCELABLE */
+ _pthread_testcancel_if_cancelable_variant();
/*
* EINTR that isn't a result of pthread_cancel()
}
}
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 */
}
projects / apple / libpthread.git / blobdiff