 @@ -1,14 +1,14 @@
-/*	$NetBSD: sem.c,v 1.21 2008/11/14 15:49:20 ad Exp $	*/
+/*	$NetBSD: sem.c,v 1.22 2012/03/07 23:31:44 joerg Exp $	*/
 /*-
  * Copyright (c) 2003, 2006, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of Wasabi Systems, Inc, and by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -49,138 +49,112 @@
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: sem.c,v 1.21 2008/11/14 15:49:20 ad Exp $");
+__RCSID("$NetBSD: sem.c,v 1.22 2012/03/07 23:31:44 joerg Exp $");
 #include <sys/types.h>
 #include <sys/ksem.h>
 #include <sys/queue.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <semaphore.h>
 #include <stdarg.h>
 #include "pthread.h"
 #include "pthread_int.h"
 struct _sem_st {
-	unsigned int	usem_magic;
+	unsigned int	ksem_magic;
-#define	USEM_MAGIC	0x09fa4012
+#define	KSEM_MAGIC	0x90af0421U
-	LIST_ENTRY(_sem_st) usem_list;
+	LIST_ENTRY(_sem_st) ksem_list;
-	intptr_t		usem_semid;	/* 0 -> user (non-shared) */
+	intptr_t		ksem_semid;	/* 0 -> user (non-shared) */
-#define	USEM_USER	0		/* assumes kernel does not use NULL */
+	sem_t		*ksem_identity;
 	sem_t		*usem_identity;
 	/* Protects data below. */
 	pthread_mutex_t	usem_interlock;
 	pthread_cond_t	usem_cv;
 	unsigned int	usem_count;
 };
 static int sem_alloc(unsigned int value, intptr_t semid, sem_t *semp);
 static void sem_free(sem_t sem);
 static LIST_HEAD(, _sem_st) named_sems = LIST_HEAD_INITIALIZER(&named_sems);
 static pthread_mutex_t named_sems_mtx = PTHREAD_MUTEX_INITIALIZER;
 static void
 sem_free(sem_t sem)
+{
-	if (sem->usem_semid == USEM_USER) {
+	sem->ksem_magic = 0;
 		pthread_cond_destroy(&sem->usem_cv);
 		pthread_mutex_destroy(&sem->usem_interlock);
 	sem->usem_magic = 0;
 	free(sem);
+}
 static int
 sem_alloc(unsigned int value, intptr_t semid, sem_t *semp)
+{
 	sem_t sem;
 	if (value > SEM_VALUE_MAX)
 		return (EINVAL);
 	if ((sem = malloc(sizeof(struct _sem_st))) == NULL)
 		return (ENOSPC);
-	sem->usem_magic = USEM_MAGIC;
+	sem->ksem_magic = KSEM_MAGIC;
-	pthread_mutex_init(&sem->usem_interlock, NULL);
+	sem->ksem_semid = semid;
 	pthread_cond_init(&sem->usem_cv, NULL);
 	sem->usem_count = value;
 	sem->usem_semid = semid;
 	*semp = sem;
 	return (0);
+}
 /* ARGSUSED */
 int
 sem_init(sem_t *sem, int pshared, unsigned int value)
+{
 	intptr_t	semid;
 	int error;
-	semid = USEM_USER;
+	if (_ksem_init(value, &semid) == -1)
 	if (pshared && _ksem_init(value, &semid) == -1)
 		return (-1);
 	if ((error = sem_alloc(value, semid, sem)) != 0) {
-		if (semid != USEM_USER)
+		_ksem_destroy(semid);
 			_ksem_destroy(semid);
 		errno = error;
 		return (-1);
+	}
 	return (0);
+}
 int
 sem_destroy(sem_t *sem)
+{
 #ifdef ERRORCHECK
-	if (sem == NULL || *sem == NULL || (*sem)->usem_magic != USEM_MAGIC) {
+	if (sem == NULL || *sem == NULL || (*sem)->ksem_magic != KSEM_MAGIC) {
 		errno = EINVAL;
 		return (-1);
+	}
 #endif
-	if ((*sem)->usem_semid != USEM_USER) {
+	if (_ksem_destroy((*sem)->ksem_semid) == -1)
-		if (_ksem_destroy((*sem)->usem_semid))
+		return (-1);
 			return (-1);
 	} else {
 		pthread_mutex_lock(&(*sem)->usem_interlock);
 		if (!PTQ_EMPTY(&(*sem)->usem_cv.ptc_waiters)) {
 			pthread_mutex_unlock(&(*sem)->usem_interlock);
 			errno = EBUSY;
 			return (-1);
 		pthread_mutex_unlock(&(*sem)->usem_interlock);
 	sem_free(*sem);
 	return (0);
+}
 sem_t *
 sem_open(const char *name, int oflag, ...)
+{
 	sem_t *sem, s;
 	intptr_t semid;
 	mode_t mode;
 	unsigned int value;
 @@ -199,217 +173,130 @@ sem_open(const char *name, int oflag, ..
 	/*
 	 * We can be lazy and let the kernel handle the oflag,
 	 * we'll just merge duplicate IDs into our list.
 	 */
 	if (_ksem_open(name, oflag, mode, value, &semid) == -1)
 		return (SEM_FAILED);
 	/*
 	 * Search for a duplicate ID, we must return the same sem_t *
 	 * if we locate one.
 	 */
 	pthread_mutex_lock(&named_sems_mtx);
-	LIST_FOREACH(s, &named_sems, usem_list) {
+	LIST_FOREACH(s, &named_sems, ksem_list) {
-		if (s->usem_semid == semid) {
+		if (s->ksem_semid == semid) {
 			pthread_mutex_unlock(&named_sems_mtx);
-			return (s->usem_identity);
+			return (s->ksem_identity);
+		}
+	}
 	if ((sem = malloc(sizeof(*sem))) == NULL) {
 		error = ENOSPC;
 		goto bad;
+	}
 	if ((error = sem_alloc(value, semid, sem)) != 0)
 		goto bad;
-	LIST_INSERT_HEAD(&named_sems, *sem, usem_list);
+	LIST_INSERT_HEAD(&named_sems, *sem, ksem_list);
 	(*sem)->usem_identity = sem;
 	pthread_mutex_unlock(&named_sems_mtx);
 	(*sem)->ksem_identity = sem;
 	return (sem);
  bad:
 	pthread_mutex_unlock(&named_sems_mtx);
 	_ksem_close(semid);
 	if (sem != NULL) {
 		if (*sem != NULL)
 			sem_free(*sem);
 		free(sem);
+	}
 	errno = error;
 	return (SEM_FAILED);
+}
 int
 sem_close(sem_t *sem)
+{
 #ifdef ERRORCHECK
-	if (sem == NULL || *sem == NULL || (*sem)->usem_magic != USEM_MAGIC) {
+	if (sem == NULL || *sem == NULL || (*sem)->ksem_magic != KSEM_MAGIC) {
 		errno = EINVAL;
 		return (-1);
+	}
 #endif
 	if ((*sem)->usem_semid == USEM_USER) {
 		errno = EINVAL;
 		return (-1);
 	pthread_mutex_lock(&named_sems_mtx);
-	if (_ksem_close((*sem)->usem_semid) == -1) {
+	if (_ksem_close((*sem)->ksem_semid) == -1) {
 		pthread_mutex_unlock(&named_sems_mtx);
 		return (-1);
+	}
 	LIST_REMOVE((*sem), usem_list);
 	LIST_REMOVE((*sem), ksem_list);
 	pthread_mutex_unlock(&named_sems_mtx);
 	sem_free(*sem);
 	free(sem);
 	return (0);
+}
 int
 sem_unlink(const char *name)
+{
 	return (_ksem_unlink(name));
+}
 int
 sem_wait(sem_t *sem)
+{
 	pthread_t self;
 	extern int pthread__started;
 #ifdef ERRORCHECK
-	if (sem == NULL || *sem == NULL || (*sem)->usem_magic != USEM_MAGIC) {
+	if (sem == NULL || *sem == NULL || (*sem)->ksem_magic != KSEM_MAGIC) {
 		errno = EINVAL;
 		return (-1);
+	}
 #endif
-	self = pthread__self();
+	return (_ksem_wait((*sem)->ksem_semid));
 	if ((*sem)->usem_semid != USEM_USER) {
 		pthread__testcancel(self);
 		return (_ksem_wait((*sem)->usem_semid));
 	if (pthread__started == 0) {
 		sigset_t set, oset;
 		sigfillset(&set);
 		(void) sigprocmask(SIG_SETMASK, &set, &oset);
 		for (;;) {
 			if ((*sem)->usem_count > 0) {
 				break;
 			(void) sigsuspend(&oset);
 		(*sem)->usem_count--;
 		(void) sigprocmask(SIG_SETMASK, &oset, NULL);
 		return 0;
 	pthread_mutex_lock(&(*sem)->usem_interlock);
 	for (;;) {
 		if (self->pt_cancel) {
 			pthread_mutex_unlock(&(*sem)->usem_interlock);
 			pthread__cancelled();
 		if ((*sem)->usem_count > 0)
 			break;
 		(void)pthread_cond_wait(&(*sem)->usem_cv,
 		    &(*sem)->usem_interlock);
 	(*sem)->usem_count--;
 	pthread_mutex_unlock(&(*sem)->usem_interlock);
 	return (0);
+}
 int
 sem_trywait(sem_t *sem)
+{
 	extern int pthread__started;
 #ifdef ERRORCHECK
-	if (sem == NULL || *sem == NULL || (*sem)->usem_magic != USEM_MAGIC) {
+	if (sem == NULL || *sem == NULL || (*sem)->ksem_magic != KSEM_MAGIC) {
 		errno = EINVAL;
 		return (-1);
+	}
 #endif
-	if ((*sem)->usem_semid != USEM_USER)
+	return (_ksem_trywait((*sem)->ksem_semid));
 		return (_ksem_trywait((*sem)->usem_semid));
 	if (pthread__started == 0) {
 		sigset_t set, oset;
 		int rv = 0;
 		sigfillset(&set);
 		(void) sigprocmask(SIG_SETMASK, &set, &oset);
 		if ((*sem)->usem_count > 0) {
 			(*sem)->usem_count--;
 		} else {
 			errno = EAGAIN;
 			rv = -1;
 		(void) sigprocmask(SIG_SETMASK, &oset, NULL);
 		return rv;
 	pthread_mutex_lock(&(*sem)->usem_interlock);
 	if ((*sem)->usem_count == 0) {
 		pthread_mutex_unlock(&(*sem)->usem_interlock);
 		errno = EAGAIN;
 		return (-1);
 	(*sem)->usem_count--;
 	pthread_mutex_unlock(&(*sem)->usem_interlock);
 	return (0);
+}
 int
 sem_post(sem_t *sem)
+{
 #ifdef ERRORCHECK
-	if (sem == NULL || *sem == NULL || (*sem)->usem_magic != USEM_MAGIC) {
+	if (sem == NULL || *sem == NULL || (*sem)->ksem_magic != KSEM_MAGIC) {
 		errno = EINVAL;
 		return (-1);
+	}
 #endif
-	if ((*sem)->usem_semid != USEM_USER)
+	return (_ksem_post((*sem)->ksem_semid));
 		return (_ksem_post((*sem)->usem_semid));
 	pthread_mutex_lock(&(*sem)->usem_interlock);
 	(*sem)->usem_count++;
 	pthread_cond_signal(&(*sem)->usem_cv);
 	pthread_mutex_unlock(&(*sem)->usem_interlock);
 	return (0);
+}
 int
 sem_getvalue(sem_t * __restrict sem, int * __restrict sval)
+{
 #ifdef ERRORCHECK
-	if (sem == NULL || *sem == NULL || (*sem)->usem_magic != USEM_MAGIC) {
+	if (sem == NULL || *sem == NULL || (*sem)->ksem_magic != KSEM_MAGIC) {
 		errno = EINVAL;
 		return (-1);
+	}
 #endif
-	if ((*sem)->usem_semid != USEM_USER)
+	return (_ksem_getvalue((*sem)->ksem_semid, sval));
 		return (_ksem_getvalue((*sem)->usem_semid, sval));
 	pthread_mutex_lock(&(*sem)->usem_interlock);
 	*sval = (int) (*sem)->usem_count;
 	pthread_mutex_unlock(&(*sem)->usem_interlock);
 	return (0);
+}

 @@ -1,14 +1,14 @@
-/* $NetBSD: t_sem.c,v 1.5 2010/11/03 16:10:22 christos Exp $ */
+/* $NetBSD: t_sem.c,v 1.6 2012/03/07 23:31:44 joerg Exp $ */
 /*
  * Copyright (c) 2008, 2010 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -76,27 +76,27 @@
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  ****************************************************************************/
 #include <sys/cdefs.h>
 __COPYRIGHT("@(#) Copyright (c) 2008, 2010\
  The NetBSD Foundation, inc. All rights reserved.");
-__RCSID("$NetBSD: t_sem.c,v 1.5 2010/11/03 16:10:22 christos Exp $");
+__RCSID("$NetBSD: t_sem.c,v 1.6 2012/03/07 23:31:44 joerg Exp $");
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <semaphore.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <atf-c.h>
 #include <atf-c/config.h>
 @@ -280,32 +280,25 @@ ATF_TC_BODY(before_start_no_threads, tc)
+{
 	before_start_test(false);
+}
 ATF_TC(before_start_one_thread);
 ATF_TC_HEAD(before_start_one_thread, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks using semaphores before "
 	    "starting one thread");
 	atf_tc_set_md_var(tc, "timeout", "40");
+}
 ATF_TC_BODY(before_start_one_thread, tc)
+{
 	/* TODO(jmmv): This really is a race condition test.  However, we can't
 	 * yet mark it as such because ATF does not provide such functionality.
 	 * Let's just mark it as an unconditional expected timeout as I haven't
 	 * got it to pass any single time. */
 	atf_tc_expect_timeout("Race condition; it is probably unsafe to call "
 	    "sem_post from a signal handler when using the pthread version");
 	before_start_test(true);
+}
 ATF_TP_ADD_TCS(tp)
+{
 	ATF_TP_ADD_TC(tp, named);
 	ATF_TP_ADD_TC(tp, unnamed);
 	ATF_TP_ADD_TC(tp, before_start_no_threads);
 	ATF_TP_ADD_TC(tp, before_start_one_thread);
 	return atf_no_error();
+}