/* $NetBSD: kern_proc.c,v 1.158 2009/11/26 00:19:11 matt Exp $ */ /*- * Copyright (c) 1999, 2006, 2007, 2008 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, * NASA Ames Research Center, and by Andrew Doran. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * Copyright (c) 1982, 1986, 1989, 1991, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95 */ #include __KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.158 2009/11/26 00:19:11 matt Exp $"); #include "opt_kstack.h" #include "opt_maxuprc.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "sys/syscall_stats.h" #include #include #include #include #include #include /* * Other process lists */ struct proclist allproc; struct proclist zombproc; /* resources have been freed */ kmutex_t *proc_lock; /* * pid to proc lookup is done by indexing the pid_table array. * Since pid numbers are only allocated when an empty slot * has been found, there is no need to search any lists ever. * (an orphaned pgrp will lock the slot, a session will lock * the pgrp with the same number.) * If the table is too small it is reallocated with twice the * previous size and the entries 'unzipped' into the two halves. * A linked list of free entries is passed through the pt_proc * field of 'free' items - set odd to be an invalid ptr. */ struct pid_table { struct proc *pt_proc; struct pgrp *pt_pgrp; }; #if 1 /* strongly typed cast - should be a noop */ static inline uint p2u(struct proc *p) { return (uint)(uintptr_t)p; } #else #define p2u(p) ((uint)p) #endif #define P_VALID(p) (!(p2u(p) & 1)) #define P_NEXT(p) (p2u(p) >> 1) #define P_FREE(pid) ((struct proc *)(uintptr_t)((pid) << 1 | 1)) #define INITIAL_PID_TABLE_SIZE (1 << 5) static struct pid_table *pid_table; static uint pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1; static uint pid_alloc_lim; /* max we allocate before growing table */ static uint pid_alloc_cnt; /* number of allocated pids */ /* links through free slots - never empty! */ static uint next_free_pt, last_free_pt; static pid_t pid_max = PID_MAX; /* largest value we allocate */ /* Components of the first process -- never freed. */ extern struct emul emul_netbsd; /* defined in kern_exec.c */ struct session session0 = { .s_count = 1, .s_sid = 0, }; struct pgrp pgrp0 = { .pg_members = LIST_HEAD_INITIALIZER(&pgrp0.pg_members), .pg_session = &session0, }; filedesc_t filedesc0; struct cwdinfo cwdi0 = { .cwdi_cmask = CMASK, /* see cmask below */ .cwdi_refcnt = 1, }; struct plimit limit0; struct pstats pstat0; struct vmspace vmspace0; struct sigacts sigacts0; struct turnstile turnstile0; struct proc proc0 = { .p_lwps = LIST_HEAD_INITIALIZER(&proc0.p_lwps), .p_sigwaiters = LIST_HEAD_INITIALIZER(&proc0.p_sigwaiters), .p_nlwps = 1, .p_nrlwps = 1, .p_nlwpid = 1, /* must match lwp0.l_lid */ .p_pgrp = &pgrp0, .p_comm = "system", /* * Set P_NOCLDWAIT so that kernel threads are reparented to init(8) * when they exit. init(8) can easily wait them out for us. */ .p_flag = PK_SYSTEM | PK_NOCLDWAIT, .p_stat = SACTIVE, .p_nice = NZERO, .p_emul = &emul_netbsd, .p_cwdi = &cwdi0, .p_limit = &limit0, .p_fd = &filedesc0, .p_vmspace = &vmspace0, .p_stats = &pstat0, .p_sigacts = &sigacts0, }; struct lwp lwp0 __aligned(MIN_LWP_ALIGNMENT) = { #ifdef LWP0_CPU_INFO .l_cpu = LWP0_CPU_INFO, #endif .l_proc = &proc0, .l_lid = 1, .l_flag = LW_SYSTEM, .l_stat = LSONPROC, .l_ts = &turnstile0, .l_syncobj = &sched_syncobj, .l_refcnt = 1, .l_priority = PRI_USER + NPRI_USER - 1, .l_inheritedprio = -1, .l_class = SCHED_OTHER, .l_psid = PS_NONE, .l_pi_lenders = SLIST_HEAD_INITIALIZER(&lwp0.l_pi_lenders), .l_name = __UNCONST("swapper"), .l_fd = &filedesc0, }; kauth_cred_t cred0; int nofile = NOFILE; int maxuprc = MAXUPRC; int cmask = CMASK; MALLOC_DEFINE(M_EMULDATA, "emuldata", "Per-process emulation data"); MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures"); /* * The process list descriptors, used during pid allocation and * by sysctl. No locking on this data structure is needed since * it is completely static. */ const struct proclist_desc proclists[] = { { &allproc }, { &zombproc }, { NULL }, }; static struct pgrp * pg_remove(pid_t); static void pg_delete(pid_t); static void orphanpg(struct pgrp *); static specificdata_domain_t proc_specificdata_domain; static pool_cache_t proc_cache; static kauth_listener_t proc_listener; static int proc_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie, void *arg0, void *arg1, void *arg2, void *arg3) { struct proc *p; int result; result = KAUTH_RESULT_DEFER; p = arg0; switch (action) { case KAUTH_PROCESS_CANSEE: { enum kauth_process_req req; req = (enum kauth_process_req)arg1; switch (req) { case KAUTH_REQ_PROCESS_CANSEE_ARGS: case KAUTH_REQ_PROCESS_CANSEE_ENTRY: case KAUTH_REQ_PROCESS_CANSEE_OPENFILES: result = KAUTH_RESULT_ALLOW; break; case KAUTH_REQ_PROCESS_CANSEE_ENV: if (kauth_cred_getuid(cred) != kauth_cred_getuid(p->p_cred) || kauth_cred_getuid(cred) != kauth_cred_getsvuid(p->p_cred)) break; result = KAUTH_RESULT_ALLOW; break; default: break; } break; } case KAUTH_PROCESS_FORK: { int lnprocs = (int)(unsigned long)arg2; /* * Don't allow a nonprivileged user to use the last few * processes. The variable lnprocs is the current number of * processes, maxproc is the limit. */ if (__predict_false((lnprocs >= maxproc - 5))) break; result = KAUTH_RESULT_ALLOW; break; } case KAUTH_PROCESS_CORENAME: case KAUTH_PROCESS_STOPFLAG: if (proc_uidmatch(cred, p->p_cred) == 0) result = KAUTH_RESULT_ALLOW; break; default: break; } return result; } /* * Initialize global process hashing structures. */ void procinit(void) { const struct proclist_desc *pd; u_int i; #define LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1)) for (pd = proclists; pd->pd_list != NULL; pd++) LIST_INIT(pd->pd_list); proc_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE); pid_table = kmem_alloc(INITIAL_PID_TABLE_SIZE * sizeof(struct pid_table), KM_SLEEP); /* Set free list running through table... Preset 'use count' above PID_MAX so we allocate pid 1 next. */ for (i = 0; i <= pid_tbl_mask; i++) { pid_table[i].pt_proc = P_FREE(LINK_EMPTY + i + 1); pid_table[i].pt_pgrp = 0; } /* slot 0 is just grabbed */ next_free_pt = 1; /* Need to fix last entry. */ last_free_pt = pid_tbl_mask; pid_table[last_free_pt].pt_proc = P_FREE(LINK_EMPTY); /* point at which we grow table - to avoid reusing pids too often */ pid_alloc_lim = pid_tbl_mask - 1; #undef LINK_EMPTY proc_specificdata_domain = specificdata_domain_create(); KASSERT(proc_specificdata_domain != NULL); proc_cache = pool_cache_init(sizeof(struct proc), 0, 0, 0, "procpl", NULL, IPL_NONE, NULL, NULL, NULL); proc_listener = kauth_listen_scope(KAUTH_SCOPE_PROCESS, proc_listener_cb, NULL); } /* * Initialize process 0. */ void proc0_init(void) { struct proc *p; struct pgrp *pg; struct lwp *l; rlim_t lim; int i; p = &proc0; pg = &pgrp0; l = &lwp0; KASSERT(l->l_addr != NULL); KASSERT(l->l_lid == p->p_nlwpid); mutex_init(&p->p_stmutex, MUTEX_DEFAULT, IPL_HIGH); mutex_init(&p->p_auxlock, MUTEX_DEFAULT, IPL_NONE); p->p_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE); rw_init(&p->p_reflock); cv_init(&p->p_waitcv, "wait"); cv_init(&p->p_lwpcv, "lwpwait"); LIST_INSERT_HEAD(&p->p_lwps, l, l_sibling); pid_table[0].pt_proc = p; LIST_INSERT_HEAD(&allproc, p, p_list); LIST_INSERT_HEAD(&alllwp, l, l_list); pid_table[0].pt_pgrp = pg; LIST_INSERT_HEAD(&pg->pg_members, p, p_pglist); #ifdef __HAVE_SYSCALL_INTERN (*p->p_emul->e_syscall_intern)(p); #endif callout_init(&l->l_timeout_ch, CALLOUT_MPSAFE); callout_setfunc(&l->l_timeout_ch, sleepq_timeout, l); cv_init(&l->l_sigcv, "sigwait"); /* Create credentials. */ cred0 = kauth_cred_alloc(); p->p_cred = cred0; kauth_cred_hold(cred0); l->l_cred = cred0; /* Create the CWD info. */ rw_init(&cwdi0.cwdi_lock); /* Create the limits structures. */ mutex_init(&limit0.pl_lock, MUTEX_DEFAULT, IPL_NONE); for (i = 0; i < __arraycount(limit0.pl_rlimit); i++) limit0.pl_rlimit[i].rlim_cur = limit0.pl_rlimit[i].rlim_max = RLIM_INFINITY; limit0.pl_rlimit[RLIMIT_NOFILE].rlim_max = maxfiles; limit0.pl_rlimit[RLIMIT_NOFILE].rlim_cur = maxfiles < nofile ? maxfiles : nofile; limit0.pl_rlimit[RLIMIT_NPROC].rlim_max = maxproc; limit0.pl_rlimit[RLIMIT_NPROC].rlim_cur = maxproc < maxuprc ? maxproc : maxuprc; lim = ptoa(uvmexp.free); limit0.pl_rlimit[RLIMIT_RSS].rlim_max = lim; limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_max = lim; limit0.pl_rlimit[RLIMIT_MEMLOCK].rlim_cur = lim / 3; limit0.pl_corename = defcorename; limit0.pl_refcnt = 1; limit0.pl_sv_limit = NULL; /* Configure virtual memory system, set vm rlimits. */ uvm_init_limits(p); /* Initialize file descriptor table for proc0. */ fd_init(&filedesc0); /* * Initialize proc0's vmspace, which uses the kernel pmap. * All kernel processes (which never have user space mappings) * share proc0's vmspace, and thus, the kernel pmap. */ uvmspace_init(&vmspace0, pmap_kernel(), round_page(VM_MIN_ADDRESS), trunc_page(VM_MAX_ADDRESS)); /* Initialize signal state for proc0. XXX IPL_SCHED */ mutex_init(&p->p_sigacts->sa_mutex, MUTEX_DEFAULT, IPL_SCHED); siginit(p); proc_initspecific(p); lwp_initspecific(l); SYSCALL_TIME_LWP_INIT(l); } /* * Session reference counting. */ void proc_sesshold(struct session *ss) { KASSERT(mutex_owned(proc_lock)); ss->s_count++; } void proc_sessrele(struct session *ss) { KASSERT(mutex_owned(proc_lock)); /* * We keep the pgrp with the same id as the session in order to * stop a process being given the same pid. Since the pgrp holds * a reference to the session, it must be a 'zombie' pgrp by now. */ if (--ss->s_count == 0) { struct pgrp *pg; pg = pg_remove(ss->s_sid); mutex_exit(proc_lock); kmem_free(pg, sizeof(struct pgrp)); kmem_free(ss, sizeof(struct session)); } else { mutex_exit(proc_lock); } } /* * Check that the specified process group is in the session of the * specified process. * Treats -ve ids as process ids. * Used to validate TIOCSPGRP requests. */ int pgid_in_session(struct proc *p, pid_t pg_id) { struct pgrp *pgrp; struct session *session; int error; mutex_enter(proc_lock); if (pg_id < 0) { struct proc *p1 = p_find(-pg_id, PFIND_LOCKED | PFIND_UNLOCK_FAIL); if (p1 == NULL) return EINVAL; pgrp = p1->p_pgrp; } else { pgrp = pg_find(pg_id, PFIND_LOCKED | PFIND_UNLOCK_FAIL); if (pgrp == NULL) return EINVAL; } session = pgrp->pg_session; if (session != p->p_pgrp->pg_session) error = EPERM; else error = 0; mutex_exit(proc_lock); return error; } /* * p_inferior: is p an inferior of q? */ static inline bool p_inferior(struct proc *p, struct proc *q) { KASSERT(mutex_owned(proc_lock)); for (; p != q; p = p->p_pptr) if (p->p_pid == 0) return false; return true; } /* * Locate a process by number */ struct proc * p_find(pid_t pid, uint flags) { struct proc *p; char stat; if (!(flags & PFIND_LOCKED)) mutex_enter(proc_lock); p = pid_table[pid & pid_tbl_mask].pt_proc; /* Only allow live processes to be found by pid. */ /* XXXSMP p_stat */ if (P_VALID(p) && p->p_pid == pid && ((stat = p->p_stat) == SACTIVE || stat == SSTOP || ((flags & PFIND_ZOMBIE) && (stat == SZOMB || stat == SDEAD || stat == SDYING)))) { if (flags & PFIND_UNLOCK_OK) mutex_exit(proc_lock); return p; } if (flags & PFIND_UNLOCK_FAIL) mutex_exit(proc_lock); return NULL; } /* * Locate a process group by number */ struct pgrp * pg_find(pid_t pgid, uint flags) { struct pgrp *pg; if (!(flags & PFIND_LOCKED)) mutex_enter(proc_lock); pg = pid_table[pgid & pid_tbl_mask].pt_pgrp; /* * Can't look up a pgrp that only exists because the session * hasn't died yet (traditional) */ if (pg == NULL || pg->pg_id != pgid || LIST_EMPTY(&pg->pg_members)) { if (flags & PFIND_UNLOCK_FAIL) mutex_exit(proc_lock); return NULL; } if (flags & PFIND_UNLOCK_OK) mutex_exit(proc_lock); return pg; } static void expand_pid_table(void) { size_t pt_size, tsz; struct pid_table *n_pt, *new_pt; struct proc *proc; struct pgrp *pgrp; pid_t pid; u_int i; pt_size = pid_tbl_mask + 1; tsz = pt_size * 2 * sizeof(struct pid_table); new_pt = kmem_alloc(tsz, KM_SLEEP); mutex_enter(proc_lock); if (pt_size != pid_tbl_mask + 1) { /* Another process beat us to it... */ mutex_exit(proc_lock); kmem_free(new_pt, tsz); return; } /* * Copy entries from old table into new one. * If 'pid' is 'odd' we need to place in the upper half, * even pid's to the lower half. * Free items stay in the low half so we don't have to * fixup the reference to them. * We stuff free items on the front of the freelist * because we can't write to unmodified entries. * Processing the table backwards maintains a semblance * of issueing pid numbers that increase with time. */ i = pt_size - 1; n_pt = new_pt + i; for (; ; i--, n_pt--) { proc = pid_table[i].pt_proc; pgrp = pid_table[i].pt_pgrp; if (!P_VALID(proc)) { /* Up 'use count' so that link is valid */ pid = (P_NEXT(proc) + pt_size) & ~pt_size; proc = P_FREE(pid); if (pgrp) pid = pgrp->pg_id; } else pid = proc->p_pid; /* Save entry in appropriate half of table */ n_pt[pid & pt_size].pt_proc = proc; n_pt[pid & pt_size].pt_pgrp = pgrp; /* Put other piece on start of free list */ pid = (pid ^ pt_size) & ~pid_tbl_mask; n_pt[pid & pt_size].pt_proc = P_FREE((pid & ~pt_size) | next_free_pt); n_pt[pid & pt_size].pt_pgrp = 0; next_free_pt = i | (pid & pt_size); if (i == 0) break; } /* Save old table size and switch tables */ tsz = pt_size * sizeof(struct pid_table); n_pt = pid_table; pid_table = new_pt; pid_tbl_mask = pt_size * 2 - 1; /* * pid_max starts as PID_MAX (= 30000), once we have 16384 * allocated pids we need it to be larger! */ if (pid_tbl_mask > PID_MAX) { pid_max = pid_tbl_mask * 2 + 1; pid_alloc_lim |= pid_alloc_lim << 1; } else pid_alloc_lim <<= 1; /* doubles number of free slots... */ mutex_exit(proc_lock); kmem_free(n_pt, tsz); } struct proc * proc_alloc(void) { struct proc *p; int nxt; pid_t pid; struct pid_table *pt; p = pool_cache_get(proc_cache, PR_WAITOK); p->p_stat = SIDL; /* protect against others */ proc_initspecific(p); /* allocate next free pid */ for (;;expand_pid_table()) { if (__predict_false(pid_alloc_cnt >= pid_alloc_lim)) /* ensure pids cycle through 2000+ values */ continue; mutex_enter(proc_lock); pt = &pid_table[next_free_pt]; #ifdef DIAGNOSTIC if (__predict_false(P_VALID(pt->pt_proc) || pt->pt_pgrp)) panic("proc_alloc: slot busy"); #endif nxt = P_NEXT(pt->pt_proc); if (nxt & pid_tbl_mask) break; /* Table full - expand (NB last entry not used....) */ mutex_exit(proc_lock); } /* pid is 'saved use count' + 'size' + entry */ pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt; if ((uint)pid > (uint)pid_max) pid &= pid_tbl_mask; p->p_pid = pid; next_free_pt = nxt & pid_tbl_mask; /* Grab table slot */ pt->pt_proc = p; pid_alloc_cnt++; mutex_exit(proc_lock); return p; } /* * Free a process id - called from proc_free (in kern_exit.c) * * Called with the proc_lock held. */ void proc_free_pid(struct proc *p) { pid_t pid = p->p_pid; struct pid_table *pt; KASSERT(mutex_owned(proc_lock)); pt = &pid_table[pid & pid_tbl_mask]; #ifdef DIAGNOSTIC if (__predict_false(pt->pt_proc != p)) panic("proc_free: pid_table mismatch, pid %x, proc %p", pid, p); #endif /* save pid use count in slot */ pt->pt_proc = P_FREE(pid & ~pid_tbl_mask); if (pt->pt_pgrp == NULL) { /* link last freed entry onto ours */ pid &= pid_tbl_mask; pt = &pid_table[last_free_pt]; pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pid); last_free_pt = pid; pid_alloc_cnt--; } atomic_dec_uint(&nprocs); } void proc_free_mem(struct proc *p) { pool_cache_put(proc_cache, p); } /* * proc_enterpgrp: move p to a new or existing process group (and session). * * If we are creating a new pgrp, the pgid should equal * the calling process' pid. * If is only valid to enter a process group that is in the session * of the process. * Also mksess should only be set if we are creating a process group * * Only called from sys_setsid and sys_setpgid. */ int proc_enterpgrp(struct proc *curp, pid_t pid, pid_t pgid, bool mksess) { struct pgrp *new_pgrp, *pgrp; struct session *sess; struct proc *p; int rval; pid_t pg_id = NO_PGID; sess = mksess ? kmem_alloc(sizeof(*sess), KM_SLEEP) : NULL; /* Allocate data areas we might need before doing any validity checks */ mutex_enter(proc_lock); /* Because pid_table might change */ if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) { mutex_exit(proc_lock); new_pgrp = kmem_alloc(sizeof(*new_pgrp), KM_SLEEP); mutex_enter(proc_lock); } else new_pgrp = NULL; rval = EPERM; /* most common error (to save typing) */ /* Check pgrp exists or can be created */ pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp; if (pgrp != NULL && pgrp->pg_id != pgid) goto done; /* Can only set another process under restricted circumstances. */ if (pid != curp->p_pid) { /* must exist and be one of our children... */ if ((p = p_find(pid, PFIND_LOCKED)) == NULL || !p_inferior(p, curp)) { rval = ESRCH; goto done; } /* ... in the same session... */ if (sess != NULL || p->p_session != curp->p_session) goto done; /* ... existing pgid must be in same session ... */ if (pgrp != NULL && pgrp->pg_session != p->p_session) goto done; /* ... and not done an exec. */ if (p->p_flag & PK_EXEC) { rval = EACCES; goto done; } } else { /* ... setsid() cannot re-enter a pgrp */ if (mksess && (curp->p_pgid == curp->p_pid || pg_find(curp->p_pid, PFIND_LOCKED))) goto done; p = curp; } /* Changing the process group/session of a session leader is definitely off limits. */ if (SESS_LEADER(p)) { if (sess == NULL && p->p_pgrp == pgrp) /* unless it's a definite noop */ rval = 0; goto done; } /* Can only create a process group with id of process */ if (pgrp == NULL && pgid != pid) goto done; /* Can only create a session if creating pgrp */ if (sess != NULL && pgrp != NULL) goto done; /* Check we allocated memory for a pgrp... */ if (pgrp == NULL && new_pgrp == NULL) goto done; /* Don't attach to 'zombie' pgrp */ if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members)) goto done; /* Expect to succeed now */ rval = 0; if (pgrp == p->p_pgrp) /* nothing to do */ goto done; /* Ok all setup, link up required structures */ if (pgrp == NULL) { pgrp = new_pgrp; new_pgrp = NULL; if (sess != NULL) { sess->s_sid = p->p_pid; sess->s_leader = p; sess->s_count = 1; sess->s_ttyvp = NULL; sess->s_ttyp = NULL; sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET; memcpy(sess->s_login, p->p_session->s_login, sizeof(sess->s_login)); p->p_lflag &= ~PL_CONTROLT; } else { sess = p->p_pgrp->pg_session; proc_sesshold(sess); } pgrp->pg_session = sess; sess = NULL; pgrp->pg_id = pgid; LIST_INIT(&pgrp->pg_members); #ifdef DIAGNOSTIC if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp)) panic("enterpgrp: pgrp table slot in use"); if (__predict_false(mksess && p != curp)) panic("enterpgrp: mksession and p != curproc"); #endif pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp; pgrp->pg_jobc = 0; } /* * Adjust eligibility of affected pgrps to participate in job control. * Increment eligibility counts before decrementing, otherwise we * could reach 0 spuriously during the first call. */ fixjobc(p, pgrp, 1); fixjobc(p, p->p_pgrp, 0); /* Interlock with ttread(). */ mutex_spin_enter(&tty_lock); /* Move process to requested group. */ LIST_REMOVE(p, p_pglist); if (LIST_EMPTY(&p->p_pgrp->pg_members)) /* defer delete until we've dumped the lock */ pg_id = p->p_pgrp->pg_id; p->p_pgrp = pgrp; LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist); /* Done with the swap; we can release the tty mutex. */ mutex_spin_exit(&tty_lock); done: if (pg_id != NO_PGID) { /* Releases proc_lock. */ pg_delete(pg_id); } else { mutex_exit(proc_lock); } if (sess != NULL) kmem_free(sess, sizeof(*sess)); if (new_pgrp != NULL) kmem_free(new_pgrp, sizeof(*new_pgrp)); #ifdef DEBUG_PGRP if (__predict_false(rval)) printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n", pid, pgid, mksess, curp->p_pid, rval); #endif return rval; } /* * proc_leavepgrp: remove a process from its process group. * => must be called with the proc_lock held, which will be released; */ void proc_leavepgrp(struct proc *p) { struct pgrp *pgrp; KASSERT(mutex_owned(proc_lock)); /* Interlock with ttread() */ mutex_spin_enter(&tty_lock); pgrp = p->p_pgrp; LIST_REMOVE(p, p_pglist); p->p_pgrp = NULL; mutex_spin_exit(&tty_lock); if (LIST_EMPTY(&pgrp->pg_members)) { /* Releases proc_lock. */ pg_delete(pgrp->pg_id); } else { mutex_exit(proc_lock); } } /* * pg_remove: remove a process group from the table. * => must be called with the proc_lock held; * => returns process group to free; */ static struct pgrp * pg_remove(pid_t pg_id) { struct pgrp *pgrp; struct pid_table *pt; KASSERT(mutex_owned(proc_lock)); pt = &pid_table[pg_id & pid_tbl_mask]; pgrp = pt->pt_pgrp; KASSERT(pgrp != NULL); KASSERT(pgrp->pg_id == pg_id); KASSERT(LIST_EMPTY(&pgrp->pg_members)); pt->pt_pgrp = NULL; if (!P_VALID(pt->pt_proc)) { /* Orphaned pgrp, put slot onto free list. */ KASSERT((P_NEXT(pt->pt_proc) & pid_tbl_mask) == 0); pg_id &= pid_tbl_mask; pt = &pid_table[last_free_pt]; pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pg_id); last_free_pt = pg_id; pid_alloc_cnt--; } return pgrp; } /* * pg_delete: delete and free a process group. * => must be called with the proc_lock held, which will be released. */ static void pg_delete(pid_t pg_id) { struct pgrp *pg; struct tty *ttyp; struct session *ss; KASSERT(mutex_owned(proc_lock)); pg = pid_table[pg_id & pid_tbl_mask].pt_pgrp; if (pg == NULL || pg->pg_id != pg_id || !LIST_EMPTY(&pg->pg_members)) { mutex_exit(proc_lock); return; } ss = pg->pg_session; /* Remove reference (if any) from tty to this process group */ mutex_spin_enter(&tty_lock); ttyp = ss->s_ttyp; if (ttyp != NULL && ttyp->t_pgrp == pg) { ttyp->t_pgrp = NULL; KASSERT(ttyp->t_session == ss); } mutex_spin_exit(&tty_lock); /* * The leading process group in a session is freed by proc_sessrele(), * if last reference. Note: proc_sessrele() releases proc_lock. */ pg = (ss->s_sid != pg->pg_id) ? pg_remove(pg_id) : NULL; proc_sessrele(ss); if (pg != NULL) { /* Free it, if was not done by proc_sessrele(). */ kmem_free(pg, sizeof(struct pgrp)); } } /* * Adjust pgrp jobc counters when specified process changes process group. * We count the number of processes in each process group that "qualify" * the group for terminal job control (those with a parent in a different * process group of the same session). If that count reaches zero, the * process group becomes orphaned. Check both the specified process' * process group and that of its children. * entering == 0 => p is leaving specified group. * entering == 1 => p is entering specified group. * * Call with proc_lock held. */ void fixjobc(struct proc *p, struct pgrp *pgrp, int entering) { struct pgrp *hispgrp; struct session *mysession = pgrp->pg_session; struct proc *child; KASSERT(mutex_owned(proc_lock)); /* * Check p's parent to see whether p qualifies its own process * group; if so, adjust count for p's process group. */ hispgrp = p->p_pptr->p_pgrp; if (hispgrp != pgrp && hispgrp->pg_session == mysession) { if (entering) { pgrp->pg_jobc++; p->p_lflag &= ~PL_ORPHANPG; } else if (--pgrp->pg_jobc == 0) orphanpg(pgrp); } /* * Check this process' children to see whether they qualify * their process groups; if so, adjust counts for children's * process groups. */ LIST_FOREACH(child, &p->p_children, p_sibling) { hispgrp = child->p_pgrp; if (hispgrp != pgrp && hispgrp->pg_session == mysession && !P_ZOMBIE(child)) { if (entering) { child->p_lflag &= ~PL_ORPHANPG; hispgrp->pg_jobc++; } else if (--hispgrp->pg_jobc == 0) orphanpg(hispgrp); } } } /* * A process group has become orphaned; * if there are any stopped processes in the group, * hang-up all process in that group. * * Call with proc_lock held. */ static void orphanpg(struct pgrp *pg) { struct proc *p; KASSERT(mutex_owned(proc_lock)); LIST_FOREACH(p, &pg->pg_members, p_pglist) { if (p->p_stat == SSTOP) { p->p_lflag |= PL_ORPHANPG; psignal(p, SIGHUP); psignal(p, SIGCONT); } } } #ifdef DDB #include void pidtbl_dump(void); void pidtbl_dump(void) { struct pid_table *pt; struct proc *p; struct pgrp *pgrp; int id; db_printf("pid table %p size %x, next %x, last %x\n", pid_table, pid_tbl_mask+1, next_free_pt, last_free_pt); for (pt = pid_table, id = 0; id <= pid_tbl_mask; id++, pt++) { p = pt->pt_proc; if (!P_VALID(p) && !pt->pt_pgrp) continue; db_printf(" id %x: ", id); if (P_VALID(p)) db_printf("proc %p id %d (0x%x) %s\n", p, p->p_pid, p->p_pid, p->p_comm); else db_printf("next %x use %x\n", P_NEXT(p) & pid_tbl_mask, P_NEXT(p) & ~pid_tbl_mask); if ((pgrp = pt->pt_pgrp)) { db_printf("\tsession %p, sid %d, count %d, login %s\n", pgrp->pg_session, pgrp->pg_session->s_sid, pgrp->pg_session->s_count, pgrp->pg_session->s_login); db_printf("\tpgrp %p, pg_id %d, pg_jobc %d, members %p\n", pgrp, pgrp->pg_id, pgrp->pg_jobc, LIST_FIRST(&pgrp->pg_members)); LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { db_printf("\t\tpid %d addr %p pgrp %p %s\n", p->p_pid, p, p->p_pgrp, p->p_comm); } } } } #endif /* DDB */ #ifdef KSTACK_CHECK_MAGIC #include #define KSTACK_MAGIC 0xdeadbeaf /* XXX should be per process basis? */ static int kstackleftmin = KSTACK_SIZE; static int kstackleftthres = KSTACK_SIZE / 8; void kstack_setup_magic(const struct lwp *l) { uint32_t *ip; uint32_t const *end; KASSERT(l != NULL); KASSERT(l != &lwp0); /* * fill all the stack with magic number * so that later modification on it can be detected. */ ip = (uint32_t *)KSTACK_LOWEST_ADDR(l); end = (uint32_t *)((char *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE); for (; ip < end; ip++) { *ip = KSTACK_MAGIC; } } void kstack_check_magic(const struct lwp *l) { uint32_t const *ip, *end; int stackleft; KASSERT(l != NULL); /* don't check proc0 */ /*XXX*/ if (l == &lwp0) return; #ifdef __MACHINE_STACK_GROWS_UP /* stack grows upwards (eg. hppa) */ ip = (uint32_t *)((void *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE); end = (uint32_t *)KSTACK_LOWEST_ADDR(l); for (ip--; ip >= end; ip--) if (*ip != KSTACK_MAGIC) break; stackleft = (void *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE - (void *)ip; #else /* __MACHINE_STACK_GROWS_UP */ /* stack grows downwards (eg. i386) */ ip = (uint32_t *)KSTACK_LOWEST_ADDR(l); end = (uint32_t *)((char *)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE); for (; ip < end; ip++) if (*ip != KSTACK_MAGIC) break; stackleft = ((const char *)ip) - (const char *)KSTACK_LOWEST_ADDR(l); #endif /* __MACHINE_STACK_GROWS_UP */ if (kstackleftmin > stackleft) { kstackleftmin = stackleft; if (stackleft < kstackleftthres) printf("warning: kernel stack left %d bytes" "(pid %u:lid %u)\n", stackleft, (u_int)l->l_proc->p_pid, (u_int)l->l_lid); } if (stackleft <= 0) { panic("magic on the top of kernel stack changed for " "pid %u, lid %u: maybe kernel stack overflow", (u_int)l->l_proc->p_pid, (u_int)l->l_lid); } } #endif /* KSTACK_CHECK_MAGIC */ int proclist_foreach_call(struct proclist *list, int (*callback)(struct proc *, void *arg), void *arg) { struct proc marker; struct proc *p; int ret = 0; marker.p_flag = PK_MARKER; mutex_enter(proc_lock); for (p = LIST_FIRST(list); ret == 0 && p != NULL;) { if (p->p_flag & PK_MARKER) { p = LIST_NEXT(p, p_list); continue; } LIST_INSERT_AFTER(p, &marker, p_list); ret = (*callback)(p, arg); KASSERT(mutex_owned(proc_lock)); p = LIST_NEXT(&marker, p_list); LIST_REMOVE(&marker, p_list); } mutex_exit(proc_lock); return ret; } int proc_vmspace_getref(struct proc *p, struct vmspace **vm) { /* XXXCDC: how should locking work here? */ /* curproc exception is for coredump. */ if ((p != curproc && (p->p_sflag & PS_WEXIT) != 0) || (p->p_vmspace->vm_refcnt < 1)) { /* XXX */ return EFAULT; } uvmspace_addref(p->p_vmspace); *vm = p->p_vmspace; return 0; } /* * Acquire a write lock on the process credential. */ void proc_crmod_enter(void) { struct lwp *l = curlwp; struct proc *p = l->l_proc; struct plimit *lim; kauth_cred_t oc; char *cn; /* Reset what needs to be reset in plimit. */ if (p->p_limit->pl_corename != defcorename) { lim_privatise(p, false); lim = p->p_limit; mutex_enter(&lim->pl_lock); cn = lim->pl_corename; lim->pl_corename = defcorename; mutex_exit(&lim->pl_lock); if (cn != defcorename) free(cn, M_TEMP); } mutex_enter(p->p_lock); /* Ensure the LWP cached credentials are up to date. */ if ((oc = l->l_cred) != p->p_cred) { kauth_cred_hold(p->p_cred); l->l_cred = p->p_cred; kauth_cred_free(oc); } } /* * Set in a new process credential, and drop the write lock. The credential * must have a reference already. Optionally, free a no-longer required * credential. The scheduler also needs to inspect p_cred, so we also * briefly acquire the sched state mutex. */ void proc_crmod_leave(kauth_cred_t scred, kauth_cred_t fcred, bool sugid) { struct lwp *l = curlwp, *l2; struct proc *p = l->l_proc; kauth_cred_t oc; KASSERT(mutex_owned(p->p_lock)); /* Is there a new credential to set in? */ if (scred != NULL) { p->p_cred = scred; LIST_FOREACH(l2, &p->p_lwps, l_sibling) { if (l2 != l) l2->l_prflag |= LPR_CRMOD; } /* Ensure the LWP cached credentials are up to date. */ if ((oc = l->l_cred) != scred) { kauth_cred_hold(scred); l->l_cred = scred; } } else oc = NULL; /* XXXgcc */ if (sugid) { /* * Mark process as having changed credentials, stops * tracing etc. */ p->p_flag |= PK_SUGID; } mutex_exit(p->p_lock); /* If there is a credential to be released, free it now. */ if (fcred != NULL) { KASSERT(scred != NULL); kauth_cred_free(fcred); if (oc != scred) kauth_cred_free(oc); } } /* * proc_specific_key_create -- * Create a key for subsystem proc-specific data. */ int proc_specific_key_create(specificdata_key_t *keyp, specificdata_dtor_t dtor) { return (specificdata_key_create(proc_specificdata_domain, keyp, dtor)); } /* * proc_specific_key_delete -- * Delete a key for subsystem proc-specific data. */ void proc_specific_key_delete(specificdata_key_t key) { specificdata_key_delete(proc_specificdata_domain, key); } /* * proc_initspecific -- * Initialize a proc's specificdata container. */ void proc_initspecific(struct proc *p) { int error; error = specificdata_init(proc_specificdata_domain, &p->p_specdataref); KASSERT(error == 0); } /* * proc_finispecific -- * Finalize a proc's specificdata container. */ void proc_finispecific(struct proc *p) { specificdata_fini(proc_specificdata_domain, &p->p_specdataref); } /* * proc_getspecific -- * Return proc-specific data corresponding to the specified key. */ void * proc_getspecific(struct proc *p, specificdata_key_t key) { return (specificdata_getspecific(proc_specificdata_domain, &p->p_specdataref, key)); } /* * proc_setspecific -- * Set proc-specific data corresponding to the specified key. */ void proc_setspecific(struct proc *p, specificdata_key_t key, void *data) { specificdata_setspecific(proc_specificdata_domain, &p->p_specdataref, key, data); } int proc_uidmatch(kauth_cred_t cred, kauth_cred_t target) { int r = 0; if (kauth_cred_getuid(cred) != kauth_cred_getuid(target) || kauth_cred_getuid(cred) != kauth_cred_getsvuid(target)) { /* * suid proc of ours or proc not ours */ r = EPERM; } else if (kauth_cred_getgid(target) != kauth_cred_getsvgid(target)) { /* * sgid proc has sgid back to us temporarily */ r = EPERM; } else { /* * our rgid must be in target's group list (ie, * sub-processes started by a sgid process) */ int ismember = 0; if (kauth_cred_ismember_gid(cred, kauth_cred_getgid(target), &ismember) != 0 || !ismember) r = EPERM; } return (r); }