/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #pragma ident "%Z%%M% %I% %E% SMI" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* directory entries for /proc */ union procent { proc_t *pe_proc; union procent *pe_next; }; struct pid pid0 = { 0, /* pid_prinactive */ 1, /* pid_pgorphaned */ 0, /* pid_padding */ 0, /* pid_prslot */ 0, /* pid_id */ NULL, /* pid_pglink */ NULL, /* pid_link */ 3 /* pid_ref */ }; static int pid_hashlen = 4; /* desired average hash chain length */ static int pid_hashsz; /* number of buckets in the hash table */ #define HASHPID(pid) (pidhash[((pid)&(pid_hashsz-1))]) extern uint_t nproc; extern struct kmem_cache *process_cache; static void upcount_init(void); kmutex_t pidlock; /* global process lock */ kmutex_t pr_pidlock; /* /proc global process lock */ kcondvar_t *pr_pid_cv; /* for /proc, one per process slot */ struct plock *proc_lock; /* persistent array of p_lock's */ /* * See the comment above pid_getlockslot() for a detailed explanation of this * constant. Note that a PLOCK_SHIFT of 3 implies 64-byte coherence * granularity; if the coherence granularity is ever changed, this constant * should be modified to reflect the change to minimize proc_lock false * sharing (correctness, however, is guaranteed regardless of the coherence * granularity). */ #define PLOCK_SHIFT 3 static kmutex_t pidlinklock; static struct pid **pidhash; static pid_t minpid; static pid_t mpid; static union procent *procdir; static union procent *procentfree; static struct pid * pid_lookup(pid_t pid) { struct pid *pidp; ASSERT(MUTEX_HELD(&pidlinklock)); for (pidp = HASHPID(pid); pidp; pidp = pidp->pid_link) { if (pidp->pid_id == pid) { ASSERT(pidp->pid_ref > 0); break; } } return (pidp); } void pid_setmin(void) { if (jump_pid && jump_pid > mpid) minpid = mpid = jump_pid; else minpid = mpid + 1; } /* * When prslots are simply used as an index to determine a process' p_lock, * adjacent prslots share adjacent p_locks. On machines where the size * of a mutex is smaller than that of a cache line (which, as of this writing, * is true for all machines on which Solaris runs), this can potentially * induce false sharing. The standard solution for false sharing is to pad * out one's data structures (in this case, struct plock). However, * given the size and (generally) sparse use of the proc_lock array, this * is suboptimal. We therefore stride through the proc_lock array with * a stride of PLOCK_SHIFT. PLOCK_SHIFT should be defined as: * * log_2 (coherence_granularity / sizeof (kmutex_t)) * * Under this scheme, false sharing is still possible -- but only when * the number of active processes is very large. Note that the one-to-one * mapping between prslots and lockslots is maintained. */ static int pid_getlockslot(int prslot) { int even = (v.v_proc >> PLOCK_SHIFT) << PLOCK_SHIFT; int perlap = even >> PLOCK_SHIFT; if (prslot >= even) return (prslot); return (((prslot % perlap) << PLOCK_SHIFT) + (prslot / perlap)); } /* * This function assigns a pid for use in a fork request. It allocates * a pid structure, tries to find an empty slot in the proc table, * and selects the process id. * * pid_assign() returns the new pid on success, -1 on failure. */ pid_t pid_assign(proc_t *prp) { struct pid *pidp; union procent *pep; pid_t newpid, startpid; pidp = kmem_zalloc(sizeof (struct pid), KM_SLEEP); mutex_enter(&pidlinklock); if ((pep = procentfree) == NULL) { /* * ran out of /proc directory entries */ goto failed; } /* * Allocate a pid */ startpid = mpid; do { newpid = (++mpid == maxpid ? mpid = minpid : mpid); } while (pid_lookup(newpid) && newpid != startpid); if (newpid == startpid && pid_lookup(newpid)) { /* couldn't find a free pid */ goto failed; } procentfree = pep->pe_next; pep->pe_proc = prp; prp->p_pidp = pidp; /* * Put pid into the pid hash table. */ pidp->pid_link = HASHPID(newpid); HASHPID(newpid) = pidp; pidp->pid_ref = 1; pidp->pid_id = newpid; pidp->pid_prslot = pep - procdir; prp->p_lockp = &proc_lock[pid_getlockslot(pidp->pid_prslot)]; mutex_exit(&pidlinklock); return (newpid); failed: mutex_exit(&pidlinklock); kmem_free(pidp, sizeof (struct pid)); return (-1); } /* * decrement the reference count for pid */ int pid_rele(struct pid *pidp) { struct pid **pidpp; mutex_enter(&pidlinklock); ASSERT(pidp != &pid0); pidpp = &HASHPID(pidp->pid_id); for (;;) { ASSERT(*pidpp != NULL); if (*pidpp == pidp) break; pidpp = &(*pidpp)->pid_link; } *pidpp = pidp->pid_link; mutex_exit(&pidlinklock); kmem_free(pidp, sizeof (*pidp)); return (0); } void proc_entry_free(struct pid *pidp) { mutex_enter(&pidlinklock); pidp->pid_prinactive = 1; procdir[pidp->pid_prslot].pe_next = procentfree; procentfree = &procdir[pidp->pid_prslot]; mutex_exit(&pidlinklock); } void pid_exit(proc_t *prp) { struct pid *pidp; ASSERT(MUTEX_HELD(&pidlock)); /* * Exit process group. If it is NULL, it's because fork failed * before calling pgjoin(). */ ASSERT(prp->p_pgidp != NULL || prp->p_stat == SIDL); if (prp->p_pgidp != NULL) pgexit(prp); SESS_RELE(prp->p_sessp); pidp = prp->p_pidp; proc_entry_free(pidp); #ifdef C2_AUDIT if (audit_active) audit_pfree(prp); #endif if (practive == prp) { practive = prp->p_next; } if (prp->p_next) { prp->p_next->p_prev = prp->p_prev; } if (prp->p_prev) { prp->p_prev->p_next = prp->p_next; } PID_RELE(pidp); mutex_destroy(&prp->p_crlock); kmem_cache_free(process_cache, prp); nproc--; } /* * Find a process visible from the specified zone given its process ID. */ proc_t * prfind_zone(pid_t pid, zoneid_t zoneid) { struct pid *pidp; proc_t *p; ASSERT(MUTEX_HELD(&pidlock)); mutex_enter(&pidlinklock); pidp = pid_lookup(pid); mutex_exit(&pidlinklock); if (pidp != NULL && pidp->pid_prinactive == 0) { p = procdir[pidp->pid_prslot].pe_proc; if (zoneid == ALL_ZONES || p->p_zone->zone_id == zoneid) return (p); } return (NULL); } /* * Find a process given its process ID. This obeys zone restrictions, * so if the caller is in a non-global zone it won't find processes * associated with other zones. Use prfind_zone(pid, ALL_ZONES) to * bypass this restriction. */ proc_t * prfind(pid_t pid) { zoneid_t zoneid; if (INGLOBALZONE(curproc)) zoneid = ALL_ZONES; else zoneid = getzoneid(); return (prfind_zone(pid, zoneid)); } proc_t * pgfind_zone(pid_t pgid, zoneid_t zoneid) { struct pid *pidp; ASSERT(MUTEX_HELD(&pidlock)); mutex_enter(&pidlinklock); pidp = pid_lookup(pgid); mutex_exit(&pidlinklock); if (pidp != NULL) { proc_t *p = pidp->pid_pglink; if (zoneid == ALL_ZONES || pgid == 0 || p == NULL || p->p_zone->zone_id == zoneid) return (p); } return (NULL); } /* * return the head of the list of processes whose process group ID is 'pgid', * or NULL, if no such process group */ proc_t * pgfind(pid_t pgid) { zoneid_t zoneid; if (INGLOBALZONE(curproc)) zoneid = ALL_ZONES; else zoneid = getzoneid(); return (pgfind_zone(pgid, zoneid)); } /* * If pid exists, find its proc, acquire its p_lock and mark it P_PR_LOCK. * Returns the proc pointer on success, NULL on failure. sprlock() is * really just a stripped-down version of pr_p_lock() to allow practive * walkers like dofusers() and dumpsys() to synchronize with /proc. */ proc_t * sprlock_zone(pid_t pid, zoneid_t zoneid) { proc_t *p; kmutex_t *mp; for (;;) { mutex_enter(&pidlock); if ((p = prfind_zone(pid, zoneid)) == NULL) { mutex_exit(&pidlock); return (NULL); } /* * p_lock is persistent, but p itself is not -- it could * vanish during cv_wait(). Load p->p_lock now so we can * drop it after cv_wait() without referencing p. */ mp = &p->p_lock; mutex_enter(mp); mutex_exit(&pidlock); /* * If the process is in some half-baked state, fail. */ if (p->p_stat == SZOMB || p->p_stat == SIDL || p->p_tlist == NULL || (p->p_flag & SEXITLWPS)) { mutex_exit(mp); return (NULL); } if (panicstr) return (p); if (!(p->p_proc_flag & P_PR_LOCK)) break; cv_wait(&pr_pid_cv[p->p_slot], mp); mutex_exit(mp); } p->p_proc_flag |= P_PR_LOCK; THREAD_KPRI_REQUEST(); return (p); } proc_t * sprlock(pid_t pid) { zoneid_t zoneid; if (INGLOBALZONE(curproc)) zoneid = ALL_ZONES; else zoneid = getzoneid(); return (sprlock_zone(pid, zoneid)); } void sprlock_proc(proc_t *p) { ASSERT(MUTEX_HELD(&p->p_lock)); while (p->p_proc_flag & P_PR_LOCK) { cv_wait(&pr_pid_cv[p->p_slot], &p->p_lock); } p->p_proc_flag |= P_PR_LOCK; THREAD_KPRI_REQUEST(); } void sprunlock(proc_t *p) { if (panicstr) { mutex_exit(&p->p_lock); return; } ASSERT(p->p_proc_flag & P_PR_LOCK); ASSERT(MUTEX_HELD(&p->p_lock)); cv_signal(&pr_pid_cv[p->p_slot]); p->p_proc_flag &= ~P_PR_LOCK; mutex_exit(&p->p_lock); THREAD_KPRI_RELEASE(); } void pid_init(void) { int i; pid_hashsz = 1 << highbit(v.v_proc / pid_hashlen); pidhash = kmem_zalloc(sizeof (struct pid *) * pid_hashsz, KM_SLEEP); procdir = kmem_alloc(sizeof (union procent) * v.v_proc, KM_SLEEP); pr_pid_cv = kmem_zalloc(sizeof (kcondvar_t) * v.v_proc, KM_SLEEP); proc_lock = kmem_zalloc(sizeof (struct plock) * v.v_proc, KM_SLEEP); nproc = 1; practive = proc_sched; proc_sched->p_next = NULL; procdir[0].pe_proc = proc_sched; procentfree = &procdir[1]; for (i = 1; i < v.v_proc - 1; i++) procdir[i].pe_next = &procdir[i+1]; procdir[i].pe_next = NULL; HASHPID(0) = &pid0; upcount_init(); } proc_t * pid_entry(int slot) { union procent *pep; proc_t *prp; ASSERT(MUTEX_HELD(&pidlock)); ASSERT(slot >= 0 && slot < v.v_proc); pep = procdir[slot].pe_next; if (pep >= procdir && pep < &procdir[v.v_proc]) return (NULL); prp = procdir[slot].pe_proc; if (prp != 0 && prp->p_stat == SIDL) return (NULL); return (prp); } /* * Send the specified signal to all processes whose process group ID is * equal to 'pgid' */ void signal(pid_t pgid, int sig) { struct pid *pidp; proc_t *prp; mutex_enter(&pidlock); mutex_enter(&pidlinklock); if (pgid == 0 || (pidp = pid_lookup(pgid)) == NULL) { mutex_exit(&pidlinklock); mutex_exit(&pidlock); return; } mutex_exit(&pidlinklock); for (prp = pidp->pid_pglink; prp; prp = prp->p_pglink) { mutex_enter(&prp->p_lock); sigtoproc(prp, NULL, sig); mutex_exit(&prp->p_lock); } mutex_exit(&pidlock); } /* * Send the specified signal to the specified process */ void prsignal(struct pid *pidp, int sig) { if (!(pidp->pid_prinactive)) psignal(procdir[pidp->pid_prslot].pe_proc, sig); } #include /* * DDI/DKI interfaces for drivers to send signals to processes */ /* * obtain an opaque reference to a process for signaling */ void * proc_ref(void) { struct pid *pidp; mutex_enter(&pidlock); pidp = curproc->p_pidp; PID_HOLD(pidp); mutex_exit(&pidlock); return (pidp); } /* * release a reference to a process * - a process can exit even if a driver has a reference to it * - one proc_unref for every proc_ref */ void proc_unref(void *pref) { mutex_enter(&pidlock); PID_RELE((struct pid *)pref); mutex_exit(&pidlock); } /* * send a signal to a process * * - send the process the signal * - if the process went away, return a -1 * - if the process is still there return 0 */ int proc_signal(void *pref, int sig) { struct pid *pidp = pref; prsignal(pidp, sig); return (pidp->pid_prinactive ? -1 : 0); } static struct upcount **upc_hash; /* a boot time allocated array */ static ulong_t upc_hashmask; #define UPC_HASH(x, y) ((ulong_t)(x ^ y) & upc_hashmask) /* * Get us off the ground. Called once at boot. */ void upcount_init(void) { ulong_t upc_hashsize; /* * An entry per MB of memory is our current guess */ /* * 2^20 is a meg, so shifting right by 20 - PAGESHIFT * converts pages to megs (without overflowing a u_int * if you have more than 4G of memory, like ptob(physmem)/1M * would). */ upc_hashsize = (1 << highbit(physmem >> (20 - PAGESHIFT))); upc_hashmask = upc_hashsize - 1; upc_hash = kmem_zalloc(upc_hashsize * sizeof (struct upcount *), KM_SLEEP); } /* * Increment the number of processes associated with a given uid and zoneid. */ void upcount_inc(uid_t uid, zoneid_t zoneid) { struct upcount **upc, **hupc; struct upcount *new; ASSERT(MUTEX_HELD(&pidlock)); new = NULL; hupc = &upc_hash[UPC_HASH(uid, zoneid)]; top: upc = hupc; while ((*upc) != NULL) { if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) { (*upc)->up_count++; if (new) { /* * did not need `new' afterall. */ kmem_free(new, sizeof (*new)); } return; } upc = &(*upc)->up_next; } /* * There is no entry for this pair. * Allocate one. If we have to drop pidlock, check * again. */ if (new == NULL) { new = (struct upcount *)kmem_alloc(sizeof (*new), KM_NOSLEEP); if (new == NULL) { mutex_exit(&pidlock); new = (struct upcount *)kmem_alloc(sizeof (*new), KM_SLEEP); mutex_enter(&pidlock); goto top; } } /* * On the assumption that a new user is going to do some * more forks, put the new upcount structure on the front. */ upc = hupc; new->up_uid = uid; new->up_zoneid = zoneid; new->up_count = 1; new->up_next = *upc; *upc = new; } /* * Decrement the number of processes a given uid and zoneid has. */ void upcount_dec(uid_t uid, zoneid_t zoneid) { struct upcount **upc; struct upcount *done; ASSERT(MUTEX_HELD(&pidlock)); upc = &upc_hash[UPC_HASH(uid, zoneid)]; while ((*upc) != NULL) { if ((*upc)->up_uid == uid && (*upc)->up_zoneid == zoneid) { (*upc)->up_count--; if ((*upc)->up_count == 0) { done = *upc; *upc = (*upc)->up_next; kmem_free(done, sizeof (*done)); } return; } upc = &(*upc)->up_next; } cmn_err(CE_PANIC, "decr_upcount-off the end"); } /* * Returns the number of processes a uid has. * Non-existent uid's are assumed to have no processes. */ int upcount_get(uid_t uid, zoneid_t zoneid) { struct upcount *upc; ASSERT(MUTEX_HELD(&pidlock)); upc = upc_hash[UPC_HASH(uid, zoneid)]; while (upc != NULL) { if (upc->up_uid == uid && upc->up_zoneid == zoneid) { return (upc->up_count); } upc = upc->up_next; } return (0); }