 @@ -1,415 +1,302 @@
-/*	$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.
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY 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 FOUNDATION OR CONTRIBUTORS
  * 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.
  */
 /*
  * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
  * 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(s), this list of conditions and the following disclaimer as
  *    the first lines of this file unmodified other than the possible
  *    addition of one or more copyright notices.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice(s), this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  * 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;
 	int error;
 	va_list ap;
 	mode = 0;
 	value = 0;
 	if (oflag & O_CREAT) {
 		va_start(ap, oflag);
 		mode = va_arg(ap, int);
 		value = va_arg(ap, unsigned int);
 		va_end(ap);
+	}
 	/*
 	 * 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,311 +1,304 @@
-/* $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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY 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 FOUNDATION OR CONTRIBUTORS
  * 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.
  */
 /*-
  * Copyright (c)2004 YAMAMOTO Takashi,
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY 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 AUTHOR OR CONTRIBUTORS 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.
  */
 /****************************************************************************
+ *
  * Copyright (C) 2000 Jason Evans <jasone@freebsd.org>.
  * 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(s), this list of conditions and the following disclaimer as
  *    the first lines of this file unmodified other than the possible
  *    addition of one or more copyright notices.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice(s), this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
  * 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>
 __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>
 #include "h_common.h"
 #define NTHREADS 10
 #define _LIBC_R_
 #define SEM_REQUIRE(x) \
 	ATF_REQUIRE_EQ_MSG(x, 0, "%s", strerror(errno))
 static sem_t sem;
 ATF_TC(named);
 ATF_TC_HEAD(named, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks named semaphores");
+}
 ATF_TC_BODY(named, tc)
+{
 	sem_t *semp;
 	ATF_REQUIRE_MSG(-1 != sysconf(_SC_SEMAPHORES), "%s", strerror(errno));
 	printf("Test begin\n");
 	(void) sem_unlink("/foo");
 	semp = sem_open("/foo", O_CREAT | O_EXCL, 0644, 0);
 	ATF_REQUIRE_MSG(semp != SEM_FAILED, "%s", strerror(errno));
 	SEM_REQUIRE(sem_close(semp));
 	SEM_REQUIRE(sem_unlink("/foo"));
 	printf("Test end\n");
+}
 ATF_TC(unnamed);
 ATF_TC_HEAD(unnamed, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks unnamed semaphores");
+}
 static void *
 entry(void * a_arg)
+{
 	pthread_t self = pthread_self();
 	sem_t *semp = (sem_t *) a_arg;
 	printf("Thread %p waiting for semaphore...\n", self);
 	sem_wait(semp);
 	printf("Thread %p got semaphore\n", self);
 	return NULL;
+}
 ATF_TC_BODY(unnamed, tc)
+{
 	sem_t sem_a, sem_b;
 	pthread_t threads[NTHREADS];
 	unsigned i, j;
 	int val;
 	ATF_REQUIRE_MSG(-1 != sysconf(_SC_SEMAPHORES), "%s", strerror(errno));
 	printf("Test begin\n");
 	SEM_REQUIRE(sem_init(&sem_b, 0, 0));
 	SEM_REQUIRE(sem_getvalue(&sem_b, &val));
 	ATF_REQUIRE_EQ(0, val);
 	SEM_REQUIRE(sem_post(&sem_b));
 	SEM_REQUIRE(sem_getvalue(&sem_b, &val));
 	ATF_REQUIRE_EQ(1, val);
 	SEM_REQUIRE(sem_wait(&sem_b));
 	ATF_REQUIRE_EQ(sem_trywait(&sem_b), -1);
 	ATF_REQUIRE_EQ(errno, EAGAIN);
 	SEM_REQUIRE(sem_post(&sem_b));
 	SEM_REQUIRE(sem_trywait(&sem_b));
 	SEM_REQUIRE(sem_post(&sem_b));
 	SEM_REQUIRE(sem_wait(&sem_b));
 	SEM_REQUIRE(sem_post(&sem_b));
 	SEM_REQUIRE(sem_destroy(&sem_b));
 	SEM_REQUIRE(sem_init(&sem_a, 0, 0));
 	for (j = 0; j < 2; j++) {
 		for (i = 0; i < NTHREADS; i++) {
 			PTHREAD_REQUIRE(pthread_create(&threads[i], NULL,
 				entry, (void *) &sem_a));
+		}
 		for (i = 0; i < NTHREADS; i++) {
 			usleep(10000);
 			printf("main loop %u: posting...\n", j+1);
 			SEM_REQUIRE(sem_post(&sem_a));
+		}
 		for (i = 0; i < NTHREADS; i++) {
 			PTHREAD_REQUIRE(pthread_join(threads[i], NULL));
+		}
+	}
 	SEM_REQUIRE(sem_destroy(&sem_a));
 	printf("Test end\n");
+}
 static void
 sighandler(int signo)
+{
 	/* printf("signal %d\n", signo); */
 	ATF_REQUIRE_EQ_MSG(signo, SIGALRM, "unexpected signal");
 	SEM_REQUIRE(sem_post(&sem));
+}
 static void
 alarm_ms(const int ms)
+{
 	struct itimerval timer;
 	timer.it_interval.tv_sec = 0;
 	timer.it_interval.tv_usec = 0;
 	timer.it_value.tv_sec = 0;
 	timer.it_value.tv_usec = ms * 1000;
 	ATF_REQUIRE(setitimer(ITIMER_REAL, &timer, NULL) == 0);
+}
 static void *
 threadfunc(void *arg)
+{
 	int i;
 	printf("Entering loop\n");
 	for (i = 0; i < 500; ) {
 		if ((i & 1) != 0) {
 			ATF_REQUIRE(sem_wait(&sem) != -1);
 		} else {
 			const int ret = sem_trywait(&sem);
 			if (ret == -1) {
 				ATF_REQUIRE(errno == EAGAIN);
 				continue;
+			}
+		}
 		printf("%s: %d\n", __func__, i);
 		alarm_ms(5);
 		i++;
+	}
 	return NULL;
+}
 static void
 before_start_test(const bool use_pthread)
+{
 	pthread_t t;
 	SEM_REQUIRE(sem_init(&sem, 0, 0));
 	ATF_REQUIRE(SIG_ERR != signal(SIGALRM, sighandler));
 	alarm_ms(5);
 	if (use_pthread) {
 		PTHREAD_REQUIRE(pthread_create(&t, NULL, threadfunc, NULL));
 		PTHREAD_REQUIRE(pthread_join(t, NULL));
 	} else {
 		threadfunc(NULL);
+	}
+}
 ATF_TC(before_start_no_threads);
 ATF_TC_HEAD(before_start_no_threads, tc)
+{
 	atf_tc_set_md_var(tc, "descr", "Checks using semaphores without any "
 	    "thread running");
 	atf_tc_set_md_var(tc, "timeout", "40");
+}
 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();
+}