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