1df8bae1dSRodney W. Grimes /* 2df8bae1dSRodney W. Grimes * Copyright (c) 1982, 1986, 1989, 1991, 1993 3df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 4df8bae1dSRodney W. Grimes * 5df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 6df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 7df8bae1dSRodney W. Grimes * are met: 8df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 9df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 10df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 11df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 12df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 13df8bae1dSRodney W. Grimes * 3. All advertising materials mentioning features or use of this software 14df8bae1dSRodney W. Grimes * must display the following acknowledgement: 15df8bae1dSRodney W. Grimes * This product includes software developed by the University of 16df8bae1dSRodney W. Grimes * California, Berkeley and its contributors. 17df8bae1dSRodney W. Grimes * 4. Neither the name of the University nor the names of its contributors 18df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 19df8bae1dSRodney W. Grimes * without specific prior written permission. 20df8bae1dSRodney W. Grimes * 21df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31df8bae1dSRodney W. Grimes * SUCH DAMAGE. 32df8bae1dSRodney W. Grimes * 33b75356e1SJeffrey Hsu * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95 34c3aac50fSPeter Wemm * $FreeBSD$ 35df8bae1dSRodney W. Grimes */ 36df8bae1dSRodney W. Grimes 37df8bae1dSRodney W. Grimes #include <sys/param.h> 38df8bae1dSRodney W. Grimes #include <sys/systm.h> 39df8bae1dSRodney W. Grimes #include <sys/kernel.h> 40fb919e4dSMark Murray #include <sys/lock.h> 41df8bae1dSRodney W. Grimes #include <sys/malloc.h> 42fb919e4dSMark Murray #include <sys/mutex.h> 43b9df5231SPoul-Henning Kamp #include <sys/proc.h> 44079b7badSJulian Elischer #include <sys/sysproto.h> 45fb919e4dSMark Murray #include <sys/sysctl.h> 4662d6ce3aSDon Lewis #include <sys/filedesc.h> 47df8bae1dSRodney W. Grimes #include <sys/tty.h> 48bb56ec4aSPoul-Henning Kamp #include <sys/signalvar.h> 491005a129SJohn Baldwin #include <sys/sx.h> 50fb919e4dSMark Murray #include <sys/user.h> 51fb919e4dSMark Murray #include <sys/jail.h> 52fb919e4dSMark Murray 53efeaf95aSDavid Greenman #include <vm/vm.h> 54efeaf95aSDavid Greenman #include <vm/pmap.h> 55efeaf95aSDavid Greenman #include <vm/vm_map.h> 56c897b813SJeff Roberson #include <vm/uma.h> 57df8bae1dSRodney W. Grimes 58f591779bSSeigo Tanimura MALLOC_DEFINE(M_PGRP, "pgrp", "process group header"); 59a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SESSION, "session", "session header"); 60876a94eeSBruce Evans static MALLOC_DEFINE(M_PROC, "proc", "Proc structures"); 61a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures"); 6255166637SPoul-Henning Kamp 634d77a549SAlfred Perlstein static struct proc *dopfind (register pid_t); 64f591779bSSeigo Tanimura 654d77a549SAlfred Perlstein static void doenterpgrp (struct proc *, struct pgrp *); 66f591779bSSeigo Tanimura 674d77a549SAlfred Perlstein static void pgdelete (struct pgrp *); 6826f9a767SRodney W. Grimes 694d77a549SAlfred Perlstein static void orphanpg (struct pgrp *pg); 7098d93822SBruce Evans 71df8bae1dSRodney W. Grimes /* 72b75356e1SJeffrey Hsu * Other process lists 73b75356e1SJeffrey Hsu */ 74b75356e1SJeffrey Hsu struct pidhashhead *pidhashtbl; 75b75356e1SJeffrey Hsu u_long pidhash; 76b75356e1SJeffrey Hsu struct pgrphashhead *pgrphashtbl; 77b75356e1SJeffrey Hsu u_long pgrphash; 78b75356e1SJeffrey Hsu struct proclist allproc; 79b75356e1SJeffrey Hsu struct proclist zombproc; 801005a129SJohn Baldwin struct sx allproc_lock; 811005a129SJohn Baldwin struct sx proctree_lock; 82f591779bSSeigo Tanimura struct sx pgrpsess_lock; 83c897b813SJeff Roberson uma_zone_t proc_zone; 84c897b813SJeff Roberson uma_zone_t ithread_zone; 85b75356e1SJeffrey Hsu 86b75356e1SJeffrey Hsu /* 87b75356e1SJeffrey Hsu * Initialize global process hashing structures. 88df8bae1dSRodney W. Grimes */ 8926f9a767SRodney W. Grimes void 90b75356e1SJeffrey Hsu procinit() 91df8bae1dSRodney W. Grimes { 92393d77ffSKirk McKusick int i, j; 93df8bae1dSRodney W. Grimes 941005a129SJohn Baldwin sx_init(&allproc_lock, "allproc"); 951005a129SJohn Baldwin sx_init(&proctree_lock, "proctree"); 96f591779bSSeigo Tanimura sx_init(&pgrpsess_lock, "pgrpsess"); 97b75356e1SJeffrey Hsu LIST_INIT(&allproc); 98b75356e1SJeffrey Hsu LIST_INIT(&zombproc); 99b75356e1SJeffrey Hsu pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash); 100b75356e1SJeffrey Hsu pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash); 101c897b813SJeff Roberson proc_zone = uma_zcreate("PROC", sizeof (struct proc), NULL, NULL, 102c897b813SJeff Roberson NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE); 103f535380cSDon Lewis uihashinit(); 1041f7d2501SKirk McKusick /* 1051f7d2501SKirk McKusick * This should really be a compile time warning, but I do 1061f7d2501SKirk McKusick * not know of any way to do that... 1071f7d2501SKirk McKusick */ 108393d77ffSKirk McKusick if (sizeof(struct kinfo_proc) != KINFO_PROC_SIZE) { 109393d77ffSKirk McKusick printf("This message will repeat for the next 20 seconds\n"); 110393d77ffSKirk McKusick for (i = 0; i < 20; i++) { 1111aa97cdeSJohn Baldwin printf("WARNING: size of kinfo_proc (%ld) should be %d!!!\n", 1121aa97cdeSJohn Baldwin (long)sizeof(struct kinfo_proc), KINFO_PROC_SIZE); 113393d77ffSKirk McKusick printf("The kinfo_proc structure was changed "); 114393d77ffSKirk McKusick printf("incorrectly in <sys/user.h>\n"); 115393d77ffSKirk McKusick for (j = 0; j < 0x7ffffff; j++); 116393d77ffSKirk McKusick } 117393d77ffSKirk McKusick 118393d77ffSKirk McKusick } 119df8bae1dSRodney W. Grimes } 120df8bae1dSRodney W. Grimes 121df8bae1dSRodney W. Grimes /* 122079b7badSJulian Elischer * Note that we do not link to the proc's ucred here 123079b7badSJulian Elischer * The thread is linked as if running but no KSE assigned 124079b7badSJulian Elischer */ 125079b7badSJulian Elischer static void 126079b7badSJulian Elischer thread_link(struct thread *td, struct ksegrp *kg) 127079b7badSJulian Elischer { 128079b7badSJulian Elischer struct proc *p = kg->kg_proc; 129079b7badSJulian Elischer 130079b7badSJulian Elischer td->td_proc = p; 131079b7badSJulian Elischer td->td_ksegrp = kg; 132de9ac44aSPeter Wemm td->td_last_kse = &p->p_kse; 133079b7badSJulian Elischer 134079b7badSJulian Elischer TAILQ_INSERT_HEAD(&p->p_threads, td, td_plist); 135079b7badSJulian Elischer TAILQ_INSERT_HEAD(&kg->kg_threads, td, td_kglist); 136079b7badSJulian Elischer td->td_critnest = 0; 137079b7badSJulian Elischer td->td_savecrit = 0; 138079b7badSJulian Elischer td->td_kse = NULL; 139079b7badSJulian Elischer } 140079b7badSJulian Elischer 141079b7badSJulian Elischer /* 142079b7badSJulian Elischer * KSE is linked onto the idle queue. 143079b7badSJulian Elischer */ 144079b7badSJulian Elischer static void 145079b7badSJulian Elischer kse_link(struct kse *ke, struct ksegrp *kg) 146079b7badSJulian Elischer { 147079b7badSJulian Elischer struct proc *p = kg->kg_proc; 148079b7badSJulian Elischer 149079b7badSJulian Elischer TAILQ_INSERT_HEAD(&kg->kg_kseq, ke, ke_kglist); 150079b7badSJulian Elischer kg->kg_kses++; 151079b7badSJulian Elischer TAILQ_INSERT_HEAD(&kg->kg_iq, ke, ke_kgrlist); 152079b7badSJulian Elischer ke->ke_proc = p; 153079b7badSJulian Elischer ke->ke_ksegrp = kg; 154079b7badSJulian Elischer ke->ke_thread = NULL; 155079b7badSJulian Elischer ke->ke_oncpu = NOCPU; 156079b7badSJulian Elischer } 157079b7badSJulian Elischer 158079b7badSJulian Elischer static void 159079b7badSJulian Elischer ksegrp_link(struct ksegrp *kg, struct proc *p) 160079b7badSJulian Elischer { 1612b8a08afSPeter Wemm 162079b7badSJulian Elischer TAILQ_INIT(&kg->kg_threads); 163079b7badSJulian Elischer TAILQ_INIT(&kg->kg_runq); /* links with td_runq */ 164079b7badSJulian Elischer TAILQ_INIT(&kg->kg_slpq); /* links with td_runq */ 165079b7badSJulian Elischer TAILQ_INIT(&kg->kg_kseq); /* all kses in ksegrp */ 166079b7badSJulian Elischer TAILQ_INIT(&kg->kg_iq); /* all kses in ksegrp */ 167079b7badSJulian Elischer kg->kg_proc = p; 168079b7badSJulian Elischer /* the following counters are in the -zero- section and may not need clearing */ 169079b7badSJulian Elischer kg->kg_runnable = 0; 170079b7badSJulian Elischer kg->kg_kses = 0; 171079b7badSJulian Elischer kg->kg_runq_kses = 0; /* XXXKSE change name */ 172079b7badSJulian Elischer /* link it in now that it's consitant */ 173079b7badSJulian Elischer TAILQ_INSERT_HEAD(&p->p_ksegrps, kg, kg_ksegrp); 174079b7badSJulian Elischer } 175079b7badSJulian Elischer 176079b7badSJulian Elischer /* 177079b7badSJulian Elischer * for a newly created process, 178079b7badSJulian Elischer * link up a the structure and its initial threads etc. 179b40ce416SJulian Elischer */ 180b40ce416SJulian Elischer void 181079b7badSJulian Elischer proc_linkup(struct proc *p, struct ksegrp *kg, 182079b7badSJulian Elischer struct kse *ke, struct thread *td) 183b40ce416SJulian Elischer { 1842b8a08afSPeter Wemm 185b40ce416SJulian Elischer TAILQ_INIT(&p->p_ksegrps); /* all ksegrps in proc */ 186b40ce416SJulian Elischer TAILQ_INIT(&p->p_threads); /* all threads in proc */ 187b40ce416SJulian Elischer 188079b7badSJulian Elischer ksegrp_link(kg, p); 189079b7badSJulian Elischer kse_link(ke, kg); 190079b7badSJulian Elischer thread_link(td, kg); 191079b7badSJulian Elischer /* link them together for 1:1 */ 192079b7badSJulian Elischer td->td_kse = ke; 193079b7badSJulian Elischer ke->ke_thread = td; 194079b7badSJulian Elischer } 195b40ce416SJulian Elischer 196079b7badSJulian Elischer /* temporary version is ultra simple while we are in 1:1 mode */ 197079b7badSJulian Elischer struct thread * 198079b7badSJulian Elischer thread_get(struct proc *p) 199079b7badSJulian Elischer { 200079b7badSJulian Elischer struct thread *td = &p->p_xxthread; 201b40ce416SJulian Elischer 202079b7badSJulian Elischer return (td); 203b40ce416SJulian Elischer } 204b40ce416SJulian Elischer 205c28841c1SJulian Elischer 206c28841c1SJulian Elischer /********************* 207c28841c1SJulian Elischer * STUB KSE syscalls 208c28841c1SJulian Elischer *********************/ 209c28841c1SJulian Elischer 210fd21c2b5SJulian Elischer /* struct thread_wakeup_args { struct thread_mailbox *tmbx; }; */ 211c28841c1SJulian Elischer int 212c28841c1SJulian Elischer thread_wakeup(struct thread *td, struct thread_wakeup_args *uap) 213c28841c1SJulian Elischer { 214c28841c1SJulian Elischer 215fd21c2b5SJulian Elischer return(ENOSYS); 216c28841c1SJulian Elischer } 217c28841c1SJulian Elischer 218c28841c1SJulian Elischer int 219c28841c1SJulian Elischer kse_exit(struct thread *td, struct kse_exit_args *uap) 220c28841c1SJulian Elischer { 221c28841c1SJulian Elischer 222fd21c2b5SJulian Elischer return(ENOSYS); 223c28841c1SJulian Elischer } 224c28841c1SJulian Elischer 225c28841c1SJulian Elischer int 226c28841c1SJulian Elischer kse_yield(struct thread *td, struct kse_yield_args *uap) 227c28841c1SJulian Elischer { 228c28841c1SJulian Elischer 229fd21c2b5SJulian Elischer return(ENOSYS); 230c28841c1SJulian Elischer } 231c28841c1SJulian Elischer 232c28841c1SJulian Elischer int kse_wakeup(struct thread *td, struct kse_wakeup_args *uap) 233c28841c1SJulian Elischer { 234c28841c1SJulian Elischer 235fd21c2b5SJulian Elischer return(ENOSYS); 236c28841c1SJulian Elischer } 237c28841c1SJulian Elischer 238c28841c1SJulian Elischer 239c28841c1SJulian Elischer int 240c28841c1SJulian Elischer kse_new(struct thread *td, struct kse_new_args *uap) 241c28841c1SJulian Elischer /* struct kse_new_args { 242c28841c1SJulian Elischer struct kse_mailbox *mbx; 243c28841c1SJulian Elischer int new_grp_flag; 244c28841c1SJulian Elischer }; */ 245c28841c1SJulian Elischer { 246c28841c1SJulian Elischer 247fd21c2b5SJulian Elischer return (ENOSYS); 248c28841c1SJulian Elischer } 249c28841c1SJulian Elischer 250b40ce416SJulian Elischer /* 251df8bae1dSRodney W. Grimes * Is p an inferior of the current process? 252df8bae1dSRodney W. Grimes */ 2531a432a2fSDima Ruban int 254df8bae1dSRodney W. Grimes inferior(p) 255df8bae1dSRodney W. Grimes register struct proc *p; 256df8bae1dSRodney W. Grimes { 257df8bae1dSRodney W. Grimes 2585b29d6e9SJohn Baldwin sx_assert(&proctree_lock, SX_LOCKED); 2595b29d6e9SJohn Baldwin for (; p != curproc; p = p->p_pptr) 26000f13cb3SJohn Baldwin if (p->p_pid == 0) 26100f13cb3SJohn Baldwin return (0); 26200f13cb3SJohn Baldwin return (1); 263df8bae1dSRodney W. Grimes } 264df8bae1dSRodney W. Grimes 265df8bae1dSRodney W. Grimes /* 266df8bae1dSRodney W. Grimes * Locate a process by number 267df8bae1dSRodney W. Grimes */ 268df8bae1dSRodney W. Grimes struct proc * 269df8bae1dSRodney W. Grimes pfind(pid) 270df8bae1dSRodney W. Grimes register pid_t pid; 271df8bae1dSRodney W. Grimes { 272df8bae1dSRodney W. Grimes register struct proc *p; 273df8bae1dSRodney W. Grimes 2741005a129SJohn Baldwin sx_slock(&allproc_lock); 275f591779bSSeigo Tanimura p = dopfind(pid); 276f591779bSSeigo Tanimura sx_sunlock(&allproc_lock); 277f591779bSSeigo Tanimura return (p); 278f591779bSSeigo Tanimura } 279f591779bSSeigo Tanimura 280f591779bSSeigo Tanimura static struct proc * 281f591779bSSeigo Tanimura dopfind(pid) 282f591779bSSeigo Tanimura register pid_t pid; 283f591779bSSeigo Tanimura { 284f591779bSSeigo Tanimura register struct proc *p; 285f591779bSSeigo Tanimura 286f591779bSSeigo Tanimura sx_assert(&allproc_lock, SX_LOCKED); 287f591779bSSeigo Tanimura 2881b727751SPoul-Henning Kamp LIST_FOREACH(p, PIDHASH(pid), p_hash) 28933a9ed9dSJohn Baldwin if (p->p_pid == pid) { 29033a9ed9dSJohn Baldwin PROC_LOCK(p); 291553629ebSJake Burkholder break; 29233a9ed9dSJohn Baldwin } 293df8bae1dSRodney W. Grimes return (p); 294df8bae1dSRodney W. Grimes } 295df8bae1dSRodney W. Grimes 296df8bae1dSRodney W. Grimes /* 297f591779bSSeigo Tanimura * Locate a process group by number. 298f591779bSSeigo Tanimura * The caller must hold pgrpsess_lock. 299df8bae1dSRodney W. Grimes */ 300df8bae1dSRodney W. Grimes struct pgrp * 301df8bae1dSRodney W. Grimes pgfind(pgid) 302df8bae1dSRodney W. Grimes register pid_t pgid; 303df8bae1dSRodney W. Grimes { 304df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 305df8bae1dSRodney W. Grimes 306f591779bSSeigo Tanimura PGRPSESS_LOCK_ASSERT(SX_LOCKED); 307f591779bSSeigo Tanimura 308f591779bSSeigo Tanimura LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) { 309f591779bSSeigo Tanimura if (pgrp->pg_id == pgid) { 310f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 311df8bae1dSRodney W. Grimes return (pgrp); 312f591779bSSeigo Tanimura } 313f591779bSSeigo Tanimura } 314df8bae1dSRodney W. Grimes return (NULL); 315df8bae1dSRodney W. Grimes } 316df8bae1dSRodney W. Grimes 317df8bae1dSRodney W. Grimes /* 318f591779bSSeigo Tanimura * Create a new process group. 319f591779bSSeigo Tanimura * pgid must be equal to the pid of p. 320f591779bSSeigo Tanimura * Begin a new session if required. 321df8bae1dSRodney W. Grimes */ 32226f9a767SRodney W. Grimes int 323f591779bSSeigo Tanimura enterpgrp(p, pgid, pgrp, sess) 324df8bae1dSRodney W. Grimes register struct proc *p; 325df8bae1dSRodney W. Grimes pid_t pgid; 326f591779bSSeigo Tanimura struct pgrp *pgrp; 327f591779bSSeigo Tanimura struct session *sess; 328df8bae1dSRodney W. Grimes { 329f591779bSSeigo Tanimura struct pgrp *pgrp2; 330df8bae1dSRodney W. Grimes 331f591779bSSeigo Tanimura PGRPSESS_LOCK_ASSERT(SX_XLOCKED); 332f591779bSSeigo Tanimura 333f591779bSSeigo Tanimura KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL")); 334f591779bSSeigo Tanimura KASSERT(p->p_pid == pgid, 335f591779bSSeigo Tanimura ("enterpgrp: new pgrp and pid != pgid")); 336f591779bSSeigo Tanimura 337f591779bSSeigo Tanimura pgrp2 = pgfind(pgid); 338f591779bSSeigo Tanimura 339f591779bSSeigo Tanimura KASSERT(pgrp2 == NULL, 340f591779bSSeigo Tanimura ("enterpgrp: pgrp with pgid exists")); 3415526d2d9SEivind Eklund KASSERT(!SESS_LEADER(p), 3425526d2d9SEivind Eklund ("enterpgrp: session leader attempted setpgrp")); 343219cbf59SEivind Eklund 344f591779bSSeigo Tanimura mtx_init(&pgrp->pg_mtx, "process group", MTX_DEF); 345df8bae1dSRodney W. Grimes 346f591779bSSeigo Tanimura if (sess != NULL) { 347df8bae1dSRodney W. Grimes /* 348df8bae1dSRodney W. Grimes * new session 349df8bae1dSRodney W. Grimes */ 350f591779bSSeigo Tanimura mtx_init(&sess->s_mtx, "session", MTX_DEF); 351f591779bSSeigo Tanimura PROC_LOCK(p); 352f591779bSSeigo Tanimura p->p_flag &= ~P_CONTROLT; 353f591779bSSeigo Tanimura PROC_UNLOCK(p); 354f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 355df8bae1dSRodney W. Grimes sess->s_leader = p; 356643a8daaSDon Lewis sess->s_sid = p->p_pid; 357df8bae1dSRodney W. Grimes sess->s_count = 1; 358df8bae1dSRodney W. Grimes sess->s_ttyvp = NULL; 359df8bae1dSRodney W. Grimes sess->s_ttyp = NULL; 360df8bae1dSRodney W. Grimes bcopy(p->p_session->s_login, sess->s_login, 361df8bae1dSRodney W. Grimes sizeof(sess->s_login)); 362df8bae1dSRodney W. Grimes pgrp->pg_session = sess; 3635526d2d9SEivind Eklund KASSERT(p == curproc, 3645526d2d9SEivind Eklund ("enterpgrp: mksession and p != curproc")); 365df8bae1dSRodney W. Grimes } else { 366df8bae1dSRodney W. Grimes pgrp->pg_session = p->p_session; 367f591779bSSeigo Tanimura SESS_LOCK(pgrp->pg_session); 368df8bae1dSRodney W. Grimes pgrp->pg_session->s_count++; 369f591779bSSeigo Tanimura SESS_UNLOCK(pgrp->pg_session); 370f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 371df8bae1dSRodney W. Grimes } 372df8bae1dSRodney W. Grimes pgrp->pg_id = pgid; 373b75356e1SJeffrey Hsu LIST_INIT(&pgrp->pg_members); 374f591779bSSeigo Tanimura 375f591779bSSeigo Tanimura /* 376f591779bSSeigo Tanimura * As we have an exclusive lock of pgrpsess_lock, 377f591779bSSeigo Tanimura * this should not deadlock. 378f591779bSSeigo Tanimura */ 379b75356e1SJeffrey Hsu LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash); 380df8bae1dSRodney W. Grimes pgrp->pg_jobc = 0; 381831d27a9SDon Lewis SLIST_INIT(&pgrp->pg_sigiolst); 382f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 383f591779bSSeigo Tanimura 384f591779bSSeigo Tanimura doenterpgrp(p, pgrp); 385f591779bSSeigo Tanimura 386df8bae1dSRodney W. Grimes return (0); 387f591779bSSeigo Tanimura } 388f591779bSSeigo Tanimura 389f591779bSSeigo Tanimura /* 390f591779bSSeigo Tanimura * Move p to an existing process group 391f591779bSSeigo Tanimura */ 392f591779bSSeigo Tanimura int 393f591779bSSeigo Tanimura enterthispgrp(p, pgrp) 394f591779bSSeigo Tanimura register struct proc *p; 395f591779bSSeigo Tanimura struct pgrp *pgrp; 396f591779bSSeigo Tanimura { 397f591779bSSeigo Tanimura PGRPSESS_LOCK_ASSERT(SX_XLOCKED); 398f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 399f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 400f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 401f591779bSSeigo Tanimura SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 402f591779bSSeigo Tanimura KASSERT(pgrp->pg_session == p->p_session, 403f591779bSSeigo Tanimura ("%s: pgrp's session %p, p->p_session %p.\n", 404f591779bSSeigo Tanimura __func__, 405f591779bSSeigo Tanimura pgrp->pg_session, 406f591779bSSeigo Tanimura p->p_session)); 407f591779bSSeigo Tanimura KASSERT(pgrp != p->p_pgrp, 408f591779bSSeigo Tanimura ("%s: p belongs to pgrp.", __func__)); 409f591779bSSeigo Tanimura 410f591779bSSeigo Tanimura doenterpgrp(p, pgrp); 411f591779bSSeigo Tanimura 412f591779bSSeigo Tanimura return (0); 413f591779bSSeigo Tanimura } 414f591779bSSeigo Tanimura 415f591779bSSeigo Tanimura /* 416f591779bSSeigo Tanimura * Move p to a process group 417f591779bSSeigo Tanimura */ 418f591779bSSeigo Tanimura static void 419f591779bSSeigo Tanimura doenterpgrp(p, pgrp) 420f591779bSSeigo Tanimura struct proc *p; 421f591779bSSeigo Tanimura struct pgrp *pgrp; 422f591779bSSeigo Tanimura { 423f591779bSSeigo Tanimura struct pgrp *savepgrp; 424f591779bSSeigo Tanimura 425f591779bSSeigo Tanimura PGRPSESS_LOCK_ASSERT(SX_XLOCKED); 426f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 427f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 428f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 429f591779bSSeigo Tanimura SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 430f591779bSSeigo Tanimura 431f591779bSSeigo Tanimura savepgrp = p->p_pgrp; 432df8bae1dSRodney W. Grimes 433df8bae1dSRodney W. Grimes /* 434df8bae1dSRodney W. Grimes * Adjust eligibility of affected pgrps to participate in job control. 435df8bae1dSRodney W. Grimes * Increment eligibility counts before decrementing, otherwise we 436df8bae1dSRodney W. Grimes * could reach 0 spuriously during the first call. 437df8bae1dSRodney W. Grimes */ 438df8bae1dSRodney W. Grimes fixjobc(p, pgrp, 1); 439df8bae1dSRodney W. Grimes fixjobc(p, p->p_pgrp, 0); 440df8bae1dSRodney W. Grimes 441f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 442f591779bSSeigo Tanimura PGRP_LOCK(savepgrp); 44315e9ec51SJohn Baldwin PROC_LOCK(p); 444b75356e1SJeffrey Hsu LIST_REMOVE(p, p_pglist); 445df8bae1dSRodney W. Grimes p->p_pgrp = pgrp; 44615e9ec51SJohn Baldwin PROC_UNLOCK(p); 447f591779bSSeigo Tanimura LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist); 448f591779bSSeigo Tanimura PGRP_UNLOCK(savepgrp); 449f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 450f591779bSSeigo Tanimura if (LIST_EMPTY(&savepgrp->pg_members)) 451f591779bSSeigo Tanimura pgdelete(savepgrp); 452df8bae1dSRodney W. Grimes } 453df8bae1dSRodney W. Grimes 454df8bae1dSRodney W. Grimes /* 455df8bae1dSRodney W. Grimes * remove process from process group 456df8bae1dSRodney W. Grimes */ 45726f9a767SRodney W. Grimes int 458df8bae1dSRodney W. Grimes leavepgrp(p) 459df8bae1dSRodney W. Grimes register struct proc *p; 460df8bae1dSRodney W. Grimes { 461f591779bSSeigo Tanimura struct pgrp *savepgrp; 462df8bae1dSRodney W. Grimes 463f591779bSSeigo Tanimura PGRPSESS_XLOCK(); 464f591779bSSeigo Tanimura savepgrp = p->p_pgrp; 465f591779bSSeigo Tanimura PGRP_LOCK(savepgrp); 46615e9ec51SJohn Baldwin PROC_LOCK(p); 467b75356e1SJeffrey Hsu LIST_REMOVE(p, p_pglist); 46815e9ec51SJohn Baldwin p->p_pgrp = NULL; 46915e9ec51SJohn Baldwin PROC_UNLOCK(p); 470f591779bSSeigo Tanimura PGRP_UNLOCK(savepgrp); 471f591779bSSeigo Tanimura if (LIST_EMPTY(&savepgrp->pg_members)) 472f591779bSSeigo Tanimura pgdelete(savepgrp); 473f591779bSSeigo Tanimura PGRPSESS_XUNLOCK(); 474df8bae1dSRodney W. Grimes return (0); 475df8bae1dSRodney W. Grimes } 476df8bae1dSRodney W. Grimes 477df8bae1dSRodney W. Grimes /* 478df8bae1dSRodney W. Grimes * delete a process group 479df8bae1dSRodney W. Grimes */ 48087b6de2bSPoul-Henning Kamp static void 481df8bae1dSRodney W. Grimes pgdelete(pgrp) 482df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 483df8bae1dSRodney W. Grimes { 484f591779bSSeigo Tanimura struct session *savesess; 485f591779bSSeigo Tanimura 486f591779bSSeigo Tanimura PGRPSESS_LOCK_ASSERT(SX_XLOCKED); 487f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 488f591779bSSeigo Tanimura SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 489f591779bSSeigo Tanimura 490f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 491df8bae1dSRodney W. Grimes 492831d27a9SDon Lewis /* 493831d27a9SDon Lewis * Reset any sigio structures pointing to us as a result of 494831d27a9SDon Lewis * F_SETOWN with our pgid. 495831d27a9SDon Lewis */ 496831d27a9SDon Lewis funsetownlst(&pgrp->pg_sigiolst); 497831d27a9SDon Lewis 498df8bae1dSRodney W. Grimes if (pgrp->pg_session->s_ttyp != NULL && 499df8bae1dSRodney W. Grimes pgrp->pg_session->s_ttyp->t_pgrp == pgrp) 500df8bae1dSRodney W. Grimes pgrp->pg_session->s_ttyp->t_pgrp = NULL; 501b75356e1SJeffrey Hsu LIST_REMOVE(pgrp, pg_hash); 502f591779bSSeigo Tanimura savesess = pgrp->pg_session; 503f591779bSSeigo Tanimura SESS_LOCK(savesess); 504f591779bSSeigo Tanimura savesess->s_count--; 505f591779bSSeigo Tanimura SESS_UNLOCK(savesess); 506f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 507f591779bSSeigo Tanimura if (savesess->s_count == 0) { 508f591779bSSeigo Tanimura mtx_destroy(&savesess->s_mtx); 509df8bae1dSRodney W. Grimes FREE(pgrp->pg_session, M_SESSION); 510f591779bSSeigo Tanimura } 511f591779bSSeigo Tanimura mtx_destroy(&pgrp->pg_mtx); 512df8bae1dSRodney W. Grimes FREE(pgrp, M_PGRP); 513df8bae1dSRodney W. Grimes } 514df8bae1dSRodney W. Grimes 515df8bae1dSRodney W. Grimes /* 516df8bae1dSRodney W. Grimes * Adjust pgrp jobc counters when specified process changes process group. 517df8bae1dSRodney W. Grimes * We count the number of processes in each process group that "qualify" 518df8bae1dSRodney W. Grimes * the group for terminal job control (those with a parent in a different 519df8bae1dSRodney W. Grimes * process group of the same session). If that count reaches zero, the 520df8bae1dSRodney W. Grimes * process group becomes orphaned. Check both the specified process' 521df8bae1dSRodney W. Grimes * process group and that of its children. 522df8bae1dSRodney W. Grimes * entering == 0 => p is leaving specified group. 523df8bae1dSRodney W. Grimes * entering == 1 => p is entering specified group. 524df8bae1dSRodney W. Grimes */ 52526f9a767SRodney W. Grimes void 526df8bae1dSRodney W. Grimes fixjobc(p, pgrp, entering) 527df8bae1dSRodney W. Grimes register struct proc *p; 528df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 529df8bae1dSRodney W. Grimes int entering; 530df8bae1dSRodney W. Grimes { 531df8bae1dSRodney W. Grimes register struct pgrp *hispgrp; 532f591779bSSeigo Tanimura register struct session *mysession; 533f591779bSSeigo Tanimura 534f591779bSSeigo Tanimura PGRPSESS_LOCK_ASSERT(SX_LOCKED); 535f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 536f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 537f591779bSSeigo Tanimura SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 538df8bae1dSRodney W. Grimes 539df8bae1dSRodney W. Grimes /* 540df8bae1dSRodney W. Grimes * Check p's parent to see whether p qualifies its own process 541df8bae1dSRodney W. Grimes * group; if so, adjust count for p's process group. 542df8bae1dSRodney W. Grimes */ 543f591779bSSeigo Tanimura mysession = pgrp->pg_session; 5441005a129SJohn Baldwin sx_slock(&proctree_lock); 545df8bae1dSRodney W. Grimes if ((hispgrp = p->p_pptr->p_pgrp) != pgrp && 546dfd5dee1SPeter Wemm hispgrp->pg_session == mysession) { 547f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 548df8bae1dSRodney W. Grimes if (entering) 549df8bae1dSRodney W. Grimes pgrp->pg_jobc++; 550f591779bSSeigo Tanimura else { 551f591779bSSeigo Tanimura --pgrp->pg_jobc; 552f591779bSSeigo Tanimura if (pgrp->pg_jobc == 0) 553df8bae1dSRodney W. Grimes orphanpg(pgrp); 554dfd5dee1SPeter Wemm } 555f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 556f591779bSSeigo Tanimura } 557df8bae1dSRodney W. Grimes 558df8bae1dSRodney W. Grimes /* 559df8bae1dSRodney W. Grimes * Check this process' children to see whether they qualify 560df8bae1dSRodney W. Grimes * their process groups; if so, adjust counts for children's 561df8bae1dSRodney W. Grimes * process groups. 562df8bae1dSRodney W. Grimes */ 563f591779bSSeigo Tanimura LIST_FOREACH(p, &p->p_children, p_sibling) { 564df8bae1dSRodney W. Grimes if ((hispgrp = p->p_pgrp) != pgrp && 565df8bae1dSRodney W. Grimes hispgrp->pg_session == mysession && 566dfd5dee1SPeter Wemm p->p_stat != SZOMB) { 567f591779bSSeigo Tanimura PGRP_LOCK(hispgrp); 568df8bae1dSRodney W. Grimes if (entering) 569df8bae1dSRodney W. Grimes hispgrp->pg_jobc++; 570f591779bSSeigo Tanimura else { 571f591779bSSeigo Tanimura --hispgrp->pg_jobc; 572f591779bSSeigo Tanimura if (hispgrp->pg_jobc == 0) 573df8bae1dSRodney W. Grimes orphanpg(hispgrp); 574df8bae1dSRodney W. Grimes } 575f591779bSSeigo Tanimura PGRP_UNLOCK(hispgrp); 576f591779bSSeigo Tanimura } 577f591779bSSeigo Tanimura } 5781005a129SJohn Baldwin sx_sunlock(&proctree_lock); 579dfd5dee1SPeter Wemm } 580df8bae1dSRodney W. Grimes 581df8bae1dSRodney W. Grimes /* 582df8bae1dSRodney W. Grimes * A process group has become orphaned; 583df8bae1dSRodney W. Grimes * if there are any stopped processes in the group, 584df8bae1dSRodney W. Grimes * hang-up all process in that group. 585df8bae1dSRodney W. Grimes */ 586df8bae1dSRodney W. Grimes static void 587df8bae1dSRodney W. Grimes orphanpg(pg) 588df8bae1dSRodney W. Grimes struct pgrp *pg; 589df8bae1dSRodney W. Grimes { 590df8bae1dSRodney W. Grimes register struct proc *p; 591df8bae1dSRodney W. Grimes 592f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pg, MA_OWNED); 593f591779bSSeigo Tanimura 59415e9ec51SJohn Baldwin mtx_lock_spin(&sched_lock); 5951b727751SPoul-Henning Kamp LIST_FOREACH(p, &pg->pg_members, p_pglist) { 596df8bae1dSRodney W. Grimes if (p->p_stat == SSTOP) { 59715e9ec51SJohn Baldwin mtx_unlock_spin(&sched_lock); 5981b727751SPoul-Henning Kamp LIST_FOREACH(p, &pg->pg_members, p_pglist) { 59915e9ec51SJohn Baldwin PROC_LOCK(p); 600df8bae1dSRodney W. Grimes psignal(p, SIGHUP); 601df8bae1dSRodney W. Grimes psignal(p, SIGCONT); 60215e9ec51SJohn Baldwin PROC_UNLOCK(p); 603df8bae1dSRodney W. Grimes } 604df8bae1dSRodney W. Grimes return; 605df8bae1dSRodney W. Grimes } 606df8bae1dSRodney W. Grimes } 60715e9ec51SJohn Baldwin mtx_unlock_spin(&sched_lock); 608df8bae1dSRodney W. Grimes } 609df8bae1dSRodney W. Grimes 610831031ceSBruce Evans #include "opt_ddb.h" 611831031ceSBruce Evans #ifdef DDB 612831031ceSBruce Evans #include <ddb/ddb.h> 613831031ceSBruce Evans 614831031ceSBruce Evans DB_SHOW_COMMAND(pgrpdump, pgrpdump) 615df8bae1dSRodney W. Grimes { 616df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 617df8bae1dSRodney W. Grimes register struct proc *p; 618876a94eeSBruce Evans register int i; 619df8bae1dSRodney W. Grimes 620b75356e1SJeffrey Hsu for (i = 0; i <= pgrphash; i++) { 6211b727751SPoul-Henning Kamp if (!LIST_EMPTY(&pgrphashtbl[i])) { 622df8bae1dSRodney W. Grimes printf("\tindx %d\n", i); 6231b727751SPoul-Henning Kamp LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { 624ac1e407bSBruce Evans printf( 625ac1e407bSBruce Evans "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n", 626ac1e407bSBruce Evans (void *)pgrp, (long)pgrp->pg_id, 627ac1e407bSBruce Evans (void *)pgrp->pg_session, 628b75356e1SJeffrey Hsu pgrp->pg_session->s_count, 6291b727751SPoul-Henning Kamp (void *)LIST_FIRST(&pgrp->pg_members)); 6301b727751SPoul-Henning Kamp LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 631ac1e407bSBruce Evans printf("\t\tpid %ld addr %p pgrp %p\n", 632ac1e407bSBruce Evans (long)p->p_pid, (void *)p, 633ac1e407bSBruce Evans (void *)p->p_pgrp); 634df8bae1dSRodney W. Grimes } 635df8bae1dSRodney W. Grimes } 636df8bae1dSRodney W. Grimes } 637df8bae1dSRodney W. Grimes } 638df8bae1dSRodney W. Grimes } 639831031ceSBruce Evans #endif /* DDB */ 640972f9b20SPoul-Henning Kamp 641972f9b20SPoul-Henning Kamp /* 6421f7d2501SKirk McKusick * Fill in an kinfo_proc structure for the specified process. 643972f9b20SPoul-Henning Kamp */ 644972f9b20SPoul-Henning Kamp void 6451f7d2501SKirk McKusick fill_kinfo_proc(p, kp) 6461f7d2501SKirk McKusick struct proc *p; 6471f7d2501SKirk McKusick struct kinfo_proc *kp; 648972f9b20SPoul-Henning Kamp { 649b40ce416SJulian Elischer struct thread *td; 6501f7d2501SKirk McKusick struct tty *tp; 6511f7d2501SKirk McKusick struct session *sp; 6521cbb9c3bSPoul-Henning Kamp struct timeval tv; 653972f9b20SPoul-Henning Kamp 6541f7d2501SKirk McKusick bzero(kp, sizeof(*kp)); 655972f9b20SPoul-Henning Kamp 6561f7d2501SKirk McKusick kp->ki_structsize = sizeof(*kp); 6571f7d2501SKirk McKusick kp->ki_paddr = p; 65842a4ed99SJohn Baldwin PROC_LOCK(p); 659b40ce416SJulian Elischer kp->ki_addr =/* p->p_addr; */0; /* XXXKSE */ 6601f7d2501SKirk McKusick kp->ki_args = p->p_args; 6611f7d2501SKirk McKusick kp->ki_tracep = p->p_tracep; 6621f7d2501SKirk McKusick kp->ki_textvp = p->p_textvp; 6631f7d2501SKirk McKusick kp->ki_fd = p->p_fd; 6641f7d2501SKirk McKusick kp->ki_vmspace = p->p_vmspace; 665b1fc0ec1SRobert Watson if (p->p_ucred) { 666b1fc0ec1SRobert Watson kp->ki_uid = p->p_ucred->cr_uid; 667b1fc0ec1SRobert Watson kp->ki_ruid = p->p_ucred->cr_ruid; 668b1fc0ec1SRobert Watson kp->ki_svuid = p->p_ucred->cr_svuid; 6690ecd57adSPeter Wemm /* XXX bde doesn't like KI_NGROUPS */ 6700ecd57adSPeter Wemm kp->ki_ngroups = min(p->p_ucred->cr_ngroups, KI_NGROUPS); 671b1fc0ec1SRobert Watson bcopy(p->p_ucred->cr_groups, kp->ki_groups, 6720ecd57adSPeter Wemm kp->ki_ngroups * sizeof(gid_t)); 673b1fc0ec1SRobert Watson kp->ki_rgid = p->p_ucred->cr_rgid; 674b1fc0ec1SRobert Watson kp->ki_svgid = p->p_ucred->cr_svgid; 675972f9b20SPoul-Henning Kamp } 676d8c85307SJulian Elischer if (p->p_procsig) { 6771f7d2501SKirk McKusick kp->ki_sigignore = p->p_procsig->ps_sigignore; 6781f7d2501SKirk McKusick kp->ki_sigcatch = p->p_procsig->ps_sigcatch; 679d8c85307SJulian Elischer } 6809ed346baSBosko Milekic mtx_lock_spin(&sched_lock); 681972f9b20SPoul-Henning Kamp if (p->p_stat != SIDL && p->p_stat != SZOMB && p->p_vmspace != NULL) { 6821f7d2501SKirk McKusick struct vmspace *vm = p->p_vmspace; 683cd73303cSDavid Greenman 6841f7d2501SKirk McKusick kp->ki_size = vm->vm_map.size; 6851f7d2501SKirk McKusick kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/ 686e414d9aaSPeter Wemm if (p->p_sflag & PS_INMEM) 687b40ce416SJulian Elischer kp->ki_rssize += UAREA_PAGES; 688b40ce416SJulian Elischer FOREACH_THREAD_IN_PROC(p, td) /* XXXKSE: thread swapout check */ 689b40ce416SJulian Elischer kp->ki_rssize += KSTACK_PAGES; 6901f7d2501SKirk McKusick kp->ki_swrss = vm->vm_swrss; 6911f7d2501SKirk McKusick kp->ki_tsize = vm->vm_tsize; 6921f7d2501SKirk McKusick kp->ki_dsize = vm->vm_dsize; 6931f7d2501SKirk McKusick kp->ki_ssize = vm->vm_ssize; 6941f7d2501SKirk McKusick } 69542a4ed99SJohn Baldwin if ((p->p_sflag & PS_INMEM) && p->p_stats) { 6961f7d2501SKirk McKusick kp->ki_start = p->p_stats->p_start; 6971f7d2501SKirk McKusick kp->ki_rusage = p->p_stats->p_ru; 6981f7d2501SKirk McKusick kp->ki_childtime.tv_sec = p->p_stats->p_cru.ru_utime.tv_sec + 6991f7d2501SKirk McKusick p->p_stats->p_cru.ru_stime.tv_sec; 7001f7d2501SKirk McKusick kp->ki_childtime.tv_usec = p->p_stats->p_cru.ru_utime.tv_usec + 7011f7d2501SKirk McKusick p->p_stats->p_cru.ru_stime.tv_usec; 7021f7d2501SKirk McKusick } 70396347d1eSAlan Cox td = FIRST_THREAD_IN_PROC(p); 704079b7badSJulian Elischer if (td->td_wmesg != NULL) 705079b7badSJulian Elischer strncpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg) - 1); 70642a4ed99SJohn Baldwin if (p->p_stat == SMTX) { 70742a4ed99SJohn Baldwin kp->ki_kiflag |= KI_MTXBLOCK; 708079b7badSJulian Elischer strncpy(kp->ki_mtxname, td->td_mtxname, 70977330eebSPeter Wemm sizeof(kp->ki_mtxname) - 1); 71042a4ed99SJohn Baldwin } 71142a4ed99SJohn Baldwin kp->ki_stat = p->p_stat; 7126d3e7b9bSJohn Baldwin kp->ki_sflag = p->p_sflag; 71342a4ed99SJohn Baldwin kp->ki_swtime = p->p_swtime; 71442a4ed99SJohn Baldwin kp->ki_traceflag = p->p_traceflag; 7151f7d2501SKirk McKusick kp->ki_pid = p->p_pid; 716b40ce416SJulian Elischer /* vvv XXXKSE */ 7171cbb9c3bSPoul-Henning Kamp bintime2timeval(&p->p_runtime, &tv); 7181cbb9c3bSPoul-Henning Kamp kp->ki_runtime = tv.tv_sec * (u_int64_t)1000000 + tv.tv_usec; 719b40ce416SJulian Elischer kp->ki_pctcpu = p->p_kse.ke_pctcpu; 7202c100766SJulian Elischer kp->ki_estcpu = td->td_ksegrp->kg_estcpu; 7212c100766SJulian Elischer kp->ki_slptime = td->td_ksegrp->kg_slptime; 722079b7badSJulian Elischer kp->ki_wchan = td->td_wchan; 7232c100766SJulian Elischer kp->ki_pri.pri_level = td->td_priority; 7242c100766SJulian Elischer kp->ki_pri.pri_user = td->td_ksegrp->kg_user_pri; 7252c100766SJulian Elischer kp->ki_pri.pri_class = td->td_ksegrp->kg_pri_class; 7262c100766SJulian Elischer kp->ki_pri.pri_native = td->td_base_pri; 7272c100766SJulian Elischer kp->ki_nice = td->td_ksegrp->kg_nice; 728b40ce416SJulian Elischer kp->ki_rqindex = p->p_kse.ke_rqindex; 729b40ce416SJulian Elischer kp->ki_oncpu = p->p_kse.ke_oncpu; 730079b7badSJulian Elischer kp->ki_lastcpu = td->td_lastcpu; 731079b7badSJulian Elischer kp->ki_tdflags = td->td_flags; 732079b7badSJulian Elischer kp->ki_pcb = td->td_pcb; 733079b7badSJulian Elischer kp->ki_kstack = (void *)td->td_kstack; 734b40ce416SJulian Elischer /* ^^^ XXXKSE */ 7359ed346baSBosko Milekic mtx_unlock_spin(&sched_lock); 7361f7d2501SKirk McKusick sp = NULL; 737f591779bSSeigo Tanimura tp = NULL; 7381f7d2501SKirk McKusick if (p->p_pgrp) { 7391f7d2501SKirk McKusick kp->ki_pgid = p->p_pgrp->pg_id; 7401f7d2501SKirk McKusick kp->ki_jobc = p->p_pgrp->pg_jobc; 7411f7d2501SKirk McKusick sp = p->p_pgrp->pg_session; 7421f7d2501SKirk McKusick 7431f7d2501SKirk McKusick if (sp != NULL) { 7441f7d2501SKirk McKusick kp->ki_sid = sp->s_sid; 745f591779bSSeigo Tanimura SESS_LOCK(sp); 74677330eebSPeter Wemm strncpy(kp->ki_login, sp->s_login, 74777330eebSPeter Wemm sizeof(kp->ki_login) - 1); 7481f7d2501SKirk McKusick if (sp->s_ttyvp) 749b8e6bf1eSJohn Baldwin kp->ki_kiflag |= KI_CTTY; 7501f7d2501SKirk McKusick if (SESS_LEADER(p)) 7511f7d2501SKirk McKusick kp->ki_kiflag |= KI_SLEADER; 752f591779bSSeigo Tanimura tp = sp->s_ttyp; 753f591779bSSeigo Tanimura SESS_UNLOCK(sp); 754cd73303cSDavid Greenman } 755cd73303cSDavid Greenman } 756f591779bSSeigo Tanimura if ((p->p_flag & P_CONTROLT) && tp != NULL) { 7571f7d2501SKirk McKusick kp->ki_tdev = dev2udev(tp->t_dev); 7581f7d2501SKirk McKusick kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 7591f7d2501SKirk McKusick if (tp->t_session) 7601f7d2501SKirk McKusick kp->ki_tsid = tp->t_session->s_sid; 761972f9b20SPoul-Henning Kamp } else 7621f7d2501SKirk McKusick kp->ki_tdev = NOUDEV; 76377330eebSPeter Wemm if (p->p_comm[0] != '\0') { 76477330eebSPeter Wemm strncpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm) - 1); 76577330eebSPeter Wemm strncpy(kp->ki_ocomm, p->p_comm, sizeof(kp->ki_ocomm) - 1); 76662ca2477SJohn Baldwin } 7671f7d2501SKirk McKusick kp->ki_siglist = p->p_siglist; 7681f7d2501SKirk McKusick kp->ki_sigmask = p->p_sigmask; 7691f7d2501SKirk McKusick kp->ki_xstat = p->p_xstat; 7701f7d2501SKirk McKusick kp->ki_acflag = p->p_acflag; 7711f7d2501SKirk McKusick kp->ki_flag = p->p_flag; 77291421ba2SRobert Watson /* If jailed(p->p_ucred), emulate the old P_JAILED flag. */ 77391421ba2SRobert Watson if (jailed(p->p_ucred)) 77491421ba2SRobert Watson kp->ki_flag |= P_JAILED; 7751f7d2501SKirk McKusick kp->ki_lock = p->p_lock; 77642a4ed99SJohn Baldwin if (p->p_pptr) 77742a4ed99SJohn Baldwin kp->ki_ppid = p->p_pptr->p_pid; 77815e9ec51SJohn Baldwin PROC_UNLOCK(p); 779972f9b20SPoul-Henning Kamp } 780972f9b20SPoul-Henning Kamp 78142a4ed99SJohn Baldwin /* 78242a4ed99SJohn Baldwin * Locate a zombie process by number 78342a4ed99SJohn Baldwin */ 78442a4ed99SJohn Baldwin struct proc * 7853ce93e4eSPoul-Henning Kamp zpfind(pid_t pid) 7863ce93e4eSPoul-Henning Kamp { 7873ce93e4eSPoul-Henning Kamp struct proc *p; 7883ce93e4eSPoul-Henning Kamp 7891005a129SJohn Baldwin sx_slock(&allproc_lock); 7901b727751SPoul-Henning Kamp LIST_FOREACH(p, &zombproc, p_list) 79133a9ed9dSJohn Baldwin if (p->p_pid == pid) { 79233a9ed9dSJohn Baldwin PROC_LOCK(p); 793c0c25570SJake Burkholder break; 79433a9ed9dSJohn Baldwin } 7951005a129SJohn Baldwin sx_sunlock(&allproc_lock); 7963ce93e4eSPoul-Henning Kamp return (p); 7973ce93e4eSPoul-Henning Kamp } 7983ce93e4eSPoul-Henning Kamp 7993ce93e4eSPoul-Henning Kamp 8003ce93e4eSPoul-Henning Kamp static int 8013ce93e4eSPoul-Henning Kamp sysctl_out_proc(struct proc *p, struct sysctl_req *req, int doingzomb) 8023ce93e4eSPoul-Henning Kamp { 8031f7d2501SKirk McKusick struct kinfo_proc kinfo_proc; 8043ce93e4eSPoul-Henning Kamp int error; 80533a9ed9dSJohn Baldwin struct proc *np; 8063ce93e4eSPoul-Henning Kamp pid_t pid = p->p_pid; 8073ce93e4eSPoul-Henning Kamp 8081f7d2501SKirk McKusick fill_kinfo_proc(p, &kinfo_proc); 8091f7d2501SKirk McKusick error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc, sizeof(kinfo_proc)); 8103ce93e4eSPoul-Henning Kamp if (error) 8113ce93e4eSPoul-Henning Kamp return (error); 81233a9ed9dSJohn Baldwin if (doingzomb) 81333a9ed9dSJohn Baldwin np = zpfind(pid); 81433a9ed9dSJohn Baldwin else { 81533a9ed9dSJohn Baldwin if (pid == 0) 81633a9ed9dSJohn Baldwin return (0); 81733a9ed9dSJohn Baldwin np = pfind(pid); 81833a9ed9dSJohn Baldwin } 81933a9ed9dSJohn Baldwin if (np == NULL) 8203ce93e4eSPoul-Henning Kamp return EAGAIN; 82133a9ed9dSJohn Baldwin if (np != p) { 82233a9ed9dSJohn Baldwin PROC_UNLOCK(np); 8233ce93e4eSPoul-Henning Kamp return EAGAIN; 82433a9ed9dSJohn Baldwin } 82533a9ed9dSJohn Baldwin PROC_UNLOCK(np); 8263ce93e4eSPoul-Henning Kamp return (0); 8273ce93e4eSPoul-Henning Kamp } 8283ce93e4eSPoul-Henning Kamp 829972f9b20SPoul-Henning Kamp static int 83082d9ae4eSPoul-Henning Kamp sysctl_kern_proc(SYSCTL_HANDLER_ARGS) 831972f9b20SPoul-Henning Kamp { 832972f9b20SPoul-Henning Kamp int *name = (int*) arg1; 833972f9b20SPoul-Henning Kamp u_int namelen = arg2; 834972f9b20SPoul-Henning Kamp struct proc *p; 835972f9b20SPoul-Henning Kamp int doingzomb; 836972f9b20SPoul-Henning Kamp int error = 0; 837972f9b20SPoul-Henning Kamp 8383ce93e4eSPoul-Henning Kamp if (oidp->oid_number == KERN_PROC_PID) { 8393ce93e4eSPoul-Henning Kamp if (namelen != 1) 840972f9b20SPoul-Henning Kamp return (EINVAL); 8413ce93e4eSPoul-Henning Kamp p = pfind((pid_t)name[0]); 8423ce93e4eSPoul-Henning Kamp if (!p) 8433ce93e4eSPoul-Henning Kamp return (0); 844a0f75161SRobert Watson if (p_cansee(curproc, p)) { 84533a9ed9dSJohn Baldwin PROC_UNLOCK(p); 84675c13541SPoul-Henning Kamp return (0); 84733a9ed9dSJohn Baldwin } 84833a9ed9dSJohn Baldwin PROC_UNLOCK(p); 8493ce93e4eSPoul-Henning Kamp error = sysctl_out_proc(p, req, 0); 8503ce93e4eSPoul-Henning Kamp return (error); 8513ce93e4eSPoul-Henning Kamp } 8523ce93e4eSPoul-Henning Kamp if (oidp->oid_number == KERN_PROC_ALL && !namelen) 8533ce93e4eSPoul-Henning Kamp ; 8543ce93e4eSPoul-Henning Kamp else if (oidp->oid_number != KERN_PROC_ALL && namelen == 1) 8553ce93e4eSPoul-Henning Kamp ; 8563ce93e4eSPoul-Henning Kamp else 8573ce93e4eSPoul-Henning Kamp return (EINVAL); 8583ce93e4eSPoul-Henning Kamp 859972f9b20SPoul-Henning Kamp if (!req->oldptr) { 8603ce93e4eSPoul-Henning Kamp /* overestimate by 5 procs */ 861972f9b20SPoul-Henning Kamp error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5); 862972f9b20SPoul-Henning Kamp if (error) 863972f9b20SPoul-Henning Kamp return (error); 864972f9b20SPoul-Henning Kamp } 8651005a129SJohn Baldwin sx_slock(&allproc_lock); 8663ce93e4eSPoul-Henning Kamp for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) { 8673ce93e4eSPoul-Henning Kamp if (!doingzomb) 8681b727751SPoul-Henning Kamp p = LIST_FIRST(&allproc); 8693ce93e4eSPoul-Henning Kamp else 8701b727751SPoul-Henning Kamp p = LIST_FIRST(&zombproc); 8711b727751SPoul-Henning Kamp for (; p != 0; p = LIST_NEXT(p, p_list)) { 872972f9b20SPoul-Henning Kamp /* 873387d2c03SRobert Watson * Show a user only appropriate processes. 87403f808c5SPaul Saab */ 875a0f75161SRobert Watson if (p_cansee(curproc, p)) 87603f808c5SPaul Saab continue; 87703f808c5SPaul Saab /* 878972f9b20SPoul-Henning Kamp * Skip embryonic processes. 879972f9b20SPoul-Henning Kamp */ 880972f9b20SPoul-Henning Kamp if (p->p_stat == SIDL) 881972f9b20SPoul-Henning Kamp continue; 882972f9b20SPoul-Henning Kamp /* 883972f9b20SPoul-Henning Kamp * TODO - make more efficient (see notes below). 884972f9b20SPoul-Henning Kamp * do by session. 885972f9b20SPoul-Henning Kamp */ 8863ce93e4eSPoul-Henning Kamp switch (oidp->oid_number) { 887972f9b20SPoul-Henning Kamp 888972f9b20SPoul-Henning Kamp case KERN_PROC_PGRP: 889972f9b20SPoul-Henning Kamp /* could do this by traversing pgrp */ 890f591779bSSeigo Tanimura PROC_LOCK(p); 8913ce93e4eSPoul-Henning Kamp if (p->p_pgrp == NULL || 892f591779bSSeigo Tanimura p->p_pgrp->pg_id != (pid_t)name[0]) { 893f591779bSSeigo Tanimura PROC_UNLOCK(p); 894972f9b20SPoul-Henning Kamp continue; 895f591779bSSeigo Tanimura } 896f591779bSSeigo Tanimura PROC_UNLOCK(p); 897972f9b20SPoul-Henning Kamp break; 898972f9b20SPoul-Henning Kamp 899972f9b20SPoul-Henning Kamp case KERN_PROC_TTY: 900f591779bSSeigo Tanimura PROC_LOCK(p); 901972f9b20SPoul-Henning Kamp if ((p->p_flag & P_CONTROLT) == 0 || 902f591779bSSeigo Tanimura p->p_session == NULL) { 903f591779bSSeigo Tanimura PROC_UNLOCK(p); 904972f9b20SPoul-Henning Kamp continue; 905f591779bSSeigo Tanimura } 906f591779bSSeigo Tanimura SESS_LOCK(p->p_session); 907f591779bSSeigo Tanimura if (p->p_session->s_ttyp == NULL || 908f591779bSSeigo Tanimura dev2udev(p->p_session->s_ttyp->t_dev) != 909f591779bSSeigo Tanimura (udev_t)name[0]) { 910f591779bSSeigo Tanimura SESS_UNLOCK(p->p_session); 911f591779bSSeigo Tanimura PROC_UNLOCK(p); 912f591779bSSeigo Tanimura continue; 913f591779bSSeigo Tanimura } 914f591779bSSeigo Tanimura SESS_UNLOCK(p->p_session); 915f591779bSSeigo Tanimura PROC_UNLOCK(p); 916972f9b20SPoul-Henning Kamp break; 917972f9b20SPoul-Henning Kamp 918972f9b20SPoul-Henning Kamp case KERN_PROC_UID: 9193ce93e4eSPoul-Henning Kamp if (p->p_ucred == NULL || 9203ce93e4eSPoul-Henning Kamp p->p_ucred->cr_uid != (uid_t)name[0]) 921972f9b20SPoul-Henning Kamp continue; 922972f9b20SPoul-Henning Kamp break; 923972f9b20SPoul-Henning Kamp 924972f9b20SPoul-Henning Kamp case KERN_PROC_RUID: 9253ce93e4eSPoul-Henning Kamp if (p->p_ucred == NULL || 926b1fc0ec1SRobert Watson p->p_ucred->cr_ruid != (uid_t)name[0]) 927972f9b20SPoul-Henning Kamp continue; 928972f9b20SPoul-Henning Kamp break; 929972f9b20SPoul-Henning Kamp } 930972f9b20SPoul-Henning Kamp 931a0f75161SRobert Watson if (p_cansee(curproc, p)) 93275c13541SPoul-Henning Kamp continue; 93375c13541SPoul-Henning Kamp 9343ce93e4eSPoul-Henning Kamp error = sysctl_out_proc(p, req, doingzomb); 935553629ebSJake Burkholder if (error) { 9361005a129SJohn Baldwin sx_sunlock(&allproc_lock); 937972f9b20SPoul-Henning Kamp return (error); 938972f9b20SPoul-Henning Kamp } 939972f9b20SPoul-Henning Kamp } 940553629ebSJake Burkholder } 9411005a129SJohn Baldwin sx_sunlock(&allproc_lock); 942972f9b20SPoul-Henning Kamp return (0); 943972f9b20SPoul-Henning Kamp } 944972f9b20SPoul-Henning Kamp 945b9df5231SPoul-Henning Kamp /* 946b9df5231SPoul-Henning Kamp * This sysctl allows a process to retrieve the argument list or process 947b9df5231SPoul-Henning Kamp * title for another process without groping around in the address space 948b9df5231SPoul-Henning Kamp * of the other process. It also allow a process to set its own "process 949b9df5231SPoul-Henning Kamp * title to a string of its own choice. 950b9df5231SPoul-Henning Kamp */ 951b9df5231SPoul-Henning Kamp static int 95282d9ae4eSPoul-Henning Kamp sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS) 953b9df5231SPoul-Henning Kamp { 954b9df5231SPoul-Henning Kamp int *name = (int*) arg1; 955b9df5231SPoul-Henning Kamp u_int namelen = arg2; 956b9df5231SPoul-Henning Kamp struct proc *p; 957b9df5231SPoul-Henning Kamp struct pargs *pa; 958b9df5231SPoul-Henning Kamp int error = 0; 959b9df5231SPoul-Henning Kamp 960b9df5231SPoul-Henning Kamp if (namelen != 1) 961b9df5231SPoul-Henning Kamp return (EINVAL); 962b9df5231SPoul-Henning Kamp 963b9df5231SPoul-Henning Kamp p = pfind((pid_t)name[0]); 964b9df5231SPoul-Henning Kamp if (!p) 965b9df5231SPoul-Henning Kamp return (0); 966b9df5231SPoul-Henning Kamp 967a0f75161SRobert Watson if ((!ps_argsopen) && p_cansee(curproc, p)) { 96833a9ed9dSJohn Baldwin PROC_UNLOCK(p); 969b9df5231SPoul-Henning Kamp return (0); 97033a9ed9dSJohn Baldwin } 97133a9ed9dSJohn Baldwin PROC_UNLOCK(p); 972b9df5231SPoul-Henning Kamp 973b9df5231SPoul-Henning Kamp if (req->newptr && curproc != p) 974b9df5231SPoul-Henning Kamp return (EPERM); 975b9df5231SPoul-Henning Kamp 976b9df5231SPoul-Henning Kamp if (req->oldptr && p->p_args != NULL) 977b9df5231SPoul-Henning Kamp error = SYSCTL_OUT(req, p->p_args->ar_args, p->p_args->ar_length); 978b9df5231SPoul-Henning Kamp if (req->newptr == NULL) 979b9df5231SPoul-Henning Kamp return (error); 980b9df5231SPoul-Henning Kamp 98133a9ed9dSJohn Baldwin PROC_LOCK(p); 982fbd26f75SJohn Baldwin pa = p->p_args; 983b9df5231SPoul-Henning Kamp p->p_args = NULL; 98415e9ec51SJohn Baldwin PROC_UNLOCK(p); 985fbd26f75SJohn Baldwin if (pa != NULL && --pa->ar_ref == 0) 986fbd26f75SJohn Baldwin FREE(pa, M_PARGS); 987b9df5231SPoul-Henning Kamp 988b9df5231SPoul-Henning Kamp if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit) 989b9df5231SPoul-Henning Kamp return (error); 990b9df5231SPoul-Henning Kamp 991b9df5231SPoul-Henning Kamp MALLOC(pa, struct pargs *, sizeof(struct pargs) + req->newlen, 992b9df5231SPoul-Henning Kamp M_PARGS, M_WAITOK); 993b9df5231SPoul-Henning Kamp pa->ar_ref = 1; 994b9df5231SPoul-Henning Kamp pa->ar_length = req->newlen; 995b9df5231SPoul-Henning Kamp error = SYSCTL_IN(req, pa->ar_args, req->newlen); 99615e9ec51SJohn Baldwin if (!error) { 99715e9ec51SJohn Baldwin PROC_LOCK(p); 998b9df5231SPoul-Henning Kamp p->p_args = pa; 99915e9ec51SJohn Baldwin PROC_UNLOCK(p); 100015e9ec51SJohn Baldwin } else 1001b9df5231SPoul-Henning Kamp FREE(pa, M_PARGS); 1002b9df5231SPoul-Henning Kamp return (error); 1003b9df5231SPoul-Henning Kamp } 10043ce93e4eSPoul-Henning Kamp 10053ce93e4eSPoul-Henning Kamp SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table"); 10063ce93e4eSPoul-Henning Kamp 10073ce93e4eSPoul-Henning Kamp SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT, 10083d177f46SBill Fumerola 0, 0, sysctl_kern_proc, "S,proc", "Return entire process table"); 10093ce93e4eSPoul-Henning Kamp 10103ce93e4eSPoul-Henning Kamp SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD, 10113ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 10123ce93e4eSPoul-Henning Kamp 10133ce93e4eSPoul-Henning Kamp SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD, 10143ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 10153ce93e4eSPoul-Henning Kamp 10163ce93e4eSPoul-Henning Kamp SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD, 10173ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 10183ce93e4eSPoul-Henning Kamp 10193ce93e4eSPoul-Henning Kamp SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD, 10203ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 10213ce93e4eSPoul-Henning Kamp 10223ce93e4eSPoul-Henning Kamp SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD, 1023972f9b20SPoul-Henning Kamp sysctl_kern_proc, "Process table"); 1024b9df5231SPoul-Henning Kamp 10259b6d9dbaSPoul-Henning Kamp SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args, CTLFLAG_RW | CTLFLAG_ANYBODY, 10269b6d9dbaSPoul-Henning Kamp sysctl_kern_proc_args, "Process argument list"); 1027