Index: head/lib/libc/sys/ptrace.2
===================================================================
--- head/lib/libc/sys/ptrace.2	(revision 350016)
+++ head/lib/libc/sys/ptrace.2	(revision 350017)
@@ -1,1127 +1,1173 @@
 .\" $FreeBSD$
 .\"	$NetBSD: ptrace.2,v 1.2 1995/02/27 12:35:37 cgd Exp $
 .\"
 .\" This file is in the public domain.
-.Dd June 2, 2018
+.Dd July 15, 2019
 .Dt PTRACE 2
 .Os
 .Sh NAME
 .Nm ptrace
 .Nd process tracing and debugging
 .Sh LIBRARY
 .Lb libc
 .Sh SYNOPSIS
 .In sys/types.h
 .In sys/ptrace.h
 .Ft int
 .Fn ptrace "int request" "pid_t pid" "caddr_t addr" "int data"
 .Sh DESCRIPTION
 The
 .Fn ptrace
 system call
 provides tracing and debugging facilities.
 It allows one process
 (the
 .Em tracing
 process)
 to control another
 (the
 .Em traced
 process).
 The tracing process must first attach to the traced process, and then
 issue a series of
 .Fn ptrace
 system calls to control the execution of the process, as well as access
 process memory and register state.
 For the duration of the tracing session, the traced process will be
 .Dq re-parented ,
 with its parent process ID (and resulting behavior)
 changed to the tracing process.
 It is permissible for a tracing process to attach to more than one
 other process at a time.
 When the tracing process has completed its work, it must detach the
 traced process; if a tracing process exits without first detaching all
 processes it has attached, those processes will be killed.
 .Pp
 Most of the time, the traced process runs normally, but when it
 receives a signal
 (see
 .Xr sigaction 2 ) ,
 it stops.
 The tracing process is expected to notice this via
 .Xr wait 2
 or the delivery of a
 .Dv SIGCHLD
 signal, examine the state of the stopped process, and cause it to
 terminate or continue as appropriate.
 The signal may be a normal process signal, generated as a result of
 traced process behavior, or use of the
 .Xr kill 2
 system call; alternatively, it may be generated by the tracing facility
 as a result of attaching, stepping by the tracing
 process,
 or an event in the traced process.
 The tracing process may choose to intercept the signal, using it to
 observe process behavior (such as
 .Dv SIGTRAP ) ,
 or forward the signal to the process if appropriate.
 The
 .Fn ptrace
 system call
 is the mechanism by which all this happens.
 .Pp
 A traced process may report additional signal stops corresponding to
 events in the traced process.
 These additional signal stops are reported as
 .Dv SIGTRAP
 or
 .Dv SIGSTOP
 signals.
 The tracing process can use the
 .Dv PT_LWPINFO
 request to determine which events are associated with a
 .Dv SIGTRAP
 or
 .Dv SIGSTOP
 signal.
 Note that multiple events may be associated with a single signal.
 For example, events indicated by the
 .Dv PL_FLAG_BORN ,
 .Dv PL_FLAG_FORKED ,
 and
 .Dv PL_FLAG_EXEC
 flags are also reported as a system call exit event
 .Pq Dv PL_FLAG_SCX .
 The signal stop for a new child process enabled via
 .Dv PTRACE_FORK
 will report a
 .Dv SIGSTOP
 signal.
 All other additional signal stops use
 .Dv SIGTRAP .
 .Pp
 Each traced process has a tracing event mask.
 An event in the traced process only reports a
 signal stop if the corresponding flag is set in the tracing event mask.
 The current set of tracing event flags include:
 .Bl -tag -width "Dv PTRACE_SYSCALL"
 .It Dv PTRACE_EXEC
 Report a stop for a successful invocation of
 .Xr execve 2 .
 This event is indicated by the
 .Dv PL_FLAG_EXEC
 flag in the
 .Va pl_flags
 member of
 .Vt "struct ptrace_lwpinfo" .
 .It Dv PTRACE_SCE
 Report a stop on each system call entry.
 This event is indicated by the
 .Dv PL_FLAG_SCE
 flag in the
 .Va pl_flags
 member of
 .Vt "struct ptrace_lwpinfo" .
 .It Dv PTRACE_SCX
 Report a stop on each system call exit.
 This event is indicated by the
 .Dv PL_FLAG_SCX
 flag in the
 .Va pl_flags
 member of
 .Vt "struct ptrace_lwpinfo" .
 .It Dv PTRACE_SYSCALL
 Report stops for both system call entry and exit.
 .It Dv PTRACE_FORK
 This event flag controls tracing for new child processes of a traced process.
 .Pp
 When this event flag is enabled,
 new child processes will enable tracing and stop before executing their
 first instruction.
 The new child process will include the
 .Dv PL_FLAG_CHILD
 flag in the
 .Va pl_flags
 member of
 .Vt "struct ptrace_lwpinfo" .
 The traced process will report a stop that includes the
 .Dv PL_FLAG_FORKED
 flag.
 The process ID of the new child process will also be present in the
 .Va pl_child_pid
 member of
 .Vt "struct ptrace_lwpinfo" .
 If the new child process was created via
 .Xr vfork 2 ,
 the traced process's stop will also include the
 .Dv PL_FLAG_VFORKED
 flag.
 Note that new child processes will be attached with the default
 tracing event mask;
 they do not inherit the event mask of the traced process.
 .Pp
 When this event flag is not enabled,
 new child processes will execute without tracing enabled.
 .It Dv PTRACE_LWP
 This event flag controls tracing of LWP
 .Pq kernel thread
 creation and destruction.
 When this event is enabled,
 new LWPs will stop and report an event with
 .Dv PL_FLAG_BORN
 set before executing their first instruction,
 and exiting LWPs will stop and report an event with
 .Dv PL_FLAG_EXITED
 set before completing their termination.
 .Pp
 Note that new processes do not report an event for the creation of their
 initial thread,
 and exiting processes do not report an event for the termination of the
 last thread.
 .It Dv PTRACE_VFORK
 Report a stop event when a parent process resumes after a
 .Xr vfork 2 .
 .Pp
 When a thread in the traced process creates a new child process via
 .Xr vfork 2 ,
 the stop that reports
 .Dv PL_FLAG_FORKED
 and
 .Dv PL_FLAG_SCX
 occurs just after the child process is created,
 but before the thread waits for the child process to stop sharing process
 memory.
 If a debugger is not tracing the new child process,
 it must ensure that no breakpoints are enabled in the shared process
 memory before detaching from the new child process.
 This means that no breakpoints are enabled in the parent process either.
 .Pp
 The
 .Dv PTRACE_VFORK
 flag enables a new stop that indicates when the new child process stops
 sharing the process memory of the parent process.
 A debugger can reinsert breakpoints in the parent process and resume it
 in response to this event.
 This event is indicated by setting the
 .Dv PL_FLAG_VFORK_DONE
 flag.
 .El
 .Pp
 The default tracing event mask when attaching to a process via
 .Dv PT_ATTACH ,
 .Dv PT_TRACE_ME ,
 or
 .Dv PTRACE_FORK
 includes only
 .Dv PTRACE_EXEC
 events.
 All other event flags are disabled.
 .Pp
 The
 .Fa request
 argument specifies what operation is being performed; the meaning of
 the rest of the arguments depends on the operation, but except for one
 special case noted below, all
 .Fn ptrace
 calls are made by the tracing process, and the
 .Fa pid
 argument specifies the process ID of the traced process
 or a corresponding thread ID.
 The
 .Fa request
 argument
 can be:
 .Bl -tag -width "Dv PT_GET_EVENT_MASK"
 .It Dv PT_TRACE_ME
 This request is the only one used by the traced process; it declares
 that the process expects to be traced by its parent.
 All the other arguments are ignored.
 (If the parent process does not expect to trace the child, it will
 probably be rather confused by the results; once the traced process
 stops, it cannot be made to continue except via
 .Fn ptrace . )
 When a process has used this request and calls
 .Xr execve 2
 or any of the routines built on it
 (such as
 .Xr execv 3 ) ,
 it will stop before executing the first instruction of the new image.
 Also, any setuid or setgid bits on the executable being executed will
 be ignored.
 If the child was created by
 .Xr vfork 2
 system call or
 .Xr rfork 2
 call with the
 .Dv RFMEM
 flag specified, the debugging events are reported to the parent
 only after the
 .Xr execve 2
 is executed.
 .It Dv PT_READ_I , Dv PT_READ_D
 These requests read a single
 .Vt int
 of data from the traced process's address space.
 Traditionally,
 .Fn ptrace
 has allowed for machines with distinct address spaces for instruction
 and data, which is why there are two requests: conceptually,
 .Dv PT_READ_I
 reads from the instruction space and
 .Dv PT_READ_D
 reads from the data space.
 In the current
 .Fx
 implementation, these two requests are completely identical.
 The
 .Fa addr
 argument specifies the address
 (in the traced process's virtual address space)
 at which the read is to be done.
 This address does not have to meet any alignment constraints.
 The value read is returned as the return value from
 .Fn ptrace .
 .It Dv PT_WRITE_I , Dv PT_WRITE_D
 These requests parallel
 .Dv PT_READ_I
 and
 .Dv PT_READ_D ,
 except that they write rather than read.
 The
 .Fa data
 argument supplies the value to be written.
 .It Dv PT_IO
 This request allows reading and writing arbitrary amounts of data in
 the traced process's address space.
 The
 .Fa addr
 argument specifies a pointer to a
 .Vt "struct ptrace_io_desc" ,
 which is defined as follows:
 .Bd -literal
 struct ptrace_io_desc {
 	int	piod_op;	/* I/O operation */
 	void	*piod_offs;	/* child offset */
 	void	*piod_addr;	/* parent offset */
 	size_t	piod_len;	/* request length */
 };
 
 /*
  * Operations in piod_op.
  */
 #define PIOD_READ_D	1	/* Read from D space */
 #define PIOD_WRITE_D	2	/* Write to D space */
 #define PIOD_READ_I	3	/* Read from I space */
 #define PIOD_WRITE_I	4	/* Write to I space */
 .Ed
 .Pp
 The
 .Fa data
 argument is ignored.
 The actual number of bytes read or written is stored in
 .Va piod_len
 upon return.
 .It Dv PT_CONTINUE
 The traced process continues execution.
 The
 .Fa addr
 argument
 is an address specifying the place where execution is to be resumed
 (a new value for the program counter),
 or
 .Po Vt caddr_t Pc Ns 1
 to indicate that execution is to pick up where it left off.
 The
 .Fa data
 argument
 provides a signal number to be delivered to the traced process as it
 resumes execution, or 0 if no signal is to be sent.
 .It Dv PT_STEP
 The traced process is single stepped one instruction.
 The
 .Fa addr
 argument
 should be passed
 .Po Vt caddr_t Pc Ns 1 .
 The
 .Fa data
 argument
 provides a signal number to be delivered to the traced process as it
 resumes execution, or 0 if no signal is to be sent.
 .It Dv PT_KILL
 The traced process terminates, as if
 .Dv PT_CONTINUE
 had been used with
 .Dv SIGKILL
 given as the signal to be delivered.
 .It Dv PT_ATTACH
 This request allows a process to gain control of an otherwise
 unrelated process and begin tracing it.
 It does not need any cooperation from the to-be-traced process.
 In
 this case,
 .Fa pid
 specifies the process ID of the to-be-traced process, and the other
 two arguments are ignored.
 This request requires that the target process must have the same real
 UID as the tracing process, and that it must not be executing a setuid
 or setgid executable.
 (If the tracing process is running as root, these restrictions do not
 apply.)
 The tracing process will see the newly-traced process stop and may
 then control it as if it had been traced all along.
 .It Dv PT_DETACH
 This request is like PT_CONTINUE, except that it does not allow
 specifying an alternate place to continue execution, and after it
 succeeds, the traced process is no longer traced and continues
 execution normally.
 .It Dv PT_GETREGS
 This request reads the traced process's machine registers into the
 .Do
 .Vt "struct reg"
 .Dc
 (defined in
 .In machine/reg.h )
 pointed to by
 .Fa addr .
 .It Dv PT_SETREGS
 This request is the converse of
 .Dv PT_GETREGS ;
 it loads the traced process's machine registers from the
 .Do
 .Vt "struct reg"
 .Dc
 (defined in
 .In machine/reg.h )
 pointed to by
 .Fa addr .
 .It Dv PT_GETFPREGS
 This request reads the traced process's floating-point registers into
 the
 .Do
 .Vt "struct fpreg"
 .Dc
 (defined in
 .In machine/reg.h )
 pointed to by
 .Fa addr .
 .It Dv PT_SETFPREGS
 This request is the converse of
 .Dv PT_GETFPREGS ;
 it loads the traced process's floating-point registers from the
 .Do
 .Vt "struct fpreg"
 .Dc
 (defined in
 .In machine/reg.h )
 pointed to by
 .Fa addr .
 .It Dv PT_GETDBREGS
 This request reads the traced process's debug registers into
 the
 .Do
 .Vt "struct dbreg"
 .Dc
 (defined in
 .In machine/reg.h )
 pointed to by
 .Fa addr .
 .It Dv PT_SETDBREGS
 This request is the converse of
 .Dv PT_GETDBREGS ;
 it loads the traced process's debug registers from the
 .Do
 .Vt "struct dbreg"
 .Dc
 (defined in
 .In machine/reg.h )
 pointed to by
 .Fa addr .
 .It Dv PT_LWPINFO
 This request can be used to obtain information about the kernel thread,
 also known as light-weight process, that caused the traced process to stop.
 The
 .Fa addr
 argument specifies a pointer to a
 .Vt "struct ptrace_lwpinfo" ,
 which is defined as follows:
 .Bd -literal
 struct ptrace_lwpinfo {
 	lwpid_t pl_lwpid;
 	int	pl_event;
 	int	pl_flags;
 	sigset_t pl_sigmask;
 	sigset_t pl_siglist;
 	siginfo_t pl_siginfo;
 	char	pl_tdname[MAXCOMLEN + 1];
 	pid_t	pl_child_pid;
 	u_int	pl_syscall_code;
 	u_int	pl_syscall_narg;
 };
 .Ed
 .Pp
 The
 .Fa data
 argument is to be set to the size of the structure known to the caller.
 This allows the structure to grow without affecting older programs.
 .Pp
 The fields in the
 .Vt "struct ptrace_lwpinfo"
 have the following meaning:
 .Bl -tag -width indent -compact
 .It Va pl_lwpid
 LWP id of the thread
 .It Va pl_event
 Event that caused the stop.
 Currently defined events are:
 .Bl -tag -width "Dv PL_EVENT_SIGNAL" -compact
 .It Dv PL_EVENT_NONE
 No reason given
 .It Dv PL_EVENT_SIGNAL
 Thread stopped due to the pending signal
 .El
 .It Va pl_flags
 Flags that specify additional details about observed stop.
 Currently defined flags are:
 .Bl -tag -width indent -compact
 .It Dv PL_FLAG_SCE
 The thread stopped due to system call entry, right after the kernel is entered.
 The debugger may examine syscall arguments that are stored in memory and
 registers according to the ABI of the current process, and modify them,
 if needed.
 .It Dv PL_FLAG_SCX
 The thread is stopped immediately before syscall is returning to the usermode.
 The debugger may examine system call return values in the ABI-defined registers
 and/or memory.
 .It Dv PL_FLAG_EXEC
 When
 .Dv PL_FLAG_SCX
 is set, this flag may be additionally specified to inform that the
 program being executed by debuggee process has been changed by successful
 execution of a system call from the
 .Fn execve 2
 family.
 .It Dv PL_FLAG_SI
 Indicates that
 .Va pl_siginfo
 member of
 .Vt "struct ptrace_lwpinfo"
 contains valid information.
 .It Dv PL_FLAG_FORKED
 Indicates that the process is returning from a call to
 .Fn fork 2
 that created a new child process.
 The process identifier of the new process is available in the
 .Va pl_child_pid
 member of
 .Vt "struct ptrace_lwpinfo" .
 .It Dv PL_FLAG_CHILD
 The flag is set for first event reported from a new child which is
 automatically attached when
 .Dv PTRACE_FORK
 is enabled.
 .It Dv PL_FLAG_BORN
 This flag is set for the first event reported from a new LWP when
 .Dv PTRACE_LWP
 is enabled.
 It is reported along with
 .Dv PL_FLAG_SCX .
 .It Dv PL_FLAG_EXITED
 This flag is set for the last event reported by an exiting LWP when
 .Dv PTRACE_LWP
 is enabled.
 Note that this event is not reported when the last LWP in a process exits.
 The termination of the last thread is reported via a normal process exit
 event.
 .It Dv PL_FLAG_VFORKED
 Indicates that the thread is returning from a call to
 .Xr vfork 2
 that created a new child process.
 This flag is set in addition to
 .Dv PL_FLAG_FORKED .
 .It Dv PL_FLAG_VFORK_DONE
 Indicates that the thread has resumed after a child process created via
 .Xr vfork 2
 has stopped sharing its address space with the traced process.
 .El
 .It Va pl_sigmask
 The current signal mask of the LWP
 .It Va pl_siglist
 The current pending set of signals for the LWP.
 Note that signals that are delivered to the process would not appear
 on an LWP siglist until the thread is selected for delivery.
 .It Va pl_siginfo
 The siginfo that accompanies the signal pending.
 Only valid for
 .Dv PL_EVENT_SIGNAL
 stop when
 .Dv PL_FLAG_SI
 is set in
 .Va pl_flags .
 .It Va pl_tdname
 The name of the thread.
 .It Va pl_child_pid
 The process identifier of the new child process.
 Only valid for a
 .Dv PL_EVENT_SIGNAL
 stop when
 .Dv PL_FLAG_FORKED
 is set in
 .Va pl_flags .
 .It Va pl_syscall_code
 The ABI-specific identifier of the current system call.
 Note that for indirect system calls this field reports the indirected
 system call.
 Only valid when
 .Dv PL_FLAG_SCE
 or
 .Dv PL_FLAG_SCX
 is set in
 .Va pl_flags.
 .It Va pl_syscall_narg
 The number of arguments passed to the current system call not counting
 the system call identifier.
 Note that for indirect system calls this field reports the arguments
 passed to the indirected system call.
 Only valid when
 .Dv PL_FLAG_SCE
 or
 .Dv PL_FLAG_SCX
 is set in
 .Va pl_flags.
 .El
 .It Dv PT_GETNUMLWPS
 This request returns the number of kernel threads associated with the
 traced process.
 .It Dv PT_GETLWPLIST
 This request can be used to get the current thread list.
 A pointer to an array of type
 .Vt lwpid_t
 should be passed in
 .Fa addr ,
 with the array size specified by
 .Fa data .
 The return value from
 .Fn ptrace
 is the count of array entries filled in.
 .It Dv PT_SETSTEP
 This request will turn on single stepping of the specified process.
 Stepping is automatically disabled when a single step trap is caught.
 .It Dv PT_CLEARSTEP
 This request will turn off single stepping of the specified process.
 .It Dv PT_SUSPEND
 This request will suspend the specified thread.
 .It Dv PT_RESUME
 This request will resume the specified thread.
 .It Dv PT_TO_SCE
 This request will set the
 .Dv PTRACE_SCE
 event flag to trace all future system call entries and continue the process.
 The
 .Fa addr
 and
 .Fa data
 arguments are used the same as for
 .Dv PT_CONTINUE.
 .It Dv PT_TO_SCX
 This request will set the
 .Dv PTRACE_SCX
 event flag to trace all future system call exits and continue the process.
 The
 .Fa addr
 and
 .Fa data
 arguments are used the same as for
 .Dv PT_CONTINUE.
 .It Dv PT_SYSCALL
 This request will set the
 .Dv PTRACE_SYSCALL
 event flag to trace all future system call entries and exits and continue
 the process.
 The
 .Fa addr
 and
 .Fa data
 arguments are used the same as for
 .Dv PT_CONTINUE.
 .It Dv PT_GET_SC_ARGS
 For the thread which is stopped in either
 .Dv PL_FLAG_SCE
 or
 .Dv PL_FLAG_SCX
 state, that is, on entry or exit to a syscall,
 this request fetches the syscall arguments.
 .Pp
 The arguments are copied out into the buffer pointed to by the
 .Fa addr
 pointer, sequentially.
 Each syscall argument is stored as the machine word.
 Kernel copies out as many arguments as the syscall accepts,
 see the
 .Va pl_syscall_narg
 member of the
 .Vt struct ptrace_lwpinfo ,
 but not more than the
 .Fa data
 bytes in total are copied.
+.It Dv PT_GET_SC_RET
+Fetch the system call return values on exit from a syscall.
+This request is only valid for threads stopped in a syscall
+exit (the
+.Dv PL_FLAG_SCX
+state).
+The
+.Fa addr
+argument specifies a pointer to a
+.Vt "struct ptrace_sc_ret" ,
+which is defined as follows:
+.Bd -literal
+struct ptrace_sc_ret {
+	register_t	sr_retval[2];
+	int		sr_error;
+};
+.Ed
+.Pp
+The
+.Fa data
+argument is set to the size of the structure.
+.Pp
+If the system call completed successfully,
+.Va sr_error
+is set to zero and the return values of the system call are saved in
+.Va sr_retval .
+If the system call failed to execute,
+.Va sr_error
+field is set to a positive
+.Xr errno 2
+value.
+If the system call completed in an unusual fashion,
+.Va sr_error
+is set to a negative value:
+.Pp
+.Bl -tag -width Dv EJUSTRETURN -compact
+.It Dv ERESTART
+System call will be restarted.
+.It Dv EJUSTRETURN
+System call completed sucessfully but did not set a return value
+.Po for example,
+.Xr setcontext 2
+and
+.Xr sigreturn 2
+.Pc .
+.El
 .It Dv PT_FOLLOW_FORK
 This request controls tracing for new child processes of a traced process.
 If
 .Fa data
 is non-zero,
 .Dv PTRACE_FORK
 is set in the traced process's event tracing mask.
 If
 .Fa data
 is zero,
 .Dv PTRACE_FORK
 is cleared from the traced process's event tracing mask.
 .It Dv PT_LWP_EVENTS
 This request controls tracing of LWP creation and destruction.
 If
 .Fa data
 is non-zero,
 .Dv PTRACE_LWP
 is set in the traced process's event tracing mask.
 If
 .Fa data
 is zero,
 .Dv PTRACE_LWP
 is cleared from the traced process's event tracing mask.
 .It Dv PT_GET_EVENT_MASK
 This request reads the traced process's event tracing mask into the
 integer pointed to by
 .Fa addr .
 The size of the integer must be passed in
 .Fa data .
 .It Dv PT_SET_EVENT_MASK
 This request sets the traced process's event tracing mask from the
 integer pointed to by
 .Fa addr .
 The size of the integer must be passed in
 .Fa data .
 .It Dv PT_VM_TIMESTAMP
 This request returns the generation number or timestamp of the memory map of
 the traced process as the return value from
 .Fn ptrace .
 This provides a low-cost way for the tracing process to determine if the
 VM map changed since the last time this request was made.
 .It Dv PT_VM_ENTRY
 This request is used to iterate over the entries of the VM map of the traced
 process.
 The
 .Fa addr
 argument specifies a pointer to a
 .Vt "struct ptrace_vm_entry" ,
 which is defined as follows:
 .Bd -literal
 struct ptrace_vm_entry {
 	int		pve_entry;
 	int		pve_timestamp;
 	u_long		pve_start;
 	u_long		pve_end;
 	u_long		pve_offset;
 	u_int		pve_prot;
 	u_int		pve_pathlen;
 	long		pve_fileid;
 	uint32_t	pve_fsid;
 	char		*pve_path;
 };
 .Ed
 .Pp
 The first entry is returned by setting
 .Va pve_entry
 to zero.
 Subsequent entries are returned by leaving
 .Va pve_entry
 unmodified from the value returned by previous requests.
 The
 .Va pve_timestamp
 field can be used to detect changes to the VM map while iterating over the
 entries.
 The tracing process can then take appropriate action, such as restarting.
 By setting
 .Va pve_pathlen
 to a non-zero value on entry, the pathname of the backing object is returned
 in the buffer pointed to by
 .Va pve_path ,
 provided the entry is backed by a vnode.
 The
 .Va pve_pathlen
 field is updated with the actual length of the pathname (including the
 terminating null character).
 The
 .Va pve_offset
 field is the offset within the backing object at which the range starts.
 The range is located in the VM space at
 .Va pve_start
 and extends up to
 .Va pve_end
 (inclusive).
 .Pp
 The
 .Fa data
 argument is ignored.
 .El
 .Sh ARM MACHINE-SPECIFIC REQUESTS
 .Bl -tag -width "Dv PT_SETVFPREGS"
 .It Dv PT_GETVFPREGS
 Return the thread's
 .Dv VFP
 machine state in the buffer pointed to by
 .Fa addr .
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_SETVFPREGS
 Set the thread's
 .Dv VFP
 machine state from the buffer pointed to by
 .Fa addr .
 .Pp
 The
 .Fa data
 argument is ignored.
 .El
 .Pp
 .Sh x86 MACHINE-SPECIFIC REQUESTS
 .Bl -tag -width "Dv PT_GETXSTATE_INFO"
 .It Dv PT_GETXMMREGS
 Copy the XMM FPU state into the buffer pointed to by the
 argument
 .Fa addr .
 The buffer has the same layout as the 32-bit save buffer for the
 machine instruction
 .Dv FXSAVE .
 .Pp
 This request is only valid for i386 programs, both on native 32-bit
 systems and on amd64 kernels.
 For 64-bit amd64 programs, the XMM state is reported as part of
 the FPU state returned by the
 .Dv PT_GETFPREGS
 request.
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_SETXMMREGS
 Load the XMM FPU state for the thread from the buffer pointed to
 by the argument
 .Fa addr .
 The buffer has the same layout as the 32-bit load buffer for the
 machine instruction
 .Dv FXRSTOR .
 .Pp
 As with
 .Dv PT_GETXMMREGS,
 this request is only valid for i386 programs.
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_GETXSTATE_INFO
 Report which XSAVE FPU extensions are supported by the CPU
 and allowed in userspace programs.
 The
 .Fa addr
 argument must point to a variable of type
 .Vt struct ptrace_xstate_info ,
 which contains the information on the request return.
 .Vt struct ptrace_xstate_info
 is defined as follows:
 .Bd -literal
 struct ptrace_xstate_info {
 	uint64_t	xsave_mask;
 	uint32_t	xsave_len;
 };
 .Ed
 The
 .Dv xsave_mask
 field is a bitmask of the currently enabled extensions.
 The meaning of the bits is defined in the Intel and AMD
 processor documentation.
 The
 .Dv xsave_len
 field reports the length of the XSAVE area for storing the hardware
 state for currently enabled extensions in the format defined by the x86
 .Dv XSAVE
 machine instruction.
 .Pp
 The
 .Fa data
 argument value must be equal to the size of the
 .Vt struct ptrace_xstate_info .
 .It Dv PT_GETXSTATE
 Return the content of the XSAVE area for the thread.
 The
 .Fa addr
 argument points to the buffer where the content is copied, and the
 .Fa data
 argument specifies the size of the buffer.
 The kernel copies out as much content as allowed by the buffer size.
 The buffer layout is specified by the layout of the save area for the
 .Dv XSAVE
 machine instruction.
 .It Dv PT_SETXSTATE
 Load the XSAVE state for the thread from the buffer specified by the
 .Fa addr
 pointer.
 The buffer size is passed in the
 .Fa data
 argument.
 The buffer must be at least as large as the
 .Vt struct savefpu
 (defined in
 .Pa x86/fpu.h )
 to allow the complete x87 FPU and XMM state load.
 It must not be larger than the XSAVE state length, as reported by the
 .Dv xsave_len
 field from the
 .Vt struct ptrace_xstate_info
 of the
 .Dv PT_GETXSTATE_INFO
 request.
 Layout of the buffer is identical to the layout of the load area for the
 .Dv XRSTOR
 machine instruction.
 .It Dv PT_GETFSBASE
 Return the value of the base used when doing segmented
 memory addressing using the %fs segment register.
 The
 .Fa addr
 argument points to an
 .Vt unsigned long
 variable where the base value is stored.
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_GETGSBASE
 Like the
 .Dv PT_GETFSBASE
 request, but returns the base for the %gs segment register.
 .It Dv PT_SETFSBASE
 Set the base for the %fs segment register to the value pointed to
 by the
 .Fa addr
 argument.
 .Fa addr
 must point to the
 .Vt unsigned long
 variable containing the new base.
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_SETGSBASE
 Like the
 .Dv PT_SETFSBASE
 request, but sets the base for the %gs segment register.
 .El
 .Sh PowerPC MACHINE-SPECIFIC REQUESTS
 .Bl -tag -width "Dv PT_SETVRREGS"
 .It Dv PT_GETVRREGS
 Return the thread's
 .Dv ALTIVEC
 machine state in the buffer pointed to by
 .Fa addr .
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_SETVRREGS
 Set the thread's
 .Dv ALTIVEC
 machine state from the buffer pointed to by
 .Fa addr .
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_GETVSRREGS
 Return doubleword 1 of the thread's
 .Dv VSX
 registers VSR0-VSR31 in the buffer pointed to by
 .Fa addr .
 .Pp
 The
 .Fa data
 argument is ignored.
 .It Dv PT_SETVSRREGS
 Set doubleword 1 of the thread's
 .Dv VSX
 registers VSR0-VSR31 from the buffer pointed to by
 .Fa addr .
 .Pp
 The
 .Fa data
 argument is ignored.
 .El
 .Pp
 Additionally, other machine-specific requests can exist.
 .Sh RETURN VALUES
 Most requests return 0 on success and \-1 on error.
 Some requests can cause
 .Fn ptrace
 to return
 \-1
 as a non-error value, among them are
 .Dv PT_READ_I
 and
 .Dv PT_READ_D ,
 which return the value read from the process memory on success.
 To disambiguate,
 .Va errno
 can be set to 0 before the call and checked afterwards.
 .Pp
 The current
 .Fn ptrace
 implementation always sets
 .Va errno
 to 0 before calling into the kernel, both for historic reasons and for
 consistency with other operating systems.
 It is recommended to assign zero to
 .Va errno
 explicitly for forward compatibility.
 .Sh ERRORS
 The
 .Fn ptrace
 system call may fail if:
 .Bl -tag -width Er
 .It Bq Er ESRCH
 .Bl -bullet -compact
 .It
 No process having the specified process ID exists.
 .El
 .It Bq Er EINVAL
 .Bl -bullet -compact
 .It
 A process attempted to use
 .Dv PT_ATTACH
 on itself.
 .It
 The
 .Fa request
 argument
 was not one of the legal requests.
 .It
 The signal number
 (in
 .Fa data )
 to
 .Dv PT_CONTINUE
 was neither 0 nor a legal signal number.
 .It
 .Dv PT_GETREGS ,
 .Dv PT_SETREGS ,
 .Dv PT_GETFPREGS ,
 .Dv PT_SETFPREGS ,
 .Dv PT_GETDBREGS ,
 or
 .Dv PT_SETDBREGS
 was attempted on a process with no valid register set.
 (This is normally true only of system processes.)
 .It
 .Dv PT_VM_ENTRY
 was given an invalid value for
 .Fa pve_entry .
 This can also be caused by changes to the VM map of the process.
 .It
 The size (in
 .Fa data )
 provided to
 .Dv PT_LWPINFO
 was less than or equal to zero, or larger than the
 .Vt ptrace_lwpinfo
 structure known to the kernel.
 .It
 The size (in
 .Fa data )
 provided to the x86-specific
 .Dv PT_GETXSTATE_INFO
 request was not equal to the size of the
 .Vt struct ptrace_xstate_info .
 .It
 The size (in
 .Fa data )
 provided to the x86-specific
 .Dv PT_SETXSTATE
 request was less than the size of the x87 plus the XMM save area.
 .It
 The size (in
 .Fa data )
 provided to the x86-specific
 .Dv PT_SETXSTATE
 request was larger than returned in the
 .Dv xsave_len
 member of the
 .Vt struct ptrace_xstate_info
 from the
 .Dv PT_GETXSTATE_INFO
 request.
 .It
 The base value, provided to the amd64-specific requests
 .Dv PT_SETFSBASE
 or
 .Dv PT_SETGSBASE ,
 pointed outside of the valid user address space.
 This error will not occur in 32-bit programs.
 .El
 .It Bq Er EBUSY
 .Bl -bullet -compact
 .It
 .Dv PT_ATTACH
 was attempted on a process that was already being traced.
 .It
 A request attempted to manipulate a process that was being traced by
 some process other than the one making the request.
 .It
 A request
 (other than
 .Dv PT_ATTACH )
 specified a process that was not stopped.
 .El
 .It Bq Er EPERM
 .Bl -bullet -compact
 .It
 A request
 (other than
 .Dv PT_ATTACH )
 attempted to manipulate a process that was not being traced at all.
 .It
 An attempt was made to use
 .Dv PT_ATTACH
 on a process in violation of the requirements listed under
 .Dv PT_ATTACH
 above.
 .El
 .It Bq Er ENOENT
 .Bl -bullet -compact
 .It
 .Dv PT_VM_ENTRY
 previously returned the last entry of the memory map.
 No more entries exist.
 .El
 .It Bq Er ENAMETOOLONG
 .Bl -bullet -compact
 .It
 .Dv PT_VM_ENTRY
 cannot return the pathname of the backing object because the buffer is not big
 enough.
 .Fa pve_pathlen
 holds the minimum buffer size required on return.
 .El
 .El
 .Sh SEE ALSO
 .Xr execve 2 ,
 .Xr sigaction 2 ,
 .Xr wait 2 ,
 .Xr execv 3 ,
 .Xr i386_clr_watch 3 ,
 .Xr i386_set_watch 3
 .Sh HISTORY
 The
 .Fn ptrace
 function appeared in
 .At v6 .
Index: head/sys/kern/sys_process.c
===================================================================
--- head/sys/kern/sys_process.c	(revision 350016)
+++ head/sys/kern/sys_process.c	(revision 350017)
@@ -1,1498 +1,1557 @@
 /*-
  * SPDX-License-Identifier: BSD-4-Clause
  *
  * Copyright (c) 1994, Sean Eric Fagan
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by Sean Eric Fagan.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/ktr.h>
 #include <sys/lock.h>
 #include <sys/mutex.h>
 #include <sys/syscallsubr.h>
 #include <sys/sysent.h>
 #include <sys/sysproto.h>
 #include <sys/pioctl.h>
 #include <sys/priv.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/ptrace.h>
 #include <sys/rwlock.h>
 #include <sys/sx.h>
 #include <sys/malloc.h>
 #include <sys/signalvar.h>
 
 #include <machine/reg.h>
 
 #include <security/audit/audit.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #include <vm/vm_extern.h>
 #include <vm/vm_map.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_object.h>
 #include <vm/vm_page.h>
 #include <vm/vm_param.h>
 
 #ifdef COMPAT_FREEBSD32
 #include <sys/procfs.h>
 #include <compat/freebsd32/freebsd32_signal.h>
 
 struct ptrace_io_desc32 {
 	int		piod_op;
 	uint32_t	piod_offs;
 	uint32_t	piod_addr;
 	uint32_t	piod_len;
 };
 
+struct ptrace_sc_ret32 {
+	uint32_t	sr_retval[2];
+	int		sr_error;
+};
+
 struct ptrace_vm_entry32 {
 	int		pve_entry;
 	int		pve_timestamp;
 	uint32_t	pve_start;
 	uint32_t	pve_end;
 	uint32_t	pve_offset;
 	u_int		pve_prot;
 	u_int		pve_pathlen;
 	int32_t		pve_fileid;
 	u_int		pve_fsid;
 	uint32_t	pve_path;
 };
 #endif
 
 /*
  * Functions implemented using PROC_ACTION():
  *
  * proc_read_regs(proc, regs)
  *	Get the current user-visible register set from the process
  *	and copy it into the regs structure (<machine/reg.h>).
  *	The process is stopped at the time read_regs is called.
  *
  * proc_write_regs(proc, regs)
  *	Update the current register set from the passed in regs
  *	structure.  Take care to avoid clobbering special CPU
  *	registers or privileged bits in the PSL.
  *	Depending on the architecture this may have fix-up work to do,
  *	especially if the IAR or PCW are modified.
  *	The process is stopped at the time write_regs is called.
  *
  * proc_read_fpregs, proc_write_fpregs
  *	deal with the floating point register set, otherwise as above.
  *
  * proc_read_dbregs, proc_write_dbregs
  *	deal with the processor debug register set, otherwise as above.
  *
  * proc_sstep(proc)
  *	Arrange for the process to trap after executing a single instruction.
  */
 
 #define	PROC_ACTION(action) do {					\
 	int error;							\
 									\
 	PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);			\
 	if ((td->td_proc->p_flag & P_INMEM) == 0)			\
 		error = EIO;						\
 	else								\
 		error = (action);					\
 	return (error);							\
 } while(0)
 
 int
 proc_read_regs(struct thread *td, struct reg *regs)
 {
 
 	PROC_ACTION(fill_regs(td, regs));
 }
 
 int
 proc_write_regs(struct thread *td, struct reg *regs)
 {
 
 	PROC_ACTION(set_regs(td, regs));
 }
 
 int
 proc_read_dbregs(struct thread *td, struct dbreg *dbregs)
 {
 
 	PROC_ACTION(fill_dbregs(td, dbregs));
 }
 
 int
 proc_write_dbregs(struct thread *td, struct dbreg *dbregs)
 {
 
 	PROC_ACTION(set_dbregs(td, dbregs));
 }
 
 /*
  * Ptrace doesn't support fpregs at all, and there are no security holes
  * or translations for fpregs, so we can just copy them.
  */
 int
 proc_read_fpregs(struct thread *td, struct fpreg *fpregs)
 {
 
 	PROC_ACTION(fill_fpregs(td, fpregs));
 }
 
 int
 proc_write_fpregs(struct thread *td, struct fpreg *fpregs)
 {
 
 	PROC_ACTION(set_fpregs(td, fpregs));
 }
 
 #ifdef COMPAT_FREEBSD32
 /* For 32 bit binaries, we need to expose the 32 bit regs layouts. */
 int
 proc_read_regs32(struct thread *td, struct reg32 *regs32)
 {
 
 	PROC_ACTION(fill_regs32(td, regs32));
 }
 
 int
 proc_write_regs32(struct thread *td, struct reg32 *regs32)
 {
 
 	PROC_ACTION(set_regs32(td, regs32));
 }
 
 int
 proc_read_dbregs32(struct thread *td, struct dbreg32 *dbregs32)
 {
 
 	PROC_ACTION(fill_dbregs32(td, dbregs32));
 }
 
 int
 proc_write_dbregs32(struct thread *td, struct dbreg32 *dbregs32)
 {
 
 	PROC_ACTION(set_dbregs32(td, dbregs32));
 }
 
 int
 proc_read_fpregs32(struct thread *td, struct fpreg32 *fpregs32)
 {
 
 	PROC_ACTION(fill_fpregs32(td, fpregs32));
 }
 
 int
 proc_write_fpregs32(struct thread *td, struct fpreg32 *fpregs32)
 {
 
 	PROC_ACTION(set_fpregs32(td, fpregs32));
 }
 #endif
 
 int
 proc_sstep(struct thread *td)
 {
 
 	PROC_ACTION(ptrace_single_step(td));
 }
 
 int
 proc_rwmem(struct proc *p, struct uio *uio)
 {
 	vm_map_t map;
 	vm_offset_t pageno;		/* page number */
 	vm_prot_t reqprot;
 	int error, fault_flags, page_offset, writing;
 
 	/*
 	 * Assert that someone has locked this vmspace.  (Should be
 	 * curthread but we can't assert that.)  This keeps the process
 	 * from exiting out from under us until this operation completes.
 	 */
 	PROC_ASSERT_HELD(p);
 	PROC_LOCK_ASSERT(p, MA_NOTOWNED);
 
 	/*
 	 * The map we want...
 	 */
 	map = &p->p_vmspace->vm_map;
 
 	/*
 	 * If we are writing, then we request vm_fault() to create a private
 	 * copy of each page.  Since these copies will not be writeable by the
 	 * process, we must explicity request that they be dirtied.
 	 */
 	writing = uio->uio_rw == UIO_WRITE;
 	reqprot = writing ? VM_PROT_COPY | VM_PROT_READ : VM_PROT_READ;
 	fault_flags = writing ? VM_FAULT_DIRTY : VM_FAULT_NORMAL;
 
 	/*
 	 * Only map in one page at a time.  We don't have to, but it
 	 * makes things easier.  This way is trivial - right?
 	 */
 	do {
 		vm_offset_t uva;
 		u_int len;
 		vm_page_t m;
 
 		uva = (vm_offset_t)uio->uio_offset;
 
 		/*
 		 * Get the page number of this segment.
 		 */
 		pageno = trunc_page(uva);
 		page_offset = uva - pageno;
 
 		/*
 		 * How many bytes to copy
 		 */
 		len = min(PAGE_SIZE - page_offset, uio->uio_resid);
 
 		/*
 		 * Fault and hold the page on behalf of the process.
 		 */
 		error = vm_fault_hold(map, pageno, reqprot, fault_flags, &m);
 		if (error != KERN_SUCCESS) {
 			if (error == KERN_RESOURCE_SHORTAGE)
 				error = ENOMEM;
 			else
 				error = EFAULT;
 			break;
 		}
 
 		/*
 		 * Now do the i/o move.
 		 */
 		error = uiomove_fromphys(&m, page_offset, len, uio);
 
 		/* Make the I-cache coherent for breakpoints. */
 		if (writing && error == 0) {
 			vm_map_lock_read(map);
 			if (vm_map_check_protection(map, pageno, pageno +
 			    PAGE_SIZE, VM_PROT_EXECUTE))
 				vm_sync_icache(map, uva, len);
 			vm_map_unlock_read(map);
 		}
 
 		/*
 		 * Release the page.
 		 */
 		vm_page_lock(m);
 		if (vm_page_unwire(m, PQ_ACTIVE) && m->object == NULL)
 			vm_page_free(m);
 		vm_page_unlock(m);
 
 	} while (error == 0 && uio->uio_resid > 0);
 
 	return (error);
 }
 
 static ssize_t
 proc_iop(struct thread *td, struct proc *p, vm_offset_t va, void *buf,
     size_t len, enum uio_rw rw)
 {
 	struct iovec iov;
 	struct uio uio;
 	ssize_t slen;
 
 	MPASS(len < SSIZE_MAX);
 	slen = (ssize_t)len;
 
 	iov.iov_base = (caddr_t)buf;
 	iov.iov_len = len;
 	uio.uio_iov = &iov;
 	uio.uio_iovcnt = 1;
 	uio.uio_offset = va;
 	uio.uio_resid = slen;
 	uio.uio_segflg = UIO_SYSSPACE;
 	uio.uio_rw = rw;
 	uio.uio_td = td;
 	proc_rwmem(p, &uio);
 	if (uio.uio_resid == slen)
 		return (-1);
 	return (slen - uio.uio_resid);
 }
 
 ssize_t
 proc_readmem(struct thread *td, struct proc *p, vm_offset_t va, void *buf,
     size_t len)
 {
 
 	return (proc_iop(td, p, va, buf, len, UIO_READ));
 }
 
 ssize_t
 proc_writemem(struct thread *td, struct proc *p, vm_offset_t va, void *buf,
     size_t len)
 {
 
 	return (proc_iop(td, p, va, buf, len, UIO_WRITE));
 }
 
 static int
 ptrace_vm_entry(struct thread *td, struct proc *p, struct ptrace_vm_entry *pve)
 {
 	struct vattr vattr;
 	vm_map_t map;
 	vm_map_entry_t entry;
 	vm_object_t obj, tobj, lobj;
 	struct vmspace *vm;
 	struct vnode *vp;
 	char *freepath, *fullpath;
 	u_int pathlen;
 	int error, index;
 
 	error = 0;
 	obj = NULL;
 
 	vm = vmspace_acquire_ref(p);
 	map = &vm->vm_map;
 	vm_map_lock_read(map);
 
 	do {
 		entry = map->header.next;
 		index = 0;
 		while (index < pve->pve_entry && entry != &map->header) {
 			entry = entry->next;
 			index++;
 		}
 		if (index != pve->pve_entry) {
 			error = EINVAL;
 			break;
 		}
 		KASSERT((map->header.eflags & MAP_ENTRY_IS_SUB_MAP) == 0,
 		    ("Submap in map header"));
 		while ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) != 0) {
 			entry = entry->next;
 			index++;
 		}
 		if (entry == &map->header) {
 			error = ENOENT;
 			break;
 		}
 
 		/* We got an entry. */
 		pve->pve_entry = index + 1;
 		pve->pve_timestamp = map->timestamp;
 		pve->pve_start = entry->start;
 		pve->pve_end = entry->end - 1;
 		pve->pve_offset = entry->offset;
 		pve->pve_prot = entry->protection;
 
 		/* Backing object's path needed? */
 		if (pve->pve_pathlen == 0)
 			break;
 
 		pathlen = pve->pve_pathlen;
 		pve->pve_pathlen = 0;
 
 		obj = entry->object.vm_object;
 		if (obj != NULL)
 			VM_OBJECT_RLOCK(obj);
 	} while (0);
 
 	vm_map_unlock_read(map);
 
 	pve->pve_fsid = VNOVAL;
 	pve->pve_fileid = VNOVAL;
 
 	if (error == 0 && obj != NULL) {
 		lobj = obj;
 		for (tobj = obj; tobj != NULL; tobj = tobj->backing_object) {
 			if (tobj != obj)
 				VM_OBJECT_RLOCK(tobj);
 			if (lobj != obj)
 				VM_OBJECT_RUNLOCK(lobj);
 			lobj = tobj;
 			pve->pve_offset += tobj->backing_object_offset;
 		}
 		vp = vm_object_vnode(lobj);
 		if (vp != NULL)
 			vref(vp);
 		if (lobj != obj)
 			VM_OBJECT_RUNLOCK(lobj);
 		VM_OBJECT_RUNLOCK(obj);
 
 		if (vp != NULL) {
 			freepath = NULL;
 			fullpath = NULL;
 			vn_fullpath(td, vp, &fullpath, &freepath);
 			vn_lock(vp, LK_SHARED | LK_RETRY);
 			if (VOP_GETATTR(vp, &vattr, td->td_ucred) == 0) {
 				pve->pve_fileid = vattr.va_fileid;
 				pve->pve_fsid = vattr.va_fsid;
 			}
 			vput(vp);
 
 			if (fullpath != NULL) {
 				pve->pve_pathlen = strlen(fullpath) + 1;
 				if (pve->pve_pathlen <= pathlen) {
 					error = copyout(fullpath, pve->pve_path,
 					    pve->pve_pathlen);
 				} else
 					error = ENAMETOOLONG;
 			}
 			if (freepath != NULL)
 				free(freepath, M_TEMP);
 		}
 	}
 	vmspace_free(vm);
 	if (error == 0)
 		CTR3(KTR_PTRACE, "PT_VM_ENTRY: pid %d, entry %d, start %p",
 		    p->p_pid, pve->pve_entry, pve->pve_start);
 
 	return (error);
 }
 
 #ifdef COMPAT_FREEBSD32
 static int
 ptrace_vm_entry32(struct thread *td, struct proc *p,
     struct ptrace_vm_entry32 *pve32)
 {
 	struct ptrace_vm_entry pve;
 	int error;
 
 	pve.pve_entry = pve32->pve_entry;
 	pve.pve_pathlen = pve32->pve_pathlen;
 	pve.pve_path = (void *)(uintptr_t)pve32->pve_path;
 
 	error = ptrace_vm_entry(td, p, &pve);
 	if (error == 0) {
 		pve32->pve_entry = pve.pve_entry;
 		pve32->pve_timestamp = pve.pve_timestamp;
 		pve32->pve_start = pve.pve_start;
 		pve32->pve_end = pve.pve_end;
 		pve32->pve_offset = pve.pve_offset;
 		pve32->pve_prot = pve.pve_prot;
 		pve32->pve_fileid = pve.pve_fileid;
 		pve32->pve_fsid = pve.pve_fsid;
 	}
 
 	pve32->pve_pathlen = pve.pve_pathlen;
 	return (error);
 }
 
 static void
 ptrace_lwpinfo_to32(const struct ptrace_lwpinfo *pl,
     struct ptrace_lwpinfo32 *pl32)
 {
 
 	bzero(pl32, sizeof(*pl32));
 	pl32->pl_lwpid = pl->pl_lwpid;
 	pl32->pl_event = pl->pl_event;
 	pl32->pl_flags = pl->pl_flags;
 	pl32->pl_sigmask = pl->pl_sigmask;
 	pl32->pl_siglist = pl->pl_siglist;
 	siginfo_to_siginfo32(&pl->pl_siginfo, &pl32->pl_siginfo);
 	strcpy(pl32->pl_tdname, pl->pl_tdname);
 	pl32->pl_child_pid = pl->pl_child_pid;
 	pl32->pl_syscall_code = pl->pl_syscall_code;
 	pl32->pl_syscall_narg = pl->pl_syscall_narg;
 }
+
+static void
+ptrace_sc_ret_to32(const struct ptrace_sc_ret *psr,
+    struct ptrace_sc_ret32 *psr32)
+{
+
+	bzero(psr32, sizeof(*psr32));
+	psr32->sr_retval[0] = psr->sr_retval[0];
+	psr32->sr_retval[1] = psr->sr_retval[1];
+	psr32->sr_error = psr->sr_error;
+}
 #endif /* COMPAT_FREEBSD32 */
 
 /*
  * Process debugging system call.
  */
 #ifndef _SYS_SYSPROTO_H_
 struct ptrace_args {
 	int	req;
 	pid_t	pid;
 	caddr_t	addr;
 	int	data;
 };
 #endif
 
 #ifdef COMPAT_FREEBSD32
 /*
  * This CPP subterfuge is to try and reduce the number of ifdefs in
  * the body of the code.
  *   COPYIN(uap->addr, &r.reg, sizeof r.reg);
  * becomes either:
  *   copyin(uap->addr, &r.reg, sizeof r.reg);
  * or
  *   copyin(uap->addr, &r.reg32, sizeof r.reg32);
  * .. except this is done at runtime.
  */
 #define	BZERO(a, s)		wrap32 ? \
 	bzero(a ## 32, s ## 32) : \
 	bzero(a, s)
 #define	COPYIN(u, k, s)		wrap32 ? \
 	copyin(u, k ## 32, s ## 32) : \
 	copyin(u, k, s)
 #define	COPYOUT(k, u, s)	wrap32 ? \
 	copyout(k ## 32, u, s ## 32) : \
 	copyout(k, u, s)
 #else
 #define	BZERO(a, s)		bzero(a, s)
 #define	COPYIN(u, k, s)		copyin(u, k, s)
 #define	COPYOUT(k, u, s)	copyout(k, u, s)
 #endif
 int
 sys_ptrace(struct thread *td, struct ptrace_args *uap)
 {
 	/*
 	 * XXX this obfuscation is to reduce stack usage, but the register
 	 * structs may be too large to put on the stack anyway.
 	 */
 	union {
 		struct ptrace_io_desc piod;
 		struct ptrace_lwpinfo pl;
 		struct ptrace_vm_entry pve;
 		struct dbreg dbreg;
 		struct fpreg fpreg;
 		struct reg reg;
 #ifdef COMPAT_FREEBSD32
 		struct dbreg32 dbreg32;
 		struct fpreg32 fpreg32;
 		struct reg32 reg32;
 		struct ptrace_io_desc32 piod32;
 		struct ptrace_lwpinfo32 pl32;
 		struct ptrace_vm_entry32 pve32;
 #endif
 		char args[sizeof(td->td_sa.args)];
+		struct ptrace_sc_ret psr;
 		int ptevents;
 	} r;
 	void *addr;
 	int error = 0;
 #ifdef COMPAT_FREEBSD32
 	int wrap32 = 0;
 
 	if (SV_CURPROC_FLAG(SV_ILP32))
 		wrap32 = 1;
 #endif
 	AUDIT_ARG_PID(uap->pid);
 	AUDIT_ARG_CMD(uap->req);
 	AUDIT_ARG_VALUE(uap->data);
 	addr = &r;
 	switch (uap->req) {
 	case PT_GET_EVENT_MASK:
 	case PT_LWPINFO:
 	case PT_GET_SC_ARGS:
+	case PT_GET_SC_RET:
 		break;
 	case PT_GETREGS:
 		BZERO(&r.reg, sizeof r.reg);
 		break;
 	case PT_GETFPREGS:
 		BZERO(&r.fpreg, sizeof r.fpreg);
 		break;
 	case PT_GETDBREGS:
 		BZERO(&r.dbreg, sizeof r.dbreg);
 		break;
 	case PT_SETREGS:
 		error = COPYIN(uap->addr, &r.reg, sizeof r.reg);
 		break;
 	case PT_SETFPREGS:
 		error = COPYIN(uap->addr, &r.fpreg, sizeof r.fpreg);
 		break;
 	case PT_SETDBREGS:
 		error = COPYIN(uap->addr, &r.dbreg, sizeof r.dbreg);
 		break;
 	case PT_SET_EVENT_MASK:
 		if (uap->data != sizeof(r.ptevents))
 			error = EINVAL;
 		else
 			error = copyin(uap->addr, &r.ptevents, uap->data);
 		break;
 	case PT_IO:
 		error = COPYIN(uap->addr, &r.piod, sizeof r.piod);
 		break;
 	case PT_VM_ENTRY:
 		error = COPYIN(uap->addr, &r.pve, sizeof r.pve);
 		break;
 	default:
 		addr = uap->addr;
 		break;
 	}
 	if (error)
 		return (error);
 
 	error = kern_ptrace(td, uap->req, uap->pid, addr, uap->data);
 	if (error)
 		return (error);
 
 	switch (uap->req) {
 	case PT_VM_ENTRY:
 		error = COPYOUT(&r.pve, uap->addr, sizeof r.pve);
 		break;
 	case PT_IO:
 		error = COPYOUT(&r.piod, uap->addr, sizeof r.piod);
 		break;
 	case PT_GETREGS:
 		error = COPYOUT(&r.reg, uap->addr, sizeof r.reg);
 		break;
 	case PT_GETFPREGS:
 		error = COPYOUT(&r.fpreg, uap->addr, sizeof r.fpreg);
 		break;
 	case PT_GETDBREGS:
 		error = COPYOUT(&r.dbreg, uap->addr, sizeof r.dbreg);
 		break;
 	case PT_GET_EVENT_MASK:
 		/* NB: The size in uap->data is validated in kern_ptrace(). */
 		error = copyout(&r.ptevents, uap->addr, uap->data);
 		break;
 	case PT_LWPINFO:
 		/* NB: The size in uap->data is validated in kern_ptrace(). */
 		error = copyout(&r.pl, uap->addr, uap->data);
 		break;
 	case PT_GET_SC_ARGS:
 		error = copyout(r.args, uap->addr, MIN(uap->data,
 		    sizeof(r.args)));
 		break;
+	case PT_GET_SC_RET:
+		error = copyout(&r.psr, uap->addr, MIN(uap->data,
+		    sizeof(r.psr)));
+		break;
 	}
 
 	return (error);
 }
 #undef COPYIN
 #undef COPYOUT
 #undef BZERO
 
 #ifdef COMPAT_FREEBSD32
 /*
  *   PROC_READ(regs, td2, addr);
  * becomes either:
  *   proc_read_regs(td2, addr);
  * or
  *   proc_read_regs32(td2, addr);
  * .. except this is done at runtime.  There is an additional
  * complication in that PROC_WRITE disallows 32 bit consumers
  * from writing to 64 bit address space targets.
  */
 #define	PROC_READ(w, t, a)	wrap32 ? \
 	proc_read_ ## w ## 32(t, a) : \
 	proc_read_ ## w (t, a)
 #define	PROC_WRITE(w, t, a)	wrap32 ? \
 	(safe ? proc_write_ ## w ## 32(t, a) : EINVAL ) : \
 	proc_write_ ## w (t, a)
 #else
 #define	PROC_READ(w, t, a)	proc_read_ ## w (t, a)
 #define	PROC_WRITE(w, t, a)	proc_write_ ## w (t, a)
 #endif
 
 void
 proc_set_traced(struct proc *p, bool stop)
 {
 
 	sx_assert(&proctree_lock, SX_XLOCKED);
 	PROC_LOCK_ASSERT(p, MA_OWNED);
 	p->p_flag |= P_TRACED;
 	if (stop)
 		p->p_flag2 |= P2_PTRACE_FSTP;
 	p->p_ptevents = PTRACE_DEFAULT;
 }
 
 int
 kern_ptrace(struct thread *td, int req, pid_t pid, void *addr, int data)
 {
 	struct iovec iov;
 	struct uio uio;
 	struct proc *curp, *p, *pp;
 	struct thread *td2 = NULL, *td3;
 	struct ptrace_io_desc *piod = NULL;
 	struct ptrace_lwpinfo *pl;
+	struct ptrace_sc_ret *psr;
 	int error, num, tmp;
 	int proctree_locked = 0;
 	lwpid_t tid = 0, *buf;
 #ifdef COMPAT_FREEBSD32
 	int wrap32 = 0, safe = 0;
 	struct ptrace_io_desc32 *piod32 = NULL;
 	struct ptrace_lwpinfo32 *pl32 = NULL;
-	struct ptrace_lwpinfo plr;
+	struct ptrace_sc_ret32 *psr32 = NULL;
+	union {
+		struct ptrace_lwpinfo pl;
+		struct ptrace_sc_ret psr;
+	} r;
 #endif
 
 	curp = td->td_proc;
 
 	/* Lock proctree before locking the process. */
 	switch (req) {
 	case PT_TRACE_ME:
 	case PT_ATTACH:
 	case PT_STEP:
 	case PT_CONTINUE:
 	case PT_TO_SCE:
 	case PT_TO_SCX:
 	case PT_SYSCALL:
 	case PT_FOLLOW_FORK:
 	case PT_LWP_EVENTS:
 	case PT_GET_EVENT_MASK:
 	case PT_SET_EVENT_MASK:
 	case PT_DETACH:
 	case PT_GET_SC_ARGS:
 		sx_xlock(&proctree_lock);
 		proctree_locked = 1;
 		break;
 	default:
 		break;
 	}
 
 	if (req == PT_TRACE_ME) {
 		p = td->td_proc;
 		PROC_LOCK(p);
 	} else {
 		if (pid <= PID_MAX) {
 			if ((p = pfind(pid)) == NULL) {
 				if (proctree_locked)
 					sx_xunlock(&proctree_lock);
 				return (ESRCH);
 			}
 		} else {
 			td2 = tdfind(pid, -1);
 			if (td2 == NULL) {
 				if (proctree_locked)
 					sx_xunlock(&proctree_lock);
 				return (ESRCH);
 			}
 			p = td2->td_proc;
 			tid = pid;
 			pid = p->p_pid;
 		}
 	}
 	AUDIT_ARG_PROCESS(p);
 
 	if ((p->p_flag & P_WEXIT) != 0) {
 		error = ESRCH;
 		goto fail;
 	}
 	if ((error = p_cansee(td, p)) != 0)
 		goto fail;
 
 	if ((error = p_candebug(td, p)) != 0)
 		goto fail;
 
 	/*
 	 * System processes can't be debugged.
 	 */
 	if ((p->p_flag & P_SYSTEM) != 0) {
 		error = EINVAL;
 		goto fail;
 	}
 
 	if (tid == 0) {
 		if ((p->p_flag & P_STOPPED_TRACE) != 0) {
 			KASSERT(p->p_xthread != NULL, ("NULL p_xthread"));
 			td2 = p->p_xthread;
 		} else {
 			td2 = FIRST_THREAD_IN_PROC(p);
 		}
 		tid = td2->td_tid;
 	}
 
 #ifdef COMPAT_FREEBSD32
 	/*
 	 * Test if we're a 32 bit client and what the target is.
 	 * Set the wrap controls accordingly.
 	 */
 	if (SV_CURPROC_FLAG(SV_ILP32)) {
 		if (SV_PROC_FLAG(td2->td_proc, SV_ILP32))
 			safe = 1;
 		wrap32 = 1;
 	}
 #endif
 	/*
 	 * Permissions check
 	 */
 	switch (req) {
 	case PT_TRACE_ME:
 		/*
 		 * Always legal, when there is a parent process which
 		 * could trace us.  Otherwise, reject.
 		 */
 		if ((p->p_flag & P_TRACED) != 0) {
 			error = EBUSY;
 			goto fail;
 		}
 		if (p->p_pptr == initproc) {
 			error = EPERM;
 			goto fail;
 		}
 		break;
 
 	case PT_ATTACH:
 		/* Self */
 		if (p == td->td_proc) {
 			error = EINVAL;
 			goto fail;
 		}
 
 		/* Already traced */
 		if (p->p_flag & P_TRACED) {
 			error = EBUSY;
 			goto fail;
 		}
 
 		/* Can't trace an ancestor if you're being traced. */
 		if (curp->p_flag & P_TRACED) {
 			for (pp = curp->p_pptr; pp != NULL; pp = pp->p_pptr) {
 				if (pp == p) {
 					error = EINVAL;
 					goto fail;
 				}
 			}
 		}
 
 
 		/* OK */
 		break;
 
 	case PT_CLEARSTEP:
 		/* Allow thread to clear single step for itself */
 		if (td->td_tid == tid)
 			break;
 
 		/* FALLTHROUGH */
 	default:
 		/* not being traced... */
 		if ((p->p_flag & P_TRACED) == 0) {
 			error = EPERM;
 			goto fail;
 		}
 
 		/* not being traced by YOU */
 		if (p->p_pptr != td->td_proc) {
 			error = EBUSY;
 			goto fail;
 		}
 
 		/* not currently stopped */
 		if ((p->p_flag & P_STOPPED_TRACE) == 0 ||
 		    p->p_suspcount != p->p_numthreads  ||
 		    (p->p_flag & P_WAITED) == 0) {
 			error = EBUSY;
 			goto fail;
 		}
 
 		/* OK */
 		break;
 	}
 
 	/* Keep this process around until we finish this request. */
 	_PHOLD(p);
 
 #ifdef FIX_SSTEP
 	/*
 	 * Single step fixup ala procfs
 	 */
 	FIX_SSTEP(td2);
 #endif
 
 	/*
 	 * Actually do the requests
 	 */
 
 	td->td_retval[0] = 0;
 
 	switch (req) {
 	case PT_TRACE_ME:
 		/* set my trace flag and "owner" so it can read/write me */
 		proc_set_traced(p, false);
 		if (p->p_flag & P_PPWAIT)
 			p->p_flag |= P_PPTRACE;
 		CTR1(KTR_PTRACE, "PT_TRACE_ME: pid %d", p->p_pid);
 		break;
 
 	case PT_ATTACH:
 		/* security check done above */
 		/*
 		 * It would be nice if the tracing relationship was separate
 		 * from the parent relationship but that would require
 		 * another set of links in the proc struct or for "wait"
 		 * to scan the entire proc table.  To make life easier,
 		 * we just re-parent the process we're trying to trace.
 		 * The old parent is remembered so we can put things back
 		 * on a "detach".
 		 */
 		proc_set_traced(p, true);
 		if (p->p_pptr != td->td_proc) {
 			proc_reparent(p, td->td_proc, false);
 		}
 		CTR2(KTR_PTRACE, "PT_ATTACH: pid %d, oppid %d", p->p_pid,
 		    p->p_oppid);
 
 		sx_xunlock(&proctree_lock);
 		proctree_locked = 0;
 		MPASS(p->p_xthread == NULL);
 		MPASS((p->p_flag & P_STOPPED_TRACE) == 0);
 
 		/*
 		 * If already stopped due to a stop signal, clear the
 		 * existing stop before triggering a traced SIGSTOP.
 		 */
 		if ((p->p_flag & P_STOPPED_SIG) != 0) {
 			PROC_SLOCK(p);
 			p->p_flag &= ~(P_STOPPED_SIG | P_WAITED);
 			thread_unsuspend(p);
 			PROC_SUNLOCK(p);
 		}
 
 		kern_psignal(p, SIGSTOP);
 		break;
 
 	case PT_CLEARSTEP:
 		CTR2(KTR_PTRACE, "PT_CLEARSTEP: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		error = ptrace_clear_single_step(td2);
 		break;
 
 	case PT_SETSTEP:
 		CTR2(KTR_PTRACE, "PT_SETSTEP: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		error = ptrace_single_step(td2);
 		break;
 
 	case PT_SUSPEND:
 		CTR2(KTR_PTRACE, "PT_SUSPEND: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		td2->td_dbgflags |= TDB_SUSPEND;
 		thread_lock(td2);
 		td2->td_flags |= TDF_NEEDSUSPCHK;
 		thread_unlock(td2);
 		break;
 
 	case PT_RESUME:
 		CTR2(KTR_PTRACE, "PT_RESUME: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		td2->td_dbgflags &= ~TDB_SUSPEND;
 		break;
 
 	case PT_FOLLOW_FORK:
 		CTR3(KTR_PTRACE, "PT_FOLLOW_FORK: pid %d %s -> %s", p->p_pid,
 		    p->p_ptevents & PTRACE_FORK ? "enabled" : "disabled",
 		    data ? "enabled" : "disabled");
 		if (data)
 			p->p_ptevents |= PTRACE_FORK;
 		else
 			p->p_ptevents &= ~PTRACE_FORK;
 		break;
 
 	case PT_LWP_EVENTS:
 		CTR3(KTR_PTRACE, "PT_LWP_EVENTS: pid %d %s -> %s", p->p_pid,
 		    p->p_ptevents & PTRACE_LWP ? "enabled" : "disabled",
 		    data ? "enabled" : "disabled");
 		if (data)
 			p->p_ptevents |= PTRACE_LWP;
 		else
 			p->p_ptevents &= ~PTRACE_LWP;
 		break;
 
 	case PT_GET_EVENT_MASK:
 		if (data != sizeof(p->p_ptevents)) {
 			error = EINVAL;
 			break;
 		}
 		CTR2(KTR_PTRACE, "PT_GET_EVENT_MASK: pid %d mask %#x", p->p_pid,
 		    p->p_ptevents);
 		*(int *)addr = p->p_ptevents;
 		break;
 
 	case PT_SET_EVENT_MASK:
 		if (data != sizeof(p->p_ptevents)) {
 			error = EINVAL;
 			break;
 		}
 		tmp = *(int *)addr;
 		if ((tmp & ~(PTRACE_EXEC | PTRACE_SCE | PTRACE_SCX |
 		    PTRACE_FORK | PTRACE_LWP | PTRACE_VFORK)) != 0) {
 			error = EINVAL;
 			break;
 		}
 		CTR3(KTR_PTRACE, "PT_SET_EVENT_MASK: pid %d mask %#x -> %#x",
 		    p->p_pid, p->p_ptevents, tmp);
 		p->p_ptevents = tmp;
 		break;
 
 	case PT_GET_SC_ARGS:
 		CTR1(KTR_PTRACE, "PT_GET_SC_ARGS: pid %d", p->p_pid);
 		if ((td2->td_dbgflags & (TDB_SCE | TDB_SCX)) == 0
 #ifdef COMPAT_FREEBSD32
 		    || (wrap32 && !safe)
 #endif
 		    ) {
 			error = EINVAL;
 			break;
 		}
 		bzero(addr, sizeof(td2->td_sa.args));
 #ifdef COMPAT_FREEBSD32
 		if (wrap32)
 			for (num = 0; num < nitems(td2->td_sa.args); num++)
 				((uint32_t *)addr)[num] = (uint32_t)
 				    td2->td_sa.args[num];
 		else
 #endif
 			bcopy(td2->td_sa.args, addr, td2->td_sa.narg *
 			    sizeof(register_t));
 		break;
+
+	case PT_GET_SC_RET:
+		if ((td2->td_dbgflags & (TDB_SCX)) == 0
+#ifdef COMPAT_FREEBSD32
+		    || (wrap32 && !safe)
+#endif
+		    ) {
+			error = EINVAL;
+			break;
+		}
+#ifdef COMPAT_FREEBSD32
+		if (wrap32) {
+			psr = &r.psr;
+			psr32 = addr;
+		} else
+#endif
+		psr = addr;
+		bzero(psr, sizeof(*psr));
+		psr->sr_error = td2->td_errno;
+		if (psr->sr_error == 0) {
+			psr->sr_retval[0] = td2->td_retval[0];
+			psr->sr_retval[1] = td2->td_retval[1];
+		}
+#ifdef COMPAT_FREEBSD32
+		if (wrap32)
+			ptrace_sc_ret_to32(psr, psr32);
+#endif
+		CTR4(KTR_PTRACE,
+		    "PT_GET_SC_RET: pid %d error %d retval %#lx,%#lx",
+		    p->p_pid, psr->sr_error, psr->sr_retval[0],
+		    psr->sr_retval[1]);
+		break;
 		
 	case PT_STEP:
 	case PT_CONTINUE:
 	case PT_TO_SCE:
 	case PT_TO_SCX:
 	case PT_SYSCALL:
 	case PT_DETACH:
 		/* Zero means do not send any signal */
 		if (data < 0 || data > _SIG_MAXSIG) {
 			error = EINVAL;
 			break;
 		}
 
 		switch (req) {
 		case PT_STEP:
 			CTR3(KTR_PTRACE, "PT_STEP: tid %d (pid %d), sig = %d",
 			    td2->td_tid, p->p_pid, data);
 			error = ptrace_single_step(td2);
 			if (error)
 				goto out;
 			break;
 		case PT_CONTINUE:
 		case PT_TO_SCE:
 		case PT_TO_SCX:
 		case PT_SYSCALL:
 			if (addr != (void *)1) {
 				error = ptrace_set_pc(td2,
 				    (u_long)(uintfptr_t)addr);
 				if (error)
 					goto out;
 			}
 			switch (req) {
 			case PT_TO_SCE:
 				p->p_ptevents |= PTRACE_SCE;
 				CTR4(KTR_PTRACE,
 		    "PT_TO_SCE: pid %d, events = %#x, PC = %#lx, sig = %d",
 				    p->p_pid, p->p_ptevents,
 				    (u_long)(uintfptr_t)addr, data);
 				break;
 			case PT_TO_SCX:
 				p->p_ptevents |= PTRACE_SCX;
 				CTR4(KTR_PTRACE,
 		    "PT_TO_SCX: pid %d, events = %#x, PC = %#lx, sig = %d",
 				    p->p_pid, p->p_ptevents,
 				    (u_long)(uintfptr_t)addr, data);
 				break;
 			case PT_SYSCALL:
 				p->p_ptevents |= PTRACE_SYSCALL;
 				CTR4(KTR_PTRACE,
 		    "PT_SYSCALL: pid %d, events = %#x, PC = %#lx, sig = %d",
 				    p->p_pid, p->p_ptevents,
 				    (u_long)(uintfptr_t)addr, data);
 				break;
 			case PT_CONTINUE:
 				CTR3(KTR_PTRACE,
 				    "PT_CONTINUE: pid %d, PC = %#lx, sig = %d",
 				    p->p_pid, (u_long)(uintfptr_t)addr, data);
 				break;
 			}
 			break;
 		case PT_DETACH:
 			/*
 			 * Reset the process parent.
 			 *
 			 * NB: This clears P_TRACED before reparenting
 			 * a detached process back to its original
 			 * parent.  Otherwise the debugee will be set
 			 * as an orphan of the debugger.
 			 */
 			p->p_flag &= ~(P_TRACED | P_WAITED);
 			if (p->p_oppid != p->p_pptr->p_pid) {
 				PROC_LOCK(p->p_pptr);
 				sigqueue_take(p->p_ksi);
 				PROC_UNLOCK(p->p_pptr);
 
 				pp = proc_realparent(p);
 				proc_reparent(p, pp, false);
 				if (pp == initproc)
 					p->p_sigparent = SIGCHLD;
 				CTR3(KTR_PTRACE,
 			    "PT_DETACH: pid %d reparented to pid %d, sig %d",
 				    p->p_pid, pp->p_pid, data);
 			} else
 				CTR2(KTR_PTRACE, "PT_DETACH: pid %d, sig %d",
 				    p->p_pid, data);
 			p->p_ptevents = 0;
 			FOREACH_THREAD_IN_PROC(p, td3) {
 				if ((td3->td_dbgflags & TDB_FSTP) != 0) {
 					sigqueue_delete(&td3->td_sigqueue,
 					    SIGSTOP);
 				}
 				td3->td_dbgflags &= ~(TDB_XSIG | TDB_FSTP |
 				    TDB_SUSPEND);
 			}
 
 			if ((p->p_flag2 & P2_PTRACE_FSTP) != 0) {
 				sigqueue_delete(&p->p_sigqueue, SIGSTOP);
 				p->p_flag2 &= ~P2_PTRACE_FSTP;
 			}
 
 			/* should we send SIGCHLD? */
 			/* childproc_continued(p); */
 			break;
 		}
 
 		sx_xunlock(&proctree_lock);
 		proctree_locked = 0;
 
 	sendsig:
 		MPASS(proctree_locked == 0);
 		
 		/* 
 		 * Clear the pending event for the thread that just
 		 * reported its event (p_xthread).  This may not be
 		 * the thread passed to PT_CONTINUE, PT_STEP, etc. if
 		 * the debugger is resuming a different thread.
 		 *
 		 * Deliver any pending signal via the reporting thread.
 		 */
 		MPASS(p->p_xthread != NULL);
 		p->p_xthread->td_dbgflags &= ~TDB_XSIG;
 		p->p_xthread->td_xsig = data;
 		p->p_xthread = NULL;
 		p->p_xsig = data;
 
 		/*
 		 * P_WKILLED is insurance that a PT_KILL/SIGKILL
 		 * always works immediately, even if another thread is
 		 * unsuspended first and attempts to handle a
 		 * different signal or if the POSIX.1b style signal
 		 * queue cannot accommodate any new signals.
 		 */
 		if (data == SIGKILL)
 			proc_wkilled(p);
 
 		/*
 		 * Unsuspend all threads.  To leave a thread
 		 * suspended, use PT_SUSPEND to suspend it before
 		 * continuing the process.
 		 */
 		PROC_SLOCK(p);
 		p->p_flag &= ~(P_STOPPED_TRACE | P_STOPPED_SIG | P_WAITED);
 		thread_unsuspend(p);
 		PROC_SUNLOCK(p);
 		break;
 
 	case PT_WRITE_I:
 	case PT_WRITE_D:
 		td2->td_dbgflags |= TDB_USERWR;
 		PROC_UNLOCK(p);
 		error = 0;
 		if (proc_writemem(td, p, (off_t)(uintptr_t)addr, &data,
 		    sizeof(int)) != sizeof(int))
 			error = ENOMEM;
 		else
 			CTR3(KTR_PTRACE, "PT_WRITE: pid %d: %p <= %#x",
 			    p->p_pid, addr, data);
 		PROC_LOCK(p);
 		break;
 
 	case PT_READ_I:
 	case PT_READ_D:
 		PROC_UNLOCK(p);
 		error = tmp = 0;
 		if (proc_readmem(td, p, (off_t)(uintptr_t)addr, &tmp,
 		    sizeof(int)) != sizeof(int))
 			error = ENOMEM;
 		else
 			CTR3(KTR_PTRACE, "PT_READ: pid %d: %p >= %#x",
 			    p->p_pid, addr, tmp);
 		td->td_retval[0] = tmp;
 		PROC_LOCK(p);
 		break;
 
 	case PT_IO:
 #ifdef COMPAT_FREEBSD32
 		if (wrap32) {
 			piod32 = addr;
 			iov.iov_base = (void *)(uintptr_t)piod32->piod_addr;
 			iov.iov_len = piod32->piod_len;
 			uio.uio_offset = (off_t)(uintptr_t)piod32->piod_offs;
 			uio.uio_resid = piod32->piod_len;
 		} else
 #endif
 		{
 			piod = addr;
 			iov.iov_base = piod->piod_addr;
 			iov.iov_len = piod->piod_len;
 			uio.uio_offset = (off_t)(uintptr_t)piod->piod_offs;
 			uio.uio_resid = piod->piod_len;
 		}
 		uio.uio_iov = &iov;
 		uio.uio_iovcnt = 1;
 		uio.uio_segflg = UIO_USERSPACE;
 		uio.uio_td = td;
 #ifdef COMPAT_FREEBSD32
 		tmp = wrap32 ? piod32->piod_op : piod->piod_op;
 #else
 		tmp = piod->piod_op;
 #endif
 		switch (tmp) {
 		case PIOD_READ_D:
 		case PIOD_READ_I:
 			CTR3(KTR_PTRACE, "PT_IO: pid %d: READ (%p, %#x)",
 			    p->p_pid, (uintptr_t)uio.uio_offset, uio.uio_resid);
 			uio.uio_rw = UIO_READ;
 			break;
 		case PIOD_WRITE_D:
 		case PIOD_WRITE_I:
 			CTR3(KTR_PTRACE, "PT_IO: pid %d: WRITE (%p, %#x)",
 			    p->p_pid, (uintptr_t)uio.uio_offset, uio.uio_resid);
 			td2->td_dbgflags |= TDB_USERWR;
 			uio.uio_rw = UIO_WRITE;
 			break;
 		default:
 			error = EINVAL;
 			goto out;
 		}
 		PROC_UNLOCK(p);
 		error = proc_rwmem(p, &uio);
 #ifdef COMPAT_FREEBSD32
 		if (wrap32)
 			piod32->piod_len -= uio.uio_resid;
 		else
 #endif
 			piod->piod_len -= uio.uio_resid;
 		PROC_LOCK(p);
 		break;
 
 	case PT_KILL:
 		CTR1(KTR_PTRACE, "PT_KILL: pid %d", p->p_pid);
 		data = SIGKILL;
 		goto sendsig;	/* in PT_CONTINUE above */
 
 	case PT_SETREGS:
 		CTR2(KTR_PTRACE, "PT_SETREGS: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		td2->td_dbgflags |= TDB_USERWR;
 		error = PROC_WRITE(regs, td2, addr);
 		break;
 
 	case PT_GETREGS:
 		CTR2(KTR_PTRACE, "PT_GETREGS: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		error = PROC_READ(regs, td2, addr);
 		break;
 
 	case PT_SETFPREGS:
 		CTR2(KTR_PTRACE, "PT_SETFPREGS: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		td2->td_dbgflags |= TDB_USERWR;
 		error = PROC_WRITE(fpregs, td2, addr);
 		break;
 
 	case PT_GETFPREGS:
 		CTR2(KTR_PTRACE, "PT_GETFPREGS: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		error = PROC_READ(fpregs, td2, addr);
 		break;
 
 	case PT_SETDBREGS:
 		CTR2(KTR_PTRACE, "PT_SETDBREGS: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		td2->td_dbgflags |= TDB_USERWR;
 		error = PROC_WRITE(dbregs, td2, addr);
 		break;
 
 	case PT_GETDBREGS:
 		CTR2(KTR_PTRACE, "PT_GETDBREGS: tid %d (pid %d)", td2->td_tid,
 		    p->p_pid);
 		error = PROC_READ(dbregs, td2, addr);
 		break;
 
 	case PT_LWPINFO:
 		if (data <= 0 ||
 #ifdef COMPAT_FREEBSD32
 		    (!wrap32 && data > sizeof(*pl)) ||
 		    (wrap32 && data > sizeof(*pl32))) {
 #else
 		    data > sizeof(*pl)) {
 #endif
 			error = EINVAL;
 			break;
 		}
 #ifdef COMPAT_FREEBSD32
 		if (wrap32) {
-			pl = &plr;
+			pl = &r.pl;
 			pl32 = addr;
 		} else
 #endif
 		pl = addr;
 		bzero(pl, sizeof(*pl));
 		pl->pl_lwpid = td2->td_tid;
 		pl->pl_event = PL_EVENT_NONE;
 		pl->pl_flags = 0;
 		if (td2->td_dbgflags & TDB_XSIG) {
 			pl->pl_event = PL_EVENT_SIGNAL;
 			if (td2->td_si.si_signo != 0 &&
 #ifdef COMPAT_FREEBSD32
 			    ((!wrap32 && data >= offsetof(struct ptrace_lwpinfo,
 			    pl_siginfo) + sizeof(pl->pl_siginfo)) ||
 			    (wrap32 && data >= offsetof(struct ptrace_lwpinfo32,
 			    pl_siginfo) + sizeof(struct siginfo32)))
 #else
 			    data >= offsetof(struct ptrace_lwpinfo, pl_siginfo)
 			    + sizeof(pl->pl_siginfo)
 #endif
 			){
 				pl->pl_flags |= PL_FLAG_SI;
 				pl->pl_siginfo = td2->td_si;
 			}
 		}
 		if (td2->td_dbgflags & TDB_SCE)
 			pl->pl_flags |= PL_FLAG_SCE;
 		else if (td2->td_dbgflags & TDB_SCX)
 			pl->pl_flags |= PL_FLAG_SCX;
 		if (td2->td_dbgflags & TDB_EXEC)
 			pl->pl_flags |= PL_FLAG_EXEC;
 		if (td2->td_dbgflags & TDB_FORK) {
 			pl->pl_flags |= PL_FLAG_FORKED;
 			pl->pl_child_pid = td2->td_dbg_forked;
 			if (td2->td_dbgflags & TDB_VFORK)
 				pl->pl_flags |= PL_FLAG_VFORKED;
 		} else if ((td2->td_dbgflags & (TDB_SCX | TDB_VFORK)) ==
 		    TDB_VFORK)
 			pl->pl_flags |= PL_FLAG_VFORK_DONE;
 		if (td2->td_dbgflags & TDB_CHILD)
 			pl->pl_flags |= PL_FLAG_CHILD;
 		if (td2->td_dbgflags & TDB_BORN)
 			pl->pl_flags |= PL_FLAG_BORN;
 		if (td2->td_dbgflags & TDB_EXIT)
 			pl->pl_flags |= PL_FLAG_EXITED;
 		pl->pl_sigmask = td2->td_sigmask;
 		pl->pl_siglist = td2->td_siglist;
 		strcpy(pl->pl_tdname, td2->td_name);
 		if ((td2->td_dbgflags & (TDB_SCE | TDB_SCX)) != 0) {
 			pl->pl_syscall_code = td2->td_sa.code;
 			pl->pl_syscall_narg = td2->td_sa.narg;
 		} else {
 			pl->pl_syscall_code = 0;
 			pl->pl_syscall_narg = 0;
 		}
 #ifdef COMPAT_FREEBSD32
 		if (wrap32)
 			ptrace_lwpinfo_to32(pl, pl32);
 #endif
 		CTR6(KTR_PTRACE,
     "PT_LWPINFO: tid %d (pid %d) event %d flags %#x child pid %d syscall %d",
 		    td2->td_tid, p->p_pid, pl->pl_event, pl->pl_flags,
 		    pl->pl_child_pid, pl->pl_syscall_code);
 		break;
 
 	case PT_GETNUMLWPS:
 		CTR2(KTR_PTRACE, "PT_GETNUMLWPS: pid %d: %d threads", p->p_pid,
 		    p->p_numthreads);
 		td->td_retval[0] = p->p_numthreads;
 		break;
 
 	case PT_GETLWPLIST:
 		CTR3(KTR_PTRACE, "PT_GETLWPLIST: pid %d: data %d, actual %d",
 		    p->p_pid, data, p->p_numthreads);
 		if (data <= 0) {
 			error = EINVAL;
 			break;
 		}
 		num = imin(p->p_numthreads, data);
 		PROC_UNLOCK(p);
 		buf = malloc(num * sizeof(lwpid_t), M_TEMP, M_WAITOK);
 		tmp = 0;
 		PROC_LOCK(p);
 		FOREACH_THREAD_IN_PROC(p, td2) {
 			if (tmp >= num)
 				break;
 			buf[tmp++] = td2->td_tid;
 		}
 		PROC_UNLOCK(p);
 		error = copyout(buf, addr, tmp * sizeof(lwpid_t));
 		free(buf, M_TEMP);
 		if (!error)
 			td->td_retval[0] = tmp;
 		PROC_LOCK(p);
 		break;
 
 	case PT_VM_TIMESTAMP:
 		CTR2(KTR_PTRACE, "PT_VM_TIMESTAMP: pid %d: timestamp %d",
 		    p->p_pid, p->p_vmspace->vm_map.timestamp);
 		td->td_retval[0] = p->p_vmspace->vm_map.timestamp;
 		break;
 
 	case PT_VM_ENTRY:
 		PROC_UNLOCK(p);
 #ifdef COMPAT_FREEBSD32
 		if (wrap32)
 			error = ptrace_vm_entry32(td, p, addr);
 		else
 #endif
 		error = ptrace_vm_entry(td, p, addr);
 		PROC_LOCK(p);
 		break;
 
 	default:
 #ifdef __HAVE_PTRACE_MACHDEP
 		if (req >= PT_FIRSTMACH) {
 			PROC_UNLOCK(p);
 			error = cpu_ptrace(td2, req, addr, data);
 			PROC_LOCK(p);
 		} else
 #endif
 			/* Unknown request. */
 			error = EINVAL;
 		break;
 	}
 
 out:
 	/* Drop our hold on this process now that the request has completed. */
 	_PRELE(p);
 fail:
 	PROC_UNLOCK(p);
 	if (proctree_locked)
 		sx_xunlock(&proctree_lock);
 	return (error);
 }
 #undef PROC_READ
 #undef PROC_WRITE
 
 /*
  * Stop a process because of a debugging event;
  * stay stopped until p->p_step is cleared
  * (cleared by PIOCCONT in procfs).
  */
 void
 stopevent(struct proc *p, unsigned int event, unsigned int val)
 {
 
 	PROC_LOCK_ASSERT(p, MA_OWNED);
 	p->p_step = 1;
 	CTR3(KTR_PTRACE, "stopevent: pid %d event %u val %u", p->p_pid, event,
 	    val);
 	do {
 		if (event != S_EXIT)
 			p->p_xsig = val;
 		p->p_xthread = NULL;
 		p->p_stype = event;	/* Which event caused the stop? */
 		wakeup(&p->p_stype);	/* Wake up any PIOCWAIT'ing procs */
 		msleep(&p->p_step, &p->p_mtx, PWAIT, "stopevent", 0);
 	} while (p->p_step);
 }
Index: head/sys/sys/ptrace.h
===================================================================
--- head/sys/sys/ptrace.h	(revision 350016)
+++ head/sys/sys/ptrace.h	(revision 350017)
@@ -1,225 +1,232 @@
 /*-
  * SPDX-License-Identifier: BSD-3-Clause
  *
  * Copyright (c) 1984, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  *	@(#)ptrace.h	8.2 (Berkeley) 1/4/94
  * $FreeBSD$
  */
 
 #ifndef	_SYS_PTRACE_H_
 #define	_SYS_PTRACE_H_
 
 #include <sys/signal.h>
 #include <sys/param.h>
 #include <machine/reg.h>
 
 #define	PT_TRACE_ME	0	/* child declares it's being traced */
 #define	PT_READ_I	1	/* read word in child's I space */
 #define	PT_READ_D	2	/* read word in child's D space */
 /* was	PT_READ_U	3	 * read word in child's user structure */
 #define	PT_WRITE_I	4	/* write word in child's I space */
 #define	PT_WRITE_D	5	/* write word in child's D space */
 /* was	PT_WRITE_U	6	 * write word in child's user structure */
 #define	PT_CONTINUE	7	/* continue the child */
 #define	PT_KILL		8	/* kill the child process */
 #define	PT_STEP		9	/* single step the child */
 
 #define	PT_ATTACH	10	/* trace some running process */
 #define	PT_DETACH	11	/* stop tracing a process */
 #define PT_IO		12	/* do I/O to/from stopped process. */
 #define	PT_LWPINFO	13	/* Info about the LWP that stopped. */
 #define PT_GETNUMLWPS	14	/* get total number of threads */
 #define PT_GETLWPLIST	15	/* get thread list */
 #define PT_CLEARSTEP	16	/* turn off single step */
 #define PT_SETSTEP	17	/* turn on single step */
 #define PT_SUSPEND	18	/* suspend a thread */
 #define PT_RESUME	19	/* resume a thread */
 
 #define	PT_TO_SCE	20
 #define	PT_TO_SCX	21
 #define	PT_SYSCALL	22
 
 #define	PT_FOLLOW_FORK	23
 #define	PT_LWP_EVENTS	24	/* report LWP birth and exit */
 
 #define	PT_GET_EVENT_MASK 25	/* get mask of optional events */
 #define	PT_SET_EVENT_MASK 26	/* set mask of optional events */
 
 #define	PT_GET_SC_ARGS	27	/* fetch syscall args */
+#define	PT_GET_SC_RET	28	/* fetch syscall results */
 
 #define PT_GETREGS      33	/* get general-purpose registers */
 #define PT_SETREGS      34	/* set general-purpose registers */
 #define PT_GETFPREGS    35	/* get floating-point registers */
 #define PT_SETFPREGS    36	/* set floating-point registers */
 #define PT_GETDBREGS    37	/* get debugging registers */
 #define PT_SETDBREGS    38	/* set debugging registers */
 
 #define	PT_VM_TIMESTAMP	40	/* Get VM version (timestamp) */
 #define	PT_VM_ENTRY	41	/* Get VM map (entry) */
 
 #define PT_FIRSTMACH    64	/* for machine-specific requests */
 #include <machine/ptrace.h>	/* machine-specific requests, if any */
 
 /* Events used with PT_GET_EVENT_MASK and PT_SET_EVENT_MASK */
 #define	PTRACE_EXEC	0x0001
 #define	PTRACE_SCE	0x0002
 #define	PTRACE_SCX	0x0004
 #define	PTRACE_SYSCALL	(PTRACE_SCE | PTRACE_SCX)
 #define	PTRACE_FORK	0x0008
 #define	PTRACE_LWP	0x0010
 #define	PTRACE_VFORK	0x0020
 
 #define	PTRACE_DEFAULT	(PTRACE_EXEC)
 
 struct ptrace_io_desc {
 	int	piod_op;	/* I/O operation */
 	void	*piod_offs;	/* child offset */
 	void	*piod_addr;	/* parent offset */
 	size_t	piod_len;	/* request length */
 };
 
 /*
  * Operations in piod_op.
  */
 #define PIOD_READ_D	1	/* Read from D space */
 #define PIOD_WRITE_D	2	/* Write to D space */
 #define PIOD_READ_I	3	/* Read from I space */
 #define PIOD_WRITE_I	4	/* Write to I space */
 
 /* Argument structure for PT_LWPINFO. */
 struct ptrace_lwpinfo {
 	lwpid_t	pl_lwpid;	/* LWP described. */
 	int	pl_event;	/* Event that stopped the LWP. */
 #define	PL_EVENT_NONE	0
 #define	PL_EVENT_SIGNAL	1
 	int	pl_flags;	/* LWP flags. */
 #define	PL_FLAG_SA	0x01	/* M:N thread */
 #define	PL_FLAG_BOUND	0x02	/* M:N bound thread */
 #define	PL_FLAG_SCE	0x04	/* syscall enter point */
 #define	PL_FLAG_SCX	0x08	/* syscall leave point */
 #define	PL_FLAG_EXEC	0x10	/* exec(2) succeeded */
 #define	PL_FLAG_SI	0x20	/* siginfo is valid */
 #define	PL_FLAG_FORKED	0x40	/* new child */
 #define	PL_FLAG_CHILD	0x80	/* I am from child */
 #define	PL_FLAG_BORN	0x100	/* new LWP */
 #define	PL_FLAG_EXITED	0x200	/* exiting LWP */
 #define	PL_FLAG_VFORKED	0x400	/* new child via vfork */
 #define	PL_FLAG_VFORK_DONE 0x800 /* vfork parent has resumed */
 	sigset_t	pl_sigmask;	/* LWP signal mask */
 	sigset_t	pl_siglist;	/* LWP pending signal */
 	struct __siginfo pl_siginfo;	/* siginfo for signal */
 	char		pl_tdname[MAXCOMLEN + 1]; /* LWP name */
 	pid_t		pl_child_pid;	/* New child pid */
 	u_int		pl_syscall_code;
 	u_int		pl_syscall_narg;
 };
 
 #if defined(_WANT_LWPINFO32) || (defined(_KERNEL) && defined(__LP64__))
 struct ptrace_lwpinfo32 {
 	lwpid_t	pl_lwpid;	/* LWP described. */
 	int	pl_event;	/* Event that stopped the LWP. */
 	int	pl_flags;	/* LWP flags. */
 	sigset_t	pl_sigmask;	/* LWP signal mask */
 	sigset_t	pl_siglist;	/* LWP pending signal */
 	struct siginfo32 pl_siginfo;	/* siginfo for signal */
 	char		pl_tdname[MAXCOMLEN + 1]; /* LWP name. */
 	pid_t		pl_child_pid;	/* New child pid */
 	u_int		pl_syscall_code;
 	u_int		pl_syscall_narg;
 };
 #endif
+
+/* Argument structure for PT_GET_SC_RET. */
+struct ptrace_sc_ret {
+	register_t	sr_retval[2];	/* Only valid if sr_error == 0. */
+	int		sr_error;
+};
 
 /* Argument structure for PT_VM_ENTRY. */
 struct ptrace_vm_entry {
 	int		pve_entry;	/* Entry number used for iteration. */
 	int		pve_timestamp;	/* Generation number of VM map. */
 	u_long		pve_start;	/* Start VA of range. */
 	u_long		pve_end;	/* End VA of range (incl). */
 	u_long		pve_offset;	/* Offset in backing object. */
 	u_int		pve_prot;	/* Protection of memory range. */
 	u_int		pve_pathlen;	/* Size of path. */
 	long		pve_fileid;	/* File ID. */
 	uint32_t	pve_fsid;	/* File system ID. */
 	char		*pve_path;	/* Path name of object. */
 };
 
 #ifdef _KERNEL
 
 int	ptrace_set_pc(struct thread *_td, unsigned long _addr);
 int	ptrace_single_step(struct thread *_td);
 int	ptrace_clear_single_step(struct thread *_td);
 
 #ifdef __HAVE_PTRACE_MACHDEP
 int	cpu_ptrace(struct thread *_td, int _req, void *_addr, int _data);
 #endif
 
 /*
  * These are prototypes for functions that implement some of the
  * debugging functionality exported by procfs / linprocfs and by the
  * ptrace(2) syscall.  They used to be part of procfs, but they don't
  * really belong there.
  */
 struct reg;
 struct fpreg;
 struct dbreg;
 struct uio;
 int	proc_read_regs(struct thread *_td, struct reg *_reg);
 int	proc_write_regs(struct thread *_td, struct reg *_reg);
 int	proc_read_fpregs(struct thread *_td, struct fpreg *_fpreg);
 int	proc_write_fpregs(struct thread *_td, struct fpreg *_fpreg);
 int	proc_read_dbregs(struct thread *_td, struct dbreg *_dbreg);
 int	proc_write_dbregs(struct thread *_td, struct dbreg *_dbreg);
 int	proc_sstep(struct thread *_td);
 int	proc_rwmem(struct proc *_p, struct uio *_uio);
 ssize_t	proc_readmem(struct thread *_td, struct proc *_p, vm_offset_t _va,
 	    void *_buf, size_t _len);
 ssize_t	proc_writemem(struct thread *_td, struct proc *_p, vm_offset_t _va,
 	    void *_buf, size_t _len);
 #ifdef COMPAT_FREEBSD32
 struct reg32;
 struct fpreg32;
 struct dbreg32;
 int	proc_read_regs32(struct thread *_td, struct reg32 *_reg32);
 int	proc_write_regs32(struct thread *_td, struct reg32 *_reg32);
 int	proc_read_fpregs32(struct thread *_td, struct fpreg32 *_fpreg32);
 int	proc_write_fpregs32(struct thread *_td, struct fpreg32 *_fpreg32);
 int	proc_read_dbregs32(struct thread *_td, struct dbreg32 *_dbreg32);
 int	proc_write_dbregs32(struct thread *_td, struct dbreg32 *_dbreg32);
 #endif
 #else /* !_KERNEL */
 
 #include <sys/cdefs.h>
 
 __BEGIN_DECLS
 int	ptrace(int _request, pid_t _pid, caddr_t _addr, int _data);
 __END_DECLS
 
 #endif /* !_KERNEL */
 
 #endif	/* !_SYS_PTRACE_H_ */
Index: head/tests/sys/kern/ptrace_test.c
===================================================================
--- head/tests/sys/kern/ptrace_test.c	(revision 350016)
+++ head/tests/sys/kern/ptrace_test.c	(revision 350017)
@@ -1,4051 +1,4127 @@
 /*-
  * Copyright (c) 2015 John Baldwin <jhb@FreeBSD.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
 #include <sys/types.h>
 #include <sys/cpuset.h>
 #include <sys/event.h>
 #include <sys/file.h>
 #include <sys/time.h>
 #include <sys/procctl.h>
 #include <sys/ptrace.h>
 #include <sys/queue.h>
 #include <sys/runq.h>
 #include <sys/syscall.h>
 #include <sys/sysctl.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 #include <errno.h>
 #include <machine/cpufunc.h>
 #include <pthread.h>
 #include <sched.h>
 #include <semaphore.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <atf-c.h>
 
 /*
  * Architectures with a user-visible breakpoint().
  */
 #if defined(__aarch64__) || defined(__amd64__) || defined(__arm__) ||	\
     defined(__i386__) || defined(__mips__) || defined(__riscv) ||	\
     defined(__sparc64__)
 #define	HAVE_BREAKPOINT
 #endif
 
 /*
  * Adjust PC to skip over a breakpoint when stopped for a breakpoint trap.
  */
 #ifdef HAVE_BREAKPOINT
 #if defined(__aarch64__)
 #define	SKIP_BREAK(reg)	((reg)->elr += 4)
 #elif defined(__amd64__) || defined(__i386__)
 #define	SKIP_BREAK(reg)
 #elif defined(__arm__)
 #define	SKIP_BREAK(reg)	((reg)->r_pc += 4)
 #elif defined(__mips__)
 #define	SKIP_BREAK(reg)	((reg)->r_regs[PC] += 4)
 #elif defined(__riscv)
 #define	SKIP_BREAK(reg)	((reg)->sepc += 4)
 #elif defined(__sparc64__)
 #define	SKIP_BREAK(reg)	do {						\
 	(reg)->r_tpc = (reg)->r_tnpc + 4;				\
 	(reg)->r_tnpc += 8;						\
 } while (0)
 #endif
 #endif
 
 /*
  * A variant of ATF_REQUIRE that is suitable for use in child
  * processes.  This only works if the parent process is tripped up by
  * the early exit and fails some requirement itself.
  */
 #define	CHILD_REQUIRE(exp) do {						\
 		if (!(exp))						\
 			child_fail_require(__FILE__, __LINE__,		\
 			    #exp " not met");				\
 	} while (0)
 
 static __dead2 void
 child_fail_require(const char *file, int line, const char *str)
 {
 	char buf[128];
 
 	snprintf(buf, sizeof(buf), "%s:%d: %s\n", file, line, str);
 	write(2, buf, strlen(buf));
 	_exit(32);
 }
 
 static void
 trace_me(void)
 {
 
 	/* Attach the parent process as a tracer of this process. */
 	CHILD_REQUIRE(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
 
 	/* Trigger a stop. */
 	raise(SIGSTOP);
 }
 
 static void
 attach_child(pid_t pid)
 {
 	pid_t wpid;
 	int status;
 
 	ATF_REQUIRE(ptrace(PT_ATTACH, pid, NULL, 0) == 0);
 
 	wpid = waitpid(pid, &status, 0);
 	ATF_REQUIRE(wpid == pid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 }
 
 static void
 wait_for_zombie(pid_t pid)
 {
 
 	/*
 	 * Wait for a process to exit.  This is kind of gross, but
 	 * there is not a better way.
 	 *
 	 * Prior to r325719, the kern.proc.pid.<pid> sysctl failed
 	 * with ESRCH.  After that change, a valid struct kinfo_proc
 	 * is returned for zombies with ki_stat set to SZOMB.
 	 */
 	for (;;) {
 		struct kinfo_proc kp;
 		size_t len;
 		int mib[4];
 
 		mib[0] = CTL_KERN;
 		mib[1] = KERN_PROC;
 		mib[2] = KERN_PROC_PID;
 		mib[3] = pid;
 		len = sizeof(kp);
 		if (sysctl(mib, nitems(mib), &kp, &len, NULL, 0) == -1) {
 			ATF_REQUIRE(errno == ESRCH);
 			break;
 		}
 		if (kp.ki_stat == SZOMB)
 			break;
 		usleep(5000);
 	}
 }
 
 /*
  * Verify that a parent debugger process "sees" the exit of a debugged
  * process exactly once when attached via PT_TRACE_ME.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_trace_me);
 ATF_TC_BODY(ptrace__parent_wait_after_trace_me, tc)
 {
 	pid_t child, wpid;
 	int status;
 
 	ATF_REQUIRE((child = fork()) != -1);
 	if (child == 0) {
 		/* Child process. */
 		trace_me();
 
 		_exit(1);
 	}
 
 	/* Parent process. */
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(child, &status, 0);
 	ATF_REQUIRE(wpid == child);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1);
 
 	/* The second wait() should report the exit status. */
 	wpid = waitpid(child, &status, 0);
 	ATF_REQUIRE(wpid == child);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	/* The child should no longer exist. */
 	wpid = waitpid(child, &status, 0);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a parent debugger process "sees" the exit of a debugged
  * process exactly once when attached via PT_ATTACH.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__parent_wait_after_attach);
 ATF_TC_BODY(ptrace__parent_wait_after_attach, tc)
 {
 	pid_t child, wpid;
 	int cpipe[2], status;
 	char c;
 
 	ATF_REQUIRE(pipe(cpipe) == 0);
 	ATF_REQUIRE((child = fork()) != -1);
 	if (child == 0) {
 		/* Child process. */
 		close(cpipe[0]);
 
 		/* Wait for the parent to attach. */
 		CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == 0);
 
 		_exit(1);
 	}
 	close(cpipe[1]);
 
 	/* Parent process. */
 
 	/* Attach to the child process. */
 	attach_child(child);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1);
 
 	/* Signal the child to exit. */
 	close(cpipe[0]);
 
 	/* The second wait() should report the exit status. */
 	wpid = waitpid(child, &status, 0);
 	ATF_REQUIRE(wpid == child);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	/* The child should no longer exist. */
 	wpid = waitpid(child, &status, 0);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a parent process "sees" the exit of a debugged process only
  * after the debugger has seen it.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_child_debugger);
 ATF_TC_BODY(ptrace__parent_sees_exit_after_child_debugger, tc)
 {
 	pid_t child, debugger, wpid;
 	int cpipe[2], dpipe[2], status;
 	char c;
 
 	ATF_REQUIRE(pipe(cpipe) == 0);
 	ATF_REQUIRE((child = fork()) != -1);
 
 	if (child == 0) {
 		/* Child process. */
 		close(cpipe[0]);
 
 		/* Wait for parent to be ready. */
 		CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c));
 
 		_exit(1);
 	}
 	close(cpipe[1]);
 
 	ATF_REQUIRE(pipe(dpipe) == 0);
 	ATF_REQUIRE((debugger = fork()) != -1);
 
 	if (debugger == 0) {
 		/* Debugger process. */
 		close(dpipe[0]);
 
 		CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1);
 
 		wpid = waitpid(child, &status, 0);
 		CHILD_REQUIRE(wpid == child);
 		CHILD_REQUIRE(WIFSTOPPED(status));
 		CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 		CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1);
 
 		/* Signal parent that debugger is attached. */
 		CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c));
 
 		/* Wait for parent's failed wait. */
 		CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == 0);
 
 		wpid = waitpid(child, &status, 0);
 		CHILD_REQUIRE(wpid == child);
 		CHILD_REQUIRE(WIFEXITED(status));
 		CHILD_REQUIRE(WEXITSTATUS(status) == 1);
 
 		_exit(0);
 	}
 	close(dpipe[1]);
 
 	/* Parent process. */
 
 	/* Wait for the debugger to attach to the child. */
 	ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c));
 
 	/* Release the child. */
 	ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c));
 	ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0);
 	close(cpipe[0]);
 
 	wait_for_zombie(child);
 
 	/*
 	 * This wait should return a pid of 0 to indicate no status to
 	 * report.  The parent should see the child as non-exited
 	 * until the debugger sees the exit.
 	 */
 	wpid = waitpid(child, &status, WNOHANG);
 	ATF_REQUIRE(wpid == 0);
 
 	/* Signal the debugger to wait for the child. */
 	close(dpipe[0]);
 
 	/* Wait for the debugger. */
 	wpid = waitpid(debugger, &status, 0);
 	ATF_REQUIRE(wpid == debugger);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	/* The child process should now be ready. */
 	wpid = waitpid(child, &status, WNOHANG);
 	ATF_REQUIRE(wpid == child);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 }
 
 /*
  * Verify that a parent process "sees" the exit of a debugged process
  * only after a non-direct-child debugger has seen it.  In particular,
  * various wait() calls in the parent must avoid failing with ESRCH by
  * checking the parent's orphan list for the debugee.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__parent_sees_exit_after_unrelated_debugger);
 ATF_TC_BODY(ptrace__parent_sees_exit_after_unrelated_debugger, tc)
 {
 	pid_t child, debugger, fpid, wpid;
 	int cpipe[2], dpipe[2], status;
 	char c;
 
 	ATF_REQUIRE(pipe(cpipe) == 0);
 	ATF_REQUIRE((child = fork()) != -1);
 
 	if (child == 0) {
 		/* Child process. */
 		close(cpipe[0]);
 
 		/* Wait for parent to be ready. */
 		CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c));
 
 		_exit(1);
 	}
 	close(cpipe[1]);
 
 	ATF_REQUIRE(pipe(dpipe) == 0);
 	ATF_REQUIRE((debugger = fork()) != -1);
 
 	if (debugger == 0) {
 		/* Debugger parent. */
 
 		/*
 		 * Fork again and drop the debugger parent so that the
 		 * debugger is not a child of the main parent.
 		 */
 		CHILD_REQUIRE((fpid = fork()) != -1);
 		if (fpid != 0)
 			_exit(2);
 
 		/* Debugger process. */
 		close(dpipe[0]);
 
 		CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1);
 
 		wpid = waitpid(child, &status, 0);
 		CHILD_REQUIRE(wpid == child);
 		CHILD_REQUIRE(WIFSTOPPED(status));
 		CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 		CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1);
 
 		/* Signal parent that debugger is attached. */
 		CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c));
 
 		/* Wait for parent's failed wait. */
 		CHILD_REQUIRE(read(dpipe[1], &c, sizeof(c)) == sizeof(c));
 
 		wpid = waitpid(child, &status, 0);
 		CHILD_REQUIRE(wpid == child);
 		CHILD_REQUIRE(WIFEXITED(status));
 		CHILD_REQUIRE(WEXITSTATUS(status) == 1);
 
 		_exit(0);
 	}
 	close(dpipe[1]);
 
 	/* Parent process. */
 
 	/* Wait for the debugger parent process to exit. */
 	wpid = waitpid(debugger, &status, 0);
 	ATF_REQUIRE(wpid == debugger);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	/* A WNOHANG wait here should see the non-exited child. */
 	wpid = waitpid(child, &status, WNOHANG);
 	ATF_REQUIRE(wpid == 0);
 
 	/* Wait for the debugger to attach to the child. */
 	ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c));
 
 	/* Release the child. */
 	ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c));
 	ATF_REQUIRE(read(cpipe[0], &c, sizeof(c)) == 0);
 	close(cpipe[0]);
 
 	wait_for_zombie(child);
 
 	/*
 	 * This wait should return a pid of 0 to indicate no status to
 	 * report.  The parent should see the child as non-exited
 	 * until the debugger sees the exit.
 	 */
 	wpid = waitpid(child, &status, WNOHANG);
 	ATF_REQUIRE(wpid == 0);
 
 	/* Signal the debugger to wait for the child. */
 	ATF_REQUIRE(write(dpipe[0], &c, sizeof(c)) == sizeof(c));
 
 	/* Wait for the debugger. */
 	ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == 0);
 	close(dpipe[0]);
 
 	/* The child process should now be ready. */
 	wpid = waitpid(child, &status, WNOHANG);
 	ATF_REQUIRE(wpid == child);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 }
 
 /*
  * Make sure that we can collect the exit status of an orphaned process.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__parent_exits_before_child);
 ATF_TC_BODY(ptrace__parent_exits_before_child, tc)
 {
 	ssize_t n;
 	int cpipe1[2], cpipe2[2], gcpipe[2], status;
 	pid_t child, gchild;
 
 	ATF_REQUIRE(pipe(cpipe1) == 0);
 	ATF_REQUIRE(pipe(cpipe2) == 0);
 	ATF_REQUIRE(pipe(gcpipe) == 0);
 
 	ATF_REQUIRE(procctl(P_PID, getpid(), PROC_REAP_ACQUIRE, NULL) == 0);
 
 	ATF_REQUIRE((child = fork()) != -1);
 	if (child == 0) {
 		CHILD_REQUIRE((gchild = fork()) != -1);
 		if (gchild == 0) {
 			status = 1;
 			do {
 				n = read(gcpipe[0], &status, sizeof(status));
 			} while (n == -1 && errno == EINTR);
 			_exit(status);
 		}
 
 		CHILD_REQUIRE(write(cpipe1[1], &gchild, sizeof(gchild)) ==
 		    sizeof(gchild));
 		CHILD_REQUIRE(read(cpipe2[0], &status, sizeof(status)) ==
 		    sizeof(status));
 		_exit(status);
 	}
 
 	ATF_REQUIRE(read(cpipe1[0], &gchild, sizeof(gchild)) == sizeof(gchild));
 
 	ATF_REQUIRE(ptrace(PT_ATTACH, gchild, NULL, 0) == 0);
 
 	status = 0;
 	ATF_REQUIRE(write(cpipe2[1], &status, sizeof(status)) ==
 	    sizeof(status));
 	ATF_REQUIRE(waitpid(child, &status, 0) == child);
 	ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
 
 	status = 0;
 	ATF_REQUIRE(write(gcpipe[1], &status, sizeof(status)) ==
 	    sizeof(status));
 	ATF_REQUIRE(waitpid(gchild, &status, 0) == gchild);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(ptrace(PT_DETACH, gchild, (caddr_t)1, 0) == 0);
 	ATF_REQUIRE(waitpid(gchild, &status, 0) == gchild);
 	ATF_REQUIRE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
 
 	ATF_REQUIRE(close(cpipe1[0]) == 0);
 	ATF_REQUIRE(close(cpipe1[1]) == 0);
 	ATF_REQUIRE(close(cpipe2[0]) == 0);
 	ATF_REQUIRE(close(cpipe2[1]) == 0);
 	ATF_REQUIRE(close(gcpipe[0]) == 0);
 	ATF_REQUIRE(close(gcpipe[1]) == 0);
 }
 
 /*
  * The parent process should always act the same regardless of how the
  * debugger is attached to it.
  */
 static __dead2 void
 follow_fork_parent(bool use_vfork)
 {
 	pid_t fpid, wpid;
 	int status;
 
 	if (use_vfork)
 		CHILD_REQUIRE((fpid = vfork()) != -1);
 	else
 		CHILD_REQUIRE((fpid = fork()) != -1);
 
 	if (fpid == 0)
 		/* Child */
 		_exit(2);
 
 	wpid = waitpid(fpid, &status, 0);
 	CHILD_REQUIRE(wpid == fpid);
 	CHILD_REQUIRE(WIFEXITED(status));
 	CHILD_REQUIRE(WEXITSTATUS(status) == 2);
 
 	_exit(1);
 }
 
 /*
  * Helper routine for follow fork tests.  This waits for two stops
  * that report both "sides" of a fork.  It returns the pid of the new
  * child process.
  */
 static pid_t
 handle_fork_events(pid_t parent, struct ptrace_lwpinfo *ppl)
 {
 	struct ptrace_lwpinfo pl;
 	bool fork_reported[2];
 	pid_t child, wpid;
 	int i, status;
 
 	fork_reported[0] = false;
 	fork_reported[1] = false;
 	child = -1;
 	
 	/*
 	 * Each process should report a fork event.  The parent should
 	 * report a PL_FLAG_FORKED event, and the child should report
 	 * a PL_FLAG_CHILD event.
 	 */
 	for (i = 0; i < 2; i++) {
 		wpid = wait(&status);
 		ATF_REQUIRE(wpid > 0);
 		ATF_REQUIRE(WIFSTOPPED(status));
 
 		ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 		    sizeof(pl)) != -1);
 		ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) !=
 		    0);
 		ATF_REQUIRE((pl.pl_flags & (PL_FLAG_FORKED | PL_FLAG_CHILD)) !=
 		    (PL_FLAG_FORKED | PL_FLAG_CHILD));
 		if (pl.pl_flags & PL_FLAG_CHILD) {
 			ATF_REQUIRE(wpid != parent);
 			ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 			ATF_REQUIRE(!fork_reported[1]);
 			if (child == -1)
 				child = wpid;
 			else
 				ATF_REQUIRE(child == wpid);
 			if (ppl != NULL)
 				ppl[1] = pl;
 			fork_reported[1] = true;
 		} else {
 			ATF_REQUIRE(wpid == parent);
 			ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 			ATF_REQUIRE(!fork_reported[0]);
 			if (child == -1)
 				child = pl.pl_child_pid;
 			else
 				ATF_REQUIRE(child == pl.pl_child_pid);
 			if (ppl != NULL)
 				ppl[0] = pl;
 			fork_reported[0] = true;
 		}
 	}
 
 	return (child);
 }
 
 /*
  * Verify that a new child process is stopped after a followed fork and
  * that the traced parent sees the exit of the child after the debugger
  * when both processes remain attached to the debugger.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached);
 ATF_TC_BODY(ptrace__follow_fork_both_attached, tc)
 {
 	pid_t children[2], fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		follow_fork_parent(false);
 	}
 
 	/* Parent process. */
 	children[0] = fpid;
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(children[0], &status, 0);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	children[1] = handle_fork_events(children[0], NULL);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * The child can't exit until the grandchild reports status, so the
 	 * grandchild should report its exit first to the debugger.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[1]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a new child process is stopped after a followed fork
  * and that the traced parent sees the exit of the child when the new
  * child process is detached after it reports its fork.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached);
 ATF_TC_BODY(ptrace__follow_fork_child_detached, tc)
 {
 	pid_t children[2], fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		follow_fork_parent(false);
 	}
 
 	/* Parent process. */
 	children[0] = fpid;
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(children[0], &status, 0);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	children[1] = handle_fork_events(children[0], NULL);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * Should not see any status from the grandchild now, only the
 	 * child.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a new child process is stopped after a followed fork
  * and that the traced parent sees the exit of the child when the
  * traced parent is detached after the fork.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached);
 ATF_TC_BODY(ptrace__follow_fork_parent_detached, tc)
 {
 	pid_t children[2], fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		follow_fork_parent(false);
 	}
 
 	/* Parent process. */
 	children[0] = fpid;
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(children[0], &status, 0);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	children[1] = handle_fork_events(children[0], NULL);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * The child can't exit until the grandchild reports status, so the
 	 * grandchild should report its exit first to the debugger.
 	 *
 	 * Even though the child process is detached, it is still a
 	 * child of the debugger, so it will still report it's exit
 	 * after the grandchild.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[1]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void
 attach_fork_parent(int cpipe[2])
 {
 	pid_t fpid;
 
 	close(cpipe[0]);
 
 	/* Double-fork to disassociate from the debugger. */
 	CHILD_REQUIRE((fpid = fork()) != -1);
 	if (fpid != 0)
 		_exit(3);
 	
 	/* Send the pid of the disassociated child to the debugger. */
 	fpid = getpid();
 	CHILD_REQUIRE(write(cpipe[1], &fpid, sizeof(fpid)) == sizeof(fpid));
 
 	/* Wait for the debugger to attach. */
 	CHILD_REQUIRE(read(cpipe[1], &fpid, sizeof(fpid)) == 0);
 }
 
 /*
  * Verify that a new child process is stopped after a followed fork and
  * that the traced parent sees the exit of the child after the debugger
  * when both processes remain attached to the debugger.  In this test
  * the parent that forks is not a direct child of the debugger.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_both_attached_unrelated_debugger);
 ATF_TC_BODY(ptrace__follow_fork_both_attached_unrelated_debugger, tc)
 {
 	pid_t children[2], fpid, wpid;
 	int cpipe[2], status;
 
 	ATF_REQUIRE(pipe(cpipe) == 0);
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		attach_fork_parent(cpipe);
 		follow_fork_parent(false);
 	}
 
 	/* Parent process. */
 	close(cpipe[1]);
 
 	/* Wait for the direct child to exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 3);
 
 	/* Read the pid of the fork parent. */
 	ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) ==
 	    sizeof(children[0]));
 
 	/* Attach to the fork parent. */
 	attach_child(children[0]);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the fork parent ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	/* Signal the fork parent to continue. */
 	close(cpipe[0]);
 
 	children[1] = handle_fork_events(children[0], NULL);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * The fork parent can't exit until the child reports status,
 	 * so the child should report its exit first to the debugger.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[1]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a new child process is stopped after a followed fork
  * and that the traced parent sees the exit of the child when the new
  * child process is detached after it reports its fork.  In this test
  * the parent that forks is not a direct child of the debugger.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_child_detached_unrelated_debugger);
 ATF_TC_BODY(ptrace__follow_fork_child_detached_unrelated_debugger, tc)
 {
 	pid_t children[2], fpid, wpid;
 	int cpipe[2], status;
 
 	ATF_REQUIRE(pipe(cpipe) == 0);
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		attach_fork_parent(cpipe);
 		follow_fork_parent(false);
 	}
 
 	/* Parent process. */
 	close(cpipe[1]);
 
 	/* Wait for the direct child to exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 3);
 
 	/* Read the pid of the fork parent. */
 	ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) ==
 	    sizeof(children[0]));
 
 	/* Attach to the fork parent. */
 	attach_child(children[0]);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the fork parent ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	/* Signal the fork parent to continue. */
 	close(cpipe[0]);
 
 	children[1] = handle_fork_events(children[0], NULL);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_DETACH, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * Should not see any status from the child now, only the fork
 	 * parent.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a new child process is stopped after a followed fork
  * and that the traced parent sees the exit of the child when the
  * traced parent is detached after the fork.  In this test the parent
  * that forks is not a direct child of the debugger.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__follow_fork_parent_detached_unrelated_debugger);
 ATF_TC_BODY(ptrace__follow_fork_parent_detached_unrelated_debugger, tc)
 {
 	pid_t children[2], fpid, wpid;
 	int cpipe[2], status;
 
 	ATF_REQUIRE(pipe(cpipe) == 0);
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		attach_fork_parent(cpipe);
 		follow_fork_parent(false);
 	}
 
 	/* Parent process. */
 	close(cpipe[1]);
 
 	/* Wait for the direct child to exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 3);
 
 	/* Read the pid of the fork parent. */
 	ATF_REQUIRE(read(cpipe[0], &children[0], sizeof(children[0])) ==
 	    sizeof(children[0]));
 
 	/* Attach to the fork parent. */
 	attach_child(children[0]);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the fork parent ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	/* Signal the fork parent to continue. */
 	close(cpipe[0]);
 
 	children[1] = handle_fork_events(children[0], NULL);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE(ptrace(PT_DETACH, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * Should not see any status from the fork parent now, only
 	 * the child.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[1]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a child process does not see an unrelated debugger as its
  * parent but sees its original parent process.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__getppid);
 ATF_TC_BODY(ptrace__getppid, tc)
 {
 	pid_t child, debugger, ppid, wpid;
 	int cpipe[2], dpipe[2], status;
 	char c;
 
 	ATF_REQUIRE(pipe(cpipe) == 0);
 	ATF_REQUIRE((child = fork()) != -1);
 
 	if (child == 0) {
 		/* Child process. */
 		close(cpipe[0]);
 
 		/* Wait for parent to be ready. */
 		CHILD_REQUIRE(read(cpipe[1], &c, sizeof(c)) == sizeof(c));
 
 		/* Report the parent PID to the parent. */
 		ppid = getppid();
 		CHILD_REQUIRE(write(cpipe[1], &ppid, sizeof(ppid)) ==
 		    sizeof(ppid));
 
 		_exit(1);
 	}
 	close(cpipe[1]);
 
 	ATF_REQUIRE(pipe(dpipe) == 0);
 	ATF_REQUIRE((debugger = fork()) != -1);
 
 	if (debugger == 0) {
 		/* Debugger process. */
 		close(dpipe[0]);
 
 		CHILD_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) != -1);
 
 		wpid = waitpid(child, &status, 0);
 		CHILD_REQUIRE(wpid == child);
 		CHILD_REQUIRE(WIFSTOPPED(status));
 		CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 		CHILD_REQUIRE(ptrace(PT_CONTINUE, child, (caddr_t)1, 0) != -1);
 
 		/* Signal parent that debugger is attached. */
 		CHILD_REQUIRE(write(dpipe[1], &c, sizeof(c)) == sizeof(c));
 
 		/* Wait for traced child to exit. */
 		wpid = waitpid(child, &status, 0);
 		CHILD_REQUIRE(wpid == child);
 		CHILD_REQUIRE(WIFEXITED(status));
 		CHILD_REQUIRE(WEXITSTATUS(status) == 1);
 
 		_exit(0);
 	}
 	close(dpipe[1]);
 
 	/* Parent process. */
 
 	/* Wait for the debugger to attach to the child. */
 	ATF_REQUIRE(read(dpipe[0], &c, sizeof(c)) == sizeof(c));
 
 	/* Release the child. */
 	ATF_REQUIRE(write(cpipe[0], &c, sizeof(c)) == sizeof(c));
 
 	/* Read the parent PID from the child. */
 	ATF_REQUIRE(read(cpipe[0], &ppid, sizeof(ppid)) == sizeof(ppid));
 	close(cpipe[0]);
 
 	ATF_REQUIRE(ppid == getpid());
 
 	/* Wait for the debugger. */
 	wpid = waitpid(debugger, &status, 0);
 	ATF_REQUIRE(wpid == debugger);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	/* The child process should now be ready. */
 	wpid = waitpid(child, &status, WNOHANG);
 	ATF_REQUIRE(wpid == child);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 }
 
 /*
  * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new
  * child process created via fork() reports the correct value.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_fork);
 ATF_TC_BODY(ptrace__new_child_pl_syscall_code_fork, tc)
 {
 	struct ptrace_lwpinfo pl[2];
 	pid_t children[2], fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		follow_fork_parent(false);
 	}
 
 	/* Parent process. */
 	children[0] = fpid;
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(children[0], &status, 0);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	/* Wait for both halves of the fork event to get reported. */
 	children[1] = handle_fork_events(children[0], pl);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_SCX) != 0);
 	ATF_REQUIRE((pl[1].pl_flags & PL_FLAG_SCX) != 0);
 	ATF_REQUIRE(pl[0].pl_syscall_code == SYS_fork);
 	ATF_REQUIRE(pl[0].pl_syscall_code == pl[1].pl_syscall_code);
 	ATF_REQUIRE(pl[0].pl_syscall_narg == pl[1].pl_syscall_narg);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * The child can't exit until the grandchild reports status, so the
 	 * grandchild should report its exit first to the debugger.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[1]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new
  * child process created via vfork() reports the correct value.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_vfork);
 ATF_TC_BODY(ptrace__new_child_pl_syscall_code_vfork, tc)
 {
 	struct ptrace_lwpinfo pl[2];
 	pid_t children[2], fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		follow_fork_parent(true);
 	}
 
 	/* Parent process. */
 	children[0] = fpid;
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(children[0], &status, 0);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, children[0], NULL, 1) != -1);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	/* Wait for both halves of the fork event to get reported. */
 	children[1] = handle_fork_events(children[0], pl);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_SCX) != 0);
 	ATF_REQUIRE((pl[1].pl_flags & PL_FLAG_SCX) != 0);
 	ATF_REQUIRE(pl[0].pl_syscall_code == SYS_vfork);
 	ATF_REQUIRE(pl[0].pl_syscall_code == pl[1].pl_syscall_code);
 	ATF_REQUIRE(pl[0].pl_syscall_narg == pl[1].pl_syscall_narg);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * The child can't exit until the grandchild reports status, so the
 	 * grandchild should report its exit first to the debugger.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[1]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void *
 simple_thread(void *arg __unused)
 {
 
 	pthread_exit(NULL);
 }
 
 static __dead2 void
 simple_thread_main(void)
 {
 	pthread_t thread;
 
 	CHILD_REQUIRE(pthread_create(&thread, NULL, simple_thread, NULL) == 0);
 	CHILD_REQUIRE(pthread_join(thread, NULL) == 0);
 	exit(1);
 }
 
 /*
  * Verify that pl_syscall_code in struct ptrace_lwpinfo for a new
  * thread reports the correct value.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__new_child_pl_syscall_code_thread);
 ATF_TC_BODY(ptrace__new_child_pl_syscall_code_thread, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	lwpid_t mainlwp;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		simple_thread_main();
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 	    sizeof(pl)) != -1);
 	mainlwp = pl.pl_lwpid;
 
 	/*
 	 * Continue the child ignoring the SIGSTOP and tracing all
 	 * system call exits.
 	 */
 	ATF_REQUIRE(ptrace(PT_TO_SCX, fpid, (caddr_t)1, 0) != -1);
 
 	/*
 	 * Wait for the new thread to arrive.  pthread_create() might
 	 * invoke any number of system calls.  For now we just wait
 	 * for the new thread to arrive and make sure it reports a
 	 * valid system call code.  If ptrace grows thread event
 	 * reporting then this test can be made more precise.
 	 */
 	for (;;) {
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		ATF_REQUIRE(WIFSTOPPED(status));
 		ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 		
 		ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 		    sizeof(pl)) != -1);
 		ATF_REQUIRE((pl.pl_flags & PL_FLAG_SCX) != 0);
 		ATF_REQUIRE(pl.pl_syscall_code != 0);
 		if (pl.pl_lwpid != mainlwp)
 			/* New thread seen. */
 			break;
 
 		ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 	}
 
 	/* Wait for the child to exit. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 	for (;;) {
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		if (WIFEXITED(status))
 			break;
 		
 		ATF_REQUIRE(WIFSTOPPED(status));
 		ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 		ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 	}
 		
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that the expected LWP events are reported for a child thread.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__lwp_events);
 ATF_TC_BODY(ptrace__lwp_events, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	lwpid_t lwps[2];
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		simple_thread_main();
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 	    sizeof(pl)) != -1);
 	lwps[0] = pl.pl_lwpid;
 
 	ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The first event should be for the child thread's birth. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 		
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) ==
 	    (PL_FLAG_BORN | PL_FLAG_SCX));
 	ATF_REQUIRE(pl.pl_lwpid != lwps[0]);
 	lwps[1] = pl.pl_lwpid;
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next event should be for the child thread's death. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 		
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXITED | PL_FLAG_SCE)) ==
 	    (PL_FLAG_EXITED | PL_FLAG_SCE));
 	ATF_REQUIRE(pl.pl_lwpid == lwps[1]);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void *
 exec_thread(void *arg __unused)
 {
 
 	execl("/usr/bin/true", "true", NULL);
 	exit(127);
 }
 
 static __dead2 void
 exec_thread_main(void)
 {
 	pthread_t thread;
 
 	CHILD_REQUIRE(pthread_create(&thread, NULL, exec_thread, NULL) == 0);
 	for (;;)
 		sleep(60);
 	exit(1);
 }
 
 /*
  * Verify that the expected LWP events are reported for a multithreaded
  * process that calls execve(2).
  */
 ATF_TC_WITHOUT_HEAD(ptrace__lwp_events_exec);
 ATF_TC_BODY(ptrace__lwp_events_exec, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	lwpid_t lwps[2];
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		exec_thread_main();
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 	    sizeof(pl)) != -1);
 	lwps[0] = pl.pl_lwpid;
 
 	ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The first event should be for the child thread's birth. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 		
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) ==
 	    (PL_FLAG_BORN | PL_FLAG_SCX));
 	ATF_REQUIRE(pl.pl_lwpid != lwps[0]);
 	lwps[1] = pl.pl_lwpid;
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/*
 	 * The next event should be for the main thread's death due to
 	 * single threading from execve().
 	 */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXITED | PL_FLAG_SCE)) ==
 	    (PL_FLAG_EXITED));
 	ATF_REQUIRE(pl.pl_lwpid == lwps[0]);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next event should be for the child process's exec. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXEC | PL_FLAG_SCX)) ==
 	    (PL_FLAG_EXEC | PL_FLAG_SCX));
 	ATF_REQUIRE(pl.pl_lwpid == lwps[1]);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void
 handler(int sig __unused)
 {
 }
 
 static void
 signal_main(void)
 {
 
 	signal(SIGINFO, handler);
 	raise(SIGINFO);
 	exit(0);
 }
 
 /*
  * Verify that the expected ptrace event is reported for a signal.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__siginfo);
 ATF_TC_BODY(ptrace__siginfo, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		signal_main();
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next event should be for the SIGINFO. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGINFO);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_event == PL_EVENT_SIGNAL);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_code == SI_LWP);
 	ATF_REQUIRE(pl.pl_siginfo.si_pid == wpid);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that the expected ptrace events are reported for PTRACE_EXEC.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_exec_disable);
 ATF_TC_BODY(ptrace__ptrace_exec_disable, tc)
 {
 	pid_t fpid, wpid;
 	int events, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		exec_thread(NULL);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	events = 0;
 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* Should get one event at exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_exec_enable);
 ATF_TC_BODY(ptrace__ptrace_exec_enable, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int events, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		exec_thread(NULL);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	events = PTRACE_EXEC;
 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next event should be for the child process's exec. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_EXEC | PL_FLAG_SCX)) ==
 	    (PL_FLAG_EXEC | PL_FLAG_SCX));
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 ATF_TC_WITHOUT_HEAD(ptrace__event_mask);
 ATF_TC_BODY(ptrace__event_mask, tc)
 {
 	pid_t fpid, wpid;
 	int events, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		exit(0);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* PT_FOLLOW_FORK should toggle the state of PTRACE_FORK. */
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, fpid, NULL, 1) != -1);
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	ATF_REQUIRE(events & PTRACE_FORK);
 	ATF_REQUIRE(ptrace(PT_FOLLOW_FORK, fpid, NULL, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	ATF_REQUIRE(!(events & PTRACE_FORK));
 
 	/* PT_LWP_EVENTS should toggle the state of PTRACE_LWP. */
 	ATF_REQUIRE(ptrace(PT_LWP_EVENTS, fpid, NULL, 1) != -1);
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	ATF_REQUIRE(events & PTRACE_LWP);
 	ATF_REQUIRE(ptrace(PT_LWP_EVENTS, fpid, NULL, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	ATF_REQUIRE(!(events & PTRACE_LWP));
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* Should get one event at exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that the expected ptrace events are reported for PTRACE_VFORK.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_vfork);
 ATF_TC_BODY(ptrace__ptrace_vfork, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int events, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		follow_fork_parent(true);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	events |= PTRACE_VFORK;
 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) != -1);
 
 	/* The next event should report the end of the vfork. */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & PL_FLAG_VFORK_DONE) != 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) != -1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 ATF_TC_WITHOUT_HEAD(ptrace__ptrace_vfork_follow);
 ATF_TC_BODY(ptrace__ptrace_vfork_follow, tc)
 {
 	struct ptrace_lwpinfo pl[2];
 	pid_t children[2], fpid, wpid;
 	int events, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		follow_fork_parent(true);
 	}
 
 	/* Parent process. */
 	children[0] = fpid;
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(children[0], &status, 0);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, children[0], (caddr_t)&events,
 	    sizeof(events)) == 0);
 	events |= PTRACE_FORK | PTRACE_VFORK;
 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, children[0], (caddr_t)&events,
 	    sizeof(events)) == 0);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	/* Wait for both halves of the fork event to get reported. */
 	children[1] = handle_fork_events(children[0], pl);
 	ATF_REQUIRE(children[1] > 0);
 
 	ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_VFORKED) != 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[1], (caddr_t)1, 0) != -1);
 
 	/*
 	 * The child can't exit until the grandchild reports status, so the
 	 * grandchild should report its exit first to the debugger.
 	 */
 	wpid = waitpid(children[1], &status, 0);
 	ATF_REQUIRE(wpid == children[1]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 2);
 
 	/*
 	 * The child should report it's vfork() completion before it
 	 * exits.
 	 */
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl[0], sizeof(pl[0])) !=
 	    -1);
 	ATF_REQUIRE((pl[0].pl_flags & PL_FLAG_VFORK_DONE) != 0);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, children[0], (caddr_t)1, 0) != -1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == children[0]);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 #ifdef HAVE_BREAKPOINT
 /*
  * Verify that no more events are reported after PT_KILL except for the
  * process exit when stopped due to a breakpoint trap.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_breakpoint);
 ATF_TC_BODY(ptrace__PT_KILL_breakpoint, tc)
 {
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		breakpoint();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report hitting the breakpoint. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	/* Kill the child process. */
 	ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0);
 
 	/* The last wait() should report the SIGKILL. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGKILL);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 #endif /* HAVE_BREAKPOINT */
 
 /*
  * Verify that no more events are reported after PT_KILL except for the
  * process exit when stopped inside of a system call.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_system_call);
 ATF_TC_BODY(ptrace__PT_KILL_system_call, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		getpid();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP and tracing system calls. */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report a system call entry for getpid(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 
 	/* Kill the child process. */
 	ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0);
 
 	/* The last wait() should report the SIGKILL. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGKILL);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that no more events are reported after PT_KILL except for the
  * process exit when killing a multithreaded process.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_threads);
 ATF_TC_BODY(ptrace__PT_KILL_threads, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	lwpid_t main_lwp;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		simple_thread_main();
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 	    sizeof(pl)) != -1);
 	main_lwp = pl.pl_lwpid;
 
 	ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The first event should be for the child thread's birth. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 		
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) ==
 	    (PL_FLAG_BORN | PL_FLAG_SCX));
 	ATF_REQUIRE(pl.pl_lwpid != main_lwp);
 
 	/* Kill the child process. */
 	ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0);
 
 	/* The last wait() should report the SIGKILL. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGKILL);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void *
 mask_usr1_thread(void *arg)
 {
 	pthread_barrier_t *pbarrier;
 	sigset_t sigmask;
 
 	pbarrier = (pthread_barrier_t*)arg;
 
 	sigemptyset(&sigmask);
 	sigaddset(&sigmask, SIGUSR1);
 	CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 	/* Sync up with other thread after sigmask updated. */
 	pthread_barrier_wait(pbarrier);
 
 	for (;;)
 		sleep(60);
 
 	return (NULL);
 }
 
 /*
  * Verify that the SIGKILL from PT_KILL takes priority over other signals
  * and prevents spurious stops due to those other signals.
  */
 ATF_TC(ptrace__PT_KILL_competing_signal);
 ATF_TC_HEAD(ptrace__PT_KILL_competing_signal, tc)
 {
 
 	atf_tc_set_md_var(tc, "require.user", "root");
 }
 ATF_TC_BODY(ptrace__PT_KILL_competing_signal, tc)
 {
 	pid_t fpid, wpid;
 	int status;
 	cpuset_t setmask;
 	pthread_t t;
 	pthread_barrier_t barrier;
 	struct sched_param sched_param;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		/* Bind to one CPU so only one thread at a time will run. */
 		CPU_ZERO(&setmask);
 		CPU_SET(0, &setmask);
 		cpusetid_t setid;
 		CHILD_REQUIRE(cpuset(&setid) == 0);
 		CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET,
 		    CPU_WHICH_CPUSET, setid, sizeof(setmask), &setmask) == 0);
 
 		CHILD_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0);
 
 		CHILD_REQUIRE(pthread_create(&t, NULL, mask_usr1_thread,
 		    (void*)&barrier) == 0);
 
 		/*
 		 * Give the main thread higher priority. The test always
 		 * assumes that, if both threads are able to run, the main
 		 * thread runs first.
 		 */
 		sched_param.sched_priority =
 		    (sched_get_priority_max(SCHED_FIFO) +
 		    sched_get_priority_min(SCHED_FIFO)) / 2;
 		CHILD_REQUIRE(pthread_setschedparam(pthread_self(),
 		    SCHED_FIFO, &sched_param) == 0);
 		sched_param.sched_priority -= RQ_PPQ;
 		CHILD_REQUIRE(pthread_setschedparam(t, SCHED_FIFO,
 		    &sched_param) == 0);
 
 		sigset_t sigmask;
 		sigemptyset(&sigmask);
 		sigaddset(&sigmask, SIGUSR2);
 		CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 		/* Sync up with other thread after sigmask updated. */
 		pthread_barrier_wait(&barrier);
 
 		trace_me();
 
 		for (;;)
 			sleep(60);
 
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* Send a signal that only the second thread can handle. */
 	ATF_REQUIRE(kill(fpid, SIGUSR2) == 0);
 
 	/* The second wait() should report the SIGUSR2. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2);
 
 	/* Send a signal that only the first thread can handle. */
 	ATF_REQUIRE(kill(fpid, SIGUSR1) == 0);
 
 	/* Replace the SIGUSR2 with a kill. */
 	ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0);
 
 	/* The last wait() should report the SIGKILL (not the SIGUSR signal). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGKILL);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that the SIGKILL from PT_KILL takes priority over other stop events
  * and prevents spurious stops caused by those events.
  */
 ATF_TC(ptrace__PT_KILL_competing_stop);
 ATF_TC_HEAD(ptrace__PT_KILL_competing_stop, tc)
 {
 
 	atf_tc_set_md_var(tc, "require.user", "root");
 }
 ATF_TC_BODY(ptrace__PT_KILL_competing_stop, tc)
 {
 	pid_t fpid, wpid;
 	int status;
 	cpuset_t setmask;
 	pthread_t t;
 	pthread_barrier_t barrier;
 	lwpid_t main_lwp;
 	struct ptrace_lwpinfo pl;
 	struct sched_param sched_param;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 
 		/* Bind to one CPU so only one thread at a time will run. */
 		CPU_ZERO(&setmask);
 		CPU_SET(0, &setmask);
 		cpusetid_t setid;
 		CHILD_REQUIRE(cpuset(&setid) == 0);
 		CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET,
 		    CPU_WHICH_CPUSET, setid, sizeof(setmask), &setmask) == 0);
 
 		CHILD_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0);
 
 		CHILD_REQUIRE(pthread_create(&t, NULL, mask_usr1_thread,
 		    (void*)&barrier) == 0);
 
 		/*
 		 * Give the main thread higher priority. The test always
 		 * assumes that, if both threads are able to run, the main
 		 * thread runs first.
 		 */
 		sched_param.sched_priority =
 		    (sched_get_priority_max(SCHED_FIFO) +
 		    sched_get_priority_min(SCHED_FIFO)) / 2;
 		CHILD_REQUIRE(pthread_setschedparam(pthread_self(),
 		    SCHED_FIFO, &sched_param) == 0);
 		sched_param.sched_priority -= RQ_PPQ;
 		CHILD_REQUIRE(pthread_setschedparam(t, SCHED_FIFO,
 		    &sched_param) == 0);
 
 		sigset_t sigmask;
 		sigemptyset(&sigmask);
 		sigaddset(&sigmask, SIGUSR2);
 		CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 		/* Sync up with other thread after sigmask updated. */
 		pthread_barrier_wait(&barrier);
 
 		/* Sync up with the test before doing the getpid(). */
 		raise(SIGSTOP);
 
 		getpid();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	main_lwp = pl.pl_lwpid;
 
 	/* Continue the child ignoring the SIGSTOP and tracing system calls. */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/*
 	 * Continue until child is done with setup, which is indicated with
 	 * SIGSTOP. Ignore system calls in the meantime.
 	 */
 	for (;;) {
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		ATF_REQUIRE(WIFSTOPPED(status));
 		if (WSTOPSIG(status) == SIGTRAP) {
 			ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 			    sizeof(pl)) != -1);
 			ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX));
 		} else {
 			ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 			break;
 		}
 		ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 	}
 
 	/* Proceed, allowing main thread to hit syscall entry for getpid(). */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 	    sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_lwpid == main_lwp);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 	/* Prevent the main thread from hitting its syscall exit for now. */
 	ATF_REQUIRE(ptrace(PT_SUSPEND, main_lwp, 0, 0) == 0);
 
 	/*
 	 * Proceed, allowing second thread to hit syscall exit for
 	 * pthread_barrier_wait().
 	 */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 	    sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_lwpid != main_lwp);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX);
 
 	/* Send a signal that only the second thread can handle. */
 	ATF_REQUIRE(kill(fpid, SIGUSR2) == 0);
 
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next wait() should report the SIGUSR2. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2);
 
 	/* Allow the main thread to try to finish its system call. */
 	ATF_REQUIRE(ptrace(PT_RESUME, main_lwp, 0, 0) == 0);
 
 	/*
 	 * At this point, the main thread is in the middle of a system call and
 	 * has been resumed. The second thread has taken a SIGUSR2 which will
 	 * be replaced with a SIGKILL below. The main thread will get to run
 	 * first. It should notice the kill request (even though the signal
 	 * replacement occurred in the other thread) and exit accordingly.  It
 	 * should not stop for the system call exit event.
 	 */
 
 	/* Replace the SIGUSR2 with a kill. */
 	ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0);
 
 	/* The last wait() should report the SIGKILL (not a syscall exit). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGKILL);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void
 sigusr1_handler(int sig)
 {
 
 	CHILD_REQUIRE(sig == SIGUSR1);
 	_exit(2);
 }
 
 /*
  * Verify that even if the signal queue is full for a child process,
  * a PT_KILL will kill the process.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_KILL_with_signal_full_sigqueue);
 ATF_TC_BODY(ptrace__PT_KILL_with_signal_full_sigqueue, tc)
 {
 	pid_t fpid, wpid;
 	int status;
 	int max_pending_per_proc;
 	size_t len;
 	int i;
 
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR);
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	len = sizeof(max_pending_per_proc);
 	ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc",
 	    &max_pending_per_proc, &len, NULL, 0) == 0);
 
 	/* Fill the signal queue. */
 	for (i = 0; i < max_pending_per_proc; ++i)
 		ATF_REQUIRE(kill(fpid, SIGUSR1) == 0);
 
 	/* Kill the child process. */
 	ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0);
 
 	/* The last wait() should report the SIGKILL. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGKILL);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that when stopped at a system call entry, a signal can be
  * requested with PT_CONTINUE which will be delivered once the system
  * call is complete.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_system_call_entry);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_system_call_entry, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR);
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		getpid();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP and tracing system calls. */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report a system call entry for getpid(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 
 	/* Continue the child process with a signal. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	for (;;) {
 		/*
 		 * The last wait() should report exit 2, i.e., a normal _exit
 		 * from the signal handler. In the meantime, catch and proceed
 		 * past any syscall stops.
 		 */
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) {
 			ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 			ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX));
 			ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 		} else {
 			ATF_REQUIRE(WIFEXITED(status));
 			ATF_REQUIRE(WEXITSTATUS(status) == 2);
 			break;
 		}
 	}
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void
 sigusr1_counting_handler(int sig)
 {
 	static int counter = 0;
 
 	CHILD_REQUIRE(sig == SIGUSR1);
 	counter++;
 	if (counter == 2)
 		_exit(2);
 }
 
 /*
  * Verify that, when continuing from a stop at system call entry and exit,
  * a signal can be requested from both stops, and both will be delivered when
  * the system call is complete.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_counting_handler) != SIG_ERR);
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		getpid();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP and tracing system calls. */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report a system call entry for getpid(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 
 	/* Continue the child process with a signal. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* The third wait() should report a system call exit for getpid(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX);
 
 	/* Continue the child process with a signal. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	for (;;) {
 		/*
 		 * The last wait() should report exit 2, i.e., a normal _exit
 		 * from the signal handler. In the meantime, catch and proceed
 		 * past any syscall stops.
 		 */
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) {
 			ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 			ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX));
 			ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 		} else {
 			ATF_REQUIRE(WIFEXITED(status));
 			ATF_REQUIRE(WEXITSTATUS(status) == 2);
 			break;
 		}
 	}
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that even if the signal queue is full for a child process,
  * a PT_CONTINUE with a signal will not result in loss of that signal.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_full_sigqueue);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_full_sigqueue, tc)
 {
 	pid_t fpid, wpid;
 	int status;
 	int max_pending_per_proc;
 	size_t len;
 	int i;
 
 	ATF_REQUIRE(signal(SIGUSR2, handler) != SIG_ERR);
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_handler) != SIG_ERR);
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	len = sizeof(max_pending_per_proc);
 	ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc",
 	    &max_pending_per_proc, &len, NULL, 0) == 0);
 
 	/* Fill the signal queue. */
 	for (i = 0; i < max_pending_per_proc; ++i)
 		ATF_REQUIRE(kill(fpid, SIGUSR2) == 0);
 
 	/* Continue with signal. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	for (;;) {
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		if (WIFSTOPPED(status)) {
 			ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2);
 			ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 		} else {
 			/*
 			 * The last wait() should report normal _exit from the
 			 * SIGUSR1 handler.
 			 */
 			ATF_REQUIRE(WIFEXITED(status));
 			ATF_REQUIRE(WEXITSTATUS(status) == 2);
 			break;
 		}
 	}
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static sem_t sigusr1_sem;
 static int got_usr1;
 
 static void
 sigusr1_sempost_handler(int sig __unused)
 {
 
 	got_usr1++;
 	CHILD_REQUIRE(sem_post(&sigusr1_sem) == 0);
 }
 
 /*
  * Verify that even if the signal queue is full for a child process,
  * and the signal is masked, a PT_CONTINUE with a signal will not
  * result in loss of that signal.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_masked_full_sigqueue);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_masked_full_sigqueue, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status, err;
 	int max_pending_per_proc;
 	size_t len;
 	int i;
 	sigset_t sigmask;
 
 	ATF_REQUIRE(signal(SIGUSR2, handler) != SIG_ERR);
 	ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0);
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR);
 
 	got_usr1 = 0;
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		CHILD_REQUIRE(sigemptyset(&sigmask) == 0);
 		CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0);
 		CHILD_REQUIRE(sigprocmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 		trace_me();
 		CHILD_REQUIRE(got_usr1 == 0);
 
 		/* Allow the pending SIGUSR1 in now. */
 		CHILD_REQUIRE(sigprocmask(SIG_UNBLOCK, &sigmask, NULL) == 0);
 		/* Wait to receive the SIGUSR1. */
 		do {
 			err = sem_wait(&sigusr1_sem);
 			CHILD_REQUIRE(err == 0 || errno == EINTR);
 		} while (err != 0 && errno == EINTR);
 		CHILD_REQUIRE(got_usr1 == 1);
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	len = sizeof(max_pending_per_proc);
 	ATF_REQUIRE(sysctlbyname("kern.sigqueue.max_pending_per_proc",
 	    &max_pending_per_proc, &len, NULL, 0) == 0);
 
 	/* Fill the signal queue. */
 	for (i = 0; i < max_pending_per_proc; ++i)
 		ATF_REQUIRE(kill(fpid, SIGUSR2) == 0);
 
 	/* Continue with signal. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* Collect and ignore all of the SIGUSR2. */
 	for (i = 0; i < max_pending_per_proc; ++i) {
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		ATF_REQUIRE(WIFSTOPPED(status));
 		ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2);
 		ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 	}
 
 	/* Now our PT_CONTINUE'd SIGUSR1 should cause a stop after unmask. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGUSR1);
 	ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGUSR1);
 
 	/* Continue the child, ignoring the SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last wait() should report exit after receiving SIGUSR1. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that, after stopping due to a signal, that signal can be
  * replaced with another signal.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_change_sig);
 ATF_TC_BODY(ptrace__PT_CONTINUE_change_sig, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		sleep(20);
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* Send a signal without ptrace. */
 	ATF_REQUIRE(kill(fpid, SIGINT) == 0);
 
 	/* The second wait() should report a SIGINT was received. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGINT);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGINT);
 
 	/* Continue the child process with a different signal. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGTERM) == 0);
 
 	/*
 	 * The last wait() should report having died due to the new
 	 * signal, SIGTERM.
 	 */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGTERM);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a signal can be passed through to the child even when there
  * was no true signal originally. Such cases arise when a SIGTRAP is
  * invented for e.g, system call stops.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_sigtrap_system_call_entry);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_sigtrap_system_call_entry, tc)
 {
 	struct ptrace_lwpinfo pl;
 	struct rlimit rl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		/* SIGTRAP expected to cause exit on syscall entry. */
 		rl.rlim_cur = rl.rlim_max = 0;
 		ATF_REQUIRE(setrlimit(RLIMIT_CORE, &rl) == 0);
 		getpid();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP and tracing system calls. */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report a system call entry for getpid(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 
 	/* Continue the child process with a SIGTRAP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGTRAP) == 0);
 
 	for (;;) {
 		/*
 		 * The last wait() should report exit due to SIGTRAP.  In the
 		 * meantime, catch and proceed past any syscall stops.
 		 */
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) {
 			ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 			ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX));
 			ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 		} else {
 			ATF_REQUIRE(WIFSIGNALED(status));
 			ATF_REQUIRE(WTERMSIG(status) == SIGTRAP);
 			break;
 		}
 	}
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 
 }
 
 /*
  * A mixed bag PT_CONTINUE with signal test.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_mix);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_mix, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_counting_handler) != SIG_ERR);
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		getpid();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP and tracing system calls. */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report a system call entry for getpid(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 
 	/* Continue with the first SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* The next wait() should report a system call exit for getpid(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX);
 
 	/* Send an ABRT without ptrace. */
 	ATF_REQUIRE(kill(fpid, SIGABRT) == 0);
 
 	/* Continue normally. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next wait() should report the SIGABRT. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGABRT);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT);
 
 	/* Continue, replacing the SIGABRT with another SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	for (;;) {
 		/*
 		 * The last wait() should report exit 2, i.e., a normal _exit
 		 * from the signal handler. In the meantime, catch and proceed
 		 * past any syscall stops.
 		 */
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) {
 			ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 			ATF_REQUIRE(pl.pl_flags & (PL_FLAG_SCE | PL_FLAG_SCX));
 			ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 		} else {
 			ATF_REQUIRE(WIFEXITED(status));
 			ATF_REQUIRE(WEXITSTATUS(status) == 2);
 			break;
 		}
 	}
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 
 }
 
 /*
  * Verify a signal delivered by ptrace is noticed by kevent(2).
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_kqueue);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_kqueue, tc)
 {
 	pid_t fpid, wpid;
 	int status, kq, nevents;
 	struct kevent kev;
 
 	ATF_REQUIRE(signal(SIGUSR1, SIG_IGN) != SIG_ERR);
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		CHILD_REQUIRE((kq = kqueue()) > 0);
 		EV_SET(&kev, SIGUSR1, EVFILT_SIGNAL, EV_ADD, 0, 0, 0);
 		CHILD_REQUIRE(kevent(kq, &kev, 1, NULL, 0, NULL) == 0);
 
 		trace_me();
 
 		for (;;) {
 			nevents = kevent(kq, NULL, 0, &kev, 1, NULL);
 			if (nevents == -1 && errno == EINTR)
 				continue;
 			CHILD_REQUIRE(nevents > 0);
 			CHILD_REQUIRE(kev.filter == EVFILT_SIGNAL);
 			CHILD_REQUIRE(kev.ident == SIGUSR1);
 			break;
 		}
 
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue with the SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/*
 	 * The last wait() should report normal exit with code 1.
 	 */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void *
 signal_thread(void *arg)
 {
 	int err;
 	sigset_t sigmask;
 
 	pthread_barrier_t *pbarrier = (pthread_barrier_t*)arg;
 
 	/* Wait for this thread to receive a SIGUSR1. */
 	do {
 		err = sem_wait(&sigusr1_sem);
 		CHILD_REQUIRE(err == 0 || errno == EINTR);
 	} while (err != 0 && errno == EINTR);
 
 	/* Free our companion thread from the barrier. */
 	pthread_barrier_wait(pbarrier);
 
 	/*
 	 * Swap ignore duties; the next SIGUSR1 should go to the
 	 * other thread.
 	 */
 	CHILD_REQUIRE(sigemptyset(&sigmask) == 0);
 	CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0);
 	CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 	/* Sync up threads after swapping signal masks. */
 	pthread_barrier_wait(pbarrier);
 
 	/* Wait until our companion has received its SIGUSR1. */
 	pthread_barrier_wait(pbarrier);
 
 	return (NULL);
 }
 
 /*
  * Verify that a traced process with blocked signal received the
  * signal from kill() once unmasked.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__killed_with_sigmask);
 ATF_TC_BODY(ptrace__killed_with_sigmask, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status, err;
 	sigset_t sigmask;
 
 	ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0);
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR);
 	got_usr1 = 0;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		CHILD_REQUIRE(sigemptyset(&sigmask) == 0);
 		CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0);
 		CHILD_REQUIRE(sigprocmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 		trace_me();
 		CHILD_REQUIRE(got_usr1 == 0);
 
 		/* Allow the pending SIGUSR1 in now. */
 		CHILD_REQUIRE(sigprocmask(SIG_UNBLOCK, &sigmask, NULL) == 0);
 		/* Wait to receive a SIGUSR1. */
 		do {
 			err = sem_wait(&sigusr1_sem);
 			CHILD_REQUIRE(err == 0 || errno == EINTR);
 		} while (err != 0 && errno == EINTR);
 		CHILD_REQUIRE(got_usr1 == 1);
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 	ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGSTOP);
 
 	/* Send blocked SIGUSR1 which should cause a stop. */
 	ATF_REQUIRE(kill(fpid, SIGUSR1) == 0);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next wait() should report the kill(SIGUSR1) was received. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGUSR1);
 	ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGUSR1);
 
 	/* Continue the child, allowing in the SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* The last wait() should report normal exit with code 1. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that a traced process with blocked signal received the
  * signal from PT_CONTINUE once unmasked.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_sigmask);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_sigmask, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status, err;
 	sigset_t sigmask;
 
 	ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0);
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR);
 	got_usr1 = 0;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		CHILD_REQUIRE(sigemptyset(&sigmask) == 0);
 		CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0);
 		CHILD_REQUIRE(sigprocmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 		trace_me();
 		CHILD_REQUIRE(got_usr1 == 0);
 
 		/* Allow the pending SIGUSR1 in now. */
 		CHILD_REQUIRE(sigprocmask(SIG_UNBLOCK, &sigmask, NULL) == 0);
 		/* Wait to receive a SIGUSR1. */
 		do {
 			err = sem_wait(&sigusr1_sem);
 			CHILD_REQUIRE(err == 0 || errno == EINTR);
 		} while (err != 0 && errno == EINTR);
 
 		CHILD_REQUIRE(got_usr1 == 1);
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 	ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGSTOP);
 
 	/* Continue the child replacing SIGSTOP with SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* The next wait() should report the SIGUSR1 was received. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGUSR1);
 	ATF_REQUIRE(ptrace(PT_LWPINFO, fpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGUSR1);
 
 	/* Continue the child, ignoring the SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last wait() should report normal exit with code 1. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
  * Verify that if ptrace stops due to a signal but continues with
  * a different signal that the new signal is routed to a thread
  * that can accept it, and that the thread is awakened by the signal
  * in a timely manner.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_with_signal_thread_sigmask);
 ATF_TC_BODY(ptrace__PT_CONTINUE_with_signal_thread_sigmask, tc)
 {
 	pid_t fpid, wpid;
 	int status, err;
 	pthread_t t;
 	sigset_t sigmask;
 	pthread_barrier_t barrier;
 
 	ATF_REQUIRE(pthread_barrier_init(&barrier, NULL, 2) == 0);
 	ATF_REQUIRE(sem_init(&sigusr1_sem, 0, 0) == 0);
 	ATF_REQUIRE(signal(SIGUSR1, sigusr1_sempost_handler) != SIG_ERR);
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		CHILD_REQUIRE(pthread_create(&t, NULL, signal_thread, (void*)&barrier) == 0);
 
 		/* The other thread should receive the first SIGUSR1. */
 		CHILD_REQUIRE(sigemptyset(&sigmask) == 0);
 		CHILD_REQUIRE(sigaddset(&sigmask, SIGUSR1) == 0);
 		CHILD_REQUIRE(pthread_sigmask(SIG_BLOCK, &sigmask, NULL) == 0);
 
 		trace_me();
 
 		/* Wait until other thread has received its SIGUSR1. */
 		pthread_barrier_wait(&barrier);
 
 		/*
 		 * Swap ignore duties; the next SIGUSR1 should go to this
 		 * thread.
 		 */
 		CHILD_REQUIRE(pthread_sigmask(SIG_UNBLOCK, &sigmask, NULL) == 0);
 
 		/* Sync up threads after swapping signal masks. */
 		pthread_barrier_wait(&barrier);
 
 		/*
 		 * Sync up with test code; we're ready for the next SIGUSR1
 		 * now.
 		 */
 		raise(SIGSTOP);
 
 		/* Wait for this thread to receive a SIGUSR1. */
 		do {
 			err = sem_wait(&sigusr1_sem);
 			CHILD_REQUIRE(err == 0 || errno == EINTR);
 		} while (err != 0 && errno == EINTR);
 
 		/* Free the other thread from the barrier. */
 		pthread_barrier_wait(&barrier);
 
 		CHILD_REQUIRE(pthread_join(t, NULL) == 0);
 
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/*
 	 * Send a signal without ptrace that either thread will accept (USR2,
 	 * in this case).
 	 */
 	ATF_REQUIRE(kill(fpid, SIGUSR2) == 0);
 	
 	/* The second wait() should report a SIGUSR2 was received. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2);
 
 	/* Continue the child, changing the signal to USR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* The next wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	ATF_REQUIRE(kill(fpid, SIGUSR2) == 0);
 
 	/* The next wait() should report a SIGUSR2 was received. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGUSR2);
 
 	/* Continue the child, changing the signal to USR1. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* The last wait() should report normal exit with code 1. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void *
 raise_sigstop_thread(void *arg __unused)
 {
 
 	raise(SIGSTOP);
 	return NULL;
 }
 
 static void *
 sleep_thread(void *arg __unused)
 {
 
 	sleep(60);
 	return NULL;
 }
 
 static void
 terminate_with_pending_sigstop(bool sigstop_from_main_thread)
 {
 	pid_t fpid, wpid;
 	int status, i;
 	cpuset_t setmask;
 	cpusetid_t setid;
 	pthread_t t;
 
 	/*
 	 * Become the reaper for this process tree. We need to be able to check
 	 * that both child and grandchild have died.
 	 */
 	ATF_REQUIRE(procctl(P_PID, getpid(), PROC_REAP_ACQUIRE, NULL) == 0);
 
 	fpid = fork();
 	ATF_REQUIRE(fpid >= 0);
 	if (fpid == 0) {
 		fpid = fork();
 		CHILD_REQUIRE(fpid >= 0);
 		if (fpid == 0) {
 			trace_me();
 
 			/* Pin to CPU 0 to serialize thread execution. */
 			CPU_ZERO(&setmask);
 			CPU_SET(0, &setmask);
 			CHILD_REQUIRE(cpuset(&setid) == 0);
 			CHILD_REQUIRE(cpuset_setaffinity(CPU_LEVEL_CPUSET,
 			    CPU_WHICH_CPUSET, setid,
 			    sizeof(setmask), &setmask) == 0);
 
 			if (sigstop_from_main_thread) {
 				/*
 				 * We expect the SIGKILL sent when our parent
 				 * dies to be delivered to the new thread.
 				 * Raise the SIGSTOP in this thread so the
 				 * threads compete.
 				 */
 				CHILD_REQUIRE(pthread_create(&t, NULL,
 				    sleep_thread, NULL) == 0);
 				raise(SIGSTOP);
 			} else {
 				/*
 				 * We expect the SIGKILL to be delivered to
 				 * this thread. After creating the new thread,
 				 * just get off the CPU so the other thread can
 				 * raise the SIGSTOP.
 				 */
 				CHILD_REQUIRE(pthread_create(&t, NULL,
 				    raise_sigstop_thread, NULL) == 0);
 				sleep(60);
 			}
 
 			exit(0);
 		}
 		/* First stop is trace_me() immediately after fork. */
 		wpid = waitpid(fpid, &status, 0);
 		CHILD_REQUIRE(wpid == fpid);
 		CHILD_REQUIRE(WIFSTOPPED(status));
 		CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 		CHILD_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 		/* Second stop is from the raise(SIGSTOP). */
 		wpid = waitpid(fpid, &status, 0);
 		CHILD_REQUIRE(wpid == fpid);
 		CHILD_REQUIRE(WIFSTOPPED(status));
 		CHILD_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 		/*
 		 * Terminate tracing process without detaching. Our child
 		 * should be killed.
 		 */
 		exit(0);
 	}
 
 	/*
 	 * We should get a normal exit from our immediate child and a SIGKILL
 	 * exit from our grandchild. The latter case is the interesting one.
 	 * Our grandchild should not have stopped due to the SIGSTOP that was
 	 * left dangling when its parent died.
 	 */
 	for (i = 0; i < 2; ++i) {
 		wpid = wait(&status);
 		if (wpid == fpid)
 			ATF_REQUIRE(WIFEXITED(status) &&
 			    WEXITSTATUS(status) == 0);
 		else
 			ATF_REQUIRE(WIFSIGNALED(status) &&
 			    WTERMSIG(status) == SIGKILL);
 	}
 }
 
 /*
  * These two tests ensure that if the tracing process exits without detaching
  * just after the child received a SIGSTOP, the child is cleanly killed and
  * doesn't go to sleep due to the SIGSTOP. The parent's death will send a
  * SIGKILL to the child. If the SIGKILL and the SIGSTOP are handled by
  * different threads, the SIGKILL must win.  There are two variants of this
  * test, designed to catch the case where the SIGKILL is delivered to the
  * younger thread (the first test) and the case where the SIGKILL is delivered
  * to the older thread (the second test). This behavior has changed in the
  * past, so make no assumption.
  */
 ATF_TC(ptrace__parent_terminate_with_pending_sigstop1);
 ATF_TC_HEAD(ptrace__parent_terminate_with_pending_sigstop1, tc)
 {
 
 	atf_tc_set_md_var(tc, "require.user", "root");
 }
 ATF_TC_BODY(ptrace__parent_terminate_with_pending_sigstop1, tc)
 {
 
 	terminate_with_pending_sigstop(true);
 }
 
 ATF_TC(ptrace__parent_terminate_with_pending_sigstop2);
 ATF_TC_HEAD(ptrace__parent_terminate_with_pending_sigstop2, tc)
 {
 
 	atf_tc_set_md_var(tc, "require.user", "root");
 }
 ATF_TC_BODY(ptrace__parent_terminate_with_pending_sigstop2, tc)
 {
 
 	terminate_with_pending_sigstop(false);
 }
 
 /*
  * Verify that after ptrace() discards a SIGKILL signal, the event mask
  * is not modified.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__event_mask_sigkill_discard);
 ATF_TC_BODY(ptrace__event_mask_sigkill_discard, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status, event_mask, new_event_mask;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		raise(SIGSTOP);
 		exit(0);
 	}
 
 	/* The first wait() should report the stop from trace_me(). */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Set several unobtrusive event bits. */
 	event_mask = PTRACE_EXEC | PTRACE_FORK | PTRACE_LWP;
 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, wpid, (caddr_t)&event_mask,
 	    sizeof(event_mask)) == 0);
 
 	/* Send a SIGKILL without using ptrace. */
 	ATF_REQUIRE(kill(fpid, SIGKILL) == 0);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next stop should be due to the SIGKILL. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGKILL);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGKILL);
 
 	/* Continue the child ignoring the SIGKILL. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Check the current event mask. It should not have changed. */
 	new_event_mask = 0;
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, wpid, (caddr_t)&new_event_mask,
 	    sizeof(new_event_mask)) == 0);
 	ATF_REQUIRE(event_mask == new_event_mask);
 
 	/* Continue the child to let it exit. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 0);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 static void *
 flock_thread(void *arg)
 {
 	int fd;
 
 	fd = *(int *)arg;
 	(void)flock(fd, LOCK_EX);
 	(void)flock(fd, LOCK_UN);
 	return (NULL);
 }
 
 /*
  * Verify that PT_ATTACH will suspend threads sleeping in an SBDRY section.
  * We rely on the fact that the lockf implementation sets SBDRY before blocking
  * on a lock. This is a regression test for r318191.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_ATTACH_with_SBDRY_thread);
 ATF_TC_BODY(ptrace__PT_ATTACH_with_SBDRY_thread, tc)
 {
 	pthread_barrier_t barrier;
 	pthread_barrierattr_t battr;
 	char tmpfile[64];
 	pid_t child, wpid;
 	int error, fd, i, status;
 
 	ATF_REQUIRE(pthread_barrierattr_init(&battr) == 0);
 	ATF_REQUIRE(pthread_barrierattr_setpshared(&battr,
 	    PTHREAD_PROCESS_SHARED) == 0);
 	ATF_REQUIRE(pthread_barrier_init(&barrier, &battr, 2) == 0);
 
 	(void)snprintf(tmpfile, sizeof(tmpfile), "./ptrace.XXXXXX");
 	fd = mkstemp(tmpfile);
 	ATF_REQUIRE(fd >= 0);
 
 	ATF_REQUIRE((child = fork()) != -1);
 	if (child == 0) {
 		pthread_t t[2];
 		int cfd;
 
 		error = pthread_barrier_wait(&barrier);
 		if (error != 0 && error != PTHREAD_BARRIER_SERIAL_THREAD)
 			_exit(1);
 
 		cfd = open(tmpfile, O_RDONLY);
 		if (cfd < 0)
 			_exit(1);
 
 		/*
 		 * We want at least two threads blocked on the file lock since
 		 * the SIGSTOP from PT_ATTACH may kick one of them out of
 		 * sleep.
 		 */
 		if (pthread_create(&t[0], NULL, flock_thread, &cfd) != 0)
 			_exit(1);
 		if (pthread_create(&t[1], NULL, flock_thread, &cfd) != 0)
 			_exit(1);
 		if (pthread_join(t[0], NULL) != 0)
 			_exit(1);
 		if (pthread_join(t[1], NULL) != 0)
 			_exit(1);
 		_exit(0);
 	}
 
 	ATF_REQUIRE(flock(fd, LOCK_EX) == 0);
 
 	error = pthread_barrier_wait(&barrier);
 	ATF_REQUIRE(error == 0 || error == PTHREAD_BARRIER_SERIAL_THREAD);
 
 	/*
 	 * Give the child some time to block. Is there a better way to do this?
 	 */
 	sleep(1);
 
 	/*
 	 * Attach and give the child 3 seconds to stop.
 	 */
 	ATF_REQUIRE(ptrace(PT_ATTACH, child, NULL, 0) == 0);
 	for (i = 0; i < 3; i++) {
 		wpid = waitpid(child, &status, WNOHANG);
 		if (wpid == child && WIFSTOPPED(status) &&
 		    WSTOPSIG(status) == SIGSTOP)
 			break;
 		sleep(1);
 	}
 	ATF_REQUIRE_MSG(i < 3, "failed to stop child process after PT_ATTACH");
 
 	ATF_REQUIRE(ptrace(PT_DETACH, child, NULL, 0) == 0);
 
 	ATF_REQUIRE(flock(fd, LOCK_UN) == 0);
 	ATF_REQUIRE(unlink(tmpfile) == 0);
 	ATF_REQUIRE(close(fd) == 0);
 }
 
 static void
 sigusr1_step_handler(int sig)
 {
 
 	CHILD_REQUIRE(sig == SIGUSR1);
 	raise(SIGABRT);
 }
 
 /*
  * Verify that PT_STEP with a signal invokes the signal before
  * stepping the next instruction (and that the next instruction is
  * stepped correctly).
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_STEP_with_signal);
 ATF_TC_BODY(ptrace__PT_STEP_with_signal, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		signal(SIGUSR1, sigusr1_step_handler);
 		raise(SIGABRT);
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next stop should report the SIGABRT in the child body. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGABRT);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT);
 
 	/* Step the child process inserting SIGUSR1. */
 	ATF_REQUIRE(ptrace(PT_STEP, fpid, (caddr_t)1, SIGUSR1) == 0);
 
 	/* The next stop should report the SIGABRT in the signal handler. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGABRT);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT);
 
 	/* Continue the child process discarding the signal. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next stop should report a trace trap from PT_STEP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP);
 	ATF_REQUIRE(pl.pl_siginfo.si_code == TRAP_TRACE);
 
 	/* Continue the child to let it exit. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 #ifdef HAVE_BREAKPOINT
 /*
  * Verify that a SIGTRAP event with the TRAP_BRKPT code is reported
  * for a breakpoint trap.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__breakpoint_siginfo);
 ATF_TC_BODY(ptrace__breakpoint_siginfo, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		breakpoint();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report hitting the breakpoint. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP);
 	ATF_REQUIRE(pl.pl_siginfo.si_code == TRAP_BRKPT);
 
 	/* Kill the child process. */
 	ATF_REQUIRE(ptrace(PT_KILL, fpid, 0, 0) == 0);
 
 	/* The last wait() should report the SIGKILL. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSIGNALED(status));
 	ATF_REQUIRE(WTERMSIG(status) == SIGKILL);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 #endif /* HAVE_BREAKPOINT */
 
 /*
  * Verify that a SIGTRAP event with the TRAP_TRACE code is reported
  * for a single-step trap from PT_STEP.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__step_siginfo);
 ATF_TC_BODY(ptrace__step_siginfo, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/* Step the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_STEP, fpid, (caddr_t)1, 0) == 0);
 
 	/* The second wait() should report a single-step trap. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP);
 	ATF_REQUIRE(pl.pl_siginfo.si_code == TRAP_TRACE);
 
 	/* Continue the child process. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 #if defined(HAVE_BREAKPOINT) && defined(SKIP_BREAK)
 static void *
 continue_thread(void *arg __unused)
 {
 	breakpoint();
 	return (NULL);
 }
 
 static __dead2 void
 continue_thread_main(void)
 {
 	pthread_t threads[2];
 
 	CHILD_REQUIRE(pthread_create(&threads[0], NULL, continue_thread,
 	    NULL) == 0);
 	CHILD_REQUIRE(pthread_create(&threads[1], NULL, continue_thread,
 	    NULL) == 0);
 	CHILD_REQUIRE(pthread_join(threads[0], NULL) == 0);
 	CHILD_REQUIRE(pthread_join(threads[1], NULL) == 0);
 	exit(1);
 }
 
 /*
  * Ensure that PT_CONTINUE clears the status of the thread that
  * triggered the stop even if a different thread's LWP was passed to
  * PT_CONTINUE.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_CONTINUE_different_thread);
 ATF_TC_BODY(ptrace__PT_CONTINUE_different_thread, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	lwpid_t lwps[2];
 	bool hit_break[2];
 	struct reg reg;
 	int i, j, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		continue_thread_main();
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 	    sizeof(pl)) != -1);
 
 	ATF_REQUIRE(ptrace(PT_LWP_EVENTS, wpid, NULL, 1) == 0);
 
 	/* Continue the child ignoring the SIGSTOP. */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* One of the new threads should report it's birth. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) ==
 	    (PL_FLAG_BORN | PL_FLAG_SCX));
 	lwps[0] = pl.pl_lwpid;
 
 	/*
 	 * Suspend this thread to ensure both threads are alive before
 	 * hitting the breakpoint.
 	 */
 	ATF_REQUIRE(ptrace(PT_SUSPEND, lwps[0], NULL, 0) != -1);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* Second thread should report it's birth. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & (PL_FLAG_BORN | PL_FLAG_SCX)) ==
 	    (PL_FLAG_BORN | PL_FLAG_SCX));
 	ATF_REQUIRE(pl.pl_lwpid != lwps[0]);
 	lwps[1] = pl.pl_lwpid;
 
 	/* Resume both threads waiting for breakpoint events. */
 	hit_break[0] = hit_break[1] = false;
 	ATF_REQUIRE(ptrace(PT_RESUME, lwps[0], NULL, 0) != -1);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* One thread should report a breakpoint. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP &&
 	    pl.pl_siginfo.si_code == TRAP_BRKPT);
 	if (pl.pl_lwpid == lwps[0])
 		i = 0;
 	else
 		i = 1;
 	hit_break[i] = true;
 	ATF_REQUIRE(ptrace(PT_GETREGS, pl.pl_lwpid, (caddr_t)&reg, 0) != -1);
 	SKIP_BREAK(&reg);
 	ATF_REQUIRE(ptrace(PT_SETREGS, pl.pl_lwpid, (caddr_t)&reg, 0) != -1);
 
 	/*
 	 * Resume both threads but pass the other thread's LWPID to
 	 * PT_CONTINUE.
 	 */
 	ATF_REQUIRE(ptrace(PT_CONTINUE, lwps[i ^ 1], (caddr_t)1, 0) == 0);
 
 	/*
 	 * Will now get two thread exit events and one more breakpoint
 	 * event.
 	 */
 	for (j = 0; j < 3; j++) {
 		wpid = waitpid(fpid, &status, 0);
 		ATF_REQUIRE(wpid == fpid);
 		ATF_REQUIRE(WIFSTOPPED(status));
 		ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 		ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl,
 		    sizeof(pl)) != -1);
 		
 		if (pl.pl_lwpid == lwps[0])
 			i = 0;
 		else
 			i = 1;
 
 		ATF_REQUIRE_MSG(lwps[i] != 0, "event for exited thread");
 		if (pl.pl_flags & PL_FLAG_EXITED) {
 			ATF_REQUIRE_MSG(hit_break[i],
 			    "exited thread did not report breakpoint");
 			lwps[i] = 0;
 		} else {
 			ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) != 0);
 			ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGTRAP &&
 			    pl.pl_siginfo.si_code == TRAP_BRKPT);
 			ATF_REQUIRE_MSG(!hit_break[i],
 			    "double breakpoint event");
 			hit_break[i] = true;
 			ATF_REQUIRE(ptrace(PT_GETREGS, pl.pl_lwpid, (caddr_t)&reg,
 			    0) != -1);
 			SKIP_BREAK(&reg);
 			ATF_REQUIRE(ptrace(PT_SETREGS, pl.pl_lwpid, (caddr_t)&reg,
 			    0) != -1);
 		}
 
 		ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 	}
 
 	/* Both threads should have exited. */
 	ATF_REQUIRE(lwps[0] == 0);
 	ATF_REQUIRE(lwps[1] == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 #endif
 
 /*
  * Verify that PT_LWPINFO doesn't return stale siginfo.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__PT_LWPINFO_stale_siginfo);
 ATF_TC_BODY(ptrace__PT_LWPINFO_stale_siginfo, tc)
 {
 	struct ptrace_lwpinfo pl;
 	pid_t fpid, wpid;
 	int events, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		raise(SIGABRT);
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The next stop should report the SIGABRT in the child body. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGABRT);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SI);
 	ATF_REQUIRE(pl.pl_siginfo.si_signo == SIGABRT);
 
 	/*
 	 * Continue the process ignoring the signal, but enabling
 	 * syscall traps.
 	 */
 	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/*
 	 * The next stop should report a system call entry from
 	 * exit().  PL_FLAGS_SI should not be set.
 	 */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 	ATF_REQUIRE((pl.pl_flags & PL_FLAG_SI) == 0);
 
 	/* Disable syscall tracing and continue the child to let it exit. */
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	events &= ~PTRACE_SYSCALL;
 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 /*
- * A simple test of PT_GET_SC_ARGS.
+ * A simple test of PT_GET_SC_ARGS and PT_GET_SC_RET.
  */
 ATF_TC_WITHOUT_HEAD(ptrace__syscall_args);
 ATF_TC_BODY(ptrace__syscall_args, tc)
 {
 	struct ptrace_lwpinfo pl;
+	struct ptrace_sc_ret psr;
 	pid_t fpid, wpid;
 	register_t args[2];
 	int events, status;
 
 	ATF_REQUIRE((fpid = fork()) != -1);
 	if (fpid == 0) {
 		trace_me();
 		kill(getpid(), 0);
+		close(3);
 		exit(1);
 	}
 
 	/* The first wait() should report the stop from SIGSTOP. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGSTOP);
 
 	/*
 	 * Continue the process ignoring the signal, but enabling
-	 * syscall entry traps.
+	 * syscall traps.
 	 */
-	ATF_REQUIRE(ptrace(PT_TO_SCE, fpid, (caddr_t)1, 0) == 0);
+	ATF_REQUIRE(ptrace(PT_SYSCALL, fpid, (caddr_t)1, 0) == 0);
 
 	/*
 	 * The next stop should be the syscall entry from getpid().
 	 */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 	ATF_REQUIRE(pl.pl_syscall_code == SYS_getpid);
 
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/*
+	 * The next stop should be the syscall exit from getpid().
+	 */
+	wpid = waitpid(fpid, &status, 0);
+	ATF_REQUIRE(wpid == fpid);
+	ATF_REQUIRE(WIFSTOPPED(status));
+	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
+
+	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
+	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX);
+	ATF_REQUIRE(pl.pl_syscall_code == SYS_getpid);
+
+	ATF_REQUIRE(ptrace(PT_GET_SC_RET, wpid, (caddr_t)&psr,
+	    sizeof(psr)) != -1);
+	ATF_REQUIRE(psr.sr_error == 0);
+	ATF_REQUIRE(psr.sr_retval[0] == wpid);
+
+	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
+
+	/*
 	 * The next stop should be the syscall entry from kill().
 	 */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(wpid == fpid);
 	ATF_REQUIRE(WIFSTOPPED(status));
 	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
 
 	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
 	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
 	ATF_REQUIRE(pl.pl_syscall_code == SYS_kill);
 	ATF_REQUIRE(pl.pl_syscall_narg == 2);
 
 	ATF_REQUIRE(ptrace(PT_GET_SC_ARGS, wpid, (caddr_t)args,
 	    sizeof(args)) != -1);
 	ATF_REQUIRE(args[0] == wpid);
 	ATF_REQUIRE(args[1] == 0);
+
+	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
+
+	/*
+	 * The next stop should be the syscall exit from kill().
+	 */
+	wpid = waitpid(fpid, &status, 0);
+	ATF_REQUIRE(wpid == fpid);
+	ATF_REQUIRE(WIFSTOPPED(status));
+	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
+
+	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
+	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX);
+	ATF_REQUIRE(pl.pl_syscall_code == SYS_kill);
+
+	ATF_REQUIRE(ptrace(PT_GET_SC_RET, wpid, (caddr_t)&psr,
+	    sizeof(psr)) != -1);
+	ATF_REQUIRE(psr.sr_error == 0);
+
+	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
+
+	/*
+	 * The next stop should be the syscall entry from close().
+	 */
+	wpid = waitpid(fpid, &status, 0);
+	ATF_REQUIRE(wpid == fpid);
+	ATF_REQUIRE(WIFSTOPPED(status));
+	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
+
+	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
+	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCE);
+	ATF_REQUIRE(pl.pl_syscall_code == SYS_close);
+	ATF_REQUIRE(pl.pl_syscall_narg == 1);
+
+	ATF_REQUIRE(ptrace(PT_GET_SC_ARGS, wpid, (caddr_t)args,
+	    sizeof(args)) != -1);
+	ATF_REQUIRE(args[0] == 3);
+
+	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
+
+	/*
+	 * The next stop should be the syscall exit from close().
+	 */
+	wpid = waitpid(fpid, &status, 0);
+	ATF_REQUIRE(wpid == fpid);
+	ATF_REQUIRE(WIFSTOPPED(status));
+	ATF_REQUIRE(WSTOPSIG(status) == SIGTRAP);
+
+	ATF_REQUIRE(ptrace(PT_LWPINFO, wpid, (caddr_t)&pl, sizeof(pl)) != -1);
+	ATF_REQUIRE(pl.pl_flags & PL_FLAG_SCX);
+	ATF_REQUIRE(pl.pl_syscall_code == SYS_close);
+
+	ATF_REQUIRE(ptrace(PT_GET_SC_RET, wpid, (caddr_t)&psr,
+	    sizeof(psr)) != -1);
+	ATF_REQUIRE(psr.sr_error == EBADF);
 
 	/* Disable syscall tracing and continue the child to let it exit. */
 	ATF_REQUIRE(ptrace(PT_GET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	events &= ~PTRACE_SYSCALL;
 	ATF_REQUIRE(ptrace(PT_SET_EVENT_MASK, fpid, (caddr_t)&events,
 	    sizeof(events)) == 0);
 	ATF_REQUIRE(ptrace(PT_CONTINUE, fpid, (caddr_t)1, 0) == 0);
 
 	/* The last event should be for the child process's exit. */
 	wpid = waitpid(fpid, &status, 0);
 	ATF_REQUIRE(WIFEXITED(status));
 	ATF_REQUIRE(WEXITSTATUS(status) == 1);
 
 	wpid = wait(&status);
 	ATF_REQUIRE(wpid == -1);
 	ATF_REQUIRE(errno == ECHILD);
 }
 
 ATF_TP_ADD_TCS(tp)
 {
 
 	ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_trace_me);
 	ATF_TP_ADD_TC(tp, ptrace__parent_wait_after_attach);
 	ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_child_debugger);
 	ATF_TP_ADD_TC(tp, ptrace__parent_sees_exit_after_unrelated_debugger);
 	ATF_TP_ADD_TC(tp, ptrace__parent_exits_before_child);
 	ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached);
 	ATF_TP_ADD_TC(tp, ptrace__follow_fork_child_detached);
 	ATF_TP_ADD_TC(tp, ptrace__follow_fork_parent_detached);
 	ATF_TP_ADD_TC(tp, ptrace__follow_fork_both_attached_unrelated_debugger);
 	ATF_TP_ADD_TC(tp,
 	    ptrace__follow_fork_child_detached_unrelated_debugger);
 	ATF_TP_ADD_TC(tp,
 	    ptrace__follow_fork_parent_detached_unrelated_debugger);
 	ATF_TP_ADD_TC(tp, ptrace__getppid);
 	ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_fork);
 	ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_vfork);
 	ATF_TP_ADD_TC(tp, ptrace__new_child_pl_syscall_code_thread);
 	ATF_TP_ADD_TC(tp, ptrace__lwp_events);
 	ATF_TP_ADD_TC(tp, ptrace__lwp_events_exec);
 	ATF_TP_ADD_TC(tp, ptrace__siginfo);
 	ATF_TP_ADD_TC(tp, ptrace__ptrace_exec_disable);
 	ATF_TP_ADD_TC(tp, ptrace__ptrace_exec_enable);
 	ATF_TP_ADD_TC(tp, ptrace__event_mask);
 	ATF_TP_ADD_TC(tp, ptrace__ptrace_vfork);
 	ATF_TP_ADD_TC(tp, ptrace__ptrace_vfork_follow);
 #ifdef HAVE_BREAKPOINT
 	ATF_TP_ADD_TC(tp, ptrace__PT_KILL_breakpoint);
 #endif
 	ATF_TP_ADD_TC(tp, ptrace__PT_KILL_system_call);
 	ATF_TP_ADD_TC(tp, ptrace__PT_KILL_threads);
 	ATF_TP_ADD_TC(tp, ptrace__PT_KILL_competing_signal);
 	ATF_TP_ADD_TC(tp, ptrace__PT_KILL_competing_stop);
 	ATF_TP_ADD_TC(tp, ptrace__PT_KILL_with_signal_full_sigqueue);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_system_call_entry);
 	ATF_TP_ADD_TC(tp,
 	    ptrace__PT_CONTINUE_with_signal_system_call_entry_and_exit);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_full_sigqueue);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_masked_full_sigqueue);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_change_sig);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_sigtrap_system_call_entry);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_mix);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_kqueue);
 	ATF_TP_ADD_TC(tp, ptrace__killed_with_sigmask);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_sigmask);
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_with_signal_thread_sigmask);
 	ATF_TP_ADD_TC(tp, ptrace__parent_terminate_with_pending_sigstop1);
 	ATF_TP_ADD_TC(tp, ptrace__parent_terminate_with_pending_sigstop2);
 	ATF_TP_ADD_TC(tp, ptrace__event_mask_sigkill_discard);
 	ATF_TP_ADD_TC(tp, ptrace__PT_ATTACH_with_SBDRY_thread);
 	ATF_TP_ADD_TC(tp, ptrace__PT_STEP_with_signal);
 #ifdef HAVE_BREAKPOINT
 	ATF_TP_ADD_TC(tp, ptrace__breakpoint_siginfo);
 #endif
 	ATF_TP_ADD_TC(tp, ptrace__step_siginfo);
 #if defined(HAVE_BREAKPOINT) && defined(SKIP_BREAK)
 	ATF_TP_ADD_TC(tp, ptrace__PT_CONTINUE_different_thread);
 #endif
 	ATF_TP_ADD_TC(tp, ptrace__PT_LWPINFO_stale_siginfo);
 	ATF_TP_ADD_TC(tp, ptrace__syscall_args);
 
 	return (atf_no_error());
 }