diff --git a/lib/libc/gen/exterr_cat_filenames.h b/lib/libc/gen/exterr_cat_filenames.h
--- a/lib/libc/gen/exterr_cat_filenames.h
+++ b/lib/libc/gen/exterr_cat_filenames.h
@@ -8,6 +8,8 @@
 	[EXTERR_CAT_GEOM] = "geom/geom_subr.c",
 	[EXTERR_CAT_GEOMVFS] = "geom/geom_vfs.c",
 	[EXTERR_CAT_FILEDESC] = "kern/kern_descrip.c",
+	[EXTERR_CAT_PROCEXIT] = "kern/kern_exit.c",
+	[EXTERR_CAT_FORK] = "kern/kern_fork.c",
 	[EXTERR_CAT_GENIO] = "kern/sys_generic.c",
 	[EXTERR_CAT_VFSBIO] = "kern/vfs_bio.c",
 	[EXTERR_CAT_INOTIFY] = "kern/vfs_inotify.c",
diff --git a/lib/libsys/Makefile.sys b/lib/libsys/Makefile.sys
--- a/lib/libsys/Makefile.sys
+++ b/lib/libsys/Makefile.sys
@@ -495,8 +495,10 @@
 MLINKS+=open.2 openat.2
 MLINKS+=pathconf.2 fpathconf.2
 MLINKS+=pathconf.2 lpathconf.2
-MLINKS+=pdfork.2 pdgetpid.2\
-	pdfork.2 pdkill.2
+MLINKS+=pdfork.2 pdgetpid.2 \
+	pdfork.2 pdkill.2 \
+	pdfork.2 pdrfork.2 \
+	pdfork.2 pdwait.2
 MLINKS+=pipe.2 pipe2.2
 MLINKS+=poll.2 ppoll.2
 MLINKS+=rctl_add_rule.2 rctl_get_limits.2 \
diff --git a/lib/libsys/Symbol.sys.map b/lib/libsys/Symbol.sys.map
--- a/lib/libsys/Symbol.sys.map
+++ b/lib/libsys/Symbol.sys.map
@@ -389,6 +389,11 @@
 	setgroups;
 };
 
+FBSD_1.9 {
+	pdrfork;
+	pdwait;
+};
+
 FBSDprivate_1.0 {
 	/* Add entries in sort(1) order */
 	__set_error_selector;
diff --git a/lib/libsys/_libsys.h b/lib/libsys/_libsys.h
--- a/lib/libsys/_libsys.h
+++ b/lib/libsys/_libsys.h
@@ -472,6 +472,8 @@
 typedef int (__sys_jail_attach_jd_t)(int);
 typedef int (__sys_jail_remove_jd_t)(int);
 typedef int (__sys_kexec_load_t)(uint64_t, u_long, struct kexec_segment *, u_long);
+typedef int (__sys_pdrfork_t)(int *, int, int);
+typedef int (__sys_pdwait_t)(int, int *, int, struct __wrusage *, struct __siginfo *);
 
 _Noreturn void __sys__exit(int rval);
 int __sys_fork(void);
@@ -879,6 +881,8 @@
 int __sys_jail_attach_jd(int fd);
 int __sys_jail_remove_jd(int fd);
 int __sys_kexec_load(uint64_t entry, u_long nseg, struct kexec_segment * segments, u_long flags);
+int __sys_pdrfork(int * fdp, int pdflags, int rfflags);
+int __sys_pdwait(int fd, int * status, int options, struct __wrusage * wrusage, struct __siginfo * info);
 __END_DECLS
 
 #endif /* __LIBSYS_H_ */
diff --git a/lib/libsys/pdfork.2 b/lib/libsys/pdfork.2
--- a/lib/libsys/pdfork.2
+++ b/lib/libsys/pdfork.2
@@ -30,24 +30,36 @@
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
-.Dd October 14, 2018
+.Dd January 20, 2026
 .Dt PDFORK 2
 .Os
 .Sh NAME
 .Nm pdfork ,
+.Nm pdrfork ,
 .Nm pdgetpid ,
-.Nm pdkill
+.Nm pdkill ,
+.Nm pdwait
 .Nd System calls to manage process descriptors
 .Sh LIBRARY
 .Lb libc
 .Sh SYNOPSIS
 .In sys/procdesc.h
 .Ft pid_t
-.Fn pdfork "int *fdp" "int flags"
+.Fn pdfork "int *fdp" "int pdflags"
+.Ft pid_t
+.Fn pdrfork "int *fdp" "int pdflags" "int rfflags"
 .Ft int
 .Fn pdgetpid "int fd" "pid_t *pidp"
 .Ft int
 .Fn pdkill "int fd" "int signum"
+.Ft int
+.Fo pdwait
+.Fa "int fd"
+.Fa "int *status"
+.Fa "int options"
+.Fa "struct __wrusage *wrusage"
+.Fa "struct __siginfo *info"
+.Fc
 .Sh DESCRIPTION
 Process descriptors are special file descriptors that represent processes,
 and are created using
@@ -63,8 +75,9 @@
 .Dv SIGCHLD
 on termination.
 .Fn pdfork
-can accept the flags:
-.Bl -tag -width ".Dv PD_DAEMON"
+can accept the
+.Fa pdflags:
+.Bl -tag -width PD_CLOEXEC
 .It Dv PD_DAEMON
 Instead of the default terminate-on-close behaviour, allow the process to
 live until it is explicitly killed with
@@ -80,6 +93,33 @@
 Set close-on-exec on process descriptor.
 .El
 .Pp
+The
+.Fn pdrfork
+system call is a variant of
+.Fn pdfork
+that also takes the
+.Fa rfflags
+argument to control sharing of process resources between the caller
+and the new process.
+Like
+.Fn pdfork ,
+the function writes the process descriptor referencing the created
+process into the location pointed to by the
+.Fa fdp
+argument.
+See
+.Xr rfork 2
+for a description of the possible
+.Fa rfflag
+flags.
+The
+.Fn pdrfork
+requires that the
+.Va RFPROC
+or
+.Va RFSPAWN
+flag is specified.
+.Pp
 .Fn pdgetpid
 queries the process ID (PID) in the process descriptor
 .Fa fd .
@@ -91,6 +131,16 @@
 .Fa fd ,
 rather than a PID.
 .Pp
+The
+.Fn pdwait
+function allows the calling thread to wait and retrieve the status information
+on the process referenced by the
+.Fa fd
+process descriptor.
+See the description of the
+.Xr wait6
+system call for the behavior specification.
+.Pp
 The following system calls also have effects specific to process descriptors:
 .Pp
 .Xr fstat 2
@@ -126,15 +176,24 @@
 the last reference to the process descriptor, the process will be terminated
 with the signal
 .Dv SIGKILL .
+The PID of the referenced process is not reused until the process
+descriptor is closed,
+whether or not the zombie process is reaped by
+Fn pdwait ,
+Xr wait6 ,
+or similar system calls.
 .Sh RETURN VALUES
 .Fn pdfork
-returns a PID, 0 or -1, as
+and
+.Fn pdrfork
+return a PID, 0 or -1, as
 .Xr fork 2
 does.
 .Pp
-.Fn pdgetpid
+.Fn pdgetpid ,
+.Fn pdkill ,
 and
-.Fn pdkill
+.Fn pdwait
 return 0 on success and -1 on failure.
 .Sh ERRORS
 These functions may return the same error numbers as their PID-based equivalents
@@ -172,6 +231,12 @@
 .Fn pdkill
 system calls first appeared in
 .Fx 9.0 .
+The
+.Fn pdrfork
+and
+.Fn pdwait
+system calls first appeared in
+.Fx 16.0 .
 .Pp
 Support for process descriptors mode was developed as part of the
 .Tn TrustedBSD
@@ -184,3 +249,11 @@
 .An Jonathan Anderson Aq Mt jonathan@FreeBSD.org
 at the University of Cambridge Computer Laboratory with support from a grant
 from Google, Inc.
+The
+.Fn pdrfork
+and
+.Fn pdwait
+functions were developed by
+.An Konstantin Belousov Aq Mt kib@FreeBSD.org
+with input from
+.An Alan Somers Aq Mt asomers@FreeBSD.org .
diff --git a/lib/libsys/rfork.2 b/lib/libsys/rfork.2
--- a/lib/libsys/rfork.2
+++ b/lib/libsys/rfork.2
@@ -194,6 +194,7 @@
 .Xr fork 2 ,
 .Xr intro 2 ,
 .Xr minherit 2 ,
+.Xr pdrfork 2 ,
 .Xr vfork 2 ,
 .Xr pthread_create 3 ,
 .Xr rfork_thread 3
diff --git a/lib/libsys/syscalls.map b/lib/libsys/syscalls.map
--- a/lib/libsys/syscalls.map
+++ b/lib/libsys/syscalls.map
@@ -819,4 +819,8 @@
 	__sys_jail_remove_jd;
 	_kexec_load;
 	__sys_kexec_load;
+	_pdrfork;
+	__sys_pdrfork;
+	_pdwait;
+	__sys_pdwait;
 };
diff --git a/lib/libsys/wait.2 b/lib/libsys/wait.2
--- a/lib/libsys/wait.2
+++ b/lib/libsys/wait.2
@@ -656,6 +656,7 @@
 .El
 .Sh SEE ALSO
 .Xr _exit 2 ,
+.Xr pdwait 2 ,
 .Xr procctl 2 ,
 .Xr ptrace 2 ,
 .Xr sigaction 2 ,
diff --git a/sys/bsm/audit_kevents.h b/sys/bsm/audit_kevents.h
--- a/sys/bsm/audit_kevents.h
+++ b/sys/bsm/audit_kevents.h
@@ -664,6 +664,7 @@
 #define	AUE_TIMERFD		43270	/* FreeBSD/Linux. */
 #define	AUE_SETCRED		43271	/* FreeBSD-specific. */
 #define	AUE_INOTIFY		43272	/* FreeBSD/Linux. */
+#define	AUE_PDRFORK		43273	/* FreeBSD-specific. */
 
 /*
  * Darwin BSM uses a number of AUE_O_* definitions, which are aliased to the
diff --git a/sys/compat/freebsd32/freebsd32_misc.c b/sys/compat/freebsd32/freebsd32_misc.c
--- a/sys/compat/freebsd32/freebsd32_misc.c
+++ b/sys/compat/freebsd32/freebsd32_misc.c
@@ -280,6 +280,37 @@
 	return (error);
 }
 
+int
+freebsd32_pdwait(struct thread *td, struct freebsd32_pdwait_args *uap)
+{
+	struct __wrusage32 wru32;
+	struct __wrusage wru, *wrup;
+	struct __siginfo32 si32;
+	struct __siginfo si, *sip;
+	int error, status;
+
+	wrup = uap->wrusage != NULL ? &wru : NULL;
+	if (uap->info != NULL) {
+		sip = &si;
+		bzero(sip, sizeof(*sip));
+	} else {
+		sip = NULL;
+	}
+	error = kern_pdwait(td, uap->fd, &status, uap->options, wrup, sip);
+	if (uap->status != NULL && error == 0)
+		error = copyout(&status, uap->status, sizeof(status));
+	if (uap->wrusage != NULL && error == 0) {
+		freebsd32_rusage_out(&wru.wru_self, &wru32.wru_self);
+		freebsd32_rusage_out(&wru.wru_children, &wru32.wru_children);
+		error = copyout(&wru32, uap->wrusage, sizeof(wru32));
+	}
+	if (uap->info != NULL && error == 0) {
+		siginfo_to_siginfo32 (&si, &si32);
+		error = copyout(&si32, uap->info, sizeof(si32));
+	}
+	return (error);
+}
+
 #ifdef COMPAT_FREEBSD4
 static void
 copy_statfs(struct statfs *in, struct ostatfs32 *out)
diff --git a/sys/compat/freebsd32/freebsd32_proto.h b/sys/compat/freebsd32/freebsd32_proto.h
--- a/sys/compat/freebsd32/freebsd32_proto.h
+++ b/sys/compat/freebsd32/freebsd32_proto.h
@@ -699,6 +699,13 @@
 	char wcred_l_[PADL_(const struct setcred32 *)]; const struct setcred32 * wcred; char wcred_r_[PADR_(const struct setcred32 *)];
 	char size_l_[PADL_(size_t)]; size_t size; char size_r_[PADR_(size_t)];
 };
+struct freebsd32_pdwait_args {
+	char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
+	char status_l_[PADL_(int *)]; int * status; char status_r_[PADR_(int *)];
+	char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)];
+	char wrusage_l_[PADL_(struct __wrusage32 *)]; struct __wrusage32 * wrusage; char wrusage_r_[PADR_(struct __wrusage32 *)];
+	char info_l_[PADL_(struct __siginfo32 *)]; struct __siginfo32 * info; char info_r_[PADR_(struct __siginfo32 *)];
+};
 int	freebsd32_wait4(struct thread *, struct freebsd32_wait4_args *);
 int	freebsd32_ptrace(struct thread *, struct freebsd32_ptrace_args *);
 int	freebsd32_recvmsg(struct thread *, struct freebsd32_recvmsg_args *);
@@ -817,6 +824,7 @@
 int	freebsd32_timerfd_gettime(struct thread *, struct freebsd32_timerfd_gettime_args *);
 int	freebsd32_timerfd_settime(struct thread *, struct freebsd32_timerfd_settime_args *);
 int	freebsd32_setcred(struct thread *, struct freebsd32_setcred_args *);
+int	freebsd32_pdwait(struct thread *, struct freebsd32_pdwait_args *);
 
 #ifdef COMPAT_43
 
@@ -1319,6 +1327,7 @@
 #define	FREEBSD32_SYS_AUE_freebsd32_timerfd_gettime	AUE_TIMERFD
 #define	FREEBSD32_SYS_AUE_freebsd32_timerfd_settime	AUE_TIMERFD
 #define	FREEBSD32_SYS_AUE_freebsd32_setcred	AUE_SETCRED
+#define	FREEBSD32_SYS_AUE_freebsd32_pdwait	AUE_PDWAIT
 
 #undef PAD_
 #undef PADL_
diff --git a/sys/compat/freebsd32/freebsd32_syscall.h b/sys/compat/freebsd32/freebsd32_syscall.h
--- a/sys/compat/freebsd32/freebsd32_syscall.h
+++ b/sys/compat/freebsd32/freebsd32_syscall.h
@@ -517,4 +517,6 @@
 #define	FREEBSD32_SYS_setgroups	596
 #define	FREEBSD32_SYS_jail_attach_jd	597
 #define	FREEBSD32_SYS_jail_remove_jd	598
-#define	FREEBSD32_SYS_MAXSYSCALL	600
+#define	FREEBSD32_SYS_pdrfork	600
+#define	FREEBSD32_SYS_freebsd32_pdwait	601
+#define	FREEBSD32_SYS_MAXSYSCALL	602
diff --git a/sys/compat/freebsd32/freebsd32_syscalls.c b/sys/compat/freebsd32/freebsd32_syscalls.c
--- a/sys/compat/freebsd32/freebsd32_syscalls.c
+++ b/sys/compat/freebsd32/freebsd32_syscalls.c
@@ -605,4 +605,6 @@
 	"jail_attach_jd",			/* 597 = jail_attach_jd */
 	"jail_remove_jd",			/* 598 = jail_remove_jd */
 	"#599",			/* 599 = kexec_load */
+	"pdrfork",			/* 600 = pdrfork */
+	"freebsd32_pdwait",			/* 601 = freebsd32_pdwait */
 };
diff --git a/sys/compat/freebsd32/freebsd32_sysent.c b/sys/compat/freebsd32/freebsd32_sysent.c
--- a/sys/compat/freebsd32/freebsd32_sysent.c
+++ b/sys/compat/freebsd32/freebsd32_sysent.c
@@ -667,4 +667,6 @@
 	{ .sy_narg = AS(jail_attach_jd_args), .sy_call = (sy_call_t *)sys_jail_attach_jd, .sy_auevent = AUE_JAIL_ATTACH, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC },	/* 597 = jail_attach_jd */
 	{ .sy_narg = AS(jail_remove_jd_args), .sy_call = (sy_call_t *)sys_jail_remove_jd, .sy_auevent = AUE_JAIL_REMOVE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC },	/* 598 = jail_remove_jd */
 	{ .sy_narg = 0, .sy_call = (sy_call_t *)nosys, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_ABSENT },	/* 599 = freebsd32_kexec_load */
+	{ .sy_narg = AS(pdrfork_args), .sy_call = (sy_call_t *)sys_pdrfork, .sy_auevent = AUE_PDRFORK, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC },	/* 600 = pdrfork */
+	{ .sy_narg = AS(freebsd32_pdwait_args), .sy_call = (sy_call_t *)freebsd32_pdwait, .sy_auevent = AUE_PDWAIT, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC },	/* 601 = freebsd32_pdwait */
 };
diff --git a/sys/compat/freebsd32/freebsd32_systrace_args.c b/sys/compat/freebsd32/freebsd32_systrace_args.c
--- a/sys/compat/freebsd32/freebsd32_systrace_args.c
+++ b/sys/compat/freebsd32/freebsd32_systrace_args.c
@@ -3427,6 +3427,26 @@
 		*n_args = 1;
 		break;
 	}
+	/* pdrfork */
+	case 600: {
+		struct pdrfork_args *p = params;
+		uarg[a++] = (intptr_t)p->fdp; /* int * */
+		iarg[a++] = p->pdflags; /* int */
+		iarg[a++] = p->rfflags; /* int */
+		*n_args = 3;
+		break;
+	}
+	/* freebsd32_pdwait */
+	case 601: {
+		struct freebsd32_pdwait_args *p = params;
+		iarg[a++] = p->fd; /* int */
+		uarg[a++] = (intptr_t)p->status; /* int * */
+		iarg[a++] = p->options; /* int */
+		uarg[a++] = (intptr_t)p->wrusage; /* struct __wrusage32 * */
+		uarg[a++] = (intptr_t)p->info; /* struct __siginfo32 * */
+		*n_args = 5;
+		break;
+	}
 	default:
 		*n_args = 0;
 		break;
@@ -9256,6 +9276,44 @@
 			break;
 		};
 		break;
+	/* pdrfork */
+	case 600:
+		switch (ndx) {
+		case 0:
+			p = "userland int *";
+			break;
+		case 1:
+			p = "int";
+			break;
+		case 2:
+			p = "int";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* freebsd32_pdwait */
+	case 601:
+		switch (ndx) {
+		case 0:
+			p = "int";
+			break;
+		case 1:
+			p = "userland int *";
+			break;
+		case 2:
+			p = "int";
+			break;
+		case 3:
+			p = "userland struct __wrusage32 *";
+			break;
+		case 4:
+			p = "userland struct __siginfo32 *";
+			break;
+		default:
+			break;
+		};
+		break;
 	default:
 		break;
 	};
@@ -11174,6 +11232,16 @@
 		if (ndx == 0 || ndx == 1)
 			p = "int";
 		break;
+	/* pdrfork */
+	case 600:
+		if (ndx == 0 || ndx == 1)
+			p = "int";
+		break;
+	/* freebsd32_pdwait */
+	case 601:
+		if (ndx == 0 || ndx == 1)
+			p = "int";
+		break;
 	default:
 		break;
 	};
diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c
--- a/sys/kern/init_sysent.c
+++ b/sys/kern/init_sysent.c
@@ -666,4 +666,6 @@
 	{ .sy_narg = AS(jail_attach_jd_args), .sy_call = (sy_call_t *)sys_jail_attach_jd, .sy_auevent = AUE_JAIL_ATTACH, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC },	/* 597 = jail_attach_jd */
 	{ .sy_narg = AS(jail_remove_jd_args), .sy_call = (sy_call_t *)sys_jail_remove_jd, .sy_auevent = AUE_JAIL_REMOVE, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC },	/* 598 = jail_remove_jd */
 	{ .sy_narg = AS(kexec_load_args), .sy_call = (sy_call_t *)sys_kexec_load, .sy_auevent = AUE_NULL, .sy_flags = 0, .sy_thrcnt = SY_THR_STATIC },	/* 599 = kexec_load */
+	{ .sy_narg = AS(pdrfork_args), .sy_call = (sy_call_t *)sys_pdrfork, .sy_auevent = AUE_PDRFORK, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC },	/* 600 = pdrfork */
+	{ .sy_narg = AS(pdwait_args), .sy_call = (sy_call_t *)sys_pdwait, .sy_auevent = AUE_PDWAIT, .sy_flags = SYF_CAPENABLED, .sy_thrcnt = SY_THR_STATIC },	/* 601 = pdwait */
 };
diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c
--- a/sys/kern/kern_exit.c
+++ b/sys/kern/kern_exit.c
@@ -34,45 +34,45 @@
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
 #include "opt_ddb.h"
 #include "opt_ktrace.h"
 
-#include <sys/param.h>
+#define EXTERR_CATEGORY	EXTERR_CAT_PROCEXIT
 #include <sys/systm.h>
-#include <sys/sysproto.h>
+#include <sys/acct.h>		/* for acct_process() function prototype */
 #include <sys/capsicum.h>
 #include <sys/eventhandler.h>
+#include <sys/exterrvar.h>
+#include <sys/filedesc.h>
+#include <sys/jail.h>
 #include <sys/kernel.h>
 #include <sys/ktr.h>
-#include <sys/malloc.h>
 #include <sys/lock.h>
+#include <sys/malloc.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/procdesc.h>
-#include <sys/jail.h>
-#include <sys/tty.h>
-#include <sys/wait.h>
-#include <sys/vmmeter.h>
-#include <sys/vnode.h>
+#include <sys/ptrace.h>
 #include <sys/racct.h>
 #include <sys/resourcevar.h>
 #include <sys/sbuf.h>
-#include <sys/signalvar.h>
 #include <sys/sched.h>
+#include <sys/sdt.h>
+#include <sys/sem.h>
+#include <sys/shm.h>
+#include <sys/signalvar.h>
 #include <sys/sx.h>
 #include <sys/syscallsubr.h>
 #include <sys/sysctl.h>
-#include <sys/syslog.h>
-#include <sys/ptrace.h>
-#include <sys/acct.h>		/* for acct_process() function prototype */
-#include <sys/filedesc.h>
-#include <sys/sdt.h>
-#include <sys/shm.h>
-#include <sys/sem.h>
 #include <sys/sysent.h>
+#include <sys/syslog.h>
+#include <sys/sysproto.h>
 #include <sys/timers.h>
+#include <sys/tty.h>
 #include <sys/umtxvar.h>
+#include <sys/vmmeter.h>
+#include <sys/vnode.h>
+#include <sys/wait.h>
 #ifdef KTRACE
 #include <sys/ktrace.h>
 #endif
@@ -906,6 +906,33 @@
 	return (error);
 }
 
+int
+sys_pdwait(struct thread *td, struct pdwait_args *uap)
+{
+	struct __wrusage wru, *wrup;
+	siginfo_t si, *sip;
+	int error, status;
+
+	wrup = uap->wrusage != NULL ? &wru : NULL;
+
+	if (uap->info != NULL) {
+		sip = &si;
+		bzero(sip, sizeof(*sip));
+	} else {
+		sip = NULL;
+	}
+
+	error = kern_pdwait(td, uap->fd, &status, uap->options, wrup, sip);
+
+	if (uap->status != NULL && error == 0)
+		error = copyout(&status, uap->status, sizeof(status));
+	if (uap->wrusage != NULL && error == 0)
+		error = copyout(&wru, uap->wrusage, sizeof(wru));
+	if (uap->info != NULL && error == 0)
+		error = copyout(&si, uap->info, sizeof(si));
+	return (error);
+}
+
 /*
  * Reap the remains of a zombie process and optionally return status and
  * rusage.  Asserts and will release both the proctree_lock and the process
@@ -924,9 +951,9 @@
 
 	q = td->td_proc;
 
-	if (status)
+	if (status != NULL)
 		*status = KW_EXITCODE(p->p_xexit, p->p_xsig);
-	if (options & WNOWAIT) {
+	if ((options & WNOWAIT) != 0) {
 		/*
 		 *  Only poll, returning the status.  Caller does not wish to
 		 * release the proc struct just yet.
@@ -979,10 +1006,10 @@
 	leavepgrp(p);
 	if (p->p_procdesc != NULL)
 		procdesc_reap(p);
+	else
+		proc_id_clear(PROC_ID_PID, p->p_pid);
 	sx_xunlock(&proctree_lock);
 
-	proc_id_clear(PROC_ID_PID, p->p_pid);
-
 	PROC_LOCK(p);
 	knlist_detach(p->p_klist);
 	p->p_klist = NULL;
@@ -1042,13 +1069,75 @@
 	atomic_add_int(&nprocs, -1);
 }
 
+static void
+wait_fill_siginfo(struct proc *p, siginfo_t *siginfo)
+{
+	PROC_LOCK_ASSERT(p, MA_OWNED);
+
+	if (siginfo == NULL)
+		return;
+
+	bzero(siginfo, sizeof(*siginfo));
+	siginfo->si_errno = 0;
+
+	/*
+	 * SUSv4 requires that the si_signo value is always
+	 * SIGCHLD. Obey it despite the rfork(2) interface allows to
+	 * request other signal for child exit notification.
+	 */
+	siginfo->si_signo = SIGCHLD;
+
+	/*
+	 *  This is still a rough estimate.  We will fix the cases
+	 *  TRAPPED, STOPPED, and CONTINUED later.
+	 */
+	if (WCOREDUMP(p->p_xsig)) {
+		siginfo->si_code = CLD_DUMPED;
+		siginfo->si_status = WTERMSIG(p->p_xsig);
+	} else if (WIFSIGNALED(p->p_xsig)) {
+		siginfo->si_code = CLD_KILLED;
+		siginfo->si_status = WTERMSIG(p->p_xsig);
+	} else {
+		siginfo->si_code = CLD_EXITED;
+		siginfo->si_status = p->p_xexit;
+	}
+
+	siginfo->si_pid = p->p_pid;
+	siginfo->si_uid = p->p_ucred->cr_uid;
+
+	/*
+	 * The si_addr field would be useful additional detail, but
+	 * apparently the PC value may be lost when we reach this
+	 * point.  bzero() above sets siginfo->si_addr to NULL.
+	 */
+}
+
+static void
+wait_fill_wrusage(struct proc *p, struct __wrusage *wrusage)
+{
+	struct rusage *rup;
+
+	PROC_LOCK_ASSERT(p, MA_OWNED);
+
+	if (wrusage == NULL)
+		return;
+
+	rup = &wrusage->wru_self;
+	*rup = p->p_ru;
+	PROC_STATLOCK(p);
+	calcru(p, &rup->ru_utime, &rup->ru_stime);
+	PROC_STATUNLOCK(p);
+
+	rup = &wrusage->wru_children;
+	*rup = p->p_stats->p_cru;
+	calccru(p, &rup->ru_utime, &rup->ru_stime);
+}
+
 static int
 proc_to_reap(struct thread *td, struct proc *p, idtype_t idtype, id_t id,
     int *status, int options, struct __wrusage *wrusage, siginfo_t *siginfo,
     int check_only)
 {
-	struct rusage *rup;
-
 	sx_assert(&proctree_lock, SA_XLOCKED);
 
 	PROC_LOCK(p);
@@ -1114,7 +1203,7 @@
 		return (0);
 	}
 
-	if (((options & WEXITED) == 0) && (p->p_state == PRS_ZOMBIE)) {
+	if ((options & WEXITED) == 0 && p->p_state == PRS_ZOMBIE) {
 		PROC_UNLOCK(p);
 		return (0);
 	}
@@ -1133,60 +1222,14 @@
 		return (0);
 	}
 
-	if (siginfo != NULL) {
-		bzero(siginfo, sizeof(*siginfo));
-		siginfo->si_errno = 0;
-
-		/*
-		 * SUSv4 requires that the si_signo value is always
-		 * SIGCHLD. Obey it despite the rfork(2) interface
-		 * allows to request other signal for child exit
-		 * notification.
-		 */
-		siginfo->si_signo = SIGCHLD;
-
-		/*
-		 *  This is still a rough estimate.  We will fix the
-		 *  cases TRAPPED, STOPPED, and CONTINUED later.
-		 */
-		if (WCOREDUMP(p->p_xsig)) {
-			siginfo->si_code = CLD_DUMPED;
-			siginfo->si_status = WTERMSIG(p->p_xsig);
-		} else if (WIFSIGNALED(p->p_xsig)) {
-			siginfo->si_code = CLD_KILLED;
-			siginfo->si_status = WTERMSIG(p->p_xsig);
-		} else {
-			siginfo->si_code = CLD_EXITED;
-			siginfo->si_status = p->p_xexit;
-		}
-
-		siginfo->si_pid = p->p_pid;
-		siginfo->si_uid = p->p_ucred->cr_uid;
-
-		/*
-		 * The si_addr field would be useful additional
-		 * detail, but apparently the PC value may be lost
-		 * when we reach this point.  bzero() above sets
-		 * siginfo->si_addr to NULL.
-		 */
-	}
+	wait_fill_siginfo(p, siginfo);
 
 	/*
 	 * There should be no reason to limit resources usage info to
 	 * exited processes only.  A snapshot about any resources used
 	 * by a stopped process may be exactly what is needed.
 	 */
-	if (wrusage != NULL) {
-		rup = &wrusage->wru_self;
-		*rup = p->p_ru;
-		PROC_STATLOCK(p);
-		calcru(p, &rup->ru_utime, &rup->ru_stime);
-		PROC_STATUNLOCK(p);
-
-		rup = &wrusage->wru_children;
-		*rup = p->p_stats->p_cru;
-		calccru(p, &rup->ru_utime, &rup->ru_stime);
-	}
+	wait_fill_wrusage(p, wrusage);
 
 	if (p->p_state == PRS_ZOMBIE && !check_only) {
 		proc_reap(td, p, status, options);
@@ -1267,10 +1310,85 @@
 	}
 	if (status != NULL)
 		*status = cont ? SIGCONT : W_STOPCODE(p->p_xsig);
-	td->td_retval[0] = p->p_pid;
 	PROC_UNLOCK(p);
 }
 
+static int
+wait6_checkopt(int options)
+{
+	/* If we don't know the option, just return. */
+	if ((options & ~(WUNTRACED | WNOHANG | WCONTINUED | WNOWAIT |
+	    WEXITED | WTRAPPED | WLINUXCLONE)) != 0)
+		return (EXTERROR(EINVAL, "Unknown options %#jx", options));
+	if ((options & (WEXITED | WUNTRACED | WCONTINUED | WTRAPPED)) == 0) {
+		/*
+		 * We will be unable to find any matching processes,
+		 * because there are no known events to look for.
+		 * Prefer to return error instead of blocking
+		 * indefinitely.
+		 */
+		return (EXTERROR(EINVAL,
+		    "Cannot match processes %#jx", options));
+	}
+	return (0);
+}
+
+/*
+ * Checks and reports status for alive process, according to the
+ * options.  Returns true if the process fits one of the requested
+ * options and its status was updated in siginfo.
+ *
+ * If the process was reported (the function result is true), both the
+ * process and proctree locks are unlocked.
+ */
+static bool
+wait6_check_alive(struct thread *td, int options, struct proc *p, int *status,
+    siginfo_t *siginfo)
+{
+	bool report;
+
+	PROC_LOCK_ASSERT(p, MA_OWNED);
+	sx_assert(&proctree_lock, SA_XLOCKED);
+
+	if ((options & WTRAPPED) != 0 && (p->p_flag & P_TRACED) != 0) {
+		PROC_SLOCK(p);
+		report = ((p->p_flag & (P_STOPPED_TRACE | P_STOPPED_SIG)) &&
+		    p->p_suspcount == p->p_numthreads &&
+		    (p->p_flag & P_WAITED) == 0);
+		PROC_SUNLOCK(p);
+		if (report) {
+			CTR4(KTR_PTRACE,
+	    "wait: returning trapped pid %d status %#x (xstat %d) xthread %d",
+			    p->p_pid, W_STOPCODE(p->p_xsig), p->p_xsig,
+			    p->p_xthread != NULL ?
+			    p->p_xthread->td_tid : -1);
+			report_alive_proc(td, p, siginfo, status,
+			    options, CLD_TRAPPED);
+			return (true);
+		}
+	}
+
+	if ((options & WUNTRACED) != 0 && (p->p_flag & P_STOPPED_SIG) != 0) {
+		PROC_SLOCK(p);
+		report = (p->p_suspcount == p->p_numthreads &&
+		    ((p->p_flag & P_WAITED) == 0));
+		PROC_SUNLOCK(p);
+		if (report) {
+			report_alive_proc(td, p, siginfo, status, options,
+			    CLD_STOPPED);
+			return (true);
+		}
+	}
+
+	if ((options & WCONTINUED) != 0 && (p->p_flag & P_CONTINUED) != 0) {
+		report_alive_proc(td, p, siginfo, status, options,
+		    CLD_CONTINUED);
+		return (true);
+	}
+
+	return (false);
+}
+
 int
 kern_wait6(struct thread *td, idtype_t idtype, id_t id, int *status,
     int options, struct __wrusage *wrusage, siginfo_t *siginfo)
@@ -1278,7 +1396,6 @@
 	struct proc *p, *q;
 	pid_t pid;
 	int error, nfound, ret;
-	bool report;
 
 	AUDIT_ARG_VALUE((int)idtype);	/* XXX - This is likely wrong! */
 	AUDIT_ARG_PID((pid_t)id);	/* XXX - This may be wrong! */
@@ -1293,20 +1410,9 @@
 		idtype = P_PGID;
 	}
 
-	/* If we don't know the option, just return. */
-	if ((options & ~(WUNTRACED | WNOHANG | WCONTINUED | WNOWAIT |
-	    WEXITED | WTRAPPED | WLINUXCLONE)) != 0)
-		return (EINVAL);
-	if ((options & (WEXITED | WUNTRACED | WCONTINUED | WTRAPPED)) == 0) {
-		/*
-		 * We will be unable to find any matching processes,
-		 * because there are no known events to look for.
-		 * Prefer to return error instead of blocking
-		 * indefinitely.
-		 */
-		return (EINVAL);
-	}
-
+	error = wait6_checkopt(options);
+	if (error != 0)
+		return (error);
 loop:
 	if (q->p_flag & P_STATCHILD) {
 		PROC_LOCK(q);
@@ -1342,44 +1448,11 @@
 		nfound++;
 		PROC_LOCK_ASSERT(p, MA_OWNED);
 
-		if ((options & WTRAPPED) != 0 &&
-		    (p->p_flag & P_TRACED) != 0) {
-			PROC_SLOCK(p);
-			report =
-			    ((p->p_flag & (P_STOPPED_TRACE | P_STOPPED_SIG)) &&
-			    p->p_suspcount == p->p_numthreads &&
-			    (p->p_flag & P_WAITED) == 0);
-			PROC_SUNLOCK(p);
-			if (report) {
-			CTR4(KTR_PTRACE,
-			    "wait: returning trapped pid %d status %#x "
-			    "(xstat %d) xthread %d",
-			    p->p_pid, W_STOPCODE(p->p_xsig), p->p_xsig,
-			    p->p_xthread != NULL ?
-			    p->p_xthread->td_tid : -1);
-				report_alive_proc(td, p, siginfo, status,
-				    options, CLD_TRAPPED);
-				return (0);
-			}
-		}
-		if ((options & WUNTRACED) != 0 &&
-		    (p->p_flag & P_STOPPED_SIG) != 0) {
-			PROC_SLOCK(p);
-			report = (p->p_suspcount == p->p_numthreads &&
-			    ((p->p_flag & P_WAITED) == 0));
-			PROC_SUNLOCK(p);
-			if (report) {
-				report_alive_proc(td, p, siginfo, status,
-				    options, CLD_STOPPED);
-				return (0);
-			}
-		}
-		if ((options & WCONTINUED) != 0 &&
-		    (p->p_flag & P_CONTINUED) != 0) {
-			report_alive_proc(td, p, siginfo, status, options,
-			    CLD_CONTINUED);
+		if (wait6_check_alive(td, options, p, status, siginfo)) {
+			td->td_retval[0] = p->p_pid;
 			return (0);
 		}
+
 		PROC_UNLOCK(p);
 	}
 
@@ -1412,24 +1485,102 @@
 		sx_xunlock(&proctree_lock);
 		return (ECHILD);
 	}
-	if (options & WNOHANG) {
+	if ((options & WNOHANG) != 0) {
 		sx_xunlock(&proctree_lock);
 		td->td_retval[0] = 0;
 		return (0);
 	}
 	PROC_LOCK(q);
-	if (q->p_flag & P_STATCHILD) {
+	if ((q->p_flag & P_STATCHILD) != 0) {
 		q->p_flag &= ~P_STATCHILD;
 		PROC_UNLOCK(q);
 		goto loop_locked;
 	}
 	sx_xunlock(&proctree_lock);
 	error = msleep(q, &q->p_mtx, PWAIT | PCATCH | PDROP, "wait", 0);
-	if (error)
+	if (error != 0)
 		return (error);
 	goto loop;
 }
 
+int
+kern_pdwait(struct thread *td, int fd, int *status,
+    int options, struct __wrusage *wrusage, siginfo_t *siginfo)
+{
+	struct proc *p;
+	struct file *fp;
+	struct procdesc *pd;
+	int error;
+
+	AUDIT_ARG_FD(fd);
+	AUDIT_ARG_VALUE(options);
+
+	error = wait6_checkopt(options);
+	if (error != 0)
+		return (error);
+
+	error = fget(td, fd, &cap_pdwait_rights, &fp);
+	if (error != 0)
+		return (error);
+	if (fp->f_type != DTYPE_PROCDESC) {
+		error = EINVAL;
+		goto exit_unlocked;
+	}
+	pd = fp->f_data;
+
+	for (;;) {
+		sx_xlock(&proctree_lock);
+		p = pd->pd_proc;
+		if (p == NULL) {
+			error = ESRCH;
+			goto exit_tree_locked;
+		}
+		PROC_LOCK(p);
+
+		error = p_canwait(td, p);
+		if (error != 0)
+			break;
+		if ((options & WEXITED) == 0 && p->p_state == PRS_ZOMBIE) {
+			error = ESRCH;
+			break;
+		}
+
+		wait_fill_siginfo(p, siginfo);
+		wait_fill_wrusage(p, wrusage);
+
+		if (p->p_state == PRS_ZOMBIE) {
+			proc_reap(td, p, status, options);
+			goto exit_unlocked;
+		}
+
+		if (wait6_check_alive(td, options, p, status, siginfo))
+			goto exit_unlocked;
+
+		if (p->p_state == PRS_ZOMBIE) {
+			if (status != NULL)
+				*status = KW_EXITCODE(p->p_xexit, p->p_xsig);
+			break;
+		}
+		if ((options & WNOHANG) != 0) {
+			error = EWOULDBLOCK;
+			break;
+		}
+
+		PROC_UNLOCK(p);
+		error = sx_sleep(&p->p_procdesc, &proctree_lock,
+		    PWAIT | PCATCH | PDROP, "pdwait", 0);
+		if (error != 0)
+			return (error);
+	}
+
+	PROC_UNLOCK(p);
+exit_tree_locked:
+	sx_xunlock(&proctree_lock);
+exit_unlocked:
+	fdrop(fp, td);
+	return (error);
+}
+
 void
 proc_add_orphan(struct proc *child, struct proc *parent)
 {
diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c
--- a/sys/kern/kern_fork.c
+++ b/sys/kern/kern_fork.c
@@ -34,20 +34,22 @@
  * SUCH DAMAGE.
  */
 
-#include <sys/cdefs.h>
 #include "opt_ktrace.h"
 #include "opt_kstack_pages.h"
 
-#include <sys/param.h>
+#define EXTERR_CATEGORY	EXTERR_CAT_FORK
 #include <sys/systm.h>
+#include <sys/acct.h>
 #include <sys/bitstring.h>
-#include <sys/sysproto.h>
 #include <sys/eventhandler.h>
+#include <sys/exterrvar.h>
 #include <sys/fcntl.h>
 #include <sys/filedesc.h>
 #include <sys/jail.h>
 #include <sys/kernel.h>
 #include <sys/kthread.h>
+#include <sys/ktr.h>
+#include <sys/ktrace.h>
 #include <sys/sysctl.h>
 #include <sys/lock.h>
 #include <sys/malloc.h>
@@ -60,17 +62,15 @@
 #include <sys/racct.h>
 #include <sys/resourcevar.h>
 #include <sys/sched.h>
+#include <sys/sdt.h>
+#include <sys/signalvar.h>
+#include <sys/sx.h>
 #include <sys/syscall.h>
+#include <sys/sysent.h>
+#include <sys/sysproto.h>
 #include <sys/vmmeter.h>
 #include <sys/vnode.h>
-#include <sys/acct.h>
-#include <sys/ktr.h>
-#include <sys/ktrace.h>
 #include <sys/unistd.h>
-#include <sys/sdt.h>
-#include <sys/sx.h>
-#include <sys/sysent.h>
-#include <sys/signalvar.h>
 
 #include <security/audit/audit.h>
 #include <security/mac/mac_framework.h>
@@ -166,10 +166,11 @@
 
 	/* Don't allow kernel-only flags. */
 	if ((uap->flags & RFKERNELONLY) != 0)
-		return (EINVAL);
+		return (EXTERROR(EINVAL, "Kernel-only flags %#jx", uap->flags));
 	/* RFSPAWN must not appear with others */
 	if ((uap->flags & RFSPAWN) != 0 && uap->flags != RFSPAWN)
-		return (EINVAL);
+		return (EXTERROR(EINVAL, "RFSPAWN must be the only flag %#jx",
+		    uap->flags));
 
 	AUDIT_ARG_FFLAGS(uap->flags);
 	bzero(&fr, sizeof(fr));
@@ -188,6 +189,48 @@
 	return (error);
 }
 
+int
+sys_pdrfork(struct thread *td, struct pdrfork_args *uap)
+{
+	struct fork_req fr;
+	int error, fd, pid;
+
+	bzero(&fr, sizeof(fr));
+	fd = -1;
+
+	AUDIT_ARG_FFLAGS(uap->pdflags);
+	AUDIT_ARG_CMD(uap->rfflags);
+
+	if ((uap->rfflags & (RFSTOPPED | RFHIGHPID)) != 0)
+		return (EXTERROR(EINVAL,
+		    "Kernel-only flags %#jx", uap->rfflags));
+
+	/* RFSPAWN must not appear with others */
+	if ((uap->rfflags & RFSPAWN) != 0) {
+		if (uap->rfflags != RFSPAWN)
+			return (EXTERROR(EINVAL,
+			    "RFSPAWN must be the only flag %#jx",
+			    uap->rfflags));
+		fr.fr_flags = RFFDG | RFPROC | RFPPWAIT | RFMEM | RFPROCDESC;
+		fr.fr_flags2 = FR2_DROPSIG_CAUGHT;
+	} else {
+		fr.fr_flags = uap->rfflags;
+	}
+
+	fr.fr_pidp = &pid;
+	fr.fr_pd_fd = &fd;
+	fr.fr_pd_flags = uap->pdflags;
+	error = fork1(td, &fr);
+	if (error == 0) {
+		td->td_retval[0] = pid;
+		td->td_retval[1] = 0;
+		if ((fr.fr_flags & (RFPROC | RFPROCDESC)) ==
+		    (RFPROC | RFPROCDESC) || uap->rfflags == RFSPAWN)
+			error = copyout(&fd, uap->fdp, sizeof(fd));
+	}
+	return (error);
+}
+
 int __exclusive_cache_line	nprocs = 1;		/* process 0 */
 int	lastpid = 0;
 SYSCTL_INT(_kern, OID_AUTO, lastpid, CTLFLAG_RD, &lastpid, 0,
@@ -871,34 +914,32 @@
 	else
 		MPASS(fr->fr_procp == NULL);
 
-	/* Check for the undefined or unimplemented flags. */
 	if ((flags & ~(RFFLAGS | RFTSIGFLAGS(RFTSIGMASK))) != 0)
-		return (EINVAL);
+		return (EXTERROR(EINVAL,
+		    "Undef or unimplemented flags %#jx", flags));
 
-	/* Signal value requires RFTSIGZMB. */
 	if ((flags & RFTSIGFLAGS(RFTSIGMASK)) != 0 && (flags & RFTSIGZMB) == 0)
-		return (EINVAL);
+		return (EXTERROR(EINVAL,
+		    "Signal value requires RFTSIGZMB", flags));
 
-	/* Can't copy and clear. */
-	if ((flags & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
-		return (EINVAL);
+	if ((flags & (RFFDG | RFCFDG)) == (RFFDG | RFCFDG))
+		return (EXTERROR(EINVAL, "Can not copy and clear"));
 
-	/* Check the validity of the signal number. */
 	if ((flags & RFTSIGZMB) != 0 && (u_int)RFTSIGNUM(flags) > _SIG_MAXSIG)
-		return (EINVAL);
+		return (EXTERROR(EINVAL, "Invalid signal", RFTSIGNUM(flags)));
 
 	if ((flags & RFPROCDESC) != 0) {
-		/* Can't not create a process yet get a process descriptor. */
 		if ((flags & RFPROC) == 0)
-			return (EINVAL);
+			return (EXTERROR(EINVAL,
+	    "Can not not create a process yet get a process descriptor"));
 
-		/* Must provide a place to put a procdesc if creating one. */
 		if (fr->fr_pd_fd == NULL)
-			return (EINVAL);
+			return (EXTERROR(EINVAL,
+		    "Must provide a place to put a procdesc if creating one"));
 
-		/* Check if we are using supported flags. */
 		if ((fr->fr_pd_flags & ~PD_ALLOWED_AT_FORK) != 0)
-			return (EINVAL);
+			return (EXTERROR(EINVAL,
+			    "Invallid pdflags at fork %#jx", fr->fr_pd_flags));
 	}
 
 	p1 = td->td_proc;
diff --git a/sys/kern/subr_capability.c b/sys/kern/subr_capability.c
--- a/sys/kern/subr_capability.c
+++ b/sys/kern/subr_capability.c
@@ -90,6 +90,7 @@
 const cap_rights_t cap_mknodat_rights = CAP_RIGHTS_INITIALIZER(CAP_MKNODAT);
 const cap_rights_t cap_pdgetpid_rights = CAP_RIGHTS_INITIALIZER(CAP_PDGETPID);
 const cap_rights_t cap_pdkill_rights = CAP_RIGHTS_INITIALIZER(CAP_PDKILL);
+const cap_rights_t cap_pdwait_rights = CAP_RIGHTS_INITIALIZER(CAP_PDWAIT);
 const cap_rights_t cap_pread_rights = CAP_RIGHTS_INITIALIZER(CAP_PREAD);
 const cap_rights_t cap_pwrite_rights = CAP_RIGHTS_INITIALIZER(CAP_PWRITE);
 const cap_rights_t cap_read_rights = CAP_RIGHTS_INITIALIZER(CAP_READ);
diff --git a/sys/kern/sys_procdesc.c b/sys/kern/sys_procdesc.c
--- a/sys/kern/sys_procdesc.c
+++ b/sys/kern/sys_procdesc.c
@@ -75,6 +75,7 @@
 #include <sys/procdesc.h>
 #include <sys/resourcevar.h>
 #include <sys/stat.h>
+#include <sys/syscallsubr.h>
 #include <sys/sysproto.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
@@ -270,6 +271,9 @@
 		KASSERT((pd->pd_flags & PDF_CLOSED),
 		    ("procdesc_free: !PDF_CLOSED"));
 
+		if (pd->pd_pid != -1)
+			proc_id_clear(PROC_ID_PID, pd->pd_pid);
+
 		knlist_destroy(&pd->pd_selinfo.si_note);
 		PROCDESC_LOCK_DESTROY(pd);
 		free(pd, M_PROCDESC);
@@ -318,6 +322,9 @@
 	}
 	KNOTE_LOCKED(&pd->pd_selinfo.si_note, NOTE_EXIT);
 	PROCDESC_UNLOCK(pd);
+
+	/* Wakeup all waiters for this procdesc' process exit. */
+	wakeup(&p->p_procdesc);
 	return (0);
 }
 
@@ -389,6 +396,7 @@
 			 */
 			pd->pd_proc = NULL;
 			p->p_procdesc = NULL;
+			pd->pd_pid = -1;
 			procdesc_free(pd);
 
 			/*
diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c
--- a/sys/kern/syscalls.c
+++ b/sys/kern/syscalls.c
@@ -605,4 +605,6 @@
 	"jail_attach_jd",			/* 597 = jail_attach_jd */
 	"jail_remove_jd",			/* 598 = jail_remove_jd */
 	"kexec_load",			/* 599 = kexec_load */
+	"pdrfork",			/* 600 = pdrfork */
+	"pdwait",			/* 601 = pdwait */
 };
diff --git a/sys/kern/syscalls.master b/sys/kern/syscalls.master
--- a/sys/kern/syscalls.master
+++ b/sys/kern/syscalls.master
@@ -3402,4 +3402,23 @@
 			u_long flags
 		);
 	}
+
+600     AUE_PDRFORK     STD|CAPENABLED {
+		int pdrfork(
+			_Out_ int *fdp,
+			int pdflags,
+			int rfflags
+		);
+	}
+
+601	AUE_PDWAIT	STD|CAPENABLED {
+		int pdwait(
+		    int fd,
+		    _Out_opt_ int *status,
+		    int options,
+		    _Out_opt_ _Contains_long_ struct __wrusage *wrusage,
+		    _Out_opt_ _Contains_long_ptr_ struct __siginfo *info
+		);
+	}
+
 ; vim: syntax=off
diff --git a/sys/kern/systrace_args.c b/sys/kern/systrace_args.c
--- a/sys/kern/systrace_args.c
+++ b/sys/kern/systrace_args.c
@@ -3524,6 +3524,26 @@
 		*n_args = 4;
 		break;
 	}
+	/* pdrfork */
+	case 600: {
+		struct pdrfork_args *p = params;
+		uarg[a++] = (intptr_t)p->fdp; /* int * */
+		iarg[a++] = p->pdflags; /* int */
+		iarg[a++] = p->rfflags; /* int */
+		*n_args = 3;
+		break;
+	}
+	/* pdwait */
+	case 601: {
+		struct pdwait_args *p = params;
+		iarg[a++] = p->fd; /* int */
+		uarg[a++] = (intptr_t)p->status; /* int * */
+		iarg[a++] = p->options; /* int */
+		uarg[a++] = (intptr_t)p->wrusage; /* struct __wrusage * */
+		uarg[a++] = (intptr_t)p->info; /* struct __siginfo * */
+		*n_args = 5;
+		break;
+	}
 	default:
 		*n_args = 0;
 		break;
@@ -9430,6 +9450,44 @@
 			break;
 		};
 		break;
+	/* pdrfork */
+	case 600:
+		switch (ndx) {
+		case 0:
+			p = "userland int *";
+			break;
+		case 1:
+			p = "int";
+			break;
+		case 2:
+			p = "int";
+			break;
+		default:
+			break;
+		};
+		break;
+	/* pdwait */
+	case 601:
+		switch (ndx) {
+		case 0:
+			p = "int";
+			break;
+		case 1:
+			p = "userland int *";
+			break;
+		case 2:
+			p = "int";
+			break;
+		case 3:
+			p = "userland struct __wrusage *";
+			break;
+		case 4:
+			p = "userland struct __siginfo *";
+			break;
+		default:
+			break;
+		};
+		break;
 	default:
 		break;
 	};
@@ -11443,6 +11501,16 @@
 		if (ndx == 0 || ndx == 1)
 			p = "int";
 		break;
+	/* pdrfork */
+	case 600:
+		if (ndx == 0 || ndx == 1)
+			p = "int";
+		break;
+	/* pdwait */
+	case 601:
+		if (ndx == 0 || ndx == 1)
+			p = "int";
+		break;
 	default:
 		break;
 	};
diff --git a/sys/security/audit/audit_bsm.c b/sys/security/audit/audit_bsm.c
--- a/sys/security/audit/audit_bsm.c
+++ b/sys/security/audit/audit_bsm.c
@@ -1115,6 +1115,16 @@
 		}
 		break;
 
+	case AUE_PDWAIT:
+		if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
+			tok = au_to_arg32(1, "flags", ar->ar_arg_fflags);
+			kau_write(rec, tok);
+		}
+		if (ARG_IS_VALID(kar, ARG_FD)) {
+			tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
+			kau_write(rec, tok);
+		}
+
 	case AUE_IOCTL:
 		if (ARG_IS_VALID(kar, ARG_CMD)) {
 			tok = au_to_arg32(2, "cmd", ar->ar_arg_cmd);
@@ -1365,6 +1375,24 @@
 			kau_write(rec, tok);
 		}
 		break;
+	case AUE_PDRFORK:
+		if (ARG_IS_VALID(kar, ARG_PID)) {
+			tok = au_to_arg32(0, "child PID", ar->ar_arg_pid);
+			kau_write(rec, tok);
+		}
+		if (ARG_IS_VALID(kar, ARG_CMD)) {
+			tok = au_to_arg32(2, "fflags", ar->ar_arg_cmd);
+			kau_write(rec, tok);
+		}
+		if (ARG_IS_VALID(kar, ARG_FFLAGS)) {
+			tok = au_to_arg32(2, "flags", ar->ar_arg_fflags);
+			kau_write(rec, tok);
+		}
+		if (ARG_IS_VALID(kar, ARG_FD)) {
+			tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
+			kau_write(rec, tok);
+		}
+		break;
 	case AUE_PDGETPID:
 		if (ARG_IS_VALID(kar, ARG_FD)) {
 			tok = au_to_arg32(1, "fd", ar->ar_arg_fd);
diff --git a/sys/sys/caprights.h b/sys/sys/caprights.h
--- a/sys/sys/caprights.h
+++ b/sys/sys/caprights.h
@@ -92,6 +92,7 @@
 extern const cap_rights_t cap_no_rights;
 extern const cap_rights_t cap_pdgetpid_rights;
 extern const cap_rights_t cap_pdkill_rights;
+extern const cap_rights_t cap_pdwait_rights;
 extern const cap_rights_t cap_pread_rights;
 extern const cap_rights_t cap_pwrite_rights;
 extern const cap_rights_t cap_read_rights;
diff --git a/sys/sys/exterr_cat.h b/sys/sys/exterr_cat.h
--- a/sys/sys/exterr_cat.h
+++ b/sys/sys/exterr_cat.h
@@ -37,6 +37,8 @@
 #define	EXTERR_CAT_GEOM		12
 #define	EXTERR_CAT_FUSE_VFS	13
 #define	EXTERR_CAT_FUSE_DEVICE	14
+#define	EXTERR_CAT_FORK		15
+#define	EXTERR_CAT_PROCEXIT	16
 
 #endif
 
diff --git a/sys/sys/procdesc.h b/sys/sys/procdesc.h
--- a/sys/sys/procdesc.h
+++ b/sys/sys/procdesc.h
@@ -122,9 +122,14 @@
  * Process descriptor system calls.
  */
 __BEGIN_DECLS
+struct __wrusage;
+struct __siginfo;
+
 pid_t	 pdfork(int *, int);
+pid_t	 pdrfork(int *, int, int);
 int	 pdkill(int, int);
 int	 pdgetpid(int, pid_t *);
+int	 pdwait(int, int *, int, struct __wrusage *, struct __siginfo *);
 __END_DECLS
 
 #endif /* _KERNEL */
diff --git a/sys/sys/syscall.h b/sys/sys/syscall.h
--- a/sys/sys/syscall.h
+++ b/sys/sys/syscall.h
@@ -538,4 +538,6 @@
 #define	SYS_jail_attach_jd	597
 #define	SYS_jail_remove_jd	598
 #define	SYS_kexec_load	599
-#define	SYS_MAXSYSCALL	600
+#define	SYS_pdrfork	600
+#define	SYS_pdwait	601
+#define	SYS_MAXSYSCALL	602
diff --git a/sys/sys/syscall.mk b/sys/sys/syscall.mk
--- a/sys/sys/syscall.mk
+++ b/sys/sys/syscall.mk
@@ -441,4 +441,6 @@
 	setgroups.o \
 	jail_attach_jd.o \
 	jail_remove_jd.o \
-	kexec_load.o
+	kexec_load.o \
+	pdrfork.o \
+	pdwait.o
diff --git a/sys/sys/syscallsubr.h b/sys/sys/syscallsubr.h
--- a/sys/sys/syscallsubr.h
+++ b/sys/sys/syscallsubr.h
@@ -286,6 +286,8 @@
 	    off_t len);
 int	kern_fspacectl(struct thread *td, int fd, int cmd,
 	    const struct spacectl_range *, int flags, struct spacectl_range *);
+int	kern_pdwait(struct thread *td, int fd, int *status,
+	    int options, struct __wrusage *wrusage, siginfo_t *sip);
 int	kern_procctl(struct thread *td, enum idtype idtype, id_t id, int com,
 	    void *data);
 int	kern_pread(struct thread *td, int fd, void *buf, size_t nbyte,
diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h
--- a/sys/sys/sysproto.h
+++ b/sys/sys/sysproto.h
@@ -1913,6 +1913,18 @@
 	char segments_l_[PADL_(struct kexec_segment *)]; struct kexec_segment * segments; char segments_r_[PADR_(struct kexec_segment *)];
 	char flags_l_[PADL_(u_long)]; u_long flags; char flags_r_[PADR_(u_long)];
 };
+struct pdrfork_args {
+	char fdp_l_[PADL_(int *)]; int * fdp; char fdp_r_[PADR_(int *)];
+	char pdflags_l_[PADL_(int)]; int pdflags; char pdflags_r_[PADR_(int)];
+	char rfflags_l_[PADL_(int)]; int rfflags; char rfflags_r_[PADR_(int)];
+};
+struct pdwait_args {
+	char fd_l_[PADL_(int)]; int fd; char fd_r_[PADR_(int)];
+	char status_l_[PADL_(int *)]; int * status; char status_r_[PADR_(int *)];
+	char options_l_[PADL_(int)]; int options; char options_r_[PADR_(int)];
+	char wrusage_l_[PADL_(struct __wrusage *)]; struct __wrusage * wrusage; char wrusage_r_[PADR_(struct __wrusage *)];
+	char info_l_[PADL_(struct __siginfo *)]; struct __siginfo * info; char info_r_[PADR_(struct __siginfo *)];
+};
 int	sys__exit(struct thread *, struct _exit_args *);
 int	sys_fork(struct thread *, struct fork_args *);
 int	sys_read(struct thread *, struct read_args *);
@@ -2320,6 +2332,8 @@
 int	sys_jail_attach_jd(struct thread *, struct jail_attach_jd_args *);
 int	sys_jail_remove_jd(struct thread *, struct jail_remove_jd_args *);
 int	sys_kexec_load(struct thread *, struct kexec_load_args *);
+int	sys_pdrfork(struct thread *, struct pdrfork_args *);
+int	sys_pdwait(struct thread *, struct pdwait_args *);
 
 #ifdef COMPAT_43
 
@@ -3319,6 +3333,8 @@
 #define	SYS_AUE_jail_attach_jd	AUE_JAIL_ATTACH
 #define	SYS_AUE_jail_remove_jd	AUE_JAIL_REMOVE
 #define	SYS_AUE_kexec_load	AUE_NULL
+#define	SYS_AUE_pdrfork	AUE_PDRFORK
+#define	SYS_AUE_pdwait	AUE_PDWAIT
 
 #undef PAD_
 #undef PADL_