xref: /illumos-gate/usr/src/uts/common/os/pid.c (revision 6a0b1217)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
59acbbeafSnn  * Common Development and Distribution License (the "License").
69acbbeafSnn  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
2197eda132Sraf 
227c478bd9Sstevel@tonic-gate /*
239ff75adeSSurya Prakki  * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24*6a0b1217SPatrick Mooney  * Copyright 2019 Joyent, Inc.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28*6a0b1217SPatrick Mooney /*	  All Rights Reserved	*/
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #include <sys/types.h>
317c478bd9Sstevel@tonic-gate #include <sys/param.h>
327c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
337c478bd9Sstevel@tonic-gate #include <sys/proc.h>
347c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
357c478bd9Sstevel@tonic-gate #include <sys/tuneable.h>
367c478bd9Sstevel@tonic-gate #include <sys/var.h>
377c478bd9Sstevel@tonic-gate #include <sys/cred.h>
387c478bd9Sstevel@tonic-gate #include <sys/systm.h>
397c478bd9Sstevel@tonic-gate #include <sys/prsystm.h>
407c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
417c478bd9Sstevel@tonic-gate #include <sys/session.h>
427c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
437c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
447c478bd9Sstevel@tonic-gate #include <sys/bitmap.h>
457c478bd9Sstevel@tonic-gate #include <sys/debug.h>
467c478bd9Sstevel@tonic-gate #include <c2/audit.h>
474bcbe6e7SMenno Lageman #include <sys/project.h>
484bcbe6e7SMenno Lageman #include <sys/task.h>
497c478bd9Sstevel@tonic-gate #include <sys/zone.h>
507c478bd9Sstevel@tonic-gate 
517c478bd9Sstevel@tonic-gate /* directory entries for /proc */
527c478bd9Sstevel@tonic-gate union procent {
537c478bd9Sstevel@tonic-gate 	proc_t *pe_proc;
547c478bd9Sstevel@tonic-gate 	union procent *pe_next;
557c478bd9Sstevel@tonic-gate };
567c478bd9Sstevel@tonic-gate 
577c478bd9Sstevel@tonic-gate struct pid pid0 = {
587c478bd9Sstevel@tonic-gate 	0,		/* pid_prinactive */
597c478bd9Sstevel@tonic-gate 	1,		/* pid_pgorphaned */
607c478bd9Sstevel@tonic-gate 	0,		/* pid_padding	*/
617c478bd9Sstevel@tonic-gate 	0,		/* pid_prslot	*/
627c478bd9Sstevel@tonic-gate 	0,		/* pid_id	*/
637c478bd9Sstevel@tonic-gate 	NULL,		/* pid_pglink	*/
64e44bd21cSsusans 	NULL,		/* pid_pgtail	*/
657c478bd9Sstevel@tonic-gate 	NULL,		/* pid_link	*/
667c478bd9Sstevel@tonic-gate 	3		/* pid_ref	*/
677c478bd9Sstevel@tonic-gate };
687c478bd9Sstevel@tonic-gate 
697c478bd9Sstevel@tonic-gate static int pid_hashlen = 4;	/* desired average hash chain length */
707c478bd9Sstevel@tonic-gate static int pid_hashsz;		/* number of buckets in the hash table */
717c478bd9Sstevel@tonic-gate 
727c478bd9Sstevel@tonic-gate #define	HASHPID(pid)	(pidhash[((pid)&(pid_hashsz-1))])
737c478bd9Sstevel@tonic-gate 
747c478bd9Sstevel@tonic-gate extern uint_t nproc;
757c478bd9Sstevel@tonic-gate extern struct kmem_cache *process_cache;
767c478bd9Sstevel@tonic-gate static void	upcount_init(void);
777c478bd9Sstevel@tonic-gate 
787c478bd9Sstevel@tonic-gate kmutex_t	pidlock;	/* global process lock */
797c478bd9Sstevel@tonic-gate kmutex_t	pr_pidlock;	/* /proc global process lock */
807c478bd9Sstevel@tonic-gate kcondvar_t	*pr_pid_cv;	/* for /proc, one per process slot */
817c478bd9Sstevel@tonic-gate struct plock	*proc_lock;	/* persistent array of p_lock's */
827c478bd9Sstevel@tonic-gate 
837c478bd9Sstevel@tonic-gate /*
847c478bd9Sstevel@tonic-gate  * See the comment above pid_getlockslot() for a detailed explanation of this
857c478bd9Sstevel@tonic-gate  * constant.  Note that a PLOCK_SHIFT of 3 implies 64-byte coherence
867c478bd9Sstevel@tonic-gate  * granularity; if the coherence granularity is ever changed, this constant
877c478bd9Sstevel@tonic-gate  * should be modified to reflect the change to minimize proc_lock false
887c478bd9Sstevel@tonic-gate  * sharing (correctness, however, is guaranteed regardless of the coherence
897c478bd9Sstevel@tonic-gate  * granularity).
907c478bd9Sstevel@tonic-gate  */
917c478bd9Sstevel@tonic-gate #define	PLOCK_SHIFT	3
927c478bd9Sstevel@tonic-gate 
937c478bd9Sstevel@tonic-gate static kmutex_t	pidlinklock;
947c478bd9Sstevel@tonic-gate static struct pid **pidhash;
957c478bd9Sstevel@tonic-gate static pid_t minpid;
9635a5a358SJonathan Adams static pid_t mpid = FAMOUS_PIDS;	/* one more than the last famous pid */
977c478bd9Sstevel@tonic-gate static union procent *procdir;
987c478bd9Sstevel@tonic-gate static union procent *procentfree;
997c478bd9Sstevel@tonic-gate 
1007c478bd9Sstevel@tonic-gate static struct pid *
pid_lookup(pid_t pid)1017c478bd9Sstevel@tonic-gate pid_lookup(pid_t pid)
1027c478bd9Sstevel@tonic-gate {
1037c478bd9Sstevel@tonic-gate 	struct pid *pidp;
1047c478bd9Sstevel@tonic-gate 
1057c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlinklock));
1067c478bd9Sstevel@tonic-gate 
1077c478bd9Sstevel@tonic-gate 	for (pidp = HASHPID(pid); pidp; pidp = pidp->pid_link) {
1087c478bd9Sstevel@tonic-gate 		if (pidp->pid_id == pid) {
1097c478bd9Sstevel@tonic-gate 			ASSERT(pidp->pid_ref > 0);
1107c478bd9Sstevel@tonic-gate 			break;
1117c478bd9Sstevel@tonic-gate 		}
1127c478bd9Sstevel@tonic-gate 	}
1137c478bd9Sstevel@tonic-gate 	return (pidp);
1147c478bd9Sstevel@tonic-gate }
1157c478bd9Sstevel@tonic-gate 
1167c478bd9Sstevel@tonic-gate void
pid_setmin(void)1177c478bd9Sstevel@tonic-gate pid_setmin(void)
1187c478bd9Sstevel@tonic-gate {
1197c478bd9Sstevel@tonic-gate 	if (jump_pid && jump_pid > mpid)
1207c478bd9Sstevel@tonic-gate 		minpid = mpid = jump_pid;
1217c478bd9Sstevel@tonic-gate 	else
12235a5a358SJonathan Adams 		minpid = mpid;
1237c478bd9Sstevel@tonic-gate }
1247c478bd9Sstevel@tonic-gate 
1257c478bd9Sstevel@tonic-gate /*
1267c478bd9Sstevel@tonic-gate  * When prslots are simply used as an index to determine a process' p_lock,
1277c478bd9Sstevel@tonic-gate  * adjacent prslots share adjacent p_locks.  On machines where the size
1287c478bd9Sstevel@tonic-gate  * of a mutex is smaller than that of a cache line (which, as of this writing,
1297c478bd9Sstevel@tonic-gate  * is true for all machines on which Solaris runs), this can potentially
1307c478bd9Sstevel@tonic-gate  * induce false sharing.  The standard solution for false sharing is to pad
1317c478bd9Sstevel@tonic-gate  * out one's data structures (in this case, struct plock).  However,
1327c478bd9Sstevel@tonic-gate  * given the size and (generally) sparse use of the proc_lock array, this
1337c478bd9Sstevel@tonic-gate  * is suboptimal.  We therefore stride through the proc_lock array with
1347c478bd9Sstevel@tonic-gate  * a stride of PLOCK_SHIFT.  PLOCK_SHIFT should be defined as:
1357c478bd9Sstevel@tonic-gate  *
1367c478bd9Sstevel@tonic-gate  *   log_2 (coherence_granularity / sizeof (kmutex_t))
1377c478bd9Sstevel@tonic-gate  *
1387c478bd9Sstevel@tonic-gate  * Under this scheme, false sharing is still possible -- but only when
1397c478bd9Sstevel@tonic-gate  * the number of active processes is very large.  Note that the one-to-one
1407c478bd9Sstevel@tonic-gate  * mapping between prslots and lockslots is maintained.
1417c478bd9Sstevel@tonic-gate  */
1427c478bd9Sstevel@tonic-gate static int
pid_getlockslot(int prslot)1437c478bd9Sstevel@tonic-gate pid_getlockslot(int prslot)
1447c478bd9Sstevel@tonic-gate {
1457c478bd9Sstevel@tonic-gate 	int even = (v.v_proc >> PLOCK_SHIFT) << PLOCK_SHIFT;
1467c478bd9Sstevel@tonic-gate 	int perlap = even >> PLOCK_SHIFT;
1477c478bd9Sstevel@tonic-gate 
1487c478bd9Sstevel@tonic-gate 	if (prslot >= even)
1497c478bd9Sstevel@tonic-gate 		return (prslot);
1507c478bd9Sstevel@tonic-gate 
1517c478bd9Sstevel@tonic-gate 	return (((prslot % perlap) << PLOCK_SHIFT) + (prslot / perlap));
1527c478bd9Sstevel@tonic-gate }
1537c478bd9Sstevel@tonic-gate 
1547c478bd9Sstevel@tonic-gate /*
1559acbbeafSnn  * This function allocates a pid structure, a free pid, and optionally a
1569acbbeafSnn  * slot in the proc table for it.
1577c478bd9Sstevel@tonic-gate  *
1589acbbeafSnn  * pid_allocate() returns the new pid on success, -1 on failure.
1597c478bd9Sstevel@tonic-gate  */
1607c478bd9Sstevel@tonic-gate pid_t
pid_allocate(proc_t * prp,pid_t pid,int flags)16135a5a358SJonathan Adams pid_allocate(proc_t *prp, pid_t pid, int flags)
1627c478bd9Sstevel@tonic-gate {
1637c478bd9Sstevel@tonic-gate 	struct pid *pidp;
1647c478bd9Sstevel@tonic-gate 	union procent *pep;
1657c478bd9Sstevel@tonic-gate 	pid_t newpid, startpid;
1667c478bd9Sstevel@tonic-gate 
1677c478bd9Sstevel@tonic-gate 	pidp = kmem_zalloc(sizeof (struct pid), KM_SLEEP);
1687c478bd9Sstevel@tonic-gate 
1697c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlinklock);
170c6f039c7SToomas Soome 	pep = procentfree;
171c6f039c7SToomas Soome 	if ((flags & PID_ALLOC_PROC) && pep == NULL) {
1727c478bd9Sstevel@tonic-gate 		/*
1737c478bd9Sstevel@tonic-gate 		 * ran out of /proc directory entries
1747c478bd9Sstevel@tonic-gate 		 */
1757c478bd9Sstevel@tonic-gate 		goto failed;
1767c478bd9Sstevel@tonic-gate 	}
1777c478bd9Sstevel@tonic-gate 
17835a5a358SJonathan Adams 	if (pid != 0) {
17935a5a358SJonathan Adams 		VERIFY(minpid == 0);
18035a5a358SJonathan Adams 		VERIFY3P(pid, <, mpid);
18135a5a358SJonathan Adams 		VERIFY3P(pid_lookup(pid), ==, NULL);
18235a5a358SJonathan Adams 		newpid = pid;
18335a5a358SJonathan Adams 	} else {
18435a5a358SJonathan Adams 		/*
18535a5a358SJonathan Adams 		 * Allocate a pid
18635a5a358SJonathan Adams 		 */
1878f14225bSRoger A. Faulkner 		ASSERT(minpid <= mpid && mpid < maxpid);
1887c478bd9Sstevel@tonic-gate 
18935a5a358SJonathan Adams 		startpid = mpid;
19035a5a358SJonathan Adams 		for (;;) {
19135a5a358SJonathan Adams 			newpid = mpid;
1928f14225bSRoger A. Faulkner 			if (++mpid == maxpid)
19335a5a358SJonathan Adams 				mpid = minpid;
19435a5a358SJonathan Adams 
19535a5a358SJonathan Adams 			if (pid_lookup(newpid) == NULL)
19635a5a358SJonathan Adams 				break;
19735a5a358SJonathan Adams 
19835a5a358SJonathan Adams 			if (mpid == startpid)
19935a5a358SJonathan Adams 				goto failed;
20035a5a358SJonathan Adams 		}
2017c478bd9Sstevel@tonic-gate 	}
2027c478bd9Sstevel@tonic-gate 
2037c478bd9Sstevel@tonic-gate 	/*
2047c478bd9Sstevel@tonic-gate 	 * Put pid into the pid hash table.
2057c478bd9Sstevel@tonic-gate 	 */
2067c478bd9Sstevel@tonic-gate 	pidp->pid_link = HASHPID(newpid);
2077c478bd9Sstevel@tonic-gate 	HASHPID(newpid) = pidp;
2087c478bd9Sstevel@tonic-gate 	pidp->pid_ref = 1;
2097c478bd9Sstevel@tonic-gate 	pidp->pid_id = newpid;
2109acbbeafSnn 
2119acbbeafSnn 	if (flags & PID_ALLOC_PROC) {
2129acbbeafSnn 		procentfree = pep->pe_next;
2139acbbeafSnn 		pidp->pid_prslot = pep - procdir;
2149acbbeafSnn 		pep->pe_proc = prp;
2159acbbeafSnn 		prp->p_pidp = pidp;
2169acbbeafSnn 		prp->p_lockp = &proc_lock[pid_getlockslot(pidp->pid_prslot)];
2179acbbeafSnn 	} else {
2189acbbeafSnn 		pidp->pid_prslot = 0;
2199acbbeafSnn 	}
2209acbbeafSnn 
2217c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlinklock);
2227c478bd9Sstevel@tonic-gate 
2237c478bd9Sstevel@tonic-gate 	return (newpid);
2247c478bd9Sstevel@tonic-gate 
2257c478bd9Sstevel@tonic-gate failed:
2267c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlinklock);
2277c478bd9Sstevel@tonic-gate 	kmem_free(pidp, sizeof (struct pid));
2287c478bd9Sstevel@tonic-gate 	return (-1);
2297c478bd9Sstevel@tonic-gate }
2307c478bd9Sstevel@tonic-gate 
2317c478bd9Sstevel@tonic-gate /*
2327c478bd9Sstevel@tonic-gate  * decrement the reference count for pid
2337c478bd9Sstevel@tonic-gate  */
2347c478bd9Sstevel@tonic-gate int
pid_rele(struct pid * pidp)2357c478bd9Sstevel@tonic-gate pid_rele(struct pid *pidp)
2367c478bd9Sstevel@tonic-gate {
2377c478bd9Sstevel@tonic-gate 	struct pid **pidpp;
2387c478bd9Sstevel@tonic-gate 
2397c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlinklock);
2407c478bd9Sstevel@tonic-gate 	ASSERT(pidp != &pid0);
2417c478bd9Sstevel@tonic-gate 
2427c478bd9Sstevel@tonic-gate 	pidpp = &HASHPID(pidp->pid_id);
2437c478bd9Sstevel@tonic-gate 	for (;;) {
2447c478bd9Sstevel@tonic-gate 		ASSERT(*pidpp != NULL);
2457c478bd9Sstevel@tonic-gate 		if (*pidpp == pidp)
2467c478bd9Sstevel@tonic-gate 			break;
2477c478bd9Sstevel@tonic-gate 		pidpp = &(*pidpp)->pid_link;
2487c478bd9Sstevel@tonic-gate 	}
2497c478bd9Sstevel@tonic-gate 
2507c478bd9Sstevel@tonic-gate 	*pidpp = pidp->pid_link;
2517c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlinklock);
2527c478bd9Sstevel@tonic-gate 
2537c478bd9Sstevel@tonic-gate 	kmem_free(pidp, sizeof (*pidp));
2547c478bd9Sstevel@tonic-gate 	return (0);
2557c478bd9Sstevel@tonic-gate }
2567c478bd9Sstevel@tonic-gate 
2577c478bd9Sstevel@tonic-gate void
proc_entry_free(struct pid * pidp)2587c478bd9Sstevel@tonic-gate proc_entry_free(struct pid *pidp)
2597c478bd9Sstevel@tonic-gate {
2607c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlinklock);
2617c478bd9Sstevel@tonic-gate 	pidp->pid_prinactive = 1;
2627c478bd9Sstevel@tonic-gate 	procdir[pidp->pid_prslot].pe_next = procentfree;
2637c478bd9Sstevel@tonic-gate 	procentfree = &procdir[pidp->pid_prslot];
2647c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlinklock);
2657c478bd9Sstevel@tonic-gate }
2667c478bd9Sstevel@tonic-gate 
2674bcbe6e7SMenno Lageman /*
2684bcbe6e7SMenno Lageman  * The original task needs to be passed in since the process has already been
2694bcbe6e7SMenno Lageman  * detached from the task at this point in time.
2704bcbe6e7SMenno Lageman  */
2717c478bd9Sstevel@tonic-gate void
pid_exit(proc_t * prp,struct task * tk)2724bcbe6e7SMenno Lageman pid_exit(proc_t *prp, struct task *tk)
2737c478bd9Sstevel@tonic-gate {
2747c478bd9Sstevel@tonic-gate 	struct pid *pidp;
2754bcbe6e7SMenno Lageman 	zone_t	*zone = prp->p_zone;
2767c478bd9Sstevel@tonic-gate 
2777c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
2787c478bd9Sstevel@tonic-gate 
2797c478bd9Sstevel@tonic-gate 	/*
2807c478bd9Sstevel@tonic-gate 	 * Exit process group.  If it is NULL, it's because fork failed
2817c478bd9Sstevel@tonic-gate 	 * before calling pgjoin().
2827c478bd9Sstevel@tonic-gate 	 */
2837c478bd9Sstevel@tonic-gate 	ASSERT(prp->p_pgidp != NULL || prp->p_stat == SIDL);
2847c478bd9Sstevel@tonic-gate 	if (prp->p_pgidp != NULL)
2857c478bd9Sstevel@tonic-gate 		pgexit(prp);
2867c478bd9Sstevel@tonic-gate 
2879acbbeafSnn 	sess_rele(prp->p_sessp, B_TRUE);
2887c478bd9Sstevel@tonic-gate 
2897c478bd9Sstevel@tonic-gate 	pidp = prp->p_pidp;
2907c478bd9Sstevel@tonic-gate 
2917c478bd9Sstevel@tonic-gate 	proc_entry_free(pidp);
2927c478bd9Sstevel@tonic-gate 
2937c478bd9Sstevel@tonic-gate 	if (audit_active)
2947c478bd9Sstevel@tonic-gate 		audit_pfree(prp);
2957c478bd9Sstevel@tonic-gate 
2967c478bd9Sstevel@tonic-gate 	if (practive == prp) {
2977c478bd9Sstevel@tonic-gate 		practive = prp->p_next;
2987c478bd9Sstevel@tonic-gate 	}
2997c478bd9Sstevel@tonic-gate 
3007c478bd9Sstevel@tonic-gate 	if (prp->p_next) {
3017c478bd9Sstevel@tonic-gate 		prp->p_next->p_prev = prp->p_prev;
3027c478bd9Sstevel@tonic-gate 	}
3037c478bd9Sstevel@tonic-gate 	if (prp->p_prev) {
3047c478bd9Sstevel@tonic-gate 		prp->p_prev->p_next = prp->p_next;
3057c478bd9Sstevel@tonic-gate 	}
3067c478bd9Sstevel@tonic-gate 
3077c478bd9Sstevel@tonic-gate 	PID_RELE(pidp);
3087c478bd9Sstevel@tonic-gate 
3097c478bd9Sstevel@tonic-gate 	mutex_destroy(&prp->p_crlock);
3107c478bd9Sstevel@tonic-gate 	kmem_cache_free(process_cache, prp);
3117c478bd9Sstevel@tonic-gate 	nproc--;
3124bcbe6e7SMenno Lageman 
3134bcbe6e7SMenno Lageman 	/*
3144bcbe6e7SMenno Lageman 	 * Decrement the process counts of the original task, project and zone.
3154bcbe6e7SMenno Lageman 	 */
3164bcbe6e7SMenno Lageman 	mutex_enter(&zone->zone_nlwps_lock);
3174bcbe6e7SMenno Lageman 	tk->tk_nprocs--;
3184bcbe6e7SMenno Lageman 	tk->tk_proj->kpj_nprocs--;
3194bcbe6e7SMenno Lageman 	zone->zone_nprocs--;
3204bcbe6e7SMenno Lageman 	mutex_exit(&zone->zone_nlwps_lock);
3217c478bd9Sstevel@tonic-gate }
3227c478bd9Sstevel@tonic-gate 
3237c478bd9Sstevel@tonic-gate /*
3247c478bd9Sstevel@tonic-gate  * Find a process visible from the specified zone given its process ID.
3257c478bd9Sstevel@tonic-gate  */
3267c478bd9Sstevel@tonic-gate proc_t *
prfind_zone(pid_t pid,zoneid_t zoneid)3277c478bd9Sstevel@tonic-gate prfind_zone(pid_t pid, zoneid_t zoneid)
3287c478bd9Sstevel@tonic-gate {
3297c478bd9Sstevel@tonic-gate 	struct pid *pidp;
3307c478bd9Sstevel@tonic-gate 	proc_t *p;
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
3337c478bd9Sstevel@tonic-gate 
3347c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlinklock);
3357c478bd9Sstevel@tonic-gate 	pidp = pid_lookup(pid);
3367c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlinklock);
3377c478bd9Sstevel@tonic-gate 	if (pidp != NULL && pidp->pid_prinactive == 0) {
3387c478bd9Sstevel@tonic-gate 		p = procdir[pidp->pid_prslot].pe_proc;
3397c478bd9Sstevel@tonic-gate 		if (zoneid == ALL_ZONES || p->p_zone->zone_id == zoneid)
3407c478bd9Sstevel@tonic-gate 			return (p);
3417c478bd9Sstevel@tonic-gate 	}
3427c478bd9Sstevel@tonic-gate 	return (NULL);
3437c478bd9Sstevel@tonic-gate }
3447c478bd9Sstevel@tonic-gate 
3457c478bd9Sstevel@tonic-gate /*
3467c478bd9Sstevel@tonic-gate  * Find a process given its process ID.  This obeys zone restrictions,
3477c478bd9Sstevel@tonic-gate  * so if the caller is in a non-global zone it won't find processes
3487c478bd9Sstevel@tonic-gate  * associated with other zones.  Use prfind_zone(pid, ALL_ZONES) to
3497c478bd9Sstevel@tonic-gate  * bypass this restriction.
3507c478bd9Sstevel@tonic-gate  */
3517c478bd9Sstevel@tonic-gate proc_t *
prfind(pid_t pid)3527c478bd9Sstevel@tonic-gate prfind(pid_t pid)
3537c478bd9Sstevel@tonic-gate {
3547c478bd9Sstevel@tonic-gate 	zoneid_t zoneid;
3557c478bd9Sstevel@tonic-gate 
3567c478bd9Sstevel@tonic-gate 	if (INGLOBALZONE(curproc))
3577c478bd9Sstevel@tonic-gate 		zoneid = ALL_ZONES;
3587c478bd9Sstevel@tonic-gate 	else
3597c478bd9Sstevel@tonic-gate 		zoneid = getzoneid();
3607c478bd9Sstevel@tonic-gate 	return (prfind_zone(pid, zoneid));
3617c478bd9Sstevel@tonic-gate }
3627c478bd9Sstevel@tonic-gate 
3637c478bd9Sstevel@tonic-gate proc_t *
pgfind_zone(pid_t pgid,zoneid_t zoneid)3647c478bd9Sstevel@tonic-gate pgfind_zone(pid_t pgid, zoneid_t zoneid)
3657c478bd9Sstevel@tonic-gate {
3667c478bd9Sstevel@tonic-gate 	struct pid *pidp;
3677c478bd9Sstevel@tonic-gate 
3687c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
3697c478bd9Sstevel@tonic-gate 
3707c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlinklock);
3717c478bd9Sstevel@tonic-gate 	pidp = pid_lookup(pgid);
3727c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlinklock);
3737c478bd9Sstevel@tonic-gate 	if (pidp != NULL) {
3747c478bd9Sstevel@tonic-gate 		proc_t *p = pidp->pid_pglink;
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate 		if (zoneid == ALL_ZONES || pgid == 0 || p == NULL ||
3777c478bd9Sstevel@tonic-gate 		    p->p_zone->zone_id == zoneid)
3787c478bd9Sstevel@tonic-gate 			return (p);
3797c478bd9Sstevel@tonic-gate 	}
3807c478bd9Sstevel@tonic-gate 	return (NULL);
3817c478bd9Sstevel@tonic-gate }
3827c478bd9Sstevel@tonic-gate 
3837c478bd9Sstevel@tonic-gate /*
3847c478bd9Sstevel@tonic-gate  * return the head of the list of processes whose process group ID is 'pgid',
3857c478bd9Sstevel@tonic-gate  * or NULL, if no such process group
3867c478bd9Sstevel@tonic-gate  */
3877c478bd9Sstevel@tonic-gate proc_t *
pgfind(pid_t pgid)3887c478bd9Sstevel@tonic-gate pgfind(pid_t pgid)
3897c478bd9Sstevel@tonic-gate {
3907c478bd9Sstevel@tonic-gate 	zoneid_t zoneid;
3917c478bd9Sstevel@tonic-gate 
3927c478bd9Sstevel@tonic-gate 	if (INGLOBALZONE(curproc))
3937c478bd9Sstevel@tonic-gate 		zoneid = ALL_ZONES;
3947c478bd9Sstevel@tonic-gate 	else
3957c478bd9Sstevel@tonic-gate 		zoneid = getzoneid();
3967c478bd9Sstevel@tonic-gate 	return (pgfind_zone(pgid, zoneid));
3977c478bd9Sstevel@tonic-gate }
3987c478bd9Sstevel@tonic-gate 
3990209230bSgjelinek /*
4000209230bSgjelinek  * Sets P_PR_LOCK on a non-system process.  Process must be fully created
4010209230bSgjelinek  * and not exiting to succeed.
4020209230bSgjelinek  *
4030209230bSgjelinek  * Returns 0 on success.
4040209230bSgjelinek  * Returns 1 if P_PR_LOCK is set.
4050209230bSgjelinek  * Returns -1 if proc is in invalid state.
4060209230bSgjelinek  */
4070209230bSgjelinek int
sprtrylock_proc(proc_t * p)4080209230bSgjelinek sprtrylock_proc(proc_t *p)
4090209230bSgjelinek {
4100209230bSgjelinek 	ASSERT(MUTEX_HELD(&p->p_lock));
4110209230bSgjelinek 
4120209230bSgjelinek 	/* skip system and incomplete processes */
4130209230bSgjelinek 	if (p->p_stat == SIDL || p->p_stat == SZOMB ||
4140209230bSgjelinek 	    (p->p_flag & (SSYS | SEXITING | SEXITLWPS))) {
4150209230bSgjelinek 		return (-1);
4160209230bSgjelinek 	}
4170209230bSgjelinek 
4180209230bSgjelinek 	if (p->p_proc_flag & P_PR_LOCK)
4190209230bSgjelinek 		return (1);
4200209230bSgjelinek 
4210209230bSgjelinek 	p->p_proc_flag |= P_PR_LOCK;
4220209230bSgjelinek 
4230209230bSgjelinek 	return (0);
4240209230bSgjelinek }
4250209230bSgjelinek 
4260209230bSgjelinek /*
4270209230bSgjelinek  * Wait for P_PR_LOCK to become clear.  Returns with p_lock dropped,
4280209230bSgjelinek  * and the proc pointer no longer valid, as the proc may have exited.
4290209230bSgjelinek  */
4300209230bSgjelinek void
sprwaitlock_proc(proc_t * p)4310209230bSgjelinek sprwaitlock_proc(proc_t *p)
4320209230bSgjelinek {
4330209230bSgjelinek 	kmutex_t *mp;
4340209230bSgjelinek 
4350209230bSgjelinek 	ASSERT(MUTEX_HELD(&p->p_lock));
4360209230bSgjelinek 	ASSERT(p->p_proc_flag & P_PR_LOCK);
4370209230bSgjelinek 
4380209230bSgjelinek 	/*
4390209230bSgjelinek 	 * p_lock is persistent, but p itself is not -- it could
4400209230bSgjelinek 	 * vanish during cv_wait().  Load p->p_lock now so we can
4410209230bSgjelinek 	 * drop it after cv_wait() without referencing p.
4420209230bSgjelinek 	 */
4430209230bSgjelinek 	mp = &p->p_lock;
4440209230bSgjelinek 	cv_wait(&pr_pid_cv[p->p_slot], mp);
4450209230bSgjelinek 	mutex_exit(mp);
4460209230bSgjelinek }
4470209230bSgjelinek 
4487c478bd9Sstevel@tonic-gate /*
4497c478bd9Sstevel@tonic-gate  * If pid exists, find its proc, acquire its p_lock and mark it P_PR_LOCK.
4507c478bd9Sstevel@tonic-gate  * Returns the proc pointer on success, NULL on failure.  sprlock() is
4517c478bd9Sstevel@tonic-gate  * really just a stripped-down version of pr_p_lock() to allow practive
4527c478bd9Sstevel@tonic-gate  * walkers like dofusers() and dumpsys() to synchronize with /proc.
4537c478bd9Sstevel@tonic-gate  */
4547c478bd9Sstevel@tonic-gate proc_t *
sprlock_zone(pid_t pid,zoneid_t zoneid)4557c478bd9Sstevel@tonic-gate sprlock_zone(pid_t pid, zoneid_t zoneid)
4567c478bd9Sstevel@tonic-gate {
4577c478bd9Sstevel@tonic-gate 	proc_t *p;
4580209230bSgjelinek 	int ret;
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate 	for (;;) {
4617c478bd9Sstevel@tonic-gate 		mutex_enter(&pidlock);
4627c478bd9Sstevel@tonic-gate 		if ((p = prfind_zone(pid, zoneid)) == NULL) {
4637c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
4647c478bd9Sstevel@tonic-gate 			return (NULL);
4657c478bd9Sstevel@tonic-gate 		}
4660209230bSgjelinek 		mutex_enter(&p->p_lock);
4677c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
4680209230bSgjelinek 
4697c478bd9Sstevel@tonic-gate 		if (panicstr)
4707c478bd9Sstevel@tonic-gate 			return (p);
4710209230bSgjelinek 
4720209230bSgjelinek 		ret = sprtrylock_proc(p);
4730209230bSgjelinek 		if (ret == -1) {
4740209230bSgjelinek 			mutex_exit(&p->p_lock);
4750209230bSgjelinek 			return (NULL);
4760209230bSgjelinek 		} else if (ret == 0) {
4777c478bd9Sstevel@tonic-gate 			break;
4780209230bSgjelinek 		}
4790209230bSgjelinek 		sprwaitlock_proc(p);
4807c478bd9Sstevel@tonic-gate 	}
4817c478bd9Sstevel@tonic-gate 	return (p);
4827c478bd9Sstevel@tonic-gate }
4837c478bd9Sstevel@tonic-gate 
4847c478bd9Sstevel@tonic-gate proc_t *
sprlock(pid_t pid)4857c478bd9Sstevel@tonic-gate sprlock(pid_t pid)
4867c478bd9Sstevel@tonic-gate {
4877c478bd9Sstevel@tonic-gate 	zoneid_t zoneid;
4887c478bd9Sstevel@tonic-gate 
4897c478bd9Sstevel@tonic-gate 	if (INGLOBALZONE(curproc))
4907c478bd9Sstevel@tonic-gate 		zoneid = ALL_ZONES;
4917c478bd9Sstevel@tonic-gate 	else
4927c478bd9Sstevel@tonic-gate 		zoneid = getzoneid();
4937c478bd9Sstevel@tonic-gate 	return (sprlock_zone(pid, zoneid));
4947c478bd9Sstevel@tonic-gate }
4957c478bd9Sstevel@tonic-gate 
4967c478bd9Sstevel@tonic-gate void
sprlock_proc(proc_t * p)4977c478bd9Sstevel@tonic-gate sprlock_proc(proc_t *p)
4987c478bd9Sstevel@tonic-gate {
4997c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
5007c478bd9Sstevel@tonic-gate 
5017c478bd9Sstevel@tonic-gate 	while (p->p_proc_flag & P_PR_LOCK) {
5027c478bd9Sstevel@tonic-gate 		cv_wait(&pr_pid_cv[p->p_slot], &p->p_lock);
5037c478bd9Sstevel@tonic-gate 	}
5047c478bd9Sstevel@tonic-gate 
5057c478bd9Sstevel@tonic-gate 	p->p_proc_flag |= P_PR_LOCK;
5067c478bd9Sstevel@tonic-gate }
5077c478bd9Sstevel@tonic-gate 
5087c478bd9Sstevel@tonic-gate void
sprunlock(proc_t * p)5097c478bd9Sstevel@tonic-gate sprunlock(proc_t *p)
5107c478bd9Sstevel@tonic-gate {
5117c478bd9Sstevel@tonic-gate 	if (panicstr) {
5127c478bd9Sstevel@tonic-gate 		mutex_exit(&p->p_lock);
5137c478bd9Sstevel@tonic-gate 		return;
5147c478bd9Sstevel@tonic-gate 	}
5157c478bd9Sstevel@tonic-gate 
5167c478bd9Sstevel@tonic-gate 	ASSERT(p->p_proc_flag & P_PR_LOCK);
5177c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
5187c478bd9Sstevel@tonic-gate 
5197c478bd9Sstevel@tonic-gate 	cv_signal(&pr_pid_cv[p->p_slot]);
5207c478bd9Sstevel@tonic-gate 	p->p_proc_flag &= ~P_PR_LOCK;
5217c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
5227c478bd9Sstevel@tonic-gate }
5237c478bd9Sstevel@tonic-gate 
5247c478bd9Sstevel@tonic-gate void
pid_init(void)5257c478bd9Sstevel@tonic-gate pid_init(void)
5267c478bd9Sstevel@tonic-gate {
5277c478bd9Sstevel@tonic-gate 	int i;
5287c478bd9Sstevel@tonic-gate 
5297c478bd9Sstevel@tonic-gate 	pid_hashsz = 1 << highbit(v.v_proc / pid_hashlen);
5307c478bd9Sstevel@tonic-gate 
5317c478bd9Sstevel@tonic-gate 	pidhash = kmem_zalloc(sizeof (struct pid *) * pid_hashsz, KM_SLEEP);
5327c478bd9Sstevel@tonic-gate 	procdir = kmem_alloc(sizeof (union procent) * v.v_proc, KM_SLEEP);
5337c478bd9Sstevel@tonic-gate 	pr_pid_cv = kmem_zalloc(sizeof (kcondvar_t) * v.v_proc, KM_SLEEP);
5347c478bd9Sstevel@tonic-gate 	proc_lock = kmem_zalloc(sizeof (struct plock) * v.v_proc, KM_SLEEP);
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate 	nproc = 1;
5377c478bd9Sstevel@tonic-gate 	practive = proc_sched;
5387c478bd9Sstevel@tonic-gate 	proc_sched->p_next = NULL;
5397c478bd9Sstevel@tonic-gate 	procdir[0].pe_proc = proc_sched;
5407c478bd9Sstevel@tonic-gate 
5417c478bd9Sstevel@tonic-gate 	procentfree = &procdir[1];
5427c478bd9Sstevel@tonic-gate 	for (i = 1; i < v.v_proc - 1; i++)
5437c478bd9Sstevel@tonic-gate 		procdir[i].pe_next = &procdir[i+1];
5447c478bd9Sstevel@tonic-gate 	procdir[i].pe_next = NULL;
5457c478bd9Sstevel@tonic-gate 
5467c478bd9Sstevel@tonic-gate 	HASHPID(0) = &pid0;
5477c478bd9Sstevel@tonic-gate 
5487c478bd9Sstevel@tonic-gate 	upcount_init();
5497c478bd9Sstevel@tonic-gate }
5507c478bd9Sstevel@tonic-gate 
5517c478bd9Sstevel@tonic-gate proc_t *
pid_entry(int slot)5527c478bd9Sstevel@tonic-gate pid_entry(int slot)
5537c478bd9Sstevel@tonic-gate {
5547c478bd9Sstevel@tonic-gate 	union procent *pep;
5557c478bd9Sstevel@tonic-gate 	proc_t *prp;
5567c478bd9Sstevel@tonic-gate 
5577c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
5587c478bd9Sstevel@tonic-gate 	ASSERT(slot >= 0 && slot < v.v_proc);
5597c478bd9Sstevel@tonic-gate 
5607c478bd9Sstevel@tonic-gate 	pep = procdir[slot].pe_next;
5617c478bd9Sstevel@tonic-gate 	if (pep >= procdir && pep < &procdir[v.v_proc])
5627c478bd9Sstevel@tonic-gate 		return (NULL);
5637c478bd9Sstevel@tonic-gate 	prp = procdir[slot].pe_proc;
5647c478bd9Sstevel@tonic-gate 	if (prp != 0 && prp->p_stat == SIDL)
5657c478bd9Sstevel@tonic-gate 		return (NULL);
5667c478bd9Sstevel@tonic-gate 	return (prp);
5677c478bd9Sstevel@tonic-gate }
5687c478bd9Sstevel@tonic-gate 
5697c478bd9Sstevel@tonic-gate /*
5707c478bd9Sstevel@tonic-gate  * Send the specified signal to all processes whose process group ID is
5717c478bd9Sstevel@tonic-gate  * equal to 'pgid'
5727c478bd9Sstevel@tonic-gate  */
5737c478bd9Sstevel@tonic-gate 
5747c478bd9Sstevel@tonic-gate void
signal(pid_t pgid,int sig)5757c478bd9Sstevel@tonic-gate signal(pid_t pgid, int sig)
5767c478bd9Sstevel@tonic-gate {
5777c478bd9Sstevel@tonic-gate 	struct pid *pidp;
5787c478bd9Sstevel@tonic-gate 	proc_t *prp;
5797c478bd9Sstevel@tonic-gate 
5807c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlock);
5817c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlinklock);
5827c478bd9Sstevel@tonic-gate 	if (pgid == 0 || (pidp = pid_lookup(pgid)) == NULL) {
5837c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlinklock);
5847c478bd9Sstevel@tonic-gate 		mutex_exit(&pidlock);
5857c478bd9Sstevel@tonic-gate 		return;
5867c478bd9Sstevel@tonic-gate 	}
5877c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlinklock);
5887c478bd9Sstevel@tonic-gate 	for (prp = pidp->pid_pglink; prp; prp = prp->p_pglink) {
5897c478bd9Sstevel@tonic-gate 		mutex_enter(&prp->p_lock);
5907c478bd9Sstevel@tonic-gate 		sigtoproc(prp, NULL, sig);
5917c478bd9Sstevel@tonic-gate 		mutex_exit(&prp->p_lock);
5927c478bd9Sstevel@tonic-gate 	}
5937c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlock);
5947c478bd9Sstevel@tonic-gate }
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate /*
5977c478bd9Sstevel@tonic-gate  * Send the specified signal to the specified process
5987c478bd9Sstevel@tonic-gate  */
5997c478bd9Sstevel@tonic-gate 
6007c478bd9Sstevel@tonic-gate void
prsignal(struct pid * pidp,int sig)6017c478bd9Sstevel@tonic-gate prsignal(struct pid *pidp, int sig)
6027c478bd9Sstevel@tonic-gate {
6037c478bd9Sstevel@tonic-gate 	if (!(pidp->pid_prinactive))
6047c478bd9Sstevel@tonic-gate 		psignal(procdir[pidp->pid_prslot].pe_proc, sig);
6057c478bd9Sstevel@tonic-gate }
6067c478bd9Sstevel@tonic-gate 
6077c478bd9Sstevel@tonic-gate #include <sys/sunddi.h>
6087c478bd9Sstevel@tonic-gate 
6097c478bd9Sstevel@tonic-gate /*
6107c478bd9Sstevel@tonic-gate  * DDI/DKI interfaces for drivers to send signals to processes
6117c478bd9Sstevel@tonic-gate  */
6127c478bd9Sstevel@tonic-gate 
6137c478bd9Sstevel@tonic-gate /*
6147c478bd9Sstevel@tonic-gate  * obtain an opaque reference to a process for signaling
6157c478bd9Sstevel@tonic-gate  */
6167c478bd9Sstevel@tonic-gate void *
proc_ref(void)6177c478bd9Sstevel@tonic-gate proc_ref(void)
6187c478bd9Sstevel@tonic-gate {
6197c478bd9Sstevel@tonic-gate 	struct pid *pidp;
6207c478bd9Sstevel@tonic-gate 
6217c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlock);
6227c478bd9Sstevel@tonic-gate 	pidp = curproc->p_pidp;
6237c478bd9Sstevel@tonic-gate 	PID_HOLD(pidp);
6247c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlock);
6257c478bd9Sstevel@tonic-gate 
6267c478bd9Sstevel@tonic-gate 	return (pidp);
6277c478bd9Sstevel@tonic-gate }
6287c478bd9Sstevel@tonic-gate 
6297c478bd9Sstevel@tonic-gate /*
6307c478bd9Sstevel@tonic-gate  * release a reference to a process
6317c478bd9Sstevel@tonic-gate  * - a process can exit even if a driver has a reference to it
6327c478bd9Sstevel@tonic-gate  * - one proc_unref for every proc_ref
6337c478bd9Sstevel@tonic-gate  */
6347c478bd9Sstevel@tonic-gate void
proc_unref(void * pref)6357c478bd9Sstevel@tonic-gate proc_unref(void *pref)
6367c478bd9Sstevel@tonic-gate {
6377c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlock);
6387c478bd9Sstevel@tonic-gate 	PID_RELE((struct pid *)pref);
6397c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlock);
6407c478bd9Sstevel@tonic-gate }
6417c478bd9Sstevel@tonic-gate 
6427c478bd9Sstevel@tonic-gate /*
6437c478bd9Sstevel@tonic-gate  * send a signal to a process
6447c478bd9Sstevel@tonic-gate  *
6457c478bd9Sstevel@tonic-gate  * - send the process the signal
6467c478bd9Sstevel@tonic-gate  * - if the process went away, return a -1
6477c478bd9Sstevel@tonic-gate  * - if the process is still there return 0
6487c478bd9Sstevel@tonic-gate  */
6497c478bd9Sstevel@tonic-gate int
proc_signal(void * pref,int sig)6507c478bd9Sstevel@tonic-gate proc_signal(void *pref, int sig)
6517c478bd9Sstevel@tonic-gate {
6527c478bd9Sstevel@tonic-gate 	struct pid *pidp = pref;
6537c478bd9Sstevel@tonic-gate 
6547c478bd9Sstevel@tonic-gate 	prsignal(pidp, sig);
6557c478bd9Sstevel@tonic-gate 	return (pidp->pid_prinactive ? -1 : 0);
6567c478bd9Sstevel@tonic-gate }
6577c478bd9Sstevel@tonic-gate 
6587c478bd9Sstevel@tonic-gate 
6597c478bd9Sstevel@tonic-gate static struct upcount	**upc_hash;	/* a boot time allocated array */
6607c478bd9Sstevel@tonic-gate static ulong_t		upc_hashmask;
6617c478bd9Sstevel@tonic-gate #define	UPC_HASH(x, y)	((ulong_t)(x ^ y) & upc_hashmask)
6627c478bd9Sstevel@tonic-gate 
6637c478bd9Sstevel@tonic-gate /*
6647c478bd9Sstevel@tonic-gate  * Get us off the ground.  Called once at boot.
6657c478bd9Sstevel@tonic-gate  */
6667c478bd9Sstevel@tonic-gate void
upcount_init(void)6677c478bd9Sstevel@tonic-gate upcount_init(void)
6687c478bd9Sstevel@tonic-gate {
6697c478bd9Sstevel@tonic-gate 	ulong_t	upc_hashsize;
6707c478bd9Sstevel@tonic-gate 
6717c478bd9Sstevel@tonic-gate 	/*
6727c478bd9Sstevel@tonic-gate 	 * An entry per MB of memory is our current guess
6737c478bd9Sstevel@tonic-gate 	 */
6747c478bd9Sstevel@tonic-gate 	/*
6757c478bd9Sstevel@tonic-gate 	 * 2^20 is a meg, so shifting right by 20 - PAGESHIFT
6767c478bd9Sstevel@tonic-gate 	 * converts pages to megs (without overflowing a u_int
6777c478bd9Sstevel@tonic-gate 	 * if you have more than 4G of memory, like ptob(physmem)/1M
6787c478bd9Sstevel@tonic-gate 	 * would).
6797c478bd9Sstevel@tonic-gate 	 */
6807c478bd9Sstevel@tonic-gate 	upc_hashsize = (1 << highbit(physmem >> (20 - PAGESHIFT)));
6817c478bd9Sstevel@tonic-gate 	upc_hashmask = upc_hashsize - 1;
6827c478bd9Sstevel@tonic-gate 	upc_hash = kmem_zalloc(upc_hashsize * sizeof (struct upcount *),
6837c478bd9Sstevel@tonic-gate 	    KM_SLEEP);
6847c478bd9Sstevel@tonic-gate }
6857c478bd9Sstevel@tonic-gate 
6867c478bd9Sstevel@tonic-gate /*
6877c478bd9Sstevel@tonic-gate  * Increment the number of processes associated with a given uid and zoneid.
6887c478bd9Sstevel@tonic-gate  */
6897c478bd9Sstevel@tonic-gate void
upcount_inc(uid_t uid,zoneid_t zoneid)6907c478bd9Sstevel@tonic-gate upcount_inc(uid_t uid, zoneid_t zoneid)
6917c478bd9Sstevel@tonic-gate {
6927c478bd9Sstevel@tonic-gate 	struct upcount	**upc, **hupc;
6937c478bd9Sstevel@tonic-gate 	struct upcount	*new;
6947c478bd9Sstevel@tonic-gate 
6957c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
6967c478bd9Sstevel@tonic-gate 	new = NULL;
6977c478bd9Sstevel@tonic-gate 	hupc = &upc_hash[UPC_HASH(uid, zoneid)];
6987c478bd9Sstevel@tonic-gate top:
6997c478bd9Sstevel@tonic-gate 	upc = hupc;
7007c478bd9Sstevel@tonic-gate 	while ((*upc) != NULL) {
7017c478bd9Sstevel@tonic-gate 		if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) {
7027c478bd9Sstevel@tonic-gate 			(*upc)->up_count++;
7037c478bd9Sstevel@tonic-gate 			if (new) {
7047c478bd9Sstevel@tonic-gate 				/*
7057c478bd9Sstevel@tonic-gate 				 * did not need `new' afterall.
7067c478bd9Sstevel@tonic-gate 				 */
7077c478bd9Sstevel@tonic-gate 				kmem_free(new, sizeof (*new));
7087c478bd9Sstevel@tonic-gate 			}
7097c478bd9Sstevel@tonic-gate 			return;
7107c478bd9Sstevel@tonic-gate 		}
7117c478bd9Sstevel@tonic-gate 		upc = &(*upc)->up_next;
7127c478bd9Sstevel@tonic-gate 	}
7137c478bd9Sstevel@tonic-gate 
7147c478bd9Sstevel@tonic-gate 	/*
7157c478bd9Sstevel@tonic-gate 	 * There is no entry for this <uid,zoneid> pair.
7167c478bd9Sstevel@tonic-gate 	 * Allocate one.  If we have to drop pidlock, check
7177c478bd9Sstevel@tonic-gate 	 * again.
7187c478bd9Sstevel@tonic-gate 	 */
7197c478bd9Sstevel@tonic-gate 	if (new == NULL) {
7207c478bd9Sstevel@tonic-gate 		new = (struct upcount *)kmem_alloc(sizeof (*new), KM_NOSLEEP);
7217c478bd9Sstevel@tonic-gate 		if (new == NULL) {
7227c478bd9Sstevel@tonic-gate 			mutex_exit(&pidlock);
7237c478bd9Sstevel@tonic-gate 			new = (struct upcount *)kmem_alloc(sizeof (*new),
7247c478bd9Sstevel@tonic-gate 			    KM_SLEEP);
7257c478bd9Sstevel@tonic-gate 			mutex_enter(&pidlock);
7267c478bd9Sstevel@tonic-gate 			goto top;
7277c478bd9Sstevel@tonic-gate 		}
7287c478bd9Sstevel@tonic-gate 	}
7297c478bd9Sstevel@tonic-gate 
7307c478bd9Sstevel@tonic-gate 
7317c478bd9Sstevel@tonic-gate 	/*
7327c478bd9Sstevel@tonic-gate 	 * On the assumption that a new user is going to do some
7337c478bd9Sstevel@tonic-gate 	 * more forks, put the new upcount structure on the front.
7347c478bd9Sstevel@tonic-gate 	 */
7357c478bd9Sstevel@tonic-gate 	upc = hupc;
7367c478bd9Sstevel@tonic-gate 
7377c478bd9Sstevel@tonic-gate 	new->up_uid = uid;
7387c478bd9Sstevel@tonic-gate 	new->up_zoneid = zoneid;
7397c478bd9Sstevel@tonic-gate 	new->up_count = 1;
7407c478bd9Sstevel@tonic-gate 	new->up_next = *upc;
7417c478bd9Sstevel@tonic-gate 
7427c478bd9Sstevel@tonic-gate 	*upc = new;
7437c478bd9Sstevel@tonic-gate }
7447c478bd9Sstevel@tonic-gate 
7457c478bd9Sstevel@tonic-gate /*
7467c478bd9Sstevel@tonic-gate  * Decrement the number of processes a given uid and zoneid has.
7477c478bd9Sstevel@tonic-gate  */
7487c478bd9Sstevel@tonic-gate void
upcount_dec(uid_t uid,zoneid_t zoneid)7497c478bd9Sstevel@tonic-gate upcount_dec(uid_t uid, zoneid_t zoneid)
7507c478bd9Sstevel@tonic-gate {
7517c478bd9Sstevel@tonic-gate 	struct	upcount **upc;
7527c478bd9Sstevel@tonic-gate 	struct	upcount *done;
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
7557c478bd9Sstevel@tonic-gate 
7567c478bd9Sstevel@tonic-gate 	upc = &upc_hash[UPC_HASH(uid, zoneid)];
7577c478bd9Sstevel@tonic-gate 	while ((*upc) != NULL) {
7587c478bd9Sstevel@tonic-gate 		if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) {
7597c478bd9Sstevel@tonic-gate 			(*upc)->up_count--;
7607c478bd9Sstevel@tonic-gate 			if ((*upc)->up_count == 0) {
7617c478bd9Sstevel@tonic-gate 				done = *upc;
7627c478bd9Sstevel@tonic-gate 				*upc = (*upc)->up_next;
7637c478bd9Sstevel@tonic-gate 				kmem_free(done, sizeof (*done));
7647c478bd9Sstevel@tonic-gate 			}
7657c478bd9Sstevel@tonic-gate 			return;
7667c478bd9Sstevel@tonic-gate 		}
7677c478bd9Sstevel@tonic-gate 		upc = &(*upc)->up_next;
7687c478bd9Sstevel@tonic-gate 	}
7697c478bd9Sstevel@tonic-gate 	cmn_err(CE_PANIC, "decr_upcount-off the end");
7707c478bd9Sstevel@tonic-gate }
7717c478bd9Sstevel@tonic-gate 
7727c478bd9Sstevel@tonic-gate /*
7737c478bd9Sstevel@tonic-gate  * Returns the number of processes a uid has.
7747c478bd9Sstevel@tonic-gate  * Non-existent uid's are assumed to have no processes.
7757c478bd9Sstevel@tonic-gate  */
7767c478bd9Sstevel@tonic-gate int
upcount_get(uid_t uid,zoneid_t zoneid)7777c478bd9Sstevel@tonic-gate upcount_get(uid_t uid, zoneid_t zoneid)
7787c478bd9Sstevel@tonic-gate {
7797c478bd9Sstevel@tonic-gate 	struct	upcount *upc;
7807c478bd9Sstevel@tonic-gate 
7817c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&pidlock));
7827c478bd9Sstevel@tonic-gate 
7837c478bd9Sstevel@tonic-gate 	upc = upc_hash[UPC_HASH(uid, zoneid)];
7847c478bd9Sstevel@tonic-gate 	while (upc != NULL) {
7857c478bd9Sstevel@tonic-gate 		if (upc->up_uid == uid && upc->up_zoneid == zoneid) {
7867c478bd9Sstevel@tonic-gate 			return (upc->up_count);
7877c478bd9Sstevel@tonic-gate 		}
7887c478bd9Sstevel@tonic-gate 		upc = upc->up_next;
7897c478bd9Sstevel@tonic-gate 	}
7907c478bd9Sstevel@tonic-gate 	return (0);
7917c478bd9Sstevel@tonic-gate }
792