 @@ -1,1105 +1,1108 @@
-/*	$NetBSD: kern_proc.c,v 1.199 2016/11/14 08:55:51 kre Exp $	*/
+/*	$NetBSD: kern_proc.c,v 1.200 2017/01/26 03:54:54 christos Exp $	*/
 /*-
  * Copyright (c) 1999, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, and by Andrew Doran.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1982, 1986, 1989, 1991, 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.
+ *
  *	@(#)kern_proc.c	8.7 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.199 2016/11/14 08:55:51 kre Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.200 2017/01/26 03:54:54 christos Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_kstack.h"
 #include "opt_maxuprc.h"
 #include "opt_dtrace.h"
 #include "opt_compat_netbsd32.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
 #include <sys/buf.h>
 #include <sys/acct.h>
 #include <sys/wait.h>
 #include <sys/file.h>
 #include <ufs/ufs/quota.h>
 #include <sys/uio.h>
 #include <sys/pool.h>
 #include <sys/pset.h>
 #include <sys/mbuf.h>
 #include <sys/ioctl.h>
 #include <sys/tty.h>
 #include <sys/signalvar.h>
 #include <sys/ras.h>
 #include <sys/filedesc.h>
 #include <sys/syscall_stats.h>
 #include <sys/kauth.h>
 #include <sys/sleepq.h>
 #include <sys/atomic.h>
 #include <sys/kmem.h>
 #include <sys/namei.h>
 #include <sys/dtrace_bsd.h>
 #include <sys/sysctl.h>
 #include <sys/exec.h>
 #include <sys/cpu.h>
 #include <uvm/uvm_extern.h>
 #include <uvm/uvm.h>
 #ifndef COMPAT_NETBSD32
 #define COMPAT_NETBSD32
 #endif
 #ifdef COMPAT_NETBSD32
 #include <compat/netbsd32/netbsd32.h>
 #endif
 /*
  * Process lists.
  */
 struct proclist		allproc		__cacheline_aligned;
 struct proclist		zombproc	__cacheline_aligned;
 kmutex_t *		proc_lock	__cacheline_aligned;
 /*
  * pid to proc lookup is done by indexing the pid_table array.
  * Since pid numbers are only allocated when an empty slot
  * has been found, there is no need to search any lists ever.
  * (an orphaned pgrp will lock the slot, a session will lock
  * the pgrp with the same number.)
  * If the table is too small it is reallocated with twice the
  * previous size and the entries 'unzipped' into the two halves.
  * A linked list of free entries is passed through the pt_proc
  * field of 'free' items - set odd to be an invalid ptr.
  */
 struct pid_table {
 	struct proc	*pt_proc;
 	struct pgrp	*pt_pgrp;
 	pid_t		pt_pid;
 };
 #if 1	/* strongly typed cast - should be a noop */
 static inline uint p2u(struct proc *p) { return (uint)(uintptr_t)p; }
 #else
 #define p2u(p) ((uint)p)
 #endif
 #define P_VALID(p) (!(p2u(p) & 1))
 #define P_NEXT(p) (p2u(p) >> 1)
 #define P_FREE(pid) ((struct proc *)(uintptr_t)((pid) << 1 | 1))
 /*
  * Table of process IDs (PIDs).
  */
 static struct pid_table *pid_table	__read_mostly;
 #define	INITIAL_PID_TABLE_SIZE		(1 << 5)
 /* Table mask, threshold for growing and number of allocated PIDs. */
 static u_int		pid_tbl_mask	__read_mostly;
 static u_int		pid_alloc_lim	__read_mostly;
 static u_int		pid_alloc_cnt	__cacheline_aligned;
 /* Next free, last free and maximum PIDs. */
 static u_int		next_free_pt	__cacheline_aligned;
 static u_int		last_free_pt	__cacheline_aligned;
 static pid_t		pid_max		__read_mostly;
 /* Components of the first process -- never freed. */
 extern struct emul emul_netbsd;	/* defined in kern_exec.c */
 struct session session0 = {
 	.s_count = 1,
 	.s_sid = 0,
 };
 struct pgrp pgrp0 = {
 	.pg_members = LIST_HEAD_INITIALIZER(&pgrp0.pg_members),
 	.pg_session = &session0,
 };
 filedesc_t filedesc0;
 struct cwdinfo cwdi0 = {
 	.cwdi_cmask = CMASK,
 	.cwdi_refcnt = 1,
 };
 struct plimit limit0;
 struct pstats pstat0;
 struct vmspace vmspace0;
 struct sigacts sigacts0;
 struct proc proc0 = {
 	.p_lwps = LIST_HEAD_INITIALIZER(&proc0.p_lwps),
 	.p_sigwaiters = LIST_HEAD_INITIALIZER(&proc0.p_sigwaiters),
 	.p_nlwps = 1,
 	.p_nrlwps = 1,
 	.p_nlwpid = 1,		/* must match lwp0.l_lid */
 	.p_pgrp = &pgrp0,
 	.p_comm = "system",
 	/*
 	 * Set P_NOCLDWAIT so that kernel threads are reparented to init(8)
 	 * when they exit.  init(8) can easily wait them out for us.
 	 */
 	.p_flag = PK_SYSTEM | PK_NOCLDWAIT,
 	.p_stat = SACTIVE,
 	.p_nice = NZERO,
 	.p_emul = &emul_netbsd,
 	.p_cwdi = &cwdi0,
 	.p_limit = &limit0,
 	.p_fd = &filedesc0,
 	.p_vmspace = &vmspace0,
 	.p_stats = &pstat0,
 	.p_sigacts = &sigacts0,
 #ifdef PROC0_MD_INITIALIZERS
 	PROC0_MD_INITIALIZERS
 #endif
 };
 kauth_cred_t cred0;
 static const int	nofile	= NOFILE;
 static const int	maxuprc	= MAXUPRC;
 static int sysctl_doeproc(SYSCTLFN_PROTO);
 static int sysctl_kern_proc_args(SYSCTLFN_PROTO);
 /*
  * The process list descriptors, used during pid allocation and
  * by sysctl.  No locking on this data structure is needed since
  * it is completely static.
  */
 const struct proclist_desc proclists[] = {
 	{ &allproc	},
 	{ &zombproc	},
 	{ NULL		},
 };
 static struct pgrp *	pg_remove(pid_t);
 static void		pg_delete(pid_t);
 static void		orphanpg(struct pgrp *);
 static specificdata_domain_t proc_specificdata_domain;
 static pool_cache_t proc_cache;
 static kauth_listener_t proc_listener;
 static int fill_pathname(struct lwp *, pid_t, void *, size_t *);
 static int
 proc_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
     void *arg0, void *arg1, void *arg2, void *arg3)
+{
 	struct proc *p;
 	int result;
 	result = KAUTH_RESULT_DEFER;
 	p = arg0;
 	switch (action) {
 	case KAUTH_PROCESS_CANSEE: {
 		enum kauth_process_req req;
 		req = (enum kauth_process_req)arg1;
 		switch (req) {
 		case KAUTH_REQ_PROCESS_CANSEE_ARGS:
 		case KAUTH_REQ_PROCESS_CANSEE_ENTRY:
 		case KAUTH_REQ_PROCESS_CANSEE_OPENFILES:
 			result = KAUTH_RESULT_ALLOW;
 			break;
 		case KAUTH_REQ_PROCESS_CANSEE_ENV:
 			if (kauth_cred_getuid(cred) !=
 			    kauth_cred_getuid(p->p_cred) ||
 			    kauth_cred_getuid(cred) !=
 			    kauth_cred_getsvuid(p->p_cred))
 				break;
 			result = KAUTH_RESULT_ALLOW;
 			break;
 		default:
 			break;
+		}
 		break;
+		}
 	case KAUTH_PROCESS_FORK: {
 		int lnprocs = (int)(unsigned long)arg2;
 		/*
 		 * Don't allow a nonprivileged user to use the last few
 		 * processes. The variable lnprocs is the current number of
 		 * processes, maxproc is the limit.
 		 */
 		if (__predict_false((lnprocs >= maxproc - 5)))
 			break;
 		result = KAUTH_RESULT_ALLOW;
 		break;
+		}
 	case KAUTH_PROCESS_CORENAME:
 	case KAUTH_PROCESS_STOPFLAG:
 		if (proc_uidmatch(cred, p->p_cred) == 0)
 			result = KAUTH_RESULT_ALLOW;
 		break;
 	default:
 		break;
+	}
 	return result;
+}
 /*
  * Initialize global process hashing structures.
  */
 void
 procinit(void)
+{
 	const struct proclist_desc *pd;
 	u_int i;
 #define	LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1))
 	for (pd = proclists; pd->pd_list != NULL; pd++)
 		LIST_INIT(pd->pd_list);
 	proc_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
 	pid_table = kmem_alloc(INITIAL_PID_TABLE_SIZE
 	    * sizeof(struct pid_table), KM_SLEEP);
 	pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1;
 	pid_max = PID_MAX;
 	/* Set free list running through table...
 	   Preset 'use count' above PID_MAX so we allocate pid 1 next. */
 	for (i = 0; i <= pid_tbl_mask; i++) {
 		pid_table[i].pt_proc = P_FREE(LINK_EMPTY + i + 1);
 		pid_table[i].pt_pgrp = 0;
 		pid_table[i].pt_pid = 0;
+	}
 	/* slot 0 is just grabbed */
 	next_free_pt = 1;
 	/* Need to fix last entry. */
 	last_free_pt = pid_tbl_mask;
 	pid_table[last_free_pt].pt_proc = P_FREE(LINK_EMPTY);
 	/* point at which we grow table - to avoid reusing pids too often */
 	pid_alloc_lim = pid_tbl_mask - 1;
 #undef LINK_EMPTY
 	proc_specificdata_domain = specificdata_domain_create();
 	KASSERT(proc_specificdata_domain != NULL);
 	proc_cache = pool_cache_init(sizeof(struct proc), 0, 0, 0,
 	    "procpl", NULL, IPL_NONE, NULL, NULL, NULL);
 	proc_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS,
 	    proc_listener_cb, NULL);
+}
 void
 procinit_sysctl(void)
+{
 	static struct sysctllog *clog;
 	sysctl_createv(&clog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_NODE, "proc",
 		       SYSCTL_DESCR("System-wide process information"),
 		       sysctl_doeproc, 0, NULL, 0,
 		       CTL_KERN, KERN_PROC, CTL_EOL);
 	sysctl_createv(&clog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_NODE, "proc2",
 		       SYSCTL_DESCR("Machine-independent process information"),
 		       sysctl_doeproc, 0, NULL, 0,
 		       CTL_KERN, KERN_PROC2, CTL_EOL);
 	sysctl_createv(&clog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_NODE, "proc_args",
 		       SYSCTL_DESCR("Process argument information"),
 		       sysctl_kern_proc_args, 0, NULL, 0,
 		       CTL_KERN, KERN_PROC_ARGS, CTL_EOL);
 	/*
 	  "nodes" under these:
 	  KERN_PROC_ALL
 	  KERN_PROC_PID pid
 	  KERN_PROC_PGRP pgrp
 	  KERN_PROC_SESSION sess
 	  KERN_PROC_TTY tty
 	  KERN_PROC_UID uid
 	  KERN_PROC_RUID uid
 	  KERN_PROC_GID gid
 	  KERN_PROC_RGID gid
 	  all in all, probably not worth the effort...
 	*/
+}
 /*
  * Initialize process 0.
  */
 void
 proc0_init(void)
+{
 	struct proc *p;
 	struct pgrp *pg;
 	struct rlimit *rlim;
 	rlim_t lim;
 	int i;
 	p = &proc0;
 	pg = &pgrp0;
 	mutex_init(&p->p_stmutex, MUTEX_DEFAULT, IPL_HIGH);
 	mutex_init(&p->p_auxlock, MUTEX_DEFAULT, IPL_NONE);
 	p->p_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
 	rw_init(&p->p_reflock);
 	cv_init(&p->p_waitcv, "wait");
 	cv_init(&p->p_lwpcv, "lwpwait");
 	LIST_INSERT_HEAD(&p->p_lwps, &lwp0, l_sibling);
 	pid_table[0].pt_proc = p;
 	LIST_INSERT_HEAD(&allproc, p, p_list);
 	pid_table[0].pt_pgrp = pg;
 	LIST_INSERT_HEAD(&pg->pg_members, p, p_pglist);
 #ifdef __HAVE_SYSCALL_INTERN
 	(*p->p_emul->e_syscall_intern)(p);
 #endif
 	/* Create credentials. */
 	cred0 = kauth_cred_alloc();
 	p->p_cred = cred0;
 	/* Create the CWD info. */
 	rw_init(&cwdi0.cwdi_lock);
 	/* Create the limits structures. */
 	mutex_init(&limit0.pl_lock, MUTEX_DEFAULT, IPL_NONE);
 	rlim = limit0.pl_rlimit;
 	for (i = 0; i < __arraycount(limit0.pl_rlimit); i++) {
 		rlim[i].rlim_cur = RLIM_INFINITY;
 		rlim[i].rlim_max = RLIM_INFINITY;
+	}
 	rlim[RLIMIT_NOFILE].rlim_max = maxfiles;
 	rlim[RLIMIT_NOFILE].rlim_cur = maxfiles < nofile ? maxfiles : nofile;
 	rlim[RLIMIT_NPROC].rlim_max = maxproc;
 	rlim[RLIMIT_NPROC].rlim_cur = maxproc < maxuprc ? maxproc : maxuprc;
 	lim = MIN(VM_MAXUSER_ADDRESS, ctob((rlim_t)uvmexp.free));
 	rlim[RLIMIT_RSS].rlim_max = lim;
 	rlim[RLIMIT_MEMLOCK].rlim_max = lim;
 	rlim[RLIMIT_MEMLOCK].rlim_cur = lim / 3;
 	rlim[RLIMIT_NTHR].rlim_max = maxlwp;
 	rlim[RLIMIT_NTHR].rlim_cur = maxlwp < maxuprc ? maxlwp : maxuprc;
 	/* Note that default core name has zero length. */
 	limit0.pl_corename = defcorename;
 	limit0.pl_cnlen = 0;
 	limit0.pl_refcnt = 1;
 	limit0.pl_writeable = false;
 	limit0.pl_sv_limit = NULL;
 	/* Configure virtual memory system, set vm rlimits. */
 	uvm_init_limits(p);
 	/* Initialize file descriptor table for proc0. */
 	fd_init(&filedesc0);
 	/*
 	 * Initialize proc0's vmspace, which uses the kernel pmap.
 	 * All kernel processes (which never have user space mappings)
 	 * share proc0's vmspace, and thus, the kernel pmap.
 	 */
 	uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS),
 	    trunc_page(VM_MAXUSER_ADDRESS),
 #ifdef __USE_TOPDOWN_VM
 	    true
 #else
 	    false
 #endif
 	    );
 	/* Initialize signal state for proc0. XXX IPL_SCHED */
 	mutex_init(&p->p_sigacts->sa_mutex, MUTEX_DEFAULT, IPL_SCHED);
 	siginit(p);
 	proc_initspecific(p);
 	kdtrace_proc_ctor(NULL, p);
+}
 /*
  * Session reference counting.
  */
 void
 proc_sesshold(struct session *ss)
+{
 	KASSERT(mutex_owned(proc_lock));
 	ss->s_count++;
+}
 void
 proc_sessrele(struct session *ss)
+{
 	KASSERT(mutex_owned(proc_lock));
 	/*
 	 * We keep the pgrp with the same id as the session in order to
 	 * stop a process being given the same pid.  Since the pgrp holds
 	 * a reference to the session, it must be a 'zombie' pgrp by now.
 	 */
 	if (--ss->s_count == 0) {
 		struct pgrp *pg;
 		pg = pg_remove(ss->s_sid);
 		mutex_exit(proc_lock);
 		kmem_free(pg, sizeof(struct pgrp));
 		kmem_free(ss, sizeof(struct session));
 	} else {
 		mutex_exit(proc_lock);
+	}
+}
 /*
  * Check that the specified process group is in the session of the
  * specified process.
  * Treats -ve ids as process ids.
  * Used to validate TIOCSPGRP requests.
  */
 int
 pgid_in_session(struct proc *p, pid_t pg_id)
+{
 	struct pgrp *pgrp;
 	struct session *session;
 	int error;
 	mutex_enter(proc_lock);
 	if (pg_id < 0) {
 		struct proc *p1 = proc_find(-pg_id);
 		if (p1 == NULL) {
 			error = EINVAL;
 			goto fail;
+		}
 		pgrp = p1->p_pgrp;
 	} else {
 		pgrp = pgrp_find(pg_id);
 		if (pgrp == NULL) {
 			error = EINVAL;
 			goto fail;
+		}
+	}
 	session = pgrp->pg_session;
 	error = (session != p->p_pgrp->pg_session) ? EPERM : 0;
 fail:
 	mutex_exit(proc_lock);
 	return error;
+}
 /*
  * p_inferior: is p an inferior of q?
  */
 static inline bool
 p_inferior(struct proc *p, struct proc *q)
+{
 	KASSERT(mutex_owned(proc_lock));
 	for (; p != q; p = p->p_pptr)
 		if (p->p_pid == 0)
 			return false;
 	return true;
+}
 /*
  * proc_find: locate a process by the ID.
+ *
  * => Must be called with proc_lock held.
  */
 proc_t *
 proc_find_raw(pid_t pid)
+{
 	struct pid_table *pt;
 	proc_t *p;
 	KASSERT(mutex_owned(proc_lock));
 	pt = &pid_table[pid & pid_tbl_mask];
 	p = pt->pt_proc;
 	if (__predict_false(!P_VALID(p) || pt->pt_pid != pid)) {
 		return NULL;
+	}
 	return p;
+}
 proc_t *
 proc_find(pid_t pid)
+{
 	proc_t *p;
 	p = proc_find_raw(pid);
 	if (__predict_false(p == NULL)) {
 		return NULL;
+	}
 	/*
 	 * Only allow live processes to be found by PID.
 	 * XXX: p_stat might change, since unlocked.
 	 */
 	if (__predict_true(p->p_stat == SACTIVE || p->p_stat == SSTOP)) {
 		return p;
+	}
 	return NULL;
+}
 /*
  * pgrp_find: locate a process group by the ID.
+ *
  * => Must be called with proc_lock held.
  */
 struct pgrp *
 pgrp_find(pid_t pgid)
+{
 	struct pgrp *pg;
 	KASSERT(mutex_owned(proc_lock));
 	pg = pid_table[pgid & pid_tbl_mask].pt_pgrp;
 	/*
 	 * Cannot look up a process group that only exists because the
 	 * session has not died yet (traditional).
 	 */
 	if (pg == NULL || pg->pg_id != pgid || LIST_EMPTY(&pg->pg_members)) {
 		return NULL;
+	}
 	return pg;
+}
 static void
 expand_pid_table(void)
+{
 	size_t pt_size, tsz;
 	struct pid_table *n_pt, *new_pt;
 	struct proc *proc;
 	struct pgrp *pgrp;
 	pid_t pid, rpid;
 	u_int i;
 	uint new_pt_mask;
 	pt_size = pid_tbl_mask + 1;
 	tsz = pt_size * 2 * sizeof(struct pid_table);
 	new_pt = kmem_alloc(tsz, KM_SLEEP);
 	new_pt_mask = pt_size * 2 - 1;
 	mutex_enter(proc_lock);
 	if (pt_size != pid_tbl_mask + 1) {
 		/* Another process beat us to it... */
 		mutex_exit(proc_lock);
 		kmem_free(new_pt, tsz);
 		return;
+	}
 	/*
 	 * Copy entries from old table into new one.
 	 * If 'pid' is 'odd' we need to place in the upper half,
 	 * even pid's to the lower half.
 	 * Free items stay in the low half so we don't have to
 	 * fixup the reference to them.
 	 * We stuff free items on the front of the freelist
 	 * because we can't write to unmodified entries.
 	 * Processing the table backwards maintains a semblance
 	 * of issuing pid numbers that increase with time.
 	 */
 	i = pt_size - 1;
 	n_pt = new_pt + i;
 	for (; ; i--, n_pt--) {
 		proc = pid_table[i].pt_proc;
 		pgrp = pid_table[i].pt_pgrp;
 		if (!P_VALID(proc)) {
 			/* Up 'use count' so that link is valid */
 			pid = (P_NEXT(proc) + pt_size) & ~pt_size;
 			rpid = 0;
 			proc = P_FREE(pid);
 			if (pgrp)
 				pid = pgrp->pg_id;
 		} else {
 			pid = pid_table[i].pt_pid;
 			rpid = pid;
+		}
 		/* Save entry in appropriate half of table */
 		n_pt[pid & pt_size].pt_proc = proc;
 		n_pt[pid & pt_size].pt_pgrp = pgrp;
 		n_pt[pid & pt_size].pt_pid = rpid;
 		/* Put other piece on start of free list */
 		pid = (pid ^ pt_size) & ~pid_tbl_mask;
 		n_pt[pid & pt_size].pt_proc =
 			P_FREE((pid & ~pt_size) | next_free_pt);
 		n_pt[pid & pt_size].pt_pgrp = 0;
 		n_pt[pid & pt_size].pt_pid = 0;
 		next_free_pt = i | (pid & pt_size);
 		if (i == 0)
 			break;
+	}
 	/* Save old table size and switch tables */
 	tsz = pt_size * sizeof(struct pid_table);
 	n_pt = pid_table;
 	pid_table = new_pt;
 	pid_tbl_mask = new_pt_mask;
 	/*
 	 * pid_max starts as PID_MAX (= 30000), once we have 16384
 	 * allocated pids we need it to be larger!
 	 */
 	if (pid_tbl_mask > PID_MAX) {
 		pid_max = pid_tbl_mask * 2 + 1;
 		pid_alloc_lim |= pid_alloc_lim << 1;
 	} else
 		pid_alloc_lim <<= 1;	/* doubles number of free slots... */
 	mutex_exit(proc_lock);
 	kmem_free(n_pt, tsz);
+}
 struct proc *
 proc_alloc(void)
+{
 	struct proc *p;
 	p = pool_cache_get(proc_cache, PR_WAITOK);
 	p->p_stat = SIDL;			/* protect against others */
 	proc_initspecific(p);
 	kdtrace_proc_ctor(NULL, p);
 	p->p_pid = -1;
 	proc_alloc_pid(p);
 	return p;
+}
 /*
  * proc_alloc_pid: allocate PID and record the given proc 'p' so that
  * proc_find_raw() can find it by the PID.
  */
 pid_t
 proc_alloc_pid(struct proc *p)
+{
 	struct pid_table *pt;
 	pid_t pid;
 	int nxt;
 	for (;;expand_pid_table()) {
 		if (__predict_false(pid_alloc_cnt >= pid_alloc_lim))
 			/* ensure pids cycle through 2000+ values */
 			continue;
 		mutex_enter(proc_lock);
 		pt = &pid_table[next_free_pt];
 #ifdef DIAGNOSTIC
 		if (__predict_false(P_VALID(pt->pt_proc) || pt->pt_pgrp))
 			panic("proc_alloc: slot busy");
 #endif
 		nxt = P_NEXT(pt->pt_proc);
 		if (nxt & pid_tbl_mask)
 			break;
 		/* Table full - expand (NB last entry not used....) */
 		mutex_exit(proc_lock);
+	}
 	/* pid is 'saved use count' + 'size' + entry */
 	pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt;
 	if ((uint)pid > (uint)pid_max)
 		pid &= pid_tbl_mask;
 	next_free_pt = nxt & pid_tbl_mask;
 	/* Grab table slot */
 	pt->pt_proc = p;
 	KASSERT(pt->pt_pid == 0);
 	pt->pt_pid = pid;
 	if (p->p_pid == -1) {
 		p->p_pid = pid;
+	}
 	pid_alloc_cnt++;
 	mutex_exit(proc_lock);
 	return pid;
+}
 /*
  * Free a process id - called from proc_free (in kern_exit.c)
+ *
  * Called with the proc_lock held.
  */
 void
 proc_free_pid(pid_t pid)
+{
 	struct pid_table *pt;
 	KASSERT(mutex_owned(proc_lock));
 	pt = &pid_table[pid & pid_tbl_mask];
 	/* save pid use count in slot */
 	pt->pt_proc = P_FREE(pid & ~pid_tbl_mask);
 	KASSERT(pt->pt_pid == pid);
 	pt->pt_pid = 0;
 	if (pt->pt_pgrp == NULL) {
 		/* link last freed entry onto ours */
 		pid &= pid_tbl_mask;
 		pt = &pid_table[last_free_pt];
 		pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pid);
 		pt->pt_pid = 0;
 		last_free_pt = pid;
 		pid_alloc_cnt--;
+	}
 	atomic_dec_uint(&nprocs);
+}
 void
 proc_free_mem(struct proc *p)
+{
 	kdtrace_proc_dtor(NULL, p);
 	pool_cache_put(proc_cache, p);
+}
 /*
  * proc_enterpgrp: move p to a new or existing process group (and session).
+ *
  * If we are creating a new pgrp, the pgid should equal
  * the calling process' pid.
  * If is only valid to enter a process group that is in the session
  * of the process.
  * Also mksess should only be set if we are creating a process group
+ *
  * Only called from sys_setsid, sys_setpgid and posix_spawn/spawn_return.
  */
 int
 proc_enterpgrp(struct proc *curp, pid_t pid, pid_t pgid, bool mksess)
+{
 	struct pgrp *new_pgrp, *pgrp;
 	struct session *sess;
 	struct proc *p;
 	int rval;
 	pid_t pg_id = NO_PGID;
 	sess = mksess ? kmem_alloc(sizeof(*sess), KM_SLEEP) : NULL;
 	/* Allocate data areas we might need before doing any validity checks */
 	mutex_enter(proc_lock);		/* Because pid_table might change */
 	if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) {
 		mutex_exit(proc_lock);
 		new_pgrp = kmem_alloc(sizeof(*new_pgrp), KM_SLEEP);
 		mutex_enter(proc_lock);
 	} else
 		new_pgrp = NULL;
 	rval = EPERM;	/* most common error (to save typing) */
 	/* Check pgrp exists or can be created */
 	pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp;
 	if (pgrp != NULL && pgrp->pg_id != pgid)
 		goto done;
 	/* Can only set another process under restricted circumstances. */
 	if (pid != curp->p_pid) {
 		/* Must exist and be one of our children... */
 		p = proc_find(pid);
 		if (p == NULL || !p_inferior(p, curp)) {
 			rval = ESRCH;
 			goto done;
+		}
 		/* ... in the same session... */
 		if (sess != NULL || p->p_session != curp->p_session)
 			goto done;
 		/* ... existing pgid must be in same session ... */
 		if (pgrp != NULL && pgrp->pg_session != p->p_session)
 			goto done;
 		/* ... and not done an exec. */
 		if (p->p_flag & PK_EXEC) {
 			rval = EACCES;
 			goto done;
+		}
 	} else {
 		/* ... setsid() cannot re-enter a pgrp */
 		if (mksess && (curp->p_pgid == curp->p_pid ||
 		    pgrp_find(curp->p_pid)))
 			goto done;
 		p = curp;
+	}
 	/* Changing the process group/session of a session
 	   leader is definitely off limits. */
 	if (SESS_LEADER(p)) {
 		if (sess == NULL && p->p_pgrp == pgrp)
 			/* unless it's a definite noop */
 			rval = 0;
 		goto done;
+	}
 	/* Can only create a process group with id of process */
 	if (pgrp == NULL && pgid != pid)
 		goto done;
 	/* Can only create a session if creating pgrp */
 	if (sess != NULL && pgrp != NULL)
 		goto done;
 	/* Check we allocated memory for a pgrp... */
 	if (pgrp == NULL && new_pgrp == NULL)
 		goto done;
 	/* Don't attach to 'zombie' pgrp */
 	if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members))
 		goto done;
 	/* Expect to succeed now */
 	rval = 0;
 	if (pgrp == p->p_pgrp)
 		/* nothing to do */
 		goto done;
 	/* Ok all setup, link up required structures */
 	if (pgrp == NULL) {
 		pgrp = new_pgrp;
 		new_pgrp = NULL;
 		if (sess != NULL) {
 			sess->s_sid = p->p_pid;
 			sess->s_leader = p;
 			sess->s_count = 1;
 			sess->s_ttyvp = NULL;
 			sess->s_ttyp = NULL;
 			sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET;
 			memcpy(sess->s_login, p->p_session->s_login,
 			    sizeof(sess->s_login));
 			p->p_lflag &= ~PL_CONTROLT;
 		} else {
 			sess = p->p_pgrp->pg_session;
 			proc_sesshold(sess);
+		}
 		pgrp->pg_session = sess;
 		sess = NULL;
 		pgrp->pg_id = pgid;
 		LIST_INIT(&pgrp->pg_members);
 #ifdef DIAGNOSTIC
 		if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp))
 			panic("enterpgrp: pgrp table slot in use");
 		if (__predict_false(mksess && p != curp))
 			panic("enterpgrp: mksession and p != curproc");
 #endif
 		pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp;
 		pgrp->pg_jobc = 0;
+	}
 	/*
 	 * Adjust eligibility of affected pgrps to participate in job control.
 	 * Increment eligibility counts before decrementing, otherwise we
 	 * could reach 0 spuriously during the first call.
 	 */
 	fixjobc(p, pgrp, 1);
 	fixjobc(p, p->p_pgrp, 0);
 	/* Interlock with ttread(). */
 	mutex_spin_enter(&tty_lock);
 	/* Move process to requested group. */
 	LIST_REMOVE(p, p_pglist);
 	if (LIST_EMPTY(&p->p_pgrp->pg_members))
 		/* defer delete until we've dumped the lock */
 		pg_id = p->p_pgrp->pg_id;
 	p->p_pgrp = pgrp;
 	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
 	/* Done with the swap; we can release the tty mutex. */
 	mutex_spin_exit(&tty_lock);
     done:
 	if (pg_id != NO_PGID) {
 		/* Releases proc_lock. */
 		pg_delete(pg_id);
 	} else {
 		mutex_exit(proc_lock);
+	}
 	if (sess != NULL)
 		kmem_free(sess, sizeof(*sess));
 	if (new_pgrp != NULL)
 		kmem_free(new_pgrp, sizeof(*new_pgrp));
 #ifdef DEBUG_PGRP
 	if (__predict_false(rval))
 		printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n",
 			pid, pgid, mksess, curp->p_pid, rval);
 #endif
 	return rval;
+}
 /*
  * proc_leavepgrp: remove a process from its process group.
  *  => must be called with the proc_lock held, which will be released;
  */
 void
 proc_leavepgrp(struct proc *p)
+{
 	struct pgrp *pgrp;
 	KASSERT(mutex_owned(proc_lock));
 	/* Interlock with ttread() */
 	mutex_spin_enter(&tty_lock);
 	pgrp = p->p_pgrp;
 	LIST_REMOVE(p, p_pglist);
 	p->p_pgrp = NULL;
 	mutex_spin_exit(&tty_lock);
 	if (LIST_EMPTY(&pgrp->pg_members)) {
 		/* Releases proc_lock. */
 		pg_delete(pgrp->pg_id);
 	} else {
 		mutex_exit(proc_lock);
+	}
+}
 /*
  * pg_remove: remove a process group from the table.
  *  => must be called with the proc_lock held;
  *  => returns process group to free;
  */
 static struct pgrp *
 pg_remove(pid_t pg_id)
+{
 	struct pgrp *pgrp;
 	struct pid_table *pt;
 	KASSERT(mutex_owned(proc_lock));
 	pt = &pid_table[pg_id & pid_tbl_mask];
 	pgrp = pt->pt_pgrp;
 	KASSERT(pgrp != NULL);
 	KASSERT(pgrp->pg_id == pg_id);
 	KASSERT(LIST_EMPTY(&pgrp->pg_members));
 	pt->pt_pgrp = NULL;
 	if (!P_VALID(pt->pt_proc)) {
 		/* Orphaned pgrp, put slot onto free list. */
 		KASSERT((P_NEXT(pt->pt_proc) & pid_tbl_mask) == 0);
 		pg_id &= pid_tbl_mask;
 		pt = &pid_table[last_free_pt];
 		pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pg_id);
 		KASSERT(pt->pt_pid == 0);
 		last_free_pt = pg_id;
 		pid_alloc_cnt--;
+	}
 	return pgrp;
+}
 /*
  * pg_delete: delete and free a process group.
  *  => must be called with the proc_lock held, which will be released.
  */
 static void
 pg_delete(pid_t pg_id)
+{
 	struct pgrp *pg;
 	struct tty *ttyp;
 	struct session *ss;
 	KASSERT(mutex_owned(proc_lock));
 	pg = pid_table[pg_id & pid_tbl_mask].pt_pgrp;
 	if (pg == NULL || pg->pg_id != pg_id || !LIST_EMPTY(&pg->pg_members)) {
 		mutex_exit(proc_lock);
 		return;
+	}
 	ss = pg->pg_session;
 	/* Remove reference (if any) from tty to this process group */
 	mutex_spin_enter(&tty_lock);
 	ttyp = ss->s_ttyp;
 	if (ttyp != NULL && ttyp->t_pgrp == pg) {
 		ttyp->t_pgrp = NULL;
 		KASSERT(ttyp->t_session == ss);
+	}
 	mutex_spin_exit(&tty_lock);
 	/*
 	 * The leading process group in a session is freed by proc_sessrele(),
 	 * if last reference.  Note: proc_sessrele() releases proc_lock.
 	 */