MFC r305358:

Update contrib/netbsd-tests with new content from NetBSD

This updates the snapshot from 09/30/2014 to 08/11/2016

This brings in a number of new testcases from upstream, most
notably:

- bin/cat
- lib/libc
- lib/msun
- lib/libthr
- usr.bin/sort

lib/libc/tests/stdio/open_memstream_test.c was moved to
lib/libc/tests/stdio/open_memstream2_test.c to accomodate
the new open_memstream test from NetBSD.

Tested on:	amd64 (VMware fusion VM; various bare metal platforms); i386 (VMware fusion VM); make tinderbox

3 files changed, 316 insertions, 7 deletions

diff --git a/contrib/netbsd-tests/lib/libpthread/t_cond.c b/contrib/netbsd-tests/lib/libpthread/t_cond.c
index 9f33c9e..83a3833 100644
--- a/contrib/netbsd-tests/lib/libpthread/t_cond.c
+++ b/contrib/netbsd-tests/lib/libpthread/t_cond.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_cond.c,v 1.6 2014/09/03 16:23:24 gson Exp $ */
+/* $NetBSD: t_cond.c,v 1.7 2016/07/03 14:24:59 christos Exp $ */
 
 /*
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
@@ -29,7 +29,7 @@
 #include <sys/cdefs.h>
 __COPYRIGHT("@(#) Copyright (c) 2008\
  The NetBSD Foundation, inc. All rights reserved.");
-__RCSID("$NetBSD: t_cond.c,v 1.6 2014/09/03 16:23:24 gson Exp $");
+__RCSID("$NetBSD: t_cond.c,v 1.7 2016/07/03 14:24:59 christos Exp $");
 
 #include <sys/time.h>
 
@@ -547,6 +547,26 @@ ATF_TC_BODY(destroy_after_cancel, tc)
 	PTHREAD_REQUIRE(pthread_mutex_destroy(&mutex));
 }
 
+ATF_TC(condattr);
+ATF_TC_HEAD(condattr, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Checks Condattr");
+}
+ATF_TC_BODY(condattr, tc)
+{
+	pthread_condattr_t condattr;
+	clockid_t clockid;
+
+	PTHREAD_REQUIRE(pthread_condattr_init(&condattr));
+	PTHREAD_REQUIRE(pthread_condattr_setclock(&condattr, CLOCK_REALTIME));
+	PTHREAD_REQUIRE(pthread_condattr_getclock(&condattr, &clockid));
+	ATF_REQUIRE_EQ(clockid, CLOCK_REALTIME);
+	
+	PTHREAD_REQUIRE(pthread_condattr_setclock(&condattr, CLOCK_MONOTONIC));
+	PTHREAD_REQUIRE(pthread_condattr_getclock(&condattr, &clockid));	
+ 	ATF_REQUIRE_EQ(clockid, CLOCK_MONOTONIC);
+}
+
 ATF_TP_ADD_TCS(tp)
 {
 
@@ -558,6 +578,7 @@ ATF_TP_ADD_TCS(tp)
 	ATF_TP_ADD_TC(tp, broadcast);
 	ATF_TP_ADD_TC(tp, bogus_timedwaits);
 	ATF_TP_ADD_TC(tp, destroy_after_cancel);
+	ATF_TP_ADD_TC(tp, condattr);
 
 	return atf_no_error();
 }
diff --git a/contrib/netbsd-tests/lib/libpthread/t_mutex.c b/contrib/netbsd-tests/lib/libpthread/t_mutex.c
index eb371fa..1fcd69e 100644
--- a/contrib/netbsd-tests/lib/libpthread/t_mutex.c
+++ b/contrib/netbsd-tests/lib/libpthread/t_mutex.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_mutex.c,v 1.7 2014/11/04 00:20:19 justin Exp $ */
+/* $NetBSD: t_mutex.c,v 1.10 2016/07/31 13:01:29 christos Exp $ */
 
 /*
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
@@ -29,12 +29,15 @@
 #include <sys/cdefs.h>
 __COPYRIGHT("@(#) Copyright (c) 2008\
  The NetBSD Foundation, inc. All rights reserved.");
-__RCSID("$NetBSD: t_mutex.c,v 1.7 2014/11/04 00:20:19 justin Exp $");
+__RCSID("$NetBSD: t_mutex.c,v 1.10 2016/07/31 13:01:29 christos Exp $");
 
 #include <pthread.h>
 #include <stdio.h>
 #include <string.h>
+#include <errno.h>
 #include <unistd.h>
+#include <sys/sched.h>
+#include <sys/param.h>
 
 #include <atf-c.h>
 
@@ -316,12 +319,281 @@ ATF_TC_BODY(mutex4, tc)
 	PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex));
 }
 
+#ifdef __NetBSD__
+static pthread_mutexattr_t attr5;
+static pthread_mutex_t mutex5;
+static int min_fifo_prio, max_fifo_prio;
+
+static void *
+child_func(void* arg)
+{
+	int res;
+
+	printf("child is waiting\n");
+	res = _sched_protect(-2);
+	ATF_REQUIRE_EQ_MSG(res, -1, "sched_protect returned %d", res);
+	ATF_REQUIRE_EQ(errno, ENOENT);
+	PTHREAD_REQUIRE(pthread_mutex_lock(&mutex5));
+	printf("child is owning resource\n");
+	res = _sched_protect(-2);
+	ATF_REQUIRE_EQ(res,  max_fifo_prio);
+	PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex5));
+	printf("child is done\n");
+	
+	return 0;
+}
+
+ATF_TC(mutex5);
+ATF_TC_HEAD(mutex5, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Checks mutexes for priority setting");
+	atf_tc_set_md_var(tc, "require.user", "root");
+}
+
+ATF_TC_BODY(mutex5, tc)
+{
+	int res;
+	struct sched_param param;
+	pthread_t child;
+
+	min_fifo_prio = sched_get_priority_min(SCHED_FIFO);
+	max_fifo_prio = sched_get_priority_max(SCHED_FIFO);
+	printf("min prio for FIFO = %d\n", min_fifo_prio);
+	param.sched_priority = min_fifo_prio;
+
+	/* = 0 OTHER, 1 FIFO, 2 RR, -1 NONE */
+	res = sched_setscheduler(getpid(), SCHED_FIFO, &param);
+	printf("previous policy used = %d\n", res);
+
+	res = sched_getscheduler(getpid());
+	ATF_REQUIRE_EQ_MSG(res, SCHED_FIFO, "sched %d != FIFO %d", res, 
+	    SCHED_FIFO);
+
+	PTHREAD_REQUIRE(pthread_mutexattr_init(&attr5));
+	PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&attr5,
+	    PTHREAD_PRIO_PROTECT));
+	PTHREAD_REQUIRE(pthread_mutexattr_setprioceiling(&attr5,
+	    max_fifo_prio));
+	
+	PTHREAD_REQUIRE(pthread_mutex_init(&mutex5, &attr5));
+	PTHREAD_REQUIRE(pthread_mutex_lock(&mutex5));
+	printf("enter critical section for main\n");
+	PTHREAD_REQUIRE(pthread_create(&child, NULL, child_func, NULL));
+	printf("main starts to sleep\n");
+	sleep(10);
+	printf("main completes\n");
+	PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex5));
+	PTHREAD_REQUIRE(pthread_join(child, NULL));
+}
+
+static pthread_mutex_t mutex6;
+static int start = 0;
+static uintmax_t high_cnt = 0, low_cnt = 0, MAX_LOOP = 100000000;
+
+static void *
+high_prio(void* arg)
+{
+	struct sched_param param;
+	int policy;
+	param.sched_priority = min_fifo_prio + 10;
+	pthread_t childid = pthread_self();
+
+	PTHREAD_REQUIRE(pthread_setschedparam(childid, 1, &param));
+	PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, &param));
+	printf("high protect = %d, prio = %d\n",
+	    _sched_protect(-2), param.sched_priority);
+	ATF_REQUIRE_EQ(policy, 1);
+	printf("high prio = %d\n", param.sched_priority);
+	sleep(1);
+	long tmp = 0;
+	for (int i = 0; i < 20; i++) {
+		while (high_cnt < MAX_LOOP) {
+			tmp += (123456789 % 1234) * (987654321 % 54321);
+			high_cnt += 1;
+		}
+		high_cnt = 0;
+		sleep(1);
+	}
+	PTHREAD_REQUIRE(pthread_mutex_lock(&mutex6));
+	if (start == 0) start = 2;
+	PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex6));
+
+	return 0;
+}
+
+static void *
+low_prio(void* arg)
+{
+	struct sched_param param;
+	int policy;
+	param.sched_priority = min_fifo_prio;
+	pthread_t childid = pthread_self();
+	int res = _sched_protect(max_fifo_prio);
+	ATF_REQUIRE_EQ(res, 0);
+	PTHREAD_REQUIRE(pthread_setschedparam(childid, 1, &param));
+	PTHREAD_REQUIRE(pthread_getschedparam(childid, &policy, &param));
+	printf("low protect = %d, prio = %d\n", _sched_protect(-2),
+	    param.sched_priority);
+	ATF_REQUIRE_EQ(policy, 1);
+	printf("low prio = %d\n", param.sched_priority);
+	sleep(1);
+	long tmp = 0;
+	for (int i = 0; i < 20; i++) {
+		while (low_cnt < MAX_LOOP) {
+			tmp += (123456789 % 1234) * (987654321 % 54321);
+			low_cnt += 1;
+		}
+		low_cnt = 0;
+		sleep(1);
+	}
+	PTHREAD_REQUIRE(pthread_mutex_lock(&mutex6));
+	if (start == 0)
+		start = 1;
+	PTHREAD_REQUIRE(pthread_mutex_unlock(&mutex6));
+
+	return 0;
+}
+
+ATF_TC(mutex6);
+ATF_TC_HEAD(mutex6, tc)
+{
+	atf_tc_set_md_var(tc, "descr",
+	    "Checks scheduling for priority ceiling");
+	atf_tc_set_md_var(tc, "require.user", "root");
+}
+
+/*
+ * 1. main thread sets itself to be a realtime task and launched two tasks,
+ *    one has higher priority and the other has lower priority.
+ * 2. each child thread(low and high priority thread) sets its scheduler and
+ *    priority.
+ * 3. each child thread did several rounds of computation, after each round it
+ *    sleep 1 second.
+ * 4. the child thread with low priority will call _sched_protect to increase
+ *    its protect priority.
+ * 5. We verify the thread with low priority runs first.
+ *
+ * Why does it work? From the main thread, we launched the high
+ * priority thread first. This gives this thread the benefit of
+ * starting first. The low priority thread did not call _sched_protect(2).
+ * The high priority thread should finish the task first. After each
+ * round of computation, we call sleep, to put the task into the
+ * sleep queue, and wake up again after the timer expires. This
+ * gives the scheduler the chance to decide which task to run. So,
+ * the thread with real high priority will always block the thread
+ * with real low priority.
+ * 
+ */
+ATF_TC_BODY(mutex6, tc)
+{
+	struct sched_param param;
+	int res;
+	pthread_t high, low;
+
+	min_fifo_prio = sched_get_priority_min(SCHED_FIFO);
+	max_fifo_prio = sched_get_priority_max(SCHED_FIFO);
+	PTHREAD_REQUIRE(pthread_mutex_init(&mutex, NULL));
+	printf("min_fifo_prio = %d, max_fifo_info = %d\n", min_fifo_prio,
+	    max_fifo_prio);
+
+	param.sched_priority = min_fifo_prio;
+	res = sched_setscheduler(getpid(), SCHED_FIFO, &param);
+	printf("previous policy used = %d\n", res);
+
+	res = sched_getscheduler(getpid());
+	ATF_REQUIRE_EQ(res, 1);
+	PTHREAD_REQUIRE(pthread_create(&high, NULL, high_prio, NULL));
+	PTHREAD_REQUIRE(pthread_create(&low, NULL, low_prio, NULL));
+	sleep(5);
+	PTHREAD_REQUIRE(pthread_join(low, NULL));
+	PTHREAD_REQUIRE(pthread_join(high, NULL));
+	
+	ATF_REQUIRE_EQ(start, 1);
+}
+#endif
+
+ATF_TC(mutexattr1);
+ATF_TC_HEAD(mutexattr1, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Checks mutexattr");
+}
+
+ATF_TC_BODY(mutexattr1, tc)
+{
+	pthread_mutexattr_t mattr;
+	int protocol, target;
+	
+	PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr));
+
+	target = PTHREAD_PRIO_NONE;
+	PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target));
+	PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol));
+	ATF_REQUIRE_EQ(protocol, target);
+
+	/*
+	target = PTHREAD_PRIO_INHERIT;
+	PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target));
+	PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol));
+	ATF_REQUIRE_EQ(protocol, target);
+	*/
+
+	target = PTHREAD_PRIO_PROTECT;
+	PTHREAD_REQUIRE(pthread_mutexattr_setprotocol(&mattr, target));
+	PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr, &protocol));
+	ATF_REQUIRE_EQ(protocol, target);
+}
+
+ATF_TC(mutexattr2);
+ATF_TC_HEAD(mutexattr2, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Checks mutexattr");
+}
+
+ATF_TC_BODY(mutexattr2, tc)
+{
+	pthread_mutexattr_t mattr;
+
+#ifdef __FreeBSD__
+	atf_tc_expect_fail("fails on i == 0 with: "
+	    "pthread_mutexattr_setprioceiling(&mattr, i): Invalid argument "
+	    "-- PR # 211802");
+#endif
+
+	PTHREAD_REQUIRE(pthread_mutexattr_init(&mattr));
+	int max_prio = sched_get_priority_max(SCHED_FIFO);
+	int min_prio = sched_get_priority_min(SCHED_FIFO);
+	for (int i = min_prio; i <= max_prio; i++) {
+		int prioceiling;
+#ifdef __FreeBSD__
+		int protocol;
+
+		PTHREAD_REQUIRE(pthread_mutexattr_getprotocol(&mattr,
+		    &protocol));
+
+		printf("priority: %d\nprotocol: %d\n", i, protocol);
+#endif
+		PTHREAD_REQUIRE(pthread_mutexattr_setprioceiling(&mattr, i));
+		PTHREAD_REQUIRE(pthread_mutexattr_getprioceiling(&mattr,
+		    &prioceiling));
+#ifdef __FreeBSD__
+		printf("prioceiling: %d\n", prioceiling);
+#endif
+		ATF_REQUIRE_EQ(i, prioceiling);
+	}
+}
+
 ATF_TP_ADD_TCS(tp)
 {
 	ATF_TP_ADD_TC(tp, mutex1);
 	ATF_TP_ADD_TC(tp, mutex2);
 	ATF_TP_ADD_TC(tp, mutex3);
 	ATF_TP_ADD_TC(tp, mutex4);
-
+#ifdef __NetBSD__
+	ATF_TP_ADD_TC(tp, mutex5);
+	ATF_TP_ADD_TC(tp, mutex6);
+#endif
+	ATF_TP_ADD_TC(tp, mutexattr1);
+	ATF_TP_ADD_TC(tp, mutexattr2);
+	
 	return atf_no_error();
 }
diff --git a/contrib/netbsd-tests/lib/libpthread/t_rwlock.c b/contrib/netbsd-tests/lib/libpthread/t_rwlock.c
index b2a3d6f..81f8c58 100644
--- a/contrib/netbsd-tests/lib/libpthread/t_rwlock.c
+++ b/contrib/netbsd-tests/lib/libpthread/t_rwlock.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_rwlock.c,v 1.1 2010/07/16 15:42:53 jmmv Exp $ */
+/* $NetBSD: t_rwlock.c,v 1.2 2015/06/26 11:07:20 pooka Exp $ */
 
 /*
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
@@ -55,7 +55,7 @@
 #include <sys/cdefs.h>
 __COPYRIGHT("@(#) Copyright (c) 2008\
  The NetBSD Foundation, inc. All rights reserved.");
-__RCSID("$NetBSD: t_rwlock.c,v 1.1 2010/07/16 15:42:53 jmmv Exp $");
+__RCSID("$NetBSD: t_rwlock.c,v 1.2 2015/06/26 11:07:20 pooka Exp $");
 
 #include <errno.h>
 #include <pthread.h>
@@ -70,6 +70,8 @@ pthread_rwlock_t lk;
 
 struct timespec to;
 
+static pthread_rwlock_t static_rwlock = PTHREAD_RWLOCK_INITIALIZER;
+
 /* ARGSUSED */
 static void *
 do_nothing(void *dummy)
@@ -117,9 +119,23 @@ ATF_TC_BODY(rwlock1, tc)
 		"%s", strerror(error));
 }
 
+ATF_TC(rwlock_static);
+ATF_TC_HEAD(rwlock_static, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "rwlock w/ static initializer");
+}
+ATF_TC_BODY(rwlock_static, tc)
+{
+
+	PTHREAD_REQUIRE(pthread_rwlock_rdlock(&static_rwlock));
+	PTHREAD_REQUIRE(pthread_rwlock_unlock(&static_rwlock));
+	PTHREAD_REQUIRE(pthread_rwlock_destroy(&static_rwlock));
+}
+
 ATF_TP_ADD_TCS(tp)
 {
 	ATF_TP_ADD_TC(tp, rwlock1);
+	ATF_TP_ADD_TC(tp, rwlock_static);
 
 	return atf_no_error();
 }