svn commit: r214916 - user/davidxu/libthr/lib/libthr/thread

[David Xu]

Author: davidxu
Date: Sun Nov  7 13:50:42 2010
New Revision: 214916
URL: http://svn.freebsd.org/changeset/base/214916

Log:
  Style fix, variable 'ret' should be named as  'error', also
  return error code in cond_wait for ROBUST and PP mutex,
  robust mutex uses kernel based cv.

Modified:
  user/davidxu/libthr/lib/libthr/thread/thr_cond.c

Modified: user/davidxu/libthr/lib/libthr/thread/thr_cond.c
==============================================================================
--- user/davidxu/libthr/lib/libthr/thread/thr_cond.c	Sun Nov  7 13:49:08 2010	(r214915)
+++ user/davidxu/libthr/lib/libthr/thread/thr_cond.c	Sun Nov  7 13:50:42 2010	(r214916)
@@ -92,27 +92,27 @@ cond_init(pthread_cond_t *cond, const pt
 static int
 init_static(struct pthread *thread, pthread_cond_t *cond)
 {
-	int ret;
+	int error;
 
 	THR_LOCK_ACQUIRE(thread, &_cond_static_lock);
 
 	if (*cond == NULL)
-		ret = cond_init(cond, NULL);
+		error = cond_init(cond, NULL);
 	else
-		ret = 0;
+		error = 0;
 
 	THR_LOCK_RELEASE(thread, &_cond_static_lock);
 
-	return (ret);
+	return (error);
 }
 
 #define CHECK_AND_INIT_COND							\
 	if (__predict_false((cv = (*cond)) <= THR_COND_DESTROYED)) {		\
 		if (cv == THR_COND_INITIALIZER) {				\
-			int ret;						\
-			ret = init_static(_get_curthread(), cond);		\
-			if (ret)						\
-				return (ret);					\
+			int error;						\
+			error = init_static(_get_curthread(), cond);		\
+			if (error)						\
+				return (error);					\
 		} else if (cv == THR_COND_DESTROYED) {				\
 			return (EINVAL);					\
 		}								\
@@ -169,39 +169,43 @@ cond_wait_kernel(pthread_cond_t *cond, p
 	pthread_cond_t  cv;
 	struct pthread_mutex *m;
 	int	recurse;
-	int	ret;
+	int	error, error2 = 0;
 
 	cv = *cond;
-	ret = _mutex_cv_detach(mutex, &recurse);
-	if (__predict_false(ret != 0))
-		return (ret);
+	error = _mutex_cv_detach(mutex, &recurse);
+	if (__predict_false(error != 0))
+		return (error);
 	m = *mutex;
 
 	if (cancel) {
 		_thr_cancel_enter2(curthread, 0);
-		ret = _thr_ucond_wait(&cv->c_kerncv, &m->m_lock, abstime,
+		error = _thr_ucond_wait(&cv->c_kerncv, &m->m_lock, abstime,
 			CVWAIT_ABSTIME|CVWAIT_CLOCKID);
 		_thr_cancel_leave(curthread, 0);
 	} else {
-		ret = _thr_ucond_wait(&cv->c_kerncv, &m->m_lock, abstime,
+		error = _thr_ucond_wait(&cv->c_kerncv, &m->m_lock, abstime,
 			CVWAIT_ABSTIME|CVWAIT_CLOCKID);
 	}
 
-	if (ret == 0) {
-		_mutex_cv_lock(mutex, recurse);
-	} else if (ret == EINTR || ret == ETIMEDOUT) {
-		_mutex_cv_lock(mutex, recurse);
-		if (cancel)
+	/*
+	 * Note that PP mutex and ROBUST mutex may return
+	 * interesting error codes.
+	 */
+	if (error == 0) {
+		error2 = _mutex_cv_lock(mutex, recurse);
+	} else if (error == EINTR || error == ETIMEDOUT) {
+		error2 = _mutex_cv_lock(mutex, recurse);
+		if (error2 == 0 && cancel)
 			_thr_testcancel(curthread);
-		if (ret == EINTR)
-			ret = 0;
+		if (error2 == EINTR)
+			error = 0;
 	} else {
 		/* We know that it didn't unlock the mutex. */
-		_mutex_cv_attach(mutex, recurse);
-		if (cancel)
+		error2 = _mutex_cv_attach(mutex, recurse);
+		if (error2 == 0 && cancel)
 			_thr_testcancel(curthread);
 	}
-	return (ret);
+	return (error2 != 0 ? error2 : error);
 }
 
 static int
@@ -212,17 +216,17 @@ cond_wait_user(pthread_cond_t *cond, pth
 	struct timespec ts, ts2, *tsp;
 	int		recurse;
 	pthread_cond_t  cv;
-	int		ret;
+	int		error;
 	uint64_t	seq, bseq;
 
 	cv = *cond;
 	_thr_umtx_lock_spin(&cv->c_lock);
 	cv->c_waiters++;
-	ret = _mutex_cv_unlock(mutex, &recurse);
-	if (__predict_false(ret != 0)) {
+	error = _mutex_cv_unlock(mutex, &recurse);
+	if (__predict_false(error != 0)) {
 		cv->c_waiters--;
 		_thr_umtx_unlock(&cv->c_lock);
-		return (ret);
+		return (error);
 	}
 
 	bseq = cv->c_broadcast_seq;
@@ -239,24 +243,24 @@ cond_wait_user(pthread_cond_t *cond, pth
 
 		if (cancel) {
 			_thr_cancel_enter2(curthread, 0);
-			ret = _thr_umtx_wait_uint((u_int *)&cv->c_seq,
+			error = _thr_umtx_wait_uint((u_int *)&cv->c_seq,
 				(u_int)seq, tsp, CV_PSHARED(cv));
 			_thr_cancel_leave(curthread, 0);
 		} else {
-			ret = _thr_umtx_wait_uint((u_int *)&cv->c_seq,
+			error = _thr_umtx_wait_uint((u_int *)&cv->c_seq,
 				(u_int)seq, tsp, CV_PSHARED(cv));
 		}
 
 		_thr_umtx_lock_spin(&cv->c_lock);
 		if (cv->c_broadcast_seq != bseq) {
-			ret = 0;
+			error = 0;
 			break;
 		}
 		if (cv->c_signaled > 0) {
 			cv->c_signaled--;
-			ret = 0;
+			error = 0;
 			break;
-		} else if (ret == ETIMEDOUT) {
+		} else if (error == ETIMEDOUT) {
 			cv->c_waiters--;
 			break;
 		} else if (cancel && SHOULD_CANCEL(curthread) &&
@@ -269,7 +273,7 @@ cond_wait_user(pthread_cond_t *cond, pth
 	}
 	_thr_umtx_unlock(&cv->c_lock);
 	_mutex_cv_lock(mutex, recurse);
-	return (ret);
+	return (error);
 }
 
 
@@ -306,7 +310,8 @@ cond_wait_common(pthread_cond_t *cond, p
 	 */
 	if (curthread->attr.sched_policy != SCHED_OTHER ||
 	    curthread->priority_mutex_count != 0  ||
-	    (m->m_lock.m_flags & (UMUTEX_PRIO_PROTECT|UMUTEX_PRIO_INHERIT)) != 0)
+	    (m->m_lock.m_flags & (UMUTEX_PRIO_PROTECT|UMUTEX_PRIO_INHERIT|
+		UMUTEX_ROBUST)) != 0)
 		return cond_wait_kernel(cond, mutex, abstime, cancel);
 	else
 		return cond_wait_user(cond, mutex, abstime, cancel);