xref: /freebsd/contrib/netbsd-tests/kernel/t_ptrace_wait.c (revision 1a36faad54665288ed4eb839d2a4699ae2ead45e)
1*dd66b5baSEnji Cooper /*	$NetBSD: t_ptrace_wait.c,v 1.69 2017/01/27 16:43:07 kamil Exp $	*/
2cdebaff8SEnji Cooper 
3cdebaff8SEnji Cooper /*-
4cdebaff8SEnji Cooper  * Copyright (c) 2016 The NetBSD Foundation, Inc.
5cdebaff8SEnji Cooper  * All rights reserved.
6cdebaff8SEnji Cooper  *
7cdebaff8SEnji Cooper  * Redistribution and use in source and binary forms, with or without
8cdebaff8SEnji Cooper  * modification, are permitted provided that the following conditions
9cdebaff8SEnji Cooper  * are met:
10cdebaff8SEnji Cooper  * 1. Redistributions of source code must retain the above copyright
11cdebaff8SEnji Cooper  *    notice, this list of conditions and the following disclaimer.
12cdebaff8SEnji Cooper  * 2. Redistributions in binary form must reproduce the above copyright
13cdebaff8SEnji Cooper  *    notice, this list of conditions and the following disclaimer in the
14cdebaff8SEnji Cooper  *    documentation and/or other materials provided with the distribution.
15cdebaff8SEnji Cooper  *
16cdebaff8SEnji Cooper  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17cdebaff8SEnji Cooper  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18cdebaff8SEnji Cooper  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19cdebaff8SEnji Cooper  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20cdebaff8SEnji Cooper  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21cdebaff8SEnji Cooper  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22cdebaff8SEnji Cooper  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23cdebaff8SEnji Cooper  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24cdebaff8SEnji Cooper  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25cdebaff8SEnji Cooper  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26cdebaff8SEnji Cooper  * POSSIBILITY OF SUCH DAMAGE.
27cdebaff8SEnji Cooper  */
28cdebaff8SEnji Cooper 
29cdebaff8SEnji Cooper #include <sys/cdefs.h>
30*dd66b5baSEnji Cooper __RCSID("$NetBSD: t_ptrace_wait.c,v 1.69 2017/01/27 16:43:07 kamil Exp $");
31cdebaff8SEnji Cooper 
32cdebaff8SEnji Cooper #include <sys/param.h>
33cdebaff8SEnji Cooper #include <sys/types.h>
34cdebaff8SEnji Cooper #include <sys/ptrace.h>
35cdebaff8SEnji Cooper #include <sys/resource.h>
36cdebaff8SEnji Cooper #include <sys/stat.h>
37cdebaff8SEnji Cooper #include <sys/sysctl.h>
38cdebaff8SEnji Cooper #include <sys/wait.h>
39cdebaff8SEnji Cooper #include <machine/reg.h>
40*dd66b5baSEnji Cooper #include <elf.h>
41cdebaff8SEnji Cooper #include <err.h>
42cdebaff8SEnji Cooper #include <errno.h>
43f40f3adcSEnji Cooper #include <lwp.h>
44cdebaff8SEnji Cooper #include <signal.h>
45cdebaff8SEnji Cooper #include <stdint.h>
46cdebaff8SEnji Cooper #include <stdio.h>
47cdebaff8SEnji Cooper #include <stdlib.h>
48cdebaff8SEnji Cooper #include <strings.h>
49cdebaff8SEnji Cooper #include <unistd.h>
50cdebaff8SEnji Cooper 
51cdebaff8SEnji Cooper #include <atf-c.h>
52cdebaff8SEnji Cooper 
5363d1fd59SEnji Cooper #include "h_macros.h"
54cdebaff8SEnji Cooper 
55cdebaff8SEnji Cooper #include "t_ptrace_wait.h"
56cdebaff8SEnji Cooper #include "msg.h"
57cdebaff8SEnji Cooper 
58cdebaff8SEnji Cooper #define PARENT_TO_CHILD(info, fds, msg) \
59cdebaff8SEnji Cooper     ATF_REQUIRE(msg_write_child(info " to child " # fds, &fds, &msg, sizeof(msg)) == 0)
60cdebaff8SEnji Cooper 
61cdebaff8SEnji Cooper #define CHILD_FROM_PARENT(info, fds, msg) \
62cdebaff8SEnji Cooper     FORKEE_ASSERT(msg_read_parent(info " from parent " # fds, &fds, &msg, sizeof(msg)) == 0)
63cdebaff8SEnji Cooper 
64cdebaff8SEnji Cooper #define CHILD_TO_PARENT(info, fds, msg) \
65cdebaff8SEnji Cooper     FORKEE_ASSERT(msg_write_parent(info " to parent " # fds, &fds, &msg, sizeof(msg)) == 0)
66cdebaff8SEnji Cooper 
67cdebaff8SEnji Cooper #define PARENT_FROM_CHILD(info, fds, msg) \
68cdebaff8SEnji Cooper     ATF_REQUIRE(msg_read_child(info " from parent " # fds, &fds, &msg, sizeof(msg)) == 0)
69cdebaff8SEnji Cooper 
7063d1fd59SEnji Cooper 
71cdebaff8SEnji Cooper ATF_TC(traceme1);
ATF_TC_HEAD(traceme1,tc)72cdebaff8SEnji Cooper ATF_TC_HEAD(traceme1, tc)
73cdebaff8SEnji Cooper {
74cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
75cdebaff8SEnji Cooper 	    "Verify SIGSTOP followed by _exit(2) in a child");
76cdebaff8SEnji Cooper }
77cdebaff8SEnji Cooper 
ATF_TC_BODY(traceme1,tc)78cdebaff8SEnji Cooper ATF_TC_BODY(traceme1, tc)
79cdebaff8SEnji Cooper {
80cdebaff8SEnji Cooper 	const int exitval = 5;
81cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
82cdebaff8SEnji Cooper 	pid_t child, wpid;
83cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
84cdebaff8SEnji Cooper 	int status;
85cdebaff8SEnji Cooper #endif
86cdebaff8SEnji Cooper 
87cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
88cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
89cdebaff8SEnji Cooper 	if (child == 0) {
90cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
91cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
92cdebaff8SEnji Cooper 
93cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
94cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
95cdebaff8SEnji Cooper 
96cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
97cdebaff8SEnji Cooper 		_exit(exitval);
98cdebaff8SEnji Cooper 	}
99cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
100cdebaff8SEnji Cooper 
101cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
102cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
103cdebaff8SEnji Cooper 
104cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
105cdebaff8SEnji Cooper 
106cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
107cdebaff8SEnji Cooper 	    "without signal to be sent\n");
108cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
109cdebaff8SEnji Cooper 
110cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
111cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
112cdebaff8SEnji Cooper 
113cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
114cdebaff8SEnji Cooper 
115cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
116cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
117cdebaff8SEnji Cooper }
118cdebaff8SEnji Cooper 
119cdebaff8SEnji Cooper ATF_TC(traceme2);
ATF_TC_HEAD(traceme2,tc)120cdebaff8SEnji Cooper ATF_TC_HEAD(traceme2, tc)
121cdebaff8SEnji Cooper {
122cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
123cdebaff8SEnji Cooper 	    "Verify SIGSTOP followed by _exit(2) in a child");
124cdebaff8SEnji Cooper }
125cdebaff8SEnji Cooper 
126cdebaff8SEnji Cooper static int traceme2_caught = 0;
127cdebaff8SEnji Cooper 
128cdebaff8SEnji Cooper static void
traceme2_sighandler(int sig)129cdebaff8SEnji Cooper traceme2_sighandler(int sig)
130cdebaff8SEnji Cooper {
131cdebaff8SEnji Cooper 	FORKEE_ASSERT_EQ(sig, SIGINT);
132cdebaff8SEnji Cooper 
133cdebaff8SEnji Cooper 	++traceme2_caught;
134cdebaff8SEnji Cooper }
135cdebaff8SEnji Cooper 
ATF_TC_BODY(traceme2,tc)136cdebaff8SEnji Cooper ATF_TC_BODY(traceme2, tc)
137cdebaff8SEnji Cooper {
138cdebaff8SEnji Cooper 	const int exitval = 5;
139cdebaff8SEnji Cooper 	const int sigval = SIGSTOP, sigsent = SIGINT;
140cdebaff8SEnji Cooper 	pid_t child, wpid;
141cdebaff8SEnji Cooper 	struct sigaction sa;
142cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
143cdebaff8SEnji Cooper 	int status;
144cdebaff8SEnji Cooper #endif
145cdebaff8SEnji Cooper 
146cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
147cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
148cdebaff8SEnji Cooper 	if (child == 0) {
149cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
150cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
151cdebaff8SEnji Cooper 
152cdebaff8SEnji Cooper 		sa.sa_handler = traceme2_sighandler;
153cdebaff8SEnji Cooper 		sa.sa_flags = SA_SIGINFO;
154cdebaff8SEnji Cooper 		sigemptyset(&sa.sa_mask);
155cdebaff8SEnji Cooper 
156cdebaff8SEnji Cooper 		FORKEE_ASSERT(sigaction(sigsent, &sa, NULL) != -1);
157cdebaff8SEnji Cooper 
158cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
159cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
160cdebaff8SEnji Cooper 
161cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(traceme2_caught, 1);
162cdebaff8SEnji Cooper 
163cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
164cdebaff8SEnji Cooper 		_exit(exitval);
165cdebaff8SEnji Cooper 	}
166cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
167cdebaff8SEnji Cooper 
168cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
169cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
170cdebaff8SEnji Cooper 
171cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
172cdebaff8SEnji Cooper 
173cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and with "
174cdebaff8SEnji Cooper 	    "signal %s to be sent\n", strsignal(sigsent));
175cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1);
176cdebaff8SEnji Cooper 
177cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
178cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
179cdebaff8SEnji Cooper 
180cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
181cdebaff8SEnji Cooper 
182cdebaff8SEnji Cooper 	printf("Before calling %s() for the exited child\n", TWAIT_FNAME);
183cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
184cdebaff8SEnji Cooper }
185cdebaff8SEnji Cooper 
186cdebaff8SEnji Cooper ATF_TC(traceme3);
ATF_TC_HEAD(traceme3,tc)187cdebaff8SEnji Cooper ATF_TC_HEAD(traceme3, tc)
188cdebaff8SEnji Cooper {
189cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
190cdebaff8SEnji Cooper 	    "Verify SIGSTOP followed by termination by a signal in a child");
191cdebaff8SEnji Cooper }
192cdebaff8SEnji Cooper 
ATF_TC_BODY(traceme3,tc)193cdebaff8SEnji Cooper ATF_TC_BODY(traceme3, tc)
194cdebaff8SEnji Cooper {
195cdebaff8SEnji Cooper 	const int sigval = SIGSTOP, sigsent = SIGINT /* Without core-dump */;
196cdebaff8SEnji Cooper 	pid_t child, wpid;
197cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
198cdebaff8SEnji Cooper 	int status;
199cdebaff8SEnji Cooper #endif
200cdebaff8SEnji Cooper 
201cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
202cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
203cdebaff8SEnji Cooper 	if (child == 0) {
204cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
205cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
206cdebaff8SEnji Cooper 
207cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
208cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
209cdebaff8SEnji Cooper 
210cdebaff8SEnji Cooper 		/* NOTREACHED */
211cdebaff8SEnji Cooper 		FORKEE_ASSERTX(0 &&
212cdebaff8SEnji Cooper 		    "Child should be terminated by a signal from its parent");
213cdebaff8SEnji Cooper 	}
214cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
215cdebaff8SEnji Cooper 
216cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
217cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
218cdebaff8SEnji Cooper 
219cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
220cdebaff8SEnji Cooper 
221cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and with "
222cdebaff8SEnji Cooper 	    "signal %s to be sent\n", strsignal(sigsent));
223cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1);
224cdebaff8SEnji Cooper 
225cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
226cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
227cdebaff8SEnji Cooper 
228cdebaff8SEnji Cooper 	validate_status_signaled(status, sigsent, 0);
229cdebaff8SEnji Cooper 
230cdebaff8SEnji Cooper 	printf("Before calling %s() for the exited child\n", TWAIT_FNAME);
231cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
232cdebaff8SEnji Cooper }
233cdebaff8SEnji Cooper 
234cdebaff8SEnji Cooper ATF_TC(traceme4);
ATF_TC_HEAD(traceme4,tc)235cdebaff8SEnji Cooper ATF_TC_HEAD(traceme4, tc)
236cdebaff8SEnji Cooper {
237cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
238cdebaff8SEnji Cooper 	    "Verify SIGSTOP followed by SIGCONT and _exit(2) in a child");
239cdebaff8SEnji Cooper }
240cdebaff8SEnji Cooper 
ATF_TC_BODY(traceme4,tc)241cdebaff8SEnji Cooper ATF_TC_BODY(traceme4, tc)
242cdebaff8SEnji Cooper {
243cdebaff8SEnji Cooper 	const int exitval = 5;
244cdebaff8SEnji Cooper 	const int sigval = SIGSTOP, sigsent = SIGCONT;
245cdebaff8SEnji Cooper 	pid_t child, wpid;
246cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
247cdebaff8SEnji Cooper 	int status;
248cdebaff8SEnji Cooper #endif
249cdebaff8SEnji Cooper 
250cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
251cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
252cdebaff8SEnji Cooper 	if (child == 0) {
253cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
254cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
255cdebaff8SEnji Cooper 
256cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
257cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
258cdebaff8SEnji Cooper 
259cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigsent));
260cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigsent) == 0);
261cdebaff8SEnji Cooper 
262cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
263cdebaff8SEnji Cooper 		_exit(exitval);
264cdebaff8SEnji Cooper 	}
265cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(),child);
266cdebaff8SEnji Cooper 
267cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
268cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
269cdebaff8SEnji Cooper 
270cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
271cdebaff8SEnji Cooper 
272cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
273cdebaff8SEnji Cooper 	    "without signal to be sent\n");
274cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
275cdebaff8SEnji Cooper 
276cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
277cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
278cdebaff8SEnji Cooper 
279cdebaff8SEnji Cooper 	validate_status_stopped(status, sigsent);
280cdebaff8SEnji Cooper 
281cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
282cdebaff8SEnji Cooper 	    "without signal to be sent\n");
283cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
284cdebaff8SEnji Cooper 
285cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
286cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
287cdebaff8SEnji Cooper 
288cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
289cdebaff8SEnji Cooper 
290cdebaff8SEnji Cooper 	printf("Before calling %s() for the exited child\n", TWAIT_FNAME);
291cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
292cdebaff8SEnji Cooper }
293cdebaff8SEnji Cooper 
294cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
295cdebaff8SEnji Cooper ATF_TC(attach1);
ATF_TC_HEAD(attach1,tc)296cdebaff8SEnji Cooper ATF_TC_HEAD(attach1, tc)
297cdebaff8SEnji Cooper {
298cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
299cdebaff8SEnji Cooper 	    "Assert that tracer sees process termination before the parent");
300cdebaff8SEnji Cooper }
301cdebaff8SEnji Cooper 
ATF_TC_BODY(attach1,tc)302cdebaff8SEnji Cooper ATF_TC_BODY(attach1, tc)
303cdebaff8SEnji Cooper {
304cdebaff8SEnji Cooper 	struct msg_fds parent_tracee, parent_tracer;
305cdebaff8SEnji Cooper 	const int exitval_tracee = 5;
306cdebaff8SEnji Cooper 	const int exitval_tracer = 10;
307cdebaff8SEnji Cooper 	pid_t tracee, tracer, wpid;
308cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
309cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
310cdebaff8SEnji Cooper 	int status;
311cdebaff8SEnji Cooper #endif
312cdebaff8SEnji Cooper 
313cdebaff8SEnji Cooper 	printf("Spawn tracee\n");
314cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
315cdebaff8SEnji Cooper 	tracee = atf_utils_fork();
316cdebaff8SEnji Cooper 	if (tracee == 0) {
317cdebaff8SEnji Cooper 		// Wait for parent to let us exit
318cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("exit tracee", parent_tracee, msg);
319cdebaff8SEnji Cooper 		_exit(exitval_tracee);
320cdebaff8SEnji Cooper 	}
321cdebaff8SEnji Cooper 
322cdebaff8SEnji Cooper 	printf("Spawn debugger\n");
323cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracer) == 0);
324cdebaff8SEnji Cooper 	tracer = atf_utils_fork();
325cdebaff8SEnji Cooper 	if (tracer == 0) {
326cdebaff8SEnji Cooper 		printf("Before calling PT_ATTACH from tracee %d\n", getpid());
327cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
328cdebaff8SEnji Cooper 
329cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it was stopped w/ SIGSTOP */
330cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
331cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
332cdebaff8SEnji Cooper 
333cdebaff8SEnji Cooper 		forkee_status_stopped(status, SIGSTOP);
334cdebaff8SEnji Cooper 
335cdebaff8SEnji Cooper 		/* Resume tracee with PT_CONTINUE */
336cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
337cdebaff8SEnji Cooper 
338cdebaff8SEnji Cooper 		/* Inform parent that tracer has attached to tracee */
339cdebaff8SEnji Cooper 		CHILD_TO_PARENT("tracer ready", parent_tracer, msg);
340cdebaff8SEnji Cooper 
341cdebaff8SEnji Cooper 		/* Wait for parent to tell use that tracee should have exited */
342cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg);
343cdebaff8SEnji Cooper 
344cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it exited */
345cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
346cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
347cdebaff8SEnji Cooper 
348cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval_tracee);
349cdebaff8SEnji Cooper 		printf("Tracee %d exited with %d\n", tracee, exitval_tracee);
350cdebaff8SEnji Cooper 
351cdebaff8SEnji Cooper 		printf("Before exiting of the tracer process\n");
352cdebaff8SEnji Cooper 		_exit(exitval_tracer);
353cdebaff8SEnji Cooper 	}
354cdebaff8SEnji Cooper 
355cdebaff8SEnji Cooper 	printf("Wait for the tracer to attach to the tracee\n");
356cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("tracer ready", parent_tracer, msg);
357cdebaff8SEnji Cooper 
358cdebaff8SEnji Cooper 	printf("Resume the tracee and let it exit\n");
359cdebaff8SEnji Cooper 	PARENT_TO_CHILD("exit tracee", parent_tracee,  msg);
360cdebaff8SEnji Cooper 
361cdebaff8SEnji Cooper 	printf("Detect that tracee is zombie\n");
362cdebaff8SEnji Cooper 	await_zombie(tracee);
363cdebaff8SEnji Cooper 
364cdebaff8SEnji Cooper 
365cdebaff8SEnji Cooper 	printf("Assert that there is no status about tracee %d - "
366cdebaff8SEnji Cooper 	    "Tracer must detect zombie first - calling %s()\n", tracee,
367cdebaff8SEnji Cooper 	    TWAIT_FNAME);
368cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
369cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0);
370cdebaff8SEnji Cooper 
371cdebaff8SEnji Cooper 	printf("Tell the tracer child should have exited\n");
372cdebaff8SEnji Cooper 	PARENT_TO_CHILD("wait for tracee exit", parent_tracer,  msg);
373cdebaff8SEnji Cooper 	printf("Wait for tracer to finish its job and exit - calling %s()\n",
374cdebaff8SEnji Cooper 	    TWAIT_FNAME);
375cdebaff8SEnji Cooper 
376cdebaff8SEnji Cooper 	printf("Wait from tracer child to complete waiting for tracee\n");
377cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0),
378cdebaff8SEnji Cooper 	    tracer);
379cdebaff8SEnji Cooper 
380cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracer);
381cdebaff8SEnji Cooper 
382cdebaff8SEnji Cooper 	printf("Wait for tracee to finish its job and exit - calling %s()\n",
383cdebaff8SEnji Cooper 	    TWAIT_FNAME);
384cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG),
385cdebaff8SEnji Cooper 	    tracee);
386cdebaff8SEnji Cooper 
387cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracee);
388cdebaff8SEnji Cooper 
389cdebaff8SEnji Cooper 	msg_close(&parent_tracer);
390cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
391cdebaff8SEnji Cooper }
392cdebaff8SEnji Cooper #endif
393cdebaff8SEnji Cooper 
394cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
395cdebaff8SEnji Cooper ATF_TC(attach2);
ATF_TC_HEAD(attach2,tc)396cdebaff8SEnji Cooper ATF_TC_HEAD(attach2, tc)
397cdebaff8SEnji Cooper {
398cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
399cdebaff8SEnji Cooper 	    "Assert that any tracer sees process termination before its "
400cdebaff8SEnji Cooper 	    "parent");
401cdebaff8SEnji Cooper }
402cdebaff8SEnji Cooper 
ATF_TC_BODY(attach2,tc)403cdebaff8SEnji Cooper ATF_TC_BODY(attach2, tc)
404cdebaff8SEnji Cooper {
405cdebaff8SEnji Cooper 	struct msg_fds parent_tracer, parent_tracee;
406cdebaff8SEnji Cooper 	const int exitval_tracee = 5;
407cdebaff8SEnji Cooper 	const int exitval_tracer1 = 10, exitval_tracer2 = 20;
408cdebaff8SEnji Cooper 	pid_t tracee, tracer, wpid;
409cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
410cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
411cdebaff8SEnji Cooper 	int status;
412cdebaff8SEnji Cooper #endif
413cdebaff8SEnji Cooper 
414cdebaff8SEnji Cooper 	printf("Spawn tracee\n");
415cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
416cdebaff8SEnji Cooper 	tracee = atf_utils_fork();
417cdebaff8SEnji Cooper 	if (tracee == 0) {
418cdebaff8SEnji Cooper 		/* Wait for message from the parent */
419cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("Message 1", parent_tracee, msg);
420cdebaff8SEnji Cooper 		_exit(exitval_tracee);
421cdebaff8SEnji Cooper 	}
422cdebaff8SEnji Cooper 
423cdebaff8SEnji Cooper 	printf("Spawn debugger\n");
424cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracer) == 0);
425cdebaff8SEnji Cooper 	tracer = atf_utils_fork();
426cdebaff8SEnji Cooper 	if (tracer == 0) {
427cdebaff8SEnji Cooper 		/* Fork again and drop parent to reattach to PID 1 */
428cdebaff8SEnji Cooper 		tracer = atf_utils_fork();
429cdebaff8SEnji Cooper 		if (tracer != 0)
430cdebaff8SEnji Cooper 			_exit(exitval_tracer1);
431cdebaff8SEnji Cooper 
432cdebaff8SEnji Cooper 		printf("Before calling PT_ATTACH from tracee %d\n", getpid());
433cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
434cdebaff8SEnji Cooper 
435cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it was stopped w/ SIGSTOP */
436cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
437cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
438cdebaff8SEnji Cooper 
439cdebaff8SEnji Cooper 		forkee_status_stopped(status, SIGSTOP);
440cdebaff8SEnji Cooper 
441cdebaff8SEnji Cooper 		/* Resume tracee with PT_CONTINUE */
442cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
443cdebaff8SEnji Cooper 
444cdebaff8SEnji Cooper 		/* Inform parent that tracer has attached to tracee */
445cdebaff8SEnji Cooper 		CHILD_TO_PARENT("Message 1", parent_tracer, msg);
446cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("Message 2", parent_tracer, msg);
447cdebaff8SEnji Cooper 
448cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it exited */
449cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
450cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
451cdebaff8SEnji Cooper 
452cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval_tracee);
453cdebaff8SEnji Cooper 
454cdebaff8SEnji Cooper 		printf("Before exiting of the tracer process\n");
455cdebaff8SEnji Cooper 		_exit(exitval_tracer2);
456cdebaff8SEnji Cooper 	}
457cdebaff8SEnji Cooper 	printf("Wait for the tracer process (direct child) to exit calling "
458cdebaff8SEnji Cooper 	    "%s()\n", TWAIT_FNAME);
459cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
460cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracer, &status, 0), tracer);
461cdebaff8SEnji Cooper 
462cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracer1);
463cdebaff8SEnji Cooper 
464cdebaff8SEnji Cooper 	printf("Wait for the non-exited tracee process with %s()\n",
465cdebaff8SEnji Cooper 	    TWAIT_FNAME);
466cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
467cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, NULL, WNOHANG), 0);
468cdebaff8SEnji Cooper 
469cdebaff8SEnji Cooper 	printf("Wait for the tracer to attach to the tracee\n");
470cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("Message 1", parent_tracer, msg);
471cdebaff8SEnji Cooper 	printf("Resume the tracee and let it exit\n");
472cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 1", parent_tracee, msg);
473cdebaff8SEnji Cooper 
474cdebaff8SEnji Cooper 	printf("Detect that tracee is zombie\n");
475cdebaff8SEnji Cooper 	await_zombie(tracee);
476cdebaff8SEnji Cooper 
477cdebaff8SEnji Cooper 	printf("Assert that there is no status about tracee - "
478cdebaff8SEnji Cooper 	    "Tracer must detect zombie first - calling %s()\n", TWAIT_FNAME);
479cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
480cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0);
481cdebaff8SEnji Cooper 
482cdebaff8SEnji Cooper 	printf("Resume the tracer and let it detect exited tracee\n");
483cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 2", parent_tracer, msg);
484cdebaff8SEnji Cooper 
485cdebaff8SEnji Cooper 	printf("Wait for tracee to finish its job and exit - calling %s()\n",
486cdebaff8SEnji Cooper 	    TWAIT_FNAME);
487cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG),
488cdebaff8SEnji Cooper 	    tracee);
489cdebaff8SEnji Cooper 
490cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracee);
491cdebaff8SEnji Cooper 
492cdebaff8SEnji Cooper 	msg_close(&parent_tracer);
493cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
494cdebaff8SEnji Cooper 
495cdebaff8SEnji Cooper }
496cdebaff8SEnji Cooper #endif
497cdebaff8SEnji Cooper 
498cdebaff8SEnji Cooper ATF_TC(attach3);
ATF_TC_HEAD(attach3,tc)499cdebaff8SEnji Cooper ATF_TC_HEAD(attach3, tc)
500cdebaff8SEnji Cooper {
501cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
502cdebaff8SEnji Cooper 	    "Assert that tracer parent can PT_ATTACH to its child");
503cdebaff8SEnji Cooper }
504cdebaff8SEnji Cooper 
ATF_TC_BODY(attach3,tc)505cdebaff8SEnji Cooper ATF_TC_BODY(attach3, tc)
506cdebaff8SEnji Cooper {
507cdebaff8SEnji Cooper 	struct msg_fds parent_tracee;
508cdebaff8SEnji Cooper 	const int exitval_tracee = 5;
509cdebaff8SEnji Cooper 	pid_t tracee, wpid;
510cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
511cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
512cdebaff8SEnji Cooper 	int status;
513cdebaff8SEnji Cooper #endif
514cdebaff8SEnji Cooper 
515cdebaff8SEnji Cooper 	printf("Spawn tracee\n");
516cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
517cdebaff8SEnji Cooper 	tracee = atf_utils_fork();
518cdebaff8SEnji Cooper 	if (tracee == 0) {
519cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("Message 1", parent_tracee, msg);
520cdebaff8SEnji Cooper 		printf("Parent should now attach to tracee\n");
521cdebaff8SEnji Cooper 
522cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("Message 2", parent_tracee, msg);
523cdebaff8SEnji Cooper 		/* Wait for message from the parent */
524cdebaff8SEnji Cooper 		_exit(exitval_tracee);
525cdebaff8SEnji Cooper 	}
526cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 1", parent_tracee, msg);
527cdebaff8SEnji Cooper 
528cdebaff8SEnji Cooper 	printf("Before calling PT_ATTACH for tracee %d\n", tracee);
529cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
530cdebaff8SEnji Cooper 
531cdebaff8SEnji Cooper 	printf("Wait for the stopped tracee process with %s()\n",
532cdebaff8SEnji Cooper 	    TWAIT_FNAME);
533cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
534cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
535cdebaff8SEnji Cooper 
536cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGSTOP);
537cdebaff8SEnji Cooper 
538cdebaff8SEnji Cooper 	printf("Resume tracee with PT_CONTINUE\n");
539cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
540cdebaff8SEnji Cooper 
541cdebaff8SEnji Cooper 	printf("Let the tracee exit now\n");
542cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 2", parent_tracee, msg);
543cdebaff8SEnji Cooper 
544cdebaff8SEnji Cooper 	printf("Wait for tracee to exit with %s()\n", TWAIT_FNAME);
545cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
546cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
547cdebaff8SEnji Cooper 
548cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracee);
549cdebaff8SEnji Cooper 
550cdebaff8SEnji Cooper 	printf("Before calling %s() for tracee\n", TWAIT_FNAME);
551cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD,
552cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, 0));
553cdebaff8SEnji Cooper 
554cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
555cdebaff8SEnji Cooper }
556cdebaff8SEnji Cooper 
557cdebaff8SEnji Cooper ATF_TC(attach4);
ATF_TC_HEAD(attach4,tc)558cdebaff8SEnji Cooper ATF_TC_HEAD(attach4, tc)
559cdebaff8SEnji Cooper {
560cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
561cdebaff8SEnji Cooper 	    "Assert that tracer child can PT_ATTACH to its parent");
562cdebaff8SEnji Cooper }
563cdebaff8SEnji Cooper 
ATF_TC_BODY(attach4,tc)564cdebaff8SEnji Cooper ATF_TC_BODY(attach4, tc)
565cdebaff8SEnji Cooper {
566cdebaff8SEnji Cooper 	struct msg_fds parent_tracee;
567cdebaff8SEnji Cooper 	const int exitval_tracer = 5;
568cdebaff8SEnji Cooper 	pid_t tracer, wpid;
569cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
570cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
571cdebaff8SEnji Cooper 	int status;
572cdebaff8SEnji Cooper #endif
573cdebaff8SEnji Cooper 
574cdebaff8SEnji Cooper 	printf("Spawn tracer\n");
575cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
576cdebaff8SEnji Cooper 	tracer = atf_utils_fork();
577cdebaff8SEnji Cooper 	if (tracer == 0) {
578cdebaff8SEnji Cooper 
579cdebaff8SEnji Cooper 		/* Wait for message from the parent */
580cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("Message 1", parent_tracee, msg);
581cdebaff8SEnji Cooper 
582cdebaff8SEnji Cooper 		printf("Attach to parent PID %d with PT_ATTACH from child\n",
583cdebaff8SEnji Cooper 		    getppid());
584cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_ATTACH, getppid(), NULL, 0) != -1);
585cdebaff8SEnji Cooper 
586cdebaff8SEnji Cooper 		printf("Wait for the stopped parent process with %s()\n",
587cdebaff8SEnji Cooper 		    TWAIT_FNAME);
588cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
589cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(getppid(), &status, 0), getppid());
590cdebaff8SEnji Cooper 
591cdebaff8SEnji Cooper 		forkee_status_stopped(status, SIGSTOP);
592cdebaff8SEnji Cooper 
593cdebaff8SEnji Cooper 		printf("Resume parent with PT_DETACH\n");
594cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_DETACH, getppid(), (void *)1, 0)
595cdebaff8SEnji Cooper 		    != -1);
596cdebaff8SEnji Cooper 
597cdebaff8SEnji Cooper 		/* Tell parent we are ready */
598cdebaff8SEnji Cooper 		CHILD_TO_PARENT("Message 1", parent_tracee, msg);
599cdebaff8SEnji Cooper 
600cdebaff8SEnji Cooper 		_exit(exitval_tracer);
601cdebaff8SEnji Cooper 	}
602cdebaff8SEnji Cooper 
603cdebaff8SEnji Cooper 	printf("Wait for the tracer to become ready\n");
604cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 1", parent_tracee, msg);
605cdebaff8SEnji Cooper 	printf("Allow the tracer to exit now\n");
606cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("Message 1", parent_tracee, msg);
607cdebaff8SEnji Cooper 
608cdebaff8SEnji Cooper 	printf("Wait for tracer to exit with %s()\n", TWAIT_FNAME);
609cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
610cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracer, &status, 0), tracer);
611cdebaff8SEnji Cooper 
612cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracer);
613cdebaff8SEnji Cooper 
614cdebaff8SEnji Cooper 	printf("Before calling %s() for tracer\n", TWAIT_FNAME);
615cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD,
616cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracer, &status, 0));
617cdebaff8SEnji Cooper 
618cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
619cdebaff8SEnji Cooper }
620cdebaff8SEnji Cooper 
621cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
622cdebaff8SEnji Cooper ATF_TC(attach5);
ATF_TC_HEAD(attach5,tc)623cdebaff8SEnji Cooper ATF_TC_HEAD(attach5, tc)
624cdebaff8SEnji Cooper {
625cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
626cdebaff8SEnji Cooper 	    "Assert that tracer sees its parent when attached to tracer "
627cdebaff8SEnji Cooper 	    "(check getppid(2))");
628cdebaff8SEnji Cooper }
629cdebaff8SEnji Cooper 
ATF_TC_BODY(attach5,tc)630cdebaff8SEnji Cooper ATF_TC_BODY(attach5, tc)
631cdebaff8SEnji Cooper {
632cdebaff8SEnji Cooper 	struct msg_fds parent_tracer, parent_tracee;
633cdebaff8SEnji Cooper 	const int exitval_tracee = 5;
634cdebaff8SEnji Cooper 	const int exitval_tracer = 10;
635cdebaff8SEnji Cooper 	pid_t parent, tracee, tracer, wpid;
636cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
637cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
638cdebaff8SEnji Cooper 	int status;
639cdebaff8SEnji Cooper #endif
640cdebaff8SEnji Cooper 
641cdebaff8SEnji Cooper 	printf("Spawn tracee\n");
642cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracer) == 0);
643cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
644cdebaff8SEnji Cooper 	tracee = atf_utils_fork();
645cdebaff8SEnji Cooper 	if (tracee == 0) {
646cdebaff8SEnji Cooper 		parent = getppid();
647cdebaff8SEnji Cooper 
648cdebaff8SEnji Cooper 		/* Emit message to the parent */
649cdebaff8SEnji Cooper 		CHILD_TO_PARENT("tracee ready", parent_tracee, msg);
650cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("exit tracee", parent_tracee, msg);
651cdebaff8SEnji Cooper 
652cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(parent, getppid());
653cdebaff8SEnji Cooper 
654cdebaff8SEnji Cooper 		_exit(exitval_tracee);
655cdebaff8SEnji Cooper 	}
656cdebaff8SEnji Cooper 	printf("Wait for child to record its parent identifier (pid)\n");
657cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("tracee ready", parent_tracee, msg);
658cdebaff8SEnji Cooper 
659cdebaff8SEnji Cooper 	printf("Spawn debugger\n");
660cdebaff8SEnji Cooper 	tracer = atf_utils_fork();
661cdebaff8SEnji Cooper 	if (tracer == 0) {
662cdebaff8SEnji Cooper 		/* No IPC to communicate with the child */
663cdebaff8SEnji Cooper 		printf("Before calling PT_ATTACH from tracee %d\n", getpid());
664cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
665cdebaff8SEnji Cooper 
666cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it was stopped w/ SIGSTOP */
667cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
668cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
669cdebaff8SEnji Cooper 
670cdebaff8SEnji Cooper 		forkee_status_stopped(status, SIGSTOP);
671cdebaff8SEnji Cooper 
672cdebaff8SEnji Cooper 		/* Resume tracee with PT_CONTINUE */
673cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
674cdebaff8SEnji Cooper 
675cdebaff8SEnji Cooper 		/* Inform parent that tracer has attached to tracee */
676cdebaff8SEnji Cooper 		CHILD_TO_PARENT("tracer ready", parent_tracer, msg);
677cdebaff8SEnji Cooper 
678cdebaff8SEnji Cooper 		/* Wait for parent to tell use that tracee should have exited */
679cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg);
680cdebaff8SEnji Cooper 
681cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it exited */
682cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
683cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
684cdebaff8SEnji Cooper 
685cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval_tracee);
686cdebaff8SEnji Cooper 
687cdebaff8SEnji Cooper 		printf("Before exiting of the tracer process\n");
688cdebaff8SEnji Cooper 		_exit(exitval_tracer);
689cdebaff8SEnji Cooper 	}
690cdebaff8SEnji Cooper 
691cdebaff8SEnji Cooper 	printf("Wait for the tracer to attach to the tracee\n");
692cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("tracer ready",  parent_tracer, msg);
693cdebaff8SEnji Cooper 
694cdebaff8SEnji Cooper 	printf("Resume the tracee and let it exit\n");
695cdebaff8SEnji Cooper 	PARENT_TO_CHILD("exit tracee",  parent_tracee, msg);
696cdebaff8SEnji Cooper 
697cdebaff8SEnji Cooper 	printf("Detect that tracee is zombie\n");
698cdebaff8SEnji Cooper 	await_zombie(tracee);
699cdebaff8SEnji Cooper 
700cdebaff8SEnji Cooper 	printf("Assert that there is no status about tracee - "
701cdebaff8SEnji Cooper 	    "Tracer must detect zombie first - calling %s()\n", TWAIT_FNAME);
702cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
703cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0);
704cdebaff8SEnji Cooper 
705cdebaff8SEnji Cooper 	printf("Tell the tracer child should have exited\n");
706cdebaff8SEnji Cooper 	PARENT_TO_CHILD("wait for tracee exit",  parent_tracer, msg);
707cdebaff8SEnji Cooper 
708cdebaff8SEnji Cooper 	printf("Wait from tracer child to complete waiting for tracee\n");
709cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0),
710cdebaff8SEnji Cooper 	    tracer);
711cdebaff8SEnji Cooper 
712cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracer);
713cdebaff8SEnji Cooper 
714cdebaff8SEnji Cooper 	printf("Wait for tracee to finish its job and exit - calling %s()\n",
715cdebaff8SEnji Cooper 	    TWAIT_FNAME);
716cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG),
717cdebaff8SEnji Cooper 	    tracee);
718cdebaff8SEnji Cooper 
719cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracee);
720cdebaff8SEnji Cooper 
721cdebaff8SEnji Cooper 	msg_close(&parent_tracer);
722cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
723cdebaff8SEnji Cooper }
724cdebaff8SEnji Cooper #endif
725cdebaff8SEnji Cooper 
726cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
727cdebaff8SEnji Cooper ATF_TC(attach6);
ATF_TC_HEAD(attach6,tc)728cdebaff8SEnji Cooper ATF_TC_HEAD(attach6, tc)
729cdebaff8SEnji Cooper {
730cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
731cdebaff8SEnji Cooper 	    "Assert that tracer sees its parent when attached to tracer "
732cdebaff8SEnji Cooper 	    "(check sysctl(7) and struct kinfo_proc2)");
733cdebaff8SEnji Cooper }
734cdebaff8SEnji Cooper 
ATF_TC_BODY(attach6,tc)735cdebaff8SEnji Cooper ATF_TC_BODY(attach6, tc)
736cdebaff8SEnji Cooper {
737cdebaff8SEnji Cooper 	struct msg_fds parent_tracee, parent_tracer;
738cdebaff8SEnji Cooper 	const int exitval_tracee = 5;
739cdebaff8SEnji Cooper 	const int exitval_tracer = 10;
740cdebaff8SEnji Cooper 	pid_t parent, tracee, tracer, wpid;
741cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
742cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
743cdebaff8SEnji Cooper 	int status;
744cdebaff8SEnji Cooper #endif
745cdebaff8SEnji Cooper 	int name[CTL_MAXNAME];
746cdebaff8SEnji Cooper 	struct kinfo_proc2 kp;
747cdebaff8SEnji Cooper 	size_t len = sizeof(kp);
748cdebaff8SEnji Cooper 	unsigned int namelen;
749cdebaff8SEnji Cooper 
750cdebaff8SEnji Cooper 	printf("Spawn tracee\n");
751cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
752cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracer) == 0);
753cdebaff8SEnji Cooper 	tracee = atf_utils_fork();
754cdebaff8SEnji Cooper 	if (tracee == 0) {
755cdebaff8SEnji Cooper 		parent = getppid();
756cdebaff8SEnji Cooper 
757cdebaff8SEnji Cooper 		/* Emit message to the parent */
758cdebaff8SEnji Cooper 		CHILD_TO_PARENT("Message 1", parent_tracee, msg);
759cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("Message 2", parent_tracee, msg);
760cdebaff8SEnji Cooper 
761cdebaff8SEnji Cooper 		namelen = 0;
762cdebaff8SEnji Cooper 		name[namelen++] = CTL_KERN;
763cdebaff8SEnji Cooper 		name[namelen++] = KERN_PROC2;
764cdebaff8SEnji Cooper 		name[namelen++] = KERN_PROC_PID;
765cdebaff8SEnji Cooper 		name[namelen++] = getpid();
766cdebaff8SEnji Cooper 		name[namelen++] = len;
767cdebaff8SEnji Cooper 		name[namelen++] = 1;
768cdebaff8SEnji Cooper 
769cdebaff8SEnji Cooper 		FORKEE_ASSERT(sysctl(name, namelen, &kp, &len, NULL, 0) == 0);
770cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(parent, kp.p_ppid);
771cdebaff8SEnji Cooper 
772cdebaff8SEnji Cooper 		_exit(exitval_tracee);
773cdebaff8SEnji Cooper 	}
774cdebaff8SEnji Cooper 
775cdebaff8SEnji Cooper 	printf("Wait for child to record its parent identifier (pid)\n");
776cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("Message 1", parent_tracee, msg);
777cdebaff8SEnji Cooper 
778cdebaff8SEnji Cooper 	printf("Spawn debugger\n");
779cdebaff8SEnji Cooper 	tracer = atf_utils_fork();
780cdebaff8SEnji Cooper 	if (tracer == 0) {
781cdebaff8SEnji Cooper 		/* No IPC to communicate with the child */
782cdebaff8SEnji Cooper 		printf("Before calling PT_ATTACH from tracee %d\n", getpid());
783cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
784cdebaff8SEnji Cooper 
785cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it was stopped w/ SIGSTOP */
786cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
787cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
788cdebaff8SEnji Cooper 
789cdebaff8SEnji Cooper 		forkee_status_stopped(status, SIGSTOP);
790cdebaff8SEnji Cooper 
791cdebaff8SEnji Cooper 		/* Resume tracee with PT_CONTINUE */
792cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
793cdebaff8SEnji Cooper 
794cdebaff8SEnji Cooper 		/* Inform parent that tracer has attached to tracee */
795cdebaff8SEnji Cooper 		CHILD_TO_PARENT("Message 1", parent_tracer, msg);
796cdebaff8SEnji Cooper 
797cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("Message 2", parent_tracer, msg);
798cdebaff8SEnji Cooper 
799cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it exited */
800cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
801cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
802cdebaff8SEnji Cooper 
803cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval_tracee);
804cdebaff8SEnji Cooper 
805cdebaff8SEnji Cooper 		printf("Before exiting of the tracer process\n");
806cdebaff8SEnji Cooper 		_exit(exitval_tracer);
807cdebaff8SEnji Cooper 	}
808cdebaff8SEnji Cooper 
809cdebaff8SEnji Cooper 	printf("Wait for the tracer to attach to the tracee\n");
810cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("Message 1", parent_tracer, msg);
811cdebaff8SEnji Cooper 
812cdebaff8SEnji Cooper 	printf("Resume the tracee and let it exit\n");
813cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 1", parent_tracee, msg);
814cdebaff8SEnji Cooper 
815cdebaff8SEnji Cooper 	printf("Detect that tracee is zombie\n");
816cdebaff8SEnji Cooper 	await_zombie(tracee);
817cdebaff8SEnji Cooper 
818cdebaff8SEnji Cooper 	printf("Assert that there is no status about tracee - "
819cdebaff8SEnji Cooper 	    "Tracer must detect zombie first - calling %s()\n", TWAIT_FNAME);
820cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
821cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0);
822cdebaff8SEnji Cooper 
823cdebaff8SEnji Cooper 	printf("Resume the tracer and let it detect exited tracee\n");
824cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 2", parent_tracer, msg);
825cdebaff8SEnji Cooper 
826cdebaff8SEnji Cooper 	printf("Wait for tracer to finish its job and exit - calling %s()\n",
827cdebaff8SEnji Cooper 	    TWAIT_FNAME);
828cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0),
829cdebaff8SEnji Cooper 	    tracer);
830cdebaff8SEnji Cooper 
831cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracer);
832cdebaff8SEnji Cooper 
833cdebaff8SEnji Cooper 	printf("Wait for tracee to finish its job and exit - calling %s()\n",
834cdebaff8SEnji Cooper 	    TWAIT_FNAME);
835cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG),
836cdebaff8SEnji Cooper 	    tracee);
837cdebaff8SEnji Cooper 
838cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracee);
839cdebaff8SEnji Cooper 
840cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
841cdebaff8SEnji Cooper 	msg_close(&parent_tracer);
842cdebaff8SEnji Cooper }
843cdebaff8SEnji Cooper #endif
844cdebaff8SEnji Cooper 
845cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
846cdebaff8SEnji Cooper ATF_TC(attach7);
ATF_TC_HEAD(attach7,tc)847cdebaff8SEnji Cooper ATF_TC_HEAD(attach7, tc)
848cdebaff8SEnji Cooper {
849cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
850cdebaff8SEnji Cooper 	    "Assert that tracer sees its parent when attached to tracer "
851cdebaff8SEnji Cooper 	    "(check /proc/curproc/status 3rd column)");
852cdebaff8SEnji Cooper }
853cdebaff8SEnji Cooper 
ATF_TC_BODY(attach7,tc)854cdebaff8SEnji Cooper ATF_TC_BODY(attach7, tc)
855cdebaff8SEnji Cooper {
856cdebaff8SEnji Cooper 	struct msg_fds parent_tracee, parent_tracer;
857cdebaff8SEnji Cooper 	int rv;
858cdebaff8SEnji Cooper 	const int exitval_tracee = 5;
859cdebaff8SEnji Cooper 	const int exitval_tracer = 10;
860cdebaff8SEnji Cooper 	pid_t parent, tracee, tracer, wpid;
861cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
862cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
863cdebaff8SEnji Cooper 	int status;
864cdebaff8SEnji Cooper #endif
865cdebaff8SEnji Cooper 	FILE *fp;
866cdebaff8SEnji Cooper 	struct stat st;
867cdebaff8SEnji Cooper 	const char *fname = "/proc/curproc/status";
868cdebaff8SEnji Cooper 	char s_executable[MAXPATHLEN];
869cdebaff8SEnji Cooper 	int s_pid, s_ppid;
870cdebaff8SEnji Cooper 	/*
871cdebaff8SEnji Cooper 	 * Format:
872cdebaff8SEnji Cooper 	 *  EXECUTABLE PID PPID ...
873cdebaff8SEnji Cooper 	 */
874cdebaff8SEnji Cooper 
875cdebaff8SEnji Cooper 	ATF_REQUIRE((rv = stat(fname, &st)) == 0 || (errno == ENOENT));
876cdebaff8SEnji Cooper 	if (rv != 0) {
877cdebaff8SEnji Cooper 		atf_tc_skip("/proc/curproc/status not found");
878cdebaff8SEnji Cooper 	}
879cdebaff8SEnji Cooper 
880cdebaff8SEnji Cooper 	printf("Spawn tracee\n");
881cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
882cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracer) == 0);
883cdebaff8SEnji Cooper 	tracee = atf_utils_fork();
884cdebaff8SEnji Cooper 	if (tracee == 0) {
885cdebaff8SEnji Cooper 		parent = getppid();
886cdebaff8SEnji Cooper 
887cdebaff8SEnji Cooper 		// Wait for parent to let us exit
888cdebaff8SEnji Cooper 		CHILD_TO_PARENT("tracee ready", parent_tracee, msg);
889cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("tracee exit", parent_tracee, msg);
890cdebaff8SEnji Cooper 
891cdebaff8SEnji Cooper 		FORKEE_ASSERT((fp = fopen(fname, "r")) != NULL);
892cdebaff8SEnji Cooper 		fscanf(fp, "%s %d %d", s_executable, &s_pid, &s_ppid);
893cdebaff8SEnji Cooper 		FORKEE_ASSERT(fclose(fp) == 0);
894cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(parent, s_ppid);
895cdebaff8SEnji Cooper 
896cdebaff8SEnji Cooper 		_exit(exitval_tracee);
897cdebaff8SEnji Cooper 	}
898cdebaff8SEnji Cooper 
899cdebaff8SEnji Cooper 	printf("Wait for child to record its parent identifier (pid)\n");
900cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("tracee ready", parent_tracee, msg);
901cdebaff8SEnji Cooper 
902cdebaff8SEnji Cooper 	printf("Spawn debugger\n");
903cdebaff8SEnji Cooper 	tracer = atf_utils_fork();
904cdebaff8SEnji Cooper 	if (tracer == 0) {
905cdebaff8SEnji Cooper 		printf("Before calling PT_ATTACH from tracee %d\n", getpid());
906cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
907cdebaff8SEnji Cooper 
908cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it was stopped w/ SIGSTOP */
909cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
910cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
911cdebaff8SEnji Cooper 
912cdebaff8SEnji Cooper 		forkee_status_stopped(status, SIGSTOP);
913cdebaff8SEnji Cooper 
914cdebaff8SEnji Cooper 		/* Resume tracee with PT_CONTINUE */
915cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
916cdebaff8SEnji Cooper 
917cdebaff8SEnji Cooper 		/* Inform parent that tracer has attached to tracee */
918cdebaff8SEnji Cooper 		CHILD_TO_PARENT("tracer ready", parent_tracer, msg);
919cdebaff8SEnji Cooper 
920cdebaff8SEnji Cooper 		/* Wait for parent to tell use that tracee should have exited */
921cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("wait for tracee exit", parent_tracer, msg);
922cdebaff8SEnji Cooper 
923cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it exited */
924cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
925cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
926cdebaff8SEnji Cooper 
927cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval_tracee);
928cdebaff8SEnji Cooper 
929cdebaff8SEnji Cooper 		printf("Before exiting of the tracer process\n");
930cdebaff8SEnji Cooper 		_exit(exitval_tracer);
931cdebaff8SEnji Cooper 	}
932cdebaff8SEnji Cooper 	printf("Wait for the tracer to attach to the tracee\n");
933cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("tracer ready", parent_tracer, msg);
934cdebaff8SEnji Cooper 	printf("Resume the tracee and let it exit\n");
935cdebaff8SEnji Cooper 	PARENT_TO_CHILD("tracee exit", parent_tracee, msg);
936cdebaff8SEnji Cooper 
937cdebaff8SEnji Cooper 	printf("Detect that tracee is zombie\n");
938cdebaff8SEnji Cooper 	await_zombie(tracee);
939cdebaff8SEnji Cooper 
940cdebaff8SEnji Cooper 	printf("Assert that there is no status about tracee - "
941cdebaff8SEnji Cooper 	    "Tracer must detect zombie first - calling %s()\n", TWAIT_FNAME);
942cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
943cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0);
944cdebaff8SEnji Cooper 
945cdebaff8SEnji Cooper 	printf("Resume the tracer and let it detect exited tracee\n");
946cdebaff8SEnji Cooper 	PARENT_TO_CHILD("Message 2", parent_tracer, msg);
947cdebaff8SEnji Cooper 
948cdebaff8SEnji Cooper 	printf("Wait for tracer to finish its job and exit - calling %s()\n",
949cdebaff8SEnji Cooper 	    TWAIT_FNAME);
950cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0),
951cdebaff8SEnji Cooper 	    tracer);
952cdebaff8SEnji Cooper 
953cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracer);
954cdebaff8SEnji Cooper 
955cdebaff8SEnji Cooper 	printf("Wait for tracee to finish its job and exit - calling %s()\n",
956cdebaff8SEnji Cooper 	    TWAIT_FNAME);
957cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG),
958cdebaff8SEnji Cooper 	    tracee);
959cdebaff8SEnji Cooper 
960cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracee);
961cdebaff8SEnji Cooper 
962cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
963cdebaff8SEnji Cooper 	msg_close(&parent_tracer);
964cdebaff8SEnji Cooper }
965cdebaff8SEnji Cooper #endif
966cdebaff8SEnji Cooper 
967cdebaff8SEnji Cooper ATF_TC(eventmask1);
ATF_TC_HEAD(eventmask1,tc)968cdebaff8SEnji Cooper ATF_TC_HEAD(eventmask1, tc)
969cdebaff8SEnji Cooper {
970cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
971cdebaff8SEnji Cooper 	    "Verify that empty EVENT_MASK is preserved");
972cdebaff8SEnji Cooper }
973cdebaff8SEnji Cooper 
ATF_TC_BODY(eventmask1,tc)974cdebaff8SEnji Cooper ATF_TC_BODY(eventmask1, tc)
975cdebaff8SEnji Cooper {
976cdebaff8SEnji Cooper 	const int exitval = 5;
977cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
978cdebaff8SEnji Cooper 	pid_t child, wpid;
979cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
980cdebaff8SEnji Cooper 	int status;
981cdebaff8SEnji Cooper #endif
982cdebaff8SEnji Cooper 	ptrace_event_t set_event, get_event;
983cdebaff8SEnji Cooper 	const int len = sizeof(ptrace_event_t);
984cdebaff8SEnji Cooper 
985cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
986cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
987cdebaff8SEnji Cooper 	if (child == 0) {
988cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
989cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
990cdebaff8SEnji Cooper 
991cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
992cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
993cdebaff8SEnji Cooper 
994cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
995cdebaff8SEnji Cooper 		_exit(exitval);
996cdebaff8SEnji Cooper 	}
997cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
998cdebaff8SEnji Cooper 
999cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1000cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1001cdebaff8SEnji Cooper 
1002cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
1003cdebaff8SEnji Cooper 
1004cdebaff8SEnji Cooper 	set_event.pe_set_event = 0;
1005cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1);
1006cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1);
1007cdebaff8SEnji Cooper 	ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0);
1008cdebaff8SEnji Cooper 
1009cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1010cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1011cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1012cdebaff8SEnji Cooper 
1013cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1014cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1015cdebaff8SEnji Cooper 
1016cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
1017cdebaff8SEnji Cooper 
1018cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1019cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1020cdebaff8SEnji Cooper }
1021cdebaff8SEnji Cooper 
1022cdebaff8SEnji Cooper ATF_TC(eventmask2);
ATF_TC_HEAD(eventmask2,tc)1023cdebaff8SEnji Cooper ATF_TC_HEAD(eventmask2, tc)
1024cdebaff8SEnji Cooper {
1025cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1026cdebaff8SEnji Cooper 	    "Verify that PTRACE_FORK in EVENT_MASK is preserved");
1027cdebaff8SEnji Cooper }
1028cdebaff8SEnji Cooper 
ATF_TC_BODY(eventmask2,tc)1029cdebaff8SEnji Cooper ATF_TC_BODY(eventmask2, tc)
1030cdebaff8SEnji Cooper {
1031cdebaff8SEnji Cooper 	const int exitval = 5;
1032cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
1033cdebaff8SEnji Cooper 	pid_t child, wpid;
1034cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1035cdebaff8SEnji Cooper 	int status;
1036cdebaff8SEnji Cooper #endif
1037cdebaff8SEnji Cooper 	ptrace_event_t set_event, get_event;
1038cdebaff8SEnji Cooper 	const int len = sizeof(ptrace_event_t);
1039cdebaff8SEnji Cooper 
1040cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1041cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1042cdebaff8SEnji Cooper 	if (child == 0) {
1043cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1044cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1045cdebaff8SEnji Cooper 
1046cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1047cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1048cdebaff8SEnji Cooper 
1049cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
1050cdebaff8SEnji Cooper 		_exit(exitval);
1051cdebaff8SEnji Cooper 	}
1052cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1053cdebaff8SEnji Cooper 
1054cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1055cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1056cdebaff8SEnji Cooper 
1057cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
1058cdebaff8SEnji Cooper 
1059cdebaff8SEnji Cooper 	set_event.pe_set_event = PTRACE_FORK;
1060cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1);
1061cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1);
1062cdebaff8SEnji Cooper 	ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0);
1063cdebaff8SEnji Cooper 
1064cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1065cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1066cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1067cdebaff8SEnji Cooper 
1068cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1069cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1070cdebaff8SEnji Cooper 
1071cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
1072cdebaff8SEnji Cooper 
1073cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1074cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1075cdebaff8SEnji Cooper }
1076cdebaff8SEnji Cooper 
107763d1fd59SEnji Cooper ATF_TC(eventmask3);
ATF_TC_HEAD(eventmask3,tc)107863d1fd59SEnji Cooper ATF_TC_HEAD(eventmask3, tc)
107963d1fd59SEnji Cooper {
108063d1fd59SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
108163d1fd59SEnji Cooper 	    "Verify that PTRACE_VFORK in EVENT_MASK is preserved");
108263d1fd59SEnji Cooper }
108363d1fd59SEnji Cooper 
ATF_TC_BODY(eventmask3,tc)108463d1fd59SEnji Cooper ATF_TC_BODY(eventmask3, tc)
108563d1fd59SEnji Cooper {
108663d1fd59SEnji Cooper 	const int exitval = 5;
108763d1fd59SEnji Cooper 	const int sigval = SIGSTOP;
108863d1fd59SEnji Cooper 	pid_t child, wpid;
108963d1fd59SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
109063d1fd59SEnji Cooper 	int status;
109163d1fd59SEnji Cooper #endif
109263d1fd59SEnji Cooper 	ptrace_event_t set_event, get_event;
109363d1fd59SEnji Cooper 	const int len = sizeof(ptrace_event_t);
109463d1fd59SEnji Cooper 
109563d1fd59SEnji Cooper 	atf_tc_expect_fail("PR kern/51630");
109663d1fd59SEnji Cooper 
109763d1fd59SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
109863d1fd59SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
109963d1fd59SEnji Cooper 	if (child == 0) {
110063d1fd59SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
110163d1fd59SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
110263d1fd59SEnji Cooper 
110363d1fd59SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
110463d1fd59SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
110563d1fd59SEnji Cooper 
110663d1fd59SEnji Cooper 		printf("Before exiting of the child process\n");
110763d1fd59SEnji Cooper 		_exit(exitval);
110863d1fd59SEnji Cooper 	}
110963d1fd59SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
111063d1fd59SEnji Cooper 
111163d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
111263d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
111363d1fd59SEnji Cooper 
111463d1fd59SEnji Cooper 	validate_status_stopped(status, sigval);
111563d1fd59SEnji Cooper 
111663d1fd59SEnji Cooper 	set_event.pe_set_event = PTRACE_VFORK;
111763d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1);
111863d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1);
111963d1fd59SEnji Cooper 	ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0);
112063d1fd59SEnji Cooper 
112163d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
112263d1fd59SEnji Cooper 	    "without signal to be sent\n");
112363d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
112463d1fd59SEnji Cooper 
112563d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
112663d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
112763d1fd59SEnji Cooper 
112863d1fd59SEnji Cooper 	validate_status_exited(status, exitval);
112963d1fd59SEnji Cooper 
113063d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
113163d1fd59SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
113263d1fd59SEnji Cooper }
113363d1fd59SEnji Cooper 
113463d1fd59SEnji Cooper ATF_TC(eventmask4);
ATF_TC_HEAD(eventmask4,tc)113563d1fd59SEnji Cooper ATF_TC_HEAD(eventmask4, tc)
113663d1fd59SEnji Cooper {
113763d1fd59SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
113863d1fd59SEnji Cooper 	    "Verify that PTRACE_VFORK_DONE in EVENT_MASK is preserved");
113963d1fd59SEnji Cooper }
114063d1fd59SEnji Cooper 
ATF_TC_BODY(eventmask4,tc)114163d1fd59SEnji Cooper ATF_TC_BODY(eventmask4, tc)
114263d1fd59SEnji Cooper {
114363d1fd59SEnji Cooper 	const int exitval = 5;
114463d1fd59SEnji Cooper 	const int sigval = SIGSTOP;
114563d1fd59SEnji Cooper 	pid_t child, wpid;
114663d1fd59SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
114763d1fd59SEnji Cooper 	int status;
114863d1fd59SEnji Cooper #endif
114963d1fd59SEnji Cooper 	ptrace_event_t set_event, get_event;
115063d1fd59SEnji Cooper 	const int len = sizeof(ptrace_event_t);
115163d1fd59SEnji Cooper 
115263d1fd59SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
115363d1fd59SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
115463d1fd59SEnji Cooper 	if (child == 0) {
115563d1fd59SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
115663d1fd59SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
115763d1fd59SEnji Cooper 
115863d1fd59SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
115963d1fd59SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
116063d1fd59SEnji Cooper 
116163d1fd59SEnji Cooper 		printf("Before exiting of the child process\n");
116263d1fd59SEnji Cooper 		_exit(exitval);
116363d1fd59SEnji Cooper 	}
116463d1fd59SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
116563d1fd59SEnji Cooper 
116663d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
116763d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
116863d1fd59SEnji Cooper 
116963d1fd59SEnji Cooper 	validate_status_stopped(status, sigval);
117063d1fd59SEnji Cooper 
117163d1fd59SEnji Cooper 	set_event.pe_set_event = PTRACE_VFORK_DONE;
117263d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1);
117363d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1);
117463d1fd59SEnji Cooper 	ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0);
117563d1fd59SEnji Cooper 
117663d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
117763d1fd59SEnji Cooper 	    "without signal to be sent\n");
117863d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
117963d1fd59SEnji Cooper 
118063d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
118163d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
118263d1fd59SEnji Cooper 
118363d1fd59SEnji Cooper 	validate_status_exited(status, exitval);
118463d1fd59SEnji Cooper 
118563d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
118663d1fd59SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
118763d1fd59SEnji Cooper }
118863d1fd59SEnji Cooper 
1189f40f3adcSEnji Cooper ATF_TC(eventmask5);
ATF_TC_HEAD(eventmask5,tc)1190f40f3adcSEnji Cooper ATF_TC_HEAD(eventmask5, tc)
1191f40f3adcSEnji Cooper {
1192f40f3adcSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1193f40f3adcSEnji Cooper 	    "Verify that PTRACE_LWP_CREATE in EVENT_MASK is preserved");
1194f40f3adcSEnji Cooper }
1195f40f3adcSEnji Cooper 
ATF_TC_BODY(eventmask5,tc)1196f40f3adcSEnji Cooper ATF_TC_BODY(eventmask5, tc)
1197f40f3adcSEnji Cooper {
1198f40f3adcSEnji Cooper 	const int exitval = 5;
1199f40f3adcSEnji Cooper 	const int sigval = SIGSTOP;
1200f40f3adcSEnji Cooper 	pid_t child, wpid;
1201f40f3adcSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1202f40f3adcSEnji Cooper 	int status;
1203f40f3adcSEnji Cooper #endif
1204f40f3adcSEnji Cooper 	ptrace_event_t set_event, get_event;
1205f40f3adcSEnji Cooper 	const int len = sizeof(ptrace_event_t);
1206f40f3adcSEnji Cooper 
1207f40f3adcSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1208f40f3adcSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1209f40f3adcSEnji Cooper 	if (child == 0) {
1210f40f3adcSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1211f40f3adcSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1212f40f3adcSEnji Cooper 
1213f40f3adcSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1214f40f3adcSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1215f40f3adcSEnji Cooper 
1216f40f3adcSEnji Cooper 		printf("Before exiting of the child process\n");
1217f40f3adcSEnji Cooper 		_exit(exitval);
1218f40f3adcSEnji Cooper 	}
1219f40f3adcSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1220f40f3adcSEnji Cooper 
1221f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1222f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1223f40f3adcSEnji Cooper 
1224f40f3adcSEnji Cooper 	validate_status_stopped(status, sigval);
1225f40f3adcSEnji Cooper 
1226f40f3adcSEnji Cooper 	set_event.pe_set_event = PTRACE_LWP_CREATE;
1227f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1);
1228f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1);
1229f40f3adcSEnji Cooper 	ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0);
1230f40f3adcSEnji Cooper 
1231f40f3adcSEnji Cooper 	printf("Before resuming the child process where it left off and "
1232f40f3adcSEnji Cooper 	    "without signal to be sent\n");
1233f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1234f40f3adcSEnji Cooper 
1235f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1236f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1237f40f3adcSEnji Cooper 
1238f40f3adcSEnji Cooper 	validate_status_exited(status, exitval);
1239f40f3adcSEnji Cooper 
1240f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1241f40f3adcSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1242f40f3adcSEnji Cooper }
1243f40f3adcSEnji Cooper 
1244f40f3adcSEnji Cooper ATF_TC(eventmask6);
ATF_TC_HEAD(eventmask6,tc)1245f40f3adcSEnji Cooper ATF_TC_HEAD(eventmask6, tc)
1246f40f3adcSEnji Cooper {
1247f40f3adcSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1248f40f3adcSEnji Cooper 	    "Verify that PTRACE_LWP_EXIT in EVENT_MASK is preserved");
1249f40f3adcSEnji Cooper }
1250f40f3adcSEnji Cooper 
ATF_TC_BODY(eventmask6,tc)1251f40f3adcSEnji Cooper ATF_TC_BODY(eventmask6, tc)
1252f40f3adcSEnji Cooper {
1253f40f3adcSEnji Cooper 	const int exitval = 5;
1254f40f3adcSEnji Cooper 	const int sigval = SIGSTOP;
1255f40f3adcSEnji Cooper 	pid_t child, wpid;
1256f40f3adcSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1257f40f3adcSEnji Cooper 	int status;
1258f40f3adcSEnji Cooper #endif
1259f40f3adcSEnji Cooper 	ptrace_event_t set_event, get_event;
1260f40f3adcSEnji Cooper 	const int len = sizeof(ptrace_event_t);
1261f40f3adcSEnji Cooper 
1262f40f3adcSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1263f40f3adcSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1264f40f3adcSEnji Cooper 	if (child == 0) {
1265f40f3adcSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1266f40f3adcSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1267f40f3adcSEnji Cooper 
1268f40f3adcSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1269f40f3adcSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1270f40f3adcSEnji Cooper 
1271f40f3adcSEnji Cooper 		printf("Before exiting of the child process\n");
1272f40f3adcSEnji Cooper 		_exit(exitval);
1273f40f3adcSEnji Cooper 	}
1274f40f3adcSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1275f40f3adcSEnji Cooper 
1276f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1277f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1278f40f3adcSEnji Cooper 
1279f40f3adcSEnji Cooper 	validate_status_stopped(status, sigval);
1280f40f3adcSEnji Cooper 
1281f40f3adcSEnji Cooper 	set_event.pe_set_event = PTRACE_LWP_EXIT;
1282f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &set_event, len) != -1);
1283f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, child, &get_event, len) != -1);
1284f40f3adcSEnji Cooper 	ATF_REQUIRE(memcmp(&set_event, &get_event, len) == 0);
1285f40f3adcSEnji Cooper 
1286f40f3adcSEnji Cooper 	printf("Before resuming the child process where it left off and "
1287f40f3adcSEnji Cooper 	    "without signal to be sent\n");
1288f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1289f40f3adcSEnji Cooper 
1290f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1291f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1292f40f3adcSEnji Cooper 
1293f40f3adcSEnji Cooper 	validate_status_exited(status, exitval);
1294f40f3adcSEnji Cooper 
1295f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1296f40f3adcSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1297f40f3adcSEnji Cooper }
1298f40f3adcSEnji Cooper 
1299cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
1300cdebaff8SEnji Cooper ATF_TC(fork1);
ATF_TC_HEAD(fork1,tc)1301cdebaff8SEnji Cooper ATF_TC_HEAD(fork1, tc)
1302cdebaff8SEnji Cooper {
1303cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1304cdebaff8SEnji Cooper 	    "Verify that fork(2) is intercepted by ptrace(2) with EVENT_MASK "
1305cdebaff8SEnji Cooper 	    "set to PTRACE_FORK");
1306cdebaff8SEnji Cooper }
1307cdebaff8SEnji Cooper 
ATF_TC_BODY(fork1,tc)1308cdebaff8SEnji Cooper ATF_TC_BODY(fork1, tc)
1309cdebaff8SEnji Cooper {
1310cdebaff8SEnji Cooper 	const int exitval = 5;
1311cdebaff8SEnji Cooper 	const int exitval2 = 15;
1312cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
1313cdebaff8SEnji Cooper 	pid_t child, child2, wpid;
1314cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1315cdebaff8SEnji Cooper 	int status;
1316cdebaff8SEnji Cooper #endif
1317cdebaff8SEnji Cooper 	ptrace_state_t state;
1318cdebaff8SEnji Cooper 	const int slen = sizeof(state);
1319cdebaff8SEnji Cooper 	ptrace_event_t event;
1320cdebaff8SEnji Cooper 	const int elen = sizeof(event);
1321cdebaff8SEnji Cooper 
1322cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1323cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1324cdebaff8SEnji Cooper 	if (child == 0) {
1325cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1326cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1327cdebaff8SEnji Cooper 
1328cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1329cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1330cdebaff8SEnji Cooper 
1331cdebaff8SEnji Cooper 		FORKEE_ASSERT((child2 = fork()) != 1);
1332cdebaff8SEnji Cooper 
1333cdebaff8SEnji Cooper 		if (child2 == 0)
1334cdebaff8SEnji Cooper 			_exit(exitval2);
1335cdebaff8SEnji Cooper 
1336cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS
1337cdebaff8SEnji Cooper 		    (wpid = TWAIT_GENERIC(child2, &status, 0), child2);
1338cdebaff8SEnji Cooper 
1339cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval2);
1340cdebaff8SEnji Cooper 
1341cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
1342cdebaff8SEnji Cooper 		_exit(exitval);
1343cdebaff8SEnji Cooper 	}
1344cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1345cdebaff8SEnji Cooper 
1346cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1347cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1348cdebaff8SEnji Cooper 
1349cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
1350cdebaff8SEnji Cooper 
1351cdebaff8SEnji Cooper 	printf("Enable PTRACE_FORK in EVENT_MASK for the child %d\n", child);
1352cdebaff8SEnji Cooper 	event.pe_set_event = PTRACE_FORK;
1353cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
1354cdebaff8SEnji Cooper 
1355cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1356cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1357cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1358cdebaff8SEnji Cooper 
1359cdebaff8SEnji Cooper 	printf("Before calling %s() for the child %d\n", TWAIT_FNAME, child);
1360cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1361cdebaff8SEnji Cooper 
1362cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
1363cdebaff8SEnji Cooper 
1364cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
1365cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_FORK);
1366cdebaff8SEnji Cooper 
1367cdebaff8SEnji Cooper 	child2 = state.pe_other_pid;
1368cdebaff8SEnji Cooper 	printf("Reported PTRACE_FORK event with forkee %d\n", child2);
1369cdebaff8SEnji Cooper 
1370cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee %d of the child %d\n",
1371cdebaff8SEnji Cooper 	    TWAIT_FNAME, child2, child);
1372cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
1373cdebaff8SEnji Cooper 	    child2);
1374cdebaff8SEnji Cooper 
1375cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
1376cdebaff8SEnji Cooper 
1377cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1);
1378cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_FORK);
1379cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_other_pid, child);
1380cdebaff8SEnji Cooper 
1381cdebaff8SEnji Cooper 	printf("Before resuming the forkee process where it left off and "
1382cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1383cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1);
1384cdebaff8SEnji Cooper 
1385cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1386cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1387cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1388cdebaff8SEnji Cooper 
1389cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee - expected exited\n",
1390cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1391cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
1392cdebaff8SEnji Cooper 	    child2);
1393cdebaff8SEnji Cooper 
1394cdebaff8SEnji Cooper 	validate_status_exited(status, exitval2);
1395cdebaff8SEnji Cooper 
1396cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee - expected no process\n",
1397cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1398cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD,
1399cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(child2, &status, 0));
1400cdebaff8SEnji Cooper 
1401cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
1402cdebaff8SEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
1403cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1404cdebaff8SEnji Cooper 
1405cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGCHLD);
1406cdebaff8SEnji Cooper 
1407cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1408cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1409cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1410cdebaff8SEnji Cooper 
1411cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
1412cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1413cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1414cdebaff8SEnji Cooper 
1415cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
1416cdebaff8SEnji Cooper 
1417cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
1418cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1419cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1420cdebaff8SEnji Cooper }
1421cdebaff8SEnji Cooper #endif
1422cdebaff8SEnji Cooper 
1423cdebaff8SEnji Cooper ATF_TC(fork2);
ATF_TC_HEAD(fork2,tc)1424cdebaff8SEnji Cooper ATF_TC_HEAD(fork2, tc)
1425cdebaff8SEnji Cooper {
1426cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1427cdebaff8SEnji Cooper 	    "Verify that fork(2) is not intercepted by ptrace(2) with empty "
1428cdebaff8SEnji Cooper 	    "EVENT_MASK");
1429cdebaff8SEnji Cooper }
1430cdebaff8SEnji Cooper 
ATF_TC_BODY(fork2,tc)1431cdebaff8SEnji Cooper ATF_TC_BODY(fork2, tc)
1432cdebaff8SEnji Cooper {
1433cdebaff8SEnji Cooper 	const int exitval = 5;
1434cdebaff8SEnji Cooper 	const int exitval2 = 15;
1435cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
1436cdebaff8SEnji Cooper 	pid_t child, child2, wpid;
1437cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1438cdebaff8SEnji Cooper 	int status;
1439cdebaff8SEnji Cooper #endif
1440cdebaff8SEnji Cooper 	ptrace_event_t event;
1441cdebaff8SEnji Cooper 	const int elen = sizeof(event);
1442cdebaff8SEnji Cooper 
1443cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1444cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1445cdebaff8SEnji Cooper 	if (child == 0) {
1446cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1447cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1448cdebaff8SEnji Cooper 
1449cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1450cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1451cdebaff8SEnji Cooper 
1452cdebaff8SEnji Cooper 		FORKEE_ASSERT((child2 = fork()) != 1);
1453cdebaff8SEnji Cooper 
1454cdebaff8SEnji Cooper 		if (child2 == 0)
1455cdebaff8SEnji Cooper 			_exit(exitval2);
1456cdebaff8SEnji Cooper 
1457cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS
1458cdebaff8SEnji Cooper 		    (wpid = TWAIT_GENERIC(child2, &status, 0), child2);
1459cdebaff8SEnji Cooper 
1460cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval2);
1461cdebaff8SEnji Cooper 
1462cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
1463cdebaff8SEnji Cooper 		_exit(exitval);
1464cdebaff8SEnji Cooper 	}
1465cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1466cdebaff8SEnji Cooper 
1467cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1468cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1469cdebaff8SEnji Cooper 
1470cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
1471cdebaff8SEnji Cooper 
1472cdebaff8SEnji Cooper 	printf("Set empty EVENT_MASK for the child %d\n", child);
1473cdebaff8SEnji Cooper 	event.pe_set_event = 0;
1474cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
1475cdebaff8SEnji Cooper 
1476cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1477cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1478cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1479cdebaff8SEnji Cooper 
1480cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
1481cdebaff8SEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
1482cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1483cdebaff8SEnji Cooper 
1484cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGCHLD);
1485cdebaff8SEnji Cooper 
1486cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1487cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1488cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1489cdebaff8SEnji Cooper 
1490cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
1491cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1492cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1493cdebaff8SEnji Cooper 
1494cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
1495cdebaff8SEnji Cooper 
1496cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
1497cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1498cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1499cdebaff8SEnji Cooper }
1500cdebaff8SEnji Cooper 
1501cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
1502cdebaff8SEnji Cooper ATF_TC(vfork1);
ATF_TC_HEAD(vfork1,tc)1503cdebaff8SEnji Cooper ATF_TC_HEAD(vfork1, tc)
1504cdebaff8SEnji Cooper {
1505cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1506cdebaff8SEnji Cooper 	    "Verify that vfork(2) is intercepted by ptrace(2) with EVENT_MASK "
1507cdebaff8SEnji Cooper 	    "set to PTRACE_VFORK");
1508cdebaff8SEnji Cooper }
1509cdebaff8SEnji Cooper 
ATF_TC_BODY(vfork1,tc)1510cdebaff8SEnji Cooper ATF_TC_BODY(vfork1, tc)
1511cdebaff8SEnji Cooper {
1512cdebaff8SEnji Cooper 	const int exitval = 5;
1513cdebaff8SEnji Cooper 	const int exitval2 = 15;
1514cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
1515cdebaff8SEnji Cooper 	pid_t child, child2, wpid;
1516cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1517cdebaff8SEnji Cooper 	int status;
1518cdebaff8SEnji Cooper #endif
1519cdebaff8SEnji Cooper 	ptrace_state_t state;
1520cdebaff8SEnji Cooper 	const int slen = sizeof(state);
1521cdebaff8SEnji Cooper 	ptrace_event_t event;
1522cdebaff8SEnji Cooper 	const int elen = sizeof(event);
1523cdebaff8SEnji Cooper 
1524cdebaff8SEnji Cooper 	atf_tc_expect_fail("PR kern/51630");
1525cdebaff8SEnji Cooper 
1526cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1527cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1528cdebaff8SEnji Cooper 	if (child == 0) {
1529cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1530cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1531cdebaff8SEnji Cooper 
1532cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1533cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1534cdebaff8SEnji Cooper 
1535cdebaff8SEnji Cooper 		FORKEE_ASSERT((child2 = vfork()) != 1);
1536cdebaff8SEnji Cooper 
1537cdebaff8SEnji Cooper 		if (child2 == 0)
1538cdebaff8SEnji Cooper 			_exit(exitval2);
1539cdebaff8SEnji Cooper 
1540cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS
1541cdebaff8SEnji Cooper 		    (wpid = TWAIT_GENERIC(child2, &status, 0), child2);
1542cdebaff8SEnji Cooper 
1543cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval2);
1544cdebaff8SEnji Cooper 
1545cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
1546cdebaff8SEnji Cooper 		_exit(exitval);
1547cdebaff8SEnji Cooper 	}
1548cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1549cdebaff8SEnji Cooper 
1550cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1551cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1552cdebaff8SEnji Cooper 
1553cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
1554cdebaff8SEnji Cooper 
1555cdebaff8SEnji Cooper 	printf("Enable PTRACE_VFORK in EVENT_MASK for the child %d\n", child);
1556cdebaff8SEnji Cooper 	event.pe_set_event = PTRACE_VFORK;
1557cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
1558cdebaff8SEnji Cooper 
1559cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1560cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1561cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1562cdebaff8SEnji Cooper 
1563cdebaff8SEnji Cooper 	printf("Before calling %s() for the child %d\n", TWAIT_FNAME, child);
1564cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1565cdebaff8SEnji Cooper 
1566cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
1567cdebaff8SEnji Cooper 
1568cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
1569cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK);
1570cdebaff8SEnji Cooper 
1571cdebaff8SEnji Cooper 	child2 = state.pe_other_pid;
1572cdebaff8SEnji Cooper 	printf("Reported PTRACE_VFORK event with forkee %d\n", child2);
1573cdebaff8SEnji Cooper 
1574cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee %d of the child %d\n",
1575cdebaff8SEnji Cooper 	    TWAIT_FNAME, child2, child);
1576cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
1577cdebaff8SEnji Cooper 	    child2);
1578cdebaff8SEnji Cooper 
1579cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
1580cdebaff8SEnji Cooper 
1581cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1);
1582cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK);
1583cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_other_pid, child);
1584cdebaff8SEnji Cooper 
1585cdebaff8SEnji Cooper 	printf("Before resuming the forkee process where it left off and "
1586cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1587cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1);
1588cdebaff8SEnji Cooper 
1589cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1590cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1591cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1592cdebaff8SEnji Cooper 
1593cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee - expected exited\n",
1594cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1595cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
1596cdebaff8SEnji Cooper 	    child2);
1597cdebaff8SEnji Cooper 
1598cdebaff8SEnji Cooper 	validate_status_exited(status, exitval2);
1599cdebaff8SEnji Cooper 
1600cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee - expected no process\n",
1601cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1602cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD,
1603cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(child2, &status, 0));
1604cdebaff8SEnji Cooper 
1605cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
1606cdebaff8SEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
1607cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1608cdebaff8SEnji Cooper 
1609cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGCHLD);
1610cdebaff8SEnji Cooper 
1611cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1612cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1613cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1614cdebaff8SEnji Cooper 
1615cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
1616cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1617cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1618cdebaff8SEnji Cooper 
1619cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
1620cdebaff8SEnji Cooper 
1621cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
1622cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1623cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1624cdebaff8SEnji Cooper }
1625cdebaff8SEnji Cooper #endif
1626cdebaff8SEnji Cooper 
1627cdebaff8SEnji Cooper ATF_TC(vfork2);
ATF_TC_HEAD(vfork2,tc)1628cdebaff8SEnji Cooper ATF_TC_HEAD(vfork2, tc)
1629cdebaff8SEnji Cooper {
1630cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1631cdebaff8SEnji Cooper 	    "Verify that vfork(2) is not intercepted by ptrace(2) with empty "
1632cdebaff8SEnji Cooper 	    "EVENT_MASK");
1633cdebaff8SEnji Cooper }
1634cdebaff8SEnji Cooper 
ATF_TC_BODY(vfork2,tc)1635cdebaff8SEnji Cooper ATF_TC_BODY(vfork2, tc)
1636cdebaff8SEnji Cooper {
1637cdebaff8SEnji Cooper 	const int exitval = 5;
1638cdebaff8SEnji Cooper 	const int exitval2 = 15;
1639cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
1640cdebaff8SEnji Cooper 	pid_t child, child2, wpid;
1641cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1642cdebaff8SEnji Cooper 	int status;
1643cdebaff8SEnji Cooper #endif
1644cdebaff8SEnji Cooper 	ptrace_event_t event;
1645cdebaff8SEnji Cooper 	const int elen = sizeof(event);
1646cdebaff8SEnji Cooper 
1647cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1648cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1649cdebaff8SEnji Cooper 	if (child == 0) {
1650cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1651cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1652cdebaff8SEnji Cooper 
1653cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1654cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1655cdebaff8SEnji Cooper 
1656cdebaff8SEnji Cooper 		FORKEE_ASSERT((child2 = vfork()) != 1);
1657cdebaff8SEnji Cooper 
1658cdebaff8SEnji Cooper 		if (child2 == 0)
1659cdebaff8SEnji Cooper 			_exit(exitval2);
1660cdebaff8SEnji Cooper 
1661cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS
1662cdebaff8SEnji Cooper 		    (wpid = TWAIT_GENERIC(child2, &status, 0), child2);
1663cdebaff8SEnji Cooper 
1664cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval2);
1665cdebaff8SEnji Cooper 
1666cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
1667cdebaff8SEnji Cooper 		_exit(exitval);
1668cdebaff8SEnji Cooper 	}
1669cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1670cdebaff8SEnji Cooper 
1671cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1672cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1673cdebaff8SEnji Cooper 
1674cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
1675cdebaff8SEnji Cooper 
1676cdebaff8SEnji Cooper 	printf("Set empty EVENT_MASK for the child %d\n", child);
1677cdebaff8SEnji Cooper 	event.pe_set_event = 0;
1678cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
1679cdebaff8SEnji Cooper 
1680cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1681cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1682cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1683cdebaff8SEnji Cooper 
1684cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
1685cdebaff8SEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
1686cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1687cdebaff8SEnji Cooper 
1688cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGCHLD);
1689cdebaff8SEnji Cooper 
1690cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1691cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1692cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1693cdebaff8SEnji Cooper 
1694cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
1695cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1696cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1697cdebaff8SEnji Cooper 
1698cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
1699cdebaff8SEnji Cooper 
1700cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
1701cdebaff8SEnji Cooper 	    TWAIT_FNAME);
1702cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1703cdebaff8SEnji Cooper }
1704cdebaff8SEnji Cooper 
170563d1fd59SEnji Cooper ATF_TC(vforkdone1);
ATF_TC_HEAD(vforkdone1,tc)170663d1fd59SEnji Cooper ATF_TC_HEAD(vforkdone1, tc)
170763d1fd59SEnji Cooper {
170863d1fd59SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
170963d1fd59SEnji Cooper 	    "Verify that vfork(2) is intercepted by ptrace(2) with EVENT_MASK "
171063d1fd59SEnji Cooper 	    "set to PTRACE_VFORK_DONE");
171163d1fd59SEnji Cooper }
171263d1fd59SEnji Cooper 
ATF_TC_BODY(vforkdone1,tc)171363d1fd59SEnji Cooper ATF_TC_BODY(vforkdone1, tc)
171463d1fd59SEnji Cooper {
171563d1fd59SEnji Cooper 	const int exitval = 5;
171663d1fd59SEnji Cooper 	const int exitval2 = 15;
171763d1fd59SEnji Cooper 	const int sigval = SIGSTOP;
171863d1fd59SEnji Cooper 	pid_t child, child2, wpid;
171963d1fd59SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
172063d1fd59SEnji Cooper 	int status;
172163d1fd59SEnji Cooper #endif
172263d1fd59SEnji Cooper 	ptrace_state_t state;
172363d1fd59SEnji Cooper 	const int slen = sizeof(state);
172463d1fd59SEnji Cooper 	ptrace_event_t event;
172563d1fd59SEnji Cooper 	const int elen = sizeof(event);
172663d1fd59SEnji Cooper 
172763d1fd59SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
172863d1fd59SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
172963d1fd59SEnji Cooper 	if (child == 0) {
173063d1fd59SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
173163d1fd59SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
173263d1fd59SEnji Cooper 
173363d1fd59SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
173463d1fd59SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
173563d1fd59SEnji Cooper 
173663d1fd59SEnji Cooper 		FORKEE_ASSERT((child2 = vfork()) != 1);
173763d1fd59SEnji Cooper 
173863d1fd59SEnji Cooper 		if (child2 == 0)
173963d1fd59SEnji Cooper 			_exit(exitval2);
174063d1fd59SEnji Cooper 
174163d1fd59SEnji Cooper 		FORKEE_REQUIRE_SUCCESS
174263d1fd59SEnji Cooper 		    (wpid = TWAIT_GENERIC(child2, &status, 0), child2);
174363d1fd59SEnji Cooper 
174463d1fd59SEnji Cooper 		forkee_status_exited(status, exitval2);
174563d1fd59SEnji Cooper 
174663d1fd59SEnji Cooper 		printf("Before exiting of the child process\n");
174763d1fd59SEnji Cooper 		_exit(exitval);
174863d1fd59SEnji Cooper 	}
174963d1fd59SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
175063d1fd59SEnji Cooper 
175163d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
175263d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
175363d1fd59SEnji Cooper 
175463d1fd59SEnji Cooper 	validate_status_stopped(status, sigval);
175563d1fd59SEnji Cooper 
1756*dd66b5baSEnji Cooper 	printf("Enable PTRACE_VFORK_DONE in EVENT_MASK for the child %d\n",
1757*dd66b5baSEnji Cooper 	    child);
175863d1fd59SEnji Cooper 	event.pe_set_event = PTRACE_VFORK_DONE;
175963d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
176063d1fd59SEnji Cooper 
176163d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
176263d1fd59SEnji Cooper 	    "without signal to be sent\n");
176363d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
176463d1fd59SEnji Cooper 
176563d1fd59SEnji Cooper 	printf("Before calling %s() for the child %d\n", TWAIT_FNAME, child);
176663d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
176763d1fd59SEnji Cooper 
176863d1fd59SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
176963d1fd59SEnji Cooper 
177063d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
177163d1fd59SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE);
177263d1fd59SEnji Cooper 
177363d1fd59SEnji Cooper 	child2 = state.pe_other_pid;
177463d1fd59SEnji Cooper 	printf("Reported PTRACE_VFORK_DONE event with forkee %d\n", child2);
177563d1fd59SEnji Cooper 
177663d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
177763d1fd59SEnji Cooper 	    "without signal to be sent\n");
177863d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
177963d1fd59SEnji Cooper 
178063d1fd59SEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
178163d1fd59SEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
178263d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
178363d1fd59SEnji Cooper 
178463d1fd59SEnji Cooper 	validate_status_stopped(status, SIGCHLD);
178563d1fd59SEnji Cooper 
178663d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
178763d1fd59SEnji Cooper 	    "without signal to be sent\n");
178863d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
178963d1fd59SEnji Cooper 
179063d1fd59SEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
179163d1fd59SEnji Cooper 	    TWAIT_FNAME);
179263d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
179363d1fd59SEnji Cooper 
179463d1fd59SEnji Cooper 	validate_status_exited(status, exitval);
179563d1fd59SEnji Cooper 
179663d1fd59SEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
179763d1fd59SEnji Cooper 	    TWAIT_FNAME);
179863d1fd59SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
179963d1fd59SEnji Cooper }
180063d1fd59SEnji Cooper 
180163d1fd59SEnji Cooper ATF_TC(vforkdone2);
ATF_TC_HEAD(vforkdone2,tc)180263d1fd59SEnji Cooper ATF_TC_HEAD(vforkdone2, tc)
180363d1fd59SEnji Cooper {
180463d1fd59SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
180563d1fd59SEnji Cooper 	    "Verify that vfork(2) is intercepted by ptrace(2) with EVENT_MASK "
180663d1fd59SEnji Cooper 	    "set to PTRACE_FORK | PTRACE_VFORK_DONE");
180763d1fd59SEnji Cooper }
180863d1fd59SEnji Cooper 
ATF_TC_BODY(vforkdone2,tc)180963d1fd59SEnji Cooper ATF_TC_BODY(vforkdone2, tc)
181063d1fd59SEnji Cooper {
181163d1fd59SEnji Cooper 	const int exitval = 5;
181263d1fd59SEnji Cooper 	const int exitval2 = 15;
181363d1fd59SEnji Cooper 	const int sigval = SIGSTOP;
181463d1fd59SEnji Cooper 	pid_t child, child2, wpid;
181563d1fd59SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
181663d1fd59SEnji Cooper 	int status;
181763d1fd59SEnji Cooper #endif
181863d1fd59SEnji Cooper 	ptrace_state_t state;
181963d1fd59SEnji Cooper 	const int slen = sizeof(state);
182063d1fd59SEnji Cooper 	ptrace_event_t event;
182163d1fd59SEnji Cooper 	const int elen = sizeof(event);
182263d1fd59SEnji Cooper 
182363d1fd59SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
182463d1fd59SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
182563d1fd59SEnji Cooper 	if (child == 0) {
182663d1fd59SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
182763d1fd59SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
182863d1fd59SEnji Cooper 
182963d1fd59SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
183063d1fd59SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
183163d1fd59SEnji Cooper 
183263d1fd59SEnji Cooper 		FORKEE_ASSERT((child2 = vfork()) != 1);
183363d1fd59SEnji Cooper 
183463d1fd59SEnji Cooper 		if (child2 == 0)
183563d1fd59SEnji Cooper 			_exit(exitval2);
183663d1fd59SEnji Cooper 
183763d1fd59SEnji Cooper 		FORKEE_REQUIRE_SUCCESS
183863d1fd59SEnji Cooper 		    (wpid = TWAIT_GENERIC(child2, &status, 0), child2);
183963d1fd59SEnji Cooper 
184063d1fd59SEnji Cooper 		forkee_status_exited(status, exitval2);
184163d1fd59SEnji Cooper 
184263d1fd59SEnji Cooper 		printf("Before exiting of the child process\n");
184363d1fd59SEnji Cooper 		_exit(exitval);
184463d1fd59SEnji Cooper 	}
184563d1fd59SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
184663d1fd59SEnji Cooper 
184763d1fd59SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
184863d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
184963d1fd59SEnji Cooper 
185063d1fd59SEnji Cooper 	validate_status_stopped(status, sigval);
185163d1fd59SEnji Cooper 
185263d1fd59SEnji Cooper 	printf("Enable PTRACE_VFORK in EVENT_MASK for the child %d\n", child);
185363d1fd59SEnji Cooper 	event.pe_set_event = PTRACE_FORK | PTRACE_VFORK_DONE;
185463d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
185563d1fd59SEnji Cooper 
185663d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
185763d1fd59SEnji Cooper 	    "without signal to be sent\n");
185863d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
185963d1fd59SEnji Cooper 
186063d1fd59SEnji Cooper 	printf("Before calling %s() for the child %d\n", TWAIT_FNAME, child);
186163d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
186263d1fd59SEnji Cooper 
186363d1fd59SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
186463d1fd59SEnji Cooper 
186563d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
186663d1fd59SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE);
186763d1fd59SEnji Cooper 
186863d1fd59SEnji Cooper 	child2 = state.pe_other_pid;
186963d1fd59SEnji Cooper 	printf("Reported PTRACE_VFORK_DONE event with forkee %d\n", child2);
187063d1fd59SEnji Cooper 
187163d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
187263d1fd59SEnji Cooper 	    "without signal to be sent\n");
187363d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
187463d1fd59SEnji Cooper 
187563d1fd59SEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
187663d1fd59SEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
187763d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
187863d1fd59SEnji Cooper 
187963d1fd59SEnji Cooper 	validate_status_stopped(status, SIGCHLD);
188063d1fd59SEnji Cooper 
188163d1fd59SEnji Cooper 	printf("Before resuming the child process where it left off and "
188263d1fd59SEnji Cooper 	    "without signal to be sent\n");
188363d1fd59SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
188463d1fd59SEnji Cooper 
188563d1fd59SEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
188663d1fd59SEnji Cooper 	    TWAIT_FNAME);
188763d1fd59SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
188863d1fd59SEnji Cooper 
188963d1fd59SEnji Cooper 	validate_status_exited(status, exitval);
189063d1fd59SEnji Cooper 
189163d1fd59SEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
189263d1fd59SEnji Cooper 	    TWAIT_FNAME);
189363d1fd59SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
189463d1fd59SEnji Cooper }
189563d1fd59SEnji Cooper 
1896cdebaff8SEnji Cooper ATF_TC(io_read_d1);
ATF_TC_HEAD(io_read_d1,tc)1897cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_d1, tc)
1898cdebaff8SEnji Cooper {
1899cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1900cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_D and len = sizeof(uint8_t)");
1901cdebaff8SEnji Cooper }
1902cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_d1,tc)1903cdebaff8SEnji Cooper ATF_TC_BODY(io_read_d1, tc)
1904cdebaff8SEnji Cooper {
1905cdebaff8SEnji Cooper 	const int exitval = 5;
1906cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
1907cdebaff8SEnji Cooper 	pid_t child, wpid;
1908cdebaff8SEnji Cooper 	uint8_t lookup_me = 0;
1909cdebaff8SEnji Cooper 	const uint8_t magic = 0xab;
1910cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
1911cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_D,
1912cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
1913cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
1914cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
1915cdebaff8SEnji Cooper 	};
1916cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1917cdebaff8SEnji Cooper 	int status;
1918cdebaff8SEnji Cooper #endif
1919cdebaff8SEnji Cooper 
1920cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1921cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1922cdebaff8SEnji Cooper 	if (child == 0) {
1923cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1924cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1925cdebaff8SEnji Cooper 
1926cdebaff8SEnji Cooper 		lookup_me = magic;
1927cdebaff8SEnji Cooper 
1928cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1929cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1930cdebaff8SEnji Cooper 
1931cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
1932cdebaff8SEnji Cooper 		_exit(exitval);
1933cdebaff8SEnji Cooper 	}
1934cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
1935cdebaff8SEnji Cooper 
1936cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1937cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1938cdebaff8SEnji Cooper 
1939cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
1940cdebaff8SEnji Cooper 
1941cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
1942cdebaff8SEnji Cooper 	    child, getpid());
1943cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
1944cdebaff8SEnji Cooper 
1945cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
1946cdebaff8SEnji Cooper 	    "got value %" PRIx8 " != expected %" PRIx8, lookup_me, magic);
1947cdebaff8SEnji Cooper 
1948cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
1949cdebaff8SEnji Cooper 	    "without signal to be sent\n");
1950cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
1951cdebaff8SEnji Cooper 
1952cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1953cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
1954cdebaff8SEnji Cooper 
1955cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
1956cdebaff8SEnji Cooper 
1957cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
1958cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
1959cdebaff8SEnji Cooper }
1960cdebaff8SEnji Cooper 
1961cdebaff8SEnji Cooper ATF_TC(io_read_d2);
ATF_TC_HEAD(io_read_d2,tc)1962cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_d2, tc)
1963cdebaff8SEnji Cooper {
1964cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
1965cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_D and len = sizeof(uint16_t)");
1966cdebaff8SEnji Cooper }
1967cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_d2,tc)1968cdebaff8SEnji Cooper ATF_TC_BODY(io_read_d2, tc)
1969cdebaff8SEnji Cooper {
1970cdebaff8SEnji Cooper 	const int exitval = 5;
1971cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
1972cdebaff8SEnji Cooper 	pid_t child, wpid;
1973cdebaff8SEnji Cooper 	uint16_t lookup_me = 0;
1974cdebaff8SEnji Cooper 	const uint16_t magic = 0x1234;
1975cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
1976cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_D,
1977cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
1978cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
1979cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
1980cdebaff8SEnji Cooper 	};
1981cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
1982cdebaff8SEnji Cooper 	int status;
1983cdebaff8SEnji Cooper #endif
1984cdebaff8SEnji Cooper 
1985cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
1986cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
1987cdebaff8SEnji Cooper 	if (child == 0) {
1988cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
1989cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
1990cdebaff8SEnji Cooper 
1991cdebaff8SEnji Cooper 		lookup_me = magic;
1992cdebaff8SEnji Cooper 
1993cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
1994cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
1995cdebaff8SEnji Cooper 
1996cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
1997cdebaff8SEnji Cooper 		_exit(exitval);
1998cdebaff8SEnji Cooper 	}
1999cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2000cdebaff8SEnji Cooper 
2001cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2002cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2003cdebaff8SEnji Cooper 
2004cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2005cdebaff8SEnji Cooper 
2006cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
2007cdebaff8SEnji Cooper 	    child, getpid());
2008cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2009cdebaff8SEnji Cooper 
2010cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
2011cdebaff8SEnji Cooper 	    "got value %" PRIx16 " != expected %" PRIx16, lookup_me, magic);
2012cdebaff8SEnji Cooper 
2013cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2014cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2015cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2016cdebaff8SEnji Cooper 
2017cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2018cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2019cdebaff8SEnji Cooper 
2020cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2021cdebaff8SEnji Cooper 
2022cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2023cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2024cdebaff8SEnji Cooper }
2025cdebaff8SEnji Cooper 
2026cdebaff8SEnji Cooper ATF_TC(io_read_d3);
ATF_TC_HEAD(io_read_d3,tc)2027cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_d3, tc)
2028cdebaff8SEnji Cooper {
2029cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2030cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_D and len = sizeof(uint32_t)");
2031cdebaff8SEnji Cooper }
2032cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_d3,tc)2033cdebaff8SEnji Cooper ATF_TC_BODY(io_read_d3, tc)
2034cdebaff8SEnji Cooper {
2035cdebaff8SEnji Cooper 	const int exitval = 5;
2036cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2037cdebaff8SEnji Cooper 	pid_t child, wpid;
2038cdebaff8SEnji Cooper 	uint32_t lookup_me = 0;
2039cdebaff8SEnji Cooper 	const uint32_t magic = 0x1234abcd;
2040cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
2041cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_D,
2042cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
2043cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
2044cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
2045cdebaff8SEnji Cooper 	};
2046cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2047cdebaff8SEnji Cooper 	int status;
2048cdebaff8SEnji Cooper #endif
2049cdebaff8SEnji Cooper 
2050cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2051cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2052cdebaff8SEnji Cooper 	if (child == 0) {
2053cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2054cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2055cdebaff8SEnji Cooper 
2056cdebaff8SEnji Cooper 		lookup_me = magic;
2057cdebaff8SEnji Cooper 
2058cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2059cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2060cdebaff8SEnji Cooper 
2061cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2062cdebaff8SEnji Cooper 		_exit(exitval);
2063cdebaff8SEnji Cooper 	}
2064cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2065cdebaff8SEnji Cooper 
2066cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2067cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2068cdebaff8SEnji Cooper 
2069cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2070cdebaff8SEnji Cooper 
2071cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
2072cdebaff8SEnji Cooper 	    child, getpid());
2073cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2074cdebaff8SEnji Cooper 
2075cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
2076cdebaff8SEnji Cooper 	    "got value %" PRIx32 " != expected %" PRIx32, lookup_me, magic);
2077cdebaff8SEnji Cooper 
2078cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2079cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2080cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2081cdebaff8SEnji Cooper 
2082cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2083cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2084cdebaff8SEnji Cooper 
2085cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2086cdebaff8SEnji Cooper 
2087cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2088cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2089cdebaff8SEnji Cooper }
2090cdebaff8SEnji Cooper 
2091cdebaff8SEnji Cooper ATF_TC(io_read_d4);
ATF_TC_HEAD(io_read_d4,tc)2092cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_d4, tc)
2093cdebaff8SEnji Cooper {
2094cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2095cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_D and len = sizeof(uint64_t)");
2096cdebaff8SEnji Cooper }
2097cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_d4,tc)2098cdebaff8SEnji Cooper ATF_TC_BODY(io_read_d4, tc)
2099cdebaff8SEnji Cooper {
2100cdebaff8SEnji Cooper 	const int exitval = 5;
2101cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2102cdebaff8SEnji Cooper 	pid_t child, wpid;
2103cdebaff8SEnji Cooper 	uint64_t lookup_me = 0;
2104cdebaff8SEnji Cooper 	const uint64_t magic = 0x1234abcd9876dcfa;
2105cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
2106cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_D,
2107cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
2108cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
2109cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
2110cdebaff8SEnji Cooper 	};
2111cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2112cdebaff8SEnji Cooper 	int status;
2113cdebaff8SEnji Cooper #endif
2114cdebaff8SEnji Cooper 
2115cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2116cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2117cdebaff8SEnji Cooper 	if (child == 0) {
2118cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2119cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2120cdebaff8SEnji Cooper 
2121cdebaff8SEnji Cooper 		lookup_me = magic;
2122cdebaff8SEnji Cooper 
2123cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2124cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2125cdebaff8SEnji Cooper 
2126cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2127cdebaff8SEnji Cooper 		_exit(exitval);
2128cdebaff8SEnji Cooper 	}
2129cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2130cdebaff8SEnji Cooper 
2131cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2132cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2133cdebaff8SEnji Cooper 
2134cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2135cdebaff8SEnji Cooper 
2136cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
2137cdebaff8SEnji Cooper 	    child, getpid());
2138cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2139cdebaff8SEnji Cooper 
2140cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
2141cdebaff8SEnji Cooper 	    "got value %" PRIx64 " != expected %" PRIx64, lookup_me, magic);
2142cdebaff8SEnji Cooper 
2143cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2144cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2145cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2146cdebaff8SEnji Cooper 
2147cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2148cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2149cdebaff8SEnji Cooper 
2150cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2151cdebaff8SEnji Cooper 
2152cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2153cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2154cdebaff8SEnji Cooper }
2155cdebaff8SEnji Cooper 
2156cdebaff8SEnji Cooper ATF_TC(io_write_d1);
ATF_TC_HEAD(io_write_d1,tc)2157cdebaff8SEnji Cooper ATF_TC_HEAD(io_write_d1, tc)
2158cdebaff8SEnji Cooper {
2159cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2160cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_WRITE_D and len = sizeof(uint8_t)");
2161cdebaff8SEnji Cooper }
2162cdebaff8SEnji Cooper 
ATF_TC_BODY(io_write_d1,tc)2163cdebaff8SEnji Cooper ATF_TC_BODY(io_write_d1, tc)
2164cdebaff8SEnji Cooper {
2165cdebaff8SEnji Cooper 	const int exitval = 5;
2166cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2167cdebaff8SEnji Cooper 	pid_t child, wpid;
2168cdebaff8SEnji Cooper 	uint8_t lookup_me = 0;
2169cdebaff8SEnji Cooper 	const uint8_t magic = 0xab;
2170cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
2171cdebaff8SEnji Cooper 		.piod_op = PIOD_WRITE_D,
2172cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
2173cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
2174cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
2175cdebaff8SEnji Cooper 	};
2176cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2177cdebaff8SEnji Cooper 	int status;
2178cdebaff8SEnji Cooper #endif
2179cdebaff8SEnji Cooper 
2180cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2181cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2182cdebaff8SEnji Cooper 	if (child == 0) {
2183cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2184cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2185cdebaff8SEnji Cooper 
2186cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2187cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2188cdebaff8SEnji Cooper 
2189cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me, magic);
2190cdebaff8SEnji Cooper 
2191cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2192cdebaff8SEnji Cooper 		_exit(exitval);
2193cdebaff8SEnji Cooper 	}
2194cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2195cdebaff8SEnji Cooper 
2196cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2197cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2198cdebaff8SEnji Cooper 
2199cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2200cdebaff8SEnji Cooper 
2201cdebaff8SEnji Cooper 	lookup_me = magic;
2202cdebaff8SEnji Cooper 
2203cdebaff8SEnji Cooper 	printf("Write new lookup_me to tracee (PID=%d) from tracer (PID=%d)\n",
2204cdebaff8SEnji Cooper 	    child, getpid());
2205cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2206cdebaff8SEnji Cooper 
2207cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2208cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2209cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2210cdebaff8SEnji Cooper 
2211cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2212cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2213cdebaff8SEnji Cooper 
2214cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2215cdebaff8SEnji Cooper 
2216cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2217cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2218cdebaff8SEnji Cooper }
2219cdebaff8SEnji Cooper 
2220cdebaff8SEnji Cooper ATF_TC(io_write_d2);
ATF_TC_HEAD(io_write_d2,tc)2221cdebaff8SEnji Cooper ATF_TC_HEAD(io_write_d2, tc)
2222cdebaff8SEnji Cooper {
2223cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2224cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_WRITE_D and len = sizeof(uint16_t)");
2225cdebaff8SEnji Cooper }
2226cdebaff8SEnji Cooper 
ATF_TC_BODY(io_write_d2,tc)2227cdebaff8SEnji Cooper ATF_TC_BODY(io_write_d2, tc)
2228cdebaff8SEnji Cooper {
2229cdebaff8SEnji Cooper 	const int exitval = 5;
2230cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2231cdebaff8SEnji Cooper 	pid_t child, wpid;
2232cdebaff8SEnji Cooper 	uint16_t lookup_me = 0;
2233cdebaff8SEnji Cooper 	const uint16_t magic = 0xab12;
2234cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
2235cdebaff8SEnji Cooper 		.piod_op = PIOD_WRITE_D,
2236cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
2237cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
2238cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
2239cdebaff8SEnji Cooper 	};
2240cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2241cdebaff8SEnji Cooper 	int status;
2242cdebaff8SEnji Cooper #endif
2243cdebaff8SEnji Cooper 
2244cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2245cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2246cdebaff8SEnji Cooper 	if (child == 0) {
2247cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2248cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2249cdebaff8SEnji Cooper 
2250cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2251cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2252cdebaff8SEnji Cooper 
2253cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me, magic);
2254cdebaff8SEnji Cooper 
2255cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2256cdebaff8SEnji Cooper 		_exit(exitval);
2257cdebaff8SEnji Cooper 	}
2258cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2259cdebaff8SEnji Cooper 
2260cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2261cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2262cdebaff8SEnji Cooper 
2263cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2264cdebaff8SEnji Cooper 
2265cdebaff8SEnji Cooper 	lookup_me = magic;
2266cdebaff8SEnji Cooper 
2267cdebaff8SEnji Cooper 	printf("Write new lookup_me to tracee (PID=%d) from tracer (PID=%d)\n",
2268cdebaff8SEnji Cooper 	    child, getpid());
2269cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2270cdebaff8SEnji Cooper 
2271cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2272cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2273cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2274cdebaff8SEnji Cooper 
2275cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2276cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2277cdebaff8SEnji Cooper 
2278cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2279cdebaff8SEnji Cooper 
2280cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2281cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2282cdebaff8SEnji Cooper }
2283cdebaff8SEnji Cooper 
2284cdebaff8SEnji Cooper ATF_TC(io_write_d3);
ATF_TC_HEAD(io_write_d3,tc)2285cdebaff8SEnji Cooper ATF_TC_HEAD(io_write_d3, tc)
2286cdebaff8SEnji Cooper {
2287cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2288cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_WRITE_D and len = sizeof(uint32_t)");
2289cdebaff8SEnji Cooper }
2290cdebaff8SEnji Cooper 
ATF_TC_BODY(io_write_d3,tc)2291cdebaff8SEnji Cooper ATF_TC_BODY(io_write_d3, tc)
2292cdebaff8SEnji Cooper {
2293cdebaff8SEnji Cooper 	const int exitval = 5;
2294cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2295cdebaff8SEnji Cooper 	pid_t child, wpid;
2296cdebaff8SEnji Cooper 	uint32_t lookup_me = 0;
2297cdebaff8SEnji Cooper 	const uint32_t magic = 0xab127643;
2298cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
2299cdebaff8SEnji Cooper 		.piod_op = PIOD_WRITE_D,
2300cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
2301cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
2302cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
2303cdebaff8SEnji Cooper 	};
2304cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2305cdebaff8SEnji Cooper 	int status;
2306cdebaff8SEnji Cooper #endif
2307cdebaff8SEnji Cooper 
2308cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2309cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2310cdebaff8SEnji Cooper 	if (child == 0) {
2311cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2312cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2313cdebaff8SEnji Cooper 
2314cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2315cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2316cdebaff8SEnji Cooper 
2317cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me, magic);
2318cdebaff8SEnji Cooper 
2319cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2320cdebaff8SEnji Cooper 		_exit(exitval);
2321cdebaff8SEnji Cooper 	}
2322cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2323cdebaff8SEnji Cooper 
2324cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2325cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2326cdebaff8SEnji Cooper 
2327cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2328cdebaff8SEnji Cooper 
2329cdebaff8SEnji Cooper 	lookup_me = magic;
2330cdebaff8SEnji Cooper 
2331cdebaff8SEnji Cooper 	printf("Write new lookup_me to tracee (PID=%d) from tracer (PID=%d)\n",
2332cdebaff8SEnji Cooper 	    child, getpid());
2333cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2334cdebaff8SEnji Cooper 
2335cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2336cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2337cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2338cdebaff8SEnji Cooper 
2339cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2340cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2341cdebaff8SEnji Cooper 
2342cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2343cdebaff8SEnji Cooper 
2344cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2345cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2346cdebaff8SEnji Cooper }
2347cdebaff8SEnji Cooper 
2348cdebaff8SEnji Cooper ATF_TC(io_write_d4);
ATF_TC_HEAD(io_write_d4,tc)2349cdebaff8SEnji Cooper ATF_TC_HEAD(io_write_d4, tc)
2350cdebaff8SEnji Cooper {
2351cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2352cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_WRITE_D and len = sizeof(uint64_t)");
2353cdebaff8SEnji Cooper }
2354cdebaff8SEnji Cooper 
ATF_TC_BODY(io_write_d4,tc)2355cdebaff8SEnji Cooper ATF_TC_BODY(io_write_d4, tc)
2356cdebaff8SEnji Cooper {
2357cdebaff8SEnji Cooper 	const int exitval = 5;
2358cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2359cdebaff8SEnji Cooper 	pid_t child, wpid;
2360cdebaff8SEnji Cooper 	uint64_t lookup_me = 0;
2361cdebaff8SEnji Cooper 	const uint64_t magic = 0xab12764376490123;
2362cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
2363cdebaff8SEnji Cooper 		.piod_op = PIOD_WRITE_D,
2364cdebaff8SEnji Cooper 		.piod_offs = &lookup_me,
2365cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
2366cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
2367cdebaff8SEnji Cooper 	};
2368cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2369cdebaff8SEnji Cooper 	int status;
2370cdebaff8SEnji Cooper #endif
2371cdebaff8SEnji Cooper 
2372cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2373cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2374cdebaff8SEnji Cooper 	if (child == 0) {
2375cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2376cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2377cdebaff8SEnji Cooper 
2378cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2379cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2380cdebaff8SEnji Cooper 
2381cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me, magic);
2382cdebaff8SEnji Cooper 
2383cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2384cdebaff8SEnji Cooper 		_exit(exitval);
2385cdebaff8SEnji Cooper 	}
2386cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2387cdebaff8SEnji Cooper 
2388cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2389cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2390cdebaff8SEnji Cooper 
2391cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2392cdebaff8SEnji Cooper 
2393cdebaff8SEnji Cooper 	lookup_me = magic;
2394cdebaff8SEnji Cooper 
2395cdebaff8SEnji Cooper 	printf("Write new lookup_me to tracee (PID=%d) from tracer (PID=%d)\n",
2396cdebaff8SEnji Cooper 	    child, getpid());
2397cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2398cdebaff8SEnji Cooper 
2399cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2400cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2401cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2402cdebaff8SEnji Cooper 
2403cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2404cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2405cdebaff8SEnji Cooper 
2406cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2407cdebaff8SEnji Cooper 
2408cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2409cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2410cdebaff8SEnji Cooper }
2411cdebaff8SEnji Cooper 
2412*dd66b5baSEnji Cooper ATF_TC(io_read_auxv1);
ATF_TC_HEAD(io_read_auxv1,tc)2413*dd66b5baSEnji Cooper ATF_TC_HEAD(io_read_auxv1, tc)
2414*dd66b5baSEnji Cooper {
2415*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2416*dd66b5baSEnji Cooper 	    "Verify PT_READ_AUXV called for tracee");
2417*dd66b5baSEnji Cooper }
2418*dd66b5baSEnji Cooper 
ATF_TC_BODY(io_read_auxv1,tc)2419*dd66b5baSEnji Cooper ATF_TC_BODY(io_read_auxv1, tc)
2420*dd66b5baSEnji Cooper {
2421*dd66b5baSEnji Cooper 	const int exitval = 5;
2422*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
2423*dd66b5baSEnji Cooper 	pid_t child, wpid;
2424*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2425*dd66b5baSEnji Cooper 	int status;
2426*dd66b5baSEnji Cooper #endif
2427*dd66b5baSEnji Cooper 	AuxInfo ai[100], *aip;
2428*dd66b5baSEnji Cooper 	struct ptrace_io_desc io = {
2429*dd66b5baSEnji Cooper 		.piod_op = PIOD_READ_AUXV,
2430*dd66b5baSEnji Cooper 		.piod_offs = 0,
2431*dd66b5baSEnji Cooper 		.piod_addr = ai,
2432*dd66b5baSEnji Cooper 		.piod_len = sizeof(ai)
2433*dd66b5baSEnji Cooper 	};
2434*dd66b5baSEnji Cooper 
2435*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2436*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2437*dd66b5baSEnji Cooper 	if (child == 0) {
2438*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2439*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2440*dd66b5baSEnji Cooper 
2441*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2442*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2443*dd66b5baSEnji Cooper 
2444*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
2445*dd66b5baSEnji Cooper 		_exit(exitval);
2446*dd66b5baSEnji Cooper 	}
2447*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2448*dd66b5baSEnji Cooper 
2449*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2450*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2451*dd66b5baSEnji Cooper 
2452*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
2453*dd66b5baSEnji Cooper 
2454*dd66b5baSEnji Cooper 	printf("Read new AUXV from tracee (PID=%d) by tracer (PID=%d)\n",
2455*dd66b5baSEnji Cooper 	    child, getpid());
2456*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
2457*dd66b5baSEnji Cooper 
2458*dd66b5baSEnji Cooper 	printf("Asserting that AUXV length (%zu) is > 0\n", io.piod_len);
2459*dd66b5baSEnji Cooper 	ATF_REQUIRE(io.piod_len > 0);
2460*dd66b5baSEnji Cooper 
2461*dd66b5baSEnji Cooper 	for (aip = ai; aip->a_type != AT_NULL; aip++)
2462*dd66b5baSEnji Cooper 		printf("a_type=%#llx a_v=%#llx\n",
2463*dd66b5baSEnji Cooper 		    (long long int)aip->a_type, (long long int)aip->a_v);
2464*dd66b5baSEnji Cooper 
2465*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
2466*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
2467*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2468*dd66b5baSEnji Cooper 
2469*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2470*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2471*dd66b5baSEnji Cooper 
2472*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
2473*dd66b5baSEnji Cooper 
2474*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2475*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2476*dd66b5baSEnji Cooper }
2477*dd66b5baSEnji Cooper 
2478cdebaff8SEnji Cooper ATF_TC(read_d1);
ATF_TC_HEAD(read_d1,tc)2479cdebaff8SEnji Cooper ATF_TC_HEAD(read_d1, tc)
2480cdebaff8SEnji Cooper {
2481cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2482cdebaff8SEnji Cooper 	    "Verify PT_READ_D called once");
2483cdebaff8SEnji Cooper }
2484cdebaff8SEnji Cooper 
ATF_TC_BODY(read_d1,tc)2485cdebaff8SEnji Cooper ATF_TC_BODY(read_d1, tc)
2486cdebaff8SEnji Cooper {
2487cdebaff8SEnji Cooper 	const int exitval = 5;
2488cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2489cdebaff8SEnji Cooper 	pid_t child, wpid;
2490cdebaff8SEnji Cooper 	int lookup_me = 0;
2491cdebaff8SEnji Cooper 	const int magic = (int)random();
2492cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2493cdebaff8SEnji Cooper 	int status;
2494cdebaff8SEnji Cooper #endif
2495cdebaff8SEnji Cooper 
2496cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2497cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2498cdebaff8SEnji Cooper 	if (child == 0) {
2499cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2500cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2501cdebaff8SEnji Cooper 
2502cdebaff8SEnji Cooper 		lookup_me = magic;
2503cdebaff8SEnji Cooper 
2504cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2505cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2506cdebaff8SEnji Cooper 
2507cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2508cdebaff8SEnji Cooper 		_exit(exitval);
2509cdebaff8SEnji Cooper 	}
2510cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2511cdebaff8SEnji Cooper 
2512cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2513cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2514cdebaff8SEnji Cooper 
2515cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2516cdebaff8SEnji Cooper 
2517cdebaff8SEnji Cooper 	printf("Read new lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
2518cdebaff8SEnji Cooper 	    child, getpid());
2519cdebaff8SEnji Cooper 	errno = 0;
2520cdebaff8SEnji Cooper 	lookup_me = ptrace(PT_READ_D, child, &lookup_me, 0);
2521cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2522cdebaff8SEnji Cooper 
2523cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
2524cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me, magic);
2525cdebaff8SEnji Cooper 
2526cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2527cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2528cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2529cdebaff8SEnji Cooper 
2530cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2531cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2532cdebaff8SEnji Cooper 
2533cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2534cdebaff8SEnji Cooper 
2535cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2536cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2537cdebaff8SEnji Cooper }
2538cdebaff8SEnji Cooper 
2539cdebaff8SEnji Cooper ATF_TC(read_d2);
ATF_TC_HEAD(read_d2,tc)2540cdebaff8SEnji Cooper ATF_TC_HEAD(read_d2, tc)
2541cdebaff8SEnji Cooper {
2542cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2543cdebaff8SEnji Cooper 	    "Verify PT_READ_D called twice");
2544cdebaff8SEnji Cooper }
2545cdebaff8SEnji Cooper 
ATF_TC_BODY(read_d2,tc)2546cdebaff8SEnji Cooper ATF_TC_BODY(read_d2, tc)
2547cdebaff8SEnji Cooper {
2548cdebaff8SEnji Cooper 	const int exitval = 5;
2549cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2550cdebaff8SEnji Cooper 	pid_t child, wpid;
2551cdebaff8SEnji Cooper 	int lookup_me1 = 0;
2552cdebaff8SEnji Cooper 	int lookup_me2 = 0;
2553cdebaff8SEnji Cooper 	const int magic1 = (int)random();
2554cdebaff8SEnji Cooper 	const int magic2 = (int)random();
2555cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2556cdebaff8SEnji Cooper 	int status;
2557cdebaff8SEnji Cooper #endif
2558cdebaff8SEnji Cooper 
2559cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2560cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2561cdebaff8SEnji Cooper 	if (child == 0) {
2562cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2563cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2564cdebaff8SEnji Cooper 
2565cdebaff8SEnji Cooper 		lookup_me1 = magic1;
2566cdebaff8SEnji Cooper 		lookup_me2 = magic2;
2567cdebaff8SEnji Cooper 
2568cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2569cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2570cdebaff8SEnji Cooper 
2571cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2572cdebaff8SEnji Cooper 		_exit(exitval);
2573cdebaff8SEnji Cooper 	}
2574cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2575cdebaff8SEnji Cooper 
2576cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2577cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2578cdebaff8SEnji Cooper 
2579cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2580cdebaff8SEnji Cooper 
2581cdebaff8SEnji Cooper 	printf("Read new lookup_me1 from tracee (PID=%d) by tracer (PID=%d)\n",
2582cdebaff8SEnji Cooper 	    child, getpid());
2583cdebaff8SEnji Cooper 	errno = 0;
2584cdebaff8SEnji Cooper 	lookup_me1 = ptrace(PT_READ_D, child, &lookup_me1, 0);
2585cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2586cdebaff8SEnji Cooper 
2587cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me1, magic1,
2588cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me1, magic1);
2589cdebaff8SEnji Cooper 
2590cdebaff8SEnji Cooper 	printf("Read new lookup_me2 from tracee (PID=%d) by tracer (PID=%d)\n",
2591cdebaff8SEnji Cooper 	    child, getpid());
2592cdebaff8SEnji Cooper 	errno = 0;
2593cdebaff8SEnji Cooper 	lookup_me2 = ptrace(PT_READ_D, child, &lookup_me2, 0);
2594cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2595cdebaff8SEnji Cooper 
2596cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me2, magic2,
2597cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me2, magic2);
2598cdebaff8SEnji Cooper 
2599cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2600cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2601cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2602cdebaff8SEnji Cooper 
2603cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2604cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2605cdebaff8SEnji Cooper 
2606cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2607cdebaff8SEnji Cooper 
2608cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2609cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2610cdebaff8SEnji Cooper }
2611cdebaff8SEnji Cooper 
2612cdebaff8SEnji Cooper ATF_TC(read_d3);
ATF_TC_HEAD(read_d3,tc)2613cdebaff8SEnji Cooper ATF_TC_HEAD(read_d3, tc)
2614cdebaff8SEnji Cooper {
2615cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2616cdebaff8SEnji Cooper 	    "Verify PT_READ_D called three times");
2617cdebaff8SEnji Cooper }
2618cdebaff8SEnji Cooper 
ATF_TC_BODY(read_d3,tc)2619cdebaff8SEnji Cooper ATF_TC_BODY(read_d3, tc)
2620cdebaff8SEnji Cooper {
2621cdebaff8SEnji Cooper 	const int exitval = 5;
2622cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2623cdebaff8SEnji Cooper 	pid_t child, wpid;
2624cdebaff8SEnji Cooper 	int lookup_me1 = 0;
2625cdebaff8SEnji Cooper 	int lookup_me2 = 0;
2626cdebaff8SEnji Cooper 	int lookup_me3 = 0;
2627cdebaff8SEnji Cooper 	const int magic1 = (int)random();
2628cdebaff8SEnji Cooper 	const int magic2 = (int)random();
2629cdebaff8SEnji Cooper 	const int magic3 = (int)random();
2630cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2631cdebaff8SEnji Cooper 	int status;
2632cdebaff8SEnji Cooper #endif
2633cdebaff8SEnji Cooper 
2634cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2635cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2636cdebaff8SEnji Cooper 	if (child == 0) {
2637cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2638cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2639cdebaff8SEnji Cooper 
2640cdebaff8SEnji Cooper 		lookup_me1 = magic1;
2641cdebaff8SEnji Cooper 		lookup_me2 = magic2;
2642cdebaff8SEnji Cooper 		lookup_me3 = magic3;
2643cdebaff8SEnji Cooper 
2644cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2645cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2646cdebaff8SEnji Cooper 
2647cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2648cdebaff8SEnji Cooper 		_exit(exitval);
2649cdebaff8SEnji Cooper 	}
2650cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2651cdebaff8SEnji Cooper 
2652cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2653cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2654cdebaff8SEnji Cooper 
2655cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2656cdebaff8SEnji Cooper 
2657cdebaff8SEnji Cooper 	printf("Read new lookup_me1 from tracee (PID=%d) by tracer (PID=%d)\n",
2658cdebaff8SEnji Cooper 	    child, getpid());
2659cdebaff8SEnji Cooper 	errno = 0;
2660cdebaff8SEnji Cooper 	lookup_me1 = ptrace(PT_READ_D, child, &lookup_me1, 0);
2661cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2662cdebaff8SEnji Cooper 
2663cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me1, magic1,
2664cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me1, magic1);
2665cdebaff8SEnji Cooper 
2666cdebaff8SEnji Cooper 	printf("Read new lookup_me2 from tracee (PID=%d) by tracer (PID=%d)\n",
2667cdebaff8SEnji Cooper 	    child, getpid());
2668cdebaff8SEnji Cooper 	errno = 0;
2669cdebaff8SEnji Cooper 	lookup_me2 = ptrace(PT_READ_D, child, &lookup_me2, 0);
2670cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2671cdebaff8SEnji Cooper 
2672cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me2, magic2,
2673cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me2, magic2);
2674cdebaff8SEnji Cooper 
2675cdebaff8SEnji Cooper 	printf("Read new lookup_me3 from tracee (PID=%d) by tracer (PID=%d)\n",
2676cdebaff8SEnji Cooper 	    child, getpid());
2677cdebaff8SEnji Cooper 	errno = 0;
2678cdebaff8SEnji Cooper 	lookup_me3 = ptrace(PT_READ_D, child, &lookup_me3, 0);
2679cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2680cdebaff8SEnji Cooper 
2681cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me3, magic3,
2682cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me3, magic3);
2683cdebaff8SEnji Cooper 
2684cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2685cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2686cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2687cdebaff8SEnji Cooper 
2688cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2689cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2690cdebaff8SEnji Cooper 
2691cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2692cdebaff8SEnji Cooper 
2693cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2694cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2695cdebaff8SEnji Cooper }
2696cdebaff8SEnji Cooper 
2697cdebaff8SEnji Cooper ATF_TC(read_d4);
ATF_TC_HEAD(read_d4,tc)2698cdebaff8SEnji Cooper ATF_TC_HEAD(read_d4, tc)
2699cdebaff8SEnji Cooper {
2700cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2701cdebaff8SEnji Cooper 	    "Verify PT_READ_D called four times");
2702cdebaff8SEnji Cooper }
2703cdebaff8SEnji Cooper 
ATF_TC_BODY(read_d4,tc)2704cdebaff8SEnji Cooper ATF_TC_BODY(read_d4, tc)
2705cdebaff8SEnji Cooper {
2706cdebaff8SEnji Cooper 	const int exitval = 5;
2707cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2708cdebaff8SEnji Cooper 	pid_t child, wpid;
2709cdebaff8SEnji Cooper 	int lookup_me1 = 0;
2710cdebaff8SEnji Cooper 	int lookup_me2 = 0;
2711cdebaff8SEnji Cooper 	int lookup_me3 = 0;
2712cdebaff8SEnji Cooper 	int lookup_me4 = 0;
2713cdebaff8SEnji Cooper 	const int magic1 = (int)random();
2714cdebaff8SEnji Cooper 	const int magic2 = (int)random();
2715cdebaff8SEnji Cooper 	const int magic3 = (int)random();
2716cdebaff8SEnji Cooper 	const int magic4 = (int)random();
2717cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2718cdebaff8SEnji Cooper 	int status;
2719cdebaff8SEnji Cooper #endif
2720cdebaff8SEnji Cooper 
2721cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2722cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2723cdebaff8SEnji Cooper 	if (child == 0) {
2724cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2725cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2726cdebaff8SEnji Cooper 
2727cdebaff8SEnji Cooper 		lookup_me1 = magic1;
2728cdebaff8SEnji Cooper 		lookup_me2 = magic2;
2729cdebaff8SEnji Cooper 		lookup_me3 = magic3;
2730cdebaff8SEnji Cooper 		lookup_me4 = magic4;
2731cdebaff8SEnji Cooper 
2732cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2733cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2734cdebaff8SEnji Cooper 
2735cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2736cdebaff8SEnji Cooper 		_exit(exitval);
2737cdebaff8SEnji Cooper 	}
2738cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2739cdebaff8SEnji Cooper 
2740cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2741cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2742cdebaff8SEnji Cooper 
2743cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2744cdebaff8SEnji Cooper 
2745cdebaff8SEnji Cooper 	printf("Read new lookup_me1 from tracee (PID=%d) by tracer (PID=%d)\n",
2746cdebaff8SEnji Cooper 	    child, getpid());
2747cdebaff8SEnji Cooper 	errno = 0;
2748cdebaff8SEnji Cooper 	lookup_me1 = ptrace(PT_READ_D, child, &lookup_me1, 0);
2749cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2750cdebaff8SEnji Cooper 
2751cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me1, magic1,
2752cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me1, magic1);
2753cdebaff8SEnji Cooper 
2754cdebaff8SEnji Cooper 	printf("Read new lookup_me2 from tracee (PID=%d) by tracer (PID=%d)\n",
2755cdebaff8SEnji Cooper 	    child, getpid());
2756cdebaff8SEnji Cooper 	errno = 0;
2757cdebaff8SEnji Cooper 	lookup_me2 = ptrace(PT_READ_D, child, &lookup_me2, 0);
2758cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2759cdebaff8SEnji Cooper 
2760cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me2, magic2,
2761cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me2, magic2);
2762cdebaff8SEnji Cooper 
2763cdebaff8SEnji Cooper 	printf("Read new lookup_me3 from tracee (PID=%d) by tracer (PID=%d)\n",
2764cdebaff8SEnji Cooper 	    child, getpid());
2765cdebaff8SEnji Cooper 	errno = 0;
2766cdebaff8SEnji Cooper 	lookup_me3 = ptrace(PT_READ_D, child, &lookup_me3, 0);
2767cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2768cdebaff8SEnji Cooper 
2769cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me3, magic3,
2770cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me3, magic3);
2771cdebaff8SEnji Cooper 
2772cdebaff8SEnji Cooper 	printf("Read new lookup_me4 from tracee (PID=%d) by tracer (PID=%d)\n",
2773cdebaff8SEnji Cooper 	    child, getpid());
2774cdebaff8SEnji Cooper 	errno = 0;
2775cdebaff8SEnji Cooper 	lookup_me4 = ptrace(PT_READ_D, child, &lookup_me4, 0);
2776cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
2777cdebaff8SEnji Cooper 
2778cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me4, magic4,
2779cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me4, magic4);
2780cdebaff8SEnji Cooper 
2781cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2782cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2783cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2784cdebaff8SEnji Cooper 
2785cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2786cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2787cdebaff8SEnji Cooper 
2788cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2789cdebaff8SEnji Cooper 
2790cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2791cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2792cdebaff8SEnji Cooper }
2793cdebaff8SEnji Cooper 
2794cdebaff8SEnji Cooper ATF_TC(write_d1);
ATF_TC_HEAD(write_d1,tc)2795cdebaff8SEnji Cooper ATF_TC_HEAD(write_d1, tc)
2796cdebaff8SEnji Cooper {
2797cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2798cdebaff8SEnji Cooper 	    "Verify PT_WRITE_D called once");
2799cdebaff8SEnji Cooper }
2800cdebaff8SEnji Cooper 
ATF_TC_BODY(write_d1,tc)2801cdebaff8SEnji Cooper ATF_TC_BODY(write_d1, tc)
2802cdebaff8SEnji Cooper {
2803cdebaff8SEnji Cooper 	const int exitval = 5;
2804cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2805cdebaff8SEnji Cooper 	pid_t child, wpid;
2806cdebaff8SEnji Cooper 	int lookup_me = 0;
2807cdebaff8SEnji Cooper 	const int magic = (int)random();
2808cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2809cdebaff8SEnji Cooper 	int status;
2810cdebaff8SEnji Cooper #endif
2811cdebaff8SEnji Cooper 
2812cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2813cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2814cdebaff8SEnji Cooper 	if (child == 0) {
2815cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2816cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2817cdebaff8SEnji Cooper 
2818cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2819cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2820cdebaff8SEnji Cooper 
2821cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me, magic);
2822cdebaff8SEnji Cooper 
2823cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2824cdebaff8SEnji Cooper 		_exit(exitval);
2825cdebaff8SEnji Cooper 	}
2826cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2827cdebaff8SEnji Cooper 
2828cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2829cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2830cdebaff8SEnji Cooper 
2831cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2832cdebaff8SEnji Cooper 
2833cdebaff8SEnji Cooper 	printf("Write new lookup_me to tracee (PID=%d) from tracer (PID=%d)\n",
2834cdebaff8SEnji Cooper 	    child, getpid());
2835cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me, magic) != -1);
2836cdebaff8SEnji Cooper 
2837cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2838cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2839cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2840cdebaff8SEnji Cooper 
2841cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2842cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2843cdebaff8SEnji Cooper 
2844cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2845cdebaff8SEnji Cooper 
2846cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2847cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2848cdebaff8SEnji Cooper }
2849cdebaff8SEnji Cooper 
2850cdebaff8SEnji Cooper ATF_TC(write_d2);
ATF_TC_HEAD(write_d2,tc)2851cdebaff8SEnji Cooper ATF_TC_HEAD(write_d2, tc)
2852cdebaff8SEnji Cooper {
2853cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2854cdebaff8SEnji Cooper 	    "Verify PT_WRITE_D called twice");
2855cdebaff8SEnji Cooper }
2856cdebaff8SEnji Cooper 
ATF_TC_BODY(write_d2,tc)2857cdebaff8SEnji Cooper ATF_TC_BODY(write_d2, tc)
2858cdebaff8SEnji Cooper {
2859cdebaff8SEnji Cooper 	const int exitval = 5;
2860cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2861cdebaff8SEnji Cooper 	pid_t child, wpid;
2862cdebaff8SEnji Cooper 	int lookup_me1 = 0;
2863cdebaff8SEnji Cooper 	int lookup_me2 = 0;
2864cdebaff8SEnji Cooper 	const int magic1 = (int)random();
2865cdebaff8SEnji Cooper 	const int magic2 = (int)random();
2866cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2867cdebaff8SEnji Cooper 	int status;
2868cdebaff8SEnji Cooper #endif
2869cdebaff8SEnji Cooper 
2870cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2871cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2872cdebaff8SEnji Cooper 	if (child == 0) {
2873cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2874cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2875cdebaff8SEnji Cooper 
2876cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2877cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2878cdebaff8SEnji Cooper 
2879cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me1, magic1);
2880cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me2, magic2);
2881cdebaff8SEnji Cooper 
2882cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2883cdebaff8SEnji Cooper 		_exit(exitval);
2884cdebaff8SEnji Cooper 	}
2885cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2886cdebaff8SEnji Cooper 
2887cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2888cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2889cdebaff8SEnji Cooper 
2890cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2891cdebaff8SEnji Cooper 
2892cdebaff8SEnji Cooper 	printf("Write new lookup_me1 to tracee (PID=%d) from tracer (PID=%d)\n",
2893cdebaff8SEnji Cooper 	    child, getpid());
2894cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me1, magic1) != -1);
2895cdebaff8SEnji Cooper 
2896cdebaff8SEnji Cooper 	printf("Write new lookup_me2 to tracee (PID=%d) from tracer (PID=%d)\n",
2897cdebaff8SEnji Cooper 	    child, getpid());
2898cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me2, magic2) != -1);
2899cdebaff8SEnji Cooper 
2900cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2901cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2902cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2903cdebaff8SEnji Cooper 
2904cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2905cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2906cdebaff8SEnji Cooper 
2907cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2908cdebaff8SEnji Cooper 
2909cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2910cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2911cdebaff8SEnji Cooper }
2912cdebaff8SEnji Cooper 
2913cdebaff8SEnji Cooper ATF_TC(write_d3);
ATF_TC_HEAD(write_d3,tc)2914cdebaff8SEnji Cooper ATF_TC_HEAD(write_d3, tc)
2915cdebaff8SEnji Cooper {
2916cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2917cdebaff8SEnji Cooper 	    "Verify PT_WRITE_D called three times");
2918cdebaff8SEnji Cooper }
2919cdebaff8SEnji Cooper 
ATF_TC_BODY(write_d3,tc)2920cdebaff8SEnji Cooper ATF_TC_BODY(write_d3, tc)
2921cdebaff8SEnji Cooper {
2922cdebaff8SEnji Cooper 	const int exitval = 5;
2923cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2924cdebaff8SEnji Cooper 	pid_t child, wpid;
2925cdebaff8SEnji Cooper 	int lookup_me1 = 0;
2926cdebaff8SEnji Cooper 	int lookup_me2 = 0;
2927cdebaff8SEnji Cooper 	int lookup_me3 = 0;
2928cdebaff8SEnji Cooper 	const int magic1 = (int)random();
2929cdebaff8SEnji Cooper 	const int magic2 = (int)random();
2930cdebaff8SEnji Cooper 	const int magic3 = (int)random();
2931cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
2932cdebaff8SEnji Cooper 	int status;
2933cdebaff8SEnji Cooper #endif
2934cdebaff8SEnji Cooper 
2935cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
2936cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
2937cdebaff8SEnji Cooper 	if (child == 0) {
2938cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
2939cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2940cdebaff8SEnji Cooper 
2941cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
2942cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
2943cdebaff8SEnji Cooper 
2944cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me1, magic1);
2945cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me2, magic2);
2946cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me3, magic3);
2947cdebaff8SEnji Cooper 
2948cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
2949cdebaff8SEnji Cooper 		_exit(exitval);
2950cdebaff8SEnji Cooper 	}
2951cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
2952cdebaff8SEnji Cooper 
2953cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2954cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2955cdebaff8SEnji Cooper 
2956cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
2957cdebaff8SEnji Cooper 
2958cdebaff8SEnji Cooper 	printf("Write new lookup_me1 to tracee (PID=%d) from tracer (PID=%d)\n",
2959cdebaff8SEnji Cooper 	    child, getpid());
2960cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me1, magic1) != -1);
2961cdebaff8SEnji Cooper 
2962cdebaff8SEnji Cooper 	printf("Write new lookup_me2 to tracee (PID=%d) from tracer (PID=%d)\n",
2963cdebaff8SEnji Cooper 	    child, getpid());
2964cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me2, magic2) != -1);
2965cdebaff8SEnji Cooper 
2966cdebaff8SEnji Cooper 	printf("Write new lookup_me3 to tracee (PID=%d) from tracer (PID=%d)\n",
2967cdebaff8SEnji Cooper 	    child, getpid());
2968cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me3, magic3) != -1);
2969cdebaff8SEnji Cooper 
2970cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
2971cdebaff8SEnji Cooper 	    "without signal to be sent\n");
2972cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
2973cdebaff8SEnji Cooper 
2974cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2975cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2976cdebaff8SEnji Cooper 
2977cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
2978cdebaff8SEnji Cooper 
2979cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
2980cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2981cdebaff8SEnji Cooper }
2982cdebaff8SEnji Cooper 
2983cdebaff8SEnji Cooper ATF_TC(write_d4);
ATF_TC_HEAD(write_d4,tc)2984cdebaff8SEnji Cooper ATF_TC_HEAD(write_d4, tc)
2985cdebaff8SEnji Cooper {
2986cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
2987cdebaff8SEnji Cooper 	    "Verify PT_WRITE_D called four times");
2988cdebaff8SEnji Cooper }
2989cdebaff8SEnji Cooper 
ATF_TC_BODY(write_d4,tc)2990cdebaff8SEnji Cooper ATF_TC_BODY(write_d4, tc)
2991cdebaff8SEnji Cooper {
2992cdebaff8SEnji Cooper 	const int exitval = 5;
2993cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
2994cdebaff8SEnji Cooper 	pid_t child, wpid;
2995cdebaff8SEnji Cooper 	int lookup_me1 = 0;
2996cdebaff8SEnji Cooper 	int lookup_me2 = 0;
2997cdebaff8SEnji Cooper 	int lookup_me3 = 0;
2998cdebaff8SEnji Cooper 	int lookup_me4 = 0;
2999cdebaff8SEnji Cooper 	const int magic1 = (int)random();
3000cdebaff8SEnji Cooper 	const int magic2 = (int)random();
3001cdebaff8SEnji Cooper 	const int magic3 = (int)random();
3002cdebaff8SEnji Cooper 	const int magic4 = (int)random();
3003cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3004cdebaff8SEnji Cooper 	int status;
3005cdebaff8SEnji Cooper #endif
3006cdebaff8SEnji Cooper 
3007cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3008cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3009cdebaff8SEnji Cooper 	if (child == 0) {
3010cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3011cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3012cdebaff8SEnji Cooper 
3013cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3014cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3015cdebaff8SEnji Cooper 
3016cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me1, magic1);
3017cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me2, magic2);
3018cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me3, magic3);
3019cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me4, magic4);
3020cdebaff8SEnji Cooper 
3021cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3022cdebaff8SEnji Cooper 		_exit(exitval);
3023cdebaff8SEnji Cooper 	}
3024cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3025cdebaff8SEnji Cooper 
3026cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3027cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3028cdebaff8SEnji Cooper 
3029cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3030cdebaff8SEnji Cooper 
3031cdebaff8SEnji Cooper 	printf("Write new lookup_me1 to tracee (PID=%d) from tracer (PID=%d)\n",
3032cdebaff8SEnji Cooper 	    child, getpid());
3033cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me1, magic1) != -1);
3034cdebaff8SEnji Cooper 
3035cdebaff8SEnji Cooper 	printf("Write new lookup_me2 to tracee (PID=%d) from tracer (PID=%d)\n",
3036cdebaff8SEnji Cooper 	    child, getpid());
3037cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me2, magic2) != -1);
3038cdebaff8SEnji Cooper 
3039cdebaff8SEnji Cooper 	printf("Write new lookup_me3 to tracee (PID=%d) from tracer (PID=%d)\n",
3040cdebaff8SEnji Cooper 	    child, getpid());
3041cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me3, magic3) != -1);
3042cdebaff8SEnji Cooper 
3043cdebaff8SEnji Cooper 	printf("Write new lookup_me4 to tracee (PID=%d) from tracer (PID=%d)\n",
3044cdebaff8SEnji Cooper 	    child, getpid());
3045cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_WRITE_D, child, &lookup_me4, magic4) != -1);
3046cdebaff8SEnji Cooper 
3047cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3048cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3049cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3050cdebaff8SEnji Cooper 
3051cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3052cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3053cdebaff8SEnji Cooper 
3054cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3055cdebaff8SEnji Cooper 
3056cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3057cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3058cdebaff8SEnji Cooper }
3059cdebaff8SEnji Cooper 
3060cdebaff8SEnji Cooper ATF_TC(io_read_d_write_d_handshake1);
ATF_TC_HEAD(io_read_d_write_d_handshake1,tc)3061cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_d_write_d_handshake1, tc)
3062cdebaff8SEnji Cooper {
3063cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3064cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_D and PIOD_WRITE_D handshake");
3065cdebaff8SEnji Cooper }
3066cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_d_write_d_handshake1,tc)3067cdebaff8SEnji Cooper ATF_TC_BODY(io_read_d_write_d_handshake1, tc)
3068cdebaff8SEnji Cooper {
3069cdebaff8SEnji Cooper 	const int exitval = 5;
3070cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3071cdebaff8SEnji Cooper 	pid_t child, wpid;
3072cdebaff8SEnji Cooper 	uint8_t lookup_me_fromtracee = 0;
3073cdebaff8SEnji Cooper 	const uint8_t magic_fromtracee = (uint8_t)random();
3074cdebaff8SEnji Cooper 	uint8_t lookup_me_totracee = 0;
3075cdebaff8SEnji Cooper 	const uint8_t magic_totracee = (uint8_t)random();
3076cdebaff8SEnji Cooper 	struct ptrace_io_desc io_fromtracee = {
3077cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_D,
3078cdebaff8SEnji Cooper 		.piod_offs = &lookup_me_fromtracee,
3079cdebaff8SEnji Cooper 		.piod_addr = &lookup_me_fromtracee,
3080cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me_fromtracee)
3081cdebaff8SEnji Cooper 	};
3082cdebaff8SEnji Cooper 	struct ptrace_io_desc io_totracee = {
3083cdebaff8SEnji Cooper 		.piod_op = PIOD_WRITE_D,
3084cdebaff8SEnji Cooper 		.piod_offs = &lookup_me_totracee,
3085cdebaff8SEnji Cooper 		.piod_addr = &lookup_me_totracee,
3086cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me_totracee)
3087cdebaff8SEnji Cooper 	};
3088cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3089cdebaff8SEnji Cooper 	int status;
3090cdebaff8SEnji Cooper #endif
3091cdebaff8SEnji Cooper 
3092cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3093cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3094cdebaff8SEnji Cooper 	if (child == 0) {
3095cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3096cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3097cdebaff8SEnji Cooper 
3098cdebaff8SEnji Cooper 		lookup_me_fromtracee = magic_fromtracee;
3099cdebaff8SEnji Cooper 
3100cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3101cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3102cdebaff8SEnji Cooper 
3103cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me_totracee, magic_totracee);
3104cdebaff8SEnji Cooper 
3105cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3106cdebaff8SEnji Cooper 		_exit(exitval);
3107cdebaff8SEnji Cooper 	}
3108cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3109cdebaff8SEnji Cooper 
3110cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3111cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3112cdebaff8SEnji Cooper 
3113cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3114cdebaff8SEnji Cooper 
3115cdebaff8SEnji Cooper 	printf("Read lookup_me_fromtracee PID=%d by tracer (PID=%d)\n",
3116cdebaff8SEnji Cooper 	    child, getpid());
3117cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io_fromtracee, 0) != -1);
3118cdebaff8SEnji Cooper 
3119cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me_fromtracee, magic_fromtracee,
3120cdebaff8SEnji Cooper 	    "got value %" PRIx8 " != expected %" PRIx8, lookup_me_fromtracee,
3121cdebaff8SEnji Cooper 	    magic_fromtracee);
3122cdebaff8SEnji Cooper 
3123cdebaff8SEnji Cooper 	lookup_me_totracee = magic_totracee;
3124cdebaff8SEnji Cooper 
3125cdebaff8SEnji Cooper 	printf("Write lookup_me_totracee to PID=%d by tracer (PID=%d)\n",
3126cdebaff8SEnji Cooper 	    child, getpid());
3127cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io_totracee, 0) != -1);
3128cdebaff8SEnji Cooper 
3129cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me_totracee, magic_totracee,
3130cdebaff8SEnji Cooper 	    "got value %" PRIx8 " != expected %" PRIx8, lookup_me_totracee,
3131cdebaff8SEnji Cooper 	    magic_totracee);
3132cdebaff8SEnji Cooper 
3133cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3134cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3135cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3136cdebaff8SEnji Cooper 
3137cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3138cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3139cdebaff8SEnji Cooper 
3140cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3141cdebaff8SEnji Cooper 
3142cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3143cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3144cdebaff8SEnji Cooper }
3145cdebaff8SEnji Cooper 
3146cdebaff8SEnji Cooper ATF_TC(io_read_d_write_d_handshake2);
ATF_TC_HEAD(io_read_d_write_d_handshake2,tc)3147cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_d_write_d_handshake2, tc)
3148cdebaff8SEnji Cooper {
3149cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3150cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_WRITE_D and PIOD_READ_D handshake");
3151cdebaff8SEnji Cooper }
3152cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_d_write_d_handshake2,tc)3153cdebaff8SEnji Cooper ATF_TC_BODY(io_read_d_write_d_handshake2, tc)
3154cdebaff8SEnji Cooper {
3155cdebaff8SEnji Cooper 	const int exitval = 5;
3156cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3157cdebaff8SEnji Cooper 	pid_t child, wpid;
3158cdebaff8SEnji Cooper 	uint8_t lookup_me_fromtracee = 0;
3159cdebaff8SEnji Cooper 	const uint8_t magic_fromtracee = (uint8_t)random();
3160cdebaff8SEnji Cooper 	uint8_t lookup_me_totracee = 0;
3161cdebaff8SEnji Cooper 	const uint8_t magic_totracee = (uint8_t)random();
3162cdebaff8SEnji Cooper 	struct ptrace_io_desc io_fromtracee = {
3163cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_D,
3164cdebaff8SEnji Cooper 		.piod_offs = &lookup_me_fromtracee,
3165cdebaff8SEnji Cooper 		.piod_addr = &lookup_me_fromtracee,
3166cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me_fromtracee)
3167cdebaff8SEnji Cooper 	};
3168cdebaff8SEnji Cooper 	struct ptrace_io_desc io_totracee = {
3169cdebaff8SEnji Cooper 		.piod_op = PIOD_WRITE_D,
3170cdebaff8SEnji Cooper 		.piod_offs = &lookup_me_totracee,
3171cdebaff8SEnji Cooper 		.piod_addr = &lookup_me_totracee,
3172cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me_totracee)
3173cdebaff8SEnji Cooper 	};
3174cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3175cdebaff8SEnji Cooper 	int status;
3176cdebaff8SEnji Cooper #endif
3177cdebaff8SEnji Cooper 
3178cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3179cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3180cdebaff8SEnji Cooper 	if (child == 0) {
3181cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3182cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3183cdebaff8SEnji Cooper 
3184cdebaff8SEnji Cooper 		lookup_me_fromtracee = magic_fromtracee;
3185cdebaff8SEnji Cooper 
3186cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3187cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3188cdebaff8SEnji Cooper 
3189cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me_totracee, magic_totracee);
3190cdebaff8SEnji Cooper 
3191cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3192cdebaff8SEnji Cooper 		_exit(exitval);
3193cdebaff8SEnji Cooper 	}
3194cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3195cdebaff8SEnji Cooper 
3196cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3197cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3198cdebaff8SEnji Cooper 
3199cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3200cdebaff8SEnji Cooper 
3201cdebaff8SEnji Cooper 	lookup_me_totracee = magic_totracee;
3202cdebaff8SEnji Cooper 
3203cdebaff8SEnji Cooper 	printf("Write lookup_me_totracee to PID=%d by tracer (PID=%d)\n",
3204cdebaff8SEnji Cooper 	    child, getpid());
3205cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io_totracee, 0) != -1);
3206cdebaff8SEnji Cooper 
3207cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me_totracee, magic_totracee,
3208cdebaff8SEnji Cooper 	    "got value %" PRIx8 " != expected %" PRIx8, lookup_me_totracee,
3209cdebaff8SEnji Cooper 	    magic_totracee);
3210cdebaff8SEnji Cooper 
3211cdebaff8SEnji Cooper 	printf("Read lookup_me_fromtracee PID=%d by tracer (PID=%d)\n",
3212cdebaff8SEnji Cooper 	    child, getpid());
3213cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io_fromtracee, 0) != -1);
3214cdebaff8SEnji Cooper 
3215cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me_fromtracee, magic_fromtracee,
3216cdebaff8SEnji Cooper 	    "got value %" PRIx8 " != expected %" PRIx8, lookup_me_fromtracee,
3217cdebaff8SEnji Cooper 	    magic_fromtracee);
3218cdebaff8SEnji Cooper 
3219cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3220cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3221cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3222cdebaff8SEnji Cooper 
3223cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3224cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3225cdebaff8SEnji Cooper 
3226cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3227cdebaff8SEnji Cooper 
3228cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3229cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3230cdebaff8SEnji Cooper }
3231cdebaff8SEnji Cooper 
3232cdebaff8SEnji Cooper ATF_TC(read_d_write_d_handshake1);
ATF_TC_HEAD(read_d_write_d_handshake1,tc)3233cdebaff8SEnji Cooper ATF_TC_HEAD(read_d_write_d_handshake1, tc)
3234cdebaff8SEnji Cooper {
3235cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3236cdebaff8SEnji Cooper 	    "Verify PT_READ_D with PT_WRITE_D handshake");
3237cdebaff8SEnji Cooper }
3238cdebaff8SEnji Cooper 
ATF_TC_BODY(read_d_write_d_handshake1,tc)3239cdebaff8SEnji Cooper ATF_TC_BODY(read_d_write_d_handshake1, tc)
3240cdebaff8SEnji Cooper {
3241cdebaff8SEnji Cooper 	const int exitval = 5;
3242cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3243cdebaff8SEnji Cooper 	pid_t child, wpid;
3244cdebaff8SEnji Cooper 	int lookup_me_fromtracee = 0;
3245cdebaff8SEnji Cooper 	const int magic_fromtracee = (int)random();
3246cdebaff8SEnji Cooper 	int lookup_me_totracee = 0;
3247cdebaff8SEnji Cooper 	const int magic_totracee = (int)random();
3248cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3249cdebaff8SEnji Cooper 	int status;
3250cdebaff8SEnji Cooper #endif
3251cdebaff8SEnji Cooper 
3252cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3253cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3254cdebaff8SEnji Cooper 	if (child == 0) {
3255cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3256cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3257cdebaff8SEnji Cooper 
3258cdebaff8SEnji Cooper 		lookup_me_fromtracee = magic_fromtracee;
3259cdebaff8SEnji Cooper 
3260cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3261cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3262cdebaff8SEnji Cooper 
3263cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me_totracee, magic_totracee);
3264cdebaff8SEnji Cooper 
3265cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3266cdebaff8SEnji Cooper 		_exit(exitval);
3267cdebaff8SEnji Cooper 	}
3268cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3269cdebaff8SEnji Cooper 
3270cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3271cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3272cdebaff8SEnji Cooper 
3273cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3274cdebaff8SEnji Cooper 
3275cdebaff8SEnji Cooper 	printf("Read new lookup_me_fromtracee PID=%d by tracer (PID=%d)\n",
3276cdebaff8SEnji Cooper 	    child, getpid());
3277cdebaff8SEnji Cooper 	errno = 0;
3278cdebaff8SEnji Cooper 	lookup_me_fromtracee =
3279cdebaff8SEnji Cooper 	    ptrace(PT_READ_D, child, &lookup_me_fromtracee, 0);
3280cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3281cdebaff8SEnji Cooper 
3282cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me_fromtracee, magic_fromtracee,
3283cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me_fromtracee,
3284cdebaff8SEnji Cooper 	    magic_fromtracee);
3285cdebaff8SEnji Cooper 
3286cdebaff8SEnji Cooper 	printf("Write new lookup_me_totracee to PID=%d from tracer (PID=%d)\n",
3287cdebaff8SEnji Cooper 	    child, getpid());
3288cdebaff8SEnji Cooper 	ATF_REQUIRE
3289cdebaff8SEnji Cooper 	    (ptrace(PT_WRITE_D, child, &lookup_me_totracee, magic_totracee)
3290cdebaff8SEnji Cooper 	    != -1);
3291cdebaff8SEnji Cooper 
3292cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3293cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3294cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3295cdebaff8SEnji Cooper 
3296cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3297cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3298cdebaff8SEnji Cooper 
3299cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3300cdebaff8SEnji Cooper 
3301cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3302cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3303cdebaff8SEnji Cooper }
3304cdebaff8SEnji Cooper 
3305cdebaff8SEnji Cooper ATF_TC(read_d_write_d_handshake2);
ATF_TC_HEAD(read_d_write_d_handshake2,tc)3306cdebaff8SEnji Cooper ATF_TC_HEAD(read_d_write_d_handshake2, tc)
3307cdebaff8SEnji Cooper {
3308cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3309cdebaff8SEnji Cooper 	    "Verify PT_WRITE_D with PT_READ_D handshake");
3310cdebaff8SEnji Cooper }
3311cdebaff8SEnji Cooper 
ATF_TC_BODY(read_d_write_d_handshake2,tc)3312cdebaff8SEnji Cooper ATF_TC_BODY(read_d_write_d_handshake2, tc)
3313cdebaff8SEnji Cooper {
3314cdebaff8SEnji Cooper 	const int exitval = 5;
3315cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3316cdebaff8SEnji Cooper 	pid_t child, wpid;
3317cdebaff8SEnji Cooper 	int lookup_me_fromtracee = 0;
3318cdebaff8SEnji Cooper 	const int magic_fromtracee = (int)random();
3319cdebaff8SEnji Cooper 	int lookup_me_totracee = 0;
3320cdebaff8SEnji Cooper 	const int magic_totracee = (int)random();
3321cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3322cdebaff8SEnji Cooper 	int status;
3323cdebaff8SEnji Cooper #endif
3324cdebaff8SEnji Cooper 
3325cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3326cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3327cdebaff8SEnji Cooper 	if (child == 0) {
3328cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3329cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3330cdebaff8SEnji Cooper 
3331cdebaff8SEnji Cooper 		lookup_me_fromtracee = magic_fromtracee;
3332cdebaff8SEnji Cooper 
3333cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3334cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3335cdebaff8SEnji Cooper 
3336cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(lookup_me_totracee, magic_totracee);
3337cdebaff8SEnji Cooper 
3338cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3339cdebaff8SEnji Cooper 		_exit(exitval);
3340cdebaff8SEnji Cooper 	}
3341cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3342cdebaff8SEnji Cooper 
3343cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3344cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3345cdebaff8SEnji Cooper 
3346cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3347cdebaff8SEnji Cooper 
3348cdebaff8SEnji Cooper 	printf("Write new lookup_me_totracee to PID=%d from tracer (PID=%d)\n",
3349cdebaff8SEnji Cooper 	    child, getpid());
3350cdebaff8SEnji Cooper 	ATF_REQUIRE
3351cdebaff8SEnji Cooper 	    (ptrace(PT_WRITE_D, child, &lookup_me_totracee, magic_totracee)
3352cdebaff8SEnji Cooper 	    != -1);
3353cdebaff8SEnji Cooper 
3354cdebaff8SEnji Cooper 	printf("Read new lookup_me_fromtracee PID=%d by tracer (PID=%d)\n",
3355cdebaff8SEnji Cooper 	    child, getpid());
3356cdebaff8SEnji Cooper 	errno = 0;
3357cdebaff8SEnji Cooper 	lookup_me_fromtracee =
3358cdebaff8SEnji Cooper 	    ptrace(PT_READ_D, child, &lookup_me_fromtracee, 0);
3359cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3360cdebaff8SEnji Cooper 
3361cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me_fromtracee, magic_fromtracee,
3362cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me_fromtracee,
3363cdebaff8SEnji Cooper 	    magic_fromtracee);
3364cdebaff8SEnji Cooper 
3365cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3366cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3367cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3368cdebaff8SEnji Cooper 
3369cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3370cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3371cdebaff8SEnji Cooper 
3372cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3373cdebaff8SEnji Cooper 
3374cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3375cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3376cdebaff8SEnji Cooper }
3377cdebaff8SEnji Cooper 
3378cdebaff8SEnji Cooper /* These dummy functions are used to be copied with ptrace(2) calls */
3379cdebaff8SEnji Cooper static int __used
dummy_fn1(int a,int b,int c,int d)3380cdebaff8SEnji Cooper dummy_fn1(int a, int b, int c, int d)
3381cdebaff8SEnji Cooper {
3382cdebaff8SEnji Cooper 
3383cdebaff8SEnji Cooper 	a *= 1;
3384cdebaff8SEnji Cooper 	b += 2;
3385cdebaff8SEnji Cooper 	c -= 3;
3386cdebaff8SEnji Cooper 	d /= 4;
3387cdebaff8SEnji Cooper 
3388cdebaff8SEnji Cooper 	return a + b * c - d;
3389cdebaff8SEnji Cooper }
3390cdebaff8SEnji Cooper 
3391cdebaff8SEnji Cooper static int __used
dummy_fn2(int a,int b,int c,int d)3392cdebaff8SEnji Cooper dummy_fn2(int a, int b, int c, int d)
3393cdebaff8SEnji Cooper {
3394cdebaff8SEnji Cooper 
3395cdebaff8SEnji Cooper 	a *= 4;
3396cdebaff8SEnji Cooper 	b += 3;
3397cdebaff8SEnji Cooper 	c -= 2;
3398cdebaff8SEnji Cooper 	d /= 1;
3399cdebaff8SEnji Cooper 
3400cdebaff8SEnji Cooper 	return a + b * c - d;
3401cdebaff8SEnji Cooper }
3402cdebaff8SEnji Cooper 
3403cdebaff8SEnji Cooper static int __used
dummy_fn3(int a,int b,int c,int d)3404cdebaff8SEnji Cooper dummy_fn3(int a, int b, int c, int d)
3405cdebaff8SEnji Cooper {
3406cdebaff8SEnji Cooper 
3407cdebaff8SEnji Cooper 	a *= 10;
3408cdebaff8SEnji Cooper 	b += 20;
3409cdebaff8SEnji Cooper 	c -= 30;
3410cdebaff8SEnji Cooper 	d /= 40;
3411cdebaff8SEnji Cooper 
3412cdebaff8SEnji Cooper 	return a + b * c - d;
3413cdebaff8SEnji Cooper }
3414cdebaff8SEnji Cooper 
3415cdebaff8SEnji Cooper static int __used
dummy_fn4(int a,int b,int c,int d)3416cdebaff8SEnji Cooper dummy_fn4(int a, int b, int c, int d)
3417cdebaff8SEnji Cooper {
3418cdebaff8SEnji Cooper 
3419cdebaff8SEnji Cooper 	a *= 40;
3420cdebaff8SEnji Cooper 	b += 30;
3421cdebaff8SEnji Cooper 	c -= 20;
3422cdebaff8SEnji Cooper 	d /= 10;
3423cdebaff8SEnji Cooper 
3424cdebaff8SEnji Cooper 	return a + b * c - d;
3425cdebaff8SEnji Cooper }
3426cdebaff8SEnji Cooper 
3427cdebaff8SEnji Cooper ATF_TC(io_read_i1);
ATF_TC_HEAD(io_read_i1,tc)3428cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_i1, tc)
3429cdebaff8SEnji Cooper {
3430cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3431cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_I and len = sizeof(uint8_t)");
3432cdebaff8SEnji Cooper }
3433cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_i1,tc)3434cdebaff8SEnji Cooper ATF_TC_BODY(io_read_i1, tc)
3435cdebaff8SEnji Cooper {
3436cdebaff8SEnji Cooper 	const int exitval = 5;
3437cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3438cdebaff8SEnji Cooper 	pid_t child, wpid;
3439cdebaff8SEnji Cooper 	uint8_t lookup_me = 0;
3440cdebaff8SEnji Cooper 	uint8_t magic;
3441cdebaff8SEnji Cooper 	memcpy(&magic, dummy_fn1, sizeof(magic));
3442cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
3443cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_I,
3444cdebaff8SEnji Cooper 		.piod_offs = dummy_fn1,
3445cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
3446cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
3447cdebaff8SEnji Cooper 	};
3448cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3449cdebaff8SEnji Cooper 	int status;
3450cdebaff8SEnji Cooper #endif
3451cdebaff8SEnji Cooper 
3452cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3453cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3454cdebaff8SEnji Cooper 	if (child == 0) {
3455cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3456cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3457cdebaff8SEnji Cooper 
3458cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3459cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3460cdebaff8SEnji Cooper 
3461cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3462cdebaff8SEnji Cooper 		_exit(exitval);
3463cdebaff8SEnji Cooper 	}
3464cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3465cdebaff8SEnji Cooper 
3466cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3467cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3468cdebaff8SEnji Cooper 
3469cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3470cdebaff8SEnji Cooper 
3471cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
3472cdebaff8SEnji Cooper 	    child, getpid());
3473cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
3474cdebaff8SEnji Cooper 
3475cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
3476cdebaff8SEnji Cooper 	    "got value %" PRIx8 " != expected %" PRIx8, lookup_me, magic);
3477cdebaff8SEnji Cooper 
3478cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3479cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3480cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3481cdebaff8SEnji Cooper 
3482cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3483cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3484cdebaff8SEnji Cooper 
3485cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3486cdebaff8SEnji Cooper 
3487cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3488cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3489cdebaff8SEnji Cooper }
3490cdebaff8SEnji Cooper 
3491cdebaff8SEnji Cooper ATF_TC(io_read_i2);
ATF_TC_HEAD(io_read_i2,tc)3492cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_i2, tc)
3493cdebaff8SEnji Cooper {
3494cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3495cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_I and len = sizeof(uint16_t)");
3496cdebaff8SEnji Cooper }
3497cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_i2,tc)3498cdebaff8SEnji Cooper ATF_TC_BODY(io_read_i2, tc)
3499cdebaff8SEnji Cooper {
3500cdebaff8SEnji Cooper 	const int exitval = 5;
3501cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3502cdebaff8SEnji Cooper 	pid_t child, wpid;
3503cdebaff8SEnji Cooper 	uint16_t lookup_me = 0;
3504cdebaff8SEnji Cooper 	uint16_t magic;
3505cdebaff8SEnji Cooper 	memcpy(&magic, dummy_fn1, sizeof(magic));
3506cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
3507cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_I,
3508cdebaff8SEnji Cooper 		.piod_offs = dummy_fn1,
3509cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
3510cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
3511cdebaff8SEnji Cooper 	};
3512cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3513cdebaff8SEnji Cooper 	int status;
3514cdebaff8SEnji Cooper #endif
3515cdebaff8SEnji Cooper 
3516cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3517cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3518cdebaff8SEnji Cooper 	if (child == 0) {
3519cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3520cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3521cdebaff8SEnji Cooper 
3522cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3523cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3524cdebaff8SEnji Cooper 
3525cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3526cdebaff8SEnji Cooper 		_exit(exitval);
3527cdebaff8SEnji Cooper 	}
3528cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3529cdebaff8SEnji Cooper 
3530cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3531cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3532cdebaff8SEnji Cooper 
3533cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3534cdebaff8SEnji Cooper 
3535cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
3536cdebaff8SEnji Cooper 	    child, getpid());
3537cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
3538cdebaff8SEnji Cooper 
3539cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
3540cdebaff8SEnji Cooper 	    "got value %" PRIx16 " != expected %" PRIx16, lookup_me, magic);
3541cdebaff8SEnji Cooper 
3542cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3543cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3544cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3545cdebaff8SEnji Cooper 
3546cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3547cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3548cdebaff8SEnji Cooper 
3549cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3550cdebaff8SEnji Cooper 
3551cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3552cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3553cdebaff8SEnji Cooper }
3554cdebaff8SEnji Cooper 
3555cdebaff8SEnji Cooper ATF_TC(io_read_i3);
ATF_TC_HEAD(io_read_i3,tc)3556cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_i3, tc)
3557cdebaff8SEnji Cooper {
3558cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3559cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_I and len = sizeof(uint32_t)");
3560cdebaff8SEnji Cooper }
3561cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_i3,tc)3562cdebaff8SEnji Cooper ATF_TC_BODY(io_read_i3, tc)
3563cdebaff8SEnji Cooper {
3564cdebaff8SEnji Cooper 	const int exitval = 5;
3565cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3566cdebaff8SEnji Cooper 	pid_t child, wpid;
3567cdebaff8SEnji Cooper 	uint32_t lookup_me = 0;
3568cdebaff8SEnji Cooper 	uint32_t magic;
3569cdebaff8SEnji Cooper 	memcpy(&magic, dummy_fn1, sizeof(magic));
3570cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
3571cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_I,
3572cdebaff8SEnji Cooper 		.piod_offs = dummy_fn1,
3573cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
3574cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
3575cdebaff8SEnji Cooper 	};
3576cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3577cdebaff8SEnji Cooper 	int status;
3578cdebaff8SEnji Cooper #endif
3579cdebaff8SEnji Cooper 
3580cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3581cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3582cdebaff8SEnji Cooper 	if (child == 0) {
3583cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3584cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3585cdebaff8SEnji Cooper 
3586cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3587cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3588cdebaff8SEnji Cooper 
3589cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3590cdebaff8SEnji Cooper 		_exit(exitval);
3591cdebaff8SEnji Cooper 	}
3592cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3593cdebaff8SEnji Cooper 
3594cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3595cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3596cdebaff8SEnji Cooper 
3597cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3598cdebaff8SEnji Cooper 
3599cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
3600cdebaff8SEnji Cooper 	    child, getpid());
3601cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
3602cdebaff8SEnji Cooper 
3603cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
3604cdebaff8SEnji Cooper 	    "got value %" PRIx32 " != expected %" PRIx32, lookup_me, magic);
3605cdebaff8SEnji Cooper 
3606cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3607cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3608cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3609cdebaff8SEnji Cooper 
3610cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3611cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3612cdebaff8SEnji Cooper 
3613cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3614cdebaff8SEnji Cooper 
3615cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3616cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3617cdebaff8SEnji Cooper }
3618cdebaff8SEnji Cooper 
3619cdebaff8SEnji Cooper ATF_TC(io_read_i4);
ATF_TC_HEAD(io_read_i4,tc)3620cdebaff8SEnji Cooper ATF_TC_HEAD(io_read_i4, tc)
3621cdebaff8SEnji Cooper {
3622cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3623cdebaff8SEnji Cooper 	    "Verify PT_IO with PIOD_READ_I and len = sizeof(uint64_t)");
3624cdebaff8SEnji Cooper }
3625cdebaff8SEnji Cooper 
ATF_TC_BODY(io_read_i4,tc)3626cdebaff8SEnji Cooper ATF_TC_BODY(io_read_i4, tc)
3627cdebaff8SEnji Cooper {
3628cdebaff8SEnji Cooper 	const int exitval = 5;
3629cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3630cdebaff8SEnji Cooper 	pid_t child, wpid;
3631cdebaff8SEnji Cooper 	uint64_t lookup_me = 0;
3632cdebaff8SEnji Cooper 	uint64_t magic;
3633cdebaff8SEnji Cooper 	memcpy(&magic, dummy_fn1, sizeof(magic));
3634cdebaff8SEnji Cooper 	struct ptrace_io_desc io = {
3635cdebaff8SEnji Cooper 		.piod_op = PIOD_READ_I,
3636cdebaff8SEnji Cooper 		.piod_offs = dummy_fn1,
3637cdebaff8SEnji Cooper 		.piod_addr = &lookup_me,
3638cdebaff8SEnji Cooper 		.piod_len = sizeof(lookup_me)
3639cdebaff8SEnji Cooper 	};
3640cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3641cdebaff8SEnji Cooper 	int status;
3642cdebaff8SEnji Cooper #endif
3643cdebaff8SEnji Cooper 
3644cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3645cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3646cdebaff8SEnji Cooper 	if (child == 0) {
3647cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3648cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3649cdebaff8SEnji Cooper 
3650cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3651cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3652cdebaff8SEnji Cooper 
3653cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3654cdebaff8SEnji Cooper 		_exit(exitval);
3655cdebaff8SEnji Cooper 	}
3656cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3657cdebaff8SEnji Cooper 
3658cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3659cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3660cdebaff8SEnji Cooper 
3661cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3662cdebaff8SEnji Cooper 
3663cdebaff8SEnji Cooper 	printf("Read lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
3664cdebaff8SEnji Cooper 	    child, getpid());
3665cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_IO, child, &io, 0) != -1);
3666cdebaff8SEnji Cooper 
3667cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
3668cdebaff8SEnji Cooper 	    "got value %" PRIx64 " != expected %" PRIx64, lookup_me, magic);
3669cdebaff8SEnji Cooper 
3670cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3671cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3672cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3673cdebaff8SEnji Cooper 
3674cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3675cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3676cdebaff8SEnji Cooper 
3677cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3678cdebaff8SEnji Cooper 
3679cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3680cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3681cdebaff8SEnji Cooper }
3682cdebaff8SEnji Cooper 
3683cdebaff8SEnji Cooper ATF_TC(read_i1);
ATF_TC_HEAD(read_i1,tc)3684cdebaff8SEnji Cooper ATF_TC_HEAD(read_i1, tc)
3685cdebaff8SEnji Cooper {
3686cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3687cdebaff8SEnji Cooper 	    "Verify PT_READ_I called once");
3688cdebaff8SEnji Cooper }
3689cdebaff8SEnji Cooper 
ATF_TC_BODY(read_i1,tc)3690cdebaff8SEnji Cooper ATF_TC_BODY(read_i1, tc)
3691cdebaff8SEnji Cooper {
3692cdebaff8SEnji Cooper 	const int exitval = 5;
3693cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3694cdebaff8SEnji Cooper 	pid_t child, wpid;
3695cdebaff8SEnji Cooper 	int lookup_me = 0;
3696cdebaff8SEnji Cooper 	int magic;
3697cdebaff8SEnji Cooper 	memcpy(&magic, dummy_fn1, sizeof(magic));
3698cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3699cdebaff8SEnji Cooper 	int status;
3700cdebaff8SEnji Cooper #endif
3701cdebaff8SEnji Cooper 
3702cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3703cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3704cdebaff8SEnji Cooper 	if (child == 0) {
3705cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3706cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3707cdebaff8SEnji Cooper 
3708cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3709cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3710cdebaff8SEnji Cooper 
3711cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3712cdebaff8SEnji Cooper 		_exit(exitval);
3713cdebaff8SEnji Cooper 	}
3714cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3715cdebaff8SEnji Cooper 
3716cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3717cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3718cdebaff8SEnji Cooper 
3719cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3720cdebaff8SEnji Cooper 
3721cdebaff8SEnji Cooper 	printf("Read new lookup_me from tracee (PID=%d) by tracer (PID=%d)\n",
3722cdebaff8SEnji Cooper 	    child, getpid());
3723cdebaff8SEnji Cooper 	errno = 0;
3724cdebaff8SEnji Cooper 	lookup_me = ptrace(PT_READ_I, child, dummy_fn1, 0);
3725cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3726cdebaff8SEnji Cooper 
3727cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me, magic,
3728cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me, magic);
3729cdebaff8SEnji Cooper 
3730cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3731cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3732cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3733cdebaff8SEnji Cooper 
3734cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3735cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3736cdebaff8SEnji Cooper 
3737cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3738cdebaff8SEnji Cooper 
3739cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3740cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3741cdebaff8SEnji Cooper }
3742cdebaff8SEnji Cooper 
3743cdebaff8SEnji Cooper ATF_TC(read_i2);
ATF_TC_HEAD(read_i2,tc)3744cdebaff8SEnji Cooper ATF_TC_HEAD(read_i2, tc)
3745cdebaff8SEnji Cooper {
3746cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3747cdebaff8SEnji Cooper 	    "Verify PT_READ_I called twice");
3748cdebaff8SEnji Cooper }
3749cdebaff8SEnji Cooper 
ATF_TC_BODY(read_i2,tc)3750cdebaff8SEnji Cooper ATF_TC_BODY(read_i2, tc)
3751cdebaff8SEnji Cooper {
3752cdebaff8SEnji Cooper 	const int exitval = 5;
3753cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3754cdebaff8SEnji Cooper 	pid_t child, wpid;
3755cdebaff8SEnji Cooper 	int lookup_me1 = 0;
3756cdebaff8SEnji Cooper 	int lookup_me2 = 0;
3757cdebaff8SEnji Cooper 	int magic1;
3758cdebaff8SEnji Cooper 	int magic2;
3759cdebaff8SEnji Cooper 	memcpy(&magic1, dummy_fn1, sizeof(magic1));
3760cdebaff8SEnji Cooper 	memcpy(&magic2, dummy_fn2, sizeof(magic2));
3761cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3762cdebaff8SEnji Cooper 	int status;
3763cdebaff8SEnji Cooper #endif
3764cdebaff8SEnji Cooper 
3765cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3766cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3767cdebaff8SEnji Cooper 	if (child == 0) {
3768cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3769cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3770cdebaff8SEnji Cooper 
3771cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3772cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3773cdebaff8SEnji Cooper 
3774cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3775cdebaff8SEnji Cooper 		_exit(exitval);
3776cdebaff8SEnji Cooper 	}
3777cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3778cdebaff8SEnji Cooper 
3779cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3780cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3781cdebaff8SEnji Cooper 
3782cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3783cdebaff8SEnji Cooper 
3784cdebaff8SEnji Cooper 	printf("Read new lookup_me1 from tracee (PID=%d) by tracer (PID=%d)\n",
3785cdebaff8SEnji Cooper 	    child, getpid());
3786cdebaff8SEnji Cooper 	errno = 0;
3787cdebaff8SEnji Cooper 	lookup_me1 = ptrace(PT_READ_I, child, dummy_fn1, 0);
3788cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3789cdebaff8SEnji Cooper 
3790cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me1, magic1,
3791cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me1, magic1);
3792cdebaff8SEnji Cooper 
3793cdebaff8SEnji Cooper 	printf("Read new lookup_me2 from tracee (PID=%d) by tracer (PID=%d)\n",
3794cdebaff8SEnji Cooper 	    child, getpid());
3795cdebaff8SEnji Cooper 	errno = 0;
3796cdebaff8SEnji Cooper 	lookup_me2 = ptrace(PT_READ_I, child, dummy_fn2, 0);
3797cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3798cdebaff8SEnji Cooper 
3799cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me2, magic2,
3800cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me2, magic2);
3801cdebaff8SEnji Cooper 
3802cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3803cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3804cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3805cdebaff8SEnji Cooper 
3806cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3807cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3808cdebaff8SEnji Cooper 
3809cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3810cdebaff8SEnji Cooper 
3811cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3812cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3813cdebaff8SEnji Cooper }
3814cdebaff8SEnji Cooper 
3815cdebaff8SEnji Cooper ATF_TC(read_i3);
ATF_TC_HEAD(read_i3,tc)3816cdebaff8SEnji Cooper ATF_TC_HEAD(read_i3, tc)
3817cdebaff8SEnji Cooper {
3818cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3819cdebaff8SEnji Cooper 	    "Verify PT_READ_I called three times");
3820cdebaff8SEnji Cooper }
3821cdebaff8SEnji Cooper 
ATF_TC_BODY(read_i3,tc)3822cdebaff8SEnji Cooper ATF_TC_BODY(read_i3, tc)
3823cdebaff8SEnji Cooper {
3824cdebaff8SEnji Cooper 	const int exitval = 5;
3825cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3826cdebaff8SEnji Cooper 	pid_t child, wpid;
3827cdebaff8SEnji Cooper 	int lookup_me1 = 0;
3828cdebaff8SEnji Cooper 	int lookup_me2 = 0;
3829cdebaff8SEnji Cooper 	int lookup_me3 = 0;
3830cdebaff8SEnji Cooper 	int magic1;
3831cdebaff8SEnji Cooper 	int magic2;
3832cdebaff8SEnji Cooper 	int magic3;
3833cdebaff8SEnji Cooper 	memcpy(&magic1, dummy_fn1, sizeof(magic1));
3834cdebaff8SEnji Cooper 	memcpy(&magic2, dummy_fn2, sizeof(magic2));
3835cdebaff8SEnji Cooper 	memcpy(&magic3, dummy_fn3, sizeof(magic3));
3836cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3837cdebaff8SEnji Cooper 	int status;
3838cdebaff8SEnji Cooper #endif
3839cdebaff8SEnji Cooper 
3840cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3841cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3842cdebaff8SEnji Cooper 	if (child == 0) {
3843cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3844cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3845cdebaff8SEnji Cooper 
3846cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3847cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3848cdebaff8SEnji Cooper 
3849cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3850cdebaff8SEnji Cooper 		_exit(exitval);
3851cdebaff8SEnji Cooper 	}
3852cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3853cdebaff8SEnji Cooper 
3854cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3855cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3856cdebaff8SEnji Cooper 
3857cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3858cdebaff8SEnji Cooper 
3859cdebaff8SEnji Cooper 	printf("Read new lookup_me1 from tracee (PID=%d) by tracer (PID=%d)\n",
3860cdebaff8SEnji Cooper 	    child, getpid());
3861cdebaff8SEnji Cooper 	errno = 0;
3862cdebaff8SEnji Cooper 	lookup_me1 = ptrace(PT_READ_I, child, dummy_fn1, 0);
3863cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3864cdebaff8SEnji Cooper 
3865cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me1, magic1,
3866cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me1, magic1);
3867cdebaff8SEnji Cooper 
3868cdebaff8SEnji Cooper 	printf("Read new lookup_me2 from tracee (PID=%d) by tracer (PID=%d)\n",
3869cdebaff8SEnji Cooper 	    child, getpid());
3870cdebaff8SEnji Cooper 	errno = 0;
3871cdebaff8SEnji Cooper 	lookup_me2 = ptrace(PT_READ_I, child, dummy_fn2, 0);
3872cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3873cdebaff8SEnji Cooper 
3874cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me2, magic2,
3875cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me2, magic2);
3876cdebaff8SEnji Cooper 
3877cdebaff8SEnji Cooper 	printf("Read new lookup_me3 from tracee (PID=%d) by tracer (PID=%d)\n",
3878cdebaff8SEnji Cooper 	    child, getpid());
3879cdebaff8SEnji Cooper 	errno = 0;
3880cdebaff8SEnji Cooper 	lookup_me3 = ptrace(PT_READ_I, child, dummy_fn3, 0);
3881cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3882cdebaff8SEnji Cooper 
3883cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me3, magic3,
3884cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me3, magic3);
3885cdebaff8SEnji Cooper 
3886cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3887cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3888cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3889cdebaff8SEnji Cooper 
3890cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3891cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3892cdebaff8SEnji Cooper 
3893cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3894cdebaff8SEnji Cooper 
3895cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3896cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3897cdebaff8SEnji Cooper }
3898cdebaff8SEnji Cooper 
3899cdebaff8SEnji Cooper ATF_TC(read_i4);
ATF_TC_HEAD(read_i4,tc)3900cdebaff8SEnji Cooper ATF_TC_HEAD(read_i4, tc)
3901cdebaff8SEnji Cooper {
3902cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
3903cdebaff8SEnji Cooper 	    "Verify PT_READ_I called four times");
3904cdebaff8SEnji Cooper }
3905cdebaff8SEnji Cooper 
ATF_TC_BODY(read_i4,tc)3906cdebaff8SEnji Cooper ATF_TC_BODY(read_i4, tc)
3907cdebaff8SEnji Cooper {
3908cdebaff8SEnji Cooper 	const int exitval = 5;
3909cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
3910cdebaff8SEnji Cooper 	pid_t child, wpid;
3911cdebaff8SEnji Cooper 	int lookup_me1 = 0;
3912cdebaff8SEnji Cooper 	int lookup_me2 = 0;
3913cdebaff8SEnji Cooper 	int lookup_me3 = 0;
3914cdebaff8SEnji Cooper 	int lookup_me4 = 0;
3915cdebaff8SEnji Cooper 	int magic1;
3916cdebaff8SEnji Cooper 	int magic2;
3917cdebaff8SEnji Cooper 	int magic3;
3918cdebaff8SEnji Cooper 	int magic4;
3919cdebaff8SEnji Cooper 	memcpy(&magic1, dummy_fn1, sizeof(magic1));
3920cdebaff8SEnji Cooper 	memcpy(&magic2, dummy_fn2, sizeof(magic2));
3921cdebaff8SEnji Cooper 	memcpy(&magic3, dummy_fn3, sizeof(magic3));
3922cdebaff8SEnji Cooper 	memcpy(&magic4, dummy_fn4, sizeof(magic4));
3923cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
3924cdebaff8SEnji Cooper 	int status;
3925cdebaff8SEnji Cooper #endif
3926cdebaff8SEnji Cooper 
3927cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
3928cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
3929cdebaff8SEnji Cooper 	if (child == 0) {
3930cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
3931cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
3932cdebaff8SEnji Cooper 
3933cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
3934cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
3935cdebaff8SEnji Cooper 
3936cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
3937cdebaff8SEnji Cooper 		_exit(exitval);
3938cdebaff8SEnji Cooper 	}
3939cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3940cdebaff8SEnji Cooper 
3941cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3942cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3943cdebaff8SEnji Cooper 
3944cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
3945cdebaff8SEnji Cooper 
3946cdebaff8SEnji Cooper 	printf("Read new lookup_me1 from tracee (PID=%d) by tracer (PID=%d)\n",
3947cdebaff8SEnji Cooper 	    child, getpid());
3948cdebaff8SEnji Cooper 	errno = 0;
3949cdebaff8SEnji Cooper 	lookup_me1 = ptrace(PT_READ_I, child, dummy_fn1, 0);
3950cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3951cdebaff8SEnji Cooper 
3952cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me1, magic1,
3953cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me1, magic1);
3954cdebaff8SEnji Cooper 
3955cdebaff8SEnji Cooper 	printf("Read new lookup_me2 from tracee (PID=%d) by tracer (PID=%d)\n",
3956cdebaff8SEnji Cooper 	    child, getpid());
3957cdebaff8SEnji Cooper 	errno = 0;
3958cdebaff8SEnji Cooper 	lookup_me2 = ptrace(PT_READ_I, child, dummy_fn2, 0);
3959cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3960cdebaff8SEnji Cooper 
3961cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me2, magic2,
3962cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me2, magic2);
3963cdebaff8SEnji Cooper 
3964cdebaff8SEnji Cooper 	printf("Read new lookup_me3 from tracee (PID=%d) by tracer (PID=%d)\n",
3965cdebaff8SEnji Cooper 	    child, getpid());
3966cdebaff8SEnji Cooper 	errno = 0;
3967cdebaff8SEnji Cooper 	lookup_me3 = ptrace(PT_READ_I, child, dummy_fn3, 0);
3968cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3969cdebaff8SEnji Cooper 
3970cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me3, magic3,
3971cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me3, magic3);
3972cdebaff8SEnji Cooper 
3973cdebaff8SEnji Cooper 	printf("Read new lookup_me4 from tracee (PID=%d) by tracer (PID=%d)\n",
3974cdebaff8SEnji Cooper 	    child, getpid());
3975cdebaff8SEnji Cooper 	errno = 0;
3976cdebaff8SEnji Cooper 	lookup_me4 = ptrace(PT_READ_I, child, dummy_fn4, 0);
3977cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(errno, 0);
3978cdebaff8SEnji Cooper 
3979cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(lookup_me4, magic4,
3980cdebaff8SEnji Cooper 	    "got value %#x != expected %#x", lookup_me4, magic4);
3981cdebaff8SEnji Cooper 
3982cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
3983cdebaff8SEnji Cooper 	    "without signal to be sent\n");
3984cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
3985cdebaff8SEnji Cooper 
3986cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3987cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3988cdebaff8SEnji Cooper 
3989cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
3990cdebaff8SEnji Cooper 
3991cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
3992cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
3993cdebaff8SEnji Cooper }
3994cdebaff8SEnji Cooper 
3995cdebaff8SEnji Cooper #if defined(HAVE_GPREGS)
3996cdebaff8SEnji Cooper ATF_TC(regs1);
ATF_TC_HEAD(regs1,tc)3997cdebaff8SEnji Cooper ATF_TC_HEAD(regs1, tc)
3998cdebaff8SEnji Cooper {
3999cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4000cdebaff8SEnji Cooper 	    "Verify plain PT_GETREGS call without further steps");
4001cdebaff8SEnji Cooper }
4002cdebaff8SEnji Cooper 
ATF_TC_BODY(regs1,tc)4003cdebaff8SEnji Cooper ATF_TC_BODY(regs1, tc)
4004cdebaff8SEnji Cooper {
4005cdebaff8SEnji Cooper 	const int exitval = 5;
4006cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4007cdebaff8SEnji Cooper 	pid_t child, wpid;
4008cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4009cdebaff8SEnji Cooper 	int status;
4010cdebaff8SEnji Cooper #endif
4011cdebaff8SEnji Cooper 	struct reg r;
4012cdebaff8SEnji Cooper 
4013cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4014cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4015cdebaff8SEnji Cooper 	if (child == 0) {
4016cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4017cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4018cdebaff8SEnji Cooper 
4019cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4020cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4021cdebaff8SEnji Cooper 
4022cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4023cdebaff8SEnji Cooper 		_exit(exitval);
4024cdebaff8SEnji Cooper 	}
4025cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4026cdebaff8SEnji Cooper 
4027cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4028cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4029cdebaff8SEnji Cooper 
4030cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4031cdebaff8SEnji Cooper 
4032cdebaff8SEnji Cooper 	printf("Call GETREGS for the child process\n");
4033cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETREGS, child, &r, 0) != -1);
4034cdebaff8SEnji Cooper 
4035cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4036cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4037cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4038cdebaff8SEnji Cooper 
4039cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4040cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4041cdebaff8SEnji Cooper 
4042cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4043cdebaff8SEnji Cooper 
4044cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4045cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4046cdebaff8SEnji Cooper }
4047cdebaff8SEnji Cooper #endif
4048cdebaff8SEnji Cooper 
4049cdebaff8SEnji Cooper #if defined(HAVE_GPREGS)
4050cdebaff8SEnji Cooper ATF_TC(regs2);
ATF_TC_HEAD(regs2,tc)4051cdebaff8SEnji Cooper ATF_TC_HEAD(regs2, tc)
4052cdebaff8SEnji Cooper {
4053cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4054cdebaff8SEnji Cooper 	    "Verify plain PT_GETREGS call and retrieve PC");
4055cdebaff8SEnji Cooper }
4056cdebaff8SEnji Cooper 
ATF_TC_BODY(regs2,tc)4057cdebaff8SEnji Cooper ATF_TC_BODY(regs2, tc)
4058cdebaff8SEnji Cooper {
4059cdebaff8SEnji Cooper 	const int exitval = 5;
4060cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4061cdebaff8SEnji Cooper 	pid_t child, wpid;
4062cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4063cdebaff8SEnji Cooper 	int status;
4064cdebaff8SEnji Cooper #endif
4065cdebaff8SEnji Cooper 	struct reg r;
4066cdebaff8SEnji Cooper 
4067cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4068cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4069cdebaff8SEnji Cooper 	if (child == 0) {
4070cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4071cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4072cdebaff8SEnji Cooper 
4073cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4074cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4075cdebaff8SEnji Cooper 
4076cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4077cdebaff8SEnji Cooper 		_exit(exitval);
4078cdebaff8SEnji Cooper 	}
4079cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4080cdebaff8SEnji Cooper 
4081cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4082cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4083cdebaff8SEnji Cooper 
4084cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4085cdebaff8SEnji Cooper 
4086cdebaff8SEnji Cooper 	printf("Call GETREGS for the child process\n");
4087cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETREGS, child, &r, 0) != -1);
4088cdebaff8SEnji Cooper 
4089cdebaff8SEnji Cooper 	printf("Retrieved PC=%" PRIxREGISTER "\n", PTRACE_REG_PC(&r));
4090cdebaff8SEnji Cooper 
4091cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4092cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4093cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4094cdebaff8SEnji Cooper 
4095cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4096cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4097cdebaff8SEnji Cooper 
4098cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4099cdebaff8SEnji Cooper 
4100cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4101cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4102cdebaff8SEnji Cooper }
4103cdebaff8SEnji Cooper #endif
4104cdebaff8SEnji Cooper 
4105cdebaff8SEnji Cooper #if defined(HAVE_GPREGS)
4106cdebaff8SEnji Cooper ATF_TC(regs3);
ATF_TC_HEAD(regs3,tc)4107cdebaff8SEnji Cooper ATF_TC_HEAD(regs3, tc)
4108cdebaff8SEnji Cooper {
4109cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4110cdebaff8SEnji Cooper 	    "Verify plain PT_GETREGS call and retrieve SP");
4111cdebaff8SEnji Cooper }
4112cdebaff8SEnji Cooper 
ATF_TC_BODY(regs3,tc)4113cdebaff8SEnji Cooper ATF_TC_BODY(regs3, tc)
4114cdebaff8SEnji Cooper {
4115cdebaff8SEnji Cooper 	const int exitval = 5;
4116cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4117cdebaff8SEnji Cooper 	pid_t child, wpid;
4118cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4119cdebaff8SEnji Cooper 	int status;
4120cdebaff8SEnji Cooper #endif
4121cdebaff8SEnji Cooper 	struct reg r;
4122cdebaff8SEnji Cooper 
4123cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4124cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4125cdebaff8SEnji Cooper 	if (child == 0) {
4126cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4127cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4128cdebaff8SEnji Cooper 
4129cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4130cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4131cdebaff8SEnji Cooper 
4132cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4133cdebaff8SEnji Cooper 		_exit(exitval);
4134cdebaff8SEnji Cooper 	}
4135cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4136cdebaff8SEnji Cooper 
4137cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4138cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4139cdebaff8SEnji Cooper 
4140cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4141cdebaff8SEnji Cooper 
4142cdebaff8SEnji Cooper 	printf("Call GETREGS for the child process\n");
4143cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETREGS, child, &r, 0) != -1);
4144cdebaff8SEnji Cooper 
4145cdebaff8SEnji Cooper 	printf("Retrieved SP=%" PRIxREGISTER "\n", PTRACE_REG_SP(&r));
4146cdebaff8SEnji Cooper 
4147cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4148cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4149cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4150cdebaff8SEnji Cooper 
4151cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4152cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4153cdebaff8SEnji Cooper 
4154cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4155cdebaff8SEnji Cooper 
4156cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4157cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4158cdebaff8SEnji Cooper }
4159cdebaff8SEnji Cooper #endif
4160cdebaff8SEnji Cooper 
4161cdebaff8SEnji Cooper #if defined(HAVE_GPREGS)
4162cdebaff8SEnji Cooper ATF_TC(regs4);
ATF_TC_HEAD(regs4,tc)4163cdebaff8SEnji Cooper ATF_TC_HEAD(regs4, tc)
4164cdebaff8SEnji Cooper {
4165cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4166cdebaff8SEnji Cooper 	    "Verify plain PT_GETREGS call and retrieve INTRV");
4167cdebaff8SEnji Cooper }
4168cdebaff8SEnji Cooper 
ATF_TC_BODY(regs4,tc)4169cdebaff8SEnji Cooper ATF_TC_BODY(regs4, tc)
4170cdebaff8SEnji Cooper {
4171cdebaff8SEnji Cooper 	const int exitval = 5;
4172cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4173cdebaff8SEnji Cooper 	pid_t child, wpid;
4174cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4175cdebaff8SEnji Cooper 	int status;
4176cdebaff8SEnji Cooper #endif
4177cdebaff8SEnji Cooper 	struct reg r;
4178cdebaff8SEnji Cooper 
4179cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4180cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4181cdebaff8SEnji Cooper 	if (child == 0) {
4182cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4183cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4184cdebaff8SEnji Cooper 
4185cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4186cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4187cdebaff8SEnji Cooper 
4188cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4189cdebaff8SEnji Cooper 		_exit(exitval);
4190cdebaff8SEnji Cooper 	}
4191cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4192cdebaff8SEnji Cooper 
4193cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4194cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4195cdebaff8SEnji Cooper 
4196cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4197cdebaff8SEnji Cooper 
4198cdebaff8SEnji Cooper 	printf("Call GETREGS for the child process\n");
4199cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETREGS, child, &r, 0) != -1);
4200cdebaff8SEnji Cooper 
4201cdebaff8SEnji Cooper 	printf("Retrieved INTRV=%" PRIxREGISTER "\n", PTRACE_REG_INTRV(&r));
4202cdebaff8SEnji Cooper 
4203cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4204cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4205cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4206cdebaff8SEnji Cooper 
4207cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4208cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4209cdebaff8SEnji Cooper 
4210cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4211cdebaff8SEnji Cooper 
4212cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4213cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4214cdebaff8SEnji Cooper }
4215cdebaff8SEnji Cooper #endif
4216cdebaff8SEnji Cooper 
4217cdebaff8SEnji Cooper #if defined(HAVE_GPREGS)
4218cdebaff8SEnji Cooper ATF_TC(regs5);
ATF_TC_HEAD(regs5,tc)4219cdebaff8SEnji Cooper ATF_TC_HEAD(regs5, tc)
4220cdebaff8SEnji Cooper {
4221cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4222cdebaff8SEnji Cooper 	    "Verify PT_GETREGS and PT_SETREGS calls without changing regs");
4223cdebaff8SEnji Cooper }
4224cdebaff8SEnji Cooper 
ATF_TC_BODY(regs5,tc)4225cdebaff8SEnji Cooper ATF_TC_BODY(regs5, tc)
4226cdebaff8SEnji Cooper {
4227cdebaff8SEnji Cooper 	const int exitval = 5;
4228cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4229cdebaff8SEnji Cooper 	pid_t child, wpid;
4230cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4231cdebaff8SEnji Cooper 	int status;
4232cdebaff8SEnji Cooper #endif
4233cdebaff8SEnji Cooper 	struct reg r;
4234cdebaff8SEnji Cooper 
4235cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4236cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4237cdebaff8SEnji Cooper 	if (child == 0) {
4238cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4239cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4240cdebaff8SEnji Cooper 
4241cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4242cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4243cdebaff8SEnji Cooper 
4244cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4245cdebaff8SEnji Cooper 		_exit(exitval);
4246cdebaff8SEnji Cooper 	}
4247cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4248cdebaff8SEnji Cooper 
4249cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4250cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4251cdebaff8SEnji Cooper 
4252cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4253cdebaff8SEnji Cooper 
4254cdebaff8SEnji Cooper 	printf("Call GETREGS for the child process\n");
4255cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETREGS, child, &r, 0) != -1);
4256cdebaff8SEnji Cooper 
4257cdebaff8SEnji Cooper 	printf("Call SETREGS for the child process (without changed regs)\n");
4258cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETREGS, child, &r, 0) != -1);
4259cdebaff8SEnji Cooper 
4260cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4261cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4262cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4263cdebaff8SEnji Cooper 
4264cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4265cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4266cdebaff8SEnji Cooper 
4267cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4268cdebaff8SEnji Cooper 
4269cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4270cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4271cdebaff8SEnji Cooper }
4272cdebaff8SEnji Cooper #endif
4273cdebaff8SEnji Cooper 
4274cdebaff8SEnji Cooper #if defined(HAVE_FPREGS)
4275cdebaff8SEnji Cooper ATF_TC(fpregs1);
ATF_TC_HEAD(fpregs1,tc)4276cdebaff8SEnji Cooper ATF_TC_HEAD(fpregs1, tc)
4277cdebaff8SEnji Cooper {
4278cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4279cdebaff8SEnji Cooper 	    "Verify plain PT_GETFPREGS call without further steps");
4280cdebaff8SEnji Cooper }
4281cdebaff8SEnji Cooper 
ATF_TC_BODY(fpregs1,tc)4282cdebaff8SEnji Cooper ATF_TC_BODY(fpregs1, tc)
4283cdebaff8SEnji Cooper {
4284cdebaff8SEnji Cooper 	const int exitval = 5;
4285cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4286cdebaff8SEnji Cooper 	pid_t child, wpid;
4287cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4288cdebaff8SEnji Cooper 	int status;
4289cdebaff8SEnji Cooper #endif
4290cdebaff8SEnji Cooper 	struct fpreg r;
4291cdebaff8SEnji Cooper 
4292cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4293cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4294cdebaff8SEnji Cooper 	if (child == 0) {
4295cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4296cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4297cdebaff8SEnji Cooper 
4298cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4299cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4300cdebaff8SEnji Cooper 
4301cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4302cdebaff8SEnji Cooper 		_exit(exitval);
4303cdebaff8SEnji Cooper 	}
4304cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4305cdebaff8SEnji Cooper 
4306cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4307cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4308cdebaff8SEnji Cooper 
4309cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4310cdebaff8SEnji Cooper 
4311cdebaff8SEnji Cooper 	printf("Call GETFPREGS for the child process\n");
4312cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETFPREGS, child, &r, 0) != -1);
4313cdebaff8SEnji Cooper 
4314cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4315cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4316cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4317cdebaff8SEnji Cooper 
4318cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4319cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4320cdebaff8SEnji Cooper 
4321cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4322cdebaff8SEnji Cooper 
4323cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4324cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4325cdebaff8SEnji Cooper }
4326cdebaff8SEnji Cooper #endif
4327cdebaff8SEnji Cooper 
4328cdebaff8SEnji Cooper #if defined(HAVE_FPREGS)
4329cdebaff8SEnji Cooper ATF_TC(fpregs2);
ATF_TC_HEAD(fpregs2,tc)4330cdebaff8SEnji Cooper ATF_TC_HEAD(fpregs2, tc)
4331cdebaff8SEnji Cooper {
4332cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4333cdebaff8SEnji Cooper 	    "Verify PT_GETFPREGS and PT_SETFPREGS calls without changing "
4334cdebaff8SEnji Cooper 	    "regs");
4335cdebaff8SEnji Cooper }
4336cdebaff8SEnji Cooper 
ATF_TC_BODY(fpregs2,tc)4337cdebaff8SEnji Cooper ATF_TC_BODY(fpregs2, tc)
4338cdebaff8SEnji Cooper {
4339cdebaff8SEnji Cooper 	const int exitval = 5;
4340cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4341cdebaff8SEnji Cooper 	pid_t child, wpid;
4342cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4343cdebaff8SEnji Cooper 	int status;
4344cdebaff8SEnji Cooper #endif
4345cdebaff8SEnji Cooper 	struct fpreg r;
4346cdebaff8SEnji Cooper 
4347cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4348cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4349cdebaff8SEnji Cooper 	if (child == 0) {
4350cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4351cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4352cdebaff8SEnji Cooper 
4353cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4354cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4355cdebaff8SEnji Cooper 
4356cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4357cdebaff8SEnji Cooper 		_exit(exitval);
4358cdebaff8SEnji Cooper 	}
4359cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4360cdebaff8SEnji Cooper 
4361cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4362cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4363cdebaff8SEnji Cooper 
4364cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4365cdebaff8SEnji Cooper 
4366cdebaff8SEnji Cooper 	printf("Call GETFPREGS for the child process\n");
4367cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GETFPREGS, child, &r, 0) != -1);
4368cdebaff8SEnji Cooper 
4369cdebaff8SEnji Cooper 	printf("Call SETFPREGS for the child (without changed regs)\n");
4370cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SETFPREGS, child, &r, 0) != -1);
4371cdebaff8SEnji Cooper 
4372cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4373cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4374cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4375cdebaff8SEnji Cooper 
4376cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4377cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4378cdebaff8SEnji Cooper 
4379cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4380cdebaff8SEnji Cooper 
4381cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4382cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4383cdebaff8SEnji Cooper }
4384cdebaff8SEnji Cooper #endif
4385cdebaff8SEnji Cooper 
4386cdebaff8SEnji Cooper #if defined(PT_STEP)
4387cdebaff8SEnji Cooper ATF_TC(step1);
ATF_TC_HEAD(step1,tc)4388cdebaff8SEnji Cooper ATF_TC_HEAD(step1, tc)
4389cdebaff8SEnji Cooper {
4390cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4391cdebaff8SEnji Cooper 	    "Verify single PT_STEP call");
4392cdebaff8SEnji Cooper }
4393cdebaff8SEnji Cooper 
ATF_TC_BODY(step1,tc)4394cdebaff8SEnji Cooper ATF_TC_BODY(step1, tc)
4395cdebaff8SEnji Cooper {
4396cdebaff8SEnji Cooper 	const int exitval = 5;
4397cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4398cdebaff8SEnji Cooper 	pid_t child, wpid;
4399cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4400cdebaff8SEnji Cooper 	int status;
4401cdebaff8SEnji Cooper #endif
4402cdebaff8SEnji Cooper 	int happy;
4403cdebaff8SEnji Cooper 
4404cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4405cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4406cdebaff8SEnji Cooper 	if (child == 0) {
4407cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4408cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4409cdebaff8SEnji Cooper 
4410cdebaff8SEnji Cooper 		happy = check_happy(100);
4411cdebaff8SEnji Cooper 
4412cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4413cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4414cdebaff8SEnji Cooper 
4415cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(happy, check_happy(100));
4416cdebaff8SEnji Cooper 
4417cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4418cdebaff8SEnji Cooper 		_exit(exitval);
4419cdebaff8SEnji Cooper 	}
4420cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4421cdebaff8SEnji Cooper 
4422cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4423cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4424cdebaff8SEnji Cooper 
4425cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4426cdebaff8SEnji Cooper 
4427cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4428cdebaff8SEnji Cooper 	    "without signal to be sent (use PT_STEP)\n");
4429cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) != -1);
4430cdebaff8SEnji Cooper 
4431cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4432cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4433cdebaff8SEnji Cooper 
4434cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
4435cdebaff8SEnji Cooper 
4436cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4437cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4438cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4439cdebaff8SEnji Cooper 
4440cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4441cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4442cdebaff8SEnji Cooper 
4443cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4444cdebaff8SEnji Cooper 
4445cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4446cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4447cdebaff8SEnji Cooper }
4448cdebaff8SEnji Cooper #endif
4449cdebaff8SEnji Cooper 
4450cdebaff8SEnji Cooper #if defined(PT_STEP)
4451cdebaff8SEnji Cooper ATF_TC(step2);
ATF_TC_HEAD(step2,tc)4452cdebaff8SEnji Cooper ATF_TC_HEAD(step2, tc)
4453cdebaff8SEnji Cooper {
4454cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4455cdebaff8SEnji Cooper 	    "Verify PT_STEP called twice");
4456cdebaff8SEnji Cooper }
4457cdebaff8SEnji Cooper 
ATF_TC_BODY(step2,tc)4458cdebaff8SEnji Cooper ATF_TC_BODY(step2, tc)
4459cdebaff8SEnji Cooper {
4460cdebaff8SEnji Cooper 	const int exitval = 5;
4461cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4462cdebaff8SEnji Cooper 	pid_t child, wpid;
4463cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4464cdebaff8SEnji Cooper 	int status;
4465cdebaff8SEnji Cooper #endif
4466cdebaff8SEnji Cooper 	int happy;
4467cdebaff8SEnji Cooper 	int N = 2;
4468cdebaff8SEnji Cooper 
4469cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4470cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4471cdebaff8SEnji Cooper 	if (child == 0) {
4472cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4473cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4474cdebaff8SEnji Cooper 
4475cdebaff8SEnji Cooper 		happy = check_happy(999);
4476cdebaff8SEnji Cooper 
4477cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4478cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4479cdebaff8SEnji Cooper 
4480cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(happy, check_happy(999));
4481cdebaff8SEnji Cooper 
4482cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4483cdebaff8SEnji Cooper 		_exit(exitval);
4484cdebaff8SEnji Cooper 	}
4485cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4486cdebaff8SEnji Cooper 
4487cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4488cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4489cdebaff8SEnji Cooper 
4490cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4491cdebaff8SEnji Cooper 
4492cdebaff8SEnji Cooper 	while (N --> 0) {
4493cdebaff8SEnji Cooper 		printf("Before resuming the child process where it left off "
4494cdebaff8SEnji Cooper 		    "and without signal to be sent (use PT_STEP)\n");
4495cdebaff8SEnji Cooper 		ATF_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) != -1);
4496cdebaff8SEnji Cooper 
4497cdebaff8SEnji Cooper 		printf("Before calling %s() for the child\n", TWAIT_FNAME);
4498cdebaff8SEnji Cooper 		TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0),
4499cdebaff8SEnji Cooper 		    child);
4500cdebaff8SEnji Cooper 
4501cdebaff8SEnji Cooper 		validate_status_stopped(status, SIGTRAP);
4502cdebaff8SEnji Cooper 	}
4503cdebaff8SEnji Cooper 
4504cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4505cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4506cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4507cdebaff8SEnji Cooper 
4508cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4509cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4510cdebaff8SEnji Cooper 
4511cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4512cdebaff8SEnji Cooper 
4513cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4514cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4515cdebaff8SEnji Cooper }
4516cdebaff8SEnji Cooper #endif
4517cdebaff8SEnji Cooper 
4518cdebaff8SEnji Cooper #if defined(PT_STEP)
4519cdebaff8SEnji Cooper ATF_TC(step3);
ATF_TC_HEAD(step3,tc)4520cdebaff8SEnji Cooper ATF_TC_HEAD(step3, tc)
4521cdebaff8SEnji Cooper {
4522cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4523cdebaff8SEnji Cooper 	    "Verify PT_STEP called three times");
4524cdebaff8SEnji Cooper }
4525cdebaff8SEnji Cooper 
ATF_TC_BODY(step3,tc)4526cdebaff8SEnji Cooper ATF_TC_BODY(step3, tc)
4527cdebaff8SEnji Cooper {
4528cdebaff8SEnji Cooper 	const int exitval = 5;
4529cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4530cdebaff8SEnji Cooper 	pid_t child, wpid;
4531cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4532cdebaff8SEnji Cooper 	int status;
4533cdebaff8SEnji Cooper #endif
4534cdebaff8SEnji Cooper 	int happy;
4535cdebaff8SEnji Cooper 	int N = 3;
4536cdebaff8SEnji Cooper 
4537cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4538cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4539cdebaff8SEnji Cooper 	if (child == 0) {
4540cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4541cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4542cdebaff8SEnji Cooper 
4543cdebaff8SEnji Cooper 		happy = check_happy(999);
4544cdebaff8SEnji Cooper 
4545cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4546cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4547cdebaff8SEnji Cooper 
4548cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(happy, check_happy(999));
4549cdebaff8SEnji Cooper 
4550cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4551cdebaff8SEnji Cooper 		_exit(exitval);
4552cdebaff8SEnji Cooper 	}
4553cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4554cdebaff8SEnji Cooper 
4555cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4556cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4557cdebaff8SEnji Cooper 
4558cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4559cdebaff8SEnji Cooper 
4560cdebaff8SEnji Cooper 	while (N --> 0) {
4561cdebaff8SEnji Cooper 		printf("Before resuming the child process where it left off "
4562cdebaff8SEnji Cooper 		    "and without signal to be sent (use PT_STEP)\n");
4563cdebaff8SEnji Cooper 		ATF_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) != -1);
4564cdebaff8SEnji Cooper 
4565cdebaff8SEnji Cooper 		printf("Before calling %s() for the child\n", TWAIT_FNAME);
4566cdebaff8SEnji Cooper 		TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0),
4567cdebaff8SEnji Cooper 		    child);
4568cdebaff8SEnji Cooper 
4569cdebaff8SEnji Cooper 		validate_status_stopped(status, SIGTRAP);
4570cdebaff8SEnji Cooper 	}
4571cdebaff8SEnji Cooper 
4572cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4573cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4574cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4575cdebaff8SEnji Cooper 
4576cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4577cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4578cdebaff8SEnji Cooper 
4579cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4580cdebaff8SEnji Cooper 
4581cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4582cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4583cdebaff8SEnji Cooper }
4584cdebaff8SEnji Cooper #endif
4585cdebaff8SEnji Cooper 
4586cdebaff8SEnji Cooper #if defined(PT_STEP)
4587cdebaff8SEnji Cooper ATF_TC(step4);
ATF_TC_HEAD(step4,tc)4588cdebaff8SEnji Cooper ATF_TC_HEAD(step4, tc)
4589cdebaff8SEnji Cooper {
4590cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4591cdebaff8SEnji Cooper 	    "Verify PT_STEP called four times");
4592cdebaff8SEnji Cooper }
4593cdebaff8SEnji Cooper 
ATF_TC_BODY(step4,tc)4594cdebaff8SEnji Cooper ATF_TC_BODY(step4, tc)
4595cdebaff8SEnji Cooper {
4596cdebaff8SEnji Cooper 	const int exitval = 5;
4597cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4598cdebaff8SEnji Cooper 	pid_t child, wpid;
4599cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4600cdebaff8SEnji Cooper 	int status;
4601cdebaff8SEnji Cooper #endif
4602cdebaff8SEnji Cooper 	int happy;
4603cdebaff8SEnji Cooper 	int N = 4;
4604cdebaff8SEnji Cooper 
4605cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4606cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4607cdebaff8SEnji Cooper 	if (child == 0) {
4608cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4609cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4610cdebaff8SEnji Cooper 
4611cdebaff8SEnji Cooper 		happy = check_happy(999);
4612cdebaff8SEnji Cooper 
4613cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4614cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4615cdebaff8SEnji Cooper 
4616cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(happy, check_happy(999));
4617cdebaff8SEnji Cooper 
4618cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4619cdebaff8SEnji Cooper 		_exit(exitval);
4620cdebaff8SEnji Cooper 	}
4621cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4622cdebaff8SEnji Cooper 
4623cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4624cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4625cdebaff8SEnji Cooper 
4626cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4627cdebaff8SEnji Cooper 
4628cdebaff8SEnji Cooper 	while (N --> 0) {
4629cdebaff8SEnji Cooper 		printf("Before resuming the child process where it left off "
4630cdebaff8SEnji Cooper 		    "and without signal to be sent (use PT_STEP)\n");
4631cdebaff8SEnji Cooper 		ATF_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) != -1);
4632cdebaff8SEnji Cooper 
4633cdebaff8SEnji Cooper 		printf("Before calling %s() for the child\n", TWAIT_FNAME);
4634cdebaff8SEnji Cooper 		TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0),
4635cdebaff8SEnji Cooper 		    child);
4636cdebaff8SEnji Cooper 
4637cdebaff8SEnji Cooper 		validate_status_stopped(status, SIGTRAP);
4638cdebaff8SEnji Cooper 	}
4639cdebaff8SEnji Cooper 
4640cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4641cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4642cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4643cdebaff8SEnji Cooper 
4644cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4645cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4646cdebaff8SEnji Cooper 
4647cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4648cdebaff8SEnji Cooper 
4649cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4650cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4651cdebaff8SEnji Cooper }
4652cdebaff8SEnji Cooper #endif
4653cdebaff8SEnji Cooper 
4654cdebaff8SEnji Cooper ATF_TC(kill1);
ATF_TC_HEAD(kill1,tc)4655cdebaff8SEnji Cooper ATF_TC_HEAD(kill1, tc)
4656cdebaff8SEnji Cooper {
4657cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4658cdebaff8SEnji Cooper 	    "Verify that PT_CONTINUE with SIGKILL terminates child");
4659cdebaff8SEnji Cooper }
4660cdebaff8SEnji Cooper 
ATF_TC_BODY(kill1,tc)4661cdebaff8SEnji Cooper ATF_TC_BODY(kill1, tc)
4662cdebaff8SEnji Cooper {
4663cdebaff8SEnji Cooper 	const int sigval = SIGSTOP, sigsent = SIGKILL;
4664cdebaff8SEnji Cooper 	pid_t child, wpid;
4665cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4666cdebaff8SEnji Cooper 	int status;
4667cdebaff8SEnji Cooper #endif
4668cdebaff8SEnji Cooper 
4669cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4670cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4671cdebaff8SEnji Cooper 	if (child == 0) {
4672cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4673cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4674cdebaff8SEnji Cooper 
4675cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4676cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4677cdebaff8SEnji Cooper 
4678cdebaff8SEnji Cooper 		/* NOTREACHED */
4679cdebaff8SEnji Cooper 		FORKEE_ASSERTX(0 &&
4680cdebaff8SEnji Cooper 		    "Child should be terminated by a signal from its parent");
4681cdebaff8SEnji Cooper 	}
4682cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4683cdebaff8SEnji Cooper 
4684cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4685cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4686cdebaff8SEnji Cooper 
4687cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4688cdebaff8SEnji Cooper 
4689cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4690cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4691cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigsent) != -1);
4692cdebaff8SEnji Cooper 
4693cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4694cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4695cdebaff8SEnji Cooper 
4696cdebaff8SEnji Cooper 	validate_status_signaled(status, sigsent, 0);
4697cdebaff8SEnji Cooper 
4698cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4699cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4700cdebaff8SEnji Cooper }
4701cdebaff8SEnji Cooper 
4702cdebaff8SEnji Cooper ATF_TC(kill2);
ATF_TC_HEAD(kill2,tc)4703cdebaff8SEnji Cooper ATF_TC_HEAD(kill2, tc)
4704cdebaff8SEnji Cooper {
4705cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4706cdebaff8SEnji Cooper 	    "Verify that PT_KILL terminates child");
4707cdebaff8SEnji Cooper }
4708cdebaff8SEnji Cooper 
ATF_TC_BODY(kill2,tc)4709cdebaff8SEnji Cooper ATF_TC_BODY(kill2, tc)
4710cdebaff8SEnji Cooper {
4711cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4712cdebaff8SEnji Cooper 	pid_t child, wpid;
4713cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4714cdebaff8SEnji Cooper 	int status;
4715cdebaff8SEnji Cooper #endif
4716cdebaff8SEnji Cooper 
4717cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4718cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4719cdebaff8SEnji Cooper 	if (child == 0) {
4720cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4721cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4722cdebaff8SEnji Cooper 
4723cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4724cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4725cdebaff8SEnji Cooper 
4726cdebaff8SEnji Cooper 		/* NOTREACHED */
4727cdebaff8SEnji Cooper 		FORKEE_ASSERTX(0 &&
4728cdebaff8SEnji Cooper 		    "Child should be terminated by a signal from its parent");
4729cdebaff8SEnji Cooper 	}
4730cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4731cdebaff8SEnji Cooper 
4732cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4733cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4734cdebaff8SEnji Cooper 
4735cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4736cdebaff8SEnji Cooper 
4737cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4738cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4739cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_KILL, child, (void*)1, 0) != -1);
4740cdebaff8SEnji Cooper 
4741cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4742cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4743cdebaff8SEnji Cooper 
4744cdebaff8SEnji Cooper 	validate_status_signaled(status, SIGKILL, 0);
4745cdebaff8SEnji Cooper 
4746cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4747cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4748cdebaff8SEnji Cooper }
4749cdebaff8SEnji Cooper 
4750cdebaff8SEnji Cooper ATF_TC(lwpinfo1);
ATF_TC_HEAD(lwpinfo1,tc)4751cdebaff8SEnji Cooper ATF_TC_HEAD(lwpinfo1, tc)
4752cdebaff8SEnji Cooper {
4753cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4754cdebaff8SEnji Cooper 	    "Verify basic LWPINFO call for single thread (PT_TRACE_ME)");
4755cdebaff8SEnji Cooper }
4756cdebaff8SEnji Cooper 
ATF_TC_BODY(lwpinfo1,tc)4757cdebaff8SEnji Cooper ATF_TC_BODY(lwpinfo1, tc)
4758cdebaff8SEnji Cooper {
4759cdebaff8SEnji Cooper 	const int exitval = 5;
4760cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
4761cdebaff8SEnji Cooper 	pid_t child, wpid;
4762cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4763cdebaff8SEnji Cooper 	int status;
4764cdebaff8SEnji Cooper #endif
4765cdebaff8SEnji Cooper 	struct ptrace_lwpinfo info = {0, 0};
4766cdebaff8SEnji Cooper 
4767cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4768cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4769cdebaff8SEnji Cooper 	if (child == 0) {
4770cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4771cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4772cdebaff8SEnji Cooper 
4773cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4774cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4775cdebaff8SEnji Cooper 
4776cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4777cdebaff8SEnji Cooper 		_exit(exitval);
4778cdebaff8SEnji Cooper 	}
4779cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4780cdebaff8SEnji Cooper 
4781cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4782cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4783cdebaff8SEnji Cooper 
4784cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4785cdebaff8SEnji Cooper 
4786cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_LWPINFO for child\n");
4787cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_LWPINFO, child, &info, sizeof(info)) != -1);
4788cdebaff8SEnji Cooper 
4789cdebaff8SEnji Cooper 	printf("Assert that there exists a thread\n");
4790cdebaff8SEnji Cooper 	ATF_REQUIRE(info.pl_lwpid > 0);
4791cdebaff8SEnji Cooper 
4792cdebaff8SEnji Cooper 	printf("Assert that lwp thread %d received event PL_EVENT_SIGNAL\n",
4793cdebaff8SEnji Cooper 	    info.pl_lwpid);
4794cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ_MSG(info.pl_event, PL_EVENT_SIGNAL,
4795cdebaff8SEnji Cooper 	    "Received event %d != expected event %d",
4796cdebaff8SEnji Cooper 	    info.pl_event, PL_EVENT_SIGNAL);
4797cdebaff8SEnji Cooper 
4798cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_LWPINFO for child\n");
4799cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_LWPINFO, child, &info, sizeof(info)) != -1);
4800cdebaff8SEnji Cooper 
4801cdebaff8SEnji Cooper 	printf("Assert that there are no more lwp threads in child\n");
4802cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.pl_lwpid, 0);
4803cdebaff8SEnji Cooper 
4804cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4805cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4806cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4807cdebaff8SEnji Cooper 
4808cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4809cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4810cdebaff8SEnji Cooper 
4811cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4812cdebaff8SEnji Cooper 
4813cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4814cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4815cdebaff8SEnji Cooper }
4816cdebaff8SEnji Cooper 
4817cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
4818cdebaff8SEnji Cooper ATF_TC(lwpinfo2);
ATF_TC_HEAD(lwpinfo2,tc)4819cdebaff8SEnji Cooper ATF_TC_HEAD(lwpinfo2, tc)
4820cdebaff8SEnji Cooper {
4821cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4822cdebaff8SEnji Cooper 	    "Verify basic LWPINFO call for single thread (PT_ATTACH from "
4823cdebaff8SEnji Cooper 	    "tracer)");
4824cdebaff8SEnji Cooper }
4825cdebaff8SEnji Cooper 
ATF_TC_BODY(lwpinfo2,tc)4826cdebaff8SEnji Cooper ATF_TC_BODY(lwpinfo2, tc)
4827cdebaff8SEnji Cooper {
4828cdebaff8SEnji Cooper 	struct msg_fds parent_tracee, parent_tracer;
4829cdebaff8SEnji Cooper 	const int exitval_tracee = 5;
4830cdebaff8SEnji Cooper 	const int exitval_tracer = 10;
4831cdebaff8SEnji Cooper 	pid_t tracee, tracer, wpid;
4832cdebaff8SEnji Cooper 	uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
4833cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4834cdebaff8SEnji Cooper 	int status;
4835cdebaff8SEnji Cooper #endif
4836cdebaff8SEnji Cooper 	struct ptrace_lwpinfo info = {0, 0};
4837cdebaff8SEnji Cooper 
4838cdebaff8SEnji Cooper 	printf("Spawn tracee\n");
4839cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracee) == 0);
4840cdebaff8SEnji Cooper 	ATF_REQUIRE(msg_open(&parent_tracer) == 0);
4841cdebaff8SEnji Cooper 	tracee = atf_utils_fork();
4842cdebaff8SEnji Cooper 	if (tracee == 0) {
4843cdebaff8SEnji Cooper 
4844cdebaff8SEnji Cooper 		/* Wait for message from the parent */
4845cdebaff8SEnji Cooper 		CHILD_TO_PARENT("tracee ready", parent_tracee, msg);
4846cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("tracee exit", parent_tracee, msg);
4847cdebaff8SEnji Cooper 
4848cdebaff8SEnji Cooper 		_exit(exitval_tracee);
4849cdebaff8SEnji Cooper 	}
4850cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("tracee ready", parent_tracee, msg);
4851cdebaff8SEnji Cooper 
4852cdebaff8SEnji Cooper 	printf("Spawn debugger\n");
4853cdebaff8SEnji Cooper 	tracer = atf_utils_fork();
4854cdebaff8SEnji Cooper 	if (tracer == 0) {
4855cdebaff8SEnji Cooper 		/* No IPC to communicate with the child */
4856cdebaff8SEnji Cooper 		printf("Before calling PT_ATTACH from tracee %d\n", getpid());
4857cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_ATTACH, tracee, NULL, 0) != -1);
4858cdebaff8SEnji Cooper 
4859cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it was stopped w/ SIGSTOP */
4860cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
4861cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
4862cdebaff8SEnji Cooper 
4863cdebaff8SEnji Cooper 		forkee_status_stopped(status, SIGSTOP);
4864cdebaff8SEnji Cooper 
4865cdebaff8SEnji Cooper 		printf("Before calling ptrace(2) with PT_LWPINFO for child\n");
4866cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &info, sizeof(info))
4867cdebaff8SEnji Cooper 		    != -1);
4868cdebaff8SEnji Cooper 
4869cdebaff8SEnji Cooper 		printf("Assert that there exists a thread\n");
4870cdebaff8SEnji Cooper 		FORKEE_ASSERTX(info.pl_lwpid > 0);
4871cdebaff8SEnji Cooper 
4872cdebaff8SEnji Cooper 		printf("Assert that lwp thread %d received event "
4873cdebaff8SEnji Cooper 		    "PL_EVENT_SIGNAL\n", info.pl_lwpid);
4874cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(info.pl_event, PL_EVENT_SIGNAL);
4875cdebaff8SEnji Cooper 
4876cdebaff8SEnji Cooper 		printf("Before calling ptrace(2) with PT_LWPINFO for child\n");
4877cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_LWPINFO, tracee, &info, sizeof(info))
4878cdebaff8SEnji Cooper 		    != -1);
4879cdebaff8SEnji Cooper 
4880cdebaff8SEnji Cooper 		printf("Assert that there are no more lwp threads in child\n");
4881cdebaff8SEnji Cooper 		FORKEE_ASSERTX(info.pl_lwpid == 0);
4882cdebaff8SEnji Cooper 
4883cdebaff8SEnji Cooper 		/* Resume tracee with PT_CONTINUE */
4884cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_CONTINUE, tracee, (void *)1, 0) != -1);
4885cdebaff8SEnji Cooper 
4886cdebaff8SEnji Cooper 		/* Inform parent that tracer has attached to tracee */
4887cdebaff8SEnji Cooper 		CHILD_TO_PARENT("tracer ready", parent_tracer, msg);
4888cdebaff8SEnji Cooper 		/* Wait for parent */
4889cdebaff8SEnji Cooper 		CHILD_FROM_PARENT("tracer wait", parent_tracer, msg);
4890cdebaff8SEnji Cooper 
4891cdebaff8SEnji Cooper 		/* Wait for tracee and assert that it exited */
4892cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS(
4893cdebaff8SEnji Cooper 		    wpid = TWAIT_GENERIC(tracee, &status, 0), tracee);
4894cdebaff8SEnji Cooper 
4895cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval_tracee);
4896cdebaff8SEnji Cooper 
4897cdebaff8SEnji Cooper 		printf("Before exiting of the tracer process\n");
4898cdebaff8SEnji Cooper 		_exit(exitval_tracer);
4899cdebaff8SEnji Cooper 	}
4900cdebaff8SEnji Cooper 
4901cdebaff8SEnji Cooper 	printf("Wait for the tracer to attach to the tracee\n");
4902cdebaff8SEnji Cooper 	PARENT_FROM_CHILD("tracer ready", parent_tracer, msg);
4903cdebaff8SEnji Cooper 
4904cdebaff8SEnji Cooper 	printf("Resume the tracee and let it exit\n");
4905cdebaff8SEnji Cooper 	PARENT_TO_CHILD("tracee exit", parent_tracee, msg);
4906cdebaff8SEnji Cooper 
4907cdebaff8SEnji Cooper 	printf("Detect that tracee is zombie\n");
4908cdebaff8SEnji Cooper 	await_zombie(tracee);
4909cdebaff8SEnji Cooper 
4910cdebaff8SEnji Cooper 	printf("Assert that there is no status about tracee - "
4911cdebaff8SEnji Cooper 	    "Tracer must detect zombie first - calling %s()\n", TWAIT_FNAME);
4912cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(
4913cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(tracee, &status, WNOHANG), 0);
4914cdebaff8SEnji Cooper 
4915cdebaff8SEnji Cooper 	printf("Resume the tracer and let it detect exited tracee\n");
4916cdebaff8SEnji Cooper 	PARENT_TO_CHILD("tracer wait", parent_tracer, msg);
4917cdebaff8SEnji Cooper 
4918cdebaff8SEnji Cooper 	printf("Wait for tracer to finish its job and exit - calling %s()\n",
4919cdebaff8SEnji Cooper 	    TWAIT_FNAME);
4920cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracer, &status, 0),
4921cdebaff8SEnji Cooper 	    tracer);
4922cdebaff8SEnji Cooper 
4923cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracer);
4924cdebaff8SEnji Cooper 
4925cdebaff8SEnji Cooper 	printf("Wait for tracee to finish its job and exit - calling %s()\n",
4926cdebaff8SEnji Cooper 	    TWAIT_FNAME);
4927cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(tracee, &status, WNOHANG),
4928cdebaff8SEnji Cooper 	    tracee);
4929cdebaff8SEnji Cooper 
4930cdebaff8SEnji Cooper 	validate_status_exited(status, exitval_tracee);
4931cdebaff8SEnji Cooper 
4932cdebaff8SEnji Cooper 	msg_close(&parent_tracer);
4933cdebaff8SEnji Cooper 	msg_close(&parent_tracee);
4934cdebaff8SEnji Cooper }
4935cdebaff8SEnji Cooper #endif
4936cdebaff8SEnji Cooper 
4937cdebaff8SEnji Cooper ATF_TC(siginfo1);
ATF_TC_HEAD(siginfo1,tc)4938cdebaff8SEnji Cooper ATF_TC_HEAD(siginfo1, tc)
4939cdebaff8SEnji Cooper {
4940cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4941cdebaff8SEnji Cooper 	    "Verify basic PT_GET_SIGINFO call for SIGTRAP from tracee");
4942cdebaff8SEnji Cooper }
4943cdebaff8SEnji Cooper 
ATF_TC_BODY(siginfo1,tc)4944cdebaff8SEnji Cooper ATF_TC_BODY(siginfo1, tc)
4945cdebaff8SEnji Cooper {
4946cdebaff8SEnji Cooper 	const int exitval = 5;
4947cdebaff8SEnji Cooper 	const int sigval = SIGTRAP;
4948cdebaff8SEnji Cooper 	pid_t child, wpid;
4949cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
4950cdebaff8SEnji Cooper 	int status;
4951cdebaff8SEnji Cooper #endif
4952cdebaff8SEnji Cooper 	struct ptrace_siginfo info;
4953cdebaff8SEnji Cooper 	memset(&info, 0, sizeof(info));
4954cdebaff8SEnji Cooper 
4955cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
4956cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
4957cdebaff8SEnji Cooper 	if (child == 0) {
4958cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
4959cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
4960cdebaff8SEnji Cooper 
4961cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
4962cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
4963cdebaff8SEnji Cooper 
4964cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
4965cdebaff8SEnji Cooper 		_exit(exitval);
4966cdebaff8SEnji Cooper 	}
4967cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
4968cdebaff8SEnji Cooper 
4969cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4970cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4971cdebaff8SEnji Cooper 
4972cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
4973cdebaff8SEnji Cooper 
4974cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
4975cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
4976cdebaff8SEnji Cooper 
4977cdebaff8SEnji Cooper 	printf("Signal traced to lwpid=%d\n", info.psi_lwpid);
4978cdebaff8SEnji Cooper 	printf("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
4979cdebaff8SEnji Cooper 	    info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
4980cdebaff8SEnji Cooper 	    info.psi_siginfo.si_errno);
4981cdebaff8SEnji Cooper 
4982cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
4983cdebaff8SEnji Cooper 	    "without signal to be sent\n");
4984cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
4985cdebaff8SEnji Cooper 
4986cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4987cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
4988cdebaff8SEnji Cooper 
4989cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
4990cdebaff8SEnji Cooper 
4991cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
4992cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
4993cdebaff8SEnji Cooper }
4994cdebaff8SEnji Cooper 
4995cdebaff8SEnji Cooper ATF_TC(siginfo2);
ATF_TC_HEAD(siginfo2,tc)4996cdebaff8SEnji Cooper ATF_TC_HEAD(siginfo2, tc)
4997cdebaff8SEnji Cooper {
4998cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
4999cdebaff8SEnji Cooper 	    "Verify basic PT_GET_SIGINFO and PT_SET_SIGINFO calls without "
5000cdebaff8SEnji Cooper 	    "modification of SIGINT from tracee");
5001cdebaff8SEnji Cooper }
5002cdebaff8SEnji Cooper 
5003cdebaff8SEnji Cooper static int siginfo2_caught = 0;
5004cdebaff8SEnji Cooper 
5005cdebaff8SEnji Cooper static void
siginfo2_sighandler(int sig)5006cdebaff8SEnji Cooper siginfo2_sighandler(int sig)
5007cdebaff8SEnji Cooper {
5008cdebaff8SEnji Cooper 	FORKEE_ASSERT_EQ(sig, SIGINT);
5009cdebaff8SEnji Cooper 
5010cdebaff8SEnji Cooper 	++siginfo2_caught;
5011cdebaff8SEnji Cooper }
5012cdebaff8SEnji Cooper 
ATF_TC_BODY(siginfo2,tc)5013cdebaff8SEnji Cooper ATF_TC_BODY(siginfo2, tc)
5014cdebaff8SEnji Cooper {
5015cdebaff8SEnji Cooper 	const int exitval = 5;
5016cdebaff8SEnji Cooper 	const int sigval = SIGINT;
5017cdebaff8SEnji Cooper 	pid_t child, wpid;
5018cdebaff8SEnji Cooper 	struct sigaction sa;
5019cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5020cdebaff8SEnji Cooper 	int status;
5021cdebaff8SEnji Cooper #endif
5022cdebaff8SEnji Cooper 	struct ptrace_siginfo info;
5023cdebaff8SEnji Cooper 	memset(&info, 0, sizeof(info));
5024cdebaff8SEnji Cooper 
5025cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5026cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5027cdebaff8SEnji Cooper 	if (child == 0) {
5028cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5029cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5030cdebaff8SEnji Cooper 
5031cdebaff8SEnji Cooper 		sa.sa_handler = siginfo2_sighandler;
5032cdebaff8SEnji Cooper 		sa.sa_flags = SA_SIGINFO;
5033cdebaff8SEnji Cooper 		sigemptyset(&sa.sa_mask);
5034cdebaff8SEnji Cooper 
5035cdebaff8SEnji Cooper 		FORKEE_ASSERT(sigaction(sigval, &sa, NULL) != -1);
5036cdebaff8SEnji Cooper 
5037cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5038cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5039cdebaff8SEnji Cooper 
5040cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(siginfo2_caught, 1);
5041cdebaff8SEnji Cooper 
5042cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
5043cdebaff8SEnji Cooper 		_exit(exitval);
5044cdebaff8SEnji Cooper 	}
5045cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5046cdebaff8SEnji Cooper 
5047cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5048cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5049cdebaff8SEnji Cooper 
5050cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
5051cdebaff8SEnji Cooper 
5052cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5053cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5054cdebaff8SEnji Cooper 
5055cdebaff8SEnji Cooper 	printf("Signal traced to lwpid=%d\n", info.psi_lwpid);
5056cdebaff8SEnji Cooper 	printf("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
5057cdebaff8SEnji Cooper 	    info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
5058cdebaff8SEnji Cooper 	    info.psi_siginfo.si_errno);
5059cdebaff8SEnji Cooper 
5060cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_SET_SIGINFO for child\n");
5061cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_SIGINFO, child, &info, sizeof(info)) != -1);
5062cdebaff8SEnji Cooper 
5063cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5064cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5065cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigval) != -1);
5066cdebaff8SEnji Cooper 
5067cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5068cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5069cdebaff8SEnji Cooper 
5070cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
5071cdebaff8SEnji Cooper 
5072cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5073cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5074cdebaff8SEnji Cooper }
5075cdebaff8SEnji Cooper 
5076cdebaff8SEnji Cooper ATF_TC(siginfo3);
ATF_TC_HEAD(siginfo3,tc)5077cdebaff8SEnji Cooper ATF_TC_HEAD(siginfo3, tc)
5078cdebaff8SEnji Cooper {
5079cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5080cdebaff8SEnji Cooper 	    "Verify basic PT_GET_SIGINFO and PT_SET_SIGINFO calls with "
5081cdebaff8SEnji Cooper 	    "setting signal to new value");
5082cdebaff8SEnji Cooper }
5083cdebaff8SEnji Cooper 
5084cdebaff8SEnji Cooper static int siginfo3_caught = 0;
5085cdebaff8SEnji Cooper 
5086cdebaff8SEnji Cooper static void
siginfo3_sigaction(int sig,siginfo_t * info,void * ctx)5087cdebaff8SEnji Cooper siginfo3_sigaction(int sig, siginfo_t *info, void *ctx)
5088cdebaff8SEnji Cooper {
5089cdebaff8SEnji Cooper 	FORKEE_ASSERT_EQ(sig, SIGTRAP);
5090cdebaff8SEnji Cooper 
5091cdebaff8SEnji Cooper 	FORKEE_ASSERT_EQ(info->si_signo, SIGTRAP);
5092cdebaff8SEnji Cooper 	FORKEE_ASSERT_EQ(info->si_code, TRAP_BRKPT);
5093cdebaff8SEnji Cooper 
5094cdebaff8SEnji Cooper 	++siginfo3_caught;
5095cdebaff8SEnji Cooper }
5096cdebaff8SEnji Cooper 
ATF_TC_BODY(siginfo3,tc)5097cdebaff8SEnji Cooper ATF_TC_BODY(siginfo3, tc)
5098cdebaff8SEnji Cooper {
5099cdebaff8SEnji Cooper 	const int exitval = 5;
5100cdebaff8SEnji Cooper 	const int sigval = SIGINT;
5101cdebaff8SEnji Cooper 	const int sigfaked = SIGTRAP;
5102cdebaff8SEnji Cooper 	const int sicodefaked = TRAP_BRKPT;
5103cdebaff8SEnji Cooper 	pid_t child, wpid;
5104cdebaff8SEnji Cooper 	struct sigaction sa;
5105cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5106cdebaff8SEnji Cooper 	int status;
5107cdebaff8SEnji Cooper #endif
5108cdebaff8SEnji Cooper 	struct ptrace_siginfo info;
5109cdebaff8SEnji Cooper 	memset(&info, 0, sizeof(info));
5110cdebaff8SEnji Cooper 
5111cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5112cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5113cdebaff8SEnji Cooper 	if (child == 0) {
5114cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5115cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5116cdebaff8SEnji Cooper 
5117cdebaff8SEnji Cooper 		sa.sa_sigaction = siginfo3_sigaction;
5118cdebaff8SEnji Cooper 		sa.sa_flags = SA_SIGINFO;
5119cdebaff8SEnji Cooper 		sigemptyset(&sa.sa_mask);
5120cdebaff8SEnji Cooper 
5121cdebaff8SEnji Cooper 		FORKEE_ASSERT(sigaction(sigfaked, &sa, NULL) != -1);
5122cdebaff8SEnji Cooper 
5123cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5124cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5125cdebaff8SEnji Cooper 
5126cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(siginfo3_caught, 1);
5127cdebaff8SEnji Cooper 
5128cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
5129cdebaff8SEnji Cooper 		_exit(exitval);
5130cdebaff8SEnji Cooper 	}
5131cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5132cdebaff8SEnji Cooper 
5133cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5134cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5135cdebaff8SEnji Cooper 
5136cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
5137cdebaff8SEnji Cooper 
5138cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5139cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5140cdebaff8SEnji Cooper 
5141cdebaff8SEnji Cooper 	printf("Signal traced to lwpid=%d\n", info.psi_lwpid);
5142cdebaff8SEnji Cooper 	printf("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
5143cdebaff8SEnji Cooper 	    info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
5144cdebaff8SEnji Cooper 	    info.psi_siginfo.si_errno);
5145cdebaff8SEnji Cooper 
5146cdebaff8SEnji Cooper 	printf("Before setting new faked signal to signo=%d si_code=%d\n",
5147cdebaff8SEnji Cooper 	    sigfaked, sicodefaked);
5148cdebaff8SEnji Cooper 	info.psi_siginfo.si_signo = sigfaked;
5149cdebaff8SEnji Cooper 	info.psi_siginfo.si_code = sicodefaked;
5150cdebaff8SEnji Cooper 
5151cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_SET_SIGINFO for child\n");
5152cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_SIGINFO, child, &info, sizeof(info)) != -1);
5153cdebaff8SEnji Cooper 
5154cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5155cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5156cdebaff8SEnji Cooper 
5157cdebaff8SEnji Cooper 	printf("Before checking siginfo_t\n");
5158cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigfaked);
5159cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, sicodefaked);
5160cdebaff8SEnji Cooper 
5161cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5162cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5163cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, sigfaked) != -1);
5164cdebaff8SEnji Cooper 
5165cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5166cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5167cdebaff8SEnji Cooper 
5168cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
5169cdebaff8SEnji Cooper 
5170cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5171cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5172cdebaff8SEnji Cooper }
5173cdebaff8SEnji Cooper 
5174cdebaff8SEnji Cooper ATF_TC(siginfo4);
ATF_TC_HEAD(siginfo4,tc)5175cdebaff8SEnji Cooper ATF_TC_HEAD(siginfo4, tc)
5176cdebaff8SEnji Cooper {
5177cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5178cdebaff8SEnji Cooper 	    "Detect SIGTRAP TRAP_EXEC from tracee");
5179cdebaff8SEnji Cooper }
5180cdebaff8SEnji Cooper 
ATF_TC_BODY(siginfo4,tc)5181cdebaff8SEnji Cooper ATF_TC_BODY(siginfo4, tc)
5182cdebaff8SEnji Cooper {
5183cdebaff8SEnji Cooper 	const int sigval = SIGTRAP;
5184cdebaff8SEnji Cooper 	pid_t child, wpid;
5185cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5186cdebaff8SEnji Cooper 	int status;
5187cdebaff8SEnji Cooper #endif
5188cdebaff8SEnji Cooper 
5189cdebaff8SEnji Cooper 	struct ptrace_siginfo info;
5190cdebaff8SEnji Cooper 	memset(&info, 0, sizeof(info));
5191cdebaff8SEnji Cooper 
5192cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5193cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5194cdebaff8SEnji Cooper 	if (child == 0) {
5195cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5196cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5197cdebaff8SEnji Cooper 
5198cdebaff8SEnji Cooper 		printf("Before calling execve(2) from child\n");
5199cdebaff8SEnji Cooper 		execlp("/bin/echo", "/bin/echo", NULL);
5200cdebaff8SEnji Cooper 
5201cdebaff8SEnji Cooper 		FORKEE_ASSERT(0 && "Not reached");
5202cdebaff8SEnji Cooper 	}
5203cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5204cdebaff8SEnji Cooper 
5205cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5206cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5207cdebaff8SEnji Cooper 
5208cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
5209cdebaff8SEnji Cooper 
5210cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5211cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5212cdebaff8SEnji Cooper 
5213cdebaff8SEnji Cooper 	printf("Signal traced to lwpid=%d\n", info.psi_lwpid);
5214cdebaff8SEnji Cooper 	printf("Signal properties: si_signo=%#x si_code=%#x si_errno=%#x\n",
5215cdebaff8SEnji Cooper 	    info.psi_siginfo.si_signo, info.psi_siginfo.si_code,
5216cdebaff8SEnji Cooper 	    info.psi_siginfo.si_errno);
5217cdebaff8SEnji Cooper 
5218cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval);
5219cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_EXEC);
5220cdebaff8SEnji Cooper 
5221cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5222cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5223cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5224cdebaff8SEnji Cooper 
5225cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5226cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5227cdebaff8SEnji Cooper 
5228cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5229cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5230cdebaff8SEnji Cooper }
5231cdebaff8SEnji Cooper 
5232cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_PID)
5233cdebaff8SEnji Cooper ATF_TC(siginfo5);
ATF_TC_HEAD(siginfo5,tc)5234cdebaff8SEnji Cooper ATF_TC_HEAD(siginfo5, tc)
5235cdebaff8SEnji Cooper {
5236cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5237cdebaff8SEnji Cooper 	    "Verify that fork(2) is intercepted by ptrace(2) with EVENT_MASK "
5238cdebaff8SEnji Cooper 	    "set to PTRACE_FORK and reports correct signal information");
5239cdebaff8SEnji Cooper }
5240cdebaff8SEnji Cooper 
ATF_TC_BODY(siginfo5,tc)5241cdebaff8SEnji Cooper ATF_TC_BODY(siginfo5, tc)
5242cdebaff8SEnji Cooper {
5243cdebaff8SEnji Cooper 	const int exitval = 5;
5244cdebaff8SEnji Cooper 	const int exitval2 = 15;
5245cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
5246cdebaff8SEnji Cooper 	pid_t child, child2, wpid;
5247cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5248cdebaff8SEnji Cooper 	int status;
5249cdebaff8SEnji Cooper #endif
5250cdebaff8SEnji Cooper 	ptrace_state_t state;
5251cdebaff8SEnji Cooper 	const int slen = sizeof(state);
5252cdebaff8SEnji Cooper 	ptrace_event_t event;
5253cdebaff8SEnji Cooper 	const int elen = sizeof(event);
5254cdebaff8SEnji Cooper 	struct ptrace_siginfo info;
5255cdebaff8SEnji Cooper 
5256cdebaff8SEnji Cooper 	memset(&info, 0, sizeof(info));
5257cdebaff8SEnji Cooper 
5258cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5259cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5260cdebaff8SEnji Cooper 	if (child == 0) {
5261cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5262cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5263cdebaff8SEnji Cooper 
5264cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5265cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5266cdebaff8SEnji Cooper 
5267cdebaff8SEnji Cooper 		FORKEE_ASSERT((child2 = fork()) != 1);
5268cdebaff8SEnji Cooper 
5269cdebaff8SEnji Cooper 		if (child2 == 0)
5270cdebaff8SEnji Cooper 			_exit(exitval2);
5271cdebaff8SEnji Cooper 
5272cdebaff8SEnji Cooper 		FORKEE_REQUIRE_SUCCESS
5273cdebaff8SEnji Cooper 		    (wpid = TWAIT_GENERIC(child2, &status, 0), child2);
5274cdebaff8SEnji Cooper 
5275cdebaff8SEnji Cooper 		forkee_status_exited(status, exitval2);
5276cdebaff8SEnji Cooper 
5277cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
5278cdebaff8SEnji Cooper 		_exit(exitval);
5279cdebaff8SEnji Cooper 	}
5280cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5281cdebaff8SEnji Cooper 
5282cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5283cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5284cdebaff8SEnji Cooper 
5285cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
5286cdebaff8SEnji Cooper 
5287cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5288cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5289cdebaff8SEnji Cooper 
5290cdebaff8SEnji Cooper 	printf("Before checking siginfo_t\n");
5291cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval);
5292cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP);
5293cdebaff8SEnji Cooper 
5294cdebaff8SEnji Cooper 	printf("Enable PTRACE_FORK in EVENT_MASK for the child %d\n", child);
5295cdebaff8SEnji Cooper 	event.pe_set_event = PTRACE_FORK;
5296cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
5297cdebaff8SEnji Cooper 
5298cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5299cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5300cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5301cdebaff8SEnji Cooper 
5302cdebaff8SEnji Cooper 	printf("Before calling %s() for the child %d\n", TWAIT_FNAME, child);
5303cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5304cdebaff8SEnji Cooper 
5305cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
5306cdebaff8SEnji Cooper 
5307cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5308cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5309cdebaff8SEnji Cooper 
5310cdebaff8SEnji Cooper 	printf("Before checking siginfo_t\n");
5311cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP);
5312cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_CHLD);
5313cdebaff8SEnji Cooper 
5314cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
5315cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_FORK);
5316cdebaff8SEnji Cooper 
5317cdebaff8SEnji Cooper 	child2 = state.pe_other_pid;
5318cdebaff8SEnji Cooper 	printf("Reported PTRACE_FORK event with forkee %d\n", child2);
5319cdebaff8SEnji Cooper 
5320cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee %d of the child %d\n",
5321cdebaff8SEnji Cooper 	    TWAIT_FNAME, child2, child);
5322cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
5323cdebaff8SEnji Cooper 	    child2);
5324cdebaff8SEnji Cooper 
5325cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
5326cdebaff8SEnji Cooper 
5327cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5328cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5329cdebaff8SEnji Cooper 
5330cdebaff8SEnji Cooper 	printf("Before checking siginfo_t\n");
5331cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP);
5332cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_CHLD);
5333cdebaff8SEnji Cooper 
5334cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1);
5335cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_FORK);
5336cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(state.pe_other_pid, child);
5337cdebaff8SEnji Cooper 
5338cdebaff8SEnji Cooper 	printf("Before resuming the forkee process where it left off and "
5339cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5340cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1);
5341cdebaff8SEnji Cooper 
5342cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5343cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5344cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5345cdebaff8SEnji Cooper 
5346cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee - expected exited\n",
5347cdebaff8SEnji Cooper 	    TWAIT_FNAME);
5348cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
5349cdebaff8SEnji Cooper 	    child2);
5350cdebaff8SEnji Cooper 
5351cdebaff8SEnji Cooper 	validate_status_exited(status, exitval2);
5352cdebaff8SEnji Cooper 
5353cdebaff8SEnji Cooper 	printf("Before calling %s() for the forkee - expected no process\n",
5354cdebaff8SEnji Cooper 	    TWAIT_FNAME);
5355cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD,
5356cdebaff8SEnji Cooper 	    wpid = TWAIT_GENERIC(child2, &status, 0));
5357cdebaff8SEnji Cooper 
5358cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
5359cdebaff8SEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
5360cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5361cdebaff8SEnji Cooper 
5362cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGCHLD);
5363cdebaff8SEnji Cooper 
5364cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5365cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5366cdebaff8SEnji Cooper 
5367cdebaff8SEnji Cooper 	printf("Before checking siginfo_t\n");
5368cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGCHLD);
5369cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, CLD_EXITED);
5370cdebaff8SEnji Cooper 
5371cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5372cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5373cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5374cdebaff8SEnji Cooper 
5375cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
5376cdebaff8SEnji Cooper 	    TWAIT_FNAME);
5377cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5378cdebaff8SEnji Cooper 
5379cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
5380cdebaff8SEnji Cooper 
5381cdebaff8SEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
5382cdebaff8SEnji Cooper 	    TWAIT_FNAME);
5383cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5384cdebaff8SEnji Cooper }
5385cdebaff8SEnji Cooper #endif
5386cdebaff8SEnji Cooper 
5387cdebaff8SEnji Cooper #if defined(PT_STEP)
5388cdebaff8SEnji Cooper ATF_TC(siginfo6);
ATF_TC_HEAD(siginfo6,tc)5389cdebaff8SEnji Cooper ATF_TC_HEAD(siginfo6, tc)
5390cdebaff8SEnji Cooper {
5391cdebaff8SEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5392cdebaff8SEnji Cooper 	    "Verify single PT_STEP call with signal information check");
5393cdebaff8SEnji Cooper }
5394cdebaff8SEnji Cooper 
ATF_TC_BODY(siginfo6,tc)5395cdebaff8SEnji Cooper ATF_TC_BODY(siginfo6, tc)
5396cdebaff8SEnji Cooper {
5397cdebaff8SEnji Cooper 	const int exitval = 5;
5398cdebaff8SEnji Cooper 	const int sigval = SIGSTOP;
5399cdebaff8SEnji Cooper 	pid_t child, wpid;
5400cdebaff8SEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5401cdebaff8SEnji Cooper 	int status;
5402cdebaff8SEnji Cooper #endif
5403cdebaff8SEnji Cooper 	int happy;
5404cdebaff8SEnji Cooper 	struct ptrace_siginfo info;
5405cdebaff8SEnji Cooper 
5406cdebaff8SEnji Cooper 	memset(&info, 0, sizeof(info));
5407cdebaff8SEnji Cooper 
5408cdebaff8SEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5409cdebaff8SEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5410cdebaff8SEnji Cooper 	if (child == 0) {
5411cdebaff8SEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5412cdebaff8SEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5413cdebaff8SEnji Cooper 
5414cdebaff8SEnji Cooper 		happy = check_happy(100);
5415cdebaff8SEnji Cooper 
5416cdebaff8SEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5417cdebaff8SEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5418cdebaff8SEnji Cooper 
5419cdebaff8SEnji Cooper 		FORKEE_ASSERT_EQ(happy, check_happy(100));
5420cdebaff8SEnji Cooper 
5421cdebaff8SEnji Cooper 		printf("Before exiting of the child process\n");
5422cdebaff8SEnji Cooper 		_exit(exitval);
5423cdebaff8SEnji Cooper 	}
5424cdebaff8SEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5425cdebaff8SEnji Cooper 
5426cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5427cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5428cdebaff8SEnji Cooper 
5429cdebaff8SEnji Cooper 	validate_status_stopped(status, sigval);
5430cdebaff8SEnji Cooper 
5431cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5432cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5433cdebaff8SEnji Cooper 
5434cdebaff8SEnji Cooper 	printf("Before checking siginfo_t\n");
5435cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, sigval);
5436cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, SI_LWP);
5437cdebaff8SEnji Cooper 
5438cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5439cdebaff8SEnji Cooper 	    "without signal to be sent (use PT_STEP)\n");
5440cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) != -1);
5441cdebaff8SEnji Cooper 
5442cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5443cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5444cdebaff8SEnji Cooper 
5445cdebaff8SEnji Cooper 	validate_status_stopped(status, SIGTRAP);
5446cdebaff8SEnji Cooper 
5447cdebaff8SEnji Cooper 	printf("Before calling ptrace(2) with PT_GET_SIGINFO for child\n");
5448cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_SIGINFO, child, &info, sizeof(info)) != -1);
5449cdebaff8SEnji Cooper 
5450cdebaff8SEnji Cooper 	printf("Before checking siginfo_t\n");
5451cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_signo, SIGTRAP);
5452cdebaff8SEnji Cooper 	ATF_REQUIRE_EQ(info.psi_siginfo.si_code, TRAP_TRACE);
5453cdebaff8SEnji Cooper 
5454cdebaff8SEnji Cooper 	printf("Before resuming the child process where it left off and "
5455cdebaff8SEnji Cooper 	    "without signal to be sent\n");
5456cdebaff8SEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5457cdebaff8SEnji Cooper 
5458cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5459cdebaff8SEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5460cdebaff8SEnji Cooper 
5461cdebaff8SEnji Cooper 	validate_status_exited(status, exitval);
5462cdebaff8SEnji Cooper 
5463cdebaff8SEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5464cdebaff8SEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5465cdebaff8SEnji Cooper }
5466cdebaff8SEnji Cooper #endif
5467cdebaff8SEnji Cooper 
5468f40f3adcSEnji Cooper volatile lwpid_t the_lwp_id = 0;
5469f40f3adcSEnji Cooper 
5470f40f3adcSEnji Cooper static void
lwp_main_func(void * arg)5471f40f3adcSEnji Cooper lwp_main_func(void *arg)
5472f40f3adcSEnji Cooper {
5473f40f3adcSEnji Cooper 	the_lwp_id = _lwp_self();
5474f40f3adcSEnji Cooper 	_lwp_exit();
5475f40f3adcSEnji Cooper }
5476f40f3adcSEnji Cooper 
5477f40f3adcSEnji Cooper ATF_TC(lwp_create1);
ATF_TC_HEAD(lwp_create1,tc)5478f40f3adcSEnji Cooper ATF_TC_HEAD(lwp_create1, tc)
5479f40f3adcSEnji Cooper {
5480f40f3adcSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5481f40f3adcSEnji Cooper 	    "Verify that 1 LWP creation is intercepted by ptrace(2) with "
5482f40f3adcSEnji Cooper 	    "EVENT_MASK set to PTRACE_LWP_CREATE");
5483f40f3adcSEnji Cooper }
5484f40f3adcSEnji Cooper 
ATF_TC_BODY(lwp_create1,tc)5485f40f3adcSEnji Cooper ATF_TC_BODY(lwp_create1, tc)
5486f40f3adcSEnji Cooper {
5487f40f3adcSEnji Cooper 	const int exitval = 5;
5488f40f3adcSEnji Cooper 	const int sigval = SIGSTOP;
5489f40f3adcSEnji Cooper 	pid_t child, wpid;
5490f40f3adcSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5491f40f3adcSEnji Cooper 	int status;
5492f40f3adcSEnji Cooper #endif
5493f40f3adcSEnji Cooper 	ptrace_state_t state;
5494f40f3adcSEnji Cooper 	const int slen = sizeof(state);
5495f40f3adcSEnji Cooper 	ptrace_event_t event;
5496f40f3adcSEnji Cooper 	const int elen = sizeof(event);
5497f40f3adcSEnji Cooper 	ucontext_t uc;
5498f40f3adcSEnji Cooper 	lwpid_t lid;
5499f40f3adcSEnji Cooper 	static const size_t ssize = 16*1024;
5500f40f3adcSEnji Cooper 	void *stack;
5501f40f3adcSEnji Cooper 
5502f40f3adcSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5503f40f3adcSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5504f40f3adcSEnji Cooper 	if (child == 0) {
5505f40f3adcSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5506f40f3adcSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5507f40f3adcSEnji Cooper 
5508f40f3adcSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5509f40f3adcSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5510f40f3adcSEnji Cooper 
5511f40f3adcSEnji Cooper 		printf("Before allocating memory for stack in child\n");
5512f40f3adcSEnji Cooper 		FORKEE_ASSERT((stack = malloc(ssize)) != NULL);
5513f40f3adcSEnji Cooper 
5514f40f3adcSEnji Cooper 		printf("Before making context for new lwp in child\n");
5515f40f3adcSEnji Cooper 		_lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize);
5516f40f3adcSEnji Cooper 
5517f40f3adcSEnji Cooper 		printf("Before creating new in child\n");
5518f40f3adcSEnji Cooper 		FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0);
5519f40f3adcSEnji Cooper 
5520f40f3adcSEnji Cooper 		printf("Before waiting for lwp %d to exit\n", lid);
5521f40f3adcSEnji Cooper 		FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0);
5522f40f3adcSEnji Cooper 
5523f40f3adcSEnji Cooper 		printf("Before verifying that reported %d and running lid %d "
5524f40f3adcSEnji Cooper 		    "are the same\n", lid, the_lwp_id);
5525f40f3adcSEnji Cooper 		FORKEE_ASSERT_EQ(lid, the_lwp_id);
5526f40f3adcSEnji Cooper 
5527f40f3adcSEnji Cooper 		printf("Before exiting of the child process\n");
5528f40f3adcSEnji Cooper 		_exit(exitval);
5529f40f3adcSEnji Cooper 	}
5530f40f3adcSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5531f40f3adcSEnji Cooper 
5532f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5533f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5534f40f3adcSEnji Cooper 
5535f40f3adcSEnji Cooper 	validate_status_stopped(status, sigval);
5536f40f3adcSEnji Cooper 
5537f40f3adcSEnji Cooper 	printf("Set empty EVENT_MASK for the child %d\n", child);
5538f40f3adcSEnji Cooper 	event.pe_set_event = PTRACE_LWP_CREATE;
5539f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
5540f40f3adcSEnji Cooper 
5541f40f3adcSEnji Cooper 	printf("Before resuming the child process where it left off and "
5542f40f3adcSEnji Cooper 	    "without signal to be sent\n");
5543f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5544f40f3adcSEnji Cooper 
5545f40f3adcSEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
5546f40f3adcSEnji Cooper 	    "SIGTRAP\n", TWAIT_FNAME);
5547f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5548f40f3adcSEnji Cooper 
5549f40f3adcSEnji Cooper 	validate_status_stopped(status, SIGTRAP);
5550f40f3adcSEnji Cooper 
5551f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
5552f40f3adcSEnji Cooper 
5553f40f3adcSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_CREATE);
5554f40f3adcSEnji Cooper 
5555f40f3adcSEnji Cooper 	lid = state.pe_lwp;
5556f40f3adcSEnji Cooper 	printf("Reported PTRACE_LWP_CREATE event with lid %d\n", lid);
5557f40f3adcSEnji Cooper 
5558f40f3adcSEnji Cooper 	printf("Before resuming the child process where it left off and "
5559f40f3adcSEnji Cooper 	    "without signal to be sent\n");
5560f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5561f40f3adcSEnji Cooper 
5562f40f3adcSEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
5563f40f3adcSEnji Cooper 	    TWAIT_FNAME);
5564f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5565f40f3adcSEnji Cooper 
5566f40f3adcSEnji Cooper 	validate_status_exited(status, exitval);
5567f40f3adcSEnji Cooper 
5568f40f3adcSEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
5569f40f3adcSEnji Cooper 	    TWAIT_FNAME);
5570f40f3adcSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5571f40f3adcSEnji Cooper }
5572f40f3adcSEnji Cooper 
5573f40f3adcSEnji Cooper ATF_TC(lwp_exit1);
ATF_TC_HEAD(lwp_exit1,tc)5574f40f3adcSEnji Cooper ATF_TC_HEAD(lwp_exit1, tc)
5575f40f3adcSEnji Cooper {
5576f40f3adcSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5577f40f3adcSEnji Cooper 	    "Verify that 1 LWP creation is intercepted by ptrace(2) with "
5578f40f3adcSEnji Cooper 	    "EVENT_MASK set to PTRACE_LWP_EXIT");
5579f40f3adcSEnji Cooper }
5580f40f3adcSEnji Cooper 
ATF_TC_BODY(lwp_exit1,tc)5581f40f3adcSEnji Cooper ATF_TC_BODY(lwp_exit1, tc)
5582f40f3adcSEnji Cooper {
5583f40f3adcSEnji Cooper 	const int exitval = 5;
5584f40f3adcSEnji Cooper 	const int sigval = SIGSTOP;
5585f40f3adcSEnji Cooper 	pid_t child, wpid;
5586f40f3adcSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5587f40f3adcSEnji Cooper 	int status;
5588f40f3adcSEnji Cooper #endif
5589f40f3adcSEnji Cooper 	ptrace_state_t state;
5590f40f3adcSEnji Cooper 	const int slen = sizeof(state);
5591f40f3adcSEnji Cooper 	ptrace_event_t event;
5592f40f3adcSEnji Cooper 	const int elen = sizeof(event);
5593f40f3adcSEnji Cooper 	ucontext_t uc;
5594f40f3adcSEnji Cooper 	lwpid_t lid;
5595f40f3adcSEnji Cooper 	static const size_t ssize = 16*1024;
5596f40f3adcSEnji Cooper 	void *stack;
5597f40f3adcSEnji Cooper 
5598f40f3adcSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5599f40f3adcSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5600f40f3adcSEnji Cooper 	if (child == 0) {
5601f40f3adcSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5602f40f3adcSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5603f40f3adcSEnji Cooper 
5604f40f3adcSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5605f40f3adcSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5606f40f3adcSEnji Cooper 
5607f40f3adcSEnji Cooper 		printf("Before allocating memory for stack in child\n");
5608f40f3adcSEnji Cooper 		FORKEE_ASSERT((stack = malloc(ssize)) != NULL);
5609f40f3adcSEnji Cooper 
5610f40f3adcSEnji Cooper 		printf("Before making context for new lwp in child\n");
5611f40f3adcSEnji Cooper 		_lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize);
5612f40f3adcSEnji Cooper 
5613f40f3adcSEnji Cooper 		printf("Before creating new in child\n");
5614f40f3adcSEnji Cooper 		FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0);
5615f40f3adcSEnji Cooper 
5616f40f3adcSEnji Cooper 		printf("Before waiting for lwp %d to exit\n", lid);
5617f40f3adcSEnji Cooper 		FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0);
5618f40f3adcSEnji Cooper 
5619f40f3adcSEnji Cooper 		printf("Before verifying that reported %d and running lid %d "
5620f40f3adcSEnji Cooper 		    "are the same\n", lid, the_lwp_id);
5621f40f3adcSEnji Cooper 		FORKEE_ASSERT_EQ(lid, the_lwp_id);
5622f40f3adcSEnji Cooper 
5623f40f3adcSEnji Cooper 		printf("Before exiting of the child process\n");
5624f40f3adcSEnji Cooper 		_exit(exitval);
5625f40f3adcSEnji Cooper 	}
5626f40f3adcSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5627f40f3adcSEnji Cooper 
5628f40f3adcSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5629f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5630f40f3adcSEnji Cooper 
5631f40f3adcSEnji Cooper 	validate_status_stopped(status, sigval);
5632f40f3adcSEnji Cooper 
5633f40f3adcSEnji Cooper 	printf("Set empty EVENT_MASK for the child %d\n", child);
5634f40f3adcSEnji Cooper 	event.pe_set_event = PTRACE_LWP_EXIT;
5635f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
5636f40f3adcSEnji Cooper 
5637f40f3adcSEnji Cooper 	printf("Before resuming the child process where it left off and "
5638f40f3adcSEnji Cooper 	    "without signal to be sent\n");
5639f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5640f40f3adcSEnji Cooper 
5641f40f3adcSEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
5642f40f3adcSEnji Cooper 	    "SIGTRAP\n", TWAIT_FNAME);
5643f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5644f40f3adcSEnji Cooper 
5645f40f3adcSEnji Cooper 	validate_status_stopped(status, SIGTRAP);
5646f40f3adcSEnji Cooper 
5647f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
5648f40f3adcSEnji Cooper 
5649f40f3adcSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_EXIT);
5650f40f3adcSEnji Cooper 
5651f40f3adcSEnji Cooper 	lid = state.pe_lwp;
5652f40f3adcSEnji Cooper 	printf("Reported PTRACE_LWP_EXIT event with lid %d\n", lid);
5653f40f3adcSEnji Cooper 
5654f40f3adcSEnji Cooper 	printf("Before resuming the child process where it left off and "
5655f40f3adcSEnji Cooper 	    "without signal to be sent\n");
5656f40f3adcSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5657f40f3adcSEnji Cooper 
5658f40f3adcSEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
5659f40f3adcSEnji Cooper 	    TWAIT_FNAME);
5660f40f3adcSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5661f40f3adcSEnji Cooper 
5662f40f3adcSEnji Cooper 	validate_status_exited(status, exitval);
5663f40f3adcSEnji Cooper 
5664f40f3adcSEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
5665f40f3adcSEnji Cooper 	    TWAIT_FNAME);
5666f40f3adcSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5667f40f3adcSEnji Cooper }
5668f40f3adcSEnji Cooper 
5669*dd66b5baSEnji Cooper ATF_TC(signal1);
ATF_TC_HEAD(signal1,tc)5670*dd66b5baSEnji Cooper ATF_TC_HEAD(signal1, tc)
5671*dd66b5baSEnji Cooper {
5672*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5673*dd66b5baSEnji Cooper 	    "Verify that masking single unrelated signal does not stop tracer "
5674*dd66b5baSEnji Cooper 	    "from catching other signals");
5675*dd66b5baSEnji Cooper }
5676*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal1,tc)5677*dd66b5baSEnji Cooper ATF_TC_BODY(signal1, tc)
5678*dd66b5baSEnji Cooper {
5679*dd66b5baSEnji Cooper 	const int exitval = 5;
5680*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
5681*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
5682*dd66b5baSEnji Cooper 	const int signotmasked = SIGINT;
5683*dd66b5baSEnji Cooper 	pid_t child, wpid;
5684*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5685*dd66b5baSEnji Cooper 	int status;
5686*dd66b5baSEnji Cooper #endif
5687*dd66b5baSEnji Cooper 	sigset_t intmask;
5688*dd66b5baSEnji Cooper 
5689*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5690*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5691*dd66b5baSEnji Cooper 	if (child == 0) {
5692*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5693*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5694*dd66b5baSEnji Cooper 
5695*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
5696*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
5697*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
5698*dd66b5baSEnji Cooper 
5699*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5700*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5701*dd66b5baSEnji Cooper 
5702*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n",
5703*dd66b5baSEnji Cooper 		    strsignal(signotmasked));
5704*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(signotmasked) == 0);
5705*dd66b5baSEnji Cooper 
5706*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
5707*dd66b5baSEnji Cooper 		_exit(exitval);
5708*dd66b5baSEnji Cooper 	}
5709*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5710*dd66b5baSEnji Cooper 
5711*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5712*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5713*dd66b5baSEnji Cooper 
5714*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
5715*dd66b5baSEnji Cooper 
5716*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5717*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5718*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5719*dd66b5baSEnji Cooper 
5720*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5721*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5722*dd66b5baSEnji Cooper 
5723*dd66b5baSEnji Cooper 	validate_status_stopped(status, signotmasked);
5724*dd66b5baSEnji Cooper 
5725*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5726*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5727*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5728*dd66b5baSEnji Cooper 
5729*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5730*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5731*dd66b5baSEnji Cooper 
5732*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
5733*dd66b5baSEnji Cooper 
5734*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5735*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5736*dd66b5baSEnji Cooper }
5737*dd66b5baSEnji Cooper 
5738*dd66b5baSEnji Cooper ATF_TC(signal2);
ATF_TC_HEAD(signal2,tc)5739*dd66b5baSEnji Cooper ATF_TC_HEAD(signal2, tc)
5740*dd66b5baSEnji Cooper {
5741*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5742*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee stops tracer from "
5743*dd66b5baSEnji Cooper 	    "catching this raised signal");
5744*dd66b5baSEnji Cooper }
5745*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal2,tc)5746*dd66b5baSEnji Cooper ATF_TC_BODY(signal2, tc)
5747*dd66b5baSEnji Cooper {
5748*dd66b5baSEnji Cooper 	const int exitval = 5;
5749*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
5750*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
5751*dd66b5baSEnji Cooper 	pid_t child, wpid;
5752*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5753*dd66b5baSEnji Cooper 	int status;
5754*dd66b5baSEnji Cooper #endif
5755*dd66b5baSEnji Cooper 	sigset_t intmask;
5756*dd66b5baSEnji Cooper 
5757*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5758*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5759*dd66b5baSEnji Cooper 	if (child == 0) {
5760*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5761*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5762*dd66b5baSEnji Cooper 
5763*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
5764*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
5765*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
5766*dd66b5baSEnji Cooper 
5767*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5768*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5769*dd66b5baSEnji Cooper 
5770*dd66b5baSEnji Cooper 		printf("Before raising %s breakpoint from child\n",
5771*dd66b5baSEnji Cooper 		    strsignal(sigmasked));
5772*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigmasked) == 0);
5773*dd66b5baSEnji Cooper 
5774*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
5775*dd66b5baSEnji Cooper 		_exit(exitval);
5776*dd66b5baSEnji Cooper 	}
5777*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5778*dd66b5baSEnji Cooper 
5779*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5780*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5781*dd66b5baSEnji Cooper 
5782*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
5783*dd66b5baSEnji Cooper 
5784*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5785*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5786*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5787*dd66b5baSEnji Cooper 
5788*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5789*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5790*dd66b5baSEnji Cooper 
5791*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
5792*dd66b5baSEnji Cooper 
5793*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5794*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5795*dd66b5baSEnji Cooper }
5796*dd66b5baSEnji Cooper 
5797*dd66b5baSEnji Cooper ATF_TC(signal3);
ATF_TC_HEAD(signal3,tc)5798*dd66b5baSEnji Cooper ATF_TC_HEAD(signal3, tc)
5799*dd66b5baSEnji Cooper {
5800*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5801*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
5802*dd66b5baSEnji Cooper 	    "catching software breakpoints");
5803*dd66b5baSEnji Cooper }
5804*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal3,tc)5805*dd66b5baSEnji Cooper ATF_TC_BODY(signal3, tc)
5806*dd66b5baSEnji Cooper {
5807*dd66b5baSEnji Cooper 	const int exitval = 5;
5808*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
5809*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
5810*dd66b5baSEnji Cooper 	pid_t child, wpid;
5811*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5812*dd66b5baSEnji Cooper 	int status;
5813*dd66b5baSEnji Cooper #endif
5814*dd66b5baSEnji Cooper 	sigset_t intmask;
5815*dd66b5baSEnji Cooper 
5816*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918");
5817*dd66b5baSEnji Cooper 
5818*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5819*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5820*dd66b5baSEnji Cooper 	if (child == 0) {
5821*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5822*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5823*dd66b5baSEnji Cooper 
5824*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
5825*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
5826*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
5827*dd66b5baSEnji Cooper 
5828*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5829*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5830*dd66b5baSEnji Cooper 
5831*dd66b5baSEnji Cooper 		printf("Before raising software breakpoint from child\n");
5832*dd66b5baSEnji Cooper #if defined(__x86_64__)
5833*dd66b5baSEnji Cooper 		__asm__ __volatile__ ("int3\n;");
5834*dd66b5baSEnji Cooper #else
5835*dd66b5baSEnji Cooper 		/*  port me */
5836*dd66b5baSEnji Cooper #endif
5837*dd66b5baSEnji Cooper 
5838*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
5839*dd66b5baSEnji Cooper 		_exit(exitval);
5840*dd66b5baSEnji Cooper 	}
5841*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5842*dd66b5baSEnji Cooper 
5843*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5844*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5845*dd66b5baSEnji Cooper 
5846*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
5847*dd66b5baSEnji Cooper 
5848*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5849*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5850*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5851*dd66b5baSEnji Cooper 
5852*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5853*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5854*dd66b5baSEnji Cooper 
5855*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
5856*dd66b5baSEnji Cooper 
5857*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5858*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5859*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5860*dd66b5baSEnji Cooper 
5861*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5862*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5863*dd66b5baSEnji Cooper 
5864*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
5865*dd66b5baSEnji Cooper 
5866*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5867*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5868*dd66b5baSEnji Cooper }
5869*dd66b5baSEnji Cooper 
5870*dd66b5baSEnji Cooper #if defined(PT_STEP)
5871*dd66b5baSEnji Cooper ATF_TC(signal4);
ATF_TC_HEAD(signal4,tc)5872*dd66b5baSEnji Cooper ATF_TC_HEAD(signal4, tc)
5873*dd66b5baSEnji Cooper {
5874*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5875*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
5876*dd66b5baSEnji Cooper 	    "catching single step trap");
5877*dd66b5baSEnji Cooper }
5878*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal4,tc)5879*dd66b5baSEnji Cooper ATF_TC_BODY(signal4, tc)
5880*dd66b5baSEnji Cooper {
5881*dd66b5baSEnji Cooper 	const int exitval = 5;
5882*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
5883*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
5884*dd66b5baSEnji Cooper 	pid_t child, wpid;
5885*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5886*dd66b5baSEnji Cooper 	int status;
5887*dd66b5baSEnji Cooper #endif
5888*dd66b5baSEnji Cooper 	sigset_t intmask;
5889*dd66b5baSEnji Cooper 	int happy;
5890*dd66b5baSEnji Cooper 
5891*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918");
5892*dd66b5baSEnji Cooper 
5893*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5894*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5895*dd66b5baSEnji Cooper 	if (child == 0) {
5896*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5897*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5898*dd66b5baSEnji Cooper 
5899*dd66b5baSEnji Cooper 		happy = check_happy(100);
5900*dd66b5baSEnji Cooper 
5901*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
5902*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
5903*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
5904*dd66b5baSEnji Cooper 
5905*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5906*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5907*dd66b5baSEnji Cooper 
5908*dd66b5baSEnji Cooper 		FORKEE_ASSERT_EQ(happy, check_happy(100));
5909*dd66b5baSEnji Cooper 
5910*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
5911*dd66b5baSEnji Cooper 		_exit(exitval);
5912*dd66b5baSEnji Cooper 	}
5913*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5914*dd66b5baSEnji Cooper 
5915*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5916*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5917*dd66b5baSEnji Cooper 
5918*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
5919*dd66b5baSEnji Cooper 
5920*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5921*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5922*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_STEP, child, (void *)1, 0) != -1);
5923*dd66b5baSEnji Cooper 
5924*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5925*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5926*dd66b5baSEnji Cooper 
5927*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
5928*dd66b5baSEnji Cooper 
5929*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5930*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5931*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5932*dd66b5baSEnji Cooper 
5933*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5934*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5935*dd66b5baSEnji Cooper 
5936*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
5937*dd66b5baSEnji Cooper 
5938*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5939*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
5940*dd66b5baSEnji Cooper }
5941*dd66b5baSEnji Cooper #endif
5942*dd66b5baSEnji Cooper 
5943*dd66b5baSEnji Cooper ATF_TC(signal5);
ATF_TC_HEAD(signal5,tc)5944*dd66b5baSEnji Cooper ATF_TC_HEAD(signal5, tc)
5945*dd66b5baSEnji Cooper {
5946*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
5947*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
5948*dd66b5baSEnji Cooper 	    "catching exec() breakpoint");
5949*dd66b5baSEnji Cooper }
5950*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal5,tc)5951*dd66b5baSEnji Cooper ATF_TC_BODY(signal5, tc)
5952*dd66b5baSEnji Cooper {
5953*dd66b5baSEnji Cooper 	const int exitval = 5;
5954*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
5955*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
5956*dd66b5baSEnji Cooper 	pid_t child, wpid;
5957*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
5958*dd66b5baSEnji Cooper 	int status;
5959*dd66b5baSEnji Cooper #endif
5960*dd66b5baSEnji Cooper 	sigset_t intmask;
5961*dd66b5baSEnji Cooper 
5962*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918");
5963*dd66b5baSEnji Cooper 
5964*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
5965*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
5966*dd66b5baSEnji Cooper 	if (child == 0) {
5967*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
5968*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
5969*dd66b5baSEnji Cooper 
5970*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
5971*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
5972*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
5973*dd66b5baSEnji Cooper 
5974*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
5975*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
5976*dd66b5baSEnji Cooper 
5977*dd66b5baSEnji Cooper 		printf("Before calling execve(2) from child\n");
5978*dd66b5baSEnji Cooper 		execlp("/bin/echo", "/bin/echo", NULL);
5979*dd66b5baSEnji Cooper 
5980*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
5981*dd66b5baSEnji Cooper 		_exit(exitval);
5982*dd66b5baSEnji Cooper 	}
5983*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
5984*dd66b5baSEnji Cooper 
5985*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5986*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5987*dd66b5baSEnji Cooper 
5988*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
5989*dd66b5baSEnji Cooper 
5990*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
5991*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
5992*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
5993*dd66b5baSEnji Cooper 
5994*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
5995*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
5996*dd66b5baSEnji Cooper 
5997*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
5998*dd66b5baSEnji Cooper 
5999*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6000*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6001*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6002*dd66b5baSEnji Cooper 
6003*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6004*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6005*dd66b5baSEnji Cooper 
6006*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
6007*dd66b5baSEnji Cooper 
6008*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6009*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
6010*dd66b5baSEnji Cooper }
6011*dd66b5baSEnji Cooper 
6012*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_PID)
6013*dd66b5baSEnji Cooper ATF_TC(signal6);
ATF_TC_HEAD(signal6,tc)6014*dd66b5baSEnji Cooper ATF_TC_HEAD(signal6, tc)
6015*dd66b5baSEnji Cooper {
6016*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
6017*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
6018*dd66b5baSEnji Cooper 	    "catching PTRACE_FORK breakpoint");
6019*dd66b5baSEnji Cooper }
6020*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal6,tc)6021*dd66b5baSEnji Cooper ATF_TC_BODY(signal6, tc)
6022*dd66b5baSEnji Cooper {
6023*dd66b5baSEnji Cooper 	const int exitval = 5;
6024*dd66b5baSEnji Cooper 	const int exitval2 = 15;
6025*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
6026*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
6027*dd66b5baSEnji Cooper 	pid_t child, child2, wpid;
6028*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
6029*dd66b5baSEnji Cooper 	int status;
6030*dd66b5baSEnji Cooper #endif
6031*dd66b5baSEnji Cooper 	sigset_t intmask;
6032*dd66b5baSEnji Cooper 	ptrace_state_t state;
6033*dd66b5baSEnji Cooper 	const int slen = sizeof(state);
6034*dd66b5baSEnji Cooper 	ptrace_event_t event;
6035*dd66b5baSEnji Cooper 	const int elen = sizeof(event);
6036*dd66b5baSEnji Cooper 
6037*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918");
6038*dd66b5baSEnji Cooper 
6039*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
6040*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
6041*dd66b5baSEnji Cooper 	if (child == 0) {
6042*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
6043*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
6044*dd66b5baSEnji Cooper 
6045*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
6046*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
6047*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
6048*dd66b5baSEnji Cooper 
6049*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
6050*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
6051*dd66b5baSEnji Cooper 
6052*dd66b5baSEnji Cooper 		FORKEE_ASSERT((child2 = fork()) != 1);
6053*dd66b5baSEnji Cooper 
6054*dd66b5baSEnji Cooper 		if (child2 == 0)
6055*dd66b5baSEnji Cooper 			_exit(exitval2);
6056*dd66b5baSEnji Cooper 
6057*dd66b5baSEnji Cooper 		FORKEE_REQUIRE_SUCCESS
6058*dd66b5baSEnji Cooper 			(wpid = TWAIT_GENERIC(child2, &status, 0), child2);
6059*dd66b5baSEnji Cooper 
6060*dd66b5baSEnji Cooper 		forkee_status_exited(status, exitval2);
6061*dd66b5baSEnji Cooper 
6062*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
6063*dd66b5baSEnji Cooper 		_exit(exitval);
6064*dd66b5baSEnji Cooper 	}
6065*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
6066*dd66b5baSEnji Cooper 
6067*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6068*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6069*dd66b5baSEnji Cooper 
6070*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
6071*dd66b5baSEnji Cooper 
6072*dd66b5baSEnji Cooper 	printf("Enable PTRACE_FORK in EVENT_MASK for the child %d\n", child);
6073*dd66b5baSEnji Cooper 	event.pe_set_event = PTRACE_FORK;
6074*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
6075*dd66b5baSEnji Cooper 
6076*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6077*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6078*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6079*dd66b5baSEnji Cooper 
6080*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6081*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6082*dd66b5baSEnji Cooper 
6083*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
6084*dd66b5baSEnji Cooper 
6085*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
6086*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_FORK);
6087*dd66b5baSEnji Cooper 
6088*dd66b5baSEnji Cooper 	child2 = state.pe_other_pid;
6089*dd66b5baSEnji Cooper 	printf("Reported PTRACE_FORK event with forkee %d\n", child2);
6090*dd66b5baSEnji Cooper 
6091*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child2\n", TWAIT_FNAME);
6092*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
6093*dd66b5baSEnji Cooper 	    child2);
6094*dd66b5baSEnji Cooper 
6095*dd66b5baSEnji Cooper 	validate_status_stopped(status, SIGTRAP);
6096*dd66b5baSEnji Cooper 
6097*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1);
6098*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_FORK);
6099*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_other_pid, child);
6100*dd66b5baSEnji Cooper 
6101*dd66b5baSEnji Cooper 	printf("Before resuming the forkee process where it left off and "
6102*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6103*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1);
6104*dd66b5baSEnji Cooper 
6105*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6106*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6107*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6108*dd66b5baSEnji Cooper 
6109*dd66b5baSEnji Cooper 	printf("Before calling %s() for the forkee - expected exited\n",
6110*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6111*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
6112*dd66b5baSEnji Cooper 	    child2);
6113*dd66b5baSEnji Cooper 
6114*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval2);
6115*dd66b5baSEnji Cooper 
6116*dd66b5baSEnji Cooper 	printf("Before calling %s() for the forkee - expected no process\n",
6117*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6118*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD,
6119*dd66b5baSEnji Cooper 	    wpid = TWAIT_GENERIC(child2, &status, 0));
6120*dd66b5baSEnji Cooper 
6121*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
6122*dd66b5baSEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
6123*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6124*dd66b5baSEnji Cooper 
6125*dd66b5baSEnji Cooper 	validate_status_stopped(status, SIGCHLD);
6126*dd66b5baSEnji Cooper 
6127*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6128*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6129*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6130*dd66b5baSEnji Cooper 
6131*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
6132*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6133*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6134*dd66b5baSEnji Cooper 
6135*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
6136*dd66b5baSEnji Cooper 
6137*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
6138*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6139*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
6140*dd66b5baSEnji Cooper }
6141*dd66b5baSEnji Cooper #endif
6142*dd66b5baSEnji Cooper 
6143*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_PID)
6144*dd66b5baSEnji Cooper ATF_TC(signal7);
ATF_TC_HEAD(signal7,tc)6145*dd66b5baSEnji Cooper ATF_TC_HEAD(signal7, tc)
6146*dd66b5baSEnji Cooper {
6147*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
6148*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
6149*dd66b5baSEnji Cooper 	    "catching PTRACE_VFORK breakpoint");
6150*dd66b5baSEnji Cooper }
6151*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal7,tc)6152*dd66b5baSEnji Cooper ATF_TC_BODY(signal7, tc)
6153*dd66b5baSEnji Cooper {
6154*dd66b5baSEnji Cooper 	const int exitval = 5;
6155*dd66b5baSEnji Cooper 	const int exitval2 = 15;
6156*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
6157*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
6158*dd66b5baSEnji Cooper 	pid_t child, child2, wpid;
6159*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
6160*dd66b5baSEnji Cooper 	int status;
6161*dd66b5baSEnji Cooper #endif
6162*dd66b5baSEnji Cooper 	sigset_t intmask;
6163*dd66b5baSEnji Cooper 	ptrace_state_t state;
6164*dd66b5baSEnji Cooper 	const int slen = sizeof(state);
6165*dd66b5baSEnji Cooper 	ptrace_event_t event;
6166*dd66b5baSEnji Cooper 	const int elen = sizeof(event);
6167*dd66b5baSEnji Cooper 
6168*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918 PR kern/51630");
6169*dd66b5baSEnji Cooper 
6170*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
6171*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
6172*dd66b5baSEnji Cooper 	if (child == 0) {
6173*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
6174*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
6175*dd66b5baSEnji Cooper 
6176*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
6177*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
6178*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
6179*dd66b5baSEnji Cooper 
6180*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
6181*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
6182*dd66b5baSEnji Cooper 
6183*dd66b5baSEnji Cooper 		FORKEE_ASSERT((child2 = fork()) != 1);
6184*dd66b5baSEnji Cooper 
6185*dd66b5baSEnji Cooper 		if (child2 == 0)
6186*dd66b5baSEnji Cooper 			_exit(exitval2);
6187*dd66b5baSEnji Cooper 
6188*dd66b5baSEnji Cooper 		FORKEE_REQUIRE_SUCCESS
6189*dd66b5baSEnji Cooper 			(wpid = TWAIT_GENERIC(child2, &status, 0), child2);
6190*dd66b5baSEnji Cooper 
6191*dd66b5baSEnji Cooper 		forkee_status_exited(status, exitval2);
6192*dd66b5baSEnji Cooper 
6193*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
6194*dd66b5baSEnji Cooper 		_exit(exitval);
6195*dd66b5baSEnji Cooper 	}
6196*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
6197*dd66b5baSEnji Cooper 
6198*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6199*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6200*dd66b5baSEnji Cooper 
6201*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
6202*dd66b5baSEnji Cooper 
6203*dd66b5baSEnji Cooper 	printf("Enable PTRACE_VFORK in EVENT_MASK for the child %d\n", child);
6204*dd66b5baSEnji Cooper 	event.pe_set_event = PTRACE_VFORK;
6205*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
6206*dd66b5baSEnji Cooper 
6207*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6208*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6209*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6210*dd66b5baSEnji Cooper 
6211*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6212*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6213*dd66b5baSEnji Cooper 
6214*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
6215*dd66b5baSEnji Cooper 
6216*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
6217*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK);
6218*dd66b5baSEnji Cooper 
6219*dd66b5baSEnji Cooper 	child2 = state.pe_other_pid;
6220*dd66b5baSEnji Cooper 	printf("Reported PTRACE_VFORK event with forkee %d\n", child2);
6221*dd66b5baSEnji Cooper 
6222*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child2\n", TWAIT_FNAME);
6223*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
6224*dd66b5baSEnji Cooper 	    child2);
6225*dd66b5baSEnji Cooper 
6226*dd66b5baSEnji Cooper 	validate_status_stopped(status, SIGTRAP);
6227*dd66b5baSEnji Cooper 
6228*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child2, &state, slen) != -1);
6229*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK);
6230*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_other_pid, child);
6231*dd66b5baSEnji Cooper 
6232*dd66b5baSEnji Cooper 	printf("Before resuming the forkee process where it left off and "
6233*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6234*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child2, (void *)1, 0) != -1);
6235*dd66b5baSEnji Cooper 
6236*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6237*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6238*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6239*dd66b5baSEnji Cooper 
6240*dd66b5baSEnji Cooper 	printf("Before calling %s() for the forkee - expected exited\n",
6241*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6242*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child2, &status, 0),
6243*dd66b5baSEnji Cooper 	    child2);
6244*dd66b5baSEnji Cooper 
6245*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval2);
6246*dd66b5baSEnji Cooper 
6247*dd66b5baSEnji Cooper 	printf("Before calling %s() for the forkee - expected no process\n",
6248*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6249*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD,
6250*dd66b5baSEnji Cooper 	    wpid = TWAIT_GENERIC(child2, &status, 0));
6251*dd66b5baSEnji Cooper 
6252*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
6253*dd66b5baSEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
6254*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6255*dd66b5baSEnji Cooper 
6256*dd66b5baSEnji Cooper 	validate_status_stopped(status, SIGCHLD);
6257*dd66b5baSEnji Cooper 
6258*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6259*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6260*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6261*dd66b5baSEnji Cooper 
6262*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
6263*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6264*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6265*dd66b5baSEnji Cooper 
6266*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
6267*dd66b5baSEnji Cooper 
6268*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
6269*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6270*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
6271*dd66b5baSEnji Cooper }
6272*dd66b5baSEnji Cooper #endif
6273*dd66b5baSEnji Cooper 
6274*dd66b5baSEnji Cooper ATF_TC(signal8);
ATF_TC_HEAD(signal8,tc)6275*dd66b5baSEnji Cooper ATF_TC_HEAD(signal8, tc)
6276*dd66b5baSEnji Cooper {
6277*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
6278*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
6279*dd66b5baSEnji Cooper 	    "catching PTRACE_VFORK_DONE breakpoint");
6280*dd66b5baSEnji Cooper }
6281*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal8,tc)6282*dd66b5baSEnji Cooper ATF_TC_BODY(signal8, tc)
6283*dd66b5baSEnji Cooper {
6284*dd66b5baSEnji Cooper 	const int exitval = 5;
6285*dd66b5baSEnji Cooper 	const int exitval2 = 15;
6286*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
6287*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
6288*dd66b5baSEnji Cooper 	pid_t child, child2, wpid;
6289*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
6290*dd66b5baSEnji Cooper 	int status;
6291*dd66b5baSEnji Cooper #endif
6292*dd66b5baSEnji Cooper 	sigset_t intmask;
6293*dd66b5baSEnji Cooper 	ptrace_state_t state;
6294*dd66b5baSEnji Cooper 	const int slen = sizeof(state);
6295*dd66b5baSEnji Cooper 	ptrace_event_t event;
6296*dd66b5baSEnji Cooper 	const int elen = sizeof(event);
6297*dd66b5baSEnji Cooper 
6298*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918");
6299*dd66b5baSEnji Cooper 
6300*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
6301*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
6302*dd66b5baSEnji Cooper 	if (child == 0) {
6303*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
6304*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
6305*dd66b5baSEnji Cooper 
6306*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
6307*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
6308*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
6309*dd66b5baSEnji Cooper 
6310*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
6311*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
6312*dd66b5baSEnji Cooper 
6313*dd66b5baSEnji Cooper 		FORKEE_ASSERT((child2 = vfork()) != 1);
6314*dd66b5baSEnji Cooper 
6315*dd66b5baSEnji Cooper 		if (child2 == 0)
6316*dd66b5baSEnji Cooper 			_exit(exitval2);
6317*dd66b5baSEnji Cooper 
6318*dd66b5baSEnji Cooper 		FORKEE_REQUIRE_SUCCESS
6319*dd66b5baSEnji Cooper 			(wpid = TWAIT_GENERIC(child2, &status, 0), child2);
6320*dd66b5baSEnji Cooper 
6321*dd66b5baSEnji Cooper 		forkee_status_exited(status, exitval2);
6322*dd66b5baSEnji Cooper 
6323*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
6324*dd66b5baSEnji Cooper 		_exit(exitval);
6325*dd66b5baSEnji Cooper 	}
6326*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
6327*dd66b5baSEnji Cooper 
6328*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6329*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6330*dd66b5baSEnji Cooper 
6331*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
6332*dd66b5baSEnji Cooper 
6333*dd66b5baSEnji Cooper 	printf("Enable PTRACE_VFORK_DONE in EVENT_MASK for the child %d\n",
6334*dd66b5baSEnji Cooper 	    child);
6335*dd66b5baSEnji Cooper 	event.pe_set_event = PTRACE_VFORK_DONE;
6336*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
6337*dd66b5baSEnji Cooper 
6338*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6339*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6340*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6341*dd66b5baSEnji Cooper 
6342*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6343*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6344*dd66b5baSEnji Cooper 
6345*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
6346*dd66b5baSEnji Cooper 
6347*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
6348*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_VFORK_DONE);
6349*dd66b5baSEnji Cooper 
6350*dd66b5baSEnji Cooper 	child2 = state.pe_other_pid;
6351*dd66b5baSEnji Cooper 	printf("Reported PTRACE_VFORK_DONE event with forkee %d\n", child2);
6352*dd66b5baSEnji Cooper 
6353*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6354*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6355*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6356*dd66b5baSEnji Cooper 
6357*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
6358*dd66b5baSEnji Cooper 	    "SIGCHLD\n", TWAIT_FNAME);
6359*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6360*dd66b5baSEnji Cooper 
6361*dd66b5baSEnji Cooper 	validate_status_stopped(status, SIGCHLD);
6362*dd66b5baSEnji Cooper 
6363*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6364*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6365*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6366*dd66b5baSEnji Cooper 
6367*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
6368*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6369*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6370*dd66b5baSEnji Cooper 
6371*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
6372*dd66b5baSEnji Cooper 
6373*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
6374*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6375*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
6376*dd66b5baSEnji Cooper }
6377*dd66b5baSEnji Cooper 
6378*dd66b5baSEnji Cooper ATF_TC(signal9);
ATF_TC_HEAD(signal9,tc)6379*dd66b5baSEnji Cooper ATF_TC_HEAD(signal9, tc)
6380*dd66b5baSEnji Cooper {
6381*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
6382*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
6383*dd66b5baSEnji Cooper 	    "catching PTRACE_LWP_CREATE breakpoint");
6384*dd66b5baSEnji Cooper }
6385*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal9,tc)6386*dd66b5baSEnji Cooper ATF_TC_BODY(signal9, tc)
6387*dd66b5baSEnji Cooper {
6388*dd66b5baSEnji Cooper 	const int exitval = 5;
6389*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
6390*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
6391*dd66b5baSEnji Cooper 	pid_t child, wpid;
6392*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
6393*dd66b5baSEnji Cooper 	int status;
6394*dd66b5baSEnji Cooper #endif
6395*dd66b5baSEnji Cooper 	sigset_t intmask;
6396*dd66b5baSEnji Cooper 	ptrace_state_t state;
6397*dd66b5baSEnji Cooper 	const int slen = sizeof(state);
6398*dd66b5baSEnji Cooper 	ptrace_event_t event;
6399*dd66b5baSEnji Cooper 	const int elen = sizeof(event);
6400*dd66b5baSEnji Cooper 	ucontext_t uc;
6401*dd66b5baSEnji Cooper 	lwpid_t lid;
6402*dd66b5baSEnji Cooper 	static const size_t ssize = 16*1024;
6403*dd66b5baSEnji Cooper 	void *stack;
6404*dd66b5baSEnji Cooper 
6405*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918");
6406*dd66b5baSEnji Cooper 
6407*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
6408*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
6409*dd66b5baSEnji Cooper 	if (child == 0) {
6410*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
6411*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
6412*dd66b5baSEnji Cooper 
6413*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
6414*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
6415*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
6416*dd66b5baSEnji Cooper 
6417*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
6418*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
6419*dd66b5baSEnji Cooper 
6420*dd66b5baSEnji Cooper 		printf("Before allocating memory for stack in child\n");
6421*dd66b5baSEnji Cooper 		FORKEE_ASSERT((stack = malloc(ssize)) != NULL);
6422*dd66b5baSEnji Cooper 
6423*dd66b5baSEnji Cooper 		printf("Before making context for new lwp in child\n");
6424*dd66b5baSEnji Cooper 		_lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize);
6425*dd66b5baSEnji Cooper 
6426*dd66b5baSEnji Cooper 		printf("Before creating new in child\n");
6427*dd66b5baSEnji Cooper 		FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0);
6428*dd66b5baSEnji Cooper 
6429*dd66b5baSEnji Cooper 		printf("Before waiting for lwp %d to exit\n", lid);
6430*dd66b5baSEnji Cooper 		FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0);
6431*dd66b5baSEnji Cooper 
6432*dd66b5baSEnji Cooper 		printf("Before verifying that reported %d and running lid %d "
6433*dd66b5baSEnji Cooper 		    "are the same\n", lid, the_lwp_id);
6434*dd66b5baSEnji Cooper 		FORKEE_ASSERT_EQ(lid, the_lwp_id);
6435*dd66b5baSEnji Cooper 
6436*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
6437*dd66b5baSEnji Cooper 		_exit(exitval);
6438*dd66b5baSEnji Cooper 	}
6439*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
6440*dd66b5baSEnji Cooper 
6441*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6442*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6443*dd66b5baSEnji Cooper 
6444*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
6445*dd66b5baSEnji Cooper 
6446*dd66b5baSEnji Cooper 	printf("Set empty EVENT_MASK for the child %d\n", child);
6447*dd66b5baSEnji Cooper 	event.pe_set_event = PTRACE_LWP_CREATE;
6448*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
6449*dd66b5baSEnji Cooper 
6450*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6451*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6452*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6453*dd66b5baSEnji Cooper 
6454*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
6455*dd66b5baSEnji Cooper 	    "SIGTRAP\n", TWAIT_FNAME);
6456*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6457*dd66b5baSEnji Cooper 
6458*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
6459*dd66b5baSEnji Cooper 
6460*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
6461*dd66b5baSEnji Cooper 
6462*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_CREATE);
6463*dd66b5baSEnji Cooper 
6464*dd66b5baSEnji Cooper 	lid = state.pe_lwp;
6465*dd66b5baSEnji Cooper 	printf("Reported PTRACE_LWP_CREATE event with lid %d\n", lid);
6466*dd66b5baSEnji Cooper 
6467*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6468*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6469*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6470*dd66b5baSEnji Cooper 
6471*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
6472*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6473*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6474*dd66b5baSEnji Cooper 
6475*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
6476*dd66b5baSEnji Cooper 
6477*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
6478*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6479*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
6480*dd66b5baSEnji Cooper }
6481*dd66b5baSEnji Cooper 
6482*dd66b5baSEnji Cooper ATF_TC(signal10);
ATF_TC_HEAD(signal10,tc)6483*dd66b5baSEnji Cooper ATF_TC_HEAD(signal10, tc)
6484*dd66b5baSEnji Cooper {
6485*dd66b5baSEnji Cooper 	atf_tc_set_md_var(tc, "descr",
6486*dd66b5baSEnji Cooper 	    "Verify that masking SIGTRAP in tracee does not stop tracer from "
6487*dd66b5baSEnji Cooper 	    "catching PTRACE_LWP_EXIT breakpoint");
6488*dd66b5baSEnji Cooper }
6489*dd66b5baSEnji Cooper 
ATF_TC_BODY(signal10,tc)6490*dd66b5baSEnji Cooper ATF_TC_BODY(signal10, tc)
6491*dd66b5baSEnji Cooper {
6492*dd66b5baSEnji Cooper 	const int exitval = 5;
6493*dd66b5baSEnji Cooper 	const int sigval = SIGSTOP;
6494*dd66b5baSEnji Cooper 	const int sigmasked = SIGTRAP;
6495*dd66b5baSEnji Cooper 	pid_t child, wpid;
6496*dd66b5baSEnji Cooper #if defined(TWAIT_HAVE_STATUS)
6497*dd66b5baSEnji Cooper 	int status;
6498*dd66b5baSEnji Cooper #endif
6499*dd66b5baSEnji Cooper 	sigset_t intmask;
6500*dd66b5baSEnji Cooper 	ptrace_state_t state;
6501*dd66b5baSEnji Cooper 	const int slen = sizeof(state);
6502*dd66b5baSEnji Cooper 	ptrace_event_t event;
6503*dd66b5baSEnji Cooper 	const int elen = sizeof(event);
6504*dd66b5baSEnji Cooper 	ucontext_t uc;
6505*dd66b5baSEnji Cooper 	lwpid_t lid;
6506*dd66b5baSEnji Cooper 	static const size_t ssize = 16*1024;
6507*dd66b5baSEnji Cooper 	void *stack;
6508*dd66b5baSEnji Cooper 
6509*dd66b5baSEnji Cooper 	atf_tc_expect_fail("PR kern/51918");
6510*dd66b5baSEnji Cooper 
6511*dd66b5baSEnji Cooper 	printf("Before forking process PID=%d\n", getpid());
6512*dd66b5baSEnji Cooper 	ATF_REQUIRE((child = fork()) != -1);
6513*dd66b5baSEnji Cooper 	if (child == 0) {
6514*dd66b5baSEnji Cooper 		printf("Before calling PT_TRACE_ME from child %d\n", getpid());
6515*dd66b5baSEnji Cooper 		FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
6516*dd66b5baSEnji Cooper 
6517*dd66b5baSEnji Cooper 		sigemptyset(&intmask);
6518*dd66b5baSEnji Cooper 		sigaddset(&intmask, sigmasked);
6519*dd66b5baSEnji Cooper 		sigprocmask(SIG_BLOCK, &intmask, NULL);
6520*dd66b5baSEnji Cooper 
6521*dd66b5baSEnji Cooper 		printf("Before raising %s from child\n", strsignal(sigval));
6522*dd66b5baSEnji Cooper 		FORKEE_ASSERT(raise(sigval) == 0);
6523*dd66b5baSEnji Cooper 
6524*dd66b5baSEnji Cooper 		printf("Before allocating memory for stack in child\n");
6525*dd66b5baSEnji Cooper 		FORKEE_ASSERT((stack = malloc(ssize)) != NULL);
6526*dd66b5baSEnji Cooper 
6527*dd66b5baSEnji Cooper 		printf("Before making context for new lwp in child\n");
6528*dd66b5baSEnji Cooper 		_lwp_makecontext(&uc, lwp_main_func, NULL, NULL, stack, ssize);
6529*dd66b5baSEnji Cooper 
6530*dd66b5baSEnji Cooper 		printf("Before creating new in child\n");
6531*dd66b5baSEnji Cooper 		FORKEE_ASSERT(_lwp_create(&uc, 0, &lid) == 0);
6532*dd66b5baSEnji Cooper 
6533*dd66b5baSEnji Cooper 		printf("Before waiting for lwp %d to exit\n", lid);
6534*dd66b5baSEnji Cooper 		FORKEE_ASSERT(_lwp_wait(lid, NULL) == 0);
6535*dd66b5baSEnji Cooper 
6536*dd66b5baSEnji Cooper 		printf("Before verifying that reported %d and running lid %d "
6537*dd66b5baSEnji Cooper 		    "are the same\n", lid, the_lwp_id);
6538*dd66b5baSEnji Cooper 		FORKEE_ASSERT_EQ(lid, the_lwp_id);
6539*dd66b5baSEnji Cooper 
6540*dd66b5baSEnji Cooper 		printf("Before exiting of the child process\n");
6541*dd66b5baSEnji Cooper 		_exit(exitval);
6542*dd66b5baSEnji Cooper 	}
6543*dd66b5baSEnji Cooper 	printf("Parent process PID=%d, child's PID=%d\n", getpid(), child);
6544*dd66b5baSEnji Cooper 
6545*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child\n", TWAIT_FNAME);
6546*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6547*dd66b5baSEnji Cooper 
6548*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigval);
6549*dd66b5baSEnji Cooper 
6550*dd66b5baSEnji Cooper 	printf("Set empty EVENT_MASK for the child %d\n", child);
6551*dd66b5baSEnji Cooper 	event.pe_set_event = PTRACE_LWP_EXIT;
6552*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, child, &event, elen) != -1);
6553*dd66b5baSEnji Cooper 
6554*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6555*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6556*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6557*dd66b5baSEnji Cooper 
6558*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected stopped "
6559*dd66b5baSEnji Cooper 	    "SIGTRAP\n", TWAIT_FNAME);
6560*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6561*dd66b5baSEnji Cooper 
6562*dd66b5baSEnji Cooper 	validate_status_stopped(status, sigmasked);
6563*dd66b5baSEnji Cooper 
6564*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_GET_PROCESS_STATE, child, &state, slen) != -1);
6565*dd66b5baSEnji Cooper 
6566*dd66b5baSEnji Cooper 	ATF_REQUIRE_EQ(state.pe_report_event, PTRACE_LWP_EXIT);
6567*dd66b5baSEnji Cooper 
6568*dd66b5baSEnji Cooper 	lid = state.pe_lwp;
6569*dd66b5baSEnji Cooper 	printf("Reported PTRACE_LWP_EXIT event with lid %d\n", lid);
6570*dd66b5baSEnji Cooper 
6571*dd66b5baSEnji Cooper 	printf("Before resuming the child process where it left off and "
6572*dd66b5baSEnji Cooper 	    "without signal to be sent\n");
6573*dd66b5baSEnji Cooper 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
6574*dd66b5baSEnji Cooper 
6575*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected exited\n",
6576*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6577*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
6578*dd66b5baSEnji Cooper 
6579*dd66b5baSEnji Cooper 	validate_status_exited(status, exitval);
6580*dd66b5baSEnji Cooper 
6581*dd66b5baSEnji Cooper 	printf("Before calling %s() for the child - expected no process\n",
6582*dd66b5baSEnji Cooper 	    TWAIT_FNAME);
6583*dd66b5baSEnji Cooper 	TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
6584*dd66b5baSEnji Cooper }
6585*dd66b5baSEnji Cooper 
ATF_TP_ADD_TCS(tp)6586cdebaff8SEnji Cooper ATF_TP_ADD_TCS(tp)
6587cdebaff8SEnji Cooper {
6588cdebaff8SEnji Cooper 	setvbuf(stdout, NULL, _IONBF, 0);
6589cdebaff8SEnji Cooper 	setvbuf(stderr, NULL, _IONBF, 0);
6590cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, traceme1);
6591cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, traceme2);
6592cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, traceme3);
6593cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, traceme4);
6594cdebaff8SEnji Cooper 
6595cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, attach1);
6596cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, attach2);
6597cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, attach3);
6598cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, attach4);
6599cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, attach5);
6600cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, attach6);
6601cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, attach7);
6602cdebaff8SEnji Cooper 
6603cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, eventmask1);
6604cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, eventmask2);
660563d1fd59SEnji Cooper 	ATF_TP_ADD_TC(tp, eventmask3);
660663d1fd59SEnji Cooper 	ATF_TP_ADD_TC(tp, eventmask4);
6607f40f3adcSEnji Cooper 	ATF_TP_ADD_TC(tp, eventmask5);
6608f40f3adcSEnji Cooper 	ATF_TP_ADD_TC(tp, eventmask6);
6609cdebaff8SEnji Cooper 
6610cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, fork1);
6611cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, fork2);
6612cdebaff8SEnji Cooper 
6613cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, vfork1);
6614cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, vfork2);
6615cdebaff8SEnji Cooper 
661663d1fd59SEnji Cooper 	ATF_TP_ADD_TC(tp, vforkdone1);
661763d1fd59SEnji Cooper 	ATF_TP_ADD_TC(tp, vforkdone2);
661863d1fd59SEnji Cooper 
6619cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_d1);
6620cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_d2);
6621cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_d3);
6622cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_d4);
6623cdebaff8SEnji Cooper 
6624cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_write_d1);
6625cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_write_d2);
6626cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_write_d3);
6627cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_write_d4);
6628cdebaff8SEnji Cooper 
6629cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_d1);
6630cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_d2);
6631cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_d3);
6632cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_d4);
6633cdebaff8SEnji Cooper 
6634cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, write_d1);
6635cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, write_d2);
6636cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, write_d3);
6637cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, write_d4);
6638cdebaff8SEnji Cooper 
6639cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_d_write_d_handshake1);
6640cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_d_write_d_handshake2);
6641cdebaff8SEnji Cooper 
6642cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_d_write_d_handshake1);
6643cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_d_write_d_handshake2);
6644cdebaff8SEnji Cooper 
6645cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_i1);
6646cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_i2);
6647cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_i3);
6648cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_i4);
6649cdebaff8SEnji Cooper 
6650cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_i1);
6651cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_i2);
6652cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_i3);
6653cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, read_i4);
6654cdebaff8SEnji Cooper 
6655*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, io_read_auxv1);
6656*dd66b5baSEnji Cooper 
6657cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_GPREGS(tp, regs1);
6658cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_GPREGS(tp, regs2);
6659cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_GPREGS(tp, regs3);
6660cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_GPREGS(tp, regs4);
6661cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_GPREGS(tp, regs5);
6662cdebaff8SEnji Cooper 
6663cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_FPREGS(tp, fpregs1);
6664cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_FPREGS(tp, fpregs2);
6665cdebaff8SEnji Cooper 
6666cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_PT_STEP(tp, step1);
6667cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_PT_STEP(tp, step2);
6668cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_PT_STEP(tp, step3);
6669cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_PT_STEP(tp, step4);
6670cdebaff8SEnji Cooper 
6671cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, kill1);
6672cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, kill2);
6673cdebaff8SEnji Cooper 
6674cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, lwpinfo1);
6675cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, lwpinfo2);
6676cdebaff8SEnji Cooper 
6677cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, siginfo1);
6678cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, siginfo2);
6679cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, siginfo3);
6680cdebaff8SEnji Cooper 	ATF_TP_ADD_TC(tp, siginfo4);
6681cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, siginfo5);
6682cdebaff8SEnji Cooper 	ATF_TP_ADD_TC_PT_STEP(tp, siginfo6);
6683cdebaff8SEnji Cooper 
6684f40f3adcSEnji Cooper 	ATF_TP_ADD_TC(tp, lwp_create1);
6685f40f3adcSEnji Cooper 
6686f40f3adcSEnji Cooper 	ATF_TP_ADD_TC(tp, lwp_exit1);
6687f40f3adcSEnji Cooper 
6688*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, signal1);
6689*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, signal2);
6690*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, signal3);
6691*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC_PT_STEP(tp, signal4);
6692*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, signal5);
6693*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, signal6);
6694*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC_HAVE_PID(tp, signal7);
6695*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, signal8);
6696*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, signal9);
6697*dd66b5baSEnji Cooper 	ATF_TP_ADD_TC(tp, signal10);
6698*dd66b5baSEnji Cooper 
6699cdebaff8SEnji Cooper 	return atf_no_error();
6700cdebaff8SEnji Cooper }
6701