19454b2d8SWarner Losh /*- 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 * 4. Neither the name of the University nor the names of its contributors 14df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 15df8bae1dSRodney W. Grimes * without specific prior written permission. 16df8bae1dSRodney W. Grimes * 17df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27df8bae1dSRodney W. Grimes * SUCH DAMAGE. 28df8bae1dSRodney W. Grimes * 29b75356e1SJeffrey Hsu * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95 30df8bae1dSRodney W. Grimes */ 31df8bae1dSRodney W. Grimes 32677b542eSDavid E. O'Brien #include <sys/cdefs.h> 33677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 34677b542eSDavid E. O'Brien 3543151ee6SPeter Wemm #include "opt_compat.h" 36cc43c38cSRobert Watson #include "opt_ddb.h" 375d217f17SJohn Birrell #include "opt_kdtrace.h" 386c84de02SJohn Baldwin #include "opt_ktrace.h" 39b9f009b0SPeter Wemm #include "opt_kstack_pages.h" 401cc8c45cSRobert Watson #include "opt_stack.h" 416c84de02SJohn Baldwin 42df8bae1dSRodney W. Grimes #include <sys/param.h> 43df8bae1dSRodney W. Grimes #include <sys/systm.h> 44c5cfcb1cSMikolaj Golub #include <sys/elf.h> 45c5cfcb1cSMikolaj Golub #include <sys/exec.h> 46df8bae1dSRodney W. Grimes #include <sys/kernel.h> 4705e06d11SKonstantin Belousov #include <sys/limits.h> 48fb919e4dSMark Murray #include <sys/lock.h> 497123f4cdSEdward Tomasz Napierala #include <sys/loginclass.h> 50df8bae1dSRodney W. Grimes #include <sys/malloc.h> 515384d089SMikolaj Golub #include <sys/mman.h> 52cc43c38cSRobert Watson #include <sys/mount.h> 53fb919e4dSMark Murray #include <sys/mutex.h> 54b9df5231SPoul-Henning Kamp #include <sys/proc.h> 55c5cfcb1cSMikolaj Golub #include <sys/ptrace.h> 5655b4a5aeSJohn Baldwin #include <sys/refcount.h> 57cc43c38cSRobert Watson #include <sys/sbuf.h> 58baf731e6SRobert Drehmel #include <sys/sysent.h> 59de028f5aSJeff Roberson #include <sys/sched.h> 60165d2b99SJulian Elischer #include <sys/smp.h> 611cc8c45cSRobert Watson #include <sys/stack.h> 62fb919e4dSMark Murray #include <sys/sysctl.h> 6362d6ce3aSDon Lewis #include <sys/filedesc.h> 64df8bae1dSRodney W. Grimes #include <sys/tty.h> 65bb56ec4aSPoul-Henning Kamp #include <sys/signalvar.h> 665d217f17SJohn Birrell #include <sys/sdt.h> 671005a129SJohn Baldwin #include <sys/sx.h> 68fb919e4dSMark Murray #include <sys/user.h> 69fb919e4dSMark Murray #include <sys/jail.h> 70fe769cddSDavid Schultz #include <sys/vnode.h> 714a62a3e5SRandall Stewart #include <sys/eventhandler.h> 72fb919e4dSMark Murray 73cc43c38cSRobert Watson #ifdef DDB 74cc43c38cSRobert Watson #include <ddb/ddb.h> 75cc43c38cSRobert Watson #endif 76cc43c38cSRobert Watson 77efeaf95aSDavid Greenman #include <vm/vm.h> 78a136efe9SPeter Wemm #include <vm/vm_extern.h> 79efeaf95aSDavid Greenman #include <vm/pmap.h> 80efeaf95aSDavid Greenman #include <vm/vm_map.h> 81cc43c38cSRobert Watson #include <vm/vm_object.h> 825384d089SMikolaj Golub #include <vm/vm_page.h> 83c897b813SJeff Roberson #include <vm/uma.h> 84df8bae1dSRodney W. Grimes 8505e06d11SKonstantin Belousov #ifdef COMPAT_FREEBSD32 8605e06d11SKonstantin Belousov #include <compat/freebsd32/freebsd32.h> 8705e06d11SKonstantin Belousov #include <compat/freebsd32/freebsd32_util.h> 8805e06d11SKonstantin Belousov #endif 8905e06d11SKonstantin Belousov 905d217f17SJohn Birrell SDT_PROVIDER_DEFINE(proc); 9179856499SRui Paulo SDT_PROBE_DEFINE(proc, kernel, ctor, entry, entry); 925d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 0, "struct proc *"); 935d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 1, "int"); 945d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 2, "void *"); 955d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 3, "int"); 9679856499SRui Paulo SDT_PROBE_DEFINE(proc, kernel, ctor, return, return); 975d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 0, "struct proc *"); 985d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 1, "int"); 995d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 2, "void *"); 1005d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 3, "int"); 10179856499SRui Paulo SDT_PROBE_DEFINE(proc, kernel, dtor, entry, entry); 1025d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 0, "struct proc *"); 1035d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 1, "int"); 1045d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 2, "void *"); 1055d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 3, "struct thread *"); 10679856499SRui Paulo SDT_PROBE_DEFINE(proc, kernel, dtor, return, return); 1075d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 0, "struct proc *"); 1085d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 1, "int"); 1095d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 2, "void *"); 11079856499SRui Paulo SDT_PROBE_DEFINE(proc, kernel, init, entry, entry); 1115d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 0, "struct proc *"); 1125d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 1, "int"); 1135d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 2, "int"); 11479856499SRui Paulo SDT_PROBE_DEFINE(proc, kernel, init, return, return); 1155d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, init, return, 0, "struct proc *"); 1165d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, init, return, 1, "int"); 1175d217f17SJohn Birrell SDT_PROBE_ARGTYPE(proc, kernel, init, return, 2, "int"); 1185d217f17SJohn Birrell 119f591779bSSeigo Tanimura MALLOC_DEFINE(M_PGRP, "pgrp", "process group header"); 120a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SESSION, "session", "session header"); 121876a94eeSBruce Evans static MALLOC_DEFINE(M_PROC, "proc", "Proc structures"); 122a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures"); 12355166637SPoul-Henning Kamp 1244d77a549SAlfred Perlstein static void doenterpgrp(struct proc *, struct pgrp *); 1254d77a549SAlfred Perlstein static void orphanpg(struct pgrp *pg); 126f8d90480SAttilio Rao static void fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp); 1275032ff81SDon Lewis static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp); 128d92909c1SRobert Watson static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, 129d92909c1SRobert Watson int preferthread); 13002e878d9SJohn Baldwin static void pgadjustjobc(struct pgrp *pgrp, int entering); 13102e878d9SJohn Baldwin static void pgdelete(struct pgrp *); 132b23f72e9SBrian Feldman static int proc_ctor(void *mem, int size, void *arg, int flags); 133a136efe9SPeter Wemm static void proc_dtor(void *mem, int size, void *arg); 134b23f72e9SBrian Feldman static int proc_init(void *mem, int size, int flags); 135a136efe9SPeter Wemm static void proc_fini(void *mem, int size); 13658e8af1bSKonstantin Belousov static void pargs_free(struct pargs *pa); 137a136efe9SPeter Wemm 138df8bae1dSRodney W. Grimes /* 139b75356e1SJeffrey Hsu * Other process lists 140b75356e1SJeffrey Hsu */ 141b75356e1SJeffrey Hsu struct pidhashhead *pidhashtbl; 142b75356e1SJeffrey Hsu u_long pidhash; 143b75356e1SJeffrey Hsu struct pgrphashhead *pgrphashtbl; 144b75356e1SJeffrey Hsu u_long pgrphash; 145b75356e1SJeffrey Hsu struct proclist allproc; 146b75356e1SJeffrey Hsu struct proclist zombproc; 1471005a129SJohn Baldwin struct sx allproc_lock; 1481005a129SJohn Baldwin struct sx proctree_lock; 149c6544064SJohn Baldwin struct mtx ppeers_lock; 150c897b813SJeff Roberson uma_zone_t proc_zone; 151b75356e1SJeffrey Hsu 152b9f009b0SPeter Wemm int kstack_pages = KSTACK_PAGES; 153b389be97SRebecca Cran SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0, 154b389be97SRebecca Cran "Kernel stack size in pages"); 155b9f009b0SPeter Wemm 156a30d7c60SJake Burkholder CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE); 157ed780687SKonstantin Belousov #ifdef COMPAT_FREEBSD32 158ed780687SKonstantin Belousov CTASSERT(sizeof(struct kinfo_proc32) == KINFO_PROC32_SIZE); 159ed780687SKonstantin Belousov #endif 160a30d7c60SJake Burkholder 161b75356e1SJeffrey Hsu /* 162b75356e1SJeffrey Hsu * Initialize global process hashing structures. 163df8bae1dSRodney W. Grimes */ 16426f9a767SRodney W. Grimes void 165b75356e1SJeffrey Hsu procinit() 166df8bae1dSRodney W. Grimes { 167df8bae1dSRodney W. Grimes 1681005a129SJohn Baldwin sx_init(&allproc_lock, "allproc"); 1691005a129SJohn Baldwin sx_init(&proctree_lock, "proctree"); 170c6544064SJohn Baldwin mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF); 171b75356e1SJeffrey Hsu LIST_INIT(&allproc); 172b75356e1SJeffrey Hsu LIST_INIT(&zombproc); 173b75356e1SJeffrey Hsu pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash); 174b75356e1SJeffrey Hsu pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash); 175de028f5aSJeff Roberson proc_zone = uma_zcreate("PROC", sched_sizeof_proc(), 176a136efe9SPeter Wemm proc_ctor, proc_dtor, proc_init, proc_fini, 177a136efe9SPeter Wemm UMA_ALIGN_PTR, UMA_ZONE_NOFREE); 178f535380cSDon Lewis uihashinit(); 179df8bae1dSRodney W. Grimes } 180df8bae1dSRodney W. Grimes 181df8bae1dSRodney W. Grimes /* 182a136efe9SPeter Wemm * Prepare a proc for use. 183a136efe9SPeter Wemm */ 184b23f72e9SBrian Feldman static int 185b23f72e9SBrian Feldman proc_ctor(void *mem, int size, void *arg, int flags) 186a136efe9SPeter Wemm { 187a136efe9SPeter Wemm struct proc *p; 188a136efe9SPeter Wemm 189a136efe9SPeter Wemm p = (struct proc *)mem; 1905d217f17SJohn Birrell SDT_PROBE(proc, kernel, ctor , entry, p, size, arg, flags, 0); 1914a62a3e5SRandall Stewart EVENTHANDLER_INVOKE(process_ctor, p); 1925d217f17SJohn Birrell SDT_PROBE(proc, kernel, ctor , return, p, size, arg, flags, 0); 193b23f72e9SBrian Feldman return (0); 194a136efe9SPeter Wemm } 195a136efe9SPeter Wemm 196a136efe9SPeter Wemm /* 197a136efe9SPeter Wemm * Reclaim a proc after use. 198a136efe9SPeter Wemm */ 199a136efe9SPeter Wemm static void 200a136efe9SPeter Wemm proc_dtor(void *mem, int size, void *arg) 201a136efe9SPeter Wemm { 202a136efe9SPeter Wemm struct proc *p; 2031faf202eSJulian Elischer struct thread *td; 204a136efe9SPeter Wemm 2051faf202eSJulian Elischer /* INVARIANTS checks go here */ 206a136efe9SPeter Wemm p = (struct proc *)mem; 207ed062c8dSJulian Elischer td = FIRST_THREAD_IN_PROC(p); 2085d217f17SJohn Birrell SDT_PROBE(proc, kernel, dtor, entry, p, size, arg, td, 0); 20989b57fcfSKonstantin Belousov if (td != NULL) { 210ed062c8dSJulian Elischer #ifdef INVARIANTS 2111faf202eSJulian Elischer KASSERT((p->p_numthreads == 1), 2121faf202eSJulian Elischer ("bad number of threads in exiting process")); 2132c255e9dSRobert Watson KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr")); 214ed062c8dSJulian Elischer #endif 2151ba4a712SPawel Jakub Dawidek /* Free all OSD associated to this thread. */ 2161ba4a712SPawel Jakub Dawidek osd_thread_exit(td); 21789b57fcfSKonstantin Belousov } 2184a62a3e5SRandall Stewart EVENTHANDLER_INVOKE(process_dtor, p); 219ebceaf6dSDavid Xu if (p->p_ksi != NULL) 220ebceaf6dSDavid Xu KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue")); 2215d217f17SJohn Birrell SDT_PROBE(proc, kernel, dtor, return, p, size, arg, 0, 0); 222a136efe9SPeter Wemm } 223a136efe9SPeter Wemm 224a136efe9SPeter Wemm /* 225a136efe9SPeter Wemm * Initialize type-stable parts of a proc (when newly created). 226a136efe9SPeter Wemm */ 227b23f72e9SBrian Feldman static int 228b23f72e9SBrian Feldman proc_init(void *mem, int size, int flags) 229a136efe9SPeter Wemm { 230a136efe9SPeter Wemm struct proc *p; 231a136efe9SPeter Wemm 232a136efe9SPeter Wemm p = (struct proc *)mem; 2335d217f17SJohn Birrell SDT_PROBE(proc, kernel, init, entry, p, size, flags, 0, 0); 234de028f5aSJeff Roberson p->p_sched = (struct p_sched *)&p[1]; 2357d447c95SJohn Baldwin bzero(&p->p_mtx, sizeof(struct mtx)); 2367d447c95SJohn Baldwin mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK); 237982d11f8SJeff Roberson mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE); 238aeb32571SKonstantin Belousov cv_init(&p->p_pwait, "ppwait"); 2396fa39a73SKonstantin Belousov cv_init(&p->p_dbgwait, "dbgwait"); 24089b57fcfSKonstantin Belousov TAILQ_INIT(&p->p_threads); /* all threads in proc */ 2414a62a3e5SRandall Stewart EVENTHANDLER_INVOKE(process_init, p); 2428b059651SDavid Schultz p->p_stats = pstats_alloc(); 2435d217f17SJohn Birrell SDT_PROBE(proc, kernel, init, return, p, size, flags, 0, 0); 244b23f72e9SBrian Feldman return (0); 245a136efe9SPeter Wemm } 246a136efe9SPeter Wemm 247a136efe9SPeter Wemm /* 2488daa8c60SDavid Schultz * UMA should ensure that this function is never called. 2498daa8c60SDavid Schultz * Freeing a proc structure would violate type stability. 250a136efe9SPeter Wemm */ 251a136efe9SPeter Wemm static void 252a136efe9SPeter Wemm proc_fini(void *mem, int size) 253a136efe9SPeter Wemm { 254f55ab994SJohn Baldwin #ifdef notnow 255f55ab994SJohn Baldwin struct proc *p; 256a136efe9SPeter Wemm 257f55ab994SJohn Baldwin p = (struct proc *)mem; 2584a62a3e5SRandall Stewart EVENTHANDLER_INVOKE(process_fini, p); 259f55ab994SJohn Baldwin pstats_free(p->p_stats); 260f55ab994SJohn Baldwin thread_free(FIRST_THREAD_IN_PROC(p)); 261f55ab994SJohn Baldwin mtx_destroy(&p->p_mtx); 262ebceaf6dSDavid Xu if (p->p_ksi != NULL) 263ebceaf6dSDavid Xu ksiginfo_free(p->p_ksi); 264f55ab994SJohn Baldwin #else 2658daa8c60SDavid Schultz panic("proc reclaimed"); 266f55ab994SJohn Baldwin #endif 267a136efe9SPeter Wemm } 268a136efe9SPeter Wemm 269a136efe9SPeter Wemm /* 270df8bae1dSRodney W. Grimes * Is p an inferior of the current process? 271df8bae1dSRodney W. Grimes */ 2721a432a2fSDima Ruban int 273df8bae1dSRodney W. Grimes inferior(p) 274df8bae1dSRodney W. Grimes register struct proc *p; 275df8bae1dSRodney W. Grimes { 276df8bae1dSRodney W. Grimes 2775b29d6e9SJohn Baldwin sx_assert(&proctree_lock, SX_LOCKED); 2785b29d6e9SJohn Baldwin for (; p != curproc; p = p->p_pptr) 27900f13cb3SJohn Baldwin if (p->p_pid == 0) 28000f13cb3SJohn Baldwin return (0); 28100f13cb3SJohn Baldwin return (1); 282df8bae1dSRodney W. Grimes } 283df8bae1dSRodney W. Grimes 284df8bae1dSRodney W. Grimes /* 2856cbea71cSRobert Watson * Locate a process by number; return only "live" processes -- i.e., neither 2866cbea71cSRobert Watson * zombies nor newly born but incompletely initialized processes. By not 2876cbea71cSRobert Watson * returning processes in the PRS_NEW state, we allow callers to avoid 2886cbea71cSRobert Watson * testing for that condition to avoid dereferencing p_ucred, et al. 289df8bae1dSRodney W. Grimes */ 290df8bae1dSRodney W. Grimes struct proc * 291df8bae1dSRodney W. Grimes pfind(pid) 292df8bae1dSRodney W. Grimes register pid_t pid; 293df8bae1dSRodney W. Grimes { 294df8bae1dSRodney W. Grimes register struct proc *p; 295df8bae1dSRodney W. Grimes 2961005a129SJohn Baldwin sx_slock(&allproc_lock); 2971b727751SPoul-Henning Kamp LIST_FOREACH(p, PIDHASH(pid), p_hash) 29833a9ed9dSJohn Baldwin if (p->p_pid == pid) { 29933a9ed9dSJohn Baldwin PROC_LOCK(p); 3008e6fa660SJohn Baldwin if (p->p_state == PRS_NEW) { 3018e6fa660SJohn Baldwin PROC_UNLOCK(p); 3028e6fa660SJohn Baldwin p = NULL; 3038e6fa660SJohn Baldwin } 304553629ebSJake Burkholder break; 30533a9ed9dSJohn Baldwin } 30698ab1489SJeffrey Hsu sx_sunlock(&allproc_lock); 307df8bae1dSRodney W. Grimes return (p); 308df8bae1dSRodney W. Grimes } 309df8bae1dSRodney W. Grimes 310df8bae1dSRodney W. Grimes /* 311f591779bSSeigo Tanimura * Locate a process group by number. 312f089b570SJohn Baldwin * The caller must hold proctree_lock. 313df8bae1dSRodney W. Grimes */ 314df8bae1dSRodney W. Grimes struct pgrp * 315df8bae1dSRodney W. Grimes pgfind(pgid) 316df8bae1dSRodney W. Grimes register pid_t pgid; 317df8bae1dSRodney W. Grimes { 318df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 319df8bae1dSRodney W. Grimes 320f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_LOCKED); 321f591779bSSeigo Tanimura 322f591779bSSeigo Tanimura LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) { 323f591779bSSeigo Tanimura if (pgrp->pg_id == pgid) { 324f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 325df8bae1dSRodney W. Grimes return (pgrp); 326f591779bSSeigo Tanimura } 327f591779bSSeigo Tanimura } 328df8bae1dSRodney W. Grimes return (NULL); 329df8bae1dSRodney W. Grimes } 330df8bae1dSRodney W. Grimes 331df8bae1dSRodney W. Grimes /* 332f591779bSSeigo Tanimura * Create a new process group. 333f591779bSSeigo Tanimura * pgid must be equal to the pid of p. 334f591779bSSeigo Tanimura * Begin a new session if required. 335df8bae1dSRodney W. Grimes */ 33626f9a767SRodney W. Grimes int 337f591779bSSeigo Tanimura enterpgrp(p, pgid, pgrp, sess) 338df8bae1dSRodney W. Grimes register struct proc *p; 339df8bae1dSRodney W. Grimes pid_t pgid; 340f591779bSSeigo Tanimura struct pgrp *pgrp; 341f591779bSSeigo Tanimura struct session *sess; 342df8bae1dSRodney W. Grimes { 343f591779bSSeigo Tanimura struct pgrp *pgrp2; 344df8bae1dSRodney W. Grimes 345f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 346f591779bSSeigo Tanimura 347f591779bSSeigo Tanimura KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL")); 348f591779bSSeigo Tanimura KASSERT(p->p_pid == pgid, 349f591779bSSeigo Tanimura ("enterpgrp: new pgrp and pid != pgid")); 350f591779bSSeigo Tanimura 351f591779bSSeigo Tanimura pgrp2 = pgfind(pgid); 352f591779bSSeigo Tanimura 353f591779bSSeigo Tanimura KASSERT(pgrp2 == NULL, 354f591779bSSeigo Tanimura ("enterpgrp: pgrp with pgid exists")); 3555526d2d9SEivind Eklund KASSERT(!SESS_LEADER(p), 3565526d2d9SEivind Eklund ("enterpgrp: session leader attempted setpgrp")); 357219cbf59SEivind Eklund 3586008862bSJohn Baldwin mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK); 359df8bae1dSRodney W. Grimes 360f591779bSSeigo Tanimura if (sess != NULL) { 361df8bae1dSRodney W. Grimes /* 362df8bae1dSRodney W. Grimes * new session 363df8bae1dSRodney W. Grimes */ 3646008862bSJohn Baldwin mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF); 365f591779bSSeigo Tanimura PROC_LOCK(p); 366f591779bSSeigo Tanimura p->p_flag &= ~P_CONTROLT; 367f591779bSSeigo Tanimura PROC_UNLOCK(p); 368f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 369df8bae1dSRodney W. Grimes sess->s_leader = p; 370643a8daaSDon Lewis sess->s_sid = p->p_pid; 371bc093719SEd Schouten refcount_init(&sess->s_count, 1); 372df8bae1dSRodney W. Grimes sess->s_ttyvp = NULL; 3738dc9b4cfSEd Schouten sess->s_ttydp = NULL; 374df8bae1dSRodney W. Grimes sess->s_ttyp = NULL; 375df8bae1dSRodney W. Grimes bcopy(p->p_session->s_login, sess->s_login, 376df8bae1dSRodney W. Grimes sizeof(sess->s_login)); 377df8bae1dSRodney W. Grimes pgrp->pg_session = sess; 3785526d2d9SEivind Eklund KASSERT(p == curproc, 3795526d2d9SEivind Eklund ("enterpgrp: mksession and p != curproc")); 380df8bae1dSRodney W. Grimes } else { 381df8bae1dSRodney W. Grimes pgrp->pg_session = p->p_session; 382bc093719SEd Schouten sess_hold(pgrp->pg_session); 383f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 384df8bae1dSRodney W. Grimes } 385df8bae1dSRodney W. Grimes pgrp->pg_id = pgid; 386b75356e1SJeffrey Hsu LIST_INIT(&pgrp->pg_members); 387f591779bSSeigo Tanimura 388f591779bSSeigo Tanimura /* 389f089b570SJohn Baldwin * As we have an exclusive lock of proctree_lock, 390f591779bSSeigo Tanimura * this should not deadlock. 391f591779bSSeigo Tanimura */ 392b75356e1SJeffrey Hsu LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash); 393df8bae1dSRodney W. Grimes pgrp->pg_jobc = 0; 394831d27a9SDon Lewis SLIST_INIT(&pgrp->pg_sigiolst); 395f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 396f591779bSSeigo Tanimura 397f591779bSSeigo Tanimura doenterpgrp(p, pgrp); 398f591779bSSeigo Tanimura 399df8bae1dSRodney W. Grimes return (0); 400f591779bSSeigo Tanimura } 401f591779bSSeigo Tanimura 402f591779bSSeigo Tanimura /* 403f591779bSSeigo Tanimura * Move p to an existing process group 404f591779bSSeigo Tanimura */ 405f591779bSSeigo Tanimura int 406f591779bSSeigo Tanimura enterthispgrp(p, pgrp) 407f591779bSSeigo Tanimura register struct proc *p; 408f591779bSSeigo Tanimura struct pgrp *pgrp; 409f591779bSSeigo Tanimura { 410f089b570SJohn Baldwin 411f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 412f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 413f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 414f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 415f591779bSSeigo Tanimura SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 416f591779bSSeigo Tanimura KASSERT(pgrp->pg_session == p->p_session, 417f591779bSSeigo Tanimura ("%s: pgrp's session %p, p->p_session %p.\n", 418f591779bSSeigo Tanimura __func__, 419f591779bSSeigo Tanimura pgrp->pg_session, 420f591779bSSeigo Tanimura p->p_session)); 421f591779bSSeigo Tanimura KASSERT(pgrp != p->p_pgrp, 422f591779bSSeigo Tanimura ("%s: p belongs to pgrp.", __func__)); 423f591779bSSeigo Tanimura 424f591779bSSeigo Tanimura doenterpgrp(p, pgrp); 425f591779bSSeigo Tanimura 426f591779bSSeigo Tanimura return (0); 427f591779bSSeigo Tanimura } 428f591779bSSeigo Tanimura 429f591779bSSeigo Tanimura /* 430f591779bSSeigo Tanimura * Move p to a process group 431f591779bSSeigo Tanimura */ 432f591779bSSeigo Tanimura static void 433f591779bSSeigo Tanimura doenterpgrp(p, pgrp) 434f591779bSSeigo Tanimura struct proc *p; 435f591779bSSeigo Tanimura struct pgrp *pgrp; 436f591779bSSeigo Tanimura { 437f591779bSSeigo Tanimura struct pgrp *savepgrp; 438f591779bSSeigo Tanimura 439f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 440f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 441f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 442f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 443f591779bSSeigo Tanimura SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 444f591779bSSeigo Tanimura 445f591779bSSeigo Tanimura savepgrp = p->p_pgrp; 446df8bae1dSRodney W. Grimes 447df8bae1dSRodney W. Grimes /* 448df8bae1dSRodney W. Grimes * Adjust eligibility of affected pgrps to participate in job control. 449df8bae1dSRodney W. Grimes * Increment eligibility counts before decrementing, otherwise we 450df8bae1dSRodney W. Grimes * could reach 0 spuriously during the first call. 451df8bae1dSRodney W. Grimes */ 452df8bae1dSRodney W. Grimes fixjobc(p, pgrp, 1); 453df8bae1dSRodney W. Grimes fixjobc(p, p->p_pgrp, 0); 454df8bae1dSRodney W. Grimes 455f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 456f591779bSSeigo Tanimura PGRP_LOCK(savepgrp); 45715e9ec51SJohn Baldwin PROC_LOCK(p); 458b75356e1SJeffrey Hsu LIST_REMOVE(p, p_pglist); 459df8bae1dSRodney W. Grimes p->p_pgrp = pgrp; 46015e9ec51SJohn Baldwin PROC_UNLOCK(p); 461f591779bSSeigo Tanimura LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist); 462f591779bSSeigo Tanimura PGRP_UNLOCK(savepgrp); 463f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 464f591779bSSeigo Tanimura if (LIST_EMPTY(&savepgrp->pg_members)) 465f591779bSSeigo Tanimura pgdelete(savepgrp); 466df8bae1dSRodney W. Grimes } 467df8bae1dSRodney W. Grimes 468df8bae1dSRodney W. Grimes /* 469df8bae1dSRodney W. Grimes * remove process from process group 470df8bae1dSRodney W. Grimes */ 47126f9a767SRodney W. Grimes int 472df8bae1dSRodney W. Grimes leavepgrp(p) 473df8bae1dSRodney W. Grimes register struct proc *p; 474df8bae1dSRodney W. Grimes { 475f591779bSSeigo Tanimura struct pgrp *savepgrp; 476df8bae1dSRodney W. Grimes 477f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 478f591779bSSeigo Tanimura savepgrp = p->p_pgrp; 479f591779bSSeigo Tanimura PGRP_LOCK(savepgrp); 48015e9ec51SJohn Baldwin PROC_LOCK(p); 481b75356e1SJeffrey Hsu LIST_REMOVE(p, p_pglist); 48215e9ec51SJohn Baldwin p->p_pgrp = NULL; 48315e9ec51SJohn Baldwin PROC_UNLOCK(p); 484f591779bSSeigo Tanimura PGRP_UNLOCK(savepgrp); 485f591779bSSeigo Tanimura if (LIST_EMPTY(&savepgrp->pg_members)) 486f591779bSSeigo Tanimura pgdelete(savepgrp); 487df8bae1dSRodney W. Grimes return (0); 488df8bae1dSRodney W. Grimes } 489df8bae1dSRodney W. Grimes 490df8bae1dSRodney W. Grimes /* 491df8bae1dSRodney W. Grimes * delete a process group 492df8bae1dSRodney W. Grimes */ 49387b6de2bSPoul-Henning Kamp static void 494df8bae1dSRodney W. Grimes pgdelete(pgrp) 495df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 496df8bae1dSRodney W. Grimes { 497f591779bSSeigo Tanimura struct session *savesess; 498bc093719SEd Schouten struct tty *tp; 499f591779bSSeigo Tanimura 500f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 501f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 502f591779bSSeigo Tanimura SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 503f591779bSSeigo Tanimura 504831d27a9SDon Lewis /* 505831d27a9SDon Lewis * Reset any sigio structures pointing to us as a result of 506831d27a9SDon Lewis * F_SETOWN with our pgid. 507831d27a9SDon Lewis */ 508831d27a9SDon Lewis funsetownlst(&pgrp->pg_sigiolst); 509831d27a9SDon Lewis 510e649887bSAlfred Perlstein PGRP_LOCK(pgrp); 511bc093719SEd Schouten tp = pgrp->pg_session->s_ttyp; 512b75356e1SJeffrey Hsu LIST_REMOVE(pgrp, pg_hash); 513f591779bSSeigo Tanimura savesess = pgrp->pg_session; 514f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 515bc093719SEd Schouten 516bc093719SEd Schouten /* Remove the reference to the pgrp before deallocating it. */ 517bc093719SEd Schouten if (tp != NULL) { 518bc093719SEd Schouten tty_lock(tp); 519bc093719SEd Schouten tty_rel_pgrp(tp, pgrp); 520bc093719SEd Schouten } 521bc093719SEd Schouten 5226041fa0aSSeigo Tanimura mtx_destroy(&pgrp->pg_mtx); 5231ede983cSDag-Erling Smørgrav free(pgrp, M_PGRP); 524bc093719SEd Schouten sess_release(savesess); 525df8bae1dSRodney W. Grimes } 526df8bae1dSRodney W. Grimes 52702e878d9SJohn Baldwin static void 52802e878d9SJohn Baldwin pgadjustjobc(pgrp, entering) 52902e878d9SJohn Baldwin struct pgrp *pgrp; 53002e878d9SJohn Baldwin int entering; 53102e878d9SJohn Baldwin { 53202e878d9SJohn Baldwin 53302e878d9SJohn Baldwin PGRP_LOCK(pgrp); 53402e878d9SJohn Baldwin if (entering) 53502e878d9SJohn Baldwin pgrp->pg_jobc++; 53602e878d9SJohn Baldwin else { 53702e878d9SJohn Baldwin --pgrp->pg_jobc; 53802e878d9SJohn Baldwin if (pgrp->pg_jobc == 0) 53902e878d9SJohn Baldwin orphanpg(pgrp); 54002e878d9SJohn Baldwin } 54102e878d9SJohn Baldwin PGRP_UNLOCK(pgrp); 54202e878d9SJohn Baldwin } 54302e878d9SJohn Baldwin 544df8bae1dSRodney W. Grimes /* 545df8bae1dSRodney W. Grimes * Adjust pgrp jobc counters when specified process changes process group. 546df8bae1dSRodney W. Grimes * We count the number of processes in each process group that "qualify" 547df8bae1dSRodney W. Grimes * the group for terminal job control (those with a parent in a different 548df8bae1dSRodney W. Grimes * process group of the same session). If that count reaches zero, the 549df8bae1dSRodney W. Grimes * process group becomes orphaned. Check both the specified process' 550df8bae1dSRodney W. Grimes * process group and that of its children. 551df8bae1dSRodney W. Grimes * entering == 0 => p is leaving specified group. 552df8bae1dSRodney W. Grimes * entering == 1 => p is entering specified group. 553df8bae1dSRodney W. Grimes */ 55426f9a767SRodney W. Grimes void 555df8bae1dSRodney W. Grimes fixjobc(p, pgrp, entering) 556df8bae1dSRodney W. Grimes register struct proc *p; 557df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 558df8bae1dSRodney W. Grimes int entering; 559df8bae1dSRodney W. Grimes { 560df8bae1dSRodney W. Grimes register struct pgrp *hispgrp; 561f591779bSSeigo Tanimura register struct session *mysession; 562f591779bSSeigo Tanimura 563f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_LOCKED); 564f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 565f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 566f591779bSSeigo Tanimura SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 567df8bae1dSRodney W. Grimes 568df8bae1dSRodney W. Grimes /* 569df8bae1dSRodney W. Grimes * Check p's parent to see whether p qualifies its own process 570df8bae1dSRodney W. Grimes * group; if so, adjust count for p's process group. 571df8bae1dSRodney W. Grimes */ 572f591779bSSeigo Tanimura mysession = pgrp->pg_session; 573df8bae1dSRodney W. Grimes if ((hispgrp = p->p_pptr->p_pgrp) != pgrp && 57402e878d9SJohn Baldwin hispgrp->pg_session == mysession) 57502e878d9SJohn Baldwin pgadjustjobc(pgrp, entering); 576df8bae1dSRodney W. Grimes 577df8bae1dSRodney W. Grimes /* 578df8bae1dSRodney W. Grimes * Check this process' children to see whether they qualify 579df8bae1dSRodney W. Grimes * their process groups; if so, adjust counts for children's 580df8bae1dSRodney W. Grimes * process groups. 581df8bae1dSRodney W. Grimes */ 582f591779bSSeigo Tanimura LIST_FOREACH(p, &p->p_children, p_sibling) { 58302e878d9SJohn Baldwin hispgrp = p->p_pgrp; 58402e878d9SJohn Baldwin if (hispgrp == pgrp || 58502e878d9SJohn Baldwin hispgrp->pg_session != mysession) 58602e878d9SJohn Baldwin continue; 58702e878d9SJohn Baldwin PROC_LOCK(p); 58802e878d9SJohn Baldwin if (p->p_state == PRS_ZOMBIE) { 58902e878d9SJohn Baldwin PROC_UNLOCK(p); 59002e878d9SJohn Baldwin continue; 591df8bae1dSRodney W. Grimes } 59202e878d9SJohn Baldwin PROC_UNLOCK(p); 59302e878d9SJohn Baldwin pgadjustjobc(hispgrp, entering); 594f591779bSSeigo Tanimura } 595dfd5dee1SPeter Wemm } 596df8bae1dSRodney W. Grimes 597df8bae1dSRodney W. Grimes /* 598df8bae1dSRodney W. Grimes * A process group has become orphaned; 599df8bae1dSRodney W. Grimes * if there are any stopped processes in the group, 600df8bae1dSRodney W. Grimes * hang-up all process in that group. 601df8bae1dSRodney W. Grimes */ 602df8bae1dSRodney W. Grimes static void 603df8bae1dSRodney W. Grimes orphanpg(pg) 604df8bae1dSRodney W. Grimes struct pgrp *pg; 605df8bae1dSRodney W. Grimes { 606df8bae1dSRodney W. Grimes register struct proc *p; 607df8bae1dSRodney W. Grimes 608f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pg, MA_OWNED); 609f591779bSSeigo Tanimura 6101b727751SPoul-Henning Kamp LIST_FOREACH(p, &pg->pg_members, p_pglist) { 61102e878d9SJohn Baldwin PROC_LOCK(p); 612e602ba25SJulian Elischer if (P_SHOULDSTOP(p)) { 61302e878d9SJohn Baldwin PROC_UNLOCK(p); 6141b727751SPoul-Henning Kamp LIST_FOREACH(p, &pg->pg_members, p_pglist) { 61515e9ec51SJohn Baldwin PROC_LOCK(p); 6168451d0ddSKip Macy kern_psignal(p, SIGHUP); 6178451d0ddSKip Macy kern_psignal(p, SIGCONT); 61815e9ec51SJohn Baldwin PROC_UNLOCK(p); 619df8bae1dSRodney W. Grimes } 620df8bae1dSRodney W. Grimes return; 621df8bae1dSRodney W. Grimes } 62202e878d9SJohn Baldwin PROC_UNLOCK(p); 623df8bae1dSRodney W. Grimes } 624df8bae1dSRodney W. Grimes } 625df8bae1dSRodney W. Grimes 626572b4402SPoul-Henning Kamp void 627bc093719SEd Schouten sess_hold(struct session *s) 628572b4402SPoul-Henning Kamp { 629572b4402SPoul-Henning Kamp 630bc093719SEd Schouten refcount_acquire(&s->s_count); 631bc093719SEd Schouten } 632bc093719SEd Schouten 633bc093719SEd Schouten void 634bc093719SEd Schouten sess_release(struct session *s) 635bc093719SEd Schouten { 636bc093719SEd Schouten 637bc093719SEd Schouten if (refcount_release(&s->s_count)) { 638bc093719SEd Schouten if (s->s_ttyp != NULL) { 639bc093719SEd Schouten tty_lock(s->s_ttyp); 640bc093719SEd Schouten tty_rel_sess(s->s_ttyp, s); 641bc093719SEd Schouten } 642572b4402SPoul-Henning Kamp mtx_destroy(&s->s_mtx); 6431ede983cSDag-Erling Smørgrav free(s, M_SESSION); 644572b4402SPoul-Henning Kamp } 645572b4402SPoul-Henning Kamp } 646572b4402SPoul-Henning Kamp 647831031ceSBruce Evans #include "opt_ddb.h" 648831031ceSBruce Evans #ifdef DDB 649831031ceSBruce Evans #include <ddb/ddb.h> 650831031ceSBruce Evans 651831031ceSBruce Evans DB_SHOW_COMMAND(pgrpdump, pgrpdump) 652df8bae1dSRodney W. Grimes { 653df8bae1dSRodney W. Grimes register struct pgrp *pgrp; 654df8bae1dSRodney W. Grimes register struct proc *p; 655876a94eeSBruce Evans register int i; 656df8bae1dSRodney W. Grimes 657b75356e1SJeffrey Hsu for (i = 0; i <= pgrphash; i++) { 6581b727751SPoul-Henning Kamp if (!LIST_EMPTY(&pgrphashtbl[i])) { 659df8bae1dSRodney W. Grimes printf("\tindx %d\n", i); 6601b727751SPoul-Henning Kamp LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { 661ac1e407bSBruce Evans printf( 662ac1e407bSBruce Evans "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n", 663ac1e407bSBruce Evans (void *)pgrp, (long)pgrp->pg_id, 664ac1e407bSBruce Evans (void *)pgrp->pg_session, 665b75356e1SJeffrey Hsu pgrp->pg_session->s_count, 6661b727751SPoul-Henning Kamp (void *)LIST_FIRST(&pgrp->pg_members)); 6671b727751SPoul-Henning Kamp LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 668ac1e407bSBruce Evans printf("\t\tpid %ld addr %p pgrp %p\n", 669ac1e407bSBruce Evans (long)p->p_pid, (void *)p, 670ac1e407bSBruce Evans (void *)p->p_pgrp); 671df8bae1dSRodney W. Grimes } 672df8bae1dSRodney W. Grimes } 673df8bae1dSRodney W. Grimes } 674df8bae1dSRodney W. Grimes } 675df8bae1dSRodney W. Grimes } 676831031ceSBruce Evans #endif /* DDB */ 677972f9b20SPoul-Henning Kamp 678972f9b20SPoul-Henning Kamp /* 679f8d90480SAttilio Rao * Calculate the kinfo_proc members which contain process-wide 680f8d90480SAttilio Rao * informations. 681f8d90480SAttilio Rao * Must be called with the target process locked. 682f8d90480SAttilio Rao */ 683f8d90480SAttilio Rao static void 684f8d90480SAttilio Rao fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp) 685f8d90480SAttilio Rao { 686f8d90480SAttilio Rao struct thread *td; 687f8d90480SAttilio Rao 688f8d90480SAttilio Rao PROC_LOCK_ASSERT(p, MA_OWNED); 689f8d90480SAttilio Rao 690f8d90480SAttilio Rao kp->ki_estcpu = 0; 691f8d90480SAttilio Rao kp->ki_pctcpu = 0; 692f8d90480SAttilio Rao FOREACH_THREAD_IN_PROC(p, td) { 693f8d90480SAttilio Rao thread_lock(td); 694f8d90480SAttilio Rao kp->ki_pctcpu += sched_pctcpu(td); 695f8d90480SAttilio Rao kp->ki_estcpu += td->td_estcpu; 696f8d90480SAttilio Rao thread_unlock(td); 697f8d90480SAttilio Rao } 698f8d90480SAttilio Rao } 699f8d90480SAttilio Rao 700f8d90480SAttilio Rao /* 7015032ff81SDon Lewis * Clear kinfo_proc and fill in any information that is common 7025032ff81SDon Lewis * to all threads in the process. 70365c9b430SJohn Baldwin * Must be called with the target process locked. 704972f9b20SPoul-Henning Kamp */ 7055032ff81SDon Lewis static void 7065032ff81SDon Lewis fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp) 707972f9b20SPoul-Henning Kamp { 7084093529dSJeff Roberson struct thread *td0; 7091f7d2501SKirk McKusick struct tty *tp; 7101f7d2501SKirk McKusick struct session *sp; 711d079d0a0SPawel Jakub Dawidek struct ucred *cred; 71290af4afaSJohn Baldwin struct sigacts *ps; 713972f9b20SPoul-Henning Kamp 714374ae2a3SJeff Roberson PROC_LOCK_ASSERT(p, MA_OWNED); 7151f7d2501SKirk McKusick bzero(kp, sizeof(*kp)); 716972f9b20SPoul-Henning Kamp 7171f7d2501SKirk McKusick kp->ki_structsize = sizeof(*kp); 7181f7d2501SKirk McKusick kp->ki_paddr = p; 7196617724cSJeff Roberson kp->ki_addr =/* p->p_addr; */0; /* XXX */ 7201f7d2501SKirk McKusick kp->ki_args = p->p_args; 7211f7d2501SKirk McKusick kp->ki_textvp = p->p_textvp; 7226c84de02SJohn Baldwin #ifdef KTRACE 723a5881ea5SJohn Baldwin kp->ki_tracep = p->p_tracevp; 7246c84de02SJohn Baldwin kp->ki_traceflag = p->p_traceflag; 7256c84de02SJohn Baldwin #endif 7261f7d2501SKirk McKusick kp->ki_fd = p->p_fd; 7271f7d2501SKirk McKusick kp->ki_vmspace = p->p_vmspace; 728cefcecbeSPawel Jakub Dawidek kp->ki_flag = p->p_flag; 729d079d0a0SPawel Jakub Dawidek cred = p->p_ucred; 730d079d0a0SPawel Jakub Dawidek if (cred) { 731d079d0a0SPawel Jakub Dawidek kp->ki_uid = cred->cr_uid; 732d079d0a0SPawel Jakub Dawidek kp->ki_ruid = cred->cr_ruid; 733d079d0a0SPawel Jakub Dawidek kp->ki_svuid = cred->cr_svuid; 73496fcc75fSRobert Watson kp->ki_cr_flags = 0; 73596fcc75fSRobert Watson if (cred->cr_flags & CRED_FLAG_CAPMODE) 73696fcc75fSRobert Watson kp->ki_cr_flags |= KI_CRF_CAPABILITY_MODE; 7371b5768beSBrooks Davis /* XXX bde doesn't like KI_NGROUPS */ 7381b5768beSBrooks Davis if (cred->cr_ngroups > KI_NGROUPS) { 7391b5768beSBrooks Davis kp->ki_ngroups = KI_NGROUPS; 7401b5768beSBrooks Davis kp->ki_cr_flags |= KI_CRF_GRP_OVERFLOW; 7411b5768beSBrooks Davis } else 742838d9858SBrooks Davis kp->ki_ngroups = cred->cr_ngroups; 7431b5768beSBrooks Davis bcopy(cred->cr_groups, kp->ki_groups, 7441b5768beSBrooks Davis kp->ki_ngroups * sizeof(gid_t)); 745d079d0a0SPawel Jakub Dawidek kp->ki_rgid = cred->cr_rgid; 746d079d0a0SPawel Jakub Dawidek kp->ki_svgid = cred->cr_svgid; 747cefcecbeSPawel Jakub Dawidek /* If jailed(cred), emulate the old P_JAILED flag. */ 748c78941e6SPawel Jakub Dawidek if (jailed(cred)) { 749cefcecbeSPawel Jakub Dawidek kp->ki_flag |= P_JAILED; 7500304c731SJamie Gritton /* If inside the jail, use 0 as a jail ID. */ 7510304c731SJamie Gritton if (cred->cr_prison != curthread->td_ucred->cr_prison) 752c78941e6SPawel Jakub Dawidek kp->ki_jid = cred->cr_prison->pr_id; 753c78941e6SPawel Jakub Dawidek } 7547123f4cdSEdward Tomasz Napierala strlcpy(kp->ki_loginclass, cred->cr_loginclass->lc_name, 7557123f4cdSEdward Tomasz Napierala sizeof(kp->ki_loginclass)); 756972f9b20SPoul-Henning Kamp } 75790af4afaSJohn Baldwin ps = p->p_sigacts; 758d079d0a0SPawel Jakub Dawidek if (ps) { 75990af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 76090af4afaSJohn Baldwin kp->ki_sigignore = ps->ps_sigignore; 76190af4afaSJohn Baldwin kp->ki_sigcatch = ps->ps_sigcatch; 76290af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 763d8c85307SJulian Elischer } 764e602ba25SJulian Elischer if (p->p_state != PRS_NEW && 765e602ba25SJulian Elischer p->p_state != PRS_ZOMBIE && 766e602ba25SJulian Elischer p->p_vmspace != NULL) { 7671f7d2501SKirk McKusick struct vmspace *vm = p->p_vmspace; 768cd73303cSDavid Greenman 7691f7d2501SKirk McKusick kp->ki_size = vm->vm_map.size; 7701f7d2501SKirk McKusick kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/ 771ceff7f2aSTim J. Robbins FOREACH_THREAD_IN_PROC(p, td0) { 772ceff7f2aSTim J. Robbins if (!TD_IS_SWAPPED(td0)) 773ceff7f2aSTim J. Robbins kp->ki_rssize += td0->td_kstack_pages; 774ceff7f2aSTim J. Robbins } 7751f7d2501SKirk McKusick kp->ki_swrss = vm->vm_swrss; 7761f7d2501SKirk McKusick kp->ki_tsize = vm->vm_tsize; 7771f7d2501SKirk McKusick kp->ki_dsize = vm->vm_dsize; 7781f7d2501SKirk McKusick kp->ki_ssize = vm->vm_ssize; 7795032ff81SDon Lewis } else if (p->p_state == PRS_ZOMBIE) 7805032ff81SDon Lewis kp->ki_stat = SZOMB; 781b61ce5b0SJeff Roberson if (kp->ki_flag & P_INMEM) 782b61ce5b0SJeff Roberson kp->ki_sflag = PS_INMEM; 783b61ce5b0SJeff Roberson else 784b61ce5b0SJeff Roberson kp->ki_sflag = 0; 78554b0e65fSJeff Roberson /* Calculate legacy swtime as seconds since 'swtick'. */ 78654b0e65fSJeff Roberson kp->ki_swtime = (ticks - p->p_swtick) / hz; 787cebabef0SPawel Jakub Dawidek kp->ki_pid = p->p_pid; 788cebabef0SPawel Jakub Dawidek kp->ki_nice = p->p_nice; 78978c85e8dSJohn Baldwin kp->ki_start = p->p_stats->p_start; 79078c85e8dSJohn Baldwin timevaladd(&kp->ki_start, &boottime); 791a1fe14bcSAttilio Rao PROC_SLOCK(p); 7928e6fa660SJohn Baldwin rufetch(p, &kp->ki_rusage); 7938e6fa660SJohn Baldwin kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime); 79478c85e8dSJohn Baldwin calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime); 795a1fe14bcSAttilio Rao PROC_SUNLOCK(p); 79678c85e8dSJohn Baldwin calccru(p, &kp->ki_childutime, &kp->ki_childstime); 797a37e14e1SEdward Tomasz Napierala /* Some callers want child times in a single value. */ 79878c85e8dSJohn Baldwin kp->ki_childtime = kp->ki_childstime; 79978c85e8dSJohn Baldwin timevaladd(&kp->ki_childtime, &kp->ki_childutime); 800a37e14e1SEdward Tomasz Napierala 801f591779bSSeigo Tanimura tp = NULL; 8021f7d2501SKirk McKusick if (p->p_pgrp) { 8031f7d2501SKirk McKusick kp->ki_pgid = p->p_pgrp->pg_id; 8041f7d2501SKirk McKusick kp->ki_jobc = p->p_pgrp->pg_jobc; 8051f7d2501SKirk McKusick sp = p->p_pgrp->pg_session; 8061f7d2501SKirk McKusick 8071f7d2501SKirk McKusick if (sp != NULL) { 8081f7d2501SKirk McKusick kp->ki_sid = sp->s_sid; 809f591779bSSeigo Tanimura SESS_LOCK(sp); 810e80fb434SRobert Drehmel strlcpy(kp->ki_login, sp->s_login, 811e80fb434SRobert Drehmel sizeof(kp->ki_login)); 8121f7d2501SKirk McKusick if (sp->s_ttyvp) 813b8e6bf1eSJohn Baldwin kp->ki_kiflag |= KI_CTTY; 8141f7d2501SKirk McKusick if (SESS_LEADER(p)) 8151f7d2501SKirk McKusick kp->ki_kiflag |= KI_SLEADER; 816bc093719SEd Schouten /* XXX proctree_lock */ 817f591779bSSeigo Tanimura tp = sp->s_ttyp; 818f591779bSSeigo Tanimura SESS_UNLOCK(sp); 819cd73303cSDavid Greenman } 820cd73303cSDavid Greenman } 821f591779bSSeigo Tanimura if ((p->p_flag & P_CONTROLT) && tp != NULL) { 822bc093719SEd Schouten kp->ki_tdev = tty_udev(tp); 8231f7d2501SKirk McKusick kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 8241f7d2501SKirk McKusick if (tp->t_session) 8251f7d2501SKirk McKusick kp->ki_tsid = tp->t_session->s_sid; 826972f9b20SPoul-Henning Kamp } else 827f3732fd1SPoul-Henning Kamp kp->ki_tdev = NODEV; 82813b762a3SEd Maste if (p->p_comm[0] != '\0') 829e80fb434SRobert Drehmel strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm)); 830078842c5SGarance A Drosehn if (p->p_sysent && p->p_sysent->sv_name != NULL && 831078842c5SGarance A Drosehn p->p_sysent->sv_name[0] != '\0') 832078842c5SGarance A Drosehn strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul)); 8331d9c5696SJuli Mallett kp->ki_siglist = p->p_siglist; 8341f7d2501SKirk McKusick kp->ki_xstat = p->p_xstat; 8351f7d2501SKirk McKusick kp->ki_acflag = p->p_acflag; 8361f7d2501SKirk McKusick kp->ki_lock = p->p_lock; 83742a4ed99SJohn Baldwin if (p->p_pptr) 83842a4ed99SJohn Baldwin kp->ki_ppid = p->p_pptr->p_pid; 839972f9b20SPoul-Henning Kamp } 840972f9b20SPoul-Henning Kamp 8415032ff81SDon Lewis /* 84200305546SKonstantin Belousov * Fill in information that is thread specific. Must be called with 84300305546SKonstantin Belousov * target process locked. If 'preferthread' is set, overwrite certain 84400305546SKonstantin Belousov * process-related fields that are maintained for both threads and 84500305546SKonstantin Belousov * processes. 8465032ff81SDon Lewis */ 8475032ff81SDon Lewis static void 848d92909c1SRobert Watson fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread) 8495032ff81SDon Lewis { 8505032ff81SDon Lewis struct proc *p; 8515032ff81SDon Lewis 8525032ff81SDon Lewis p = td->td_proc; 8536239ef1dSEd Maste kp->ki_tdaddr = td; 854374ae2a3SJeff Roberson PROC_LOCK_ASSERT(p, MA_OWNED); 8555032ff81SDon Lewis 8562417d97eSJohn Baldwin if (preferthread) 8572417d97eSJohn Baldwin PROC_SLOCK(p); 858982d11f8SJeff Roberson thread_lock(td); 8595032ff81SDon Lewis if (td->td_wmesg != NULL) 8605032ff81SDon Lewis strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg)); 8615032ff81SDon Lewis else 8625032ff81SDon Lewis bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg)); 863925af544SBjoern A. Zeeb strlcpy(kp->ki_tdname, td->td_name, sizeof(kp->ki_tdname)); 8645032ff81SDon Lewis if (TD_ON_LOCK(td)) { 8655032ff81SDon Lewis kp->ki_kiflag |= KI_LOCKBLOCK; 8665032ff81SDon Lewis strlcpy(kp->ki_lockname, td->td_lockname, 8675032ff81SDon Lewis sizeof(kp->ki_lockname)); 8685032ff81SDon Lewis } else { 8695032ff81SDon Lewis kp->ki_kiflag &= ~KI_LOCKBLOCK; 8705032ff81SDon Lewis bzero(kp->ki_lockname, sizeof(kp->ki_lockname)); 8715032ff81SDon Lewis } 8725032ff81SDon Lewis 8736617724cSJeff Roberson if (p->p_state == PRS_NORMAL) { /* approximate. */ 8745032ff81SDon Lewis if (TD_ON_RUNQ(td) || 8755032ff81SDon Lewis TD_CAN_RUN(td) || 8765032ff81SDon Lewis TD_IS_RUNNING(td)) { 8775032ff81SDon Lewis kp->ki_stat = SRUN; 8785032ff81SDon Lewis } else if (P_SHOULDSTOP(p)) { 8795032ff81SDon Lewis kp->ki_stat = SSTOP; 8805032ff81SDon Lewis } else if (TD_IS_SLEEPING(td)) { 8815032ff81SDon Lewis kp->ki_stat = SSLEEP; 8825032ff81SDon Lewis } else if (TD_ON_LOCK(td)) { 8835032ff81SDon Lewis kp->ki_stat = SLOCK; 8845032ff81SDon Lewis } else { 8855032ff81SDon Lewis kp->ki_stat = SWAIT; 8865032ff81SDon Lewis } 8873357835aSDavid Xu } else if (p->p_state == PRS_ZOMBIE) { 8883357835aSDavid Xu kp->ki_stat = SZOMB; 8895032ff81SDon Lewis } else { 8905032ff81SDon Lewis kp->ki_stat = SIDL; 8915032ff81SDon Lewis } 8925032ff81SDon Lewis 8935032ff81SDon Lewis /* Things in the thread */ 8945032ff81SDon Lewis kp->ki_wchan = td->td_wchan; 8955032ff81SDon Lewis kp->ki_pri.pri_level = td->td_priority; 8965032ff81SDon Lewis kp->ki_pri.pri_native = td->td_base_pri; 8975032ff81SDon Lewis kp->ki_lastcpu = td->td_lastcpu; 8985032ff81SDon Lewis kp->ki_oncpu = td->td_oncpu; 8995032ff81SDon Lewis kp->ki_tdflags = td->td_flags; 9005032ff81SDon Lewis kp->ki_tid = td->td_tid; 9015032ff81SDon Lewis kp->ki_numthreads = p->p_numthreads; 9025032ff81SDon Lewis kp->ki_pcb = td->td_pcb; 9035032ff81SDon Lewis kp->ki_kstack = (void *)td->td_kstack; 90454b0e65fSJeff Roberson kp->ki_slptime = (ticks - td->td_slptick) / hz; 9058460a577SJohn Birrell kp->ki_pri.pri_class = td->td_pri_class; 9068460a577SJohn Birrell kp->ki_pri.pri_user = td->td_user_pri; 9075032ff81SDon Lewis 908f8d90480SAttilio Rao if (preferthread) { 9092417d97eSJohn Baldwin rufetchtd(td, &kp->ki_rusage); 910213c077fSKonstantin Belousov kp->ki_runtime = cputick2usec(td->td_rux.rux_runtime); 911f8d90480SAttilio Rao kp->ki_pctcpu = sched_pctcpu(td); 912f8d90480SAttilio Rao kp->ki_estcpu = td->td_estcpu; 913f8d90480SAttilio Rao } 914d92909c1SRobert Watson 9155032ff81SDon Lewis /* We can't get this anymore but ps etc never used it anyway. */ 9165032ff81SDon Lewis kp->ki_rqindex = 0; 9175032ff81SDon Lewis 91800305546SKonstantin Belousov if (preferthread) 91900305546SKonstantin Belousov kp->ki_siglist = td->td_siglist; 9205032ff81SDon Lewis kp->ki_sigmask = td->td_sigmask; 921982d11f8SJeff Roberson thread_unlock(td); 9222417d97eSJohn Baldwin if (preferthread) 9232417d97eSJohn Baldwin PROC_SUNLOCK(p); 9245032ff81SDon Lewis } 9255032ff81SDon Lewis 9265032ff81SDon Lewis /* 9275032ff81SDon Lewis * Fill in a kinfo_proc structure for the specified process. 9285032ff81SDon Lewis * Must be called with the target process locked. 9295032ff81SDon Lewis */ 9305032ff81SDon Lewis void 9315032ff81SDon Lewis fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp) 9325032ff81SDon Lewis { 9335032ff81SDon Lewis 934f8d90480SAttilio Rao MPASS(FIRST_THREAD_IN_PROC(p) != NULL); 935f8d90480SAttilio Rao 9365032ff81SDon Lewis fill_kinfo_proc_only(p, kp); 937d92909c1SRobert Watson fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0); 938f8d90480SAttilio Rao fill_kinfo_aggregate(p, kp); 9395032ff81SDon Lewis } 9405032ff81SDon Lewis 9418b059651SDavid Schultz struct pstats * 9428b059651SDavid Schultz pstats_alloc(void) 9438b059651SDavid Schultz { 9448b059651SDavid Schultz 9458b059651SDavid Schultz return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK)); 9468b059651SDavid Schultz } 9478b059651SDavid Schultz 9488b059651SDavid Schultz /* 9498b059651SDavid Schultz * Copy parts of p_stats; zero the rest of p_stats (statistics). 9508b059651SDavid Schultz */ 9518b059651SDavid Schultz void 9528b059651SDavid Schultz pstats_fork(struct pstats *src, struct pstats *dst) 9538b059651SDavid Schultz { 9548b059651SDavid Schultz 9558b059651SDavid Schultz bzero(&dst->pstat_startzero, 9566db36923SDavid Schultz __rangeof(struct pstats, pstat_startzero, pstat_endzero)); 9578b059651SDavid Schultz bcopy(&src->pstat_startcopy, &dst->pstat_startcopy, 9586db36923SDavid Schultz __rangeof(struct pstats, pstat_startcopy, pstat_endcopy)); 9598b059651SDavid Schultz } 9608b059651SDavid Schultz 9618b059651SDavid Schultz void 9628b059651SDavid Schultz pstats_free(struct pstats *ps) 9638b059651SDavid Schultz { 9648b059651SDavid Schultz 9658b059651SDavid Schultz free(ps, M_SUBPROC); 9668b059651SDavid Schultz } 9678b059651SDavid Schultz 9688b059651SDavid Schultz /* 96942a4ed99SJohn Baldwin * Locate a zombie process by number 97042a4ed99SJohn Baldwin */ 97142a4ed99SJohn Baldwin struct proc * 9723ce93e4eSPoul-Henning Kamp zpfind(pid_t pid) 9733ce93e4eSPoul-Henning Kamp { 9743ce93e4eSPoul-Henning Kamp struct proc *p; 9753ce93e4eSPoul-Henning Kamp 9761005a129SJohn Baldwin sx_slock(&allproc_lock); 9771b727751SPoul-Henning Kamp LIST_FOREACH(p, &zombproc, p_list) 97833a9ed9dSJohn Baldwin if (p->p_pid == pid) { 97933a9ed9dSJohn Baldwin PROC_LOCK(p); 980c0c25570SJake Burkholder break; 98133a9ed9dSJohn Baldwin } 9821005a129SJohn Baldwin sx_sunlock(&allproc_lock); 9833ce93e4eSPoul-Henning Kamp return (p); 9843ce93e4eSPoul-Henning Kamp } 9853ce93e4eSPoul-Henning Kamp 98630c6f34eSScott Long #define KERN_PROC_ZOMBMASK 0x3 98730c6f34eSScott Long #define KERN_PROC_NOTHREADS 0x4 9883ce93e4eSPoul-Henning Kamp 98905e06d11SKonstantin Belousov #ifdef COMPAT_FREEBSD32 99005e06d11SKonstantin Belousov 99105e06d11SKonstantin Belousov /* 99205e06d11SKonstantin Belousov * This function is typically used to copy out the kernel address, so 99305e06d11SKonstantin Belousov * it can be replaced by assignment of zero. 99405e06d11SKonstantin Belousov */ 99505e06d11SKonstantin Belousov static inline uint32_t 99605e06d11SKonstantin Belousov ptr32_trim(void *ptr) 99705e06d11SKonstantin Belousov { 99805e06d11SKonstantin Belousov uintptr_t uptr; 99905e06d11SKonstantin Belousov 100005e06d11SKonstantin Belousov uptr = (uintptr_t)ptr; 100105e06d11SKonstantin Belousov return ((uptr > UINT_MAX) ? 0 : uptr); 100205e06d11SKonstantin Belousov } 100305e06d11SKonstantin Belousov 100405e06d11SKonstantin Belousov #define PTRTRIM_CP(src,dst,fld) \ 100505e06d11SKonstantin Belousov do { (dst).fld = ptr32_trim((src).fld); } while (0) 100605e06d11SKonstantin Belousov 100705e06d11SKonstantin Belousov static void 100805e06d11SKonstantin Belousov freebsd32_kinfo_proc_out(const struct kinfo_proc *ki, struct kinfo_proc32 *ki32) 100905e06d11SKonstantin Belousov { 101005e06d11SKonstantin Belousov int i; 101105e06d11SKonstantin Belousov 101205e06d11SKonstantin Belousov bzero(ki32, sizeof(struct kinfo_proc32)); 101305e06d11SKonstantin Belousov ki32->ki_structsize = sizeof(struct kinfo_proc32); 101405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_layout); 101505e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_args); 101605e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_paddr); 101705e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_addr); 101805e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_tracep); 101905e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_textvp); 102005e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_fd); 102105e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_vmspace); 102205e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_wchan); 102305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pid); 102405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ppid); 102505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pgid); 102605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tpgid); 102705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sid); 102805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tsid); 102905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_jobc); 103005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tdev); 103105e06d11SKonstantin Belousov CP(*ki, *ki32, ki_siglist); 103205e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sigmask); 103305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sigignore); 103405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sigcatch); 103505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_uid); 103605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ruid); 103705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_svuid); 103805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_rgid); 103905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_svgid); 104005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ngroups); 104105e06d11SKonstantin Belousov for (i = 0; i < KI_NGROUPS; i++) 104205e06d11SKonstantin Belousov CP(*ki, *ki32, ki_groups[i]); 104305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_size); 104405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_rssize); 104505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_swrss); 104605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tsize); 104705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_dsize); 104805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ssize); 104905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_xstat); 105005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_acflag); 105105e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pctcpu); 105205e06d11SKonstantin Belousov CP(*ki, *ki32, ki_estcpu); 105305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_slptime); 105405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_swtime); 105505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_runtime); 105605e06d11SKonstantin Belousov TV_CP(*ki, *ki32, ki_start); 105705e06d11SKonstantin Belousov TV_CP(*ki, *ki32, ki_childtime); 105805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_flag); 105905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_kiflag); 106005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_traceflag); 106105e06d11SKonstantin Belousov CP(*ki, *ki32, ki_stat); 106205e06d11SKonstantin Belousov CP(*ki, *ki32, ki_nice); 106305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_lock); 106405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_rqindex); 106505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_oncpu); 106605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_lastcpu); 1067925af544SBjoern A. Zeeb bcopy(ki->ki_tdname, ki32->ki_tdname, TDNAMLEN + 1); 106805e06d11SKonstantin Belousov bcopy(ki->ki_wmesg, ki32->ki_wmesg, WMESGLEN + 1); 106905e06d11SKonstantin Belousov bcopy(ki->ki_login, ki32->ki_login, LOGNAMELEN + 1); 107005e06d11SKonstantin Belousov bcopy(ki->ki_lockname, ki32->ki_lockname, LOCKNAMELEN + 1); 107105e06d11SKonstantin Belousov bcopy(ki->ki_comm, ki32->ki_comm, COMMLEN + 1); 107205e06d11SKonstantin Belousov bcopy(ki->ki_emul, ki32->ki_emul, KI_EMULNAMELEN + 1); 10737123f4cdSEdward Tomasz Napierala bcopy(ki->ki_loginclass, ki32->ki_loginclass, LOGINCLASSLEN + 1); 107405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_cr_flags); 107505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_jid); 107605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_numthreads); 107705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tid); 107805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pri); 107905e06d11SKonstantin Belousov freebsd32_rusage_out(&ki->ki_rusage, &ki32->ki_rusage); 108005e06d11SKonstantin Belousov freebsd32_rusage_out(&ki->ki_rusage_ch, &ki32->ki_rusage_ch); 108105e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_pcb); 108205e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_kstack); 108305e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_udata); 108405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sflag); 108505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tdflags); 108605e06d11SKonstantin Belousov } 108705e06d11SKonstantin Belousov 108805e06d11SKonstantin Belousov static int 108905e06d11SKonstantin Belousov sysctl_out_proc_copyout(struct kinfo_proc *ki, struct sysctl_req *req) 109005e06d11SKonstantin Belousov { 109105e06d11SKonstantin Belousov struct kinfo_proc32 ki32; 109205e06d11SKonstantin Belousov int error; 109305e06d11SKonstantin Belousov 109405e06d11SKonstantin Belousov if (req->flags & SCTL_MASK32) { 109505e06d11SKonstantin Belousov freebsd32_kinfo_proc_out(ki, &ki32); 1096e68d26fdSKonstantin Belousov error = SYSCTL_OUT(req, &ki32, sizeof(struct kinfo_proc32)); 109705e06d11SKonstantin Belousov } else 1098e68d26fdSKonstantin Belousov error = SYSCTL_OUT(req, ki, sizeof(struct kinfo_proc)); 109905e06d11SKonstantin Belousov return (error); 110005e06d11SKonstantin Belousov } 110105e06d11SKonstantin Belousov #else 110205e06d11SKonstantin Belousov static int 110305e06d11SKonstantin Belousov sysctl_out_proc_copyout(struct kinfo_proc *ki, struct sysctl_req *req) 110405e06d11SKonstantin Belousov { 110505e06d11SKonstantin Belousov 1106e68d26fdSKonstantin Belousov return (SYSCTL_OUT(req, ki, sizeof(struct kinfo_proc))); 110705e06d11SKonstantin Belousov } 110805e06d11SKonstantin Belousov #endif 110905e06d11SKonstantin Belousov 111065c9b430SJohn Baldwin /* 111165c9b430SJohn Baldwin * Must be called with the process locked and will return with it unlocked. 111265c9b430SJohn Baldwin */ 11133ce93e4eSPoul-Henning Kamp static int 111430c6f34eSScott Long sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags) 11153ce93e4eSPoul-Henning Kamp { 111630c6f34eSScott Long struct thread *td; 11171f7d2501SKirk McKusick struct kinfo_proc kinfo_proc; 111830c6f34eSScott Long int error = 0; 111933a9ed9dSJohn Baldwin struct proc *np; 11203ce93e4eSPoul-Henning Kamp pid_t pid = p->p_pid; 11213ce93e4eSPoul-Henning Kamp 112265c9b430SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 1123f8d90480SAttilio Rao MPASS(FIRST_THREAD_IN_PROC(p) != NULL); 112430c6f34eSScott Long 1125f8d90480SAttilio Rao fill_kinfo_proc(p, &kinfo_proc); 1126f8d90480SAttilio Rao if (flags & KERN_PROC_NOTHREADS) 112705e06d11SKonstantin Belousov error = sysctl_out_proc_copyout(&kinfo_proc, req); 1128f8d90480SAttilio Rao else { 112930c6f34eSScott Long FOREACH_THREAD_IN_PROC(p, td) { 1130d92909c1SRobert Watson fill_kinfo_thread(td, &kinfo_proc, 1); 113105e06d11SKonstantin Belousov error = sysctl_out_proc_copyout(&kinfo_proc, req); 113230c6f34eSScott Long if (error) 113330c6f34eSScott Long break; 113430c6f34eSScott Long } 113530c6f34eSScott Long } 113630c6f34eSScott Long PROC_UNLOCK(p); 11373ce93e4eSPoul-Henning Kamp if (error) 11383ce93e4eSPoul-Henning Kamp return (error); 113930c6f34eSScott Long if (flags & KERN_PROC_ZOMBMASK) 114033a9ed9dSJohn Baldwin np = zpfind(pid); 114133a9ed9dSJohn Baldwin else { 114233a9ed9dSJohn Baldwin if (pid == 0) 114333a9ed9dSJohn Baldwin return (0); 114433a9ed9dSJohn Baldwin np = pfind(pid); 114533a9ed9dSJohn Baldwin } 114633a9ed9dSJohn Baldwin if (np == NULL) 1147f308bdddSKevin Lo return (ESRCH); 114833a9ed9dSJohn Baldwin if (np != p) { 114933a9ed9dSJohn Baldwin PROC_UNLOCK(np); 1150f308bdddSKevin Lo return (ESRCH); 115133a9ed9dSJohn Baldwin } 115233a9ed9dSJohn Baldwin PROC_UNLOCK(np); 11533ce93e4eSPoul-Henning Kamp return (0); 11543ce93e4eSPoul-Henning Kamp } 11553ce93e4eSPoul-Henning Kamp 1156972f9b20SPoul-Henning Kamp static int 115782d9ae4eSPoul-Henning Kamp sysctl_kern_proc(SYSCTL_HANDLER_ARGS) 1158972f9b20SPoul-Henning Kamp { 1159972f9b20SPoul-Henning Kamp int *name = (int*) arg1; 1160972f9b20SPoul-Henning Kamp u_int namelen = arg2; 1161972f9b20SPoul-Henning Kamp struct proc *p; 11622648efa6SDaniel Eischen int flags, doingzomb, oid_number; 1163972f9b20SPoul-Henning Kamp int error = 0; 1164972f9b20SPoul-Henning Kamp 11652648efa6SDaniel Eischen oid_number = oidp->oid_number; 11662648efa6SDaniel Eischen if (oid_number != KERN_PROC_ALL && 11672648efa6SDaniel Eischen (oid_number & KERN_PROC_INC_THREAD) == 0) 11682648efa6SDaniel Eischen flags = KERN_PROC_NOTHREADS; 11692648efa6SDaniel Eischen else { 11702648efa6SDaniel Eischen flags = 0; 11712648efa6SDaniel Eischen oid_number &= ~KERN_PROC_INC_THREAD; 11722648efa6SDaniel Eischen } 11732648efa6SDaniel Eischen if (oid_number == KERN_PROC_PID) { 11743ce93e4eSPoul-Henning Kamp if (namelen != 1) 1175972f9b20SPoul-Henning Kamp return (EINVAL); 11765032ff81SDon Lewis error = sysctl_wire_old_buffer(req, 0); 11775032ff81SDon Lewis if (error) 11785032ff81SDon Lewis return (error); 11793ce93e4eSPoul-Henning Kamp p = pfind((pid_t)name[0]); 11803ce93e4eSPoul-Henning Kamp if (!p) 1181e76bad96SRobert Drehmel return (ESRCH); 1182e76bad96SRobert Drehmel if ((error = p_cansee(curthread, p))) { 118333a9ed9dSJohn Baldwin PROC_UNLOCK(p); 1184e76bad96SRobert Drehmel return (error); 118533a9ed9dSJohn Baldwin } 11862648efa6SDaniel Eischen error = sysctl_out_proc(p, req, flags); 11873ce93e4eSPoul-Henning Kamp return (error); 11883ce93e4eSPoul-Henning Kamp } 11893ddaef40STim J. Robbins 11902648efa6SDaniel Eischen switch (oid_number) { 11913ddaef40STim J. Robbins case KERN_PROC_ALL: 11923ddaef40STim J. Robbins if (namelen != 0) 11933ce93e4eSPoul-Henning Kamp return (EINVAL); 11943ddaef40STim J. Robbins break; 119525e247afSPeter Wemm case KERN_PROC_PROC: 119625e247afSPeter Wemm if (namelen != 0 && namelen != 1) 119725e247afSPeter Wemm return (EINVAL); 119825e247afSPeter Wemm break; 11993ddaef40STim J. Robbins default: 12003ddaef40STim J. Robbins if (namelen != 1) 12013ddaef40STim J. Robbins return (EINVAL); 12023ddaef40STim J. Robbins break; 12033ddaef40STim J. Robbins } 12043ce93e4eSPoul-Henning Kamp 1205972f9b20SPoul-Henning Kamp if (!req->oldptr) { 12063ce93e4eSPoul-Henning Kamp /* overestimate by 5 procs */ 1207972f9b20SPoul-Henning Kamp error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5); 1208972f9b20SPoul-Henning Kamp if (error) 1209972f9b20SPoul-Henning Kamp return (error); 1210972f9b20SPoul-Henning Kamp } 121147934cefSDon Lewis error = sysctl_wire_old_buffer(req, 0); 121247934cefSDon Lewis if (error != 0) 121347934cefSDon Lewis return (error); 12141005a129SJohn Baldwin sx_slock(&allproc_lock); 12153ce93e4eSPoul-Henning Kamp for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) { 12163ce93e4eSPoul-Henning Kamp if (!doingzomb) 12171b727751SPoul-Henning Kamp p = LIST_FIRST(&allproc); 12183ce93e4eSPoul-Henning Kamp else 12191b727751SPoul-Henning Kamp p = LIST_FIRST(&zombproc); 12201b727751SPoul-Henning Kamp for (; p != 0; p = LIST_NEXT(p, p_list)) { 122102e878d9SJohn Baldwin /* 122202e878d9SJohn Baldwin * Skip embryonic processes. 122302e878d9SJohn Baldwin */ 12248e6fa660SJohn Baldwin PROC_LOCK(p); 122502e878d9SJohn Baldwin if (p->p_state == PRS_NEW) { 12268e6fa660SJohn Baldwin PROC_UNLOCK(p); 122702e878d9SJohn Baldwin continue; 122802e878d9SJohn Baldwin } 1229b241b0a2SJuli Mallett KASSERT(p->p_ucred != NULL, 1230b241b0a2SJuli Mallett ("process credential is NULL for non-NEW proc")); 1231972f9b20SPoul-Henning Kamp /* 1232387d2c03SRobert Watson * Show a user only appropriate processes. 123303f808c5SPaul Saab */ 1234f44d9e24SJohn Baldwin if (p_cansee(curthread, p)) { 123565c9b430SJohn Baldwin PROC_UNLOCK(p); 123603f808c5SPaul Saab continue; 123765c9b430SJohn Baldwin } 123803f808c5SPaul Saab /* 1239972f9b20SPoul-Henning Kamp * TODO - make more efficient (see notes below). 1240972f9b20SPoul-Henning Kamp * do by session. 1241972f9b20SPoul-Henning Kamp */ 12422648efa6SDaniel Eischen switch (oid_number) { 1243972f9b20SPoul-Henning Kamp 1244078842c5SGarance A Drosehn case KERN_PROC_GID: 1245b241b0a2SJuli Mallett if (p->p_ucred->cr_gid != (gid_t)name[0]) { 1246078842c5SGarance A Drosehn PROC_UNLOCK(p); 1247078842c5SGarance A Drosehn continue; 1248078842c5SGarance A Drosehn } 1249078842c5SGarance A Drosehn break; 1250078842c5SGarance A Drosehn 1251972f9b20SPoul-Henning Kamp case KERN_PROC_PGRP: 1252972f9b20SPoul-Henning Kamp /* could do this by traversing pgrp */ 12533ce93e4eSPoul-Henning Kamp if (p->p_pgrp == NULL || 1254f591779bSSeigo Tanimura p->p_pgrp->pg_id != (pid_t)name[0]) { 1255f591779bSSeigo Tanimura PROC_UNLOCK(p); 1256972f9b20SPoul-Henning Kamp continue; 1257f591779bSSeigo Tanimura } 1258972f9b20SPoul-Henning Kamp break; 1259972f9b20SPoul-Henning Kamp 1260b8fdc89dSGarance A Drosehn case KERN_PROC_RGID: 1261b241b0a2SJuli Mallett if (p->p_ucred->cr_rgid != (gid_t)name[0]) { 1262b8fdc89dSGarance A Drosehn PROC_UNLOCK(p); 1263b8fdc89dSGarance A Drosehn continue; 1264b8fdc89dSGarance A Drosehn } 1265b8fdc89dSGarance A Drosehn break; 1266b8fdc89dSGarance A Drosehn 1267b8fdc89dSGarance A Drosehn case KERN_PROC_SESSION: 1268b8fdc89dSGarance A Drosehn if (p->p_session == NULL || 1269b8fdc89dSGarance A Drosehn p->p_session->s_sid != (pid_t)name[0]) { 1270b8fdc89dSGarance A Drosehn PROC_UNLOCK(p); 1271b8fdc89dSGarance A Drosehn continue; 1272b8fdc89dSGarance A Drosehn } 1273b8fdc89dSGarance A Drosehn break; 1274b8fdc89dSGarance A Drosehn 1275972f9b20SPoul-Henning Kamp case KERN_PROC_TTY: 1276972f9b20SPoul-Henning Kamp if ((p->p_flag & P_CONTROLT) == 0 || 1277f591779bSSeigo Tanimura p->p_session == NULL) { 1278f591779bSSeigo Tanimura PROC_UNLOCK(p); 1279972f9b20SPoul-Henning Kamp continue; 1280f591779bSSeigo Tanimura } 1281bc093719SEd Schouten /* XXX proctree_lock */ 1282f591779bSSeigo Tanimura SESS_LOCK(p->p_session); 1283f591779bSSeigo Tanimura if (p->p_session->s_ttyp == NULL || 1284bc093719SEd Schouten tty_udev(p->p_session->s_ttyp) != 1285f3732fd1SPoul-Henning Kamp (dev_t)name[0]) { 1286f591779bSSeigo Tanimura SESS_UNLOCK(p->p_session); 1287f591779bSSeigo Tanimura PROC_UNLOCK(p); 1288f591779bSSeigo Tanimura continue; 1289f591779bSSeigo Tanimura } 1290f591779bSSeigo Tanimura SESS_UNLOCK(p->p_session); 1291972f9b20SPoul-Henning Kamp break; 1292972f9b20SPoul-Henning Kamp 1293972f9b20SPoul-Henning Kamp case KERN_PROC_UID: 1294b241b0a2SJuli Mallett if (p->p_ucred->cr_uid != (uid_t)name[0]) { 129565c9b430SJohn Baldwin PROC_UNLOCK(p); 1296972f9b20SPoul-Henning Kamp continue; 129765c9b430SJohn Baldwin } 1298972f9b20SPoul-Henning Kamp break; 1299972f9b20SPoul-Henning Kamp 1300972f9b20SPoul-Henning Kamp case KERN_PROC_RUID: 1301b241b0a2SJuli Mallett if (p->p_ucred->cr_ruid != (uid_t)name[0]) { 130265c9b430SJohn Baldwin PROC_UNLOCK(p); 1303972f9b20SPoul-Henning Kamp continue; 130465c9b430SJohn Baldwin } 1305972f9b20SPoul-Henning Kamp break; 130630c6f34eSScott Long 130730c6f34eSScott Long case KERN_PROC_PROC: 130830c6f34eSScott Long break; 130930c6f34eSScott Long 131030c6f34eSScott Long default: 131130c6f34eSScott Long break; 131230c6f34eSScott Long 1313972f9b20SPoul-Henning Kamp } 1314972f9b20SPoul-Henning Kamp 131530c6f34eSScott Long error = sysctl_out_proc(p, req, flags | doingzomb); 1316553629ebSJake Burkholder if (error) { 13171005a129SJohn Baldwin sx_sunlock(&allproc_lock); 1318972f9b20SPoul-Henning Kamp return (error); 1319972f9b20SPoul-Henning Kamp } 1320972f9b20SPoul-Henning Kamp } 1321553629ebSJake Burkholder } 13221005a129SJohn Baldwin sx_sunlock(&allproc_lock); 1323972f9b20SPoul-Henning Kamp return (0); 1324972f9b20SPoul-Henning Kamp } 1325972f9b20SPoul-Henning Kamp 1326c1508b28SAlfred Perlstein struct pargs * 1327c1508b28SAlfred Perlstein pargs_alloc(int len) 1328c1508b28SAlfred Perlstein { 1329c1508b28SAlfred Perlstein struct pargs *pa; 1330c1508b28SAlfred Perlstein 13311ede983cSDag-Erling Smørgrav pa = malloc(sizeof(struct pargs) + len, M_PARGS, 1332a163d034SWarner Losh M_WAITOK); 133355b4a5aeSJohn Baldwin refcount_init(&pa->ar_ref, 1); 1334c1508b28SAlfred Perlstein pa->ar_length = len; 1335c1508b28SAlfred Perlstein return (pa); 1336c1508b28SAlfred Perlstein } 1337c1508b28SAlfred Perlstein 133858e8af1bSKonstantin Belousov static void 1339c1508b28SAlfred Perlstein pargs_free(struct pargs *pa) 1340c1508b28SAlfred Perlstein { 1341c1508b28SAlfred Perlstein 13421ede983cSDag-Erling Smørgrav free(pa, M_PARGS); 1343c1508b28SAlfred Perlstein } 1344c1508b28SAlfred Perlstein 1345c1508b28SAlfred Perlstein void 1346c1508b28SAlfred Perlstein pargs_hold(struct pargs *pa) 1347c1508b28SAlfred Perlstein { 1348c1508b28SAlfred Perlstein 1349c1508b28SAlfred Perlstein if (pa == NULL) 1350c1508b28SAlfred Perlstein return; 135155b4a5aeSJohn Baldwin refcount_acquire(&pa->ar_ref); 1352c1508b28SAlfred Perlstein } 1353c1508b28SAlfred Perlstein 1354c1508b28SAlfred Perlstein void 1355c1508b28SAlfred Perlstein pargs_drop(struct pargs *pa) 1356c1508b28SAlfred Perlstein { 1357c1508b28SAlfred Perlstein 1358c1508b28SAlfred Perlstein if (pa == NULL) 1359c1508b28SAlfred Perlstein return; 136055b4a5aeSJohn Baldwin if (refcount_release(&pa->ar_ref)) 1361c1508b28SAlfred Perlstein pargs_free(pa); 1362c1508b28SAlfred Perlstein } 1363c1508b28SAlfred Perlstein 1364c5cfcb1cSMikolaj Golub static int 1365c5cfcb1cSMikolaj Golub proc_read_mem(struct thread *td, struct proc *p, vm_offset_t offset, void* buf, 1366c5cfcb1cSMikolaj Golub size_t len) 1367c5cfcb1cSMikolaj Golub { 1368c5cfcb1cSMikolaj Golub struct iovec iov; 1369c5cfcb1cSMikolaj Golub struct uio uio; 1370c5cfcb1cSMikolaj Golub 1371c5cfcb1cSMikolaj Golub iov.iov_base = (caddr_t)buf; 1372c5cfcb1cSMikolaj Golub iov.iov_len = len; 1373c5cfcb1cSMikolaj Golub uio.uio_iov = &iov; 1374c5cfcb1cSMikolaj Golub uio.uio_iovcnt = 1; 1375c5cfcb1cSMikolaj Golub uio.uio_offset = offset; 1376c5cfcb1cSMikolaj Golub uio.uio_resid = (ssize_t)len; 1377c5cfcb1cSMikolaj Golub uio.uio_segflg = UIO_SYSSPACE; 1378c5cfcb1cSMikolaj Golub uio.uio_rw = UIO_READ; 1379c5cfcb1cSMikolaj Golub uio.uio_td = td; 1380c5cfcb1cSMikolaj Golub 1381c5cfcb1cSMikolaj Golub return (proc_rwmem(p, &uio)); 1382c5cfcb1cSMikolaj Golub } 1383c5cfcb1cSMikolaj Golub 1384c5cfcb1cSMikolaj Golub static int 1385c5cfcb1cSMikolaj Golub proc_read_string(struct thread *td, struct proc *p, const char *sptr, char *buf, 1386c5cfcb1cSMikolaj Golub size_t len) 1387c5cfcb1cSMikolaj Golub { 1388c5cfcb1cSMikolaj Golub size_t i; 1389c5cfcb1cSMikolaj Golub int error; 1390c5cfcb1cSMikolaj Golub 1391c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, (vm_offset_t)sptr, buf, len); 1392c5cfcb1cSMikolaj Golub /* 1393c5cfcb1cSMikolaj Golub * Reading the chunk may validly return EFAULT if the string is shorter 1394c5cfcb1cSMikolaj Golub * than the chunk and is aligned at the end of the page, assuming the 1395c5cfcb1cSMikolaj Golub * next page is not mapped. So if EFAULT is returned do a fallback to 1396c5cfcb1cSMikolaj Golub * one byte read loop. 1397c5cfcb1cSMikolaj Golub */ 1398c5cfcb1cSMikolaj Golub if (error == EFAULT) { 1399c5cfcb1cSMikolaj Golub for (i = 0; i < len; i++, buf++, sptr++) { 1400c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, (vm_offset_t)sptr, buf, 1); 1401c5cfcb1cSMikolaj Golub if (error != 0) 1402c5cfcb1cSMikolaj Golub return (error); 1403c5cfcb1cSMikolaj Golub if (*buf == '\0') 1404c5cfcb1cSMikolaj Golub break; 1405c5cfcb1cSMikolaj Golub } 1406c5cfcb1cSMikolaj Golub error = 0; 1407c5cfcb1cSMikolaj Golub } 1408c5cfcb1cSMikolaj Golub return (error); 1409c5cfcb1cSMikolaj Golub } 1410c5cfcb1cSMikolaj Golub 1411c5cfcb1cSMikolaj Golub #define PROC_AUXV_MAX 256 /* Safety limit on auxv size. */ 1412c5cfcb1cSMikolaj Golub 1413c5cfcb1cSMikolaj Golub enum proc_vector_type { 1414c5cfcb1cSMikolaj Golub PROC_ARG, 1415c5cfcb1cSMikolaj Golub PROC_ENV, 1416c5cfcb1cSMikolaj Golub PROC_AUX, 1417c5cfcb1cSMikolaj Golub }; 1418c5cfcb1cSMikolaj Golub 1419c5cfcb1cSMikolaj Golub #ifdef COMPAT_FREEBSD32 1420c5cfcb1cSMikolaj Golub static int 1421c5cfcb1cSMikolaj Golub get_proc_vector32(struct thread *td, struct proc *p, char ***proc_vectorp, 1422c5cfcb1cSMikolaj Golub size_t *vsizep, enum proc_vector_type type) 1423c5cfcb1cSMikolaj Golub { 1424c5cfcb1cSMikolaj Golub struct freebsd32_ps_strings pss; 1425c5cfcb1cSMikolaj Golub Elf32_Auxinfo aux; 1426c5cfcb1cSMikolaj Golub vm_offset_t vptr, ptr; 1427c5cfcb1cSMikolaj Golub uint32_t *proc_vector32; 1428c5cfcb1cSMikolaj Golub char **proc_vector; 1429c5cfcb1cSMikolaj Golub size_t vsize, size; 1430c5cfcb1cSMikolaj Golub int i, error; 1431c5cfcb1cSMikolaj Golub 1432c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, (vm_offset_t)(p->p_sysent->sv_psstrings), 1433c5cfcb1cSMikolaj Golub &pss, sizeof(pss)); 1434c5cfcb1cSMikolaj Golub if (error != 0) 1435c5cfcb1cSMikolaj Golub return (error); 1436c5cfcb1cSMikolaj Golub switch (type) { 1437c5cfcb1cSMikolaj Golub case PROC_ARG: 1438c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)PTRIN(pss.ps_argvstr); 1439c5cfcb1cSMikolaj Golub vsize = pss.ps_nargvstr; 1440c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1441c5cfcb1cSMikolaj Golub return (ENOEXEC); 1442c5cfcb1cSMikolaj Golub size = vsize * sizeof(int32_t); 1443c5cfcb1cSMikolaj Golub break; 1444c5cfcb1cSMikolaj Golub case PROC_ENV: 1445c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)PTRIN(pss.ps_envstr); 1446c5cfcb1cSMikolaj Golub vsize = pss.ps_nenvstr; 1447c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1448c5cfcb1cSMikolaj Golub return (ENOEXEC); 1449c5cfcb1cSMikolaj Golub size = vsize * sizeof(int32_t); 1450c5cfcb1cSMikolaj Golub break; 1451c5cfcb1cSMikolaj Golub case PROC_AUX: 1452c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)PTRIN(pss.ps_envstr) + 1453c5cfcb1cSMikolaj Golub (pss.ps_nenvstr + 1) * sizeof(int32_t); 1454c5cfcb1cSMikolaj Golub if (vptr % 4 != 0) 1455c5cfcb1cSMikolaj Golub return (ENOEXEC); 1456c5cfcb1cSMikolaj Golub for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) { 1457c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, ptr, &aux, sizeof(aux)); 1458c5cfcb1cSMikolaj Golub if (error != 0) 1459c5cfcb1cSMikolaj Golub return (error); 1460c5cfcb1cSMikolaj Golub if (aux.a_type == AT_NULL) 1461c5cfcb1cSMikolaj Golub break; 1462c5cfcb1cSMikolaj Golub ptr += sizeof(aux); 1463c5cfcb1cSMikolaj Golub } 1464c5cfcb1cSMikolaj Golub if (aux.a_type != AT_NULL) 1465c5cfcb1cSMikolaj Golub return (ENOEXEC); 1466c5cfcb1cSMikolaj Golub vsize = i + 1; 1467c5cfcb1cSMikolaj Golub size = vsize * sizeof(aux); 1468c5cfcb1cSMikolaj Golub break; 1469c5cfcb1cSMikolaj Golub default: 1470c5cfcb1cSMikolaj Golub KASSERT(0, ("Wrong proc vector type: %d", type)); 1471*7ad9baaeSMikolaj Golub return (EINVAL); 1472c5cfcb1cSMikolaj Golub } 1473c5cfcb1cSMikolaj Golub proc_vector32 = malloc(size, M_TEMP, M_WAITOK); 1474c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, vptr, proc_vector32, size); 1475c5cfcb1cSMikolaj Golub if (error != 0) 1476c5cfcb1cSMikolaj Golub goto done; 1477c5cfcb1cSMikolaj Golub if (type == PROC_AUX) { 1478c5cfcb1cSMikolaj Golub *proc_vectorp = (char **)proc_vector32; 1479c5cfcb1cSMikolaj Golub *vsizep = vsize; 1480c5cfcb1cSMikolaj Golub return (0); 1481c5cfcb1cSMikolaj Golub } 1482c5cfcb1cSMikolaj Golub proc_vector = malloc(vsize * sizeof(char *), M_TEMP, M_WAITOK); 1483c5cfcb1cSMikolaj Golub for (i = 0; i < (int)vsize; i++) 1484c5cfcb1cSMikolaj Golub proc_vector[i] = PTRIN(proc_vector32[i]); 1485c5cfcb1cSMikolaj Golub *proc_vectorp = proc_vector; 1486c5cfcb1cSMikolaj Golub *vsizep = vsize; 1487c5cfcb1cSMikolaj Golub done: 1488c5cfcb1cSMikolaj Golub free(proc_vector32, M_TEMP); 1489c5cfcb1cSMikolaj Golub return (error); 1490c5cfcb1cSMikolaj Golub } 1491c5cfcb1cSMikolaj Golub #endif 1492c5cfcb1cSMikolaj Golub 1493c5cfcb1cSMikolaj Golub static int 1494c5cfcb1cSMikolaj Golub get_proc_vector(struct thread *td, struct proc *p, char ***proc_vectorp, 1495c5cfcb1cSMikolaj Golub size_t *vsizep, enum proc_vector_type type) 1496c5cfcb1cSMikolaj Golub { 1497c5cfcb1cSMikolaj Golub struct ps_strings pss; 1498c5cfcb1cSMikolaj Golub Elf_Auxinfo aux; 1499c5cfcb1cSMikolaj Golub vm_offset_t vptr, ptr; 1500c5cfcb1cSMikolaj Golub char **proc_vector; 1501c5cfcb1cSMikolaj Golub size_t vsize, size; 1502c5cfcb1cSMikolaj Golub int error, i; 1503c5cfcb1cSMikolaj Golub 1504c5cfcb1cSMikolaj Golub #ifdef COMPAT_FREEBSD32 1505c5cfcb1cSMikolaj Golub if (SV_PROC_FLAG(p, SV_ILP32) != 0) 1506c5cfcb1cSMikolaj Golub return (get_proc_vector32(td, p, proc_vectorp, vsizep, type)); 1507c5cfcb1cSMikolaj Golub #endif 1508c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, (vm_offset_t)(p->p_sysent->sv_psstrings), 1509c5cfcb1cSMikolaj Golub &pss, sizeof(pss)); 1510c5cfcb1cSMikolaj Golub if (error != 0) 1511c5cfcb1cSMikolaj Golub return (error); 1512c5cfcb1cSMikolaj Golub switch (type) { 1513c5cfcb1cSMikolaj Golub case PROC_ARG: 1514c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)pss.ps_argvstr; 1515c5cfcb1cSMikolaj Golub vsize = pss.ps_nargvstr; 1516c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1517c5cfcb1cSMikolaj Golub return (ENOEXEC); 1518c5cfcb1cSMikolaj Golub size = vsize * sizeof(char *); 1519c5cfcb1cSMikolaj Golub break; 1520c5cfcb1cSMikolaj Golub case PROC_ENV: 1521c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)pss.ps_envstr; 1522c5cfcb1cSMikolaj Golub vsize = pss.ps_nenvstr; 1523c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1524c5cfcb1cSMikolaj Golub return (ENOEXEC); 1525c5cfcb1cSMikolaj Golub size = vsize * sizeof(char *); 1526c5cfcb1cSMikolaj Golub break; 1527c5cfcb1cSMikolaj Golub case PROC_AUX: 1528c5cfcb1cSMikolaj Golub /* 1529c5cfcb1cSMikolaj Golub * The aux array is just above env array on the stack. Check 1530c5cfcb1cSMikolaj Golub * that the address is naturally aligned. 1531c5cfcb1cSMikolaj Golub */ 1532c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)pss.ps_envstr + (pss.ps_nenvstr + 1) 1533c5cfcb1cSMikolaj Golub * sizeof(char *); 1534c5cfcb1cSMikolaj Golub #if __ELF_WORD_SIZE == 64 1535c5cfcb1cSMikolaj Golub if (vptr % sizeof(uint64_t) != 0) 1536c5cfcb1cSMikolaj Golub #else 1537c5cfcb1cSMikolaj Golub if (vptr % sizeof(uint32_t) != 0) 1538c5cfcb1cSMikolaj Golub #endif 1539c5cfcb1cSMikolaj Golub return (ENOEXEC); 1540c5cfcb1cSMikolaj Golub /* 1541c5cfcb1cSMikolaj Golub * We count the array size reading the aux vectors from the 1542c5cfcb1cSMikolaj Golub * stack until AT_NULL vector is returned. So (to keep the code 1543c5cfcb1cSMikolaj Golub * simple) we read the process stack twice: the first time here 1544c5cfcb1cSMikolaj Golub * to find the size and the second time when copying the vectors 1545c5cfcb1cSMikolaj Golub * to the allocated proc_vector. 1546c5cfcb1cSMikolaj Golub */ 1547c5cfcb1cSMikolaj Golub for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) { 1548c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, ptr, &aux, sizeof(aux)); 1549c5cfcb1cSMikolaj Golub if (error != 0) 1550c5cfcb1cSMikolaj Golub return (error); 1551c5cfcb1cSMikolaj Golub if (aux.a_type == AT_NULL) 1552c5cfcb1cSMikolaj Golub break; 1553c5cfcb1cSMikolaj Golub ptr += sizeof(aux); 1554c5cfcb1cSMikolaj Golub } 1555c5cfcb1cSMikolaj Golub /* 1556c5cfcb1cSMikolaj Golub * If the PROC_AUXV_MAX entries are iterated over, and we have 1557c5cfcb1cSMikolaj Golub * not reached AT_NULL, it is most likely we are reading wrong 1558c5cfcb1cSMikolaj Golub * data: either the process doesn't have auxv array or data has 1559c5cfcb1cSMikolaj Golub * been modified. Return the error in this case. 1560c5cfcb1cSMikolaj Golub */ 1561c5cfcb1cSMikolaj Golub if (aux.a_type != AT_NULL) 1562c5cfcb1cSMikolaj Golub return (ENOEXEC); 1563c5cfcb1cSMikolaj Golub vsize = i + 1; 1564c5cfcb1cSMikolaj Golub size = vsize * sizeof(aux); 1565c5cfcb1cSMikolaj Golub break; 1566c5cfcb1cSMikolaj Golub default: 1567c5cfcb1cSMikolaj Golub KASSERT(0, ("Wrong proc vector type: %d", type)); 1568*7ad9baaeSMikolaj Golub return (EINVAL); /* In case we are built without INVARIANTS. */ 1569c5cfcb1cSMikolaj Golub } 1570c5cfcb1cSMikolaj Golub proc_vector = malloc(size, M_TEMP, M_WAITOK); 1571c5cfcb1cSMikolaj Golub if (proc_vector == NULL) 1572c5cfcb1cSMikolaj Golub return (ENOMEM); 1573c5cfcb1cSMikolaj Golub error = proc_read_mem(td, p, vptr, proc_vector, size); 1574c5cfcb1cSMikolaj Golub if (error != 0) { 1575c5cfcb1cSMikolaj Golub free(proc_vector, M_TEMP); 1576c5cfcb1cSMikolaj Golub return (error); 1577c5cfcb1cSMikolaj Golub } 1578c5cfcb1cSMikolaj Golub *proc_vectorp = proc_vector; 1579c5cfcb1cSMikolaj Golub *vsizep = vsize; 1580c5cfcb1cSMikolaj Golub 1581c5cfcb1cSMikolaj Golub return (0); 1582c5cfcb1cSMikolaj Golub } 1583c5cfcb1cSMikolaj Golub 1584c5cfcb1cSMikolaj Golub #define GET_PS_STRINGS_CHUNK_SZ 256 /* Chunk size (bytes) for ps_strings operations. */ 1585c5cfcb1cSMikolaj Golub 1586c5cfcb1cSMikolaj Golub static int 1587c5cfcb1cSMikolaj Golub get_ps_strings(struct thread *td, struct proc *p, struct sbuf *sb, 1588c5cfcb1cSMikolaj Golub enum proc_vector_type type, size_t nchr) 1589c5cfcb1cSMikolaj Golub { 1590c5cfcb1cSMikolaj Golub size_t done, len, vsize; 1591c5cfcb1cSMikolaj Golub int error, i; 1592c5cfcb1cSMikolaj Golub char **proc_vector, *sptr; 1593c5cfcb1cSMikolaj Golub char pss_string[GET_PS_STRINGS_CHUNK_SZ]; 1594c5cfcb1cSMikolaj Golub 1595c5cfcb1cSMikolaj Golub PROC_ASSERT_HELD(p); 1596c5cfcb1cSMikolaj Golub 1597c5cfcb1cSMikolaj Golub /* 1598c5cfcb1cSMikolaj Golub * We are not going to read more than 2 * (PATH_MAX + ARG_MAX) bytes. 1599c5cfcb1cSMikolaj Golub */ 1600c5cfcb1cSMikolaj Golub if (nchr > 2 * (PATH_MAX + ARG_MAX)) 1601c5cfcb1cSMikolaj Golub nchr = 2 * (PATH_MAX + ARG_MAX); 1602c5cfcb1cSMikolaj Golub 1603c5cfcb1cSMikolaj Golub error = get_proc_vector(td, p, &proc_vector, &vsize, type); 1604c5cfcb1cSMikolaj Golub if (error != 0) 1605c5cfcb1cSMikolaj Golub return (error); 1606c5cfcb1cSMikolaj Golub for (done = 0, i = 0; i < (int)vsize && done < nchr; i++) { 1607c5cfcb1cSMikolaj Golub /* 1608c5cfcb1cSMikolaj Golub * The program may have scribbled into its argv array, e.g. to 1609c5cfcb1cSMikolaj Golub * remove some arguments. If that has happened, break out 1610c5cfcb1cSMikolaj Golub * before trying to read from NULL. 1611c5cfcb1cSMikolaj Golub */ 1612c5cfcb1cSMikolaj Golub if (proc_vector[i] == NULL) 1613c5cfcb1cSMikolaj Golub break; 1614c5cfcb1cSMikolaj Golub for (sptr = proc_vector[i]; ; sptr += GET_PS_STRINGS_CHUNK_SZ) { 1615c5cfcb1cSMikolaj Golub error = proc_read_string(td, p, sptr, pss_string, 1616c5cfcb1cSMikolaj Golub sizeof(pss_string)); 1617c5cfcb1cSMikolaj Golub if (error != 0) 1618c5cfcb1cSMikolaj Golub goto done; 1619c5cfcb1cSMikolaj Golub len = strnlen(pss_string, GET_PS_STRINGS_CHUNK_SZ); 1620c5cfcb1cSMikolaj Golub if (done + len >= nchr) 1621c5cfcb1cSMikolaj Golub len = nchr - done - 1; 1622c5cfcb1cSMikolaj Golub sbuf_bcat(sb, pss_string, len); 1623c5cfcb1cSMikolaj Golub if (len != GET_PS_STRINGS_CHUNK_SZ) 1624c5cfcb1cSMikolaj Golub break; 1625c5cfcb1cSMikolaj Golub done += GET_PS_STRINGS_CHUNK_SZ; 1626c5cfcb1cSMikolaj Golub } 1627c5cfcb1cSMikolaj Golub sbuf_bcat(sb, "", 1); 1628c5cfcb1cSMikolaj Golub done += len + 1; 1629c5cfcb1cSMikolaj Golub } 1630c5cfcb1cSMikolaj Golub done: 1631c5cfcb1cSMikolaj Golub free(proc_vector, M_TEMP); 1632c5cfcb1cSMikolaj Golub return (error); 1633c5cfcb1cSMikolaj Golub } 1634c5cfcb1cSMikolaj Golub 1635c5cfcb1cSMikolaj Golub int 1636c5cfcb1cSMikolaj Golub proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb, size_t nchr) 1637c5cfcb1cSMikolaj Golub { 1638c5cfcb1cSMikolaj Golub 1639c5cfcb1cSMikolaj Golub return (get_ps_strings(curthread, p, sb, PROC_ARG, nchr)); 1640c5cfcb1cSMikolaj Golub } 1641c5cfcb1cSMikolaj Golub 1642c5cfcb1cSMikolaj Golub int 1643c5cfcb1cSMikolaj Golub proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb, size_t nchr) 1644c5cfcb1cSMikolaj Golub { 1645c5cfcb1cSMikolaj Golub 1646c5cfcb1cSMikolaj Golub return (get_ps_strings(curthread, p, sb, PROC_ENV, nchr)); 1647c5cfcb1cSMikolaj Golub } 1648c5cfcb1cSMikolaj Golub 1649b9df5231SPoul-Henning Kamp /* 1650b9df5231SPoul-Henning Kamp * This sysctl allows a process to retrieve the argument list or process 1651b9df5231SPoul-Henning Kamp * title for another process without groping around in the address space 1652b9df5231SPoul-Henning Kamp * of the other process. It also allow a process to set its own "process 1653b9df5231SPoul-Henning Kamp * title to a string of its own choice. 1654b9df5231SPoul-Henning Kamp */ 1655b9df5231SPoul-Henning Kamp static int 165682d9ae4eSPoul-Henning Kamp sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS) 1657b9df5231SPoul-Henning Kamp { 1658b9df5231SPoul-Henning Kamp int *name = (int*) arg1; 1659b9df5231SPoul-Henning Kamp u_int namelen = arg2; 16608510f2a8SJohn Baldwin struct pargs *newpa, *pa; 1661b9df5231SPoul-Henning Kamp struct proc *p; 1662c5cfcb1cSMikolaj Golub struct sbuf sb; 1663c5cfcb1cSMikolaj Golub int error = 0, error2; 1664b9df5231SPoul-Henning Kamp 1665b9df5231SPoul-Henning Kamp if (namelen != 1) 1666b9df5231SPoul-Henning Kamp return (EINVAL); 1667b9df5231SPoul-Henning Kamp 1668b9df5231SPoul-Henning Kamp p = pfind((pid_t)name[0]); 1669b9df5231SPoul-Henning Kamp if (!p) 1670e76bad96SRobert Drehmel return (ESRCH); 1671b9df5231SPoul-Henning Kamp 16729cdb6216SPawel Jakub Dawidek if ((error = p_cansee(curthread, p)) != 0) { 167333a9ed9dSJohn Baldwin PROC_UNLOCK(p); 1674e76bad96SRobert Drehmel return (error); 167533a9ed9dSJohn Baldwin } 16764bc6471bSJohn Baldwin 16774bc6471bSJohn Baldwin if (req->newptr && curproc != p) { 167833a9ed9dSJohn Baldwin PROC_UNLOCK(p); 1679b9df5231SPoul-Henning Kamp return (EPERM); 16804bc6471bSJohn Baldwin } 1681b9df5231SPoul-Henning Kamp 16827b11fea6SAlfred Perlstein pa = p->p_args; 1683c5cfcb1cSMikolaj Golub if (pa != NULL) { 16847b11fea6SAlfred Perlstein pargs_hold(pa); 16857b11fea6SAlfred Perlstein PROC_UNLOCK(p); 16867b11fea6SAlfred Perlstein error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length); 16877b11fea6SAlfred Perlstein pargs_drop(pa); 1688c5cfcb1cSMikolaj Golub } else if ((p->p_flag & (P_WEXIT | P_SYSTEM)) == 0) { 1689c5cfcb1cSMikolaj Golub _PHOLD(p); 1690c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1691c5cfcb1cSMikolaj Golub sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req); 1692c5cfcb1cSMikolaj Golub error = proc_getargv(curthread, p, &sb, req->oldlen); 1693c5cfcb1cSMikolaj Golub error2 = sbuf_finish(&sb); 1694c5cfcb1cSMikolaj Golub PRELE(p); 1695c5cfcb1cSMikolaj Golub sbuf_delete(&sb); 1696c5cfcb1cSMikolaj Golub if (error == 0 && error2 != 0) 1697c5cfcb1cSMikolaj Golub error = error2; 1698c5cfcb1cSMikolaj Golub } else { 1699c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1700c5cfcb1cSMikolaj Golub } 17018510f2a8SJohn Baldwin if (error != 0 || req->newptr == NULL) 1702b9df5231SPoul-Henning Kamp return (error); 1703b9df5231SPoul-Henning Kamp 1704b9df5231SPoul-Henning Kamp if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit) 17058510f2a8SJohn Baldwin return (ENOMEM); 17064bc6471bSJohn Baldwin newpa = pargs_alloc(req->newlen); 17074bc6471bSJohn Baldwin error = SYSCTL_IN(req, newpa->ar_args, req->newlen); 17088510f2a8SJohn Baldwin if (error != 0) { 17094bc6471bSJohn Baldwin pargs_free(newpa); 1710b9df5231SPoul-Henning Kamp return (error); 1711b9df5231SPoul-Henning Kamp } 17124bc6471bSJohn Baldwin PROC_LOCK(p); 17134bc6471bSJohn Baldwin pa = p->p_args; 17144bc6471bSJohn Baldwin p->p_args = newpa; 17154bc6471bSJohn Baldwin PROC_UNLOCK(p); 17164bc6471bSJohn Baldwin pargs_drop(pa); 17174bc6471bSJohn Baldwin return (0); 17184bc6471bSJohn Baldwin } 17194bc6471bSJohn Baldwin 1720fe769cddSDavid Schultz /* 1721c5cfcb1cSMikolaj Golub * This sysctl allows a process to retrieve environment of another process. 1722c5cfcb1cSMikolaj Golub */ 1723c5cfcb1cSMikolaj Golub static int 1724c5cfcb1cSMikolaj Golub sysctl_kern_proc_env(SYSCTL_HANDLER_ARGS) 1725c5cfcb1cSMikolaj Golub { 1726c5cfcb1cSMikolaj Golub int *name = (int*) arg1; 1727c5cfcb1cSMikolaj Golub u_int namelen = arg2; 1728c5cfcb1cSMikolaj Golub struct proc *p; 1729c5cfcb1cSMikolaj Golub struct sbuf sb; 1730c5cfcb1cSMikolaj Golub int error, error2; 1731c5cfcb1cSMikolaj Golub 1732c5cfcb1cSMikolaj Golub if (namelen != 1) 1733c5cfcb1cSMikolaj Golub return (EINVAL); 1734c5cfcb1cSMikolaj Golub 1735c5cfcb1cSMikolaj Golub p = pfind((pid_t)name[0]); 1736c5cfcb1cSMikolaj Golub if (p == NULL) 1737c5cfcb1cSMikolaj Golub return (ESRCH); 1738c5cfcb1cSMikolaj Golub if ((p->p_flag & P_WEXIT) != 0) { 1739c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1740c5cfcb1cSMikolaj Golub return (ESRCH); 1741c5cfcb1cSMikolaj Golub } 1742c5cfcb1cSMikolaj Golub if ((error = p_candebug(curthread, p)) != 0) { 1743c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1744c5cfcb1cSMikolaj Golub return (error); 1745c5cfcb1cSMikolaj Golub } 1746c5cfcb1cSMikolaj Golub if ((p->p_flag & P_SYSTEM) != 0) { 1747c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1748c5cfcb1cSMikolaj Golub return (0); 1749c5cfcb1cSMikolaj Golub } 1750c5cfcb1cSMikolaj Golub _PHOLD(p); 1751c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1752c5cfcb1cSMikolaj Golub sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req); 1753c5cfcb1cSMikolaj Golub error = proc_getenvv(curthread, p, &sb, req->oldlen); 1754c5cfcb1cSMikolaj Golub error2 = sbuf_finish(&sb); 1755c5cfcb1cSMikolaj Golub PRELE(p); 1756c5cfcb1cSMikolaj Golub sbuf_delete(&sb); 1757c5cfcb1cSMikolaj Golub return (error != 0 ? error : error2); 1758c5cfcb1cSMikolaj Golub } 1759c5cfcb1cSMikolaj Golub 1760c5cfcb1cSMikolaj Golub /* 1761c5cfcb1cSMikolaj Golub * This sysctl allows a process to retrieve ELF auxiliary vector of 1762c5cfcb1cSMikolaj Golub * another process. 1763c5cfcb1cSMikolaj Golub */ 1764c5cfcb1cSMikolaj Golub static int 1765c5cfcb1cSMikolaj Golub sysctl_kern_proc_auxv(SYSCTL_HANDLER_ARGS) 1766c5cfcb1cSMikolaj Golub { 1767c5cfcb1cSMikolaj Golub int *name = (int*) arg1; 1768c5cfcb1cSMikolaj Golub u_int namelen = arg2; 1769c5cfcb1cSMikolaj Golub struct proc *p; 1770c5cfcb1cSMikolaj Golub size_t vsize; 1771c5cfcb1cSMikolaj Golub char **auxv; 1772c5cfcb1cSMikolaj Golub int error; 1773c5cfcb1cSMikolaj Golub 1774c5cfcb1cSMikolaj Golub if (namelen != 1) 1775c5cfcb1cSMikolaj Golub return (EINVAL); 1776c5cfcb1cSMikolaj Golub 1777c5cfcb1cSMikolaj Golub p = pfind((pid_t)name[0]); 1778c5cfcb1cSMikolaj Golub if (p == NULL) 1779c5cfcb1cSMikolaj Golub return (ESRCH); 1780c5cfcb1cSMikolaj Golub if (p->p_flag & P_WEXIT) { 1781c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1782c5cfcb1cSMikolaj Golub return (ESRCH); 1783c5cfcb1cSMikolaj Golub } 1784c5cfcb1cSMikolaj Golub if ((error = p_cansee(curthread, p)) != 0) { 1785c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1786c5cfcb1cSMikolaj Golub return (error); 1787c5cfcb1cSMikolaj Golub } 1788c5cfcb1cSMikolaj Golub if ((p->p_flag & P_SYSTEM) != 0) { 1789c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1790c5cfcb1cSMikolaj Golub return (0); 1791c5cfcb1cSMikolaj Golub } 1792c5cfcb1cSMikolaj Golub _PHOLD(p); 1793c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1794c5cfcb1cSMikolaj Golub error = get_proc_vector(curthread, p, &auxv, &vsize, PROC_AUX); 1795c5cfcb1cSMikolaj Golub PRELE(p); 1796c5cfcb1cSMikolaj Golub if (error == 0) { 1797c5cfcb1cSMikolaj Golub #ifdef COMPAT_FREEBSD32 1798c5cfcb1cSMikolaj Golub if (SV_PROC_FLAG(p, SV_ILP32) != 0) 1799c5cfcb1cSMikolaj Golub error = SYSCTL_OUT(req, auxv, vsize * 1800c5cfcb1cSMikolaj Golub sizeof(Elf32_Auxinfo)); 1801c5cfcb1cSMikolaj Golub else 1802c5cfcb1cSMikolaj Golub #endif 1803c5cfcb1cSMikolaj Golub error = SYSCTL_OUT(req, auxv, vsize * sizeof(Elf_Auxinfo)); 1804c5cfcb1cSMikolaj Golub free(auxv, M_TEMP); 1805c5cfcb1cSMikolaj Golub } 1806c5cfcb1cSMikolaj Golub return (error); 1807c5cfcb1cSMikolaj Golub } 1808c5cfcb1cSMikolaj Golub 1809c5cfcb1cSMikolaj Golub /* 1810fe769cddSDavid Schultz * This sysctl allows a process to retrieve the path of the executable for 1811fe769cddSDavid Schultz * itself or another process. 1812fe769cddSDavid Schultz */ 1813fe769cddSDavid Schultz static int 1814fe769cddSDavid Schultz sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS) 1815fe769cddSDavid Schultz { 1816fe769cddSDavid Schultz pid_t *pidp = (pid_t *)arg1; 1817fe769cddSDavid Schultz unsigned int arglen = arg2; 1818fe769cddSDavid Schultz struct proc *p; 1819fe769cddSDavid Schultz struct vnode *vp; 1820fe769cddSDavid Schultz char *retbuf, *freebuf; 182124f87fdbSJohn Baldwin int error, vfslocked; 1822fe769cddSDavid Schultz 1823fe769cddSDavid Schultz if (arglen != 1) 1824fe769cddSDavid Schultz return (EINVAL); 1825fe769cddSDavid Schultz if (*pidp == -1) { /* -1 means this process */ 1826fe769cddSDavid Schultz p = req->td->td_proc; 1827fe769cddSDavid Schultz } else { 1828fe769cddSDavid Schultz p = pfind(*pidp); 1829fe769cddSDavid Schultz if (p == NULL) 1830fe769cddSDavid Schultz return (ESRCH); 1831fe769cddSDavid Schultz if ((error = p_cansee(curthread, p)) != 0) { 1832fe769cddSDavid Schultz PROC_UNLOCK(p); 1833fe769cddSDavid Schultz return (error); 1834fe769cddSDavid Schultz } 1835fe769cddSDavid Schultz } 1836fe769cddSDavid Schultz 1837fe769cddSDavid Schultz vp = p->p_textvp; 1838965b55e2SRobert Watson if (vp == NULL) { 1839965b55e2SRobert Watson if (*pidp != -1) 1840965b55e2SRobert Watson PROC_UNLOCK(p); 1841965b55e2SRobert Watson return (0); 1842965b55e2SRobert Watson } 1843fe769cddSDavid Schultz vref(vp); 1844fe769cddSDavid Schultz if (*pidp != -1) 1845fe769cddSDavid Schultz PROC_UNLOCK(p); 1846fe769cddSDavid Schultz error = vn_fullpath(req->td, vp, &retbuf, &freebuf); 184724f87fdbSJohn Baldwin vfslocked = VFS_LOCK_GIANT(vp->v_mount); 1848fe769cddSDavid Schultz vrele(vp); 184924f87fdbSJohn Baldwin VFS_UNLOCK_GIANT(vfslocked); 1850fe769cddSDavid Schultz if (error) 1851fe769cddSDavid Schultz return (error); 1852fe769cddSDavid Schultz error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1); 1853fe769cddSDavid Schultz free(freebuf, M_TEMP); 1854fe769cddSDavid Schultz return (error); 1855fe769cddSDavid Schultz } 1856fe769cddSDavid Schultz 1857baf731e6SRobert Drehmel static int 1858baf731e6SRobert Drehmel sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS) 1859baf731e6SRobert Drehmel { 1860baf731e6SRobert Drehmel struct proc *p; 1861baf731e6SRobert Drehmel char *sv_name; 1862baf731e6SRobert Drehmel int *name; 1863baf731e6SRobert Drehmel int namelen; 1864e76bad96SRobert Drehmel int error; 1865baf731e6SRobert Drehmel 1866baf731e6SRobert Drehmel namelen = arg2; 1867baf731e6SRobert Drehmel if (namelen != 1) 1868baf731e6SRobert Drehmel return (EINVAL); 1869baf731e6SRobert Drehmel 1870baf731e6SRobert Drehmel name = (int *)arg1; 1871baf731e6SRobert Drehmel if ((p = pfind((pid_t)name[0])) == NULL) 1872e76bad96SRobert Drehmel return (ESRCH); 1873e76bad96SRobert Drehmel if ((error = p_cansee(curthread, p))) { 1874baf731e6SRobert Drehmel PROC_UNLOCK(p); 1875e76bad96SRobert Drehmel return (error); 1876baf731e6SRobert Drehmel } 1877baf731e6SRobert Drehmel sv_name = p->p_sysent->sv_name; 1878baf731e6SRobert Drehmel PROC_UNLOCK(p); 1879baf731e6SRobert Drehmel return (sysctl_handle_string(oidp, sv_name, 0, req)); 1880baf731e6SRobert Drehmel } 1881baf731e6SRobert Drehmel 188243151ee6SPeter Wemm #ifdef KINFO_OVMENTRY_SIZE 188343151ee6SPeter Wemm CTASSERT(sizeof(struct kinfo_ovmentry) == KINFO_OVMENTRY_SIZE); 188443151ee6SPeter Wemm #endif 188543151ee6SPeter Wemm 188643151ee6SPeter Wemm #ifdef COMPAT_FREEBSD7 1887cc43c38cSRobert Watson static int 188843151ee6SPeter Wemm sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_ARGS) 1889cc43c38cSRobert Watson { 1890cc43c38cSRobert Watson vm_map_entry_t entry, tmp_entry; 1891cc43c38cSRobert Watson unsigned int last_timestamp; 1892cc43c38cSRobert Watson char *fullpath, *freepath; 189343151ee6SPeter Wemm struct kinfo_ovmentry *kve; 18947a9c4d24SPeter Wemm struct vattr va; 18957a9c4d24SPeter Wemm struct ucred *cred; 1896cc43c38cSRobert Watson int error, *name; 1897cc43c38cSRobert Watson struct vnode *vp; 1898cc43c38cSRobert Watson struct proc *p; 1899cc43c38cSRobert Watson vm_map_t map; 1900c7462f43SKonstantin Belousov struct vmspace *vm; 1901baf731e6SRobert Drehmel 1902cc43c38cSRobert Watson name = (int *)arg1; 1903cc43c38cSRobert Watson if ((p = pfind((pid_t)name[0])) == NULL) 1904cc43c38cSRobert Watson return (ESRCH); 190563d79c4fSRobert Watson if (p->p_flag & P_WEXIT) { 190663d79c4fSRobert Watson PROC_UNLOCK(p); 190763d79c4fSRobert Watson return (ESRCH); 190863d79c4fSRobert Watson } 1909cc43c38cSRobert Watson if ((error = p_candebug(curthread, p))) { 1910cc43c38cSRobert Watson PROC_UNLOCK(p); 1911cc43c38cSRobert Watson return (error); 1912cc43c38cSRobert Watson } 1913cc43c38cSRobert Watson _PHOLD(p); 1914cc43c38cSRobert Watson PROC_UNLOCK(p); 1915c7462f43SKonstantin Belousov vm = vmspace_acquire_ref(p); 1916c7462f43SKonstantin Belousov if (vm == NULL) { 1917c7462f43SKonstantin Belousov PRELE(p); 1918c7462f43SKonstantin Belousov return (ESRCH); 1919c7462f43SKonstantin Belousov } 1920cc43c38cSRobert Watson kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK); 1921cc43c38cSRobert Watson 1922ca4aa8c3SSergey Kandaurov map = &vm->vm_map; 1923cc43c38cSRobert Watson vm_map_lock_read(map); 1924cc43c38cSRobert Watson for (entry = map->header.next; entry != &map->header; 1925cc43c38cSRobert Watson entry = entry->next) { 1926cc43c38cSRobert Watson vm_object_t obj, tobj, lobj; 1927cc43c38cSRobert Watson vm_offset_t addr; 1928cc43c38cSRobert Watson int vfslocked; 1929cc43c38cSRobert Watson 1930cc43c38cSRobert Watson if (entry->eflags & MAP_ENTRY_IS_SUB_MAP) 1931cc43c38cSRobert Watson continue; 1932cc43c38cSRobert Watson 1933cc43c38cSRobert Watson bzero(kve, sizeof(*kve)); 1934cc43c38cSRobert Watson kve->kve_structsize = sizeof(*kve); 1935cc43c38cSRobert Watson 1936cc43c38cSRobert Watson kve->kve_private_resident = 0; 1937cc43c38cSRobert Watson obj = entry->object.vm_object; 1938cc43c38cSRobert Watson if (obj != NULL) { 1939cc43c38cSRobert Watson VM_OBJECT_LOCK(obj); 1940cc43c38cSRobert Watson if (obj->shadow_count == 1) 1941cc43c38cSRobert Watson kve->kve_private_resident = 1942cc43c38cSRobert Watson obj->resident_page_count; 1943cc43c38cSRobert Watson } 1944cc43c38cSRobert Watson kve->kve_resident = 0; 1945cc43c38cSRobert Watson addr = entry->start; 1946cc43c38cSRobert Watson while (addr < entry->end) { 1947cc43c38cSRobert Watson if (pmap_extract(map->pmap, addr)) 1948cc43c38cSRobert Watson kve->kve_resident++; 1949cc43c38cSRobert Watson addr += PAGE_SIZE; 1950cc43c38cSRobert Watson } 1951cc43c38cSRobert Watson 1952cc43c38cSRobert Watson for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) { 1953cc43c38cSRobert Watson if (tobj != obj) 1954cc43c38cSRobert Watson VM_OBJECT_LOCK(tobj); 1955cc43c38cSRobert Watson if (lobj != obj) 1956cc43c38cSRobert Watson VM_OBJECT_UNLOCK(lobj); 1957cc43c38cSRobert Watson lobj = tobj; 1958cc43c38cSRobert Watson } 1959cc43c38cSRobert Watson 1960118d0afaSKonstantin Belousov kve->kve_start = (void*)entry->start; 1961118d0afaSKonstantin Belousov kve->kve_end = (void*)entry->end; 1962118d0afaSKonstantin Belousov kve->kve_offset = (off_t)entry->offset; 1963118d0afaSKonstantin Belousov 1964118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_READ) 1965118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_READ; 1966118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_WRITE) 1967118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_WRITE; 1968118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_EXECUTE) 1969118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_EXEC; 1970118d0afaSKonstantin Belousov 1971118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_COW) 1972118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_COW; 1973118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_NEEDS_COPY) 1974118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_NEEDS_COPY; 1975937912eaSAttilio Rao if (entry->eflags & MAP_ENTRY_NOCOREDUMP) 1976937912eaSAttilio Rao kve->kve_flags |= KVME_FLAG_NOCOREDUMP; 1977118d0afaSKonstantin Belousov 1978118d0afaSKonstantin Belousov last_timestamp = map->timestamp; 1979118d0afaSKonstantin Belousov vm_map_unlock_read(map); 1980118d0afaSKonstantin Belousov 19817a9c4d24SPeter Wemm kve->kve_fileid = 0; 19827a9c4d24SPeter Wemm kve->kve_fsid = 0; 1983cc43c38cSRobert Watson freepath = NULL; 1984cc43c38cSRobert Watson fullpath = ""; 1985cc43c38cSRobert Watson if (lobj) { 1986cc43c38cSRobert Watson vp = NULL; 1987cc43c38cSRobert Watson switch (lobj->type) { 1988cc43c38cSRobert Watson case OBJT_DEFAULT: 1989cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_DEFAULT; 1990cc43c38cSRobert Watson break; 1991cc43c38cSRobert Watson case OBJT_VNODE: 1992cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_VNODE; 1993cc43c38cSRobert Watson vp = lobj->handle; 1994cc43c38cSRobert Watson vref(vp); 1995cc43c38cSRobert Watson break; 1996cc43c38cSRobert Watson case OBJT_SWAP: 1997cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_SWAP; 1998cc43c38cSRobert Watson break; 1999cc43c38cSRobert Watson case OBJT_DEVICE: 2000cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_DEVICE; 2001cc43c38cSRobert Watson break; 2002cc43c38cSRobert Watson case OBJT_PHYS: 2003cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_PHYS; 2004cc43c38cSRobert Watson break; 2005cc43c38cSRobert Watson case OBJT_DEAD: 2006cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_DEAD; 2007cc43c38cSRobert Watson break; 200801381811SJohn Baldwin case OBJT_SG: 200901381811SJohn Baldwin kve->kve_type = KVME_TYPE_SG; 201001381811SJohn Baldwin break; 2011cc43c38cSRobert Watson default: 2012cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_UNKNOWN; 2013cc43c38cSRobert Watson break; 2014cc43c38cSRobert Watson } 2015cc43c38cSRobert Watson if (lobj != obj) 2016cc43c38cSRobert Watson VM_OBJECT_UNLOCK(lobj); 2017cc43c38cSRobert Watson 2018cc43c38cSRobert Watson kve->kve_ref_count = obj->ref_count; 2019cc43c38cSRobert Watson kve->kve_shadow_count = obj->shadow_count; 2020cc43c38cSRobert Watson VM_OBJECT_UNLOCK(obj); 2021cc43c38cSRobert Watson if (vp != NULL) { 2022cc43c38cSRobert Watson vn_fullpath(curthread, vp, &fullpath, 2023cc43c38cSRobert Watson &freepath); 20247a9c4d24SPeter Wemm cred = curthread->td_ucred; 20252ff47c5fSJohn Baldwin vfslocked = VFS_LOCK_GIANT(vp->v_mount); 20262ff47c5fSJohn Baldwin vn_lock(vp, LK_SHARED | LK_RETRY); 20277a9c4d24SPeter Wemm if (VOP_GETATTR(vp, &va, cred) == 0) { 20287a9c4d24SPeter Wemm kve->kve_fileid = va.va_fileid; 20297a9c4d24SPeter Wemm kve->kve_fsid = va.va_fsid; 20307a9c4d24SPeter Wemm } 2031cc43c38cSRobert Watson vput(vp); 2032cc43c38cSRobert Watson VFS_UNLOCK_GIANT(vfslocked); 2033cc43c38cSRobert Watson } 2034cc43c38cSRobert Watson } else { 2035cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_NONE; 2036cc43c38cSRobert Watson kve->kve_ref_count = 0; 2037cc43c38cSRobert Watson kve->kve_shadow_count = 0; 2038cc43c38cSRobert Watson } 2039cc43c38cSRobert Watson 2040cc43c38cSRobert Watson strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path)); 2041cc43c38cSRobert Watson if (freepath != NULL) 2042cc43c38cSRobert Watson free(freepath, M_TEMP); 2043cc43c38cSRobert Watson 2044cc43c38cSRobert Watson error = SYSCTL_OUT(req, kve, sizeof(*kve)); 2045cc43c38cSRobert Watson vm_map_lock_read(map); 2046cc43c38cSRobert Watson if (error) 2047cc43c38cSRobert Watson break; 204822a448c4SKonstantin Belousov if (last_timestamp != map->timestamp) { 2049cc43c38cSRobert Watson vm_map_lookup_entry(map, addr - 1, &tmp_entry); 2050cc43c38cSRobert Watson entry = tmp_entry; 2051cc43c38cSRobert Watson } 2052cc43c38cSRobert Watson } 2053cc43c38cSRobert Watson vm_map_unlock_read(map); 2054c7462f43SKonstantin Belousov vmspace_free(vm); 2055cc43c38cSRobert Watson PRELE(p); 2056cc43c38cSRobert Watson free(kve, M_TEMP); 2057cc43c38cSRobert Watson return (error); 2058cc43c38cSRobert Watson } 205943151ee6SPeter Wemm #endif /* COMPAT_FREEBSD7 */ 206043151ee6SPeter Wemm 206143151ee6SPeter Wemm #ifdef KINFO_VMENTRY_SIZE 206243151ee6SPeter Wemm CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE); 206343151ee6SPeter Wemm #endif 206443151ee6SPeter Wemm 206543151ee6SPeter Wemm static int 206643151ee6SPeter Wemm sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS) 206743151ee6SPeter Wemm { 206843151ee6SPeter Wemm vm_map_entry_t entry, tmp_entry; 206943151ee6SPeter Wemm unsigned int last_timestamp; 207043151ee6SPeter Wemm char *fullpath, *freepath; 207143151ee6SPeter Wemm struct kinfo_vmentry *kve; 207243151ee6SPeter Wemm struct vattr va; 207343151ee6SPeter Wemm struct ucred *cred; 207443151ee6SPeter Wemm int error, *name; 207543151ee6SPeter Wemm struct vnode *vp; 207643151ee6SPeter Wemm struct proc *p; 2077c7462f43SKonstantin Belousov struct vmspace *vm; 207843151ee6SPeter Wemm vm_map_t map; 207943151ee6SPeter Wemm 208043151ee6SPeter Wemm name = (int *)arg1; 208143151ee6SPeter Wemm if ((p = pfind((pid_t)name[0])) == NULL) 208243151ee6SPeter Wemm return (ESRCH); 208343151ee6SPeter Wemm if (p->p_flag & P_WEXIT) { 208443151ee6SPeter Wemm PROC_UNLOCK(p); 208543151ee6SPeter Wemm return (ESRCH); 208643151ee6SPeter Wemm } 208743151ee6SPeter Wemm if ((error = p_candebug(curthread, p))) { 208843151ee6SPeter Wemm PROC_UNLOCK(p); 208943151ee6SPeter Wemm return (error); 209043151ee6SPeter Wemm } 209143151ee6SPeter Wemm _PHOLD(p); 209243151ee6SPeter Wemm PROC_UNLOCK(p); 2093c7462f43SKonstantin Belousov vm = vmspace_acquire_ref(p); 2094c7462f43SKonstantin Belousov if (vm == NULL) { 2095c7462f43SKonstantin Belousov PRELE(p); 2096c7462f43SKonstantin Belousov return (ESRCH); 2097c7462f43SKonstantin Belousov } 209843151ee6SPeter Wemm kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK); 209943151ee6SPeter Wemm 2100ca4aa8c3SSergey Kandaurov map = &vm->vm_map; 210143151ee6SPeter Wemm vm_map_lock_read(map); 210243151ee6SPeter Wemm for (entry = map->header.next; entry != &map->header; 210343151ee6SPeter Wemm entry = entry->next) { 210443151ee6SPeter Wemm vm_object_t obj, tobj, lobj; 210543151ee6SPeter Wemm vm_offset_t addr; 21065384d089SMikolaj Golub vm_paddr_t locked_pa; 21075384d089SMikolaj Golub int vfslocked, mincoreinfo; 210843151ee6SPeter Wemm 210943151ee6SPeter Wemm if (entry->eflags & MAP_ENTRY_IS_SUB_MAP) 211043151ee6SPeter Wemm continue; 211143151ee6SPeter Wemm 211243151ee6SPeter Wemm bzero(kve, sizeof(*kve)); 211343151ee6SPeter Wemm 211443151ee6SPeter Wemm kve->kve_private_resident = 0; 211543151ee6SPeter Wemm obj = entry->object.vm_object; 211643151ee6SPeter Wemm if (obj != NULL) { 211743151ee6SPeter Wemm VM_OBJECT_LOCK(obj); 211843151ee6SPeter Wemm if (obj->shadow_count == 1) 211943151ee6SPeter Wemm kve->kve_private_resident = 212043151ee6SPeter Wemm obj->resident_page_count; 212143151ee6SPeter Wemm } 212243151ee6SPeter Wemm kve->kve_resident = 0; 212343151ee6SPeter Wemm addr = entry->start; 212443151ee6SPeter Wemm while (addr < entry->end) { 21255384d089SMikolaj Golub locked_pa = 0; 21265384d089SMikolaj Golub mincoreinfo = pmap_mincore(map->pmap, addr, &locked_pa); 21275384d089SMikolaj Golub if (locked_pa != 0) 21285384d089SMikolaj Golub vm_page_unlock(PHYS_TO_VM_PAGE(locked_pa)); 21295384d089SMikolaj Golub if (mincoreinfo & MINCORE_INCORE) 213043151ee6SPeter Wemm kve->kve_resident++; 21315384d089SMikolaj Golub if (mincoreinfo & MINCORE_SUPER) 21325384d089SMikolaj Golub kve->kve_flags |= KVME_FLAG_SUPER; 213343151ee6SPeter Wemm addr += PAGE_SIZE; 213443151ee6SPeter Wemm } 213543151ee6SPeter Wemm 213643151ee6SPeter Wemm for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) { 213743151ee6SPeter Wemm if (tobj != obj) 213843151ee6SPeter Wemm VM_OBJECT_LOCK(tobj); 213943151ee6SPeter Wemm if (lobj != obj) 214043151ee6SPeter Wemm VM_OBJECT_UNLOCK(lobj); 214143151ee6SPeter Wemm lobj = tobj; 214243151ee6SPeter Wemm } 214343151ee6SPeter Wemm 2144118d0afaSKonstantin Belousov kve->kve_start = entry->start; 2145118d0afaSKonstantin Belousov kve->kve_end = entry->end; 2146118d0afaSKonstantin Belousov kve->kve_offset = entry->offset; 2147118d0afaSKonstantin Belousov 2148118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_READ) 2149118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_READ; 2150118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_WRITE) 2151118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_WRITE; 2152118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_EXECUTE) 2153118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_EXEC; 2154118d0afaSKonstantin Belousov 2155118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_COW) 2156118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_COW; 2157118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_NEEDS_COPY) 2158118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_NEEDS_COPY; 2159937912eaSAttilio Rao if (entry->eflags & MAP_ENTRY_NOCOREDUMP) 2160937912eaSAttilio Rao kve->kve_flags |= KVME_FLAG_NOCOREDUMP; 2161118d0afaSKonstantin Belousov 2162118d0afaSKonstantin Belousov last_timestamp = map->timestamp; 2163118d0afaSKonstantin Belousov vm_map_unlock_read(map); 2164118d0afaSKonstantin Belousov 216543151ee6SPeter Wemm freepath = NULL; 216643151ee6SPeter Wemm fullpath = ""; 216743151ee6SPeter Wemm if (lobj) { 216843151ee6SPeter Wemm vp = NULL; 216943151ee6SPeter Wemm switch (lobj->type) { 217043151ee6SPeter Wemm case OBJT_DEFAULT: 217143151ee6SPeter Wemm kve->kve_type = KVME_TYPE_DEFAULT; 217243151ee6SPeter Wemm break; 217343151ee6SPeter Wemm case OBJT_VNODE: 217443151ee6SPeter Wemm kve->kve_type = KVME_TYPE_VNODE; 217543151ee6SPeter Wemm vp = lobj->handle; 217643151ee6SPeter Wemm vref(vp); 217743151ee6SPeter Wemm break; 217843151ee6SPeter Wemm case OBJT_SWAP: 217943151ee6SPeter Wemm kve->kve_type = KVME_TYPE_SWAP; 218043151ee6SPeter Wemm break; 218143151ee6SPeter Wemm case OBJT_DEVICE: 218243151ee6SPeter Wemm kve->kve_type = KVME_TYPE_DEVICE; 218343151ee6SPeter Wemm break; 218443151ee6SPeter Wemm case OBJT_PHYS: 218543151ee6SPeter Wemm kve->kve_type = KVME_TYPE_PHYS; 218643151ee6SPeter Wemm break; 218743151ee6SPeter Wemm case OBJT_DEAD: 218843151ee6SPeter Wemm kve->kve_type = KVME_TYPE_DEAD; 218943151ee6SPeter Wemm break; 219001381811SJohn Baldwin case OBJT_SG: 219101381811SJohn Baldwin kve->kve_type = KVME_TYPE_SG; 219201381811SJohn Baldwin break; 219343151ee6SPeter Wemm default: 219443151ee6SPeter Wemm kve->kve_type = KVME_TYPE_UNKNOWN; 219543151ee6SPeter Wemm break; 219643151ee6SPeter Wemm } 219743151ee6SPeter Wemm if (lobj != obj) 219843151ee6SPeter Wemm VM_OBJECT_UNLOCK(lobj); 219943151ee6SPeter Wemm 220043151ee6SPeter Wemm kve->kve_ref_count = obj->ref_count; 220143151ee6SPeter Wemm kve->kve_shadow_count = obj->shadow_count; 220243151ee6SPeter Wemm VM_OBJECT_UNLOCK(obj); 220343151ee6SPeter Wemm if (vp != NULL) { 220443151ee6SPeter Wemm vn_fullpath(curthread, vp, &fullpath, 220543151ee6SPeter Wemm &freepath); 22060daf62d9SStanislav Sedov kve->kve_vn_type = vntype_to_kinfo(vp->v_type); 220743151ee6SPeter Wemm cred = curthread->td_ucred; 220843151ee6SPeter Wemm vfslocked = VFS_LOCK_GIANT(vp->v_mount); 220943151ee6SPeter Wemm vn_lock(vp, LK_SHARED | LK_RETRY); 221043151ee6SPeter Wemm if (VOP_GETATTR(vp, &va, cred) == 0) { 22110daf62d9SStanislav Sedov kve->kve_vn_fileid = va.va_fileid; 22120daf62d9SStanislav Sedov kve->kve_vn_fsid = va.va_fsid; 22130daf62d9SStanislav Sedov kve->kve_vn_mode = 22140daf62d9SStanislav Sedov MAKEIMODE(va.va_type, va.va_mode); 22150daf62d9SStanislav Sedov kve->kve_vn_size = va.va_size; 22160daf62d9SStanislav Sedov kve->kve_vn_rdev = va.va_rdev; 22170daf62d9SStanislav Sedov kve->kve_status = KF_ATTR_VALID; 221843151ee6SPeter Wemm } 221943151ee6SPeter Wemm vput(vp); 222043151ee6SPeter Wemm VFS_UNLOCK_GIANT(vfslocked); 222143151ee6SPeter Wemm } 222243151ee6SPeter Wemm } else { 222343151ee6SPeter Wemm kve->kve_type = KVME_TYPE_NONE; 222443151ee6SPeter Wemm kve->kve_ref_count = 0; 222543151ee6SPeter Wemm kve->kve_shadow_count = 0; 222643151ee6SPeter Wemm } 222743151ee6SPeter Wemm 222843151ee6SPeter Wemm strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path)); 222943151ee6SPeter Wemm if (freepath != NULL) 223043151ee6SPeter Wemm free(freepath, M_TEMP); 223143151ee6SPeter Wemm 223243151ee6SPeter Wemm /* Pack record size down */ 223343151ee6SPeter Wemm kve->kve_structsize = offsetof(struct kinfo_vmentry, kve_path) + 223443151ee6SPeter Wemm strlen(kve->kve_path) + 1; 223543151ee6SPeter Wemm kve->kve_structsize = roundup(kve->kve_structsize, 223643151ee6SPeter Wemm sizeof(uint64_t)); 223743151ee6SPeter Wemm error = SYSCTL_OUT(req, kve, kve->kve_structsize); 223843151ee6SPeter Wemm vm_map_lock_read(map); 223943151ee6SPeter Wemm if (error) 224043151ee6SPeter Wemm break; 224122a448c4SKonstantin Belousov if (last_timestamp != map->timestamp) { 224243151ee6SPeter Wemm vm_map_lookup_entry(map, addr - 1, &tmp_entry); 224343151ee6SPeter Wemm entry = tmp_entry; 224443151ee6SPeter Wemm } 224543151ee6SPeter Wemm } 224643151ee6SPeter Wemm vm_map_unlock_read(map); 2247c7462f43SKonstantin Belousov vmspace_free(vm); 224843151ee6SPeter Wemm PRELE(p); 224943151ee6SPeter Wemm free(kve, M_TEMP); 225043151ee6SPeter Wemm return (error); 225143151ee6SPeter Wemm } 2252cc43c38cSRobert Watson 22531cc8c45cSRobert Watson #if defined(STACK) || defined(DDB) 22541cc8c45cSRobert Watson static int 22551cc8c45cSRobert Watson sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS) 22561cc8c45cSRobert Watson { 22571cc8c45cSRobert Watson struct kinfo_kstack *kkstp; 22581cc8c45cSRobert Watson int error, i, *name, numthreads; 22591cc8c45cSRobert Watson lwpid_t *lwpidarray; 22601cc8c45cSRobert Watson struct thread *td; 22611cc8c45cSRobert Watson struct stack *st; 22621cc8c45cSRobert Watson struct sbuf sb; 22631cc8c45cSRobert Watson struct proc *p; 22641cc8c45cSRobert Watson 22651cc8c45cSRobert Watson name = (int *)arg1; 22661cc8c45cSRobert Watson if ((p = pfind((pid_t)name[0])) == NULL) 22671cc8c45cSRobert Watson return (ESRCH); 22680417fe54SRobert Watson /* XXXRW: Not clear ESRCH is the right error during proc execve(). */ 22690417fe54SRobert Watson if (p->p_flag & P_WEXIT || p->p_flag & P_INEXEC) { 227063d79c4fSRobert Watson PROC_UNLOCK(p); 227163d79c4fSRobert Watson return (ESRCH); 227263d79c4fSRobert Watson } 22731cc8c45cSRobert Watson if ((error = p_candebug(curthread, p))) { 22741cc8c45cSRobert Watson PROC_UNLOCK(p); 22751cc8c45cSRobert Watson return (error); 22761cc8c45cSRobert Watson } 22771cc8c45cSRobert Watson _PHOLD(p); 22781cc8c45cSRobert Watson PROC_UNLOCK(p); 22791cc8c45cSRobert Watson 22801cc8c45cSRobert Watson kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK); 22811cc8c45cSRobert Watson st = stack_create(); 22821cc8c45cSRobert Watson 22831cc8c45cSRobert Watson lwpidarray = NULL; 22841cc8c45cSRobert Watson numthreads = 0; 2285374ae2a3SJeff Roberson PROC_LOCK(p); 22861cc8c45cSRobert Watson repeat: 22871cc8c45cSRobert Watson if (numthreads < p->p_numthreads) { 22881cc8c45cSRobert Watson if (lwpidarray != NULL) { 22891cc8c45cSRobert Watson free(lwpidarray, M_TEMP); 22901cc8c45cSRobert Watson lwpidarray = NULL; 22911cc8c45cSRobert Watson } 22921cc8c45cSRobert Watson numthreads = p->p_numthreads; 2293374ae2a3SJeff Roberson PROC_UNLOCK(p); 22941cc8c45cSRobert Watson lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP, 22951cc8c45cSRobert Watson M_WAITOK | M_ZERO); 2296374ae2a3SJeff Roberson PROC_LOCK(p); 22971cc8c45cSRobert Watson goto repeat; 22981cc8c45cSRobert Watson } 22991cc8c45cSRobert Watson i = 0; 23001cc8c45cSRobert Watson 23011cc8c45cSRobert Watson /* 23021cc8c45cSRobert Watson * XXXRW: During the below loop, execve(2) and countless other sorts 23031cc8c45cSRobert Watson * of changes could have taken place. Should we check to see if the 23041cc8c45cSRobert Watson * vmspace has been replaced, or the like, in order to prevent 23051cc8c45cSRobert Watson * giving a snapshot that spans, say, execve(2), with some threads 23061cc8c45cSRobert Watson * before and some after? Among other things, the credentials could 23071cc8c45cSRobert Watson * have changed, in which case the right to extract debug info might 23081cc8c45cSRobert Watson * no longer be assured. 23091cc8c45cSRobert Watson */ 23101cc8c45cSRobert Watson FOREACH_THREAD_IN_PROC(p, td) { 23111cc8c45cSRobert Watson KASSERT(i < numthreads, 23121cc8c45cSRobert Watson ("sysctl_kern_proc_kstack: numthreads")); 23131cc8c45cSRobert Watson lwpidarray[i] = td->td_tid; 23141cc8c45cSRobert Watson i++; 23151cc8c45cSRobert Watson } 23161cc8c45cSRobert Watson numthreads = i; 23171cc8c45cSRobert Watson for (i = 0; i < numthreads; i++) { 23181cc8c45cSRobert Watson td = thread_find(p, lwpidarray[i]); 23191cc8c45cSRobert Watson if (td == NULL) { 23201cc8c45cSRobert Watson continue; 23211cc8c45cSRobert Watson } 23221cc8c45cSRobert Watson bzero(kkstp, sizeof(*kkstp)); 23231cc8c45cSRobert Watson (void)sbuf_new(&sb, kkstp->kkst_trace, 23241cc8c45cSRobert Watson sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN); 23251cc8c45cSRobert Watson thread_lock(td); 23261cc8c45cSRobert Watson kkstp->kkst_tid = td->td_tid; 23271cc8c45cSRobert Watson if (TD_IS_SWAPPED(td)) 23281cc8c45cSRobert Watson kkstp->kkst_state = KKST_STATE_SWAPPED; 23291cc8c45cSRobert Watson else if (TD_IS_RUNNING(td)) 23301cc8c45cSRobert Watson kkstp->kkst_state = KKST_STATE_RUNNING; 23311cc8c45cSRobert Watson else { 23321cc8c45cSRobert Watson kkstp->kkst_state = KKST_STATE_STACKOK; 23331cc8c45cSRobert Watson stack_save_td(st, td); 23341cc8c45cSRobert Watson } 23351cc8c45cSRobert Watson thread_unlock(td); 23361cc8c45cSRobert Watson PROC_UNLOCK(p); 23371cc8c45cSRobert Watson stack_sbuf_print(&sb, st); 23381cc8c45cSRobert Watson sbuf_finish(&sb); 23391cc8c45cSRobert Watson sbuf_delete(&sb); 23401cc8c45cSRobert Watson error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp)); 23411cc8c45cSRobert Watson PROC_LOCK(p); 23421cc8c45cSRobert Watson if (error) 23431cc8c45cSRobert Watson break; 23441cc8c45cSRobert Watson } 23451cc8c45cSRobert Watson _PRELE(p); 23461cc8c45cSRobert Watson PROC_UNLOCK(p); 23471cc8c45cSRobert Watson if (lwpidarray != NULL) 23481cc8c45cSRobert Watson free(lwpidarray, M_TEMP); 23491cc8c45cSRobert Watson stack_destroy(st); 23501cc8c45cSRobert Watson free(kkstp, M_TEMP); 23511cc8c45cSRobert Watson return (error); 23521cc8c45cSRobert Watson } 23531cc8c45cSRobert Watson #endif 23541cc8c45cSRobert Watson 2355254d03c5SBrooks Davis /* 2356254d03c5SBrooks Davis * This sysctl allows a process to retrieve the full list of groups from 2357254d03c5SBrooks Davis * itself or another process. 2358254d03c5SBrooks Davis */ 2359254d03c5SBrooks Davis static int 2360254d03c5SBrooks Davis sysctl_kern_proc_groups(SYSCTL_HANDLER_ARGS) 2361254d03c5SBrooks Davis { 2362254d03c5SBrooks Davis pid_t *pidp = (pid_t *)arg1; 2363254d03c5SBrooks Davis unsigned int arglen = arg2; 2364254d03c5SBrooks Davis struct proc *p; 2365254d03c5SBrooks Davis struct ucred *cred; 2366254d03c5SBrooks Davis int error; 2367254d03c5SBrooks Davis 2368254d03c5SBrooks Davis if (arglen != 1) 2369254d03c5SBrooks Davis return (EINVAL); 2370254d03c5SBrooks Davis if (*pidp == -1) { /* -1 means this process */ 2371254d03c5SBrooks Davis p = req->td->td_proc; 2372254d03c5SBrooks Davis } else { 2373254d03c5SBrooks Davis p = pfind(*pidp); 2374254d03c5SBrooks Davis if (p == NULL) 2375254d03c5SBrooks Davis return (ESRCH); 2376254d03c5SBrooks Davis if ((error = p_cansee(curthread, p)) != 0) { 2377254d03c5SBrooks Davis PROC_UNLOCK(p); 2378254d03c5SBrooks Davis return (error); 2379254d03c5SBrooks Davis } 2380254d03c5SBrooks Davis } 2381254d03c5SBrooks Davis 2382254d03c5SBrooks Davis cred = crhold(p->p_ucred); 2383254d03c5SBrooks Davis if (*pidp != -1) 2384254d03c5SBrooks Davis PROC_UNLOCK(p); 2385254d03c5SBrooks Davis 2386254d03c5SBrooks Davis error = SYSCTL_OUT(req, cred->cr_groups, 2387254d03c5SBrooks Davis cred->cr_ngroups * sizeof(gid_t)); 2388254d03c5SBrooks Davis crfree(cred); 2389254d03c5SBrooks Davis return (error); 2390254d03c5SBrooks Davis } 2391254d03c5SBrooks Davis 2392cc43c38cSRobert Watson SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table"); 23933ce93e4eSPoul-Henning Kamp 239424f87fdbSJohn Baldwin SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT| 239524f87fdbSJohn Baldwin CTLFLAG_MPSAFE, 0, 0, sysctl_kern_proc, "S,proc", 239624f87fdbSJohn Baldwin "Return entire process table"); 23973ce93e4eSPoul-Henning Kamp 239824f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD | CTLFLAG_MPSAFE, 2399078842c5SGarance A Drosehn sysctl_kern_proc, "Process table"); 2400078842c5SGarance A Drosehn 240124f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD | CTLFLAG_MPSAFE, 24023ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 24033ce93e4eSPoul-Henning Kamp 240424f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD | CTLFLAG_MPSAFE, 2405b8fdc89dSGarance A Drosehn sysctl_kern_proc, "Process table"); 2406b8fdc89dSGarance A Drosehn 240724f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD | 240824f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 240924f87fdbSJohn Baldwin 241024f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD | CTLFLAG_MPSAFE, 2411b8fdc89dSGarance A Drosehn sysctl_kern_proc, "Process table"); 2412b8fdc89dSGarance A Drosehn 241324f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD | CTLFLAG_MPSAFE, 24143ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 24153ce93e4eSPoul-Henning Kamp 241624f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD | CTLFLAG_MPSAFE, 24173ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 24183ce93e4eSPoul-Henning Kamp 241924f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD | CTLFLAG_MPSAFE, 24203ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 24213ce93e4eSPoul-Henning Kamp 242224f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD | CTLFLAG_MPSAFE, 242330c6f34eSScott Long sysctl_kern_proc, "Return process table, no threads"); 242430c6f34eSScott Long 24250c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args, 242624f87fdbSJohn Baldwin CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, 24279b6d9dbaSPoul-Henning Kamp sysctl_kern_proc_args, "Process argument list"); 2428baf731e6SRobert Drehmel 2429c5cfcb1cSMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_ENV, env, 2430c5cfcb1cSMikolaj Golub CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, 2431c5cfcb1cSMikolaj Golub sysctl_kern_proc_env, "Process environment"); 2432c5cfcb1cSMikolaj Golub 2433c5cfcb1cSMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_AUXV, auxv, 2434c5cfcb1cSMikolaj Golub CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, 2435c5cfcb1cSMikolaj Golub sysctl_kern_proc_auxv, "Process ELF auxiliary vector"); 2436c5cfcb1cSMikolaj Golub 243724f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD | 243824f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_pathname, "Process executable path"); 2439fe769cddSDavid Schultz 244024f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD | 244124f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_sv_name, 244224f87fdbSJohn Baldwin "Process syscall vector name (ABI type)"); 24432648efa6SDaniel Eischen 24440c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td, 244524f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 2446078842c5SGarance A Drosehn 24470c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td, 244824f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 24492648efa6SDaniel Eischen 24500c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td, 245124f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 2452b8fdc89dSGarance A Drosehn 24530c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD), 245424f87fdbSJohn Baldwin sid_td, CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 24550c898376SPoul-Henning Kamp 24560c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td, 245724f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 2458b8fdc89dSGarance A Drosehn 24590c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td, 246024f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 24612648efa6SDaniel Eischen 24620c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td, 246324f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 24642648efa6SDaniel Eischen 24650c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td, 246624f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 24672648efa6SDaniel Eischen 24680c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td, 246924f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, 247024f87fdbSJohn Baldwin "Return process table, no threads"); 2471cc43c38cSRobert Watson 247243151ee6SPeter Wemm #ifdef COMPAT_FREEBSD7 247324f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_OVMMAP, ovmmap, CTLFLAG_RD | 247424f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_ovmmap, "Old Process vm map entries"); 247543151ee6SPeter Wemm #endif 247643151ee6SPeter Wemm 247724f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_VMMAP, vmmap, CTLFLAG_RD | 247824f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_vmmap, "Process vm map entries"); 24791cc8c45cSRobert Watson 24801cc8c45cSRobert Watson #if defined(STACK) || defined(DDB) 248124f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_KSTACK, kstack, CTLFLAG_RD | 248224f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_kstack, "Process kernel stacks"); 24831cc8c45cSRobert Watson #endif 2484254d03c5SBrooks Davis 2485254d03c5SBrooks Davis static SYSCTL_NODE(_kern_proc, KERN_PROC_GROUPS, groups, CTLFLAG_RD | 2486254d03c5SBrooks Davis CTLFLAG_MPSAFE, sysctl_kern_proc_groups, "Process groups"); 2487