 @@ -1,14 +1,14 @@
-/*	$NetBSD: t_ptrace_wait.c,v 1.84 2019/02/12 21:35:35 kamil Exp $	*/
+/*	$NetBSD: t_ptrace_wait.c,v 1.85 2019/02/14 05:38:45 kamil Exp $	*/
 /*-
  * Copyright (c) 2016, 2017, 2018, 2019 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.
 @@ -17,27 +17,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: t_ptrace_wait.c,v 1.84 2019/02/12 21:35:35 kamil Exp $");
+__RCSID("$NetBSD: t_ptrace_wait.c,v 1.85 2019/02/14 05:38:45 kamil Exp $");
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/ptrace.h>
 #include <sys/resource.h>
 #include <sys/stat.h>
 #include <sys/syscall.h>
 #include <sys/sysctl.h>
 #include <sys/wait.h>
 #include <machine/reg.h>
 #include <elf.h>
 #include <err.h>
 @@ -169,26 +169,31 @@ ATF_TC_HEAD(test, tc)							\
 }									\
+									\
 ATF_TC_BODY(test, tc)							\
 {									\
+									\
 	traceme_raise(sig);						\
+}
 TRACEME_RAISE(traceme_raise1, SIGKILL) /* non-maskable */
 TRACEME_RAISE(traceme_raise2, SIGSTOP) /* non-maskable */
 TRACEME_RAISE(traceme_raise3, SIGABRT) /* regular abort trap */
 TRACEME_RAISE(traceme_raise4, SIGHUP)  /* hangup */
 TRACEME_RAISE(traceme_raise5, SIGCONT) /* continued? */
 TRACEME_RAISE(traceme_raise6, SIGTRAP) /* crash signal */
 TRACEME_RAISE(traceme_raise7, SIGBUS) /* crash signal */
 TRACEME_RAISE(traceme_raise8, SIGILL) /* crash signal */
 TRACEME_RAISE(traceme_raise9, SIGFPE) /* crash signal */
 TRACEME_RAISE(traceme_raise10, SIGSEGV) /* crash signal */
 /// ----------------------------------------------------------------------------
 static void
 traceme_crash(int sig)
+{
 	pid_t child, wpid;
 #if defined(TWAIT_HAVE_STATUS)
 	int status;
 #endif
 	struct ptrace_siginfo info;
 #ifndef PTRACE_ILLEGAL_ASM
 @@ -382,26 +387,31 @@ test##_sighandler(int arg)						\
 	++ test##_caught;						\
 }									\
+									\
 ATF_TC_BODY(test, tc)							\
 {									\
+									\
 	traceme_sendsignal_handle(sig, test##_sighandler, & test##_caught); \
+}
 // A signal handler for SIGKILL and SIGSTOP cannot be registered.
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle1, SIGABRT) /* abort trap */
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle2, SIGHUP)  /* hangup */
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle3, SIGCONT) /* continued? */
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle4, SIGTRAP) /* crash sig. */
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle5, SIGBUS) /* crash sig. */
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle6, SIGILL) /* crash sig. */
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle7, SIGFPE) /* crash sig. */
 TRACEME_SENDSIGNAL_HANDLE(traceme_sendsignal_handle8, SIGSEGV) /* crash sig. */
 /// ----------------------------------------------------------------------------
 static void
 traceme_sendsignal_masked(int sigsent)
+{
 	const int exitval = 5;
 	const int sigval = SIGSTOP;
 	pid_t child, wpid;
 	sigset_t set;
 #if defined(TWAIT_HAVE_STATUS)
 	int status;
 #endif
 @@ -465,26 +475,31 @@ ATF_TC_HEAD(test, tc)							\
 	    "handled correctly and the signal is masked by SIG_BLOCK");	\
 }									\
+									\
 ATF_TC_BODY(test, tc)							\
 {									\
+									\
 	traceme_sendsignal_masked(sig);					\
+}
 // A signal handler for SIGKILL and SIGSTOP cannot be masked.
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked1, SIGABRT) /* abort trap */
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked2, SIGHUP)  /* hangup */
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked3, SIGCONT) /* continued? */
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked4, SIGTRAP) /* crash sig. */
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked5, SIGBUS) /* crash sig. */
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked6, SIGILL) /* crash sig. */
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked7, SIGFPE) /* crash sig. */
 TRACEME_SENDSIGNAL_MASKED(traceme_sendsignal_masked8, SIGSEGV) /* crash sig. */
 /// ----------------------------------------------------------------------------
 static void
 traceme_sendsignal_ignored(int sigsent)
+{
 	const int exitval = 5;
 	const int sigval = SIGSTOP;
 	pid_t child, wpid;
 	struct sigaction sa;
 #if defined(TWAIT_HAVE_STATUS)
 	int status;
 #endif
 @@ -550,38 +565,57 @@ ATF_TC_HEAD(test, tc)							\
 	    "handled correctly and the signal is masked by SIG_IGN");	\
 }									\
+									\
 ATF_TC_BODY(test, tc)							\
 {									\
+									\
 	traceme_sendsignal_ignored(sig);				\
+}
 // A signal handler for SIGKILL and SIGSTOP cannot be ignored.
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored1, SIGABRT) /* abort */
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored2, SIGHUP)  /* hangup */
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored3, SIGCONT) /* continued */
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored4, SIGTRAP) /* crash s. */
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored5, SIGBUS) /* crash s. */
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored6, SIGILL) /* crash s. */
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored7, SIGFPE) /* crash s. */
 TRACEME_SENDSIGNAL_IGNORED(traceme_sendsignal_ignored8, SIGSEGV) /* crash s. */
 /// ----------------------------------------------------------------------------
 static void
 traceme_sendsignal_simple(int sigsent)
+{
 	const int sigval = SIGSTOP;
 	int exitval = 0;
 	pid_t child, wpid;
 #if defined(TWAIT_HAVE_STATUS)
 	int status;
-	int expect_core = (sigsent == SIGABRT) ? 1 : 0;
+	int expect_core;
 	switch (sigsent) {
 	case SIGABRT:
 	case SIGTRAP:
 	case SIGBUS:
 	case SIGILL:
 	case SIGFPE:
 	case SIGSEGV:
 		expect_core = 1;
 		break;
 	default:
 		expect_core = 0;
 		break;
+	}
 #endif
 	struct ptrace_siginfo info;
 	memset(&info, 0, sizeof(info));
 	DPRINTF("Before forking process PID=%d\n", getpid());
 	SYSCALL_REQUIRE((child = fork()) != -1);
 	if (child == 0) {
 		DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
 		DPRINTF("Before raising %s from child\n", strsignal(sigval));
 		FORKEE_ASSERT(raise(sigval) == 0);
 @@ -668,26 +702,31 @@ ATF_TC_HEAD(test, tc)							\
 }									\
+									\
 ATF_TC_BODY(test, tc)							\
 {									\
+									\
 	traceme_sendsignal_simple(sig);					\
+}
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple1, SIGKILL) /* non-maskable*/
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple2, SIGSTOP) /* non-maskable*/
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple3, SIGABRT) /* abort trap */
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple4, SIGHUP)  /* hangup */
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple5, SIGCONT) /* continued? */
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple6, SIGTRAP) /* crash sig. */
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple7, SIGBUS) /* crash sig. */
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple8, SIGILL) /* crash sig. */
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple9, SIGFPE) /* crash sig. */
 TRACEME_SENDSIGNAL_SIMPLE(traceme_sendsignal_simple10, SIGSEGV) /* crash sig. */
 /// ----------------------------------------------------------------------------
 ATF_TC(traceme_pid1_parent);
 ATF_TC_HEAD(traceme_pid1_parent, tc)
+{
 	atf_tc_set_md_var(tc, "descr",
 	    "Verify that PT_TRACE_ME is not allowed when our parent is PID1");
+}
 ATF_TC_BODY(traceme_pid1_parent, tc)
+{
 	struct msg_fds parent_child;
 @@ -738,27 +777,43 @@ ATF_TC_BODY(traceme_pid1_parent, tc)
 	PARENT_FROM_CHILD("child2 exiting", parent_child, msg);
+}
 /// ----------------------------------------------------------------------------
 static void
 traceme_vfork_raise(int sigval)
+{
 	const int exitval = 5, exitval_watcher = 10;
 	pid_t child, parent, watcher, wpid;
 	int rv;
 #if defined(TWAIT_HAVE_STATUS)
 	int status;
 	int expect_core = (sigval == SIGABRT) ? 1 : 0;
 	/* volatile workarounds GCC -Werror=clobbered */
 	volatile int expect_core;
 	switch (sigval) {
 	case SIGABRT:
 	case SIGTRAP:
 	case SIGBUS:
 	case SIGILL:
 	case SIGFPE:
 	case SIGSEGV:
 		expect_core = 1;
 		break;
 	default:
 		expect_core = 0;
 		break;
+	}
 #endif
 	/*
 	 * Spawn a dedicated thread to watch for a stopped child and emit
 	 * the SIGKILL signal to it.
+	 *
 	 * vfork(2) might clobber watcher, this means that it's safer and
 	 * simpler to reparent this process to initproc and forget about it.
 	 */
 	if (sigval == SIGSTOP) {
 		parent = getpid();
 		watcher = fork();
 @@ -795,43 +850,53 @@ traceme_vfork_raise(int sigval)
 	SYSCALL_REQUIRE((child = vfork()) != -1);
 	if (child == 0) {
 		DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
 		DPRINTF("Before raising %s from child\n", strsignal(sigval));
 		FORKEE_ASSERT(raise(sigval) == 0);
 		switch (sigval) {
 		case SIGSTOP:
 		case SIGKILL:
 		case SIGABRT:
 		case SIGHUP:
 		case SIGTRAP:
 		case SIGBUS:
 		case SIGILL:
 		case SIGFPE:
 		case SIGSEGV:
 			/* NOTREACHED */
 			FORKEE_ASSERTX(0 && "This shall not be reached");
 			__unreachable();
 		default:
 			DPRINTF("Before exiting of the child process\n");
 			_exit(exitval);
+		}
+	}
 	DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
 	DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
 	switch (sigval) {
 	case SIGKILL:
 	case SIGABRT:
 	case SIGHUP:
 	case SIGTRAP:
 	case SIGBUS:
 	case SIGILL:
 	case SIGFPE:
 	case SIGSEGV:
 		validate_status_signaled(status, sigval, expect_core);
 		break;
 	case SIGSTOP:
 		validate_status_signaled(status, SIGKILL, 0);
 		break;
 	case SIGCONT:
 	case SIGTSTP:
 	case SIGTTIN:
 	case SIGTTOU:
 		validate_status_exited(status, exitval);
 		break;
 	default:
 		/* NOTREACHED */
 @@ -856,26 +921,31 @@ ATF_TC_BODY(test, tc)							\
 {									\
+									\
 	traceme_vfork_raise(sig);					\
+}
 TRACEME_VFORK_RAISE(traceme_vfork_raise1, SIGKILL) /* non-maskable */
 TRACEME_VFORK_RAISE(traceme_vfork_raise2, SIGSTOP) /* non-maskable */
 TRACEME_VFORK_RAISE(traceme_vfork_raise3, SIGTSTP) /* ignored in vfork(2) */
 TRACEME_VFORK_RAISE(traceme_vfork_raise4, SIGTTIN) /* ignored in vfork(2) */
 TRACEME_VFORK_RAISE(traceme_vfork_raise5, SIGTTOU) /* ignored in vfork(2) */
 TRACEME_VFORK_RAISE(traceme_vfork_raise6, SIGABRT) /* regular abort trap */
 TRACEME_VFORK_RAISE(traceme_vfork_raise7, SIGHUP)  /* hangup */
 TRACEME_VFORK_RAISE(traceme_vfork_raise8, SIGCONT) /* continued? */
 TRACEME_VFORK_RAISE(traceme_vfork_raise9, SIGTRAP) /* crash signal */
 TRACEME_VFORK_RAISE(traceme_vfork_raise10, SIGBUS) /* crash signal */
 TRACEME_VFORK_RAISE(traceme_vfork_raise11, SIGILL) /* crash signal */
 TRACEME_VFORK_RAISE(traceme_vfork_raise12, SIGFPE) /* crash signal */
 TRACEME_VFORK_RAISE(traceme_vfork_raise13, SIGSEGV) /* crash signal */
 /// ----------------------------------------------------------------------------
 static void
 traceme_vfork_crash(int sig)
+{
 	pid_t child, wpid;
 #if defined(TWAIT_HAVE_STATUS)
 	int status;
 #endif
 #ifndef PTRACE_ILLEGAL_ASM
 	if (sig == SIGILL)
 @@ -5170,61 +5240,91 @@ ATF_TC_BODY(syscallemu1, tc)
 #include "t_ptrace_i386_wait.h"
 #include "t_ptrace_x86_wait.h"
 ATF_TP_ADD_TCS(tp)
+{
 	setvbuf(stdout, NULL, _IONBF, 0);
 	setvbuf(stderr, NULL, _IONBF, 0);
 	ATF_TP_ADD_TC(tp, traceme_raise1);
 	ATF_TP_ADD_TC(tp, traceme_raise2);
 	ATF_TP_ADD_TC(tp, traceme_raise3);
 	ATF_TP_ADD_TC(tp, traceme_raise4);
 	ATF_TP_ADD_TC(tp, traceme_raise5);
 	ATF_TP_ADD_TC(tp, traceme_raise6);
 	ATF_TP_ADD_TC(tp, traceme_raise7);
 	ATF_TP_ADD_TC(tp, traceme_raise8);
 	ATF_TP_ADD_TC(tp, traceme_raise9);
 	ATF_TP_ADD_TC(tp, traceme_raise10);
 	ATF_TP_ADD_TC(tp, traceme_crash_trap);
 	ATF_TP_ADD_TC(tp, traceme_crash_segv);
 	ATF_TP_ADD_TC(tp, traceme_crash_ill);
 	ATF_TP_ADD_TC(tp, traceme_crash_fpe);
 	ATF_TP_ADD_TC(tp, traceme_crash_bus);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle1);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle2);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle3);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle4);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle5);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle6);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle7);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_handle8);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked1);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked2);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked3);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked4);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked5);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked6);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked7);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_masked8);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored1);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored2);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored3);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored4);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored5);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored6);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored7);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_ignored8);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple1);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple2);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple3);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple4);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple5);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple6);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple7);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple8);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple9);
 	ATF_TP_ADD_TC(tp, traceme_sendsignal_simple10);
 	ATF_TP_ADD_TC(tp, traceme_pid1_parent);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise1);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise2);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise3);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise4);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise5);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise6);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise7);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise8);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise9);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise10);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise11);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise12);
 	ATF_TP_ADD_TC(tp, traceme_vfork_raise13);
 	ATF_TP_ADD_TC(tp, traceme_vfork_crash_trap);
 	ATF_TP_ADD_TC(tp, traceme_vfork_crash_segv);
 	ATF_TP_ADD_TC(tp, traceme_vfork_crash_ill);
 	ATF_TP_ADD_TC(tp, traceme_vfork_crash_fpe);
 	ATF_TP_ADD_TC(tp, traceme_vfork_crash_bus);
 	ATF_TP_ADD_TC(tp, traceme_vfork_exec);
 	ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_trap);
 	ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_segv);
 	ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_ill);
 	ATF_TP_ADD_TC_HAVE_PID(tp, unrelated_tracer_sees_crash_fpe);