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 59acbbeafSnn35248 * Common Development and Distribution License (the "License"). 69acbbeafSnn35248 * 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 /* 239acbbeafSnn35248 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 287c478bd9Sstevel@tonic-gate /* All Rights Reserved */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate 317c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 327c478bd9Sstevel@tonic-gate 337c478bd9Sstevel@tonic-gate #include <sys/types.h> 347c478bd9Sstevel@tonic-gate #include <sys/param.h> 357c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 367c478bd9Sstevel@tonic-gate #include <sys/proc.h> 377c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 387c478bd9Sstevel@tonic-gate #include <sys/tuneable.h> 397c478bd9Sstevel@tonic-gate #include <sys/var.h> 407c478bd9Sstevel@tonic-gate #include <sys/cred.h> 417c478bd9Sstevel@tonic-gate #include <sys/systm.h> 427c478bd9Sstevel@tonic-gate #include <sys/prsystm.h> 437c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 447c478bd9Sstevel@tonic-gate #include <sys/session.h> 457c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h> 467c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 477c478bd9Sstevel@tonic-gate #include <sys/bitmap.h> 487c478bd9Sstevel@tonic-gate #include <sys/debug.h> 497c478bd9Sstevel@tonic-gate #include <c2/audit.h> 507c478bd9Sstevel@tonic-gate #include <sys/zone.h> 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate /* directory entries for /proc */ 537c478bd9Sstevel@tonic-gate union procent { 547c478bd9Sstevel@tonic-gate proc_t *pe_proc; 557c478bd9Sstevel@tonic-gate union procent *pe_next; 567c478bd9Sstevel@tonic-gate }; 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate struct pid pid0 = { 597c478bd9Sstevel@tonic-gate 0, /* pid_prinactive */ 607c478bd9Sstevel@tonic-gate 1, /* pid_pgorphaned */ 617c478bd9Sstevel@tonic-gate 0, /* pid_padding */ 627c478bd9Sstevel@tonic-gate 0, /* pid_prslot */ 637c478bd9Sstevel@tonic-gate 0, /* pid_id */ 647c478bd9Sstevel@tonic-gate NULL, /* pid_pglink */ 65e44bd21cSsusans NULL, /* pid_pgtail */ 667c478bd9Sstevel@tonic-gate NULL, /* pid_link */ 677c478bd9Sstevel@tonic-gate 3 /* pid_ref */ 687c478bd9Sstevel@tonic-gate }; 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate static int pid_hashlen = 4; /* desired average hash chain length */ 717c478bd9Sstevel@tonic-gate static int pid_hashsz; /* number of buckets in the hash table */ 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate #define HASHPID(pid) (pidhash[((pid)&(pid_hashsz-1))]) 747c478bd9Sstevel@tonic-gate 757c478bd9Sstevel@tonic-gate extern uint_t nproc; 767c478bd9Sstevel@tonic-gate extern struct kmem_cache *process_cache; 777c478bd9Sstevel@tonic-gate static void upcount_init(void); 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate kmutex_t pidlock; /* global process lock */ 807c478bd9Sstevel@tonic-gate kmutex_t pr_pidlock; /* /proc global process lock */ 817c478bd9Sstevel@tonic-gate kcondvar_t *pr_pid_cv; /* for /proc, one per process slot */ 827c478bd9Sstevel@tonic-gate struct plock *proc_lock; /* persistent array of p_lock's */ 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate /* 857c478bd9Sstevel@tonic-gate * See the comment above pid_getlockslot() for a detailed explanation of this 867c478bd9Sstevel@tonic-gate * constant. Note that a PLOCK_SHIFT of 3 implies 64-byte coherence 877c478bd9Sstevel@tonic-gate * granularity; if the coherence granularity is ever changed, this constant 887c478bd9Sstevel@tonic-gate * should be modified to reflect the change to minimize proc_lock false 897c478bd9Sstevel@tonic-gate * sharing (correctness, however, is guaranteed regardless of the coherence 907c478bd9Sstevel@tonic-gate * granularity). 917c478bd9Sstevel@tonic-gate */ 927c478bd9Sstevel@tonic-gate #define PLOCK_SHIFT 3 937c478bd9Sstevel@tonic-gate 947c478bd9Sstevel@tonic-gate static kmutex_t pidlinklock; 957c478bd9Sstevel@tonic-gate static struct pid **pidhash; 967c478bd9Sstevel@tonic-gate static pid_t minpid; 977c478bd9Sstevel@tonic-gate static pid_t mpid; 987c478bd9Sstevel@tonic-gate static union procent *procdir; 997c478bd9Sstevel@tonic-gate static union procent *procentfree; 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate static struct pid * 1027c478bd9Sstevel@tonic-gate pid_lookup(pid_t pid) 1037c478bd9Sstevel@tonic-gate { 1047c478bd9Sstevel@tonic-gate struct pid *pidp; 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlinklock)); 1077c478bd9Sstevel@tonic-gate 1087c478bd9Sstevel@tonic-gate for (pidp = HASHPID(pid); pidp; pidp = pidp->pid_link) { 1097c478bd9Sstevel@tonic-gate if (pidp->pid_id == pid) { 1107c478bd9Sstevel@tonic-gate ASSERT(pidp->pid_ref > 0); 1117c478bd9Sstevel@tonic-gate break; 1127c478bd9Sstevel@tonic-gate } 1137c478bd9Sstevel@tonic-gate } 1147c478bd9Sstevel@tonic-gate return (pidp); 1157c478bd9Sstevel@tonic-gate } 1167c478bd9Sstevel@tonic-gate 1179acbbeafSnn35248 struct pid * 1189acbbeafSnn35248 pid_find(pid_t pid) 1199acbbeafSnn35248 { 1209acbbeafSnn35248 struct pid *pidp; 1219acbbeafSnn35248 1229acbbeafSnn35248 mutex_enter(&pidlinklock); 1239acbbeafSnn35248 pidp = pid_lookup(pid); 1249acbbeafSnn35248 mutex_exit(&pidlinklock); 1259acbbeafSnn35248 1269acbbeafSnn35248 return (pidp); 1279acbbeafSnn35248 } 1289acbbeafSnn35248 1297c478bd9Sstevel@tonic-gate void 1307c478bd9Sstevel@tonic-gate pid_setmin(void) 1317c478bd9Sstevel@tonic-gate { 1327c478bd9Sstevel@tonic-gate if (jump_pid && jump_pid > mpid) 1337c478bd9Sstevel@tonic-gate minpid = mpid = jump_pid; 1347c478bd9Sstevel@tonic-gate else 1357c478bd9Sstevel@tonic-gate minpid = mpid + 1; 1367c478bd9Sstevel@tonic-gate } 1377c478bd9Sstevel@tonic-gate 1387c478bd9Sstevel@tonic-gate /* 1397c478bd9Sstevel@tonic-gate * When prslots are simply used as an index to determine a process' p_lock, 1407c478bd9Sstevel@tonic-gate * adjacent prslots share adjacent p_locks. On machines where the size 1417c478bd9Sstevel@tonic-gate * of a mutex is smaller than that of a cache line (which, as of this writing, 1427c478bd9Sstevel@tonic-gate * is true for all machines on which Solaris runs), this can potentially 1437c478bd9Sstevel@tonic-gate * induce false sharing. The standard solution for false sharing is to pad 1447c478bd9Sstevel@tonic-gate * out one's data structures (in this case, struct plock). However, 1457c478bd9Sstevel@tonic-gate * given the size and (generally) sparse use of the proc_lock array, this 1467c478bd9Sstevel@tonic-gate * is suboptimal. We therefore stride through the proc_lock array with 1477c478bd9Sstevel@tonic-gate * a stride of PLOCK_SHIFT. PLOCK_SHIFT should be defined as: 1487c478bd9Sstevel@tonic-gate * 1497c478bd9Sstevel@tonic-gate * log_2 (coherence_granularity / sizeof (kmutex_t)) 1507c478bd9Sstevel@tonic-gate * 1517c478bd9Sstevel@tonic-gate * Under this scheme, false sharing is still possible -- but only when 1527c478bd9Sstevel@tonic-gate * the number of active processes is very large. Note that the one-to-one 1537c478bd9Sstevel@tonic-gate * mapping between prslots and lockslots is maintained. 1547c478bd9Sstevel@tonic-gate */ 1557c478bd9Sstevel@tonic-gate static int 1567c478bd9Sstevel@tonic-gate pid_getlockslot(int prslot) 1577c478bd9Sstevel@tonic-gate { 1587c478bd9Sstevel@tonic-gate int even = (v.v_proc >> PLOCK_SHIFT) << PLOCK_SHIFT; 1597c478bd9Sstevel@tonic-gate int perlap = even >> PLOCK_SHIFT; 1607c478bd9Sstevel@tonic-gate 1617c478bd9Sstevel@tonic-gate if (prslot >= even) 1627c478bd9Sstevel@tonic-gate return (prslot); 1637c478bd9Sstevel@tonic-gate 1647c478bd9Sstevel@tonic-gate return (((prslot % perlap) << PLOCK_SHIFT) + (prslot / perlap)); 1657c478bd9Sstevel@tonic-gate } 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate /* 1689acbbeafSnn35248 * This function allocates a pid structure, a free pid, and optionally a 1699acbbeafSnn35248 * slot in the proc table for it. 1707c478bd9Sstevel@tonic-gate * 1719acbbeafSnn35248 * pid_allocate() returns the new pid on success, -1 on failure. 1727c478bd9Sstevel@tonic-gate */ 1737c478bd9Sstevel@tonic-gate pid_t 1749acbbeafSnn35248 pid_allocate(proc_t *prp, int flags) 1757c478bd9Sstevel@tonic-gate { 1767c478bd9Sstevel@tonic-gate struct pid *pidp; 1777c478bd9Sstevel@tonic-gate union procent *pep; 1787c478bd9Sstevel@tonic-gate pid_t newpid, startpid; 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate pidp = kmem_zalloc(sizeof (struct pid), KM_SLEEP); 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate mutex_enter(&pidlinklock); 1839acbbeafSnn35248 if ((flags & PID_ALLOC_PROC) && (pep = procentfree) == NULL) { 1847c478bd9Sstevel@tonic-gate /* 1857c478bd9Sstevel@tonic-gate * ran out of /proc directory entries 1867c478bd9Sstevel@tonic-gate */ 1877c478bd9Sstevel@tonic-gate goto failed; 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate /* 1917c478bd9Sstevel@tonic-gate * Allocate a pid 1927c478bd9Sstevel@tonic-gate */ 1937c478bd9Sstevel@tonic-gate startpid = mpid; 1947c478bd9Sstevel@tonic-gate do { 1957c478bd9Sstevel@tonic-gate newpid = (++mpid == maxpid ? mpid = minpid : mpid); 1967c478bd9Sstevel@tonic-gate } while (pid_lookup(newpid) && newpid != startpid); 1977c478bd9Sstevel@tonic-gate 1987c478bd9Sstevel@tonic-gate if (newpid == startpid && pid_lookup(newpid)) { 1997c478bd9Sstevel@tonic-gate /* couldn't find a free pid */ 2007c478bd9Sstevel@tonic-gate goto failed; 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; 2109acbbeafSnn35248 2119acbbeafSnn35248 if (flags & PID_ALLOC_PROC) { 2129acbbeafSnn35248 procentfree = pep->pe_next; 2137c478bd9Sstevel@tonic-gate pidp->pid_prslot = pep - procdir; 2149acbbeafSnn35248 pep->pe_proc = prp; 2159acbbeafSnn35248 prp->p_pidp = pidp; 2167c478bd9Sstevel@tonic-gate prp->p_lockp = &proc_lock[pid_getlockslot(pidp->pid_prslot)]; 2179acbbeafSnn35248 } else { 2189acbbeafSnn35248 pidp->pid_prslot = 0; 2199acbbeafSnn35248 } 2209acbbeafSnn35248 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 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 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 2677c478bd9Sstevel@tonic-gate void 2687c478bd9Sstevel@tonic-gate pid_exit(proc_t *prp) 2697c478bd9Sstevel@tonic-gate { 2707c478bd9Sstevel@tonic-gate struct pid *pidp; 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock)); 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate /* 2757c478bd9Sstevel@tonic-gate * Exit process group. If it is NULL, it's because fork failed 2767c478bd9Sstevel@tonic-gate * before calling pgjoin(). 2777c478bd9Sstevel@tonic-gate */ 2787c478bd9Sstevel@tonic-gate ASSERT(prp->p_pgidp != NULL || prp->p_stat == SIDL); 2797c478bd9Sstevel@tonic-gate if (prp->p_pgidp != NULL) 2807c478bd9Sstevel@tonic-gate pgexit(prp); 2817c478bd9Sstevel@tonic-gate 2829acbbeafSnn35248 sess_rele(prp->p_sessp, B_TRUE); 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate pidp = prp->p_pidp; 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate proc_entry_free(pidp); 2877c478bd9Sstevel@tonic-gate 2887c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT 2897c478bd9Sstevel@tonic-gate if (audit_active) 2907c478bd9Sstevel@tonic-gate audit_pfree(prp); 2917c478bd9Sstevel@tonic-gate #endif 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate if (practive == prp) { 2947c478bd9Sstevel@tonic-gate practive = prp->p_next; 2957c478bd9Sstevel@tonic-gate } 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate if (prp->p_next) { 2987c478bd9Sstevel@tonic-gate prp->p_next->p_prev = prp->p_prev; 2997c478bd9Sstevel@tonic-gate } 3007c478bd9Sstevel@tonic-gate if (prp->p_prev) { 3017c478bd9Sstevel@tonic-gate prp->p_prev->p_next = prp->p_next; 3027c478bd9Sstevel@tonic-gate } 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate PID_RELE(pidp); 3057c478bd9Sstevel@tonic-gate 3067c478bd9Sstevel@tonic-gate mutex_destroy(&prp->p_crlock); 3077c478bd9Sstevel@tonic-gate kmem_cache_free(process_cache, prp); 3087c478bd9Sstevel@tonic-gate nproc--; 3097c478bd9Sstevel@tonic-gate } 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate /* 3127c478bd9Sstevel@tonic-gate * Find a process visible from the specified zone given its process ID. 3137c478bd9Sstevel@tonic-gate */ 3147c478bd9Sstevel@tonic-gate proc_t * 3157c478bd9Sstevel@tonic-gate prfind_zone(pid_t pid, zoneid_t zoneid) 3167c478bd9Sstevel@tonic-gate { 3177c478bd9Sstevel@tonic-gate struct pid *pidp; 3187c478bd9Sstevel@tonic-gate proc_t *p; 3197c478bd9Sstevel@tonic-gate 3207c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock)); 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate mutex_enter(&pidlinklock); 3237c478bd9Sstevel@tonic-gate pidp = pid_lookup(pid); 3247c478bd9Sstevel@tonic-gate mutex_exit(&pidlinklock); 3257c478bd9Sstevel@tonic-gate if (pidp != NULL && pidp->pid_prinactive == 0) { 3267c478bd9Sstevel@tonic-gate p = procdir[pidp->pid_prslot].pe_proc; 3277c478bd9Sstevel@tonic-gate if (zoneid == ALL_ZONES || p->p_zone->zone_id == zoneid) 3287c478bd9Sstevel@tonic-gate return (p); 3297c478bd9Sstevel@tonic-gate } 3307c478bd9Sstevel@tonic-gate return (NULL); 3317c478bd9Sstevel@tonic-gate } 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate /* 3347c478bd9Sstevel@tonic-gate * Find a process given its process ID. This obeys zone restrictions, 3357c478bd9Sstevel@tonic-gate * so if the caller is in a non-global zone it won't find processes 3367c478bd9Sstevel@tonic-gate * associated with other zones. Use prfind_zone(pid, ALL_ZONES) to 3377c478bd9Sstevel@tonic-gate * bypass this restriction. 3387c478bd9Sstevel@tonic-gate */ 3397c478bd9Sstevel@tonic-gate proc_t * 3407c478bd9Sstevel@tonic-gate prfind(pid_t pid) 3417c478bd9Sstevel@tonic-gate { 3427c478bd9Sstevel@tonic-gate zoneid_t zoneid; 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate if (INGLOBALZONE(curproc)) 3457c478bd9Sstevel@tonic-gate zoneid = ALL_ZONES; 3467c478bd9Sstevel@tonic-gate else 3477c478bd9Sstevel@tonic-gate zoneid = getzoneid(); 3487c478bd9Sstevel@tonic-gate return (prfind_zone(pid, zoneid)); 3497c478bd9Sstevel@tonic-gate } 3507c478bd9Sstevel@tonic-gate 3517c478bd9Sstevel@tonic-gate proc_t * 3527c478bd9Sstevel@tonic-gate pgfind_zone(pid_t pgid, zoneid_t zoneid) 3537c478bd9Sstevel@tonic-gate { 3547c478bd9Sstevel@tonic-gate struct pid *pidp; 3557c478bd9Sstevel@tonic-gate 3567c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock)); 3577c478bd9Sstevel@tonic-gate 3587c478bd9Sstevel@tonic-gate mutex_enter(&pidlinklock); 3597c478bd9Sstevel@tonic-gate pidp = pid_lookup(pgid); 3607c478bd9Sstevel@tonic-gate mutex_exit(&pidlinklock); 3617c478bd9Sstevel@tonic-gate if (pidp != NULL) { 3627c478bd9Sstevel@tonic-gate proc_t *p = pidp->pid_pglink; 3637c478bd9Sstevel@tonic-gate 3647c478bd9Sstevel@tonic-gate if (zoneid == ALL_ZONES || pgid == 0 || p == NULL || 3657c478bd9Sstevel@tonic-gate p->p_zone->zone_id == zoneid) 3667c478bd9Sstevel@tonic-gate return (p); 3677c478bd9Sstevel@tonic-gate } 3687c478bd9Sstevel@tonic-gate return (NULL); 3697c478bd9Sstevel@tonic-gate } 3707c478bd9Sstevel@tonic-gate 3717c478bd9Sstevel@tonic-gate /* 3727c478bd9Sstevel@tonic-gate * return the head of the list of processes whose process group ID is 'pgid', 3737c478bd9Sstevel@tonic-gate * or NULL, if no such process group 3747c478bd9Sstevel@tonic-gate */ 3757c478bd9Sstevel@tonic-gate proc_t * 3767c478bd9Sstevel@tonic-gate pgfind(pid_t pgid) 3777c478bd9Sstevel@tonic-gate { 3787c478bd9Sstevel@tonic-gate zoneid_t zoneid; 3797c478bd9Sstevel@tonic-gate 3807c478bd9Sstevel@tonic-gate if (INGLOBALZONE(curproc)) 3817c478bd9Sstevel@tonic-gate zoneid = ALL_ZONES; 3827c478bd9Sstevel@tonic-gate else 3837c478bd9Sstevel@tonic-gate zoneid = getzoneid(); 3847c478bd9Sstevel@tonic-gate return (pgfind_zone(pgid, zoneid)); 3857c478bd9Sstevel@tonic-gate } 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate /* 388*0209230bSgjelinek * Sets P_PR_LOCK on a non-system process. Process must be fully created 389*0209230bSgjelinek * and not exiting to succeed. 390*0209230bSgjelinek * 391*0209230bSgjelinek * Returns 0 on success. 392*0209230bSgjelinek * Returns 1 if P_PR_LOCK is set. 393*0209230bSgjelinek * Returns -1 if proc is in invalid state. 394*0209230bSgjelinek */ 395*0209230bSgjelinek int 396*0209230bSgjelinek sprtrylock_proc(proc_t *p) 397*0209230bSgjelinek { 398*0209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 399*0209230bSgjelinek 400*0209230bSgjelinek /* skip system and incomplete processes */ 401*0209230bSgjelinek if (p->p_stat == SIDL || p->p_stat == SZOMB || 402*0209230bSgjelinek (p->p_flag & (SSYS | SEXITING | SEXITLWPS))) { 403*0209230bSgjelinek return (-1); 404*0209230bSgjelinek } 405*0209230bSgjelinek 406*0209230bSgjelinek if (p->p_proc_flag & P_PR_LOCK) 407*0209230bSgjelinek return (1); 408*0209230bSgjelinek 409*0209230bSgjelinek p->p_proc_flag |= P_PR_LOCK; 410*0209230bSgjelinek THREAD_KPRI_REQUEST(); 411*0209230bSgjelinek 412*0209230bSgjelinek return (0); 413*0209230bSgjelinek } 414*0209230bSgjelinek 415*0209230bSgjelinek /* 416*0209230bSgjelinek * Wait for P_PR_LOCK to become clear. Returns with p_lock dropped, 417*0209230bSgjelinek * and the proc pointer no longer valid, as the proc may have exited. 418*0209230bSgjelinek */ 419*0209230bSgjelinek void 420*0209230bSgjelinek sprwaitlock_proc(proc_t *p) 421*0209230bSgjelinek { 422*0209230bSgjelinek kmutex_t *mp; 423*0209230bSgjelinek 424*0209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 425*0209230bSgjelinek ASSERT(p->p_proc_flag & P_PR_LOCK); 426*0209230bSgjelinek 427*0209230bSgjelinek /* 428*0209230bSgjelinek * p_lock is persistent, but p itself is not -- it could 429*0209230bSgjelinek * vanish during cv_wait(). Load p->p_lock now so we can 430*0209230bSgjelinek * drop it after cv_wait() without referencing p. 431*0209230bSgjelinek */ 432*0209230bSgjelinek mp = &p->p_lock; 433*0209230bSgjelinek cv_wait(&pr_pid_cv[p->p_slot], mp); 434*0209230bSgjelinek mutex_exit(mp); 435*0209230bSgjelinek } 436*0209230bSgjelinek 437*0209230bSgjelinek /* 4387c478bd9Sstevel@tonic-gate * If pid exists, find its proc, acquire its p_lock and mark it P_PR_LOCK. 4397c478bd9Sstevel@tonic-gate * Returns the proc pointer on success, NULL on failure. sprlock() is 4407c478bd9Sstevel@tonic-gate * really just a stripped-down version of pr_p_lock() to allow practive 4417c478bd9Sstevel@tonic-gate * walkers like dofusers() and dumpsys() to synchronize with /proc. 4427c478bd9Sstevel@tonic-gate */ 4437c478bd9Sstevel@tonic-gate proc_t * 4447c478bd9Sstevel@tonic-gate sprlock_zone(pid_t pid, zoneid_t zoneid) 4457c478bd9Sstevel@tonic-gate { 4467c478bd9Sstevel@tonic-gate proc_t *p; 447*0209230bSgjelinek int ret; 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate for (;;) { 4507c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 4517c478bd9Sstevel@tonic-gate if ((p = prfind_zone(pid, zoneid)) == NULL) { 4527c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 4537c478bd9Sstevel@tonic-gate return (NULL); 4547c478bd9Sstevel@tonic-gate } 455*0209230bSgjelinek mutex_enter(&p->p_lock); 4567c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 457*0209230bSgjelinek 4587c478bd9Sstevel@tonic-gate if (panicstr) 4597c478bd9Sstevel@tonic-gate return (p); 460*0209230bSgjelinek 461*0209230bSgjelinek ret = sprtrylock_proc(p); 462*0209230bSgjelinek if (ret == -1) { 463*0209230bSgjelinek mutex_exit(&p->p_lock); 464*0209230bSgjelinek return (NULL); 465*0209230bSgjelinek } else if (ret == 0) { 4667c478bd9Sstevel@tonic-gate break; 4677c478bd9Sstevel@tonic-gate } 468*0209230bSgjelinek sprwaitlock_proc(p); 469*0209230bSgjelinek } 4707c478bd9Sstevel@tonic-gate return (p); 4717c478bd9Sstevel@tonic-gate } 4727c478bd9Sstevel@tonic-gate 4737c478bd9Sstevel@tonic-gate proc_t * 4747c478bd9Sstevel@tonic-gate sprlock(pid_t pid) 4757c478bd9Sstevel@tonic-gate { 4767c478bd9Sstevel@tonic-gate zoneid_t zoneid; 4777c478bd9Sstevel@tonic-gate 4787c478bd9Sstevel@tonic-gate if (INGLOBALZONE(curproc)) 4797c478bd9Sstevel@tonic-gate zoneid = ALL_ZONES; 4807c478bd9Sstevel@tonic-gate else 4817c478bd9Sstevel@tonic-gate zoneid = getzoneid(); 4827c478bd9Sstevel@tonic-gate return (sprlock_zone(pid, zoneid)); 4837c478bd9Sstevel@tonic-gate } 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate void 4867c478bd9Sstevel@tonic-gate sprlock_proc(proc_t *p) 4877c478bd9Sstevel@tonic-gate { 4887c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate while (p->p_proc_flag & P_PR_LOCK) { 4917c478bd9Sstevel@tonic-gate cv_wait(&pr_pid_cv[p->p_slot], &p->p_lock); 4927c478bd9Sstevel@tonic-gate } 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate p->p_proc_flag |= P_PR_LOCK; 4957c478bd9Sstevel@tonic-gate THREAD_KPRI_REQUEST(); 4967c478bd9Sstevel@tonic-gate } 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate void 4997c478bd9Sstevel@tonic-gate sprunlock(proc_t *p) 5007c478bd9Sstevel@tonic-gate { 5017c478bd9Sstevel@tonic-gate if (panicstr) { 5027c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock); 5037c478bd9Sstevel@tonic-gate return; 5047c478bd9Sstevel@tonic-gate } 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate ASSERT(p->p_proc_flag & P_PR_LOCK); 5077c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate cv_signal(&pr_pid_cv[p->p_slot]); 5107c478bd9Sstevel@tonic-gate p->p_proc_flag &= ~P_PR_LOCK; 5117c478bd9Sstevel@tonic-gate mutex_exit(&p->p_lock); 5127c478bd9Sstevel@tonic-gate THREAD_KPRI_RELEASE(); 5137c478bd9Sstevel@tonic-gate } 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate void 5167c478bd9Sstevel@tonic-gate pid_init(void) 5177c478bd9Sstevel@tonic-gate { 5187c478bd9Sstevel@tonic-gate int i; 5197c478bd9Sstevel@tonic-gate 5207c478bd9Sstevel@tonic-gate pid_hashsz = 1 << highbit(v.v_proc / pid_hashlen); 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate pidhash = kmem_zalloc(sizeof (struct pid *) * pid_hashsz, KM_SLEEP); 5237c478bd9Sstevel@tonic-gate procdir = kmem_alloc(sizeof (union procent) * v.v_proc, KM_SLEEP); 5247c478bd9Sstevel@tonic-gate pr_pid_cv = kmem_zalloc(sizeof (kcondvar_t) * v.v_proc, KM_SLEEP); 5257c478bd9Sstevel@tonic-gate proc_lock = kmem_zalloc(sizeof (struct plock) * v.v_proc, KM_SLEEP); 5267c478bd9Sstevel@tonic-gate 5277c478bd9Sstevel@tonic-gate nproc = 1; 5287c478bd9Sstevel@tonic-gate practive = proc_sched; 5297c478bd9Sstevel@tonic-gate proc_sched->p_next = NULL; 5307c478bd9Sstevel@tonic-gate procdir[0].pe_proc = proc_sched; 5317c478bd9Sstevel@tonic-gate 5327c478bd9Sstevel@tonic-gate procentfree = &procdir[1]; 5337c478bd9Sstevel@tonic-gate for (i = 1; i < v.v_proc - 1; i++) 5347c478bd9Sstevel@tonic-gate procdir[i].pe_next = &procdir[i+1]; 5357c478bd9Sstevel@tonic-gate procdir[i].pe_next = NULL; 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate HASHPID(0) = &pid0; 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate upcount_init(); 5407c478bd9Sstevel@tonic-gate } 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate proc_t * 5437c478bd9Sstevel@tonic-gate pid_entry(int slot) 5447c478bd9Sstevel@tonic-gate { 5457c478bd9Sstevel@tonic-gate union procent *pep; 5467c478bd9Sstevel@tonic-gate proc_t *prp; 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock)); 5497c478bd9Sstevel@tonic-gate ASSERT(slot >= 0 && slot < v.v_proc); 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate pep = procdir[slot].pe_next; 5527c478bd9Sstevel@tonic-gate if (pep >= procdir && pep < &procdir[v.v_proc]) 5537c478bd9Sstevel@tonic-gate return (NULL); 5547c478bd9Sstevel@tonic-gate prp = procdir[slot].pe_proc; 5557c478bd9Sstevel@tonic-gate if (prp != 0 && prp->p_stat == SIDL) 5567c478bd9Sstevel@tonic-gate return (NULL); 5577c478bd9Sstevel@tonic-gate return (prp); 5587c478bd9Sstevel@tonic-gate } 5597c478bd9Sstevel@tonic-gate 5607c478bd9Sstevel@tonic-gate /* 5617c478bd9Sstevel@tonic-gate * Send the specified signal to all processes whose process group ID is 5627c478bd9Sstevel@tonic-gate * equal to 'pgid' 5637c478bd9Sstevel@tonic-gate */ 5647c478bd9Sstevel@tonic-gate 5657c478bd9Sstevel@tonic-gate void 5667c478bd9Sstevel@tonic-gate signal(pid_t pgid, int sig) 5677c478bd9Sstevel@tonic-gate { 5687c478bd9Sstevel@tonic-gate struct pid *pidp; 5697c478bd9Sstevel@tonic-gate proc_t *prp; 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 5727c478bd9Sstevel@tonic-gate mutex_enter(&pidlinklock); 5737c478bd9Sstevel@tonic-gate if (pgid == 0 || (pidp = pid_lookup(pgid)) == NULL) { 5747c478bd9Sstevel@tonic-gate mutex_exit(&pidlinklock); 5757c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 5767c478bd9Sstevel@tonic-gate return; 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate mutex_exit(&pidlinklock); 5797c478bd9Sstevel@tonic-gate for (prp = pidp->pid_pglink; prp; prp = prp->p_pglink) { 5807c478bd9Sstevel@tonic-gate mutex_enter(&prp->p_lock); 5817c478bd9Sstevel@tonic-gate sigtoproc(prp, NULL, sig); 5827c478bd9Sstevel@tonic-gate mutex_exit(&prp->p_lock); 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 5857c478bd9Sstevel@tonic-gate } 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate /* 5887c478bd9Sstevel@tonic-gate * Send the specified signal to the specified process 5897c478bd9Sstevel@tonic-gate */ 5907c478bd9Sstevel@tonic-gate 5917c478bd9Sstevel@tonic-gate void 5927c478bd9Sstevel@tonic-gate prsignal(struct pid *pidp, int sig) 5937c478bd9Sstevel@tonic-gate { 5947c478bd9Sstevel@tonic-gate if (!(pidp->pid_prinactive)) 5957c478bd9Sstevel@tonic-gate psignal(procdir[pidp->pid_prslot].pe_proc, sig); 5967c478bd9Sstevel@tonic-gate } 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 5997c478bd9Sstevel@tonic-gate 6007c478bd9Sstevel@tonic-gate /* 6017c478bd9Sstevel@tonic-gate * DDI/DKI interfaces for drivers to send signals to processes 6027c478bd9Sstevel@tonic-gate */ 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate /* 6057c478bd9Sstevel@tonic-gate * obtain an opaque reference to a process for signaling 6067c478bd9Sstevel@tonic-gate */ 6077c478bd9Sstevel@tonic-gate void * 6087c478bd9Sstevel@tonic-gate proc_ref(void) 6097c478bd9Sstevel@tonic-gate { 6107c478bd9Sstevel@tonic-gate struct pid *pidp; 6117c478bd9Sstevel@tonic-gate 6127c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 6137c478bd9Sstevel@tonic-gate pidp = curproc->p_pidp; 6147c478bd9Sstevel@tonic-gate PID_HOLD(pidp); 6157c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 6167c478bd9Sstevel@tonic-gate 6177c478bd9Sstevel@tonic-gate return (pidp); 6187c478bd9Sstevel@tonic-gate } 6197c478bd9Sstevel@tonic-gate 6207c478bd9Sstevel@tonic-gate /* 6217c478bd9Sstevel@tonic-gate * release a reference to a process 6227c478bd9Sstevel@tonic-gate * - a process can exit even if a driver has a reference to it 6237c478bd9Sstevel@tonic-gate * - one proc_unref for every proc_ref 6247c478bd9Sstevel@tonic-gate */ 6257c478bd9Sstevel@tonic-gate void 6267c478bd9Sstevel@tonic-gate proc_unref(void *pref) 6277c478bd9Sstevel@tonic-gate { 6287c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 6297c478bd9Sstevel@tonic-gate PID_RELE((struct pid *)pref); 6307c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 6317c478bd9Sstevel@tonic-gate } 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate /* 6347c478bd9Sstevel@tonic-gate * send a signal to a process 6357c478bd9Sstevel@tonic-gate * 6367c478bd9Sstevel@tonic-gate * - send the process the signal 6377c478bd9Sstevel@tonic-gate * - if the process went away, return a -1 6387c478bd9Sstevel@tonic-gate * - if the process is still there return 0 6397c478bd9Sstevel@tonic-gate */ 6407c478bd9Sstevel@tonic-gate int 6417c478bd9Sstevel@tonic-gate proc_signal(void *pref, int sig) 6427c478bd9Sstevel@tonic-gate { 6437c478bd9Sstevel@tonic-gate struct pid *pidp = pref; 6447c478bd9Sstevel@tonic-gate 6457c478bd9Sstevel@tonic-gate prsignal(pidp, sig); 6467c478bd9Sstevel@tonic-gate return (pidp->pid_prinactive ? -1 : 0); 6477c478bd9Sstevel@tonic-gate } 6487c478bd9Sstevel@tonic-gate 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate static struct upcount **upc_hash; /* a boot time allocated array */ 6517c478bd9Sstevel@tonic-gate static ulong_t upc_hashmask; 6527c478bd9Sstevel@tonic-gate #define UPC_HASH(x, y) ((ulong_t)(x ^ y) & upc_hashmask) 6537c478bd9Sstevel@tonic-gate 6547c478bd9Sstevel@tonic-gate /* 6557c478bd9Sstevel@tonic-gate * Get us off the ground. Called once at boot. 6567c478bd9Sstevel@tonic-gate */ 6577c478bd9Sstevel@tonic-gate void 6587c478bd9Sstevel@tonic-gate upcount_init(void) 6597c478bd9Sstevel@tonic-gate { 6607c478bd9Sstevel@tonic-gate ulong_t upc_hashsize; 6617c478bd9Sstevel@tonic-gate 6627c478bd9Sstevel@tonic-gate /* 6637c478bd9Sstevel@tonic-gate * An entry per MB of memory is our current guess 6647c478bd9Sstevel@tonic-gate */ 6657c478bd9Sstevel@tonic-gate /* 6667c478bd9Sstevel@tonic-gate * 2^20 is a meg, so shifting right by 20 - PAGESHIFT 6677c478bd9Sstevel@tonic-gate * converts pages to megs (without overflowing a u_int 6687c478bd9Sstevel@tonic-gate * if you have more than 4G of memory, like ptob(physmem)/1M 6697c478bd9Sstevel@tonic-gate * would). 6707c478bd9Sstevel@tonic-gate */ 6717c478bd9Sstevel@tonic-gate upc_hashsize = (1 << highbit(physmem >> (20 - PAGESHIFT))); 6727c478bd9Sstevel@tonic-gate upc_hashmask = upc_hashsize - 1; 6737c478bd9Sstevel@tonic-gate upc_hash = kmem_zalloc(upc_hashsize * sizeof (struct upcount *), 6747c478bd9Sstevel@tonic-gate KM_SLEEP); 6757c478bd9Sstevel@tonic-gate } 6767c478bd9Sstevel@tonic-gate 6777c478bd9Sstevel@tonic-gate /* 6787c478bd9Sstevel@tonic-gate * Increment the number of processes associated with a given uid and zoneid. 6797c478bd9Sstevel@tonic-gate */ 6807c478bd9Sstevel@tonic-gate void 6817c478bd9Sstevel@tonic-gate upcount_inc(uid_t uid, zoneid_t zoneid) 6827c478bd9Sstevel@tonic-gate { 6837c478bd9Sstevel@tonic-gate struct upcount **upc, **hupc; 6847c478bd9Sstevel@tonic-gate struct upcount *new; 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock)); 6877c478bd9Sstevel@tonic-gate new = NULL; 6887c478bd9Sstevel@tonic-gate hupc = &upc_hash[UPC_HASH(uid, zoneid)]; 6897c478bd9Sstevel@tonic-gate top: 6907c478bd9Sstevel@tonic-gate upc = hupc; 6917c478bd9Sstevel@tonic-gate while ((*upc) != NULL) { 6927c478bd9Sstevel@tonic-gate if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) { 6937c478bd9Sstevel@tonic-gate (*upc)->up_count++; 6947c478bd9Sstevel@tonic-gate if (new) { 6957c478bd9Sstevel@tonic-gate /* 6967c478bd9Sstevel@tonic-gate * did not need `new' afterall. 6977c478bd9Sstevel@tonic-gate */ 6987c478bd9Sstevel@tonic-gate kmem_free(new, sizeof (*new)); 6997c478bd9Sstevel@tonic-gate } 7007c478bd9Sstevel@tonic-gate return; 7017c478bd9Sstevel@tonic-gate } 7027c478bd9Sstevel@tonic-gate upc = &(*upc)->up_next; 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate /* 7067c478bd9Sstevel@tonic-gate * There is no entry for this <uid,zoneid> pair. 7077c478bd9Sstevel@tonic-gate * Allocate one. If we have to drop pidlock, check 7087c478bd9Sstevel@tonic-gate * again. 7097c478bd9Sstevel@tonic-gate */ 7107c478bd9Sstevel@tonic-gate if (new == NULL) { 7117c478bd9Sstevel@tonic-gate new = (struct upcount *)kmem_alloc(sizeof (*new), KM_NOSLEEP); 7127c478bd9Sstevel@tonic-gate if (new == NULL) { 7137c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 7147c478bd9Sstevel@tonic-gate new = (struct upcount *)kmem_alloc(sizeof (*new), 7157c478bd9Sstevel@tonic-gate KM_SLEEP); 7167c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 7177c478bd9Sstevel@tonic-gate goto top; 7187c478bd9Sstevel@tonic-gate } 7197c478bd9Sstevel@tonic-gate } 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate /* 7237c478bd9Sstevel@tonic-gate * On the assumption that a new user is going to do some 7247c478bd9Sstevel@tonic-gate * more forks, put the new upcount structure on the front. 7257c478bd9Sstevel@tonic-gate */ 7267c478bd9Sstevel@tonic-gate upc = hupc; 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate new->up_uid = uid; 7297c478bd9Sstevel@tonic-gate new->up_zoneid = zoneid; 7307c478bd9Sstevel@tonic-gate new->up_count = 1; 7317c478bd9Sstevel@tonic-gate new->up_next = *upc; 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate *upc = new; 7347c478bd9Sstevel@tonic-gate } 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate /* 7377c478bd9Sstevel@tonic-gate * Decrement the number of processes a given uid and zoneid has. 7387c478bd9Sstevel@tonic-gate */ 7397c478bd9Sstevel@tonic-gate void 7407c478bd9Sstevel@tonic-gate upcount_dec(uid_t uid, zoneid_t zoneid) 7417c478bd9Sstevel@tonic-gate { 7427c478bd9Sstevel@tonic-gate struct upcount **upc; 7437c478bd9Sstevel@tonic-gate struct upcount *done; 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock)); 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate upc = &upc_hash[UPC_HASH(uid, zoneid)]; 7487c478bd9Sstevel@tonic-gate while ((*upc) != NULL) { 7497c478bd9Sstevel@tonic-gate if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) { 7507c478bd9Sstevel@tonic-gate (*upc)->up_count--; 7517c478bd9Sstevel@tonic-gate if ((*upc)->up_count == 0) { 7527c478bd9Sstevel@tonic-gate done = *upc; 7537c478bd9Sstevel@tonic-gate *upc = (*upc)->up_next; 7547c478bd9Sstevel@tonic-gate kmem_free(done, sizeof (*done)); 7557c478bd9Sstevel@tonic-gate } 7567c478bd9Sstevel@tonic-gate return; 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate upc = &(*upc)->up_next; 7597c478bd9Sstevel@tonic-gate } 7607c478bd9Sstevel@tonic-gate cmn_err(CE_PANIC, "decr_upcount-off the end"); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate /* 7647c478bd9Sstevel@tonic-gate * Returns the number of processes a uid has. 7657c478bd9Sstevel@tonic-gate * Non-existent uid's are assumed to have no processes. 7667c478bd9Sstevel@tonic-gate */ 7677c478bd9Sstevel@tonic-gate int 7687c478bd9Sstevel@tonic-gate upcount_get(uid_t uid, zoneid_t zoneid) 7697c478bd9Sstevel@tonic-gate { 7707c478bd9Sstevel@tonic-gate struct upcount *upc; 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&pidlock)); 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate upc = upc_hash[UPC_HASH(uid, zoneid)]; 7757c478bd9Sstevel@tonic-gate while (upc != NULL) { 7767c478bd9Sstevel@tonic-gate if (upc->up_uid == uid && upc->up_zoneid == zoneid) { 7777c478bd9Sstevel@tonic-gate return (upc->up_count); 7787c478bd9Sstevel@tonic-gate } 7797c478bd9Sstevel@tonic-gate upc = upc->up_next; 7807c478bd9Sstevel@tonic-gate } 7817c478bd9Sstevel@tonic-gate return (0); 7827c478bd9Sstevel@tonic-gate } 783