MFC r305358,r305449,r305451,r306367,r306397,r309474:

This also contains a merge of ^/projects/netbsd-tests-update-12@r304035 .
This change never hit ^/head because bin/cat's behavior was changed (on ^/head)
to match NetBSD.

PR:	210607

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

r305449:

Install h_db to unbreak some of the lib/libc/db testcases after
r305358

r305451:

Fix lib/libc/rpc test assumptions added in r305358

- Require root in the tcp/udp subtests (it's needed on FreeBSD when
  registering services).
- Skip the tests if service registration fails.

r306367 (by br):

Allow up to 6 arguments only on MIPS.

r306397 (by br):

Use right piece of code for FreeBSD.

r309474:

Don't build :strvis_locale if VIS_NOLOCALE is undefined

The copy of contrib/libc-vis on ^/stable/10 doesn't contain all of the features
in the ^/stable/11 // ^/head version, including VIS_NOLOCALE. The risk is lower
in conditionally running the test instead of backporting the newer version of
libc-vis

1 files changed, 150 insertions, 5 deletions

diff --git a/contrib/netbsd-tests/lib/libc/sys/t_sigqueue.c b/contrib/netbsd-tests/lib/libc/sys/t_sigqueue.c
index 6686f02..e911d42 100644
--- a/contrib/netbsd-tests/lib/libc/sys/t_sigqueue.c
+++ b/contrib/netbsd-tests/lib/libc/sys/t_sigqueue.c
@@ -1,4 +1,4 @@
-/* $NetBSD: t_sigqueue.c,v 1.4 2011/07/07 16:31:11 jruoho Exp $ */
+/* $NetBSD: t_sigqueue.c,v 1.6 2016/08/04 06:43:43 christos Exp $ */
 
 /*-
  * Copyright (c) 2011 The NetBSD Foundation, Inc.
@@ -30,8 +30,7 @@
  */
 
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_sigqueue.c,v 1.4 2011/07/07 16:31:11 jruoho Exp $");
-
+__RCSID("$NetBSD: t_sigqueue.c,v 1.6 2016/08/04 06:43:43 christos Exp $");
 
 #include <atf-c.h>
 #include <errno.h>
@@ -40,6 +39,11 @@ __RCSID("$NetBSD: t_sigqueue.c,v 1.4 2011/07/07 16:31:11 jruoho Exp $");
 #include <sched.h>
 #include <unistd.h>
 
+#ifdef __FreeBSD__
+#include <err.h>
+#include <stdio.h>
+#endif
+
 static void	handler(int, siginfo_t *, void *);
 
 #define VALUE (int)0xc001dad1
@@ -77,7 +81,7 @@ ATF_TC_BODY(sigqueue_basic, tc)
 	sv.sival_int = VALUE;
 
 #ifdef __FreeBSD__
-	/* 
+	/*
 	 * From kern_sig.c:
 	 * Specification says sigqueue can only send signal to single process.
 	 */
@@ -99,17 +103,158 @@ ATF_TC_HEAD(sigqueue_err, tc)
 
 ATF_TC_BODY(sigqueue_err, tc)
 {
-	union sigval sv;
+	static union sigval sv;
 
 	errno = 0;
 	ATF_REQUIRE_ERRNO(EINVAL, sigqueue(getpid(), -1, sv) == -1);
 }
 
+static int signals[] = {
+	SIGINT, SIGRTMIN + 1, SIGINT, SIGRTMIN + 0, SIGRTMIN + 2,
+	SIGQUIT, SIGRTMIN + 1
+};
+#ifdef __arraycount
+#define CNT	__arraycount(signals)
+#else
+#define CNT	(sizeof(signals) / sizeof(signals[0]))
+#endif
+
+static sig_atomic_t count = 0;
+static int delivered[CNT];
+
+static void
+myhandler(int signo, siginfo_t *info, void *context)
+{
+	delivered[count++] = signo;
+#ifdef __FreeBSD__
+	printf("Signal #%zu: signo: %d\n", (size_t)count, signo);
+#endif
+}
+
+static int
+asc(const void *a, const void *b)
+{
+	const int *ia = a, *ib = b;
+	return *ib - *ia;
+}
+
+/*
+ * given a array of signals to be delivered in tosend of size len
+ * place in ordered the signals to be delivered in delivery order
+ * and return the number of signals that should be delivered
+ */
+static size_t
+sigorder(int *ordered, const int *tosend, size_t len)
+{
+	memcpy(ordered, tosend, len * sizeof(*tosend));
+	qsort(ordered, len, sizeof(*ordered), asc);
+	if (len == 1)
+		return len;
+
+#ifdef __FreeBSD__
+	/*
+	 * Don't dedupe signal numbers (bug 212173)
+	 *
+	 * Per kib's comment..
+	 *
+	 * "
+	 * OTOH, FreeBSD behaviour is to treat all signals as realtime while
+	 * there is no mem shortage and siginfo can be allocated.  In
+	 * particular, signals < SIGRTMIN are not collapsed when queued more
+	 * than once.
+	 * "
+	 */
+
+	return len;
+#else
+
+	size_t i, j;
+	for (i = 0, j = 0; i < len - 1; i++) {
+		if (ordered[i] >= SIGRTMIN)
+			continue;
+		if (j == 0)
+			j = i + 1;
+		while (ordered[i] == ordered[j] && j < len)
+			j++;
+		if (j == len)
+			break;
+		ordered[i + 1] = ordered[j];
+	}
+	return i + 1;
+#endif
+}
+
+ATF_TC(sigqueue_rt);
+ATF_TC_HEAD(sigqueue_rt, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Test queuing of real-time signals");
+}
+
+ATF_TC_BODY(sigqueue_rt, tc)
+{
+	pid_t pid;
+	union sigval val;
+	struct sigaction act;
+	int ordered[CNT];
+	struct sigaction oact[CNT];
+	size_t ndelivered;
+
+	ndelivered = sigorder(ordered, signals, CNT);
+
+	act.sa_flags = SA_SIGINFO;
+	act.sa_sigaction = myhandler;
+	sigemptyset(&act.sa_mask);
+	for (size_t i = 0; i < ndelivered; i++)
+		ATF_REQUIRE(sigaction(ordered[i], &act, &oact[i]) != -1);
+
+	val.sival_int = 0;
+	pid = getpid();
+
+	sigset_t mask, orig;
+	sigemptyset(&mask);
+	for (size_t i = 0; i < CNT; i++)
+#ifdef __FreeBSD__
+		if (sigaddset(&mask, signals[i]) == -1)
+			warn("sigaddset");
+#else
+		sigaddset(&mask, signals[i]);
+#endif
+
+	ATF_REQUIRE(sigprocmask(SIG_BLOCK, &mask, &orig) != -1);
+	
+	for (size_t i = 0; i < CNT; i++)
+		ATF_REQUIRE(sigqueue(pid, signals[i], val) != -1);
+	
+	ATF_REQUIRE(sigprocmask(SIG_UNBLOCK, &mask, &orig) != -1);
+	sleep(1);
+#ifdef __FreeBSD__
+	ATF_CHECK_MSG((size_t)count == ndelivered,
+	    "count %zu != ndelivered %zu", (size_t)count, ndelivered);
+#else
+	ATF_REQUIRE_MSG((size_t)count == ndelivered,
+	    "count %zu != ndelivered %zu", (size_t)count, ndelivered);
+#endif
+	for (size_t i = 0; i < ndelivered; i++)
+		ATF_REQUIRE_MSG(ordered[i] == delivered[i],
+		    "%zu: ordered %d != delivered %d",
+		    i, ordered[i], delivered[i]);
+
+#ifdef __FreeBSD__
+	if (count > ndelivered)
+		for (size_t i = ndelivered; i < count; i++)
+			printf("Undelivered signal #%zu: %d\n", i, ordered[i]);
+#endif
+
+	for (size_t i = 0; i < ndelivered; i++)
+		ATF_REQUIRE(sigaction(signals[i], &oact[i], NULL) != -1);
+}
+
 ATF_TP_ADD_TCS(tp)
 {
 
 	ATF_TP_ADD_TC(tp, sigqueue_basic);
 	ATF_TP_ADD_TC(tp, sigqueue_err);
+	ATF_TP_ADD_TC(tp, sigqueue_rt);
 
 	return atf_no_error();
 }