Index: sys/arm/arm/pmap-v6.c =================================================================== --- sys/arm/arm/pmap-v6.c +++ sys/arm/arm/pmap-v6.c @@ -6577,7 +6577,7 @@ int npte2 = 0; int i, j, index; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { if (p->p_pid != pid || p->p_vmspace == NULL) continue; @@ -6605,7 +6605,7 @@ index = 0; printf("\n"); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (npte2); } pte2p = pmap_pte2(pmap, va); @@ -6632,7 +6632,7 @@ } } } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (npte2); } Index: sys/cddl/contrib/opensolaris/uts/intel/dtrace/fasttrap_isa.c =================================================================== --- sys/cddl/contrib/opensolaris/uts/intel/dtrace/fasttrap_isa.c +++ sys/cddl/contrib/opensolaris/uts/intel/dtrace/fasttrap_isa.c @@ -1022,11 +1022,11 @@ mutex_enter(pid_mtx); #else pp = p; - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); while (pp->p_vmspace == pp->p_pptr->p_vmspace) pp = pp->p_pptr; pid = pp->p_pid; - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); pp = NULL; rm_rlock(&fasttrap_tp_lock, &tracker); Index: sys/compat/linprocfs/linprocfs.c =================================================================== --- sys/compat/linprocfs/linprocfs.c +++ sys/compat/linprocfs/linprocfs.c @@ -619,8 +619,8 @@ (int)(averunnable.ldavg[2] / averunnable.fscale), (int)(averunnable.ldavg[2] * 100 / averunnable.fscale % 100), 1, /* number of running tasks */ - nprocs, /* number of tasks */ - lastpid /* the last pid */ + V_nprocs, /* number of tasks */ + V_lastpid /* the last pid */ ); return (0); } @@ -638,10 +638,10 @@ vm_offset_t startcode, startdata; getboottime(&boottime); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); PROC_LOCK(p); fill_kinfo_proc(p, &kp); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); if (p->p_vmspace) { startcode = (vm_offset_t)p->p_vmspace->vm_taddr; startdata = (vm_offset_t)p->p_vmspace->vm_daddr; @@ -717,11 +717,11 @@ struct kinfo_proc kp; segsz_t lsize; - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); PROC_LOCK(p); fill_kinfo_proc(p, &kp); PROC_UNLOCK(p); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); /* * See comments in linprocfs_doprocstatus() regarding the @@ -755,7 +755,7 @@ l_sigset_t siglist, sigignore, sigcatch; int i; - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); PROC_LOCK(p); td2 = FIRST_THREAD_IN_PROC(p); /* XXXKSE pretend only one thread */ @@ -794,7 +794,7 @@ } fill_kinfo_proc(p, &kp); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); sbuf_printf(sb, "Name:\t%s\n", p->p_comm); /* XXX escape */ sbuf_printf(sb, "State:\t%s\n", state); Index: sys/compat/linux/linux_file.c =================================================================== --- sys/compat/linux/linux_file.c +++ sys/compat/linux/linux_file.c @@ -148,17 +148,17 @@ fdrop(fp, td); goto done; } - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); PROC_LOCK(p); if (SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) { PROC_UNLOCK(p); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); /* XXXPJD: Verify if TIOCSCTTY is allowed. */ (void) fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td->td_ucred, td); } else { PROC_UNLOCK(p); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); } fdrop(fp, td); } Index: sys/compat/linux/linux_fork.c =================================================================== --- sys/compat/linux/linux_fork.c +++ sys/compat/linux/linux_fork.c @@ -230,11 +230,11 @@ * the same as that of the calling process. */ if (args->flags & LINUX_CLONE_PARENT) { - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); PROC_LOCK(p2); proc_reparent(p2, td->td_proc->p_pptr); PROC_UNLOCK(p2); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); } #ifdef DEBUG Index: sys/compat/linux/linux_misc.c =================================================================== --- sys/compat/linux/linux_misc.c +++ sys/compat/linux/linux_misc.c @@ -181,7 +181,7 @@ sysinfo.totalswap = i * PAGE_SIZE; sysinfo.freeswap = (i - j) * PAGE_SIZE; - sysinfo.procs = nprocs; + sysinfo.procs = V_nprocs; /* The following are only present in newer Linux kernels. */ sysinfo.totalbig = 0; Index: sys/compat/linuxkpi/common/src/linux_current.c =================================================================== --- sys/compat/linuxkpi/common/src/linux_current.c +++ sys/compat/linuxkpi/common/src/linux_current.c @@ -230,7 +230,7 @@ struct task_struct *ts; struct thread *td; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); FOREACH_THREAD_IN_PROC(p, td) { @@ -241,7 +241,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); EVENTHANDLER_DEREGISTER(thread_dtor, linuxkpi_thread_dtor_tag); } Index: sys/ddb/db_command.c =================================================================== --- sys/ddb/db_command.c +++ sys/ddb/db_command.c @@ -693,11 +693,11 @@ * Find the process in question. allproc_lock is not needed * since we're in DDB. */ - /* sx_slock(&allproc_lock); */ + /* sx_slock(&V_allproc_lock); */ FOREACH_PROC_IN_SYSTEM(p) if (p->p_pid == pid) break; - /* sx_sunlock(&allproc_lock); */ + /* sx_sunlock(&V_allproc_lock); */ if (p == NULL) DB_ERROR(("Can't find process with pid %ld\n", (long) pid)); Index: sys/ddb/db_ps.c =================================================================== --- sys/ddb/db_ps.c +++ sys/ddb/db_ps.c @@ -46,6 +46,7 @@ #include #include #include +#include #include @@ -89,10 +90,10 @@ char state[9]; int np, rflag, sflag, dflag, lflag, wflag; - np = nprocs; + np = V_nprocs; - if (!LIST_EMPTY(&allproc)) - p = LIST_FIRST(&allproc); + if (!LIST_EMPTY(&V_allproc)) + p = LIST_FIRST(&V_allproc); else p = &proc0; @@ -216,8 +217,9 @@ p = LIST_NEXT(p, p_list); if (p == NULL && np > 0) - p = LIST_FIRST(&zombproc); + p = LIST_FIRST(&V_zombproc); } + db_printf("nprocs = %d, np = %d\n", V_nprocs, np); } static void Index: sys/ddb/db_thread.c =================================================================== --- sys/ddb/db_thread.c +++ sys/ddb/db_thread.c @@ -139,7 +139,7 @@ if (p->p_pid == decaddr) return (FIRST_THREAD_IN_PROC(p)); } - LIST_FOREACH(p, &zombproc, p_list) { + LIST_FOREACH(p, &V_zombproc, p_list) { if (p->p_pid == decaddr) return (FIRST_THREAD_IN_PROC(p)); } @@ -165,7 +165,7 @@ if (p->p_pid == decaddr) return (p); } - LIST_FOREACH(p, &zombproc, p_list) { + LIST_FOREACH(p, &V_zombproc, p_list) { if (p->p_pid == decaddr) return (p); } Index: sys/dev/filemon/filemon.c =================================================================== --- sys/dev/filemon/filemon.c +++ sys/dev/filemon/filemon.c @@ -223,7 +223,7 @@ * filemon_event_process_exit() will lock on filemon->lock * which we hold. */ - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { /* * No PROC_LOCK is needed to compare here since it is @@ -234,7 +234,7 @@ if (p->p_filemon == filemon) filemon_proc_drop(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); /* * It's possible some references were acquired but will be Index: sys/dev/hwpmc/hwpmc_mod.c =================================================================== --- sys/dev/hwpmc/hwpmc_mod.c +++ sys/dev/hwpmc/hwpmc_mod.c @@ -1176,7 +1176,7 @@ * this PMC. */ - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); top = p; @@ -1200,7 +1200,7 @@ (void) pmc_detach_process(top, pm); done: - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return error; } @@ -1285,7 +1285,7 @@ * partially attached proc tree. */ - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); top = p; @@ -1306,7 +1306,7 @@ } done: - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); if (LIST_EMPTY(&pm->pm_targets)) pm->pm_flags &= ~PMC_F_ATTACH_DONE; @@ -1985,7 +1985,7 @@ PROC_UNLOCK(p); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); top = p; @@ -2004,7 +2004,7 @@ } } done: - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); } /* Index: sys/fs/devfs/devfs_vnops.c =================================================================== --- sys/fs/devfs/devfs_vnops.c +++ sys/fs/devfs/devfs_vnops.c @@ -596,7 +596,7 @@ if (vp == p->p_session->s_ttyvp) { PROC_UNLOCK(p); oldvp = NULL; - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); if (vp == p->p_session->s_ttyvp) { SESS_LOCK(p->p_session); VI_LOCK(vp); @@ -609,7 +609,7 @@ VI_UNLOCK(vp); SESS_UNLOCK(p->p_session); } - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); if (oldvp != NULL) vrele(oldvp); } else @@ -813,9 +813,9 @@ if (error == 0 && com == TIOCSCTTY) { /* Do nothing if reassigning same control tty */ - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (td->td_proc->p_session->s_ttyvp == vp) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (0); } @@ -826,7 +826,7 @@ td->td_proc->p_session->s_ttydp = cdev2priv(dev); SESS_UNLOCK(td->td_proc->p_session); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); /* Get rid of reference to old control tty */ if (vpold) Index: sys/fs/nfs/nfsport.h =================================================================== --- sys/fs/nfs/nfsport.h +++ sys/fs/nfs/nfsport.h @@ -692,8 +692,8 @@ #define NFSUNLOCKMNT(m) mtx_unlock(&((m)->nm_mtx)) #define NFSLOCKREQUEST(r) mtx_lock(&((r)->r_mtx)) #define NFSUNLOCKREQUEST(r) mtx_unlock(&((r)->r_mtx)) -#define NFSPROCLISTLOCK() sx_slock(&allproc_lock) -#define NFSPROCLISTUNLOCK() sx_sunlock(&allproc_lock) +#define NFSPROCLISTLOCK() sx_slock(&V_allproc_lock) +#define NFSPROCLISTUNLOCK() sx_sunlock(&V_allproc_lock) #define NFSLOCKSOCKREQ(r) mtx_lock(&((r)->nr_mtx)) #define NFSUNLOCKSOCKREQ(r) mtx_unlock(&((r)->nr_mtx)) #define NFSLOCKDS(d) mtx_lock(&((d)->nfsclds_mtx)) Index: sys/fs/pseudofs/pseudofs_vnops.c =================================================================== --- sys/fs/pseudofs/pseudofs_vnops.c +++ sys/fs/pseudofs/pseudofs_vnops.c @@ -705,7 +705,7 @@ { int visible; - sx_assert(&allproc_lock, SX_SLOCKED); + sx_assert(&V_allproc_lock, SX_SLOCKED); pfs_assert_owned(pd); again: if (*pn == NULL) { @@ -718,7 +718,7 @@ if (*pn != NULL && (*pn)->pn_type == pfstype_procdir) { /* next process */ if (*p == NULL) - *p = LIST_FIRST(&allproc); + *p = LIST_FIRST(&V_allproc); else *p = LIST_NEXT(*p, p_list); /* out of processes: next node */ @@ -791,12 +791,12 @@ if (resid == 0) PFS_RETURN (0); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); pfs_lock(pd); /* check if the directory is visible to the caller */ if (!pfs_visible(curthread, pd, pid, true, &proc)) { - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); pfs_unlock(pd); PFS_RETURN (ENOENT); } @@ -810,7 +810,7 @@ if (proc != NULL) PROC_UNLOCK(proc); pfs_unlock(pd); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); PFS_RETURN (0); } } @@ -860,7 +860,7 @@ if (proc != NULL) PROC_UNLOCK(proc); pfs_unlock(pd); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); i = 0; STAILQ_FOREACH_SAFE(pfsent, &lst, link, pfsent2) { if (error == 0) Index: sys/i386/i386/pmap.c =================================================================== --- sys/i386/i386/pmap.c +++ sys/i386/i386/pmap.c @@ -5652,7 +5652,7 @@ int npte = 0; int index; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { if (p->p_pid != pid) continue; @@ -5675,7 +5675,7 @@ index = 0; printf("\n"); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (npte); } pte = pmap_pte(pmap, va); @@ -5700,7 +5700,7 @@ } } } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (npte); } #endif Index: sys/i386/ibcs2/ibcs2_sysvec.c =================================================================== --- sys/i386/ibcs2/ibcs2_sysvec.c +++ sys/i386/ibcs2/ibcs2_sysvec.c @@ -117,14 +117,14 @@ break; case MOD_UNLOAD: /* if this was an ELF module we'd use elf_brand_inuse()... */ - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { if (p->p_sysent == &ibcs2_svr3_sysvec) { rval = EBUSY; break; } } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); break; default: rval = EOPNOTSUPP; Index: sys/kern/imgact_elf.c =================================================================== --- sys/kern/imgact_elf.c +++ sys/kern/imgact_elf.c @@ -241,14 +241,14 @@ struct proc *p; int rval = FALSE; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { if (p->p_sysent == entry->sysvec) { rval = TRUE; break; } } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (rval); } @@ -2107,10 +2107,10 @@ KASSERT(*sizep == size, ("invalid size")); structsize = sizeof(elf_kinfo_proc_t); sbuf_bcat(sb, &structsize, sizeof(structsize)); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); PROC_LOCK(p); kern_proc_out(p, sb, ELF_KERN_PROC_MASK); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); } *sizep = size; } Index: sys/kern/init_main.c =================================================================== --- sys/kern/init_main.c +++ sys/kern/init_main.c @@ -103,7 +103,9 @@ struct proc proc0; struct thread0_storage thread0_st __aligned(32); struct vmspace vmspace0; -struct proc *initproc; +VPS_DEFINE(struct proc *, initproc); + +VPS_DEFINE(struct proc *, vproc0); #ifndef BOOTHOWTO #define BOOTHOWTO 0 @@ -449,9 +451,8 @@ p->p_osrel = osreldate; /* - * Initialize thread and process structures. + * Initialize thread structures. */ - procinit(); /* set up proc zone */ threadinit(); /* set up UMA zones */ /* @@ -463,7 +464,8 @@ /* * Create process 0 (the swapper). */ - LIST_INSERT_HEAD(&allproc, p, p_list); + V_vproc0 = p; + LIST_INSERT_HEAD(&V_allproc, p, p_list); LIST_INSERT_HEAD(PIDHASH(0), p, p_hash); mtx_init(&pgrp0.pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK); p->p_pgrp = &pgrp0; @@ -536,7 +538,7 @@ p->p_sigacts = sigacts_alloc(); /* Initialize signal state for process 0. */ - siginit(&proc0); + siginit(V_vproc0); /* Create the file descriptor table. */ p->p_fd = fdinit(NULL, false); @@ -616,7 +618,7 @@ * Now we can look at the time, having had a chance to verify the * time from the filesystem. Pretend that proc0 started now. */ - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { microuptime(&p->p_stats->p_start); PROC_STATLOCK(p); @@ -630,7 +632,7 @@ td->td_runtime = 0; } } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); PCPU_SET(switchtime, cpu_ticks()); PCPU_SET(switchticks, ticks); @@ -822,19 +824,19 @@ bzero(&fr, sizeof(fr)); fr.fr_flags = RFFDG | RFPROC | RFSTOPPED; - fr.fr_procp = &initproc; + fr.fr_procp = &V_initproc; error = fork1(&thread0, &fr); if (error) panic("cannot fork init: %d\n", error); - KASSERT(initproc->p_pid == 1, ("create_init: initproc->p_pid != 1")); + KASSERT(V_initproc->p_pid == 1, ("create_init: initproc->p_pid != 1")); /* divorce init's credentials from the kernel's */ newcred = crget(); - sx_xlock(&proctree_lock); - PROC_LOCK(initproc); - initproc->p_flag |= P_SYSTEM | P_INMEM; - initproc->p_treeflag |= P_TREE_REAPER; - LIST_INSERT_HEAD(&initproc->p_reaplist, &proc0, p_reapsibling); - oldcred = initproc->p_ucred; + sx_xlock(&V_proctree_lock); + PROC_LOCK(V_initproc); + V_initproc->p_flag |= P_SYSTEM | P_INMEM; + V_initproc->p_treeflag |= P_TREE_REAPER; + LIST_INSERT_HEAD(&V_initproc->p_reaplist, V_vproc0, p_reapsibling); + oldcred = V_initproc->p_ucred; crcopy(newcred, oldcred); #ifdef MAC mac_cred_create_init(newcred); @@ -842,14 +844,14 @@ #ifdef AUDIT audit_cred_proc1(newcred); #endif - proc_set_cred(initproc, newcred); - td = FIRST_THREAD_IN_PROC(initproc); + proc_set_cred(V_initproc, newcred); + td = FIRST_THREAD_IN_PROC(V_initproc); crfree(td->td_ucred); - td->td_ucred = crhold(initproc->p_ucred); - PROC_UNLOCK(initproc); - sx_xunlock(&proctree_lock); + td->td_ucred = crhold(V_initproc->p_ucred); + PROC_UNLOCK(V_initproc); + sx_xunlock(&V_proctree_lock); crfree(oldcred); - cpu_fork_kthread_handler(FIRST_THREAD_IN_PROC(initproc), + cpu_fork_kthread_handler(FIRST_THREAD_IN_PROC(V_initproc), start_init, NULL); } SYSINIT(init, SI_SUB_CREATE_INIT, SI_ORDER_FIRST, create_init, NULL); @@ -862,7 +864,7 @@ { struct thread *td; - td = FIRST_THREAD_IN_PROC(initproc); + td = FIRST_THREAD_IN_PROC(V_initproc); thread_lock(td); TD_SET_CAN_RUN(td); sched_add(td, SRQ_BORING); Index: sys/kern/kern_acct.c =================================================================== --- sys/kern/kern_acct.c +++ sys/kern/kern_acct.c @@ -378,7 +378,7 @@ * Get process accounting information. */ - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); PROC_LOCK(p); /* (1) The terminal from which the process was started */ @@ -386,7 +386,7 @@ acct.ac_tty = tty_udev(p->p_pgrp->pg_session->s_ttyp); else acct.ac_tty = NODEV; - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); /* (2) The name of the command that ran */ bcopy(p->p_comm, acct.ac_comm, sizeof acct.ac_comm); Index: sys/kern/kern_clock.c =================================================================== --- sys/kern/kern_clock.c +++ sys/kern/kern_clock.c @@ -202,7 +202,7 @@ * priority inversion problem leading to starvation. * If the lock can't be held after 100 tries, panic. */ - if (!sx_try_slock(&allproc_lock)) { + if (!sx_try_slock(&V_allproc_lock)) { if (tryl > 100) panic("%s: possible deadlock detected on allproc_lock\n", __func__); @@ -240,7 +240,7 @@ * turnstile. */ PROC_UNLOCK(p); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); panic("%s: possible deadlock detected for %p, blocked for %d ticks\n", __func__, td, tticks); } @@ -286,7 +286,7 @@ continue; } PROC_UNLOCK(p); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); panic("%s: possible deadlock detected for %p, blocked for %d ticks\n", __func__, td, tticks); } @@ -295,7 +295,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); /* Sleep for sleepfreq seconds. */ pause("-", sleepfreq * hz); Index: sys/kern/kern_cpuset.c =================================================================== --- sys/kern/kern_cpuset.c +++ sys/kern/kern_cpuset.c @@ -513,7 +513,7 @@ struct thread *td; struct proc *p; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NEW) { @@ -527,7 +527,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); kernel_object->domain.dr_policy = cpuset_kernel->cs_domain; } Index: sys/kern/kern_descrip.c =================================================================== --- sys/kern/kern_descrip.c +++ sys/kern/kern_descrip.c @@ -1063,7 +1063,7 @@ sigio->sio_ucred = crhold(curthread->td_ucred); sigio->sio_myref = sigiop; - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (pgid > 0) { proc = pfind(pgid); if (proc == NULL) { @@ -1131,14 +1131,14 @@ sigio->sio_pgrp = pgrp; PGRP_UNLOCK(pgrp); } - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); SIGIO_LOCK(); *sigiop = sigio; SIGIO_UNLOCK(); return (0); fail: - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); crfree(sigio->sio_ucred); free(sigio, M_SIGIO); return (ret); @@ -3199,7 +3199,7 @@ if (vrefcnt(olddp) == 1) return; nrele = 0; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); fdp = fdhold(p); @@ -3225,7 +3225,7 @@ FILEDESC_XUNLOCK(fdp); fddrop(fdp); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (rootvnode == olddp) { vrefact(newdp); rootvnode = newdp; @@ -3319,7 +3319,7 @@ return (error); if (req->oldptr == NULL) { n = 0; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NEW) { @@ -3335,13 +3335,13 @@ n += fdp->fd_lastfile; fddrop(fdp); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (SYSCTL_OUT(req, 0, n * sizeof(xf))); } error = 0; bzero(&xf, sizeof(xf)); xf.xf_size = sizeof(xf); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NEW) { @@ -3380,7 +3380,7 @@ if (error) break; } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } Index: sys/kern/kern_exit.c =================================================================== --- sys/kern/kern_exit.c +++ sys/kern/kern_exit.c @@ -106,13 +106,13 @@ { struct proc *p, *parent; - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); if ((child->p_treeflag & P_TREE_ORPHANED) == 0) { if (child->p_oppid == 0 || child->p_pptr->p_pid == child->p_oppid) parent = child->p_pptr; else - parent = initproc; + parent = V_initproc; return (parent); } for (p = child; (p->p_treeflag & P_TREE_FIRST_ORPHAN) == 0;) { @@ -132,8 +132,8 @@ { struct proc *p1, *p2, *ptmp; - sx_assert(&proctree_lock, SX_LOCKED); - KASSERT(p != initproc, ("reaper_abandon_children for initproc")); + sx_assert(&V_proctree_lock, SX_LOCKED); + KASSERT(p != V_initproc, ("reaper_abandon_children for initproc")); if ((p->p_treeflag & P_TREE_REAPER) == 0) return; p1 = p->p_reaper; @@ -157,7 +157,7 @@ { struct proc *p1; - sx_assert(&proctree_lock, SA_XLOCKED); + sx_assert(&V_proctree_lock, SA_XLOCKED); if ((p->p_treeflag & P_TREE_ORPHANED) == 0) return; if ((p->p_treeflag & P_TREE_FIRST_ORPHAN) != 0) { @@ -203,7 +203,7 @@ * work around an unsolved stack overflow seen very late during * shutdown on sparc64 when the gmirror worker process exists. */ - if (p == initproc && rebooting == 0) { + if (p == V_initproc && rebooting == 0) { printf("init died (signal %d, exit %d)\n", signo, rval); panic("Going nowhere without my init!"); } @@ -313,7 +313,7 @@ /* Are we a task leader with peers? */ if (p->p_peers != NULL && p == p->p_leader) { - mtx_lock(&ppeers_lock); + mtx_lock(&V_ppeers_lock); q = p->p_peers; while (q != NULL) { PROC_LOCK(q); @@ -322,8 +322,8 @@ q = q->p_peers; } while (p->p_peers != NULL) - msleep(p, &ppeers_lock, PWAIT, "exit1", 0); - mtx_unlock(&ppeers_lock); + msleep(p, &V_ppeers_lock, PWAIT, "exit1", 0); + mtx_unlock(&V_ppeers_lock); } /* @@ -388,7 +388,7 @@ * Remove ourself from our leader's peer list and wake our leader. */ if (p->p_leader->p_peers != NULL) { - mtx_lock(&ppeers_lock); + mtx_lock(&V_ppeers_lock); if (p->p_leader->p_peers != NULL) { q = p->p_leader; while (q->p_peers != p) @@ -396,7 +396,7 @@ q->p_peers = p->p_peers; wakeup(p->p_leader); } - mtx_unlock(&ppeers_lock); + mtx_unlock(&V_ppeers_lock); } vmspace_exit(td); @@ -432,16 +432,16 @@ WITNESS_WARN(WARN_PANIC, NULL, "process (pid %d) exiting", p->p_pid); - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); /* * Remove proc from allproc queue and pidhash chain. * Place onto zombproc. Unlink from parent's child list. */ - sx_xlock(&allproc_lock); + sx_xlock(&V_allproc_lock); LIST_REMOVE(p, p_list); - LIST_INSERT_HEAD(&zombproc, p, p_list); + LIST_INSERT_HEAD(&V_zombproc, p, p_list); LIST_REMOVE(p, p_hash); - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); /* * Reparent all children processes: @@ -602,7 +602,7 @@ } else mtx_unlock(&p->p_pptr->p_sigacts->ps_mtx); - if (p->p_pptr == p->p_reaper || p->p_pptr == initproc) { + if (p->p_pptr == p->p_reaper || p->p_pptr == V_initproc) { signal_parent = 1; } else if (p->p_sigparent != 0) { if (p->p_sigparent == SIGCHLD) { @@ -613,7 +613,7 @@ } } else PROC_LOCK(p->p_pptr); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); if (signal_parent == 1) { childproc_exited(p); @@ -827,7 +827,7 @@ { struct proc *q, *t; - sx_assert(&proctree_lock, SA_XLOCKED); + sx_assert(&V_proctree_lock, SA_XLOCKED); PROC_LOCK_ASSERT(p, MA_OWNED); KASSERT(p->p_state == PRS_ZOMBIE, ("proc_reap: !PRS_ZOMBIE")); @@ -843,7 +843,7 @@ * release the proc struct just yet. */ PROC_UNLOCK(p); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return; } @@ -870,7 +870,7 @@ wakeup(t); cv_broadcast(&p->p_pwait); PROC_UNLOCK(t); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return; } p->p_oppid = 0; @@ -880,9 +880,9 @@ * Remove other references to this process to ensure we have an * exclusive reference. */ - sx_xlock(&allproc_lock); + sx_xlock(&V_allproc_lock); LIST_REMOVE(p, p_list); /* off zombproc */ - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); LIST_REMOVE(p, p_sibling); reaper_abandon_children(p, true); LIST_REMOVE(p, p_reapsibling); @@ -892,7 +892,7 @@ leavepgrp(p); if (p->p_procdesc != NULL) procdesc_reap(p); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); PROC_LOCK(p); knlist_detach(p->p_klist); @@ -955,7 +955,7 @@ KASSERT(FIRST_THREAD_IN_PROC(p), ("proc_reap: no residual thread!")); uma_zfree(proc_zone, p); - atomic_add_int(&nprocs, -1); + atomic_add_int(&V_nprocs, -1); } static int @@ -965,7 +965,7 @@ { struct rusage *rup; - sx_assert(&proctree_lock, SA_XLOCKED); + sx_assert(&V_proctree_lock, SA_XLOCKED); PROC_LOCK(p); @@ -1156,7 +1156,7 @@ bool cont; PROC_LOCK_ASSERT(p, MA_OWNED); - sx_assert(&proctree_lock, SA_XLOCKED); + sx_assert(&V_proctree_lock, SA_XLOCKED); MPASS(si_code == CLD_TRAPPED || si_code == CLD_STOPPED || si_code == CLD_CONTINUED); @@ -1170,7 +1170,7 @@ sigqueue_take(p->p_ksi); PROC_UNLOCK(td->td_proc); } - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); if (siginfo != NULL) { siginfo->si_code = si_code; siginfo->si_status = cont ? SIGCONT : p->p_xsig; @@ -1223,7 +1223,7 @@ q->p_flag &= ~P_STATCHILD; PROC_UNLOCK(q); } - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); loop_locked: nfound = 0; LIST_FOREACH(p, &q->p_children, p_sibling) { @@ -1307,11 +1307,11 @@ } } if (nfound == 0) { - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return (ECHILD); } if (options & WNOHANG) { - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); td->td_retval[0] = 0; return (0); } @@ -1321,7 +1321,7 @@ PROC_UNLOCK(q); goto loop_locked; } - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); error = msleep(q, &q->p_mtx, PWAIT | PCATCH | PDROP, "wait", 0); if (error) return (error); @@ -1336,7 +1336,7 @@ proc_reparent(struct proc *child, struct proc *parent) { - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); PROC_LOCK_ASSERT(child, MA_OWNED); if (child->p_pptr == parent) return; Index: sys/kern/kern_fork.c =================================================================== --- sys/kern/kern_fork.c +++ sys/kern/kern_fork.c @@ -74,6 +74,7 @@ #include #include #include +#include #include #include @@ -184,10 +185,10 @@ return (error); } -int nprocs = 1; /* process 0 */ -int lastpid = 0; -SYSCTL_INT(_kern, OID_AUTO, lastpid, CTLFLAG_RD, &lastpid, 0, - "Last used PID"); +VPS_DEFINE(int, nprocs) = 1; /* process 0 */ +VPS_DEFINE(int, lastpid) = 0; +SYSCTL_INT(_kern, OID_AUTO, lastpid, CTLFLAG_RD|CTLFLAG_VPS, + &VPS_NAME(lastpid), 0, "Last used PID"); /* * Random component to lastpid generation. We mix in a random factor to make @@ -197,7 +198,8 @@ * modulus that is too big causes a LOT more process table scans and slows * down fork processing as the pidchecked caching is defeated. */ -static int randompid = 0; +static VPS_DEFINE(int, randompid) = 0; +#define V_randompid VPS(randompid) static int sysctl_kern_randompid(SYSCTL_HANDLER_ARGS) @@ -207,44 +209,46 @@ error = sysctl_wire_old_buffer(req, sizeof(int)); if (error != 0) return(error); - sx_xlock(&allproc_lock); - pid = randompid; + sx_xlock(&V_allproc_lock); + pid = V_randompid; error = sysctl_handle_int(oidp, &pid, 0, req); if (error == 0 && req->newptr != NULL) { if (pid == 0) - randompid = 0; + V_randompid = 0; else if (pid == 1) /* generate a random PID modulus between 100 and 1123 */ - randompid = 100 + arc4random() % 1024; + V_randompid = 100 + arc4random() % 1024; else if (pid < 0 || pid > pid_max - 100) /* out of range */ - randompid = pid_max - 100; + V_randompid = pid_max - 100; else if (pid < 100) /* Make it reasonable */ - randompid = 100; + V_randompid = 100; else - randompid = pid; + V_randompid = pid; } - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); return (error); } SYSCTL_PROC(_kern, OID_AUTO, randompid, CTLTYPE_INT|CTLFLAG_RW, 0, 0, sysctl_kern_randompid, "I", "Random PID modulus. Special values: 0: disable, 1: choose random value"); +static VPS_DEFINE(int, pidchecked) = 0; +#define V_pidchecked VPS(pidchecked) + static int fork_findpid(int flags) { struct proc *p; int trypid; - static int pidchecked = 0; /* * Requires allproc_lock in order to iterate over the list * of processes, and proctree_lock to access p_pgrp. */ - sx_assert(&allproc_lock, SX_LOCKED); - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_allproc_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); /* * Find an unused process ID. We remember a range of unused IDs @@ -253,13 +257,13 @@ * If RFHIGHPID is set (used during system boot), do not allocate * low-numbered pids. */ - trypid = lastpid + 1; + trypid = V_lastpid + 1; if (flags & RFHIGHPID) { if (trypid < 10) trypid = 10; } else { - if (randompid) - trypid += arc4random() % randompid; + if (V_randompid) + trypid += arc4random() % V_randompid; } retry: /* @@ -271,12 +275,12 @@ trypid = trypid % pid_max; if (trypid < 100) trypid += 100; - pidchecked = 0; + V_pidchecked = 0; } - if (trypid >= pidchecked) { + if (trypid >= V_pidchecked) { int doingzomb = 0; - pidchecked = PID_MAX; + V_pidchecked = PID_MAX; /* * Scan the active and zombie procs to check whether this pid * is in use. Remember the lowest pid that's greater @@ -291,7 +295,7 @@ * reserved pids is limited by process limit times * two. */ - p = LIST_FIRST(&allproc); + p = LIST_FIRST(&V_allproc); again: for (; p != NULL; p = LIST_NEXT(p, p_list)) { while (p->p_pid == trypid || @@ -301,24 +305,24 @@ (p->p_session != NULL && p->p_session->s_sid == trypid)))) { trypid++; - if (trypid >= pidchecked) + if (trypid >= V_pidchecked) goto retry; } - if (p->p_pid > trypid && pidchecked > p->p_pid) - pidchecked = p->p_pid; + if (p->p_pid > trypid && V_pidchecked > p->p_pid) + V_pidchecked = p->p_pid; if (p->p_pgrp != NULL) { if (p->p_pgrp->pg_id > trypid && - pidchecked > p->p_pgrp->pg_id) - pidchecked = p->p_pgrp->pg_id; + V_pidchecked > p->p_pgrp->pg_id) + V_pidchecked = p->p_pgrp->pg_id; if (p->p_session != NULL && p->p_session->s_sid > trypid && - pidchecked > p->p_session->s_sid) - pidchecked = p->p_session->s_sid; + V_pidchecked > p->p_session->s_sid) + V_pidchecked = p->p_session->s_sid; } } if (!doingzomb) { doingzomb = 1; - p = LIST_FIRST(&zombproc); + p = LIST_FIRST(&V_zombproc); goto again; } } @@ -327,9 +331,9 @@ * RFHIGHPID does not mess with the lastpid counter during boot. */ if (flags & RFHIGHPID) - pidchecked = 0; + V_pidchecked = 0; else - lastpid = trypid; + V_lastpid = trypid; return (trypid); } @@ -394,8 +398,8 @@ struct filedesc_to_leader *fdtol; struct sigacts *newsigacts; - sx_assert(&proctree_lock, SX_LOCKED); - sx_assert(&allproc_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); + sx_assert(&V_allproc_lock, SX_XLOCKED); p1 = td->td_proc; @@ -404,14 +408,14 @@ p2->p_state = PRS_NEW; /* protect against others */ p2->p_pid = trypid; AUDIT_ARG_PID(p2->p_pid); - LIST_INSERT_HEAD(&allproc, p2, p_list); + LIST_INSERT_HEAD(&V_allproc, p2, p_list); allproc_gen++; LIST_INSERT_HEAD(PIDHASH(p2->p_pid), p2, p_hash); PROC_LOCK(p2); PROC_LOCK(p1); - sx_xunlock(&allproc_lock); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_allproc_lock); + sx_xunlock(&V_proctree_lock); bcopy(&p1->p_startcopy, &p2->p_startcopy, __rangeof(struct proc, p_startcopy, p_endcopy)); @@ -554,11 +558,11 @@ * Set up linkage for kernel based threading. */ if ((fr->fr_flags & RFTHREAD) != 0) { - mtx_lock(&ppeers_lock); + mtx_lock(&V_ppeers_lock); p2->p_peers = p1->p_peers; p1->p_peers = p2; p2->p_leader = p1->p_leader; - mtx_unlock(&ppeers_lock); + mtx_unlock(&V_ppeers_lock); PROC_LOCK(p1->p_leader); if ((p1->p_leader->p_flag & P_WEXIT) != 0) { PROC_UNLOCK(p1->p_leader); @@ -585,7 +589,7 @@ p2->p_leader = p2; } - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); PGRP_LOCK(p1->p_pgrp); PROC_LOCK(p2); PROC_LOCK(p1); @@ -648,7 +652,7 @@ LIST_INSERT_HEAD(&p2->p_reaper->p_reaplist, p2, p_reapsibling); if (p2->p_reaper == p1) p2->p_reapsubtree = p2->p_pid; - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); /* Inform accounting that we have forked. */ p2->p_acflag = AFORK; @@ -783,6 +787,11 @@ PROC_UNLOCK(p2); } +static VPS_DEFINE(int, curfail); +#define V_curfail VPS(curfail) +static VPS_DEFINE(struct timeval, lastfail); +#define V_lastfail VPS(lastfail) + int fork1(struct thread *td, struct fork_req *fr) { @@ -792,8 +801,6 @@ struct file *fp_procdesc; vm_ooffset_t mem_charged; int error, nprocs_new, ok; - static int curfail; - static struct timeval lastfail; int flags, pages; flags = fr->fr_flags; @@ -863,17 +870,17 @@ * Don't allow a nonprivileged user to use the last ten * processes; don't let root exceed the limit. */ - nprocs_new = atomic_fetchadd_int(&nprocs, 1) + 1; + nprocs_new = atomic_fetchadd_int(&V_nprocs, 1) + 1; if ((nprocs_new >= maxproc - 10 && priv_check_cred(td->td_ucred, PRIV_MAXPROC, 0) != 0) || nprocs_new >= maxproc) { error = EAGAIN; - sx_xlock(&allproc_lock); - if (ppsratecheck(&lastfail, &curfail, 1)) { + sx_xlock(&V_allproc_lock); + if (ppsratecheck(&V_lastfail, &V_curfail, 1)) { printf("maxproc limit exceeded by uid %u (pid %d); " "see tuning(7) and login.conf(5)\n", td->td_ucred->cr_ruid, p1->p_pid); } - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); goto fail2; } @@ -955,8 +962,8 @@ STAILQ_INIT(&newproc->p_ktr); /* We have to lock the process tree while we look for a pid. */ - sx_xlock(&proctree_lock); - sx_xlock(&allproc_lock); + sx_xlock(&V_proctree_lock); + sx_xlock(&V_allproc_lock); /* * Increment the count of procs running with this uid. Don't allow @@ -977,8 +984,8 @@ } error = EAGAIN; - sx_xunlock(&allproc_lock); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_allproc_lock); + sx_xunlock(&V_proctree_lock); #ifdef MAC mac_proc_destroy(newproc); #endif @@ -994,7 +1001,7 @@ fdclose(td, fp_procdesc, *fr->fr_pd_fd); fdrop(fp_procdesc, td); } - atomic_add_int(&nprocs, -1); + atomic_add_int(&V_nprocs, -1); pause("fork", hz / 2); return (error); } @@ -1067,7 +1074,7 @@ p = td->td_proc; if (td->td_dbgflags & TDB_STOPATFORK) { - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); PROC_LOCK(p); if (p->p_pptr->p_ptevents & PTRACE_FORK) { /* @@ -1080,7 +1087,7 @@ "fork_return: attaching to new child pid %d: oppid %d", p->p_pid, p->p_oppid); proc_reparent(p, dbg); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); td->td_dbgflags |= TDB_CHILD | TDB_SCX | TDB_FSTP; ptracestop(td, SIGSTOP, NULL); td->td_dbgflags &= ~(TDB_CHILD | TDB_SCX); @@ -1088,7 +1095,7 @@ /* * ... otherwise clear the request. */ - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); td->td_dbgflags &= ~TDB_STOPATFORK; cv_broadcast(&p->p_dbgwait); } Index: sys/kern/kern_jail.c =================================================================== --- sys/kern/kern_jail.c +++ sys/kern/kern_jail.c @@ -2360,15 +2360,15 @@ #endif #endif { - sx_slock(&allproc_lock); - LIST_FOREACH(p, &allproc, p_list) { + sx_slock(&V_allproc_lock); + LIST_FOREACH(p, &V_allproc, p_list) { PROC_LOCK(p); if (p->p_state != PRS_NEW && p->p_ucred && p->p_ucred->cr_prison == pr) kern_psignal(p, SIGKILL); PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); } /* Remove the temporary reference added by jail_remove. */ prison_deref(pr, deuref | PD_DEREF); @@ -4125,12 +4125,12 @@ ASSERT_RACCT_ENABLED(); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); sx_xlock(&allprison_lock); if (strcmp(pr->pr_name, pr->pr_prison_racct->prr_name) == 0) { sx_xunlock(&allprison_lock); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return; } @@ -4157,7 +4157,7 @@ } #endif - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); prison_racct_free_locked(oldprr); sx_xunlock(&allprison_lock); } Index: sys/kern/kern_kthread.c =================================================================== --- sys/kern/kern_kthread.c +++ sys/kern/kern_kthread.c @@ -89,7 +89,7 @@ struct thread *td; struct proc *p2; - if (!proc0.p_stats) + if (!V_vproc0->p_stats) panic("kproc_create called too soon"); bzero(&fr, sizeof(fr)); @@ -158,11 +158,11 @@ * Reparent curthread from proc0 to init so that the zombie * is harvested. */ - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); PROC_LOCK(p); - proc_reparent(p, initproc); + proc_reparent(p, V_initproc); PROC_UNLOCK(p); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); /* * Wakeup anyone waiting for us to exit. @@ -260,12 +260,12 @@ va_list ap; struct thread *newtd, *oldtd; - if (!proc0.p_stats) + if (!V_vproc0->p_stats) panic("kthread_add called too soon"); /* If no process supplied, put it on proc0 */ if (p == NULL) - p = &proc0; + p = V_vproc0; /* Initialize our new td */ newtd = thread_alloc(pages); Index: sys/kern/kern_ktrace.c =================================================================== --- sys/kern/kern_ktrace.c +++ sys/kern/kern_ktrace.c @@ -955,7 +955,7 @@ int vrele_count; vrele_count = 0; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_tracevp == vp) { @@ -970,7 +970,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (vrele_count > 0) { while (vrele_count-- > 0) vrele(vp); @@ -980,14 +980,14 @@ /* * do it */ - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (uap->pid < 0) { /* * by process group */ pg = pgfind(-uap->pid); if (pg == NULL) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); error = ESRCH; goto done; } @@ -1011,7 +1011,7 @@ ret |= ktrops(td, p, ops, facs, vp); } if (nfound == 0) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); error = ESRCH; goto done; } @@ -1027,7 +1027,7 @@ if (error) { if (p != NULL) PROC_UNLOCK(p); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); goto done; } if (descend) @@ -1035,7 +1035,7 @@ else ret |= ktrops(td, p, ops, facs, vp); } - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); if (!ret) error = EPERM; done: @@ -1143,7 +1143,7 @@ p = top; PROC_LOCK_ASSERT(p, MA_OWNED); - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); for (;;) { ret |= ktrops(td, p, ops, facs, vp); /* @@ -1270,7 +1270,7 @@ * credentials for the operation. */ cred = NULL; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_tracevp == vp) { @@ -1285,7 +1285,7 @@ cred = NULL; } } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); while (vrele_count-- > 0) vrele(vp); Index: sys/kern/kern_mib.c =================================================================== --- sys/kern/kern_mib.c +++ sys/kern/kern_mib.c @@ -556,8 +556,8 @@ error = sysctl_handle_int(oidp, &pm, 0, req); if (error || !req->newptr) return (error); - sx_xlock(&proctree_lock); - sx_xlock(&allproc_lock); + sx_xlock(&V_proctree_lock); + sx_xlock(&V_allproc_lock); /* * Only permit the values less then PID_MAX. @@ -567,8 +567,8 @@ error = EINVAL; else pid_max = pm; - sx_xunlock(&allproc_lock); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_allproc_lock); + sx_xunlock(&V_proctree_lock); return (error); } SYSCTL_PROC(_kern, OID_AUTO, pid_max, CTLTYPE_INT | Index: sys/kern/kern_proc.c =================================================================== --- sys/kern/kern_proc.c +++ sys/kern/kern_proc.c @@ -126,15 +126,21 @@ /* * Other process lists */ -struct pidhashhead *pidhashtbl; -u_long pidhash; -struct pgrphashhead *pgrphashtbl; -u_long pgrphash; -struct proclist allproc; -struct proclist zombproc; +VPS_DEFINE(struct pidhashhead *, pidhashtbl); +VPS_DEFINE(u_long, pidhash); +VPS_DEFINE(struct pgrphashhead *, pgrphashtbl); +VPS_DEFINE(u_long, pgrphash); +VPS_DEFINE(struct proclist, allproc); +VPS_DEFINE(struct proclist, zombproc); +#ifndef VIMAGE struct sx __exclusive_cache_line allproc_lock; struct sx __exclusive_cache_line proctree_lock; struct mtx __exclusive_cache_line ppeers_lock; +#else +VPS_DEFINE(struct sx, allproc_lock); +VPS_DEFINE(struct sx, proctree_lock); +VPS_DEFINE(struct mtx, ppeers_lock); +#endif uma_zone_t proc_zone; /* @@ -179,22 +185,22 @@ /* * Initialize global process hashing structures. */ -void +static void procinit(void) { - sx_init(&allproc_lock, "allproc"); - sx_init(&proctree_lock, "proctree"); - mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF); - LIST_INIT(&allproc); - LIST_INIT(&zombproc); - pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash); - pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash); + sx_init(&V_allproc_lock, "allproc"); + sx_init(&V_proctree_lock, "proctree"); + mtx_init(&V_ppeers_lock, "p_peers", NULL, MTX_DEF); + LIST_INIT(&V_allproc); + LIST_INIT(&V_zombproc); + V_pidhashtbl = hashinit(maxproc / 4, M_PROC, &V_pidhash); + V_pgrphashtbl = hashinit(maxproc / 4, M_PROC, &V_pgrphash); proc_zone = uma_zcreate("PROC", sched_sizeof_proc(), proc_ctor, proc_dtor, proc_init, proc_fini, UMA_ALIGN_PTR, UMA_ZONE_NOFREE); - uihashinit(); } +VPS_SYSINIT(procinit, SI_SUB_INTRINSIC, SI_ORDER_SECOND, procinit, NULL); /* * Prepare a proc for use. @@ -304,7 +310,7 @@ inferior(struct proc *p) { - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); PROC_LOCK_ASSERT(p, MA_OWNED); for (; p != curproc; p = proc_realparent(p)) { if (p->p_pid == 0) @@ -318,7 +324,7 @@ { struct proc *p; - sx_assert(&allproc_lock, SX_LOCKED); + sx_assert(&V_allproc_lock, SX_LOCKED); LIST_FOREACH(p, PIDHASH(pid), p_hash) { if (p->p_pid == pid) { PROC_LOCK(p); @@ -348,9 +354,9 @@ PROC_LOCK(p); return (p); } - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); p = pfind_locked(pid); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (p); } @@ -362,11 +368,11 @@ { struct proc *p; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); p = pfind_locked(pid); if (p == NULL) p = zpfind_locked(pid); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (p); } @@ -377,7 +383,7 @@ struct proc *p; struct thread *td; - sx_assert(&allproc_lock, SX_LOCKED); + sx_assert(&V_allproc_lock, SX_LOCKED); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NEW) { @@ -403,7 +409,7 @@ { struct pgrp *pgrp; - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) { if (pgrp->pg_id == pgid) { @@ -427,7 +433,7 @@ if (p->p_pid == pid) { PROC_LOCK(p); } else { - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); if (pid <= PID_MAX) { p = pfind_locked(pid); if (p == NULL && (flags & PGET_NOTWEXIT) == 0) @@ -437,7 +443,7 @@ } else { p = NULL; } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (p == NULL) return (ESRCH); if ((flags & PGET_CANSEE) != 0) { @@ -487,7 +493,7 @@ enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess) { - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL")); KASSERT(p->p_pid == pgid, @@ -548,7 +554,7 @@ enterthispgrp(struct proc *p, struct pgrp *pgrp) { - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); PROC_LOCK_ASSERT(p, MA_NOTOWNED); PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); @@ -574,7 +580,7 @@ { struct pgrp *savepgrp; - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); PROC_LOCK_ASSERT(p, MA_NOTOWNED); PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); @@ -611,7 +617,7 @@ { struct pgrp *savepgrp; - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); savepgrp = p->p_pgrp; PGRP_LOCK(savepgrp); PROC_LOCK(p); @@ -633,7 +639,7 @@ struct session *savesess; struct tty *tp; - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); @@ -692,7 +698,7 @@ struct session *mysession; struct proc *q; - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); PROC_LOCK_ASSERT(p, MA_NOTOWNED); PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); @@ -745,7 +751,7 @@ } PROC_UNLOCK(p); - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); if (SESS_LEADER(p)) { sp = p->p_session; @@ -782,17 +788,17 @@ } if (ttyvp != NULL) { - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); if (vn_lock(ttyvp, LK_EXCLUSIVE) == 0) { VOP_REVOKE(ttyvp, REVOKEALL); VOP_UNLOCK(ttyvp, 0); } vrele(ttyvp); - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); } } fixjobc(p, p->p_pgrp, 0); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); } /* @@ -852,10 +858,10 @@ struct proc *p; int i; - for (i = 0; i <= pgrphash; i++) { - if (!LIST_EMPTY(&pgrphashtbl[i])) { + for (i = 0; i <= V_pgrphash; i++) { + if (!LIST_EMPTY(&V_pgrphashtbl[i])) { printf("\tindx %d\n", i); - LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { + LIST_FOREACH(pgrp, &V_pgrphashtbl[i], pg_hash) { printf( "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n", (void *)pgrp, (long)pgrp->pg_id, @@ -911,7 +917,7 @@ struct timeval boottime; /* For proc_realparent. */ - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); PROC_LOCK_ASSERT(p, MA_OWNED); bzero(kp, sizeof(*kp)); @@ -1020,7 +1026,7 @@ kp->ki_kiflag |= KI_CTTY; if (SESS_LEADER(p)) kp->ki_kiflag |= KI_SLEADER; - /* XXX proctree_lock */ + /* XXX V_proctree_lock */ tp = sp->s_ttyp; SESS_UNLOCK(sp); } @@ -1210,8 +1216,8 @@ { struct proc *p; - sx_assert(&allproc_lock, SX_LOCKED); - LIST_FOREACH(p, &zombproc, p_list) { + sx_assert(&V_allproc_lock, SX_LOCKED); + LIST_FOREACH(p, &V_zombproc, p_list) { if (p->p_pid == pid) { PROC_LOCK(p); break; @@ -1228,9 +1234,9 @@ { struct proc *p; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); p = zpfind_locked(pid); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (p); } @@ -1466,11 +1472,11 @@ error = sysctl_wire_old_buffer(req, 0); if (error) return (error); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); error = pget((pid_t)name[0], PGET_CANSEE, &p); if (error == 0) error = sysctl_out_proc(p, req, flags); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (error); } @@ -1503,14 +1509,14 @@ * traced process. Only grab it if we are producing any * data to begin with. */ - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); } - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) { if (!doingzomb) - p = LIST_FIRST(&allproc); + p = LIST_FIRST(&V_allproc); else - p = LIST_FIRST(&zombproc); + p = LIST_FIRST(&V_zombproc); for (; p != NULL; p = LIST_NEXT(p, p_list)) { /* * Skip embryonic processes. @@ -1570,7 +1576,7 @@ PROC_UNLOCK(p); continue; } - /* XXX proctree_lock */ + /* XXX V_proctree_lock */ SESS_LOCK(p->p_session); if (p->p_session->s_ttyp == NULL || tty_udev(p->p_session->s_ttyp) != @@ -1610,9 +1616,9 @@ } } out: - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (req->oldptr != NULL) - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (error); } @@ -3093,11 +3099,11 @@ cp = curproc; allproc_loop: - sx_xlock(&allproc_lock); + sx_xlock(&V_allproc_lock); gen = allproc_gen; seen_exiting = seen_stopped = stopped_some = restart = false; LIST_REMOVE(cp, p_list); - LIST_INSERT_HEAD(&allproc, cp, p_list); + LIST_INSERT_HEAD(&V_allproc, cp, p_list); for (;;) { p = LIST_NEXT(cp, p_list); if (p == NULL) @@ -3127,7 +3133,7 @@ continue; } _PHOLD(p); - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); r = thread_single(p, SINGLE_ALLPROC); if (r != 0) restart = true; @@ -3135,12 +3141,12 @@ stopped_some = true; _PRELE(p); PROC_UNLOCK(p); - sx_xlock(&allproc_lock); + sx_xlock(&V_allproc_lock); } /* Catch forked children we did not see in iteration. */ if (gen != allproc_gen) restart = true; - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); if (restart || stopped_some || seen_exiting || seen_stopped) { kern_yield(PRI_USER); goto allproc_loop; @@ -3153,10 +3159,10 @@ struct proc *cp, *p; cp = curproc; - sx_xlock(&allproc_lock); + sx_xlock(&V_allproc_lock); again: LIST_REMOVE(cp, p_list); - LIST_INSERT_HEAD(&allproc, cp, p_list); + LIST_INSERT_HEAD(&V_allproc, cp, p_list); for (;;) { p = LIST_NEXT(cp, p_list); if (p == NULL) @@ -3165,23 +3171,23 @@ LIST_INSERT_AFTER(p, cp, p_list); PROC_LOCK(p); if ((p->p_flag & P_TOTAL_STOP) != 0) { - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); _PHOLD(p); thread_single_end(p, SINGLE_ALLPROC); _PRELE(p); PROC_UNLOCK(p); - sx_xlock(&allproc_lock); + sx_xlock(&V_allproc_lock); } else { PROC_UNLOCK(p); } } /* Did the loop above missed any stopped process ? */ - LIST_FOREACH(p, &allproc, p_list) { + LIST_FOREACH(p, &V_allproc, p_list) { /* No need for proc lock. */ if ((p->p_flag & P_TOTAL_STOP) != 0) goto again; } - sx_xunlock(&allproc_lock); + sx_xunlock(&V_allproc_lock); } /* #define TOTAL_STOP_DEBUG 1 */ Index: sys/kern/kern_procctl.c =================================================================== --- sys/kern/kern_procctl.c +++ sys/kern/kern_procctl.c @@ -69,7 +69,7 @@ p = top; ret = 0; - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); for (;;) { ret |= protect_setchild(td, p, flags); PROC_UNLOCK(p); @@ -128,7 +128,7 @@ reap_acquire(struct thread *td, struct proc *p) { - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); if (p != curproc) return (EPERM); if ((p->p_treeflag & P_TREE_REAPER) != 0) @@ -145,10 +145,10 @@ reap_release(struct thread *td, struct proc *p) { - sx_assert(&proctree_lock, SX_XLOCKED); + sx_assert(&V_proctree_lock, SX_XLOCKED); if (p != curproc) return (EPERM); - if (p == initproc) + if (p == V_initproc) return (EINVAL); if ((p->p_treeflag & P_TREE_REAPER) == 0) return (EINVAL); @@ -162,7 +162,7 @@ { struct proc *reap, *p2, *first_p; - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); bzero(rs, sizeof(*rs)); if ((p->p_treeflag & P_TREE_REAPER) == 0) { reap = p->p_reaper; @@ -170,7 +170,7 @@ reap = p; rs->rs_flags |= REAPER_STATUS_OWNED; } - if (reap == initproc) + if (reap == V_initproc) rs->rs_flags |= REAPER_STATUS_REALINIT; rs->rs_reaper = reap->p_pid; rs->rs_descendants = 0; @@ -199,18 +199,18 @@ u_int i, n; int error; - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); PROC_UNLOCK(p); reap = (p->p_treeflag & P_TREE_REAPER) == 0 ? p->p_reaper : p; n = i = 0; error = 0; LIST_FOREACH(p2, &reap->p_reaplist, p_reapsibling) n++; - sx_unlock(&proctree_lock); + sx_unlock(&V_proctree_lock); if (rp->rp_count < n) n = rp->rp_count; pi = malloc(n * sizeof(*pi), M_TEMP, M_WAITOK); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); LIST_FOREACH(p2, &reap->p_reaplist, p_reapsibling) { if (i == n) break; @@ -225,10 +225,10 @@ pip->pi_flags |= REAPER_PIDINFO_REAPER; i++; } - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); error = copyout(pi, rp->rp_pids, i * sizeof(*pi)); free(pi, M_TEMP); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); PROC_LOCK(p); return (error); } @@ -278,7 +278,7 @@ struct reap_kill_tracker *t; int error; - sx_assert(&proctree_lock, SX_LOCKED); + sx_assert(&V_proctree_lock, SX_LOCKED); if (IN_CAPABILITY_MODE(td)) return (ECAPMODE); if (rk->rk_sig <= 0 || rk->rk_sig > _SIG_MAXSIG || @@ -585,12 +585,12 @@ case PROC_REAP_KILL: case PROC_TRACE_CTL: case PROC_TRAPCAP_CTL: - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); tree_locked = true; break; case PROC_REAP_ACQUIRE: case PROC_REAP_RELEASE: - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); tree_locked = true; break; case PROC_TRACE_STATUS: @@ -657,6 +657,6 @@ break; } if (tree_locked) - sx_unlock(&proctree_lock); + sx_unlock(&V_proctree_lock); return (error); } Index: sys/kern/kern_prot.c =================================================================== --- sys/kern/kern_prot.c +++ sys/kern/kern_prot.c @@ -133,10 +133,10 @@ PROC_UNLOCK(p); } else { PROC_UNLOCK(p); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); pp = proc_realparent(p); ppid = pp->p_pid; - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); } return (ppid); @@ -340,7 +340,7 @@ newpgrp = malloc(sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO); newsess = malloc(sizeof(struct session), M_SESSION, M_WAITOK | M_ZERO); - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); if (p->p_pgid == p->p_pid || (pgrp = pgfind(p->p_pid)) != NULL) { if (pgrp != NULL) @@ -353,7 +353,7 @@ newsess = NULL; } - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); if (newpgrp != NULL) free(newpgrp, M_PGRP); @@ -399,7 +399,7 @@ newpgrp = malloc(sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO); - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); if (uap->pid != 0 && uap->pid != curp->p_pid) { if ((targp = pfind(uap->pid)) == NULL) { error = ESRCH; @@ -457,7 +457,7 @@ error = enterthispgrp(targp, pgrp); } done: - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); KASSERT((error == 0) || (newpgrp != NULL), ("setpgid failed and newpgrp is NULL")); if (newpgrp != NULL) @@ -1738,7 +1738,7 @@ } /* Can't trace init when securelevel > 0. */ - if (p == initproc) { + if (p == V_initproc) { error = securelevel_gt(td->td_ucred, 0); if (error) return (error); Index: sys/kern/kern_racct.c =================================================================== --- sys/kern/kern_racct.c +++ sys/kern/kern_racct.c @@ -1226,9 +1226,9 @@ for (;;) { racct_decay(); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); - LIST_FOREACH(p, &zombproc, p_list) { + LIST_FOREACH(p, &V_zombproc, p_list) { PROC_LOCK(p); racct_set(p, RACCT_PCTCPU, 0); PROC_UNLOCK(p); @@ -1301,7 +1301,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); pause("-", hz); } } Index: sys/kern/kern_rctl.c =================================================================== --- sys/kern/kern_rctl.c +++ sys/kern/kern_rctl.c @@ -1175,7 +1175,7 @@ error = str2id(subject_idstr, &id); if (error != 0) goto out; - sx_assert(&allproc_lock, SA_LOCKED); + sx_assert(&V_allproc_lock, SA_LOCKED); rule->rr_subject.rs_proc = pfind(id); if (rule->rr_subject.rs_proc == NULL) { error = ESRCH; @@ -1357,7 +1357,7 @@ * Now go through all the processes and add the new rule to the ones * it applies to. */ - sx_assert(&allproc_lock, SA_LOCKED); + sx_assert(&V_allproc_lock, SA_LOCKED); FOREACH_PROC_IN_SYSTEM(p) { cred = p->p_ucred; switch (rule->rr_subject_type) { @@ -1452,7 +1452,7 @@ rctl_rule_pre_callback, rctl_rule_post_callback, filter, (void *)&found); - sx_assert(&allproc_lock, SA_LOCKED); + sx_assert(&V_allproc_lock, SA_LOCKED); RACCT_LOCK(); FOREACH_PROC_IN_SYSTEM(p) { found += rctl_racct_remove_rules(p->p_racct, filter); @@ -1623,11 +1623,11 @@ if (error != 0) return (error); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); error = rctl_string_to_rule(inputstr, &filter); free(inputstr, M_RCTL); if (error != 0) { - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } @@ -1669,7 +1669,7 @@ } out: rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (error != 0) return (error); @@ -1718,17 +1718,17 @@ if (error != 0) return (error); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); error = rctl_string_to_rule(inputstr, &filter); free(inputstr, M_RCTL); if (error != 0) { - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } bufsize = uap->outbuflen; if (bufsize > rctl_maxbufsize) { - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (E2BIG); } @@ -1777,7 +1777,7 @@ error = rctl_write_outbuf(sb, uap->outbufp, uap->outbuflen); out: rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); free(buf, M_RCTL); return (error); } @@ -1803,34 +1803,34 @@ if (error != 0) return (error); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); error = rctl_string_to_rule(inputstr, &filter); free(inputstr, M_RCTL); if (error != 0) { - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } if (filter->rr_subject_type == RCTL_SUBJECT_TYPE_UNDEFINED) { rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (EINVAL); } if (filter->rr_subject_type != RCTL_SUBJECT_TYPE_PROCESS) { rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (EOPNOTSUPP); } if (filter->rr_subject.rs_proc == NULL) { rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (EINVAL); } bufsize = uap->outbuflen; if (bufsize > rctl_maxbufsize) { rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (E2BIG); } @@ -1860,7 +1860,7 @@ error = rctl_write_outbuf(sb, uap->outbufp, uap->outbuflen); out: rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); free(buf, M_RCTL); return (error); } @@ -1883,11 +1883,11 @@ if (error != 0) return (error); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); error = rctl_string_to_rule(inputstr, &rule); free(inputstr, M_RCTL); if (error != 0) { - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } /* @@ -1906,7 +1906,7 @@ out: rctl_rule_release(rule); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } @@ -1928,17 +1928,17 @@ if (error != 0) return (error); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); error = rctl_string_to_rule(inputstr, &filter); free(inputstr, M_RCTL); if (error != 0) { - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } error = rctl_rule_remove(filter); rctl_rule_release(filter); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); return (error); } Index: sys/kern/kern_resource.c =================================================================== --- sys/kern/kern_resource.c +++ sys/kern/kern_resource.c @@ -69,10 +69,15 @@ static MALLOC_DEFINE(M_PLIMIT, "plimit", "plimit structures"); static MALLOC_DEFINE(M_UIDINFO, "uidinfo", "uidinfo structures"); -#define UIHASH(uid) (&uihashtbl[(uid) & uihash]) + static struct rwlock uihashtbl_lock; -static LIST_HEAD(uihashhead, uidinfo) *uihashtbl; -static u_long uihash; /* size of hash table - 1 */ + +LIST_HEAD(uihashhead, uidinfo); +static VPS_DEFINE(struct uihashhead *, uihashtbl); +#define V_uihashtbl VPS(uihashtbl) +static VPS_DEFINE(u_long, uihash); /* size of hash table - 1 */ +#define V_uihash VPS(uihash) +#define UIHASH(uid) (&V_uihashtbl[(uid) & V_uihash]) static void calcru1(struct proc *p, struct rusage_ext *ruxp, struct timeval *up, struct timeval *sp); @@ -114,18 +119,18 @@ break; case PRIO_PGRP: - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (uap->who == 0) { pg = td->td_proc->p_pgrp; PGRP_LOCK(pg); } else { pg = pgfind(uap->who); if (pg == NULL) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); break; } } - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); LIST_FOREACH(p, &pg->pg_members, p_pglist) { PROC_LOCK(p); if (p->p_state == PRS_NORMAL && @@ -141,7 +146,7 @@ case PRIO_USER: if (uap->who == 0) uap->who = td->td_ucred->cr_uid; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NORMAL && @@ -152,7 +157,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); break; default: @@ -199,18 +204,18 @@ break; case PRIO_PGRP: - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (uap->who == 0) { pg = curp->p_pgrp; PGRP_LOCK(pg); } else { pg = pgfind(uap->who); if (pg == NULL) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); break; } } - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); LIST_FOREACH(p, &pg->pg_members, p_pglist) { PROC_LOCK(p); if (p->p_state == PRS_NORMAL && @@ -226,7 +231,7 @@ case PRIO_USER: if (uap->who == 0) uap->who = td->td_ucred->cr_uid; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NORMAL && @@ -237,7 +242,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); break; default: @@ -1214,13 +1219,22 @@ p->p_sysent->sv_fixlimit(rlp, which); } -void +static void uihashinit() { - uihashtbl = hashinit(maxproc / 16, M_UIDINFO, &uihash); rw_init(&uihashtbl_lock, "uidinfo hash"); } +SYSINIT(uihashinit, SI_SUB_INTRINSIC, SI_ORDER_SECOND, uihashinit, NULL); + +static void +uihashinit_vps() +{ + + V_uihashtbl = hashinit(maxproc / 16, M_UIDINFO, &V_uihash); +} +VPS_SYSINIT(uihashinit_vps, SI_SUB_INTRINSIC, SI_ORDER_SECOND, uihashinit_vps, + NULL); /* * Look up a uidinfo struct for the parameter uid. @@ -1368,7 +1382,7 @@ rw_rlock(&uihashtbl_lock); if (pre != NULL) (pre)(); - for (uih = &uihashtbl[uihash]; uih >= uihashtbl; uih--) { + for (uih = &V_uihashtbl[V_uihash]; uih >= V_uihashtbl; uih--) { LIST_FOREACH(uip, uih, ui_hash) { (callback)(uip->ui_racct, arg2, arg3); } Index: sys/kern/kern_shutdown.c =================================================================== --- sys/kern/kern_shutdown.c +++ sys/kern/kern_shutdown.c @@ -289,16 +289,16 @@ howto = (uintptr_t)arg; /* Send a signal to init(8) and have it shutdown the world. */ - PROC_LOCK(initproc); + PROC_LOCK(V_initproc); if (howto & RB_POWEROFF) - kern_psignal(initproc, SIGUSR2); + kern_psignal(V_initproc, SIGUSR2); else if (howto & RB_POWERCYCLE) - kern_psignal(initproc, SIGWINCH); + kern_psignal(V_initproc, SIGWINCH); else if (howto & RB_HALT) - kern_psignal(initproc, SIGUSR1); + kern_psignal(V_initproc, SIGUSR1); else - kern_psignal(initproc, SIGINT); - PROC_UNLOCK(initproc); + kern_psignal(V_initproc, SIGINT); + PROC_UNLOCK(V_initproc); } static struct task shutdown_nice_task = TASK_INITIALIZER(0, @@ -311,7 +311,7 @@ shutdown_nice(int howto) { - if (initproc != NULL && !SCHEDULER_STOPPED()) { + if (V_initproc != NULL && !SCHEDULER_STOPPED()) { shutdown_nice_task.ta_context = (void *)(uintptr_t)howto; taskqueue_enqueue(taskqueue_fast, &shutdown_nice_task); } else { @@ -462,7 +462,7 @@ struct mount *mp, *devmp; int error; - if (curproc != initproc) + if (curproc != V_initproc) return (EPERM); /* Index: sys/kern/kern_sig.c =================================================================== --- sys/kern/kern_sig.c +++ sys/kern/kern_sig.c @@ -1671,7 +1671,7 @@ /* * broadcast */ - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || p == td->td_proc || p->p_state == PRS_NEW) { @@ -1688,9 +1688,9 @@ ret = err; PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); } else { - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (pgid == 0) { /* * zero pgid means send to my process group. @@ -1700,11 +1700,11 @@ } else { pgrp = pgfind(pgid); if (pgrp == NULL) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (ESRCH); } } - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { PROC_LOCK(p); if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || @@ -1891,9 +1891,9 @@ struct pgrp *pgrp; if (pgid != 0) { - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); pgrp = pgfind(pgid); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); if (pgrp != NULL) { pgsignal(pgrp, sig, 0, ksi); PGRP_UNLOCK(pgrp); @@ -3279,7 +3279,7 @@ /* * Protect the access to corefilename[] by allproc_lock. */ -#define corefilename_lock allproc_lock +#define corefilename_lock V_allproc_lock static char corefilename[MAXPATHLEN] = {"%N.core"}; TUNABLE_STR("kern.corefile", corefilename, sizeof(corefilename)); Index: sys/kern/kern_sysctl.c =================================================================== --- sys/kern/kern_sysctl.c +++ sys/kern/kern_sysctl.c @@ -60,6 +60,7 @@ #include #include #include +#include #ifdef KTRACE #include #endif @@ -500,6 +501,7 @@ if ((oidp->oid_kind & CTLTYPE) != CTLTYPE_NODE && #ifdef VIMAGE (oidp->oid_kind & CTLFLAG_VNET) == 0 && + (oidp->oid_kind & CTLFLAG_VPS) == 0 && #endif (oidp->oid_kind & CTLFLAG_TUN) != 0 && (oidp->oid_kind & CTLFLAG_NOFETCH) == 0) { @@ -2000,6 +2002,9 @@ else if ((oid->oid_kind & CTLFLAG_VNET) && prison_owns_vnet(req->td->td_ucred)) priv = PRIV_SYSCTL_WRITEJAIL; + else if ((oid->oid_kind & CTLFLAG_VPS) && + prison_owns_vps(req->td->td_ucred)) + priv = PRIV_SYSCTL_WRITEJAIL; #endif else priv = PRIV_SYSCTL_WRITE; @@ -2027,8 +2032,13 @@ goto out; #endif #ifdef VIMAGE + KASSERT(((oid->oid_kind & (CTLFLAG_VNET|CTLFLAG_VPS)) != + (CTLFLAG_VNET|CTLFLAG_VPS)), + ("CTLFLAG VNET and VPS set oid %p", oid)); if ((oid->oid_kind & CTLFLAG_VNET) && arg1 != NULL) arg1 = (void *)(curvnet->vnet_data_base + (uintptr_t)arg1); + if ((oid->oid_kind & CTLFLAG_VPS) && arg1 != NULL) + arg1 = (void *)(curvps->vps_data_base + (uintptr_t)arg1); #endif error = sysctl_root_handler_locked(oid, arg1, arg2, req, &tracker); Index: sys/kern/sched_4bsd.c =================================================================== --- sys/kern/sched_4bsd.c +++ sys/kern/sched_4bsd.c @@ -464,7 +464,7 @@ struct td_sched *ts; int awake; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NEW) { @@ -550,7 +550,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); } /* Index: sys/kern/subr_kdb.c =================================================================== --- sys/kern/subr_kdb.c +++ sys/kern/subr_kdb.c @@ -580,7 +580,7 @@ struct proc *p; struct thread *thr; - p = LIST_FIRST(&allproc); + p = LIST_FIRST(&V_allproc); while (p != NULL) { if (p->p_flag & P_INMEM) { thr = FIRST_THREAD_IN_PROC(p); @@ -597,7 +597,7 @@ { struct proc *p; - p = LIST_FIRST(&allproc); + p = LIST_FIRST(&V_allproc); while (p != NULL) { if (p->p_flag & P_INMEM && p->p_pid == pid) return (FIRST_THREAD_IN_PROC(p)); Index: sys/kern/subr_prf.c =================================================================== --- sys/kern/subr_prf.c +++ sys/kern/subr_prf.c @@ -165,12 +165,12 @@ if (TD_IS_IDLETHREAD(td)) return (0); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); p = td->td_proc; PROC_LOCK(p); if ((p->p_flag & P_CONTROLT) == 0) { PROC_UNLOCK(p); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (0); } SESS_LOCK(p->p_session); @@ -178,14 +178,14 @@ SESS_UNLOCK(p->p_session); PROC_UNLOCK(p); if (pca.tty == NULL) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (0); } pca.flags = TOTTY; pca.p_bufr = NULL; va_start(ap, fmt); tty_lock(pca.tty); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); retval = kvprintf(fmt, putchar, &pca, 10, ap); tty_unlock(pca.tty); va_end(ap); @@ -214,7 +214,7 @@ struct putchar_arg pca; struct session *sess = NULL; - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (pri != -1) flags |= TOLOG; if (p != NULL) { @@ -237,7 +237,7 @@ pca.p_bufr = NULL; if (pca.tty != NULL) tty_lock(pca.tty); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); kvprintf(fmt, putchar, &pca, 10, ap); if (pca.tty != NULL) tty_unlock(pca.tty); Index: sys/kern/sys_procdesc.c =================================================================== --- sys/kern/sys_procdesc.c +++ sys/kern/sys_procdesc.c @@ -153,13 +153,13 @@ goto out; } pd = fp->f_data; - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (pd->pd_proc != NULL) { *p = pd->pd_proc; PROC_LOCK(*p); } else error = ESRCH; - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); out: fdrop(fp, td); return (error); @@ -305,14 +305,14 @@ { struct procdesc *pd; - sx_assert(&proctree_lock, SA_XLOCKED); + sx_assert(&V_proctree_lock, SA_XLOCKED); PROC_LOCK_ASSERT(p, MA_OWNED); KASSERT(p->p_procdesc != NULL, ("procdesc_exit: p_procdesc NULL")); pd = p->p_procdesc; PROCDESC_LOCK(pd); - KASSERT((pd->pd_flags & PDF_CLOSED) == 0 || p->p_pptr == initproc, + KASSERT((pd->pd_flags & PDF_CLOSED) == 0 || p->p_pptr == V_initproc, ("procdesc_exit: closed && parent not init")); pd->pd_flags |= PDF_EXITED; @@ -349,7 +349,7 @@ { struct procdesc *pd; - sx_assert(&proctree_lock, SA_XLOCKED); + sx_assert(&V_proctree_lock, SA_XLOCKED); KASSERT(p->p_procdesc != NULL, ("procdesc_reap: p_procdesc == NULL")); pd = p->p_procdesc; @@ -375,7 +375,7 @@ fp->f_ops = &badfileops; fp->f_data = NULL; - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); PROCDESC_LOCK(pd); pd->pd_flags |= PDF_CLOSED; PROCDESC_UNLOCK(pd); @@ -385,7 +385,7 @@ * This is the case where process' exit status was already * collected and procdesc_reap() was already called. */ - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); } else { PROC_LOCK(p); AUDIT_ARG_PROCESS(p); @@ -415,11 +415,11 @@ * prejudice. */ p->p_sigparent = SIGCHLD; - proc_reparent(p, initproc); + proc_reparent(p, V_initproc); if ((pd->pd_flags & PDF_DAEMON) == 0) kern_psignal(p, SIGKILL); PROC_UNLOCK(p); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); } } @@ -531,7 +531,7 @@ */ bzero(sb, sizeof(*sb)); pd = fp->f_data; - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); if (pd->pd_proc != NULL) { PROC_LOCK(pd->pd_proc); AUDIT_ARG_PROCESS(pd->pd_proc); @@ -553,7 +553,7 @@ PROC_UNLOCK(pd->pd_proc); } else sb->st_mode = S_IFREG; - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (0); } Index: sys/kern/sys_process.c =================================================================== --- sys/kern/sys_process.c +++ sys/kern/sys_process.c @@ -732,7 +732,7 @@ case PT_SET_EVENT_MASK: case PT_DETACH: case PT_GET_SC_ARGS: - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); proctree_locked = 1; break; default: @@ -746,14 +746,14 @@ if (pid <= PID_MAX) { if ((p = pfind(pid)) == NULL) { if (proctree_locked) - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return (ESRCH); } } else { td2 = tdfind(pid, -1); if (td2 == NULL) { if (proctree_locked) - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return (ESRCH); } p = td2->td_proc; @@ -815,7 +815,7 @@ error = EBUSY; goto fail; } - if (p->p_pptr == initproc) { + if (p->p_pptr == V_initproc) { error = EPERM; goto fail; } @@ -922,7 +922,7 @@ CTR2(KTR_PTRACE, "PT_ATTACH: pid %d, oppid %d", p->p_pid, p->p_oppid); - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); proctree_locked = 0; MPASS(p->p_xthread == NULL); MPASS((p->p_flag & P_STOPPED_TRACE) == 0); @@ -1112,7 +1112,7 @@ pp = proc_realparent(p); proc_reparent(p, pp); - if (pp == initproc) + if (pp == V_initproc) p->p_sigparent = SIGCHLD; CTR3(KTR_PTRACE, "PT_DETACH: pid %d reparented to pid %d, sig %d", @@ -1141,7 +1141,7 @@ break; } - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); proctree_locked = 0; sendsig: @@ -1455,7 +1455,7 @@ fail: PROC_UNLOCK(p); if (proctree_locked) - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return (error); } #undef PROC_READ Index: sys/kern/tty.c =================================================================== --- sys/kern/tty.c +++ sys/kern/tty.c @@ -1703,18 +1703,18 @@ /* XXX: This looks awful. */ tty_unlock(tp); - sx_xlock(&proctree_lock); + sx_xlock(&V_proctree_lock); tty_lock(tp); if (!SESS_LEADER(p)) { /* Only the session leader may do this. */ - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return (EPERM); } if (tp->t_session != NULL && tp->t_session == p->p_session) { /* This is already our controlling TTY. */ - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return (0); } @@ -1732,7 +1732,7 @@ * TTYs of which the session leader has been * killed or the TTY revoked. */ - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); return (EPERM); } @@ -1740,7 +1740,7 @@ tp->t_session = p->p_session; tp->t_session->s_ttyp = tp; tp->t_sessioncnt++; - sx_xunlock(&proctree_lock); + sx_xunlock(&V_proctree_lock); /* Assign foreground process group. */ tp->t_pgrp = p->p_pgrp; @@ -1759,12 +1759,12 @@ * decompose proctree_lock. */ tty_unlock(tp); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); pg = pgfind(*(int *)data); if (pg != NULL) PGRP_UNLOCK(pg); if (pg == NULL || pg->pg_session != td->td_proc->p_session) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); tty_lock(tp); return (EPERM); } @@ -1775,11 +1775,11 @@ * relocking the TTY. */ if (!tty_is_ctty(tp, td->td_proc)) { - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); return (ENOTTY); } tp->t_pgrp = pg; - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); /* Wake up the background process groups. */ cv_broadcast(&tp->t_bgwait); Index: sys/kern/tty_tty.c =================================================================== --- sys/kern/tty_tty.c +++ sys/kern/tty_tty.c @@ -68,7 +68,7 @@ return; p = curproc; sx_sunlock(&clone_drain_lock); - sx_slock(&proctree_lock); + sx_slock(&V_proctree_lock); sx_slock(&clone_drain_lock); dev_lock(); if (!(p->p_flag & P_CONTROLT)) @@ -83,7 +83,7 @@ *dev = p->p_session->s_ttyvp->v_rdev; dev_refl(*dev); dev_unlock(); - sx_sunlock(&proctree_lock); + sx_sunlock(&V_proctree_lock); } static void Index: sys/sys/proc.h =================================================================== --- sys/sys/proc.h +++ sys/sys/proc.h @@ -68,6 +68,9 @@ #include #include #include +#ifdef _KERNEL +#include +#endif #include /* Machine-dependent proc substruct. */ #ifdef _KERNEL @@ -827,7 +830,7 @@ #endif #define FOREACH_PROC_IN_SYSTEM(p) \ - LIST_FOREACH((p), &allproc, p_list) + LIST_FOREACH((p), &V_allproc, p_list) #define FOREACH_THREAD_IN_PROC(p, td) \ TAILQ_FOREACH((td), &(p)->p_threads, td_plist) @@ -957,38 +960,61 @@ #define THREAD_CAN_SLEEP() ((curthread)->td_no_sleeping == 0) -#define PIDHASH(pid) (&pidhashtbl[(pid) & pidhash]) -extern LIST_HEAD(pidhashhead, proc) *pidhashtbl; -extern u_long pidhash; -#define TIDHASH(tid) (&tidhashtbl[(tid) & tidhash]) +LIST_HEAD(pidhashhead, proc); +VPS_DECLARE(struct pidhashhead *, pidhashtbl); +#define V_pidhashtbl VPS(pidhashtbl) +VPS_DECLARE(u_long, pidhash); +#define V_pidhash VPS(pidhash) +#define PIDHASH(pid) (&V_pidhashtbl[(pid) & V_pidhash]) + extern LIST_HEAD(tidhashhead, thread) *tidhashtbl; extern u_long tidhash; +#define TIDHASH(tid) (&tidhashtbl[(tid) & tidhash]) extern struct rwlock tidhash_lock; -#define PGRPHASH(pgid) (&pgrphashtbl[(pgid) & pgrphash]) -extern LIST_HEAD(pgrphashhead, pgrp) *pgrphashtbl; -extern u_long pgrphash; +LIST_HEAD(pgrphashhead, pgrp); +VPS_DECLARE(struct pgrphashhead *, pgrphashtbl); +#define V_pgrphashtbl VPS(pgrphashtbl) +VPS_DECLARE(u_long, pgrphash); +#define V_pgrphash VPS(pgrphash) +#define PGRPHASH(pgid) (&V_pgrphashtbl[(pgid) & V_pgrphash]) -extern struct sx allproc_lock; +VPS_DECLARE(struct sx, allproc_lock); +#define V_allproc_lock VPS(allproc_lock) extern int allproc_gen; -extern struct sx proctree_lock; -extern struct mtx ppeers_lock; +VPS_DECLARE(struct sx, proctree_lock); +#define V_proctree_lock VPS(proctree_lock) +VPS_DECLARE(struct mtx, ppeers_lock); +#define V_ppeers_lock VPS(ppeers_lock) extern struct proc proc0; /* Process slot for swapper. */ extern struct thread0_storage thread0_st; /* Primary thread in proc0. */ #define thread0 (thread0_st.t0st_thread) extern struct vmspace vmspace0; /* VM space for proc0. */ +VPS_DECLARE(struct proc *, vproc0); +#define V_vproc0 VPS(vproc0) +#ifdef VIMAGE +VPS_DECLARE(int, vpsdying); +#define V_vpsdying VPS(vpsdying) +#endif extern int hogticks; /* Limit on kernel cpu hogs. */ -extern int lastpid; -extern int nprocs, maxproc; /* Current and max number of procs. */ +VPS_DECLARE(int, lastpid); +#define V_lastpid VPS(lastpid) +VPS_DECLARE(int, nprocs); /* Current number of procs. */ +#define V_nprocs VPS(nprocs) +extern int maxproc; /* Max number of procs. */ extern int maxprocperuid; /* Max procs per uid. */ extern u_long ps_arg_cache_limit; LIST_HEAD(proclist, proc); TAILQ_HEAD(procqueue, proc); TAILQ_HEAD(threadqueue, thread); -extern struct proclist allproc; /* List of all processes. */ -extern struct proclist zombproc; /* List of zombie processes. */ -extern struct proc *initproc, *pageproc; /* Process slots for init, pager. */ +VPS_DECLARE(struct proclist, allproc); /* List of all processes. */ +#define V_allproc VPS(allproc) +VPS_DECLARE(struct proclist, zombproc); /* List of zombie processes. */ +#define V_zombproc VPS(zombproc) +VPS_DECLARE(struct proc *, initproc); /* Process slots for init. */ +#define V_initproc VPS(initproc) +extern struct proc *pageproc; /* Process slot for pager. */ extern struct uma_zone *proc_zone; @@ -1061,7 +1087,6 @@ int proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb); int proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb); int proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb); -void procinit(void); void proc_linkup0(struct proc *p, struct thread *td); void proc_linkup(struct proc *p, struct thread *td); struct proc *proc_realparent(struct proc *child); Index: sys/sys/resourcevar.h =================================================================== --- sys/sys/resourcevar.h +++ sys/sys/resourcevar.h @@ -154,7 +154,6 @@ struct uidinfo *uifind(uid_t uid); void uifree(struct uidinfo *uip); -void uihashinit(void); void uihold(struct uidinfo *uip); #ifdef RACCT void ui_racct_foreach(void (*callback)(struct racct *racct, Index: sys/vm/vm_meter.c =================================================================== --- sys/vm/vm_meter.c +++ sys/vm/vm_meter.c @@ -197,7 +197,7 @@ /* * Calculate process statistics. */ - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { if ((p->p_flag & P_SYSTEM) != 0) continue; @@ -231,7 +231,7 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); /* * Calculate object memory usage statistics. */ Index: sys/vm/vm_object.c =================================================================== --- sys/vm/vm_object.c +++ sys/vm/vm_object.c @@ -2509,16 +2509,16 @@ { struct proc *p; - /* sx_slock(&allproc_lock); */ + /* sx_slock(&V_allproc_lock); */ FOREACH_PROC_IN_SYSTEM(p) { if (!p->p_vmspace /* || (p->p_flag & (P_SYSTEM|P_WEXIT)) */) continue; if (_vm_object_in_map(&p->p_vmspace->vm_map, object, 0)) { - /* sx_sunlock(&allproc_lock); */ + /* sx_sunlock(&V_allproc_lock); */ return 1; } } - /* sx_sunlock(&allproc_lock); */ + /* sx_sunlock(&V_allproc_lock); */ if (_vm_object_in_map(kernel_map, object, 0)) return 1; return 0; Index: sys/vm/vm_pageout.c =================================================================== --- sys/vm/vm_pageout.c +++ sys/vm/vm_pageout.c @@ -1781,7 +1781,7 @@ */ bigproc = NULL; bigsize = 0; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); @@ -1827,10 +1827,10 @@ } _PHOLD_LITE(p); PROC_UNLOCK(p); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (!vm_map_trylock_read(&vm->vm_map)) { vmspace_free(vm); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); PRELE(p); continue; } @@ -1839,7 +1839,7 @@ size += vm_pageout_oom_pagecount(vm); vm_map_unlock_read(&vm->vm_map); vmspace_free(vm); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); /* * If this process is bigger than the biggest one, @@ -1854,7 +1854,7 @@ PRELE(p); } } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (bigproc != NULL) { if (vm_panic_on_oom != 0) panic("out of swap space"); Index: sys/vm/vm_swapout.c =================================================================== --- sys/vm/vm_swapout.c +++ sys/vm/vm_swapout.c @@ -417,7 +417,7 @@ attempts = 0; again: attempts++; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { vm_pindex_t limit, size; @@ -473,7 +473,7 @@ PRELE(p); continue; } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); size = vmspace_resident_count(vm); if (size >= limit) { @@ -521,10 +521,10 @@ } #endif vmspace_free(vm); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); PRELE(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); if (tryagain != 0 && attempts <= 10) { maybe_yield(); goto again; @@ -663,7 +663,7 @@ pp = NULL; ppri = INT_MIN; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { PROC_LOCK(p); if (p->p_state == PRS_NEW || @@ -698,13 +698,13 @@ } PROC_UNLOCK(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); /* * Nothing to do, back to sleep. */ if ((p = pp) == NULL) { - tsleep(&proc0, PVM, "swapin", MAXSLP * hz / 2); + tsleep(V_vproc0, PVM, "swapin", MAXSLP * hz / 2); goto loop; } PROC_LOCK(p); @@ -746,7 +746,7 @@ MPASS((action & (VM_SWAP_NORMAL | VM_SWAP_IDLE)) != 0); didswap = false; - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); FOREACH_PROC_IN_SYSTEM(p) { /* * Filter out not yet fully constructed processes. Do @@ -776,7 +776,7 @@ * allproc list while it is unlocked. */ _PHOLD_LITE(p); - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); /* * Do not swapout a realtime process. @@ -803,17 +803,17 @@ didswap = true; PROC_UNLOCK(p); - sx_slock(&allproc_lock); + sx_slock(&V_allproc_lock); PRELE(p); } - sx_sunlock(&allproc_lock); + sx_sunlock(&V_allproc_lock); /* * If we swapped something out, and another process needed memory, * then wakeup the sched process. */ if (didswap) - wakeup(&proc0); + wakeup(V_vproc0); } static void