src/pthread_cond.c

/*
 * Copyright (c) 2000-2003, 2007, 2008 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 "internal.h"
#include <sys/time.h>	      /* For struct timespec and getclock(). */
#include <stdio.h>

#ifdef PLOCKSTAT
#include "plockstat.h"
#else /* !PLOCKSTAT */
#define PLOCKSTAT_MUTEX_RELEASE(x, y)
#endif /* PLOCKSTAT */

__private_extern__ int _pthread_cond_init(_pthread_cond *, const pthread_condattr_t *, int);
__private_extern__ int _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime, int isRelative, int isconforming);

extern int __gettimeofday(struct timeval *, struct timezone *);

#ifndef BUILDING_VARIANT
static void _pthread_cond_cleanup(void *arg);
static void _pthread_cond_updateval(_pthread_cond * cond, int error, uint32_t updateval);
#endif

static void
COND_GETSEQ_ADDR(_pthread_cond *cond,
		 volatile uint32_t **c_lseqcnt,
		 volatile uint32_t **c_useqcnt,
		 volatile uint32_t **c_sseqcnt)
{
	if (cond->misalign) {
		*c_lseqcnt = &cond->c_seq[1];
		*c_sseqcnt = &cond->c_seq[2];
		*c_useqcnt = &cond->c_seq[0];
	} else {
		*c_lseqcnt = &cond->c_seq[0];
		*c_sseqcnt = &cond->c_seq[1];
		*c_useqcnt = &cond->c_seq[2];
	}
}

#ifndef BUILDING_VARIANT /* [ */

int
pthread_condattr_init(pthread_condattr_t *attr)
{
	attr->sig = _PTHREAD_COND_ATTR_SIG;
	attr->pshared = _PTHREAD_DEFAULT_PSHARED;
	return 0;
}

int
pthread_condattr_destroy(pthread_condattr_t *attr)
{
	attr->sig = _PTHREAD_NO_SIG;
	return 0;
}

int
pthread_condattr_getpshared(const pthread_condattr_t *attr, int *pshared)
{
	int res = EINVAL;
	if (attr->sig == _PTHREAD_COND_ATTR_SIG) {
		*pshared = (int)attr->pshared;
		res = 0;
	}
	return res;
}

int
pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared)
{
	int res = EINVAL;
	if (attr->sig == _PTHREAD_COND_ATTR_SIG) {
#if __DARWIN_UNIX03
		if (pshared == PTHREAD_PROCESS_PRIVATE || pshared == PTHREAD_PROCESS_SHARED)
#else /* __DARWIN_UNIX03 */
		if (pshared == PTHREAD_PROCESS_PRIVATE)
#endif /* __DARWIN_UNIX03 */
		{
			attr->pshared = pshared;
			res = 0;
		}
	}
	return res;
}

__private_extern__ int
_pthread_cond_init(_pthread_cond *cond, const pthread_condattr_t *attr, int conforming)
{
	volatile uint32_t *c_lseqcnt, *c_useqcnt, *c_sseqcnt;

	cond->busy = NULL;
	cond->c_seq[0] = 0;
	cond->c_seq[1] = 0;
	cond->c_seq[2] = 0;
	cond->unused = 0;

	cond->misalign = (((uintptr_t)&cond->c_seq[0]) & 0x7) != 0;
	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);
	*c_sseqcnt = PTH_RWS_CV_CBIT; // set Sword to 0c

	if (conforming) {
		if (attr) {
			cond->pshared = attr->pshared;
		} else {
			cond->pshared = _PTHREAD_DEFAULT_PSHARED;
		}
	} else {
		cond->pshared = _PTHREAD_DEFAULT_PSHARED;
	}

	// Ensure all contents are properly set before setting signature.
	OSMemoryBarrier();
	cond->sig = _PTHREAD_COND_SIG;

	return 0;
}

static int
_pthread_cond_check_init(_pthread_cond *cond, bool *inited)
{
	int res = 0;
	if (cond->sig != _PTHREAD_COND_SIG) {
		res = EINVAL;
		if (cond->sig == _PTHREAD_COND_SIG_init) {
			LOCK(cond->lock);
			if (cond->sig == _PTHREAD_COND_SIG_init) {
				res = _pthread_cond_init(cond, NULL, 0);
				if (inited) {
					*inited = true;
				}
			} else if (cond->sig == _PTHREAD_COND_SIG) {
				res = 0;
			}
			UNLOCK(cond->lock);
		}
	}
	return res;
}

int
pthread_cond_destroy(pthread_cond_t *ocond)
{
	_pthread_cond *cond = (_pthread_cond *)ocond;
	int res = EINVAL;
	if (cond->sig == _PTHREAD_COND_SIG) {
		LOCK(cond->lock);

		uint64_t oldval64, newval64;
		uint32_t lcntval, ucntval, scntval;
		volatile uint32_t *c_lseqcnt, *c_useqcnt, *c_sseqcnt;

		COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);

		do {
			lcntval = *c_lseqcnt;
			ucntval = *c_useqcnt;
			scntval = *c_sseqcnt;

			// validate it is not busy
			if ((lcntval & PTHRW_COUNT_MASK) != (scntval & PTHRW_COUNT_MASK)) {
				//res = EBUSY;
				break;
			}
			oldval64 = (((uint64_t)scntval) << 32);
			oldval64 |= lcntval;
			newval64 = oldval64;
		} while (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE);

		// <rdar://problem/13782056> Need to clear preposts.
		uint32_t flags = 0;
		bool needclearpre = ((scntval & PTH_RWS_CV_PBIT) != 0);
		if (needclearpre && cond->pshared == PTHREAD_PROCESS_SHARED) {
			flags |= _PTHREAD_MTX_OPT_PSHARED;
		}

		cond->sig = _PTHREAD_NO_SIG;
		res = 0;

		UNLOCK(cond->lock);

		if (needclearpre) {
			(void)__psynch_cvclrprepost(cond, lcntval, ucntval, scntval, 0, lcntval, flags);
		}
	} else if (cond->sig == _PTHREAD_COND_SIG_init) {
		// Compatibility for misbehaving applications that attempt to
		// destroy a statically initialized condition variable.
		cond->sig = _PTHREAD_NO_SIG;
		res = 0;
	}
	return res;
}

static int
_pthread_cond_signal(pthread_cond_t *ocond, bool broadcast, mach_port_t thread)
{
	int res;
	_pthread_cond *cond = (_pthread_cond *)ocond;

	uint32_t updateval;
	uint32_t diffgen;
	uint32_t ulval;

	uint64_t oldval64, newval64;
	uint32_t lcntval, ucntval, scntval;
	volatile uint32_t *c_lseqcnt, *c_useqcnt, *c_sseqcnt;

	int retry_count = 0, uretry_count = 0;
	int ucountreset = 0;

	bool inited = false;
	res = _pthread_cond_check_init(cond, &inited);
	if (res != 0 || inited == true) {
		return res;
	}

	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);

	bool retry;
	do {
		retry = false;

		lcntval = *c_lseqcnt;
		ucntval = *c_useqcnt;
		scntval = *c_sseqcnt;

		if (((lcntval & PTHRW_COUNT_MASK) == (scntval & PTHRW_COUNT_MASK)) ||
		    (thread == MACH_PORT_NULL && ((lcntval & PTHRW_COUNT_MASK) == (ucntval & PTHRW_COUNT_MASK)))) {
			/* validate it is spurious and return */
			oldval64 = (((uint64_t)scntval) << 32);
			oldval64 |= lcntval;
			newval64 = oldval64;

			if (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE) {
				retry = true;
				continue;
			} else {
				return 0;
			}
		}

		if (thread) {
			break;
		}

		/* validate to eliminate spurious values, race snapshots */
		if (is_seqhigher((scntval & PTHRW_COUNT_MASK), (lcntval & PTHRW_COUNT_MASK))) {
			/* since ucntval may be newer, just redo */
			retry_count++;
			if (retry_count > 8192) {
				return EAGAIN;
			} else {
				sched_yield();
				retry = true;
				continue;
			}
		} else if (is_seqhigher((ucntval & PTHRW_COUNT_MASK), (lcntval & PTHRW_COUNT_MASK))) {
			/* since ucntval may be newer, just redo */
			uretry_count++;
			if (uretry_count > 8192) {
				/*
				 * U value if not used for a while can go out of sync
				 * set this to S value and try one more time.
				 */
				if (ucountreset != 0) {
					return EAGAIN;
				} else if (OSAtomicCompareAndSwap32Barrier(ucntval, (scntval & PTHRW_COUNT_MASK), (volatile int32_t *)c_useqcnt) == TRUE) {
					/* now the U is reset to S value */
					ucountreset = 1;
					uretry_count = 0;
				}
			}
			sched_yield();
			retry = true;
			continue;
		}

		if (is_seqlower(ucntval & PTHRW_COUNT_MASK, scntval & PTHRW_COUNT_MASK) != 0) {
			/* If U < S, set U = S+diff due to intr's TO, etc */
			ulval = (scntval & PTHRW_COUNT_MASK);
		} else {
			/* If U >= S, set U = U+diff due to intr's TO, etc */
			ulval = (ucntval & PTHRW_COUNT_MASK);
		}

		if (broadcast) {
			diffgen = diff_genseq(lcntval, ulval);
			// Set U = L
			ulval = (lcntval & PTHRW_COUNT_MASK);
		} else {
			ulval += PTHRW_INC;
		}

	} while (retry || OSAtomicCompareAndSwap32Barrier(ucntval, ulval, (volatile int32_t *)c_useqcnt) != TRUE);

	uint32_t flags = 0;
	if (cond->pshared == PTHREAD_PROCESS_SHARED) {
		flags |= _PTHREAD_MTX_OPT_PSHARED;
	}

	uint64_t cvlsgen = ((uint64_t)scntval << 32) | lcntval;

	if (broadcast) {
		// pass old U val so kernel will know the diffgen
		uint64_t cvudgen = ((uint64_t)ucntval << 32) | diffgen;
		updateval = __psynch_cvbroad(ocond, cvlsgen, cvudgen, flags, NULL, 0, 0);
	} else {
		updateval = __psynch_cvsignal(ocond, cvlsgen, ucntval, thread, NULL, 0, 0, flags);
	}

	if (updateval != (uint32_t)-1 && updateval != 0) {
		_pthread_cond_updateval(cond, 0, updateval);
	}

	return 0;
}


/*
 * Signal a condition variable, waking up all threads waiting for it.
 */
int
pthread_cond_broadcast(pthread_cond_t *ocond)
{
	return _pthread_cond_signal(ocond, true, MACH_PORT_NULL);
}

/*
 * Signal a condition variable, waking a specified thread.
 */
int
pthread_cond_signal_thread_np(pthread_cond_t *ocond, pthread_t thread)
{
	mach_port_t mp = MACH_PORT_NULL;
	if (thread) {
		mp = pthread_mach_thread_np(thread);
	}
	return _pthread_cond_signal(ocond, false, mp);
}

/*
 * Signal a condition variable, waking only one thread.
 */
int
pthread_cond_signal(pthread_cond_t *cond)
{
	return pthread_cond_signal_thread_np(cond, NULL);
}

/*
 * Manage a list of condition variables associated with a mutex
 */


/*
 * Suspend waiting for a condition variable.
 * Note: we have to keep a list of condition variables which are using
 * this same mutex variable so we can detect invalid 'destroy' sequences.
 * If isconforming < 0, we skip the _pthread_testcancel(), but keep the
 * remaining conforming behavior..
 */
__private_extern__ int
_pthread_cond_wait(pthread_cond_t *ocond,
			pthread_mutex_t *omutex,
			const struct timespec *abstime,
			int isRelative,
			int isconforming)
{
	int res;
	_pthread_cond *cond = (_pthread_cond *)ocond;
	_pthread_mutex *mutex = (_pthread_mutex *)omutex;
	struct timespec then = { 0, 0 };
	uint32_t mtxgen, mtxugen, flags=0, updateval;
	uint32_t lcntval, ucntval, scntval;
	uint32_t nlval, ulval, savebits;
	volatile uint32_t *c_lseqcnt, *c_useqcnt, *c_sseqcnt;
	uint64_t oldval64, newval64, mugen, cvlsgen;
	uint32_t *npmtx = NULL;

extern void _pthread_testcancel(pthread_t thread, int isconforming);

	res = _pthread_cond_check_init(cond, NULL);
	if (res != 0) {
		return res;
	}

	if (isconforming) {
		if (mutex->sig != _PTHREAD_MUTEX_SIG && (mutex->sig & _PTHREAD_MUTEX_SIG_init_MASK) != _PTHREAD_MUTEX_SIG_CMP) {
			return EINVAL;
		}
		if (isconforming > 0) {
			_pthread_testcancel(pthread_self(), 1);
		}
	}

	/* send relative time to kernel */
	if (abstime) {
		if (isRelative == 0) {
			struct timespec now;
			struct timeval tv;
			__gettimeofday(&tv, NULL);
			TIMEVAL_TO_TIMESPEC(&tv, &now);

			/* Compute relative time to sleep */
			then.tv_nsec = abstime->tv_nsec - now.tv_nsec;
			then.tv_sec = abstime->tv_sec - now.tv_sec;
			if (then.tv_nsec < 0) {
				then.tv_nsec += NSEC_PER_SEC;
				then.tv_sec--;
			}
			if (then.tv_sec < 0 || (then.tv_sec == 0 && then.tv_nsec == 0)) {
				return ETIMEDOUT;
			}
			if (isconforming &&
			    (abstime->tv_sec < 0 ||
			     abstime->tv_nsec < 0 ||
			     abstime->tv_nsec >= NSEC_PER_SEC)) {
				return EINVAL;
			}
		} else {
			then.tv_sec = abstime->tv_sec;
			then.tv_nsec = abstime->tv_nsec;
			if ((then.tv_sec == 0) && (then.tv_nsec == 0)) {
				return ETIMEDOUT;
			}
		}
		if (isconforming && (then.tv_sec < 0 || then.tv_nsec < 0)) {
			return EINVAL;
		}
		if (then.tv_nsec >= NSEC_PER_SEC) {
			return EINVAL;
		}
	}

	if (cond->busy != NULL && cond->busy != mutex) {
		return EINVAL;
	}

	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);

	do {
		lcntval = *c_lseqcnt;
		ucntval = *c_useqcnt;
		scntval = *c_sseqcnt;

		oldval64 = (((uint64_t)scntval) << 32);
		oldval64 |= lcntval;

		/* remove c and p bits on S word */
		savebits = scntval & PTH_RWS_CV_BITSALL;
		ulval = (scntval & PTHRW_COUNT_MASK);
		nlval = lcntval + PTHRW_INC;
		newval64 = (((uint64_t)ulval) << 32);
		newval64 |= nlval;
	} while (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE);

	cond->busy = mutex;

	res = __mtx_droplock(mutex, &flags, &npmtx, &mtxgen, &mtxugen);

	/* TBD: cases are for normal (non owner for recursive mutex; error checking)*/
	if (res != 0) {
		return EINVAL;
	}
	if ((flags & _PTHREAD_MTX_OPT_NOTIFY) == 0) {
		npmtx = NULL;
		mugen = 0;
	} else {
		mugen = ((uint64_t)mtxugen << 32) | mtxgen;
	}
	flags &= ~_PTHREAD_MTX_OPT_MUTEX;	/* reset the mutex bit as this is cvar */

	cvlsgen = ((uint64_t)(ulval | savebits)<< 32) | nlval;

	// SUSv3 requires pthread_cond_wait to be a cancellation point
	if (isconforming) {
		pthread_cleanup_push(_pthread_cond_cleanup, (void *)cond);
		updateval = __psynch_cvwait(ocond, cvlsgen, ucntval, (pthread_mutex_t *)npmtx, mugen, flags, (int64_t)then.tv_sec, (int32_t)then.tv_nsec);
		_pthread_testcancel(pthread_self(), isconforming);
		pthread_cleanup_pop(0);
	} else {
		updateval = __psynch_cvwait(ocond, cvlsgen, ucntval, (pthread_mutex_t *)npmtx, mugen, flags, (int64_t)then.tv_sec, (int32_t)then.tv_nsec);
	}

	if (updateval == (uint32_t)-1) {
		int err = errno;
		switch (err & 0xff) {
			case ETIMEDOUT:
				res = ETIMEDOUT;
				break;
			case EINTR:
				// spurious wakeup (unless canceled)
				res = 0;
				break;
			default:
				res = EINVAL;
				break;
		}

		// add unlock ref to show one less waiter
		_pthread_cond_updateval(cond, err, 0);
	} else if (updateval != 0) {
		// Successful wait
		// The return due to prepost and might have bit states
		// update S and return for prepo if needed
		_pthread_cond_updateval(cond, 0, updateval);
	}

	pthread_mutex_lock(omutex);

	return res;
}

static void
_pthread_cond_cleanup(void *arg)
{
	_pthread_cond *cond = (_pthread_cond *)arg;
	pthread_mutex_t *mutex;

// 4597450: begin
	pthread_t thread = pthread_self();
	int thcanceled = 0;

	LOCK(thread->lock);
	thcanceled = (thread->detached & _PTHREAD_WASCANCEL);
	UNLOCK(thread->lock);

	if (thcanceled == 0) {
		return;
	}

// 4597450: end
	mutex = (pthread_mutex_t *)cond->busy;

	// add unlock ref to show one less waiter
	_pthread_cond_updateval(cond, thread->cancel_error, 0);

	/*
	** Can't do anything if this fails -- we're on the way out
	*/
	if (mutex != NULL) {
		(void)pthread_mutex_lock(mutex);
	}
}

#define ECVCERORR       256
#define ECVPERORR       512

static void
_pthread_cond_updateval(_pthread_cond *cond, int error, uint32_t updateval)
{
	int needclearpre;

	uint32_t diffgen, nsval;
	uint64_t oldval64, newval64;
	uint32_t lcntval, ucntval, scntval;
	volatile uint32_t *c_lseqcnt, *c_useqcnt, *c_sseqcnt;

	if (error != 0) {
		updateval = PTHRW_INC;
		if ((error & ECVCERORR) != 0) {
			updateval |= PTH_RWS_CV_CBIT;
		}
		if ((error & ECVPERORR) != 0) {
			updateval |= PTH_RWS_CV_PBIT;
		}
	}

	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);

	do {
		lcntval = *c_lseqcnt;
		ucntval = *c_useqcnt;
		scntval = *c_sseqcnt;

		diffgen = diff_genseq(lcntval, scntval); // pending waiters

		oldval64 = (((uint64_t)scntval) << 32);
		oldval64 |= lcntval;

		if (diffgen <= 0) {
			/* TBD: Assert, should not be the case */
			/* validate it is spurious and return */
			newval64 = oldval64;
		} else {
			// update S by one

			// update scntval with number of expected returns and bits
			nsval = (scntval & PTHRW_COUNT_MASK) + (updateval & PTHRW_COUNT_MASK);
			// set bits
			nsval |= ((scntval & PTH_RWS_CV_BITSALL) | (updateval & PTH_RWS_CV_BITSALL));

			// if L==S and c&p bits are set, needs clearpre
			if (((nsval & PTHRW_COUNT_MASK) == (lcntval & PTHRW_COUNT_MASK)) &&
			    ((nsval & PTH_RWS_CV_BITSALL) == PTH_RWS_CV_BITSALL)) {
				// reset p bit but retain c bit on the sword
				nsval &= PTH_RWS_CV_RESET_PBIT;
				needclearpre = 1;
			} else {
				needclearpre = 0;
			}

			newval64 = (((uint64_t)nsval) << 32);
			newval64 |= lcntval;
		}
	} while (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE);

	if (diffgen > 0) {
		// if L == S, then reset associated mutex
		if ((nsval & PTHRW_COUNT_MASK) == (lcntval & PTHRW_COUNT_MASK)) {
			cond->busy = NULL;
		}

		if (needclearpre != 0) {
			uint32_t flags = 0;
			if (cond->pshared == PTHREAD_PROCESS_SHARED) {
				flags |= _PTHREAD_MTX_OPT_PSHARED;
			}
			(void)__psynch_cvclrprepost(cond, lcntval, ucntval, nsval, 0, lcntval, flags);
		}
	}
}


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

#endif /* !BUILDING_VARIANT ] */

int
pthread_cond_init(pthread_cond_t *ocond, const pthread_condattr_t *attr)
{
	int conforming;

#if __DARWIN_UNIX03
	conforming = 1;
#else /* __DARWIN_UNIX03 */
	conforming = 0;
#endif /* __DARWIN_UNIX03 */

	_pthread_cond *cond = (_pthread_cond *)ocond;
	LOCK_INIT(cond->lock);
	return _pthread_cond_init(cond, attr, conforming);
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2000-2003, 2007, 2008 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	* MkLinux
	45	*/
	46
	47	/*
	48	* POSIX Pthread Library
	49	*/
	50
	51	#include "internal.h"
	52	#include <sys/time.h> /* For struct timespec and getclock(). */
	53	#include <stdio.h>
	54
	55	#ifdef PLOCKSTAT
	56	#include "plockstat.h"
	57	#else /* !PLOCKSTAT */
	58	#define PLOCKSTAT_MUTEX_RELEASE(x, y)
	59	#endif /* PLOCKSTAT */
	60
	61	__private_extern__ int _pthread_cond_init(_pthread_cond , const pthread_condattr_t , int);
	62	__private_extern__ int _pthread_cond_wait(pthread_cond_t cond, pthread_mutex_t mutex, const struct timespec *abstime, int isRelative, int isconforming);
	63
	64	extern int __gettimeofday(struct timeval , struct timezone );
	65
	66	#ifndef BUILDING_VARIANT
	67	static void _pthread_cond_cleanup(void *arg);
	68	static void _pthread_cond_updateval(_pthread_cond * cond, int error, uint32_t updateval);
	69	#endif
	70
	71	static void
	72	COND_GETSEQ_ADDR(_pthread_cond *cond,
	73	volatile uint32_t **c_lseqcnt,
	74	volatile uint32_t **c_useqcnt,
	75	volatile uint32_t **c_sseqcnt)
	76	{
	77	if (cond->misalign) {
	78	*c_lseqcnt = &cond->c_seq[1];
	79	*c_sseqcnt = &cond->c_seq[2];
	80	*c_useqcnt = &cond->c_seq[0];
	81	} else {
	82	*c_lseqcnt = &cond->c_seq[0];
	83	*c_sseqcnt = &cond->c_seq[1];
	84	*c_useqcnt = &cond->c_seq[2];
	85	}
	86	}
	87
	88	#ifndef BUILDING_VARIANT /* [ */
	89
	90	int
	91	pthread_condattr_init(pthread_condattr_t *attr)
	92	{
	93	attr->sig = _PTHREAD_COND_ATTR_SIG;
	94	attr->pshared = _PTHREAD_DEFAULT_PSHARED;
	95	return 0;
	96	}
	97
	98	int
	99	pthread_condattr_destroy(pthread_condattr_t *attr)
	100	{
	101	attr->sig = _PTHREAD_NO_SIG;
	102	return 0;
	103	}
	104
	105	int
	106	pthread_condattr_getpshared(const pthread_condattr_t attr, int pshared)
	107	{
	108	int res = EINVAL;
	109	if (attr->sig == _PTHREAD_COND_ATTR_SIG) {
	110	*pshared = (int)attr->pshared;
	111	res = 0;
	112	}
	113	return res;
	114	}
	115
	116	int
	117	pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared)
	118	{
	119	int res = EINVAL;
	120	if (attr->sig == _PTHREAD_COND_ATTR_SIG) {
	121	#if __DARWIN_UNIX03
	122	if (pshared == PTHREAD_PROCESS_PRIVATE \|\| pshared == PTHREAD_PROCESS_SHARED)
	123	#else /* __DARWIN_UNIX03 */
	124	if (pshared == PTHREAD_PROCESS_PRIVATE)
	125	#endif /* __DARWIN_UNIX03 */
	126	{
	127	attr->pshared = pshared;
	128	res = 0;
	129	}
	130	}
	131	return res;
	132	}
	133
	134	__private_extern__ int
	135	_pthread_cond_init(_pthread_cond cond, const pthread_condattr_t attr, int conforming)
	136	{
	137	volatile uint32_t c_lseqcnt, c_useqcnt, *c_sseqcnt;
	138
	139	cond->busy = NULL;
	140	cond->c_seq[0] = 0;
	141	cond->c_seq[1] = 0;
	142	cond->c_seq[2] = 0;
	143	cond->unused = 0;
	144
	145	cond->misalign = (((uintptr_t)&cond->c_seq[0]) & 0x7) != 0;
	146	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);
	147	*c_sseqcnt = PTH_RWS_CV_CBIT; // set Sword to 0c
	148
	149	if (conforming) {
	150	if (attr) {
	151	cond->pshared = attr->pshared;
	152	} else {
	153	cond->pshared = _PTHREAD_DEFAULT_PSHARED;
	154	}
	155	} else {
	156	cond->pshared = _PTHREAD_DEFAULT_PSHARED;
	157	}
	158
	159	// Ensure all contents are properly set before setting signature.
	160	OSMemoryBarrier();
	161	cond->sig = _PTHREAD_COND_SIG;
	162
	163	return 0;
	164	}
	165
	166	static int
	167	_pthread_cond_check_init(_pthread_cond cond, bool inited)
	168	{
	169	int res = 0;
	170	if (cond->sig != _PTHREAD_COND_SIG) {
	171	res = EINVAL;
	172	if (cond->sig == _PTHREAD_COND_SIG_init) {
	173	LOCK(cond->lock);
	174	if (cond->sig == _PTHREAD_COND_SIG_init) {
	175	res = _pthread_cond_init(cond, NULL, 0);
	176	if (inited) {
	177	*inited = true;
	178	}
	179	} else if (cond->sig == _PTHREAD_COND_SIG) {
	180	res = 0;
	181	}
	182	UNLOCK(cond->lock);
	183	}
	184	}
	185	return res;
	186	}
	187
	188	int
	189	pthread_cond_destroy(pthread_cond_t *ocond)
	190	{
	191	_pthread_cond cond = (_pthread_cond )ocond;
	192	int res = EINVAL;
	193	if (cond->sig == _PTHREAD_COND_SIG) {
	194	LOCK(cond->lock);
	195
	196	uint64_t oldval64, newval64;
	197	uint32_t lcntval, ucntval, scntval;
	198	volatile uint32_t c_lseqcnt, c_useqcnt, *c_sseqcnt;
	199
	200	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);
	201
	202	do {
	203	lcntval = *c_lseqcnt;
	204	ucntval = *c_useqcnt;
	205	scntval = *c_sseqcnt;
	206
	207	// validate it is not busy
	208	if ((lcntval & PTHRW_COUNT_MASK) != (scntval & PTHRW_COUNT_MASK)) {
	209	//res = EBUSY;
	210	break;
	211	}
	212	oldval64 = (((uint64_t)scntval) << 32);
	213	oldval64 \|= lcntval;
	214	newval64 = oldval64;
	215	} while (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE);
	216
	217	// <rdar://problem/13782056> Need to clear preposts.
	218	uint32_t flags = 0;
	219	bool needclearpre = ((scntval & PTH_RWS_CV_PBIT) != 0);
	220	if (needclearpre && cond->pshared == PTHREAD_PROCESS_SHARED) {
	221	flags \|= _PTHREAD_MTX_OPT_PSHARED;
	222	}
	223
	224	cond->sig = _PTHREAD_NO_SIG;
	225	res = 0;
	226
	227	UNLOCK(cond->lock);
	228
	229	if (needclearpre) {
	230	(void)__psynch_cvclrprepost(cond, lcntval, ucntval, scntval, 0, lcntval, flags);
	231	}
	232	} else if (cond->sig == _PTHREAD_COND_SIG_init) {
	233	// Compatibility for misbehaving applications that attempt to
	234	// destroy a statically initialized condition variable.
	235	cond->sig = _PTHREAD_NO_SIG;
	236	res = 0;
	237	}
	238	return res;
	239	}
	240
	241	static int
	242	_pthread_cond_signal(pthread_cond_t *ocond, bool broadcast, mach_port_t thread)
	243	{
	244	int res;
	245	_pthread_cond cond = (_pthread_cond )ocond;
	246
	247	uint32_t updateval;
	248	uint32_t diffgen;
	249	uint32_t ulval;
	250
	251	uint64_t oldval64, newval64;
	252	uint32_t lcntval, ucntval, scntval;
	253	volatile uint32_t c_lseqcnt, c_useqcnt, *c_sseqcnt;
	254
	255	int retry_count = 0, uretry_count = 0;
	256	int ucountreset = 0;
	257
	258	bool inited = false;
	259	res = _pthread_cond_check_init(cond, &inited);
	260	if (res != 0 \|\| inited == true) {
	261	return res;
	262	}
	263
	264	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);
	265
	266	bool retry;
	267	do {
	268	retry = false;
	269
	270	lcntval = *c_lseqcnt;
	271	ucntval = *c_useqcnt;
	272	scntval = *c_sseqcnt;
	273
	274	if (((lcntval & PTHRW_COUNT_MASK) == (scntval & PTHRW_COUNT_MASK)) \|\|
	275	(thread == MACH_PORT_NULL && ((lcntval & PTHRW_COUNT_MASK) == (ucntval & PTHRW_COUNT_MASK)))) {
	276	/* validate it is spurious and return */
	277	oldval64 = (((uint64_t)scntval) << 32);
	278	oldval64 \|= lcntval;
	279	newval64 = oldval64;
	280
	281	if (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE) {
	282	retry = true;
	283	continue;
	284	} else {
	285	return 0;
	286	}
	287	}
	288
	289	if (thread) {
	290	break;
	291	}
	292
	293	/* validate to eliminate spurious values, race snapshots */
	294	if (is_seqhigher((scntval & PTHRW_COUNT_MASK), (lcntval & PTHRW_COUNT_MASK))) {
	295	/* since ucntval may be newer, just redo */
	296	retry_count++;
	297	if (retry_count > 8192) {
	298	return EAGAIN;
	299	} else {
	300	sched_yield();
	301	retry = true;
	302	continue;
	303	}
	304	} else if (is_seqhigher((ucntval & PTHRW_COUNT_MASK), (lcntval & PTHRW_COUNT_MASK))) {
	305	/* since ucntval may be newer, just redo */
	306	uretry_count++;
	307	if (uretry_count > 8192) {
	308	/*
	309	* U value if not used for a while can go out of sync
	310	* set this to S value and try one more time.
	311	*/
	312	if (ucountreset != 0) {
	313	return EAGAIN;
	314	} else if (OSAtomicCompareAndSwap32Barrier(ucntval, (scntval & PTHRW_COUNT_MASK), (volatile int32_t *)c_useqcnt) == TRUE) {
	315	/* now the U is reset to S value */
	316	ucountreset = 1;
	317	uretry_count = 0;
	318	}
	319	}
	320	sched_yield();
	321	retry = true;
	322	continue;
	323	}
	324
	325	if (is_seqlower(ucntval & PTHRW_COUNT_MASK, scntval & PTHRW_COUNT_MASK) != 0) {
	326	/* If U < S, set U = S+diff due to intr's TO, etc */
	327	ulval = (scntval & PTHRW_COUNT_MASK);
	328	} else {
	329	/* If U >= S, set U = U+diff due to intr's TO, etc */
	330	ulval = (ucntval & PTHRW_COUNT_MASK);
	331	}
	332
	333	if (broadcast) {
	334	diffgen = diff_genseq(lcntval, ulval);
	335	// Set U = L
	336	ulval = (lcntval & PTHRW_COUNT_MASK);
	337	} else {
	338	ulval += PTHRW_INC;
	339	}
	340
	341	} while (retry \|\| OSAtomicCompareAndSwap32Barrier(ucntval, ulval, (volatile int32_t *)c_useqcnt) != TRUE);
	342
	343	uint32_t flags = 0;
	344	if (cond->pshared == PTHREAD_PROCESS_SHARED) {
	345	flags \|= _PTHREAD_MTX_OPT_PSHARED;
	346	}
	347
	348	uint64_t cvlsgen = ((uint64_t)scntval << 32) \| lcntval;
	349
	350	if (broadcast) {
	351	// pass old U val so kernel will know the diffgen
	352	uint64_t cvudgen = ((uint64_t)ucntval << 32) \| diffgen;
	353	updateval = __psynch_cvbroad(ocond, cvlsgen, cvudgen, flags, NULL, 0, 0);
	354	} else {
	355	updateval = __psynch_cvsignal(ocond, cvlsgen, ucntval, thread, NULL, 0, 0, flags);
	356	}
	357
	358	if (updateval != (uint32_t)-1 && updateval != 0) {
	359	_pthread_cond_updateval(cond, 0, updateval);
	360	}
	361
	362	return 0;
	363	}
	364
	365
	366	/*
	367	* Signal a condition variable, waking up all threads waiting for it.
	368	*/
	369	int
	370	pthread_cond_broadcast(pthread_cond_t *ocond)
	371	{
	372	return _pthread_cond_signal(ocond, true, MACH_PORT_NULL);
	373	}
	374
	375	/*
	376	* Signal a condition variable, waking a specified thread.
	377	*/
	378	int
	379	pthread_cond_signal_thread_np(pthread_cond_t *ocond, pthread_t thread)
	380	{
	381	mach_port_t mp = MACH_PORT_NULL;
	382	if (thread) {
	383	mp = pthread_mach_thread_np(thread);
	384	}
	385	return _pthread_cond_signal(ocond, false, mp);
	386	}
	387
	388	/*
	389	* Signal a condition variable, waking only one thread.
	390	*/
	391	int
	392	pthread_cond_signal(pthread_cond_t *cond)
	393	{
	394	return pthread_cond_signal_thread_np(cond, NULL);
	395	}
	396
	397	/*
	398	* Manage a list of condition variables associated with a mutex
	399	*/
	400
	401
	402	/*
	403	* Suspend waiting for a condition variable.
	404	* Note: we have to keep a list of condition variables which are using
	405	* this same mutex variable so we can detect invalid 'destroy' sequences.
	406	* If isconforming < 0, we skip the _pthread_testcancel(), but keep the
	407	* remaining conforming behavior..
	408	*/
	409	__private_extern__ int
	410	_pthread_cond_wait(pthread_cond_t *ocond,
	411	pthread_mutex_t *omutex,
	412	const struct timespec *abstime,
	413	int isRelative,
	414	int isconforming)
	415	{
	416	int res;
	417	_pthread_cond cond = (_pthread_cond )ocond;
	418	_pthread_mutex mutex = (_pthread_mutex )omutex;
	419	struct timespec then = { 0, 0 };
	420	uint32_t mtxgen, mtxugen, flags=0, updateval;
	421	uint32_t lcntval, ucntval, scntval;
	422	uint32_t nlval, ulval, savebits;
	423	volatile uint32_t c_lseqcnt, c_useqcnt, *c_sseqcnt;
	424	uint64_t oldval64, newval64, mugen, cvlsgen;
	425	uint32_t *npmtx = NULL;
	426
	427	extern void _pthread_testcancel(pthread_t thread, int isconforming);
	428
	429	res = _pthread_cond_check_init(cond, NULL);
	430	if (res != 0) {
	431	return res;
	432	}
	433
	434	if (isconforming) {
	435	if (mutex->sig != _PTHREAD_MUTEX_SIG && (mutex->sig & _PTHREAD_MUTEX_SIG_init_MASK) != _PTHREAD_MUTEX_SIG_CMP) {
	436	return EINVAL;
	437	}
	438	if (isconforming > 0) {
	439	_pthread_testcancel(pthread_self(), 1);
	440	}
	441	}
	442
	443	/* send relative time to kernel */
	444	if (abstime) {
	445	if (isRelative == 0) {
	446	struct timespec now;
	447	struct timeval tv;
	448	__gettimeofday(&tv, NULL);
	449	TIMEVAL_TO_TIMESPEC(&tv, &now);
	450
	451	/* Compute relative time to sleep */
	452	then.tv_nsec = abstime->tv_nsec - now.tv_nsec;
	453	then.tv_sec = abstime->tv_sec - now.tv_sec;
	454	if (then.tv_nsec < 0) {
	455	then.tv_nsec += NSEC_PER_SEC;
	456	then.tv_sec--;
	457	}
	458	if (then.tv_sec < 0 \|\| (then.tv_sec == 0 && then.tv_nsec == 0)) {
	459	return ETIMEDOUT;
	460	}
	461	if (isconforming &&
	462	(abstime->tv_sec < 0 \|\|
	463	abstime->tv_nsec < 0 \|\|
	464	abstime->tv_nsec >= NSEC_PER_SEC)) {
	465	return EINVAL;
	466	}
	467	} else {
	468	then.tv_sec = abstime->tv_sec;
	469	then.tv_nsec = abstime->tv_nsec;
	470	if ((then.tv_sec == 0) && (then.tv_nsec == 0)) {
	471	return ETIMEDOUT;
	472	}
	473	}
	474	if (isconforming && (then.tv_sec < 0 \|\| then.tv_nsec < 0)) {
	475	return EINVAL;
	476	}
	477	if (then.tv_nsec >= NSEC_PER_SEC) {
	478	return EINVAL;
	479	}
	480	}
	481
	482	if (cond->busy != NULL && cond->busy != mutex) {
	483	return EINVAL;
	484	}
	485
	486	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);
	487
	488	do {
	489	lcntval = *c_lseqcnt;
	490	ucntval = *c_useqcnt;
	491	scntval = *c_sseqcnt;
	492
	493	oldval64 = (((uint64_t)scntval) << 32);
	494	oldval64 \|= lcntval;
	495
	496	/* remove c and p bits on S word */
	497	savebits = scntval & PTH_RWS_CV_BITSALL;
	498	ulval = (scntval & PTHRW_COUNT_MASK);
	499	nlval = lcntval + PTHRW_INC;
	500	newval64 = (((uint64_t)ulval) << 32);
	501	newval64 \|= nlval;
	502	} while (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE);
	503
	504	cond->busy = mutex;
	505
	506	res = __mtx_droplock(mutex, &flags, &npmtx, &mtxgen, &mtxugen);
	507
	508	/* TBD: cases are for normal (non owner for recursive mutex; error checking)*/
	509	if (res != 0) {
	510	return EINVAL;
	511	}
	512	if ((flags & _PTHREAD_MTX_OPT_NOTIFY) == 0) {
	513	npmtx = NULL;
	514	mugen = 0;
	515	} else {
	516	mugen = ((uint64_t)mtxugen << 32) \| mtxgen;
	517	}
	518	flags &= ~_PTHREAD_MTX_OPT_MUTEX; /* reset the mutex bit as this is cvar */
	519
	520	cvlsgen = ((uint64_t)(ulval \| savebits)<< 32) \| nlval;
	521
	522	// SUSv3 requires pthread_cond_wait to be a cancellation point
	523	if (isconforming) {
	524	pthread_cleanup_push(_pthread_cond_cleanup, (void *)cond);
	525	updateval = __psynch_cvwait(ocond, cvlsgen, ucntval, (pthread_mutex_t *)npmtx, mugen, flags, (int64_t)then.tv_sec, (int32_t)then.tv_nsec);
	526	_pthread_testcancel(pthread_self(), isconforming);
	527	pthread_cleanup_pop(0);
	528	} else {
	529	updateval = __psynch_cvwait(ocond, cvlsgen, ucntval, (pthread_mutex_t *)npmtx, mugen, flags, (int64_t)then.tv_sec, (int32_t)then.tv_nsec);
	530	}
	531
	532	if (updateval == (uint32_t)-1) {
	533	int err = errno;
	534	switch (err & 0xff) {
	535	case ETIMEDOUT:
	536	res = ETIMEDOUT;
	537	break;
	538	case EINTR:
	539	// spurious wakeup (unless canceled)
	540	res = 0;
	541	break;
	542	default:
	543	res = EINVAL;
	544	break;
	545	}
	546
	547	// add unlock ref to show one less waiter
	548	_pthread_cond_updateval(cond, err, 0);
	549	} else if (updateval != 0) {
	550	// Successful wait
	551	// The return due to prepost and might have bit states
	552	// update S and return for prepo if needed
	553	_pthread_cond_updateval(cond, 0, updateval);
	554	}
	555
	556	pthread_mutex_lock(omutex);
	557
	558	return res;
	559	}
	560
	561	static void
	562	_pthread_cond_cleanup(void *arg)
	563	{
	564	_pthread_cond cond = (_pthread_cond )arg;
	565	pthread_mutex_t *mutex;
	566
	567	// 4597450: begin
	568	pthread_t thread = pthread_self();
	569	int thcanceled = 0;
	570
	571	LOCK(thread->lock);
	572	thcanceled = (thread->detached & _PTHREAD_WASCANCEL);
	573	UNLOCK(thread->lock);
	574
	575	if (thcanceled == 0) {
	576	return;
	577	}
	578
	579	// 4597450: end
	580	mutex = (pthread_mutex_t *)cond->busy;
	581
	582	// add unlock ref to show one less waiter
	583	_pthread_cond_updateval(cond, thread->cancel_error, 0);
	584
	585	/*
	586	** Can't do anything if this fails -- we're on the way out
	587	*/
	588	if (mutex != NULL) {
	589	(void)pthread_mutex_lock(mutex);
	590	}
	591	}
	592
	593	#define ECVCERORR 256
	594	#define ECVPERORR 512
	595
	596	static void
	597	_pthread_cond_updateval(_pthread_cond *cond, int error, uint32_t updateval)
	598	{
	599	int needclearpre;
	600
	601	uint32_t diffgen, nsval;
	602	uint64_t oldval64, newval64;
	603	uint32_t lcntval, ucntval, scntval;
	604	volatile uint32_t c_lseqcnt, c_useqcnt, *c_sseqcnt;
	605
	606	if (error != 0) {
	607	updateval = PTHRW_INC;
	608	if ((error & ECVCERORR) != 0) {
	609	updateval \|= PTH_RWS_CV_CBIT;
	610	}
	611	if ((error & ECVPERORR) != 0) {
	612	updateval \|= PTH_RWS_CV_PBIT;
	613	}
	614	}
	615
	616	COND_GETSEQ_ADDR(cond, &c_lseqcnt, &c_useqcnt, &c_sseqcnt);
	617
	618	do {
	619	lcntval = *c_lseqcnt;
	620	ucntval = *c_useqcnt;
	621	scntval = *c_sseqcnt;
	622
	623	diffgen = diff_genseq(lcntval, scntval); // pending waiters
	624
	625	oldval64 = (((uint64_t)scntval) << 32);
	626	oldval64 \|= lcntval;
	627
	628	if (diffgen <= 0) {
	629	/* TBD: Assert, should not be the case */
	630	/* validate it is spurious and return */
	631	newval64 = oldval64;
	632	} else {
	633	// update S by one
	634
	635	// update scntval with number of expected returns and bits
	636	nsval = (scntval & PTHRW_COUNT_MASK) + (updateval & PTHRW_COUNT_MASK);
	637	// set bits
	638	nsval \|= ((scntval & PTH_RWS_CV_BITSALL) \| (updateval & PTH_RWS_CV_BITSALL));
	639
	640	// if L==S and c&p bits are set, needs clearpre
	641	if (((nsval & PTHRW_COUNT_MASK) == (lcntval & PTHRW_COUNT_MASK)) &&
	642	((nsval & PTH_RWS_CV_BITSALL) == PTH_RWS_CV_BITSALL)) {
	643	// reset p bit but retain c bit on the sword
	644	nsval &= PTH_RWS_CV_RESET_PBIT;
	645	needclearpre = 1;
	646	} else {
	647	needclearpre = 0;
	648	}
	649
	650	newval64 = (((uint64_t)nsval) << 32);
	651	newval64 \|= lcntval;
	652	}
	653	} while (OSAtomicCompareAndSwap64Barrier(oldval64, newval64, (volatile int64_t *)c_lseqcnt) != TRUE);
	654
	655	if (diffgen > 0) {
	656	// if L == S, then reset associated mutex
	657	if ((nsval & PTHRW_COUNT_MASK) == (lcntval & PTHRW_COUNT_MASK)) {
	658	cond->busy = NULL;
	659	}
	660
	661	if (needclearpre != 0) {
	662	uint32_t flags = 0;
	663	if (cond->pshared == PTHREAD_PROCESS_SHARED) {
	664	flags \|= _PTHREAD_MTX_OPT_PSHARED;
	665	}
	666	(void)__psynch_cvclrprepost(cond, lcntval, ucntval, nsval, 0, lcntval, flags);
	667	}
	668	}
	669	}
	670
	671
	672	int
	673	pthread_cond_timedwait_relative_np(pthread_cond_t cond, pthread_mutex_t mutex, const struct timespec *abstime)
	674	{
	675	return _pthread_cond_wait(cond, mutex, abstime, 1, 0);
	676	}
	677
	678	#endif /* !BUILDING_VARIANT ] */
	679
	680	int
	681	pthread_cond_init(pthread_cond_t ocond, const pthread_condattr_t attr)
	682	{
	683	int conforming;
	684
	685	#if __DARWIN_UNIX03
	686	conforming = 1;
	687	#else /* __DARWIN_UNIX03 */
	688	conforming = 0;
	689	#endif /* __DARWIN_UNIX03 */
	690
	691	_pthread_cond cond = (_pthread_cond )ocond;
	692	LOCK_INIT(cond->lock);
	693	return _pthread_cond_init(cond, attr, conforming);
	694	}