19454b2d8SWarner Losh /*- 251369649SPedro F. Giffuni * SPDX-License-Identifier: BSD-3-Clause 351369649SPedro F. Giffuni * 4df8bae1dSRodney W. Grimes * Copyright (c) 1982, 1986, 1989, 1991, 1993 5df8bae1dSRodney W. Grimes * The Regents of the University of California. All rights reserved. 6df8bae1dSRodney W. Grimes * 7df8bae1dSRodney W. Grimes * Redistribution and use in source and binary forms, with or without 8df8bae1dSRodney W. Grimes * modification, are permitted provided that the following conditions 9df8bae1dSRodney W. Grimes * are met: 10df8bae1dSRodney W. Grimes * 1. Redistributions of source code must retain the above copyright 11df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer. 12df8bae1dSRodney W. Grimes * 2. Redistributions in binary form must reproduce the above copyright 13df8bae1dSRodney W. Grimes * notice, this list of conditions and the following disclaimer in the 14df8bae1dSRodney W. Grimes * documentation and/or other materials provided with the distribution. 1569a28758SEd Maste * 3. Neither the name of the University nor the names of its contributors 16df8bae1dSRodney W. Grimes * may be used to endorse or promote products derived from this software 17df8bae1dSRodney W. Grimes * without specific prior written permission. 18df8bae1dSRodney W. Grimes * 19df8bae1dSRodney W. Grimes * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20df8bae1dSRodney W. Grimes * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21df8bae1dSRodney W. Grimes * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22df8bae1dSRodney W. Grimes * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23df8bae1dSRodney W. Grimes * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24df8bae1dSRodney W. Grimes * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25df8bae1dSRodney W. Grimes * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26df8bae1dSRodney W. Grimes * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27df8bae1dSRodney W. Grimes * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28df8bae1dSRodney W. Grimes * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29df8bae1dSRodney W. Grimes * SUCH DAMAGE. 30df8bae1dSRodney W. Grimes * 31b75356e1SJeffrey Hsu * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95 32df8bae1dSRodney W. Grimes */ 33df8bae1dSRodney W. Grimes 34677b542eSDavid E. O'Brien #include <sys/cdefs.h> 35677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 36677b542eSDavid E. O'Brien 37cc43c38cSRobert Watson #include "opt_ddb.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> 45b4490c6eSKonstantin Belousov #include <sys/eventhandler.h> 46c5cfcb1cSMikolaj Golub #include <sys/exec.h> 47b4490c6eSKonstantin Belousov #include <sys/jail.h> 48df8bae1dSRodney W. Grimes #include <sys/kernel.h> 4905e06d11SKonstantin Belousov #include <sys/limits.h> 50fb919e4dSMark Murray #include <sys/lock.h> 517123f4cdSEdward Tomasz Napierala #include <sys/loginclass.h> 52df8bae1dSRodney W. Grimes #include <sys/malloc.h> 535384d089SMikolaj Golub #include <sys/mman.h> 54cc43c38cSRobert Watson #include <sys/mount.h> 55fb919e4dSMark Murray #include <sys/mutex.h> 56b9df5231SPoul-Henning Kamp #include <sys/proc.h> 57c5cfcb1cSMikolaj Golub #include <sys/ptrace.h> 5855b4a5aeSJohn Baldwin #include <sys/refcount.h> 599e7d0583SMikolaj Golub #include <sys/resourcevar.h> 6089f6b863SAttilio Rao #include <sys/rwlock.h> 61cc43c38cSRobert Watson #include <sys/sbuf.h> 62baf731e6SRobert Drehmel #include <sys/sysent.h> 63de028f5aSJeff Roberson #include <sys/sched.h> 64165d2b99SJulian Elischer #include <sys/smp.h> 651cc8c45cSRobert Watson #include <sys/stack.h> 666ce13747SMikolaj Golub #include <sys/stat.h> 67fb919e4dSMark Murray #include <sys/sysctl.h> 6862d6ce3aSDon Lewis #include <sys/filedesc.h> 69df8bae1dSRodney W. Grimes #include <sys/tty.h> 70bb56ec4aSPoul-Henning Kamp #include <sys/signalvar.h> 715d217f17SJohn Birrell #include <sys/sdt.h> 721005a129SJohn Baldwin #include <sys/sx.h> 73fb919e4dSMark Murray #include <sys/user.h> 74fe769cddSDavid Schultz #include <sys/vnode.h> 75b4490c6eSKonstantin Belousov #include <sys/wait.h> 76fb919e4dSMark Murray 77cc43c38cSRobert Watson #ifdef DDB 78cc43c38cSRobert Watson #include <ddb/ddb.h> 79cc43c38cSRobert Watson #endif 80cc43c38cSRobert Watson 81efeaf95aSDavid Greenman #include <vm/vm.h> 821c771f92SKonstantin Belousov #include <vm/vm_param.h> 83a136efe9SPeter Wemm #include <vm/vm_extern.h> 84efeaf95aSDavid Greenman #include <vm/pmap.h> 85efeaf95aSDavid Greenman #include <vm/vm_map.h> 86cc43c38cSRobert Watson #include <vm/vm_object.h> 875384d089SMikolaj Golub #include <vm/vm_page.h> 88c897b813SJeff Roberson #include <vm/uma.h> 89df8bae1dSRodney W. Grimes 9005e06d11SKonstantin Belousov #ifdef COMPAT_FREEBSD32 9105e06d11SKonstantin Belousov #include <compat/freebsd32/freebsd32.h> 9205e06d11SKonstantin Belousov #include <compat/freebsd32/freebsd32_util.h> 9305e06d11SKonstantin Belousov #endif 9405e06d11SKonstantin Belousov 955d217f17SJohn Birrell SDT_PROVIDER_DEFINE(proc); 965d217f17SJohn Birrell 97f591779bSSeigo Tanimura MALLOC_DEFINE(M_PGRP, "pgrp", "process group header"); 98a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SESSION, "session", "session header"); 99876a94eeSBruce Evans static MALLOC_DEFINE(M_PROC, "proc", "Proc structures"); 100a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures"); 10155166637SPoul-Henning Kamp 1024d77a549SAlfred Perlstein static void doenterpgrp(struct proc *, struct pgrp *); 1034d77a549SAlfred Perlstein static void orphanpg(struct pgrp *pg); 104f8d90480SAttilio Rao static void fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp); 1055032ff81SDon Lewis static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp); 106d92909c1SRobert Watson static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, 107d92909c1SRobert Watson int preferthread); 10802e878d9SJohn Baldwin static void pgadjustjobc(struct pgrp *pgrp, int entering); 10902e878d9SJohn Baldwin static void pgdelete(struct pgrp *); 110b23f72e9SBrian Feldman static int proc_ctor(void *mem, int size, void *arg, int flags); 111a136efe9SPeter Wemm static void proc_dtor(void *mem, int size, void *arg); 112b23f72e9SBrian Feldman static int proc_init(void *mem, int size, int flags); 113a136efe9SPeter Wemm static void proc_fini(void *mem, int size); 11458e8af1bSKonstantin Belousov static void pargs_free(struct pargs *pa); 115134eb42eSKonstantin Belousov static struct proc *zpfind_locked(pid_t pid); 116a136efe9SPeter Wemm 117df8bae1dSRodney W. Grimes /* 118b75356e1SJeffrey Hsu * Other process lists 119b75356e1SJeffrey Hsu */ 120b75356e1SJeffrey Hsu struct pidhashhead *pidhashtbl; 121b75356e1SJeffrey Hsu u_long pidhash; 122b75356e1SJeffrey Hsu struct pgrphashhead *pgrphashtbl; 123b75356e1SJeffrey Hsu u_long pgrphash; 124b75356e1SJeffrey Hsu struct proclist allproc; 125b75356e1SJeffrey Hsu struct proclist zombproc; 1263e72c844SMateusz Guzik struct sx __exclusive_cache_line allproc_lock; 1273e72c844SMateusz Guzik struct sx __exclusive_cache_line proctree_lock; 1283e72c844SMateusz Guzik struct mtx __exclusive_cache_line ppeers_lock; 129c897b813SJeff Roberson uma_zone_t proc_zone; 130b75356e1SJeffrey Hsu 131645743eaSJohn Baldwin /* 132645743eaSJohn Baldwin * The offset of various fields in struct proc and struct thread. 133645743eaSJohn Baldwin * These are used by kernel debuggers to enumerate kernel threads and 134645743eaSJohn Baldwin * processes. 135645743eaSJohn Baldwin */ 136645743eaSJohn Baldwin const int proc_off_p_pid = offsetof(struct proc, p_pid); 137645743eaSJohn Baldwin const int proc_off_p_comm = offsetof(struct proc, p_comm); 138645743eaSJohn Baldwin const int proc_off_p_list = offsetof(struct proc, p_list); 139645743eaSJohn Baldwin const int proc_off_p_threads = offsetof(struct proc, p_threads); 140645743eaSJohn Baldwin const int thread_off_td_tid = offsetof(struct thread, td_tid); 141645743eaSJohn Baldwin const int thread_off_td_name = offsetof(struct thread, td_name); 142645743eaSJohn Baldwin const int thread_off_td_oncpu = offsetof(struct thread, td_oncpu); 143645743eaSJohn Baldwin const int thread_off_td_pcb = offsetof(struct thread, td_pcb); 144645743eaSJohn Baldwin const int thread_off_td_plist = offsetof(struct thread, td_plist); 145645743eaSJohn Baldwin 1462ca45184SMatt Joras EVENTHANDLER_LIST_DEFINE(process_ctor); 1472ca45184SMatt Joras EVENTHANDLER_LIST_DEFINE(process_dtor); 1482ca45184SMatt Joras EVENTHANDLER_LIST_DEFINE(process_init); 1492ca45184SMatt Joras EVENTHANDLER_LIST_DEFINE(process_fini); 1502ca45184SMatt Joras EVENTHANDLER_LIST_DEFINE(process_exit); 1512ca45184SMatt Joras EVENTHANDLER_LIST_DEFINE(process_fork); 1522ca45184SMatt Joras EVENTHANDLER_LIST_DEFINE(process_exec); 1532ca45184SMatt Joras 1542ca45184SMatt Joras EVENTHANDLER_LIST_DECLARE(thread_ctor); 1552ca45184SMatt Joras EVENTHANDLER_LIST_DECLARE(thread_dtor); 1562ca45184SMatt Joras 157b9f009b0SPeter Wemm int kstack_pages = KSTACK_PAGES; 158b389be97SRebecca Cran SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0, 159b389be97SRebecca Cran "Kernel stack size in pages"); 160a91831a2SKonstantin Belousov static int vmmap_skip_res_cnt = 0; 161a91831a2SKonstantin Belousov SYSCTL_INT(_kern, OID_AUTO, proc_vmmap_skip_resident_count, CTLFLAG_RW, 162a91831a2SKonstantin Belousov &vmmap_skip_res_cnt, 0, 163a91831a2SKonstantin Belousov "Skip calculation of the pages resident count in kern.proc.vmmap"); 164b9f009b0SPeter Wemm 165a30d7c60SJake Burkholder CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE); 166ed780687SKonstantin Belousov #ifdef COMPAT_FREEBSD32 167ed780687SKonstantin Belousov CTASSERT(sizeof(struct kinfo_proc32) == KINFO_PROC32_SIZE); 168ed780687SKonstantin Belousov #endif 169a30d7c60SJake Burkholder 170b75356e1SJeffrey Hsu /* 171b75356e1SJeffrey Hsu * Initialize global process hashing structures. 172df8bae1dSRodney W. Grimes */ 17326f9a767SRodney W. Grimes void 174314381b5SKonstantin Belousov procinit(void) 175df8bae1dSRodney W. Grimes { 176df8bae1dSRodney W. Grimes 1771005a129SJohn Baldwin sx_init(&allproc_lock, "allproc"); 1781005a129SJohn Baldwin sx_init(&proctree_lock, "proctree"); 179c6544064SJohn Baldwin mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF); 180b75356e1SJeffrey Hsu LIST_INIT(&allproc); 181b75356e1SJeffrey Hsu LIST_INIT(&zombproc); 182b75356e1SJeffrey Hsu pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash); 183b75356e1SJeffrey Hsu pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash); 184de028f5aSJeff Roberson proc_zone = uma_zcreate("PROC", sched_sizeof_proc(), 185a136efe9SPeter Wemm proc_ctor, proc_dtor, proc_init, proc_fini, 186a136efe9SPeter Wemm UMA_ALIGN_PTR, UMA_ZONE_NOFREE); 187f535380cSDon Lewis uihashinit(); 188df8bae1dSRodney W. Grimes } 189df8bae1dSRodney W. Grimes 190df8bae1dSRodney W. Grimes /* 191a136efe9SPeter Wemm * Prepare a proc for use. 192a136efe9SPeter Wemm */ 193b23f72e9SBrian Feldman static int 194b23f72e9SBrian Feldman proc_ctor(void *mem, int size, void *arg, int flags) 195a136efe9SPeter Wemm { 196a136efe9SPeter Wemm struct proc *p; 197316e092aSHans Petter Selasky struct thread *td; 198a136efe9SPeter Wemm 199a136efe9SPeter Wemm p = (struct proc *)mem; 2002ca45184SMatt Joras EVENTHANDLER_DIRECT_INVOKE(process_ctor, p); 201316e092aSHans Petter Selasky td = FIRST_THREAD_IN_PROC(p); 202316e092aSHans Petter Selasky if (td != NULL) { 203316e092aSHans Petter Selasky /* Make sure all thread constructors are executed */ 2042ca45184SMatt Joras EVENTHANDLER_DIRECT_INVOKE(thread_ctor, td); 205316e092aSHans Petter Selasky } 206b23f72e9SBrian Feldman return (0); 207a136efe9SPeter Wemm } 208a136efe9SPeter Wemm 209a136efe9SPeter Wemm /* 210a136efe9SPeter Wemm * Reclaim a proc after use. 211a136efe9SPeter Wemm */ 212a136efe9SPeter Wemm static void 213a136efe9SPeter Wemm proc_dtor(void *mem, int size, void *arg) 214a136efe9SPeter Wemm { 215a136efe9SPeter Wemm struct proc *p; 2161faf202eSJulian Elischer struct thread *td; 217a136efe9SPeter Wemm 2181faf202eSJulian Elischer /* INVARIANTS checks go here */ 219a136efe9SPeter Wemm p = (struct proc *)mem; 220ed062c8dSJulian Elischer td = FIRST_THREAD_IN_PROC(p); 22189b57fcfSKonstantin Belousov if (td != NULL) { 222ed062c8dSJulian Elischer #ifdef INVARIANTS 2231faf202eSJulian Elischer KASSERT((p->p_numthreads == 1), 2241faf202eSJulian Elischer ("bad number of threads in exiting process")); 2252c255e9dSRobert Watson KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr")); 226ed062c8dSJulian Elischer #endif 2271ba4a712SPawel Jakub Dawidek /* Free all OSD associated to this thread. */ 2281ba4a712SPawel Jakub Dawidek osd_thread_exit(td); 229a7ca2c6aSKonstantin Belousov td_softdep_cleanup(td); 230a7ca2c6aSKonstantin Belousov MPASS(td->td_su == NULL); 231316e092aSHans Petter Selasky 232316e092aSHans Petter Selasky /* Make sure all thread destructors are executed */ 2332ca45184SMatt Joras EVENTHANDLER_DIRECT_INVOKE(thread_dtor, td); 23489b57fcfSKonstantin Belousov } 2352ca45184SMatt Joras EVENTHANDLER_DIRECT_INVOKE(process_dtor, p); 236ebceaf6dSDavid Xu if (p->p_ksi != NULL) 237ebceaf6dSDavid Xu KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue")); 238a136efe9SPeter Wemm } 239a136efe9SPeter Wemm 240a136efe9SPeter Wemm /* 241a136efe9SPeter Wemm * Initialize type-stable parts of a proc (when newly created). 242a136efe9SPeter Wemm */ 243b23f72e9SBrian Feldman static int 244b23f72e9SBrian Feldman proc_init(void *mem, int size, int flags) 245a136efe9SPeter Wemm { 246a136efe9SPeter Wemm struct proc *p; 247a136efe9SPeter Wemm 248a136efe9SPeter Wemm p = (struct proc *)mem; 249f97af970SMateusz Guzik mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK | MTX_NEW); 250f97af970SMateusz Guzik mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_NEW); 251f97af970SMateusz Guzik mtx_init(&p->p_statmtx, "pstatl", NULL, MTX_SPIN | MTX_NEW); 252f97af970SMateusz Guzik mtx_init(&p->p_itimmtx, "pitiml", NULL, MTX_SPIN | MTX_NEW); 253f97af970SMateusz Guzik mtx_init(&p->p_profmtx, "pprofl", NULL, MTX_SPIN | MTX_NEW); 254aeb32571SKonstantin Belousov cv_init(&p->p_pwait, "ppwait"); 25589b57fcfSKonstantin Belousov TAILQ_INIT(&p->p_threads); /* all threads in proc */ 2562ca45184SMatt Joras EVENTHANDLER_DIRECT_INVOKE(process_init, p); 2578b059651SDavid Schultz p->p_stats = pstats_alloc(); 258aa0241d6SMateusz Guzik p->p_pgrp = NULL; 259b23f72e9SBrian Feldman return (0); 260a136efe9SPeter Wemm } 261a136efe9SPeter Wemm 262a136efe9SPeter Wemm /* 2638daa8c60SDavid Schultz * UMA should ensure that this function is never called. 2648daa8c60SDavid Schultz * Freeing a proc structure would violate type stability. 265a136efe9SPeter Wemm */ 266a136efe9SPeter Wemm static void 267a136efe9SPeter Wemm proc_fini(void *mem, int size) 268a136efe9SPeter Wemm { 269f55ab994SJohn Baldwin #ifdef notnow 270f55ab994SJohn Baldwin struct proc *p; 271a136efe9SPeter Wemm 272f55ab994SJohn Baldwin p = (struct proc *)mem; 2732ca45184SMatt Joras EVENTHANDLER_DIRECT_INVOKE(process_fini, p); 274f55ab994SJohn Baldwin pstats_free(p->p_stats); 275f55ab994SJohn Baldwin thread_free(FIRST_THREAD_IN_PROC(p)); 276f55ab994SJohn Baldwin mtx_destroy(&p->p_mtx); 277ebceaf6dSDavid Xu if (p->p_ksi != NULL) 278ebceaf6dSDavid Xu ksiginfo_free(p->p_ksi); 279f55ab994SJohn Baldwin #else 2808daa8c60SDavid Schultz panic("proc reclaimed"); 281f55ab994SJohn Baldwin #endif 282a136efe9SPeter Wemm } 283a136efe9SPeter Wemm 284a136efe9SPeter Wemm /* 285df8bae1dSRodney W. Grimes * Is p an inferior of the current process? 286df8bae1dSRodney W. Grimes */ 2871a432a2fSDima Ruban int 288d7359980SKonstantin Belousov inferior(struct proc *p) 289df8bae1dSRodney W. Grimes { 290df8bae1dSRodney W. Grimes 2915b29d6e9SJohn Baldwin sx_assert(&proctree_lock, SX_LOCKED); 292d7359980SKonstantin Belousov PROC_LOCK_ASSERT(p, MA_OWNED); 293d7359980SKonstantin Belousov for (; p != curproc; p = proc_realparent(p)) { 29400f13cb3SJohn Baldwin if (p->p_pid == 0) 29500f13cb3SJohn Baldwin return (0); 296d7359980SKonstantin Belousov } 29700f13cb3SJohn Baldwin return (1); 298df8bae1dSRodney W. Grimes } 299df8bae1dSRodney W. Grimes 300df8bae1dSRodney W. Grimes struct proc * 301134eb42eSKonstantin Belousov pfind_locked(pid_t pid) 302df8bae1dSRodney W. Grimes { 303134eb42eSKonstantin Belousov struct proc *p; 304df8bae1dSRodney W. Grimes 305134eb42eSKonstantin Belousov sx_assert(&allproc_lock, SX_LOCKED); 306134eb42eSKonstantin Belousov LIST_FOREACH(p, PIDHASH(pid), p_hash) { 30733a9ed9dSJohn Baldwin if (p->p_pid == pid) { 30833a9ed9dSJohn Baldwin PROC_LOCK(p); 3098e6fa660SJohn Baldwin if (p->p_state == PRS_NEW) { 3108e6fa660SJohn Baldwin PROC_UNLOCK(p); 3118e6fa660SJohn Baldwin p = NULL; 3128e6fa660SJohn Baldwin } 313553629ebSJake Burkholder break; 31433a9ed9dSJohn Baldwin } 315134eb42eSKonstantin Belousov } 316134eb42eSKonstantin Belousov return (p); 317134eb42eSKonstantin Belousov } 318134eb42eSKonstantin Belousov 319134eb42eSKonstantin Belousov /* 320134eb42eSKonstantin Belousov * Locate a process by number; return only "live" processes -- i.e., neither 321134eb42eSKonstantin Belousov * zombies nor newly born but incompletely initialized processes. By not 322134eb42eSKonstantin Belousov * returning processes in the PRS_NEW state, we allow callers to avoid 323134eb42eSKonstantin Belousov * testing for that condition to avoid dereferencing p_ucred, et al. 324134eb42eSKonstantin Belousov */ 325134eb42eSKonstantin Belousov struct proc * 326134eb42eSKonstantin Belousov pfind(pid_t pid) 327134eb42eSKonstantin Belousov { 328134eb42eSKonstantin Belousov struct proc *p; 329134eb42eSKonstantin Belousov 330272640b7SMateusz Guzik p = curproc; 331272640b7SMateusz Guzik if (p->p_pid == pid) { 332272640b7SMateusz Guzik PROC_LOCK(p); 333272640b7SMateusz Guzik return (p); 334272640b7SMateusz Guzik } 335134eb42eSKonstantin Belousov sx_slock(&allproc_lock); 336134eb42eSKonstantin Belousov p = pfind_locked(pid); 33798ab1489SJeffrey Hsu sx_sunlock(&allproc_lock); 338df8bae1dSRodney W. Grimes return (p); 339df8bae1dSRodney W. Grimes } 340df8bae1dSRodney W. Grimes 3416e1619daSMateusz Guzik /* 3426e1619daSMateusz Guzik * Same as pfind but allow zombies. 3436e1619daSMateusz Guzik */ 3446e1619daSMateusz Guzik struct proc * 3456e1619daSMateusz Guzik pfind_any(pid_t pid) 3466e1619daSMateusz Guzik { 3476e1619daSMateusz Guzik struct proc *p; 3486e1619daSMateusz Guzik 3496e1619daSMateusz Guzik sx_slock(&allproc_lock); 3506e1619daSMateusz Guzik p = pfind_locked(pid); 3516e1619daSMateusz Guzik if (p == NULL) 3526e1619daSMateusz Guzik p = zpfind_locked(pid); 3536e1619daSMateusz Guzik sx_sunlock(&allproc_lock); 3546e1619daSMateusz Guzik 3556e1619daSMateusz Guzik return (p); 3566e1619daSMateusz Guzik } 3576e1619daSMateusz Guzik 358b3bfb267SKonstantin Belousov static struct proc * 359134eb42eSKonstantin Belousov pfind_tid_locked(pid_t tid) 360b3bfb267SKonstantin Belousov { 361b3bfb267SKonstantin Belousov struct proc *p; 362b3bfb267SKonstantin Belousov struct thread *td; 363b3bfb267SKonstantin Belousov 364134eb42eSKonstantin Belousov sx_assert(&allproc_lock, SX_LOCKED); 365b3bfb267SKonstantin Belousov FOREACH_PROC_IN_SYSTEM(p) { 366b3bfb267SKonstantin Belousov PROC_LOCK(p); 367b3bfb267SKonstantin Belousov if (p->p_state == PRS_NEW) { 368b3bfb267SKonstantin Belousov PROC_UNLOCK(p); 369b3bfb267SKonstantin Belousov continue; 370b3bfb267SKonstantin Belousov } 371b3bfb267SKonstantin Belousov FOREACH_THREAD_IN_PROC(p, td) { 372b3bfb267SKonstantin Belousov if (td->td_tid == tid) 373b3bfb267SKonstantin Belousov goto found; 374b3bfb267SKonstantin Belousov } 375b3bfb267SKonstantin Belousov PROC_UNLOCK(p); 376b3bfb267SKonstantin Belousov } 377b3bfb267SKonstantin Belousov found: 378b3bfb267SKonstantin Belousov return (p); 379b3bfb267SKonstantin Belousov } 380b3bfb267SKonstantin Belousov 381df8bae1dSRodney W. Grimes /* 382f591779bSSeigo Tanimura * Locate a process group by number. 383f089b570SJohn Baldwin * The caller must hold proctree_lock. 384df8bae1dSRodney W. Grimes */ 385df8bae1dSRodney W. Grimes struct pgrp * 38618c23dffSEd Maste pgfind(pid_t pgid) 387df8bae1dSRodney W. Grimes { 38818c23dffSEd Maste struct pgrp *pgrp; 389df8bae1dSRodney W. Grimes 390f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_LOCKED); 391f591779bSSeigo Tanimura 392f591779bSSeigo Tanimura LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) { 393f591779bSSeigo Tanimura if (pgrp->pg_id == pgid) { 394f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 395df8bae1dSRodney W. Grimes return (pgrp); 396f591779bSSeigo Tanimura } 397f591779bSSeigo Tanimura } 398df8bae1dSRodney W. Grimes return (NULL); 399df8bae1dSRodney W. Grimes } 400df8bae1dSRodney W. Grimes 401df8bae1dSRodney W. Grimes /* 402fa3935bcSMikolaj Golub * Locate process and do additional manipulations, depending on flags. 403fa3935bcSMikolaj Golub */ 404fa3935bcSMikolaj Golub int 405fa3935bcSMikolaj Golub pget(pid_t pid, int flags, struct proc **pp) 406fa3935bcSMikolaj Golub { 407fa3935bcSMikolaj Golub struct proc *p; 408fa3935bcSMikolaj Golub int error; 409fa3935bcSMikolaj Golub 410a2c36a24SMateusz Guzik p = curproc; 411a2c36a24SMateusz Guzik if (p->p_pid == pid) { 412a2c36a24SMateusz Guzik PROC_LOCK(p); 413a2c36a24SMateusz Guzik } else { 414134eb42eSKonstantin Belousov sx_slock(&allproc_lock); 4154f666417SPawel Jakub Dawidek if (pid <= PID_MAX) { 416134eb42eSKonstantin Belousov p = pfind_locked(pid); 417134eb42eSKonstantin Belousov if (p == NULL && (flags & PGET_NOTWEXIT) == 0) 418134eb42eSKonstantin Belousov p = zpfind_locked(pid); 4194f666417SPawel Jakub Dawidek } else if ((flags & PGET_NOTID) == 0) { 4204f666417SPawel Jakub Dawidek p = pfind_tid_locked(pid); 4214f666417SPawel Jakub Dawidek } else { 4224f666417SPawel Jakub Dawidek p = NULL; 4234f666417SPawel Jakub Dawidek } 424134eb42eSKonstantin Belousov sx_sunlock(&allproc_lock); 425fa3935bcSMikolaj Golub if (p == NULL) 426fa3935bcSMikolaj Golub return (ESRCH); 427fa3935bcSMikolaj Golub if ((flags & PGET_CANSEE) != 0) { 428fa3935bcSMikolaj Golub error = p_cansee(curthread, p); 429fa3935bcSMikolaj Golub if (error != 0) 430fa3935bcSMikolaj Golub goto errout; 431fa3935bcSMikolaj Golub } 432a2c36a24SMateusz Guzik } 433fa3935bcSMikolaj Golub if ((flags & PGET_CANDEBUG) != 0) { 434fa3935bcSMikolaj Golub error = p_candebug(curthread, p); 435fa3935bcSMikolaj Golub if (error != 0) 436fa3935bcSMikolaj Golub goto errout; 437fa3935bcSMikolaj Golub } 438fa3935bcSMikolaj Golub if ((flags & PGET_ISCURRENT) != 0 && curproc != p) { 439fa3935bcSMikolaj Golub error = EPERM; 440fa3935bcSMikolaj Golub goto errout; 441fa3935bcSMikolaj Golub } 442fa3935bcSMikolaj Golub if ((flags & PGET_NOTWEXIT) != 0 && (p->p_flag & P_WEXIT) != 0) { 443fa3935bcSMikolaj Golub error = ESRCH; 444fa3935bcSMikolaj Golub goto errout; 445fa3935bcSMikolaj Golub } 446fa3935bcSMikolaj Golub if ((flags & PGET_NOTINEXEC) != 0 && (p->p_flag & P_INEXEC) != 0) { 447fa3935bcSMikolaj Golub /* 448fa3935bcSMikolaj Golub * XXXRW: Not clear ESRCH is the right error during proc 449fa3935bcSMikolaj Golub * execve(). 450fa3935bcSMikolaj Golub */ 451fa3935bcSMikolaj Golub error = ESRCH; 452fa3935bcSMikolaj Golub goto errout; 453fa3935bcSMikolaj Golub } 454fa3935bcSMikolaj Golub if ((flags & PGET_HOLD) != 0) { 455fa3935bcSMikolaj Golub _PHOLD(p); 456fa3935bcSMikolaj Golub PROC_UNLOCK(p); 457fa3935bcSMikolaj Golub } 458fa3935bcSMikolaj Golub *pp = p; 459fa3935bcSMikolaj Golub return (0); 460fa3935bcSMikolaj Golub errout: 461fa3935bcSMikolaj Golub PROC_UNLOCK(p); 462fa3935bcSMikolaj Golub return (error); 463fa3935bcSMikolaj Golub } 464fa3935bcSMikolaj Golub 465fa3935bcSMikolaj Golub /* 466f591779bSSeigo Tanimura * Create a new process group. 467f591779bSSeigo Tanimura * pgid must be equal to the pid of p. 468f591779bSSeigo Tanimura * Begin a new session if required. 469df8bae1dSRodney W. Grimes */ 47026f9a767SRodney W. Grimes int 47118c23dffSEd Maste enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess) 472df8bae1dSRodney W. Grimes { 473df8bae1dSRodney W. Grimes 474f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 475f591779bSSeigo Tanimura 476f591779bSSeigo Tanimura KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL")); 477f591779bSSeigo Tanimura KASSERT(p->p_pid == pgid, 478f591779bSSeigo Tanimura ("enterpgrp: new pgrp and pid != pgid")); 4794419a8a8SMateusz Guzik KASSERT(pgfind(pgid) == NULL, 480f591779bSSeigo Tanimura ("enterpgrp: pgrp with pgid exists")); 4815526d2d9SEivind Eklund KASSERT(!SESS_LEADER(p), 4825526d2d9SEivind Eklund ("enterpgrp: session leader attempted setpgrp")); 483219cbf59SEivind Eklund 4846008862bSJohn Baldwin mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK); 485df8bae1dSRodney W. Grimes 486f591779bSSeigo Tanimura if (sess != NULL) { 487df8bae1dSRodney W. Grimes /* 488df8bae1dSRodney W. Grimes * new session 489df8bae1dSRodney W. Grimes */ 4906008862bSJohn Baldwin mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF); 491f591779bSSeigo Tanimura PROC_LOCK(p); 492f591779bSSeigo Tanimura p->p_flag &= ~P_CONTROLT; 493f591779bSSeigo Tanimura PROC_UNLOCK(p); 494f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 495df8bae1dSRodney W. Grimes sess->s_leader = p; 496643a8daaSDon Lewis sess->s_sid = p->p_pid; 497bc093719SEd Schouten refcount_init(&sess->s_count, 1); 498df8bae1dSRodney W. Grimes sess->s_ttyvp = NULL; 4998dc9b4cfSEd Schouten sess->s_ttydp = NULL; 500df8bae1dSRodney W. Grimes sess->s_ttyp = NULL; 501df8bae1dSRodney W. Grimes bcopy(p->p_session->s_login, sess->s_login, 502df8bae1dSRodney W. Grimes sizeof(sess->s_login)); 503df8bae1dSRodney W. Grimes pgrp->pg_session = sess; 5045526d2d9SEivind Eklund KASSERT(p == curproc, 5055526d2d9SEivind Eklund ("enterpgrp: mksession and p != curproc")); 506df8bae1dSRodney W. Grimes } else { 507df8bae1dSRodney W. Grimes pgrp->pg_session = p->p_session; 508bc093719SEd Schouten sess_hold(pgrp->pg_session); 509f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 510df8bae1dSRodney W. Grimes } 511df8bae1dSRodney W. Grimes pgrp->pg_id = pgid; 512b75356e1SJeffrey Hsu LIST_INIT(&pgrp->pg_members); 513f591779bSSeigo Tanimura 514f591779bSSeigo Tanimura /* 515f089b570SJohn Baldwin * As we have an exclusive lock of proctree_lock, 516f591779bSSeigo Tanimura * this should not deadlock. 517f591779bSSeigo Tanimura */ 518b75356e1SJeffrey Hsu LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash); 519df8bae1dSRodney W. Grimes pgrp->pg_jobc = 0; 520831d27a9SDon Lewis SLIST_INIT(&pgrp->pg_sigiolst); 521f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 522f591779bSSeigo Tanimura 523f591779bSSeigo Tanimura doenterpgrp(p, pgrp); 524f591779bSSeigo Tanimura 525df8bae1dSRodney W. Grimes return (0); 526f591779bSSeigo Tanimura } 527f591779bSSeigo Tanimura 528f591779bSSeigo Tanimura /* 529f591779bSSeigo Tanimura * Move p to an existing process group 530f591779bSSeigo Tanimura */ 531f591779bSSeigo Tanimura int 53218c23dffSEd Maste enterthispgrp(struct proc *p, struct pgrp *pgrp) 533f591779bSSeigo Tanimura { 534f089b570SJohn Baldwin 535f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 536f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 537f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 538f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 539f591779bSSeigo Tanimura SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 540f591779bSSeigo Tanimura KASSERT(pgrp->pg_session == p->p_session, 541f591779bSSeigo Tanimura ("%s: pgrp's session %p, p->p_session %p.\n", 542f591779bSSeigo Tanimura __func__, 543f591779bSSeigo Tanimura pgrp->pg_session, 544f591779bSSeigo Tanimura p->p_session)); 545f591779bSSeigo Tanimura KASSERT(pgrp != p->p_pgrp, 546f591779bSSeigo Tanimura ("%s: p belongs to pgrp.", __func__)); 547f591779bSSeigo Tanimura 548f591779bSSeigo Tanimura doenterpgrp(p, pgrp); 549f591779bSSeigo Tanimura 550f591779bSSeigo Tanimura return (0); 551f591779bSSeigo Tanimura } 552f591779bSSeigo Tanimura 553f591779bSSeigo Tanimura /* 554f591779bSSeigo Tanimura * Move p to a process group 555f591779bSSeigo Tanimura */ 556f591779bSSeigo Tanimura static void 55718c23dffSEd Maste doenterpgrp(struct proc *p, struct pgrp *pgrp) 558f591779bSSeigo Tanimura { 559f591779bSSeigo Tanimura struct pgrp *savepgrp; 560f591779bSSeigo Tanimura 561f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 562f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 563f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 564f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED); 565f591779bSSeigo Tanimura SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED); 566f591779bSSeigo Tanimura 567f591779bSSeigo Tanimura savepgrp = p->p_pgrp; 568df8bae1dSRodney W. Grimes 569df8bae1dSRodney W. Grimes /* 570df8bae1dSRodney W. Grimes * Adjust eligibility of affected pgrps to participate in job control. 571df8bae1dSRodney W. Grimes * Increment eligibility counts before decrementing, otherwise we 572df8bae1dSRodney W. Grimes * could reach 0 spuriously during the first call. 573df8bae1dSRodney W. Grimes */ 574df8bae1dSRodney W. Grimes fixjobc(p, pgrp, 1); 575df8bae1dSRodney W. Grimes fixjobc(p, p->p_pgrp, 0); 576df8bae1dSRodney W. Grimes 577f591779bSSeigo Tanimura PGRP_LOCK(pgrp); 578f591779bSSeigo Tanimura PGRP_LOCK(savepgrp); 57915e9ec51SJohn Baldwin PROC_LOCK(p); 580b75356e1SJeffrey Hsu LIST_REMOVE(p, p_pglist); 581df8bae1dSRodney W. Grimes p->p_pgrp = pgrp; 58215e9ec51SJohn Baldwin PROC_UNLOCK(p); 583f591779bSSeigo Tanimura LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist); 584f591779bSSeigo Tanimura PGRP_UNLOCK(savepgrp); 585f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 586f591779bSSeigo Tanimura if (LIST_EMPTY(&savepgrp->pg_members)) 587f591779bSSeigo Tanimura pgdelete(savepgrp); 588df8bae1dSRodney W. Grimes } 589df8bae1dSRodney W. Grimes 590df8bae1dSRodney W. Grimes /* 591df8bae1dSRodney W. Grimes * remove process from process group 592df8bae1dSRodney W. Grimes */ 59326f9a767SRodney W. Grimes int 59418c23dffSEd Maste leavepgrp(struct proc *p) 595df8bae1dSRodney W. Grimes { 596f591779bSSeigo Tanimura struct pgrp *savepgrp; 597df8bae1dSRodney W. Grimes 598f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 599f591779bSSeigo Tanimura savepgrp = p->p_pgrp; 600f591779bSSeigo Tanimura PGRP_LOCK(savepgrp); 60115e9ec51SJohn Baldwin PROC_LOCK(p); 602b75356e1SJeffrey Hsu LIST_REMOVE(p, p_pglist); 60315e9ec51SJohn Baldwin p->p_pgrp = NULL; 60415e9ec51SJohn Baldwin PROC_UNLOCK(p); 605f591779bSSeigo Tanimura PGRP_UNLOCK(savepgrp); 606f591779bSSeigo Tanimura if (LIST_EMPTY(&savepgrp->pg_members)) 607f591779bSSeigo Tanimura pgdelete(savepgrp); 608df8bae1dSRodney W. Grimes return (0); 609df8bae1dSRodney W. Grimes } 610df8bae1dSRodney W. Grimes 611df8bae1dSRodney W. Grimes /* 612df8bae1dSRodney W. Grimes * delete a process group 613df8bae1dSRodney W. Grimes */ 61487b6de2bSPoul-Henning Kamp static void 61518c23dffSEd Maste pgdelete(struct pgrp *pgrp) 616df8bae1dSRodney W. Grimes { 617f591779bSSeigo Tanimura struct session *savesess; 618bc093719SEd Schouten struct tty *tp; 619f591779bSSeigo Tanimura 620f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_XLOCKED); 621f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 622f591779bSSeigo Tanimura SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 623f591779bSSeigo Tanimura 624831d27a9SDon Lewis /* 625831d27a9SDon Lewis * Reset any sigio structures pointing to us as a result of 626831d27a9SDon Lewis * F_SETOWN with our pgid. 627831d27a9SDon Lewis */ 628831d27a9SDon Lewis funsetownlst(&pgrp->pg_sigiolst); 629831d27a9SDon Lewis 630e649887bSAlfred Perlstein PGRP_LOCK(pgrp); 631bc093719SEd Schouten tp = pgrp->pg_session->s_ttyp; 632b75356e1SJeffrey Hsu LIST_REMOVE(pgrp, pg_hash); 633f591779bSSeigo Tanimura savesess = pgrp->pg_session; 634f591779bSSeigo Tanimura PGRP_UNLOCK(pgrp); 635bc093719SEd Schouten 636bc093719SEd Schouten /* Remove the reference to the pgrp before deallocating it. */ 637bc093719SEd Schouten if (tp != NULL) { 638bc093719SEd Schouten tty_lock(tp); 639bc093719SEd Schouten tty_rel_pgrp(tp, pgrp); 640bc093719SEd Schouten } 641bc093719SEd Schouten 6426041fa0aSSeigo Tanimura mtx_destroy(&pgrp->pg_mtx); 6431ede983cSDag-Erling Smørgrav free(pgrp, M_PGRP); 644bc093719SEd Schouten sess_release(savesess); 645df8bae1dSRodney W. Grimes } 646df8bae1dSRodney W. Grimes 64702e878d9SJohn Baldwin static void 64818c23dffSEd Maste pgadjustjobc(struct pgrp *pgrp, int entering) 64902e878d9SJohn Baldwin { 65002e878d9SJohn Baldwin 65102e878d9SJohn Baldwin PGRP_LOCK(pgrp); 65202e878d9SJohn Baldwin if (entering) 65302e878d9SJohn Baldwin pgrp->pg_jobc++; 65402e878d9SJohn Baldwin else { 65502e878d9SJohn Baldwin --pgrp->pg_jobc; 65602e878d9SJohn Baldwin if (pgrp->pg_jobc == 0) 65702e878d9SJohn Baldwin orphanpg(pgrp); 65802e878d9SJohn Baldwin } 65902e878d9SJohn Baldwin PGRP_UNLOCK(pgrp); 66002e878d9SJohn Baldwin } 66102e878d9SJohn Baldwin 662df8bae1dSRodney W. Grimes /* 663df8bae1dSRodney W. Grimes * Adjust pgrp jobc counters when specified process changes process group. 664df8bae1dSRodney W. Grimes * We count the number of processes in each process group that "qualify" 665df8bae1dSRodney W. Grimes * the group for terminal job control (those with a parent in a different 666df8bae1dSRodney W. Grimes * process group of the same session). If that count reaches zero, the 667df8bae1dSRodney W. Grimes * process group becomes orphaned. Check both the specified process' 668df8bae1dSRodney W. Grimes * process group and that of its children. 669df8bae1dSRodney W. Grimes * entering == 0 => p is leaving specified group. 670df8bae1dSRodney W. Grimes * entering == 1 => p is entering specified group. 671df8bae1dSRodney W. Grimes */ 67226f9a767SRodney W. Grimes void 6736760182cSMateusz Guzik fixjobc(struct proc *p, struct pgrp *pgrp, int entering) 674df8bae1dSRodney W. Grimes { 6756760182cSMateusz Guzik struct pgrp *hispgrp; 6766760182cSMateusz Guzik struct session *mysession; 6776760182cSMateusz Guzik struct proc *q; 678f591779bSSeigo Tanimura 679f089b570SJohn Baldwin sx_assert(&proctree_lock, SX_LOCKED); 680f591779bSSeigo Tanimura PROC_LOCK_ASSERT(p, MA_NOTOWNED); 681f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED); 682f591779bSSeigo Tanimura SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED); 683df8bae1dSRodney W. Grimes 684df8bae1dSRodney W. Grimes /* 685df8bae1dSRodney W. Grimes * Check p's parent to see whether p qualifies its own process 686df8bae1dSRodney W. Grimes * group; if so, adjust count for p's process group. 687df8bae1dSRodney W. Grimes */ 688f591779bSSeigo Tanimura mysession = pgrp->pg_session; 689df8bae1dSRodney W. Grimes if ((hispgrp = p->p_pptr->p_pgrp) != pgrp && 69002e878d9SJohn Baldwin hispgrp->pg_session == mysession) 69102e878d9SJohn Baldwin pgadjustjobc(pgrp, entering); 692df8bae1dSRodney W. Grimes 693df8bae1dSRodney W. Grimes /* 694df8bae1dSRodney W. Grimes * Check this process' children to see whether they qualify 695df8bae1dSRodney W. Grimes * their process groups; if so, adjust counts for children's 696df8bae1dSRodney W. Grimes * process groups. 697df8bae1dSRodney W. Grimes */ 6986760182cSMateusz Guzik LIST_FOREACH(q, &p->p_children, p_sibling) { 6996760182cSMateusz Guzik hispgrp = q->p_pgrp; 70002e878d9SJohn Baldwin if (hispgrp == pgrp || 70102e878d9SJohn Baldwin hispgrp->pg_session != mysession) 70202e878d9SJohn Baldwin continue; 7036760182cSMateusz Guzik if (q->p_state == PRS_ZOMBIE) 70402e878d9SJohn Baldwin continue; 70502e878d9SJohn Baldwin pgadjustjobc(hispgrp, entering); 706f591779bSSeigo Tanimura } 707dfd5dee1SPeter Wemm } 708df8bae1dSRodney W. Grimes 70917182b13SMateusz Guzik void 71017182b13SMateusz Guzik killjobc(void) 71117182b13SMateusz Guzik { 71217182b13SMateusz Guzik struct session *sp; 71317182b13SMateusz Guzik struct tty *tp; 71417182b13SMateusz Guzik struct proc *p; 71517182b13SMateusz Guzik struct vnode *ttyvp; 71617182b13SMateusz Guzik 71717182b13SMateusz Guzik p = curproc; 71817182b13SMateusz Guzik MPASS(p->p_flag & P_WEXIT); 71917182b13SMateusz Guzik /* 72017182b13SMateusz Guzik * Do a quick check to see if there is anything to do with the 72117182b13SMateusz Guzik * proctree_lock held. pgrp and LIST_EMPTY checks are for fixjobc(). 72217182b13SMateusz Guzik */ 72317182b13SMateusz Guzik PROC_LOCK(p); 72417182b13SMateusz Guzik if (!SESS_LEADER(p) && 72517182b13SMateusz Guzik (p->p_pgrp == p->p_pptr->p_pgrp) && 72617182b13SMateusz Guzik LIST_EMPTY(&p->p_children)) { 72717182b13SMateusz Guzik PROC_UNLOCK(p); 72817182b13SMateusz Guzik return; 72917182b13SMateusz Guzik } 73017182b13SMateusz Guzik PROC_UNLOCK(p); 73117182b13SMateusz Guzik 73217182b13SMateusz Guzik sx_xlock(&proctree_lock); 73317182b13SMateusz Guzik if (SESS_LEADER(p)) { 73417182b13SMateusz Guzik sp = p->p_session; 73517182b13SMateusz Guzik 73617182b13SMateusz Guzik /* 73717182b13SMateusz Guzik * s_ttyp is not zero'd; we use this to indicate that 73817182b13SMateusz Guzik * the session once had a controlling terminal. (for 73917182b13SMateusz Guzik * logging and informational purposes) 74017182b13SMateusz Guzik */ 74117182b13SMateusz Guzik SESS_LOCK(sp); 74217182b13SMateusz Guzik ttyvp = sp->s_ttyvp; 74317182b13SMateusz Guzik tp = sp->s_ttyp; 74417182b13SMateusz Guzik sp->s_ttyvp = NULL; 74517182b13SMateusz Guzik sp->s_ttydp = NULL; 74617182b13SMateusz Guzik sp->s_leader = NULL; 74717182b13SMateusz Guzik SESS_UNLOCK(sp); 74817182b13SMateusz Guzik 74917182b13SMateusz Guzik /* 75017182b13SMateusz Guzik * Signal foreground pgrp and revoke access to 75117182b13SMateusz Guzik * controlling terminal if it has not been revoked 75217182b13SMateusz Guzik * already. 75317182b13SMateusz Guzik * 75417182b13SMateusz Guzik * Because the TTY may have been revoked in the mean 75517182b13SMateusz Guzik * time and could already have a new session associated 75617182b13SMateusz Guzik * with it, make sure we don't send a SIGHUP to a 75717182b13SMateusz Guzik * foreground process group that does not belong to this 75817182b13SMateusz Guzik * session. 75917182b13SMateusz Guzik */ 76017182b13SMateusz Guzik 76117182b13SMateusz Guzik if (tp != NULL) { 76217182b13SMateusz Guzik tty_lock(tp); 76317182b13SMateusz Guzik if (tp->t_session == sp) 76417182b13SMateusz Guzik tty_signal_pgrp(tp, SIGHUP); 76517182b13SMateusz Guzik tty_unlock(tp); 76617182b13SMateusz Guzik } 76717182b13SMateusz Guzik 76817182b13SMateusz Guzik if (ttyvp != NULL) { 76917182b13SMateusz Guzik sx_xunlock(&proctree_lock); 77017182b13SMateusz Guzik if (vn_lock(ttyvp, LK_EXCLUSIVE) == 0) { 77117182b13SMateusz Guzik VOP_REVOKE(ttyvp, REVOKEALL); 77217182b13SMateusz Guzik VOP_UNLOCK(ttyvp, 0); 77317182b13SMateusz Guzik } 77417182b13SMateusz Guzik vrele(ttyvp); 77517182b13SMateusz Guzik sx_xlock(&proctree_lock); 77617182b13SMateusz Guzik } 77717182b13SMateusz Guzik } 77817182b13SMateusz Guzik fixjobc(p, p->p_pgrp, 0); 77917182b13SMateusz Guzik sx_xunlock(&proctree_lock); 78017182b13SMateusz Guzik } 78117182b13SMateusz Guzik 782df8bae1dSRodney W. Grimes /* 783df8bae1dSRodney W. Grimes * A process group has become orphaned; 784df8bae1dSRodney W. Grimes * if there are any stopped processes in the group, 785df8bae1dSRodney W. Grimes * hang-up all process in that group. 786df8bae1dSRodney W. Grimes */ 787df8bae1dSRodney W. Grimes static void 78818c23dffSEd Maste orphanpg(struct pgrp *pg) 789df8bae1dSRodney W. Grimes { 79018c23dffSEd Maste struct proc *p; 791df8bae1dSRodney W. Grimes 792f591779bSSeigo Tanimura PGRP_LOCK_ASSERT(pg, MA_OWNED); 793f591779bSSeigo Tanimura 7941b727751SPoul-Henning Kamp LIST_FOREACH(p, &pg->pg_members, p_pglist) { 79502e878d9SJohn Baldwin PROC_LOCK(p); 7964295bec1SJohn Baldwin if (P_SHOULDSTOP(p) == P_STOPPED_SIG) { 79702e878d9SJohn Baldwin PROC_UNLOCK(p); 7981b727751SPoul-Henning Kamp LIST_FOREACH(p, &pg->pg_members, p_pglist) { 79915e9ec51SJohn Baldwin PROC_LOCK(p); 8008451d0ddSKip Macy kern_psignal(p, SIGHUP); 8018451d0ddSKip Macy kern_psignal(p, SIGCONT); 80215e9ec51SJohn Baldwin PROC_UNLOCK(p); 803df8bae1dSRodney W. Grimes } 804df8bae1dSRodney W. Grimes return; 805df8bae1dSRodney W. Grimes } 80602e878d9SJohn Baldwin PROC_UNLOCK(p); 807df8bae1dSRodney W. Grimes } 808df8bae1dSRodney W. Grimes } 809df8bae1dSRodney W. Grimes 810572b4402SPoul-Henning Kamp void 811bc093719SEd Schouten sess_hold(struct session *s) 812572b4402SPoul-Henning Kamp { 813572b4402SPoul-Henning Kamp 814bc093719SEd Schouten refcount_acquire(&s->s_count); 815bc093719SEd Schouten } 816bc093719SEd Schouten 817bc093719SEd Schouten void 818bc093719SEd Schouten sess_release(struct session *s) 819bc093719SEd Schouten { 820bc093719SEd Schouten 821bc093719SEd Schouten if (refcount_release(&s->s_count)) { 822bc093719SEd Schouten if (s->s_ttyp != NULL) { 823bc093719SEd Schouten tty_lock(s->s_ttyp); 824bc093719SEd Schouten tty_rel_sess(s->s_ttyp, s); 825bc093719SEd Schouten } 826572b4402SPoul-Henning Kamp mtx_destroy(&s->s_mtx); 8271ede983cSDag-Erling Smørgrav free(s, M_SESSION); 828572b4402SPoul-Henning Kamp } 829572b4402SPoul-Henning Kamp } 830572b4402SPoul-Henning Kamp 831831031ceSBruce Evans #ifdef DDB 832831031ceSBruce Evans 833831031ceSBruce Evans DB_SHOW_COMMAND(pgrpdump, pgrpdump) 834df8bae1dSRodney W. Grimes { 83518c23dffSEd Maste struct pgrp *pgrp; 83618c23dffSEd Maste struct proc *p; 83718c23dffSEd Maste int i; 838df8bae1dSRodney W. Grimes 839b75356e1SJeffrey Hsu for (i = 0; i <= pgrphash; i++) { 8401b727751SPoul-Henning Kamp if (!LIST_EMPTY(&pgrphashtbl[i])) { 841df8bae1dSRodney W. Grimes printf("\tindx %d\n", i); 8421b727751SPoul-Henning Kamp LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) { 843ac1e407bSBruce Evans printf( 844ac1e407bSBruce Evans "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n", 845ac1e407bSBruce Evans (void *)pgrp, (long)pgrp->pg_id, 846ac1e407bSBruce Evans (void *)pgrp->pg_session, 847b75356e1SJeffrey Hsu pgrp->pg_session->s_count, 8481b727751SPoul-Henning Kamp (void *)LIST_FIRST(&pgrp->pg_members)); 8491b727751SPoul-Henning Kamp LIST_FOREACH(p, &pgrp->pg_members, p_pglist) { 850ac1e407bSBruce Evans printf("\t\tpid %ld addr %p pgrp %p\n", 851ac1e407bSBruce Evans (long)p->p_pid, (void *)p, 852ac1e407bSBruce Evans (void *)p->p_pgrp); 853df8bae1dSRodney W. Grimes } 854df8bae1dSRodney W. Grimes } 855df8bae1dSRodney W. Grimes } 856df8bae1dSRodney W. Grimes } 857df8bae1dSRodney W. Grimes } 858831031ceSBruce Evans #endif /* DDB */ 859972f9b20SPoul-Henning Kamp 860972f9b20SPoul-Henning Kamp /* 861f8d90480SAttilio Rao * Calculate the kinfo_proc members which contain process-wide 862f8d90480SAttilio Rao * informations. 863f8d90480SAttilio Rao * Must be called with the target process locked. 864f8d90480SAttilio Rao */ 865f8d90480SAttilio Rao static void 866f8d90480SAttilio Rao fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp) 867f8d90480SAttilio Rao { 868f8d90480SAttilio Rao struct thread *td; 869f8d90480SAttilio Rao 870f8d90480SAttilio Rao PROC_LOCK_ASSERT(p, MA_OWNED); 871f8d90480SAttilio Rao 872f8d90480SAttilio Rao kp->ki_estcpu = 0; 873f8d90480SAttilio Rao kp->ki_pctcpu = 0; 874f8d90480SAttilio Rao FOREACH_THREAD_IN_PROC(p, td) { 875f8d90480SAttilio Rao thread_lock(td); 876f8d90480SAttilio Rao kp->ki_pctcpu += sched_pctcpu(td); 877ccd0ec40SKonstantin Belousov kp->ki_estcpu += sched_estcpu(td); 878f8d90480SAttilio Rao thread_unlock(td); 879f8d90480SAttilio Rao } 880f8d90480SAttilio Rao } 881f8d90480SAttilio Rao 882f8d90480SAttilio Rao /* 8835032ff81SDon Lewis * Clear kinfo_proc and fill in any information that is common 8845032ff81SDon Lewis * to all threads in the process. 88565c9b430SJohn Baldwin * Must be called with the target process locked. 886972f9b20SPoul-Henning Kamp */ 8875032ff81SDon Lewis static void 8885032ff81SDon Lewis fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp) 889972f9b20SPoul-Henning Kamp { 8904093529dSJeff Roberson struct thread *td0; 8911f7d2501SKirk McKusick struct tty *tp; 8921f7d2501SKirk McKusick struct session *sp; 893d079d0a0SPawel Jakub Dawidek struct ucred *cred; 89490af4afaSJohn Baldwin struct sigacts *ps; 895584b675eSKonstantin Belousov struct timeval boottime; 896972f9b20SPoul-Henning Kamp 897374ae2a3SJeff Roberson PROC_LOCK_ASSERT(p, MA_OWNED); 8981f7d2501SKirk McKusick bzero(kp, sizeof(*kp)); 899972f9b20SPoul-Henning Kamp 9001f7d2501SKirk McKusick kp->ki_structsize = sizeof(*kp); 9011f7d2501SKirk McKusick kp->ki_paddr = p; 9026617724cSJeff Roberson kp->ki_addr =/* p->p_addr; */0; /* XXX */ 9031f7d2501SKirk McKusick kp->ki_args = p->p_args; 9041f7d2501SKirk McKusick kp->ki_textvp = p->p_textvp; 9056c84de02SJohn Baldwin #ifdef KTRACE 906a5881ea5SJohn Baldwin kp->ki_tracep = p->p_tracevp; 9076c84de02SJohn Baldwin kp->ki_traceflag = p->p_traceflag; 9086c84de02SJohn Baldwin #endif 9091f7d2501SKirk McKusick kp->ki_fd = p->p_fd; 9101f7d2501SKirk McKusick kp->ki_vmspace = p->p_vmspace; 911cefcecbeSPawel Jakub Dawidek kp->ki_flag = p->p_flag; 91255648840SJohn Baldwin kp->ki_flag2 = p->p_flag2; 913d079d0a0SPawel Jakub Dawidek cred = p->p_ucred; 914d079d0a0SPawel Jakub Dawidek if (cred) { 915d079d0a0SPawel Jakub Dawidek kp->ki_uid = cred->cr_uid; 916d079d0a0SPawel Jakub Dawidek kp->ki_ruid = cred->cr_ruid; 917d079d0a0SPawel Jakub Dawidek kp->ki_svuid = cred->cr_svuid; 91896fcc75fSRobert Watson kp->ki_cr_flags = 0; 91996fcc75fSRobert Watson if (cred->cr_flags & CRED_FLAG_CAPMODE) 92096fcc75fSRobert Watson kp->ki_cr_flags |= KI_CRF_CAPABILITY_MODE; 9211b5768beSBrooks Davis /* XXX bde doesn't like KI_NGROUPS */ 9221b5768beSBrooks Davis if (cred->cr_ngroups > KI_NGROUPS) { 9231b5768beSBrooks Davis kp->ki_ngroups = KI_NGROUPS; 9241b5768beSBrooks Davis kp->ki_cr_flags |= KI_CRF_GRP_OVERFLOW; 9251b5768beSBrooks Davis } else 926838d9858SBrooks Davis kp->ki_ngroups = cred->cr_ngroups; 9271b5768beSBrooks Davis bcopy(cred->cr_groups, kp->ki_groups, 9281b5768beSBrooks Davis kp->ki_ngroups * sizeof(gid_t)); 929d079d0a0SPawel Jakub Dawidek kp->ki_rgid = cred->cr_rgid; 930d079d0a0SPawel Jakub Dawidek kp->ki_svgid = cred->cr_svgid; 931cefcecbeSPawel Jakub Dawidek /* If jailed(cred), emulate the old P_JAILED flag. */ 932c78941e6SPawel Jakub Dawidek if (jailed(cred)) { 933cefcecbeSPawel Jakub Dawidek kp->ki_flag |= P_JAILED; 9340304c731SJamie Gritton /* If inside the jail, use 0 as a jail ID. */ 9350304c731SJamie Gritton if (cred->cr_prison != curthread->td_ucred->cr_prison) 936c78941e6SPawel Jakub Dawidek kp->ki_jid = cred->cr_prison->pr_id; 937c78941e6SPawel Jakub Dawidek } 9387123f4cdSEdward Tomasz Napierala strlcpy(kp->ki_loginclass, cred->cr_loginclass->lc_name, 9397123f4cdSEdward Tomasz Napierala sizeof(kp->ki_loginclass)); 940972f9b20SPoul-Henning Kamp } 94190af4afaSJohn Baldwin ps = p->p_sigacts; 942d079d0a0SPawel Jakub Dawidek if (ps) { 94390af4afaSJohn Baldwin mtx_lock(&ps->ps_mtx); 94490af4afaSJohn Baldwin kp->ki_sigignore = ps->ps_sigignore; 94590af4afaSJohn Baldwin kp->ki_sigcatch = ps->ps_sigcatch; 94690af4afaSJohn Baldwin mtx_unlock(&ps->ps_mtx); 947d8c85307SJulian Elischer } 948e602ba25SJulian Elischer if (p->p_state != PRS_NEW && 949e602ba25SJulian Elischer p->p_state != PRS_ZOMBIE && 950e602ba25SJulian Elischer p->p_vmspace != NULL) { 9511f7d2501SKirk McKusick struct vmspace *vm = p->p_vmspace; 952cd73303cSDavid Greenman 9531f7d2501SKirk McKusick kp->ki_size = vm->vm_map.size; 9541f7d2501SKirk McKusick kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/ 955ceff7f2aSTim J. Robbins FOREACH_THREAD_IN_PROC(p, td0) { 956ceff7f2aSTim J. Robbins if (!TD_IS_SWAPPED(td0)) 957ceff7f2aSTim J. Robbins kp->ki_rssize += td0->td_kstack_pages; 958ceff7f2aSTim J. Robbins } 9591f7d2501SKirk McKusick kp->ki_swrss = vm->vm_swrss; 9601f7d2501SKirk McKusick kp->ki_tsize = vm->vm_tsize; 9611f7d2501SKirk McKusick kp->ki_dsize = vm->vm_dsize; 9621f7d2501SKirk McKusick kp->ki_ssize = vm->vm_ssize; 9635032ff81SDon Lewis } else if (p->p_state == PRS_ZOMBIE) 9645032ff81SDon Lewis kp->ki_stat = SZOMB; 965b61ce5b0SJeff Roberson if (kp->ki_flag & P_INMEM) 966b61ce5b0SJeff Roberson kp->ki_sflag = PS_INMEM; 967b61ce5b0SJeff Roberson else 968b61ce5b0SJeff Roberson kp->ki_sflag = 0; 96954b0e65fSJeff Roberson /* Calculate legacy swtime as seconds since 'swtick'. */ 97054b0e65fSJeff Roberson kp->ki_swtime = (ticks - p->p_swtick) / hz; 971cebabef0SPawel Jakub Dawidek kp->ki_pid = p->p_pid; 972cebabef0SPawel Jakub Dawidek kp->ki_nice = p->p_nice; 9735e9ccc87SWill Andrews kp->ki_fibnum = p->p_fibnum; 97478c85e8dSJohn Baldwin kp->ki_start = p->p_stats->p_start; 975584b675eSKonstantin Belousov getboottime(&boottime); 97678c85e8dSJohn Baldwin timevaladd(&kp->ki_start, &boottime); 9775c7bebf9SKonstantin Belousov PROC_STATLOCK(p); 9788e6fa660SJohn Baldwin rufetch(p, &kp->ki_rusage); 9798e6fa660SJohn Baldwin kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime); 98078c85e8dSJohn Baldwin calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime); 9815c7bebf9SKonstantin Belousov PROC_STATUNLOCK(p); 98278c85e8dSJohn Baldwin calccru(p, &kp->ki_childutime, &kp->ki_childstime); 983a37e14e1SEdward Tomasz Napierala /* Some callers want child times in a single value. */ 98478c85e8dSJohn Baldwin kp->ki_childtime = kp->ki_childstime; 98578c85e8dSJohn Baldwin timevaladd(&kp->ki_childtime, &kp->ki_childutime); 986a37e14e1SEdward Tomasz Napierala 9874d34e019SKonstantin Belousov FOREACH_THREAD_IN_PROC(p, td0) 9884d34e019SKonstantin Belousov kp->ki_cow += td0->td_cow; 9894d34e019SKonstantin Belousov 990f591779bSSeigo Tanimura tp = NULL; 9911f7d2501SKirk McKusick if (p->p_pgrp) { 9921f7d2501SKirk McKusick kp->ki_pgid = p->p_pgrp->pg_id; 9931f7d2501SKirk McKusick kp->ki_jobc = p->p_pgrp->pg_jobc; 9941f7d2501SKirk McKusick sp = p->p_pgrp->pg_session; 9951f7d2501SKirk McKusick 9961f7d2501SKirk McKusick if (sp != NULL) { 9971f7d2501SKirk McKusick kp->ki_sid = sp->s_sid; 998f591779bSSeigo Tanimura SESS_LOCK(sp); 999e80fb434SRobert Drehmel strlcpy(kp->ki_login, sp->s_login, 1000e80fb434SRobert Drehmel sizeof(kp->ki_login)); 10011f7d2501SKirk McKusick if (sp->s_ttyvp) 1002b8e6bf1eSJohn Baldwin kp->ki_kiflag |= KI_CTTY; 10031f7d2501SKirk McKusick if (SESS_LEADER(p)) 10041f7d2501SKirk McKusick kp->ki_kiflag |= KI_SLEADER; 1005bc093719SEd Schouten /* XXX proctree_lock */ 1006f591779bSSeigo Tanimura tp = sp->s_ttyp; 1007f591779bSSeigo Tanimura SESS_UNLOCK(sp); 1008cd73303cSDavid Greenman } 1009cd73303cSDavid Greenman } 1010f591779bSSeigo Tanimura if ((p->p_flag & P_CONTROLT) && tp != NULL) { 1011bc093719SEd Schouten kp->ki_tdev = tty_udev(tp); 101269921123SKonstantin Belousov kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */ 10131f7d2501SKirk McKusick kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID; 10141f7d2501SKirk McKusick if (tp->t_session) 10151f7d2501SKirk McKusick kp->ki_tsid = tp->t_session->s_sid; 101669921123SKonstantin Belousov } else { 1017f3732fd1SPoul-Henning Kamp kp->ki_tdev = NODEV; 101869921123SKonstantin Belousov kp->ki_tdev_freebsd11 = kp->ki_tdev; /* truncate */ 101969921123SKonstantin Belousov } 102013b762a3SEd Maste if (p->p_comm[0] != '\0') 1021e80fb434SRobert Drehmel strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm)); 1022078842c5SGarance A Drosehn if (p->p_sysent && p->p_sysent->sv_name != NULL && 1023078842c5SGarance A Drosehn p->p_sysent->sv_name[0] != '\0') 1024078842c5SGarance A Drosehn strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul)); 10251d9c5696SJuli Mallett kp->ki_siglist = p->p_siglist; 1026b4490c6eSKonstantin Belousov kp->ki_xstat = KW_EXITCODE(p->p_xexit, p->p_xsig); 10271f7d2501SKirk McKusick kp->ki_acflag = p->p_acflag; 10281f7d2501SKirk McKusick kp->ki_lock = p->p_lock; 10295b5477d7SGleb Smirnoff if (p->p_pptr) { 1030*2c054ce9SMateusz Guzik kp->ki_ppid = p->p_oppid; 10318b04bbefSMateusz Guzik if (p->p_flag & P_TRACED) 10328b04bbefSMateusz Guzik kp->ki_tracer = p->p_pptr->p_pid; 1033972f9b20SPoul-Henning Kamp } 10345b5477d7SGleb Smirnoff } 1035972f9b20SPoul-Henning Kamp 10365032ff81SDon Lewis /* 103700305546SKonstantin Belousov * Fill in information that is thread specific. Must be called with 103800305546SKonstantin Belousov * target process locked. If 'preferthread' is set, overwrite certain 103900305546SKonstantin Belousov * process-related fields that are maintained for both threads and 104000305546SKonstantin Belousov * processes. 10415032ff81SDon Lewis */ 10425032ff81SDon Lewis static void 1043d92909c1SRobert Watson fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread) 10445032ff81SDon Lewis { 10455032ff81SDon Lewis struct proc *p; 10465032ff81SDon Lewis 10475032ff81SDon Lewis p = td->td_proc; 10486239ef1dSEd Maste kp->ki_tdaddr = td; 1049374ae2a3SJeff Roberson PROC_LOCK_ASSERT(p, MA_OWNED); 10505032ff81SDon Lewis 10512417d97eSJohn Baldwin if (preferthread) 10525c7bebf9SKonstantin Belousov PROC_STATLOCK(p); 1053982d11f8SJeff Roberson thread_lock(td); 10545032ff81SDon Lewis if (td->td_wmesg != NULL) 10555032ff81SDon Lewis strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg)); 10565032ff81SDon Lewis else 10575032ff81SDon Lewis bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg)); 10583d32d4a7SEric van Gyzen if (strlcpy(kp->ki_tdname, td->td_name, sizeof(kp->ki_tdname)) >= 10593d32d4a7SEric van Gyzen sizeof(kp->ki_tdname)) { 10603d32d4a7SEric van Gyzen strlcpy(kp->ki_moretdname, 10613d32d4a7SEric van Gyzen td->td_name + sizeof(kp->ki_tdname) - 1, 10623d32d4a7SEric van Gyzen sizeof(kp->ki_moretdname)); 10633d32d4a7SEric van Gyzen } else { 10643d32d4a7SEric van Gyzen bzero(kp->ki_moretdname, sizeof(kp->ki_moretdname)); 10653d32d4a7SEric van Gyzen } 10665032ff81SDon Lewis if (TD_ON_LOCK(td)) { 10675032ff81SDon Lewis kp->ki_kiflag |= KI_LOCKBLOCK; 10685032ff81SDon Lewis strlcpy(kp->ki_lockname, td->td_lockname, 10695032ff81SDon Lewis sizeof(kp->ki_lockname)); 10705032ff81SDon Lewis } else { 10715032ff81SDon Lewis kp->ki_kiflag &= ~KI_LOCKBLOCK; 10725032ff81SDon Lewis bzero(kp->ki_lockname, sizeof(kp->ki_lockname)); 10735032ff81SDon Lewis } 10745032ff81SDon Lewis 10756617724cSJeff Roberson if (p->p_state == PRS_NORMAL) { /* approximate. */ 10765032ff81SDon Lewis if (TD_ON_RUNQ(td) || 10775032ff81SDon Lewis TD_CAN_RUN(td) || 10785032ff81SDon Lewis TD_IS_RUNNING(td)) { 10795032ff81SDon Lewis kp->ki_stat = SRUN; 10805032ff81SDon Lewis } else if (P_SHOULDSTOP(p)) { 10815032ff81SDon Lewis kp->ki_stat = SSTOP; 10825032ff81SDon Lewis } else if (TD_IS_SLEEPING(td)) { 10835032ff81SDon Lewis kp->ki_stat = SSLEEP; 10845032ff81SDon Lewis } else if (TD_ON_LOCK(td)) { 10855032ff81SDon Lewis kp->ki_stat = SLOCK; 10865032ff81SDon Lewis } else { 10875032ff81SDon Lewis kp->ki_stat = SWAIT; 10885032ff81SDon Lewis } 10893357835aSDavid Xu } else if (p->p_state == PRS_ZOMBIE) { 10903357835aSDavid Xu kp->ki_stat = SZOMB; 10915032ff81SDon Lewis } else { 10925032ff81SDon Lewis kp->ki_stat = SIDL; 10935032ff81SDon Lewis } 10945032ff81SDon Lewis 10955032ff81SDon Lewis /* Things in the thread */ 10965032ff81SDon Lewis kp->ki_wchan = td->td_wchan; 10975032ff81SDon Lewis kp->ki_pri.pri_level = td->td_priority; 10985032ff81SDon Lewis kp->ki_pri.pri_native = td->td_base_pri; 1099e77f9fedSAdrian Chadd 1100e77f9fedSAdrian Chadd /* 1101e77f9fedSAdrian Chadd * Note: legacy fields; clamp at the old NOCPU value and/or 1102e77f9fedSAdrian Chadd * the maximum u_char CPU value. 1103e77f9fedSAdrian Chadd */ 1104e77f9fedSAdrian Chadd if (td->td_lastcpu == NOCPU) 1105e77f9fedSAdrian Chadd kp->ki_lastcpu_old = NOCPU_OLD; 1106e77f9fedSAdrian Chadd else if (td->td_lastcpu > MAXCPU_OLD) 1107e77f9fedSAdrian Chadd kp->ki_lastcpu_old = MAXCPU_OLD; 1108e77f9fedSAdrian Chadd else 1109e77f9fedSAdrian Chadd kp->ki_lastcpu_old = td->td_lastcpu; 1110e77f9fedSAdrian Chadd 1111e77f9fedSAdrian Chadd if (td->td_oncpu == NOCPU) 1112e77f9fedSAdrian Chadd kp->ki_oncpu_old = NOCPU_OLD; 1113e77f9fedSAdrian Chadd else if (td->td_oncpu > MAXCPU_OLD) 1114e77f9fedSAdrian Chadd kp->ki_oncpu_old = MAXCPU_OLD; 1115e77f9fedSAdrian Chadd else 1116e77f9fedSAdrian Chadd kp->ki_oncpu_old = td->td_oncpu; 1117e77f9fedSAdrian Chadd 11185032ff81SDon Lewis kp->ki_lastcpu = td->td_lastcpu; 11195032ff81SDon Lewis kp->ki_oncpu = td->td_oncpu; 11205032ff81SDon Lewis kp->ki_tdflags = td->td_flags; 11215032ff81SDon Lewis kp->ki_tid = td->td_tid; 11225032ff81SDon Lewis kp->ki_numthreads = p->p_numthreads; 11235032ff81SDon Lewis kp->ki_pcb = td->td_pcb; 11245032ff81SDon Lewis kp->ki_kstack = (void *)td->td_kstack; 112554b0e65fSJeff Roberson kp->ki_slptime = (ticks - td->td_slptick) / hz; 11268460a577SJohn Birrell kp->ki_pri.pri_class = td->td_pri_class; 11278460a577SJohn Birrell kp->ki_pri.pri_user = td->td_user_pri; 11285032ff81SDon Lewis 1129f8d90480SAttilio Rao if (preferthread) { 11302417d97eSJohn Baldwin rufetchtd(td, &kp->ki_rusage); 1131213c077fSKonstantin Belousov kp->ki_runtime = cputick2usec(td->td_rux.rux_runtime); 1132f8d90480SAttilio Rao kp->ki_pctcpu = sched_pctcpu(td); 1133ccd0ec40SKonstantin Belousov kp->ki_estcpu = sched_estcpu(td); 11344d34e019SKonstantin Belousov kp->ki_cow = td->td_cow; 1135f8d90480SAttilio Rao } 1136d92909c1SRobert Watson 11375032ff81SDon Lewis /* We can't get this anymore but ps etc never used it anyway. */ 11385032ff81SDon Lewis kp->ki_rqindex = 0; 11395032ff81SDon Lewis 114000305546SKonstantin Belousov if (preferthread) 114100305546SKonstantin Belousov kp->ki_siglist = td->td_siglist; 11425032ff81SDon Lewis kp->ki_sigmask = td->td_sigmask; 1143982d11f8SJeff Roberson thread_unlock(td); 11442417d97eSJohn Baldwin if (preferthread) 11455c7bebf9SKonstantin Belousov PROC_STATUNLOCK(p); 11465032ff81SDon Lewis } 11475032ff81SDon Lewis 11485032ff81SDon Lewis /* 11495032ff81SDon Lewis * Fill in a kinfo_proc structure for the specified process. 11505032ff81SDon Lewis * Must be called with the target process locked. 11515032ff81SDon Lewis */ 11525032ff81SDon Lewis void 11535032ff81SDon Lewis fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp) 11545032ff81SDon Lewis { 11555032ff81SDon Lewis 1156f8d90480SAttilio Rao MPASS(FIRST_THREAD_IN_PROC(p) != NULL); 1157f8d90480SAttilio Rao 11585032ff81SDon Lewis fill_kinfo_proc_only(p, kp); 1159d92909c1SRobert Watson fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0); 1160f8d90480SAttilio Rao fill_kinfo_aggregate(p, kp); 11615032ff81SDon Lewis } 11625032ff81SDon Lewis 11638b059651SDavid Schultz struct pstats * 11648b059651SDavid Schultz pstats_alloc(void) 11658b059651SDavid Schultz { 11668b059651SDavid Schultz 11678b059651SDavid Schultz return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK)); 11688b059651SDavid Schultz } 11698b059651SDavid Schultz 11708b059651SDavid Schultz /* 11718b059651SDavid Schultz * Copy parts of p_stats; zero the rest of p_stats (statistics). 11728b059651SDavid Schultz */ 11738b059651SDavid Schultz void 11748b059651SDavid Schultz pstats_fork(struct pstats *src, struct pstats *dst) 11758b059651SDavid Schultz { 11768b059651SDavid Schultz 11778b059651SDavid Schultz bzero(&dst->pstat_startzero, 11786db36923SDavid Schultz __rangeof(struct pstats, pstat_startzero, pstat_endzero)); 11798b059651SDavid Schultz bcopy(&src->pstat_startcopy, &dst->pstat_startcopy, 11806db36923SDavid Schultz __rangeof(struct pstats, pstat_startcopy, pstat_endcopy)); 11818b059651SDavid Schultz } 11828b059651SDavid Schultz 11838b059651SDavid Schultz void 11848b059651SDavid Schultz pstats_free(struct pstats *ps) 11858b059651SDavid Schultz { 11868b059651SDavid Schultz 11878b059651SDavid Schultz free(ps, M_SUBPROC); 11888b059651SDavid Schultz } 11898b059651SDavid Schultz 1190134eb42eSKonstantin Belousov static struct proc * 1191134eb42eSKonstantin Belousov zpfind_locked(pid_t pid) 1192134eb42eSKonstantin Belousov { 1193134eb42eSKonstantin Belousov struct proc *p; 1194134eb42eSKonstantin Belousov 1195134eb42eSKonstantin Belousov sx_assert(&allproc_lock, SX_LOCKED); 1196134eb42eSKonstantin Belousov LIST_FOREACH(p, &zombproc, p_list) { 1197134eb42eSKonstantin Belousov if (p->p_pid == pid) { 1198134eb42eSKonstantin Belousov PROC_LOCK(p); 1199134eb42eSKonstantin Belousov break; 1200134eb42eSKonstantin Belousov } 1201134eb42eSKonstantin Belousov } 1202134eb42eSKonstantin Belousov return (p); 1203134eb42eSKonstantin Belousov } 1204134eb42eSKonstantin Belousov 12058b059651SDavid Schultz /* 120642a4ed99SJohn Baldwin * Locate a zombie process by number 120742a4ed99SJohn Baldwin */ 120842a4ed99SJohn Baldwin struct proc * 12093ce93e4eSPoul-Henning Kamp zpfind(pid_t pid) 12103ce93e4eSPoul-Henning Kamp { 12113ce93e4eSPoul-Henning Kamp struct proc *p; 12123ce93e4eSPoul-Henning Kamp 12131005a129SJohn Baldwin sx_slock(&allproc_lock); 1214134eb42eSKonstantin Belousov p = zpfind_locked(pid); 12151005a129SJohn Baldwin sx_sunlock(&allproc_lock); 12163ce93e4eSPoul-Henning Kamp return (p); 12173ce93e4eSPoul-Henning Kamp } 12183ce93e4eSPoul-Henning Kamp 121905e06d11SKonstantin Belousov #ifdef COMPAT_FREEBSD32 122005e06d11SKonstantin Belousov 122105e06d11SKonstantin Belousov /* 122205e06d11SKonstantin Belousov * This function is typically used to copy out the kernel address, so 122305e06d11SKonstantin Belousov * it can be replaced by assignment of zero. 122405e06d11SKonstantin Belousov */ 122505e06d11SKonstantin Belousov static inline uint32_t 122605e06d11SKonstantin Belousov ptr32_trim(void *ptr) 122705e06d11SKonstantin Belousov { 122805e06d11SKonstantin Belousov uintptr_t uptr; 122905e06d11SKonstantin Belousov 123005e06d11SKonstantin Belousov uptr = (uintptr_t)ptr; 123105e06d11SKonstantin Belousov return ((uptr > UINT_MAX) ? 0 : uptr); 123205e06d11SKonstantin Belousov } 123305e06d11SKonstantin Belousov 123405e06d11SKonstantin Belousov #define PTRTRIM_CP(src,dst,fld) \ 123505e06d11SKonstantin Belousov do { (dst).fld = ptr32_trim((src).fld); } while (0) 123605e06d11SKonstantin Belousov 123705e06d11SKonstantin Belousov static void 123805e06d11SKonstantin Belousov freebsd32_kinfo_proc_out(const struct kinfo_proc *ki, struct kinfo_proc32 *ki32) 123905e06d11SKonstantin Belousov { 124005e06d11SKonstantin Belousov int i; 124105e06d11SKonstantin Belousov 124205e06d11SKonstantin Belousov bzero(ki32, sizeof(struct kinfo_proc32)); 124305e06d11SKonstantin Belousov ki32->ki_structsize = sizeof(struct kinfo_proc32); 124405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_layout); 124505e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_args); 124605e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_paddr); 124705e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_addr); 124805e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_tracep); 124905e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_textvp); 125005e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_fd); 125105e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_vmspace); 125205e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_wchan); 125305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pid); 125405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ppid); 125505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pgid); 125605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tpgid); 125705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sid); 125805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tsid); 125905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_jobc); 126005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tdev); 126169921123SKonstantin Belousov CP(*ki, *ki32, ki_tdev_freebsd11); 126205e06d11SKonstantin Belousov CP(*ki, *ki32, ki_siglist); 126305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sigmask); 126405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sigignore); 126505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sigcatch); 126605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_uid); 126705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ruid); 126805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_svuid); 126905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_rgid); 127005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_svgid); 127105e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ngroups); 127205e06d11SKonstantin Belousov for (i = 0; i < KI_NGROUPS; i++) 127305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_groups[i]); 127405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_size); 127505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_rssize); 127605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_swrss); 127705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tsize); 127805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_dsize); 127905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_ssize); 128005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_xstat); 128105e06d11SKonstantin Belousov CP(*ki, *ki32, ki_acflag); 128205e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pctcpu); 128305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_estcpu); 128405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_slptime); 128505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_swtime); 1286371778a3SKonstantin Belousov CP(*ki, *ki32, ki_cow); 128705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_runtime); 128805e06d11SKonstantin Belousov TV_CP(*ki, *ki32, ki_start); 128905e06d11SKonstantin Belousov TV_CP(*ki, *ki32, ki_childtime); 129005e06d11SKonstantin Belousov CP(*ki, *ki32, ki_flag); 129105e06d11SKonstantin Belousov CP(*ki, *ki32, ki_kiflag); 129205e06d11SKonstantin Belousov CP(*ki, *ki32, ki_traceflag); 129305e06d11SKonstantin Belousov CP(*ki, *ki32, ki_stat); 129405e06d11SKonstantin Belousov CP(*ki, *ki32, ki_nice); 129505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_lock); 129605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_rqindex); 129705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_oncpu); 129805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_lastcpu); 1299e77f9fedSAdrian Chadd 1300e77f9fedSAdrian Chadd /* XXX TODO: wrap cpu value as appropriate */ 1301e77f9fedSAdrian Chadd CP(*ki, *ki32, ki_oncpu_old); 1302e77f9fedSAdrian Chadd CP(*ki, *ki32, ki_lastcpu_old); 1303e77f9fedSAdrian Chadd 1304925af544SBjoern A. Zeeb bcopy(ki->ki_tdname, ki32->ki_tdname, TDNAMLEN + 1); 130505e06d11SKonstantin Belousov bcopy(ki->ki_wmesg, ki32->ki_wmesg, WMESGLEN + 1); 130605e06d11SKonstantin Belousov bcopy(ki->ki_login, ki32->ki_login, LOGNAMELEN + 1); 130705e06d11SKonstantin Belousov bcopy(ki->ki_lockname, ki32->ki_lockname, LOCKNAMELEN + 1); 130805e06d11SKonstantin Belousov bcopy(ki->ki_comm, ki32->ki_comm, COMMLEN + 1); 130905e06d11SKonstantin Belousov bcopy(ki->ki_emul, ki32->ki_emul, KI_EMULNAMELEN + 1); 13107123f4cdSEdward Tomasz Napierala bcopy(ki->ki_loginclass, ki32->ki_loginclass, LOGINCLASSLEN + 1); 13113d32d4a7SEric van Gyzen bcopy(ki->ki_moretdname, ki32->ki_moretdname, MAXCOMLEN - TDNAMLEN + 1); 13128b04bbefSMateusz Guzik CP(*ki, *ki32, ki_tracer); 131355648840SJohn Baldwin CP(*ki, *ki32, ki_flag2); 13145e9ccc87SWill Andrews CP(*ki, *ki32, ki_fibnum); 131505e06d11SKonstantin Belousov CP(*ki, *ki32, ki_cr_flags); 131605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_jid); 131705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_numthreads); 131805e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tid); 131905e06d11SKonstantin Belousov CP(*ki, *ki32, ki_pri); 132005e06d11SKonstantin Belousov freebsd32_rusage_out(&ki->ki_rusage, &ki32->ki_rusage); 132105e06d11SKonstantin Belousov freebsd32_rusage_out(&ki->ki_rusage_ch, &ki32->ki_rusage_ch); 132205e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_pcb); 132305e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_kstack); 132405e06d11SKonstantin Belousov PTRTRIM_CP(*ki, *ki32, ki_udata); 13256aacc698SBrooks Davis PTRTRIM_CP(*ki, *ki32, ki_tdaddr); 132605e06d11SKonstantin Belousov CP(*ki, *ki32, ki_sflag); 132705e06d11SKonstantin Belousov CP(*ki, *ki32, ki_tdflags); 132805e06d11SKonstantin Belousov } 132905e06d11SKonstantin Belousov #endif 133005e06d11SKonstantin Belousov 13319d4e369aSMateusz Guzik static ssize_t 13329d4e369aSMateusz Guzik kern_proc_out_size(struct proc *p, int flags) 13339d4e369aSMateusz Guzik { 13349d4e369aSMateusz Guzik ssize_t size = 0; 13359d4e369aSMateusz Guzik 13369d4e369aSMateusz Guzik PROC_LOCK_ASSERT(p, MA_OWNED); 13379d4e369aSMateusz Guzik 13389d4e369aSMateusz Guzik if ((flags & KERN_PROC_NOTHREADS) != 0) { 13399d4e369aSMateusz Guzik #ifdef COMPAT_FREEBSD32 13409d4e369aSMateusz Guzik if ((flags & KERN_PROC_MASK32) != 0) { 13419d4e369aSMateusz Guzik size += sizeof(struct kinfo_proc32); 13429d4e369aSMateusz Guzik } else 13439d4e369aSMateusz Guzik #endif 13449d4e369aSMateusz Guzik size += sizeof(struct kinfo_proc); 13459d4e369aSMateusz Guzik } else { 13469d4e369aSMateusz Guzik #ifdef COMPAT_FREEBSD32 13479d4e369aSMateusz Guzik if ((flags & KERN_PROC_MASK32) != 0) 13489d4e369aSMateusz Guzik size += sizeof(struct kinfo_proc32) * p->p_numthreads; 13499d4e369aSMateusz Guzik else 13509d4e369aSMateusz Guzik #endif 13519d4e369aSMateusz Guzik size += sizeof(struct kinfo_proc) * p->p_numthreads; 13529d4e369aSMateusz Guzik } 13539d4e369aSMateusz Guzik PROC_UNLOCK(p); 13549d4e369aSMateusz Guzik return (size); 13559d4e369aSMateusz Guzik } 13569d4e369aSMateusz Guzik 1357fe52cf54SMikolaj Golub int 1358fe52cf54SMikolaj Golub kern_proc_out(struct proc *p, struct sbuf *sb, int flags) 13593ce93e4eSPoul-Henning Kamp { 136030c6f34eSScott Long struct thread *td; 1361fe52cf54SMikolaj Golub struct kinfo_proc ki; 1362fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32 1363fe52cf54SMikolaj Golub struct kinfo_proc32 ki32; 1364fe52cf54SMikolaj Golub #endif 1365fe52cf54SMikolaj Golub int error; 13663ce93e4eSPoul-Henning Kamp 136765c9b430SJohn Baldwin PROC_LOCK_ASSERT(p, MA_OWNED); 1368f8d90480SAttilio Rao MPASS(FIRST_THREAD_IN_PROC(p) != NULL); 136930c6f34eSScott Long 1370fe52cf54SMikolaj Golub error = 0; 1371fe52cf54SMikolaj Golub fill_kinfo_proc(p, &ki); 1372fe52cf54SMikolaj Golub if ((flags & KERN_PROC_NOTHREADS) != 0) { 1373fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32 1374fe52cf54SMikolaj Golub if ((flags & KERN_PROC_MASK32) != 0) { 1375fe52cf54SMikolaj Golub freebsd32_kinfo_proc_out(&ki, &ki32); 137657c2505eSKonstantin Belousov if (sbuf_bcat(sb, &ki32, sizeof(ki32)) != 0) 137757c2505eSKonstantin Belousov error = ENOMEM; 1378fe52cf54SMikolaj Golub } else 1379fe52cf54SMikolaj Golub #endif 138057c2505eSKonstantin Belousov if (sbuf_bcat(sb, &ki, sizeof(ki)) != 0) 138157c2505eSKonstantin Belousov error = ENOMEM; 1382fe52cf54SMikolaj Golub } else { 138330c6f34eSScott Long FOREACH_THREAD_IN_PROC(p, td) { 1384fe52cf54SMikolaj Golub fill_kinfo_thread(td, &ki, 1); 1385fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32 1386fe52cf54SMikolaj Golub if ((flags & KERN_PROC_MASK32) != 0) { 1387fe52cf54SMikolaj Golub freebsd32_kinfo_proc_out(&ki, &ki32); 138857c2505eSKonstantin Belousov if (sbuf_bcat(sb, &ki32, sizeof(ki32)) != 0) 138957c2505eSKonstantin Belousov error = ENOMEM; 1390fe52cf54SMikolaj Golub } else 1391fe52cf54SMikolaj Golub #endif 139257c2505eSKonstantin Belousov if (sbuf_bcat(sb, &ki, sizeof(ki)) != 0) 139357c2505eSKonstantin Belousov error = ENOMEM; 139457c2505eSKonstantin Belousov if (error != 0) 139530c6f34eSScott Long break; 139630c6f34eSScott Long } 139730c6f34eSScott Long } 139830c6f34eSScott Long PROC_UNLOCK(p); 13993ce93e4eSPoul-Henning Kamp return (error); 1400fe52cf54SMikolaj Golub } 1401fe52cf54SMikolaj Golub 1402fe52cf54SMikolaj Golub static int 14039b57bf75SMateusz Guzik sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags) 1404fe52cf54SMikolaj Golub { 1405fe52cf54SMikolaj Golub struct sbuf sb; 1406fe52cf54SMikolaj Golub struct kinfo_proc ki; 1407fe52cf54SMikolaj Golub int error, error2; 1408fe52cf54SMikolaj Golub 14099d4e369aSMateusz Guzik if (req->oldptr == NULL) 14109d4e369aSMateusz Guzik return (SYSCTL_OUT(req, 0, kern_proc_out_size(p, flags))); 14119d4e369aSMateusz Guzik 1412fe52cf54SMikolaj Golub sbuf_new_for_sysctl(&sb, (char *)&ki, sizeof(ki), req); 14131eafc078SIan Lepore sbuf_clear_flags(&sb, SBUF_INCLUDENUL); 1414fe52cf54SMikolaj Golub error = kern_proc_out(p, &sb, flags); 1415fe52cf54SMikolaj Golub error2 = sbuf_finish(&sb); 1416fe52cf54SMikolaj Golub sbuf_delete(&sb); 1417fe52cf54SMikolaj Golub if (error != 0) 1418fe52cf54SMikolaj Golub return (error); 1419fe52cf54SMikolaj Golub else if (error2 != 0) 1420fe52cf54SMikolaj Golub return (error2); 14213ce93e4eSPoul-Henning Kamp return (0); 14223ce93e4eSPoul-Henning Kamp } 14233ce93e4eSPoul-Henning Kamp 1424972f9b20SPoul-Henning Kamp static int 142582d9ae4eSPoul-Henning Kamp sysctl_kern_proc(SYSCTL_HANDLER_ARGS) 1426972f9b20SPoul-Henning Kamp { 1427972f9b20SPoul-Henning Kamp int *name = (int *)arg1; 1428972f9b20SPoul-Henning Kamp u_int namelen = arg2; 1429972f9b20SPoul-Henning Kamp struct proc *p; 14302648efa6SDaniel Eischen int flags, doingzomb, oid_number; 1431972f9b20SPoul-Henning Kamp int error = 0; 1432972f9b20SPoul-Henning Kamp 14332648efa6SDaniel Eischen oid_number = oidp->oid_number; 14342648efa6SDaniel Eischen if (oid_number != KERN_PROC_ALL && 14352648efa6SDaniel Eischen (oid_number & KERN_PROC_INC_THREAD) == 0) 14362648efa6SDaniel Eischen flags = KERN_PROC_NOTHREADS; 14372648efa6SDaniel Eischen else { 14382648efa6SDaniel Eischen flags = 0; 14392648efa6SDaniel Eischen oid_number &= ~KERN_PROC_INC_THREAD; 14402648efa6SDaniel Eischen } 1441fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32 1442fe52cf54SMikolaj Golub if (req->flags & SCTL_MASK32) 1443fe52cf54SMikolaj Golub flags |= KERN_PROC_MASK32; 1444fe52cf54SMikolaj Golub #endif 14452648efa6SDaniel Eischen if (oid_number == KERN_PROC_PID) { 14463ce93e4eSPoul-Henning Kamp if (namelen != 1) 1447972f9b20SPoul-Henning Kamp return (EINVAL); 14485032ff81SDon Lewis error = sysctl_wire_old_buffer(req, 0); 14495032ff81SDon Lewis if (error) 14505032ff81SDon Lewis return (error); 1451fa3935bcSMikolaj Golub error = pget((pid_t)name[0], PGET_CANSEE, &p); 14528b04bbefSMateusz Guzik if (error == 0) 14539b57bf75SMateusz Guzik error = sysctl_out_proc(p, req, flags); 14543ce93e4eSPoul-Henning Kamp return (error); 14553ce93e4eSPoul-Henning Kamp } 14563ddaef40STim J. Robbins 14572648efa6SDaniel Eischen switch (oid_number) { 14583ddaef40STim J. Robbins case KERN_PROC_ALL: 14593ddaef40STim J. Robbins if (namelen != 0) 14603ce93e4eSPoul-Henning Kamp return (EINVAL); 14613ddaef40STim J. Robbins break; 146225e247afSPeter Wemm case KERN_PROC_PROC: 146325e247afSPeter Wemm if (namelen != 0 && namelen != 1) 146425e247afSPeter Wemm return (EINVAL); 146525e247afSPeter Wemm break; 14663ddaef40STim J. Robbins default: 14673ddaef40STim J. Robbins if (namelen != 1) 14683ddaef40STim J. Robbins return (EINVAL); 14693ddaef40STim J. Robbins break; 14703ddaef40STim J. Robbins } 14713ce93e4eSPoul-Henning Kamp 14729d4e369aSMateusz Guzik if (req->oldptr == NULL) { 14733ce93e4eSPoul-Henning Kamp /* overestimate by 5 procs */ 1474972f9b20SPoul-Henning Kamp error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5); 1475972f9b20SPoul-Henning Kamp if (error) 1476972f9b20SPoul-Henning Kamp return (error); 14779d4e369aSMateusz Guzik } else { 147847934cefSDon Lewis error = sysctl_wire_old_buffer(req, 0); 147947934cefSDon Lewis if (error != 0) 148047934cefSDon Lewis return (error); 14819d4e369aSMateusz Guzik } 14821005a129SJohn Baldwin sx_slock(&allproc_lock); 14833ce93e4eSPoul-Henning Kamp for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) { 14843ce93e4eSPoul-Henning Kamp if (!doingzomb) 14851b727751SPoul-Henning Kamp p = LIST_FIRST(&allproc); 14863ce93e4eSPoul-Henning Kamp else 14871b727751SPoul-Henning Kamp p = LIST_FIRST(&zombproc); 1488b85f65afSPedro F. Giffuni for (; p != NULL; p = LIST_NEXT(p, p_list)) { 148902e878d9SJohn Baldwin /* 149002e878d9SJohn Baldwin * Skip embryonic processes. 149102e878d9SJohn Baldwin */ 149299713164SMateusz Guzik if (p->p_state == PRS_NEW) 149302e878d9SJohn Baldwin continue; 149499713164SMateusz Guzik PROC_LOCK(p); 1495b241b0a2SJuli Mallett KASSERT(p->p_ucred != NULL, 1496b241b0a2SJuli Mallett ("process credential is NULL for non-NEW proc")); 1497972f9b20SPoul-Henning Kamp /* 1498387d2c03SRobert Watson * Show a user only appropriate processes. 149903f808c5SPaul Saab */ 1500f44d9e24SJohn Baldwin if (p_cansee(curthread, p)) { 150165c9b430SJohn Baldwin PROC_UNLOCK(p); 150203f808c5SPaul Saab continue; 150365c9b430SJohn Baldwin } 150403f808c5SPaul Saab /* 1505972f9b20SPoul-Henning Kamp * TODO - make more efficient (see notes below). 1506972f9b20SPoul-Henning Kamp * do by session. 1507972f9b20SPoul-Henning Kamp */ 15082648efa6SDaniel Eischen switch (oid_number) { 1509972f9b20SPoul-Henning Kamp 1510078842c5SGarance A Drosehn case KERN_PROC_GID: 1511b241b0a2SJuli Mallett if (p->p_ucred->cr_gid != (gid_t)name[0]) { 1512078842c5SGarance A Drosehn PROC_UNLOCK(p); 1513078842c5SGarance A Drosehn continue; 1514078842c5SGarance A Drosehn } 1515078842c5SGarance A Drosehn break; 1516078842c5SGarance A Drosehn 1517972f9b20SPoul-Henning Kamp case KERN_PROC_PGRP: 1518972f9b20SPoul-Henning Kamp /* could do this by traversing pgrp */ 15193ce93e4eSPoul-Henning Kamp if (p->p_pgrp == NULL || 1520f591779bSSeigo Tanimura p->p_pgrp->pg_id != (pid_t)name[0]) { 1521f591779bSSeigo Tanimura PROC_UNLOCK(p); 1522972f9b20SPoul-Henning Kamp continue; 1523f591779bSSeigo Tanimura } 1524972f9b20SPoul-Henning Kamp break; 1525972f9b20SPoul-Henning Kamp 1526b8fdc89dSGarance A Drosehn case KERN_PROC_RGID: 1527b241b0a2SJuli Mallett if (p->p_ucred->cr_rgid != (gid_t)name[0]) { 1528b8fdc89dSGarance A Drosehn PROC_UNLOCK(p); 1529b8fdc89dSGarance A Drosehn continue; 1530b8fdc89dSGarance A Drosehn } 1531b8fdc89dSGarance A Drosehn break; 1532b8fdc89dSGarance A Drosehn 1533b8fdc89dSGarance A Drosehn case KERN_PROC_SESSION: 1534b8fdc89dSGarance A Drosehn if (p->p_session == NULL || 1535b8fdc89dSGarance A Drosehn p->p_session->s_sid != (pid_t)name[0]) { 1536b8fdc89dSGarance A Drosehn PROC_UNLOCK(p); 1537b8fdc89dSGarance A Drosehn continue; 1538b8fdc89dSGarance A Drosehn } 1539b8fdc89dSGarance A Drosehn break; 1540b8fdc89dSGarance A Drosehn 1541972f9b20SPoul-Henning Kamp case KERN_PROC_TTY: 1542972f9b20SPoul-Henning Kamp if ((p->p_flag & P_CONTROLT) == 0 || 1543f591779bSSeigo Tanimura p->p_session == NULL) { 1544f591779bSSeigo Tanimura PROC_UNLOCK(p); 1545972f9b20SPoul-Henning Kamp continue; 1546f591779bSSeigo Tanimura } 1547bc093719SEd Schouten /* XXX proctree_lock */ 1548f591779bSSeigo Tanimura SESS_LOCK(p->p_session); 1549f591779bSSeigo Tanimura if (p->p_session->s_ttyp == NULL || 1550bc093719SEd Schouten tty_udev(p->p_session->s_ttyp) != 1551f3732fd1SPoul-Henning Kamp (dev_t)name[0]) { 1552f591779bSSeigo Tanimura SESS_UNLOCK(p->p_session); 1553f591779bSSeigo Tanimura PROC_UNLOCK(p); 1554f591779bSSeigo Tanimura continue; 1555f591779bSSeigo Tanimura } 1556f591779bSSeigo Tanimura SESS_UNLOCK(p->p_session); 1557972f9b20SPoul-Henning Kamp break; 1558972f9b20SPoul-Henning Kamp 1559972f9b20SPoul-Henning Kamp case KERN_PROC_UID: 1560b241b0a2SJuli Mallett if (p->p_ucred->cr_uid != (uid_t)name[0]) { 156165c9b430SJohn Baldwin PROC_UNLOCK(p); 1562972f9b20SPoul-Henning Kamp continue; 156365c9b430SJohn Baldwin } 1564972f9b20SPoul-Henning Kamp break; 1565972f9b20SPoul-Henning Kamp 1566972f9b20SPoul-Henning Kamp case KERN_PROC_RUID: 1567b241b0a2SJuli Mallett if (p->p_ucred->cr_ruid != (uid_t)name[0]) { 156865c9b430SJohn Baldwin PROC_UNLOCK(p); 1569972f9b20SPoul-Henning Kamp continue; 157065c9b430SJohn Baldwin } 1571972f9b20SPoul-Henning Kamp break; 157230c6f34eSScott Long 157330c6f34eSScott Long case KERN_PROC_PROC: 157430c6f34eSScott Long break; 157530c6f34eSScott Long 157630c6f34eSScott Long default: 157730c6f34eSScott Long break; 157830c6f34eSScott Long 1579972f9b20SPoul-Henning Kamp } 1580972f9b20SPoul-Henning Kamp 15819b57bf75SMateusz Guzik error = sysctl_out_proc(p, req, flags); 15829d4e369aSMateusz Guzik if (error) 15839d4e369aSMateusz Guzik goto out; 15849d4e369aSMateusz Guzik } 15859d4e369aSMateusz Guzik } 15869d4e369aSMateusz Guzik out: 15871005a129SJohn Baldwin sx_sunlock(&allproc_lock); 1588972f9b20SPoul-Henning Kamp return (error); 1589972f9b20SPoul-Henning Kamp } 1590972f9b20SPoul-Henning Kamp 1591c1508b28SAlfred Perlstein struct pargs * 1592c1508b28SAlfred Perlstein pargs_alloc(int len) 1593c1508b28SAlfred Perlstein { 1594c1508b28SAlfred Perlstein struct pargs *pa; 1595c1508b28SAlfred Perlstein 15961ede983cSDag-Erling Smørgrav pa = malloc(sizeof(struct pargs) + len, M_PARGS, 1597a163d034SWarner Losh M_WAITOK); 159855b4a5aeSJohn Baldwin refcount_init(&pa->ar_ref, 1); 1599c1508b28SAlfred Perlstein pa->ar_length = len; 1600c1508b28SAlfred Perlstein return (pa); 1601c1508b28SAlfred Perlstein } 1602c1508b28SAlfred Perlstein 160358e8af1bSKonstantin Belousov static void 1604c1508b28SAlfred Perlstein pargs_free(struct pargs *pa) 1605c1508b28SAlfred Perlstein { 1606c1508b28SAlfred Perlstein 16071ede983cSDag-Erling Smørgrav free(pa, M_PARGS); 1608c1508b28SAlfred Perlstein } 1609c1508b28SAlfred Perlstein 1610c1508b28SAlfred Perlstein void 1611c1508b28SAlfred Perlstein pargs_hold(struct pargs *pa) 1612c1508b28SAlfred Perlstein { 1613c1508b28SAlfred Perlstein 1614c1508b28SAlfred Perlstein if (pa == NULL) 1615c1508b28SAlfred Perlstein return; 161655b4a5aeSJohn Baldwin refcount_acquire(&pa->ar_ref); 1617c1508b28SAlfred Perlstein } 1618c1508b28SAlfred Perlstein 1619c1508b28SAlfred Perlstein void 1620c1508b28SAlfred Perlstein pargs_drop(struct pargs *pa) 1621c1508b28SAlfred Perlstein { 1622c1508b28SAlfred Perlstein 1623c1508b28SAlfred Perlstein if (pa == NULL) 1624c1508b28SAlfred Perlstein return; 162555b4a5aeSJohn Baldwin if (refcount_release(&pa->ar_ref)) 1626c1508b28SAlfred Perlstein pargs_free(pa); 1627c1508b28SAlfred Perlstein } 1628c1508b28SAlfred Perlstein 1629c5cfcb1cSMikolaj Golub static int 1630c5cfcb1cSMikolaj Golub proc_read_string(struct thread *td, struct proc *p, const char *sptr, char *buf, 1631c5cfcb1cSMikolaj Golub size_t len) 1632c5cfcb1cSMikolaj Golub { 1633711fbd17SMark Johnston ssize_t n; 1634c5cfcb1cSMikolaj Golub 1635c5cfcb1cSMikolaj Golub /* 1636711fbd17SMark Johnston * This may return a short read if the string is shorter than the chunk 1637711fbd17SMark Johnston * and is aligned at the end of the page, and the following page is not 1638711fbd17SMark Johnston * mapped. 1639c5cfcb1cSMikolaj Golub */ 1640711fbd17SMark Johnston n = proc_readmem(td, p, (vm_offset_t)sptr, buf, len); 1641711fbd17SMark Johnston if (n <= 0) 1642711fbd17SMark Johnston return (ENOMEM); 1643711fbd17SMark Johnston return (0); 1644c5cfcb1cSMikolaj Golub } 1645c5cfcb1cSMikolaj Golub 1646c5cfcb1cSMikolaj Golub #define PROC_AUXV_MAX 256 /* Safety limit on auxv size. */ 1647c5cfcb1cSMikolaj Golub 1648c5cfcb1cSMikolaj Golub enum proc_vector_type { 1649c5cfcb1cSMikolaj Golub PROC_ARG, 1650c5cfcb1cSMikolaj Golub PROC_ENV, 1651c5cfcb1cSMikolaj Golub PROC_AUX, 1652c5cfcb1cSMikolaj Golub }; 1653c5cfcb1cSMikolaj Golub 1654c5cfcb1cSMikolaj Golub #ifdef COMPAT_FREEBSD32 1655c5cfcb1cSMikolaj Golub static int 1656c5cfcb1cSMikolaj Golub get_proc_vector32(struct thread *td, struct proc *p, char ***proc_vectorp, 1657c5cfcb1cSMikolaj Golub size_t *vsizep, enum proc_vector_type type) 1658c5cfcb1cSMikolaj Golub { 1659c5cfcb1cSMikolaj Golub struct freebsd32_ps_strings pss; 1660c5cfcb1cSMikolaj Golub Elf32_Auxinfo aux; 1661c5cfcb1cSMikolaj Golub vm_offset_t vptr, ptr; 1662c5cfcb1cSMikolaj Golub uint32_t *proc_vector32; 1663c5cfcb1cSMikolaj Golub char **proc_vector; 1664c5cfcb1cSMikolaj Golub size_t vsize, size; 1665c5cfcb1cSMikolaj Golub int i, error; 1666c5cfcb1cSMikolaj Golub 1667711fbd17SMark Johnston error = 0; 1668711fbd17SMark Johnston if (proc_readmem(td, p, (vm_offset_t)p->p_sysent->sv_psstrings, &pss, 1669711fbd17SMark Johnston sizeof(pss)) != sizeof(pss)) 1670711fbd17SMark Johnston return (ENOMEM); 1671c5cfcb1cSMikolaj Golub switch (type) { 1672c5cfcb1cSMikolaj Golub case PROC_ARG: 1673c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)PTRIN(pss.ps_argvstr); 1674c5cfcb1cSMikolaj Golub vsize = pss.ps_nargvstr; 1675c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1676c5cfcb1cSMikolaj Golub return (ENOEXEC); 1677c5cfcb1cSMikolaj Golub size = vsize * sizeof(int32_t); 1678c5cfcb1cSMikolaj Golub break; 1679c5cfcb1cSMikolaj Golub case PROC_ENV: 1680c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)PTRIN(pss.ps_envstr); 1681c5cfcb1cSMikolaj Golub vsize = pss.ps_nenvstr; 1682c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1683c5cfcb1cSMikolaj Golub return (ENOEXEC); 1684c5cfcb1cSMikolaj Golub size = vsize * sizeof(int32_t); 1685c5cfcb1cSMikolaj Golub break; 1686c5cfcb1cSMikolaj Golub case PROC_AUX: 1687c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)PTRIN(pss.ps_envstr) + 1688c5cfcb1cSMikolaj Golub (pss.ps_nenvstr + 1) * sizeof(int32_t); 1689c5cfcb1cSMikolaj Golub if (vptr % 4 != 0) 1690c5cfcb1cSMikolaj Golub return (ENOEXEC); 1691c5cfcb1cSMikolaj Golub for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) { 1692711fbd17SMark Johnston if (proc_readmem(td, p, ptr, &aux, sizeof(aux)) != 1693711fbd17SMark Johnston sizeof(aux)) 1694711fbd17SMark Johnston return (ENOMEM); 1695c5cfcb1cSMikolaj Golub if (aux.a_type == AT_NULL) 1696c5cfcb1cSMikolaj Golub break; 1697c5cfcb1cSMikolaj Golub ptr += sizeof(aux); 1698c5cfcb1cSMikolaj Golub } 1699c5cfcb1cSMikolaj Golub if (aux.a_type != AT_NULL) 1700c5cfcb1cSMikolaj Golub return (ENOEXEC); 1701c5cfcb1cSMikolaj Golub vsize = i + 1; 1702c5cfcb1cSMikolaj Golub size = vsize * sizeof(aux); 1703c5cfcb1cSMikolaj Golub break; 1704c5cfcb1cSMikolaj Golub default: 1705c5cfcb1cSMikolaj Golub KASSERT(0, ("Wrong proc vector type: %d", type)); 17067ad9baaeSMikolaj Golub return (EINVAL); 1707c5cfcb1cSMikolaj Golub } 1708c5cfcb1cSMikolaj Golub proc_vector32 = malloc(size, M_TEMP, M_WAITOK); 1709711fbd17SMark Johnston if (proc_readmem(td, p, vptr, proc_vector32, size) != size) { 1710711fbd17SMark Johnston error = ENOMEM; 1711c5cfcb1cSMikolaj Golub goto done; 1712711fbd17SMark Johnston } 1713c5cfcb1cSMikolaj Golub if (type == PROC_AUX) { 1714c5cfcb1cSMikolaj Golub *proc_vectorp = (char **)proc_vector32; 1715c5cfcb1cSMikolaj Golub *vsizep = vsize; 1716c5cfcb1cSMikolaj Golub return (0); 1717c5cfcb1cSMikolaj Golub } 1718c5cfcb1cSMikolaj Golub proc_vector = malloc(vsize * sizeof(char *), M_TEMP, M_WAITOK); 1719c5cfcb1cSMikolaj Golub for (i = 0; i < (int)vsize; i++) 1720c5cfcb1cSMikolaj Golub proc_vector[i] = PTRIN(proc_vector32[i]); 1721c5cfcb1cSMikolaj Golub *proc_vectorp = proc_vector; 1722c5cfcb1cSMikolaj Golub *vsizep = vsize; 1723c5cfcb1cSMikolaj Golub done: 1724c5cfcb1cSMikolaj Golub free(proc_vector32, M_TEMP); 1725c5cfcb1cSMikolaj Golub return (error); 1726c5cfcb1cSMikolaj Golub } 1727c5cfcb1cSMikolaj Golub #endif 1728c5cfcb1cSMikolaj Golub 1729c5cfcb1cSMikolaj Golub static int 1730c5cfcb1cSMikolaj Golub get_proc_vector(struct thread *td, struct proc *p, char ***proc_vectorp, 1731c5cfcb1cSMikolaj Golub size_t *vsizep, enum proc_vector_type type) 1732c5cfcb1cSMikolaj Golub { 1733c5cfcb1cSMikolaj Golub struct ps_strings pss; 1734c5cfcb1cSMikolaj Golub Elf_Auxinfo aux; 1735c5cfcb1cSMikolaj Golub vm_offset_t vptr, ptr; 1736c5cfcb1cSMikolaj Golub char **proc_vector; 1737c5cfcb1cSMikolaj Golub size_t vsize, size; 1738711fbd17SMark Johnston int i; 1739c5cfcb1cSMikolaj Golub 1740c5cfcb1cSMikolaj Golub #ifdef COMPAT_FREEBSD32 1741c5cfcb1cSMikolaj Golub if (SV_PROC_FLAG(p, SV_ILP32) != 0) 1742c5cfcb1cSMikolaj Golub return (get_proc_vector32(td, p, proc_vectorp, vsizep, type)); 1743c5cfcb1cSMikolaj Golub #endif 1744711fbd17SMark Johnston if (proc_readmem(td, p, (vm_offset_t)p->p_sysent->sv_psstrings, &pss, 1745711fbd17SMark Johnston sizeof(pss)) != sizeof(pss)) 1746711fbd17SMark Johnston return (ENOMEM); 1747c5cfcb1cSMikolaj Golub switch (type) { 1748c5cfcb1cSMikolaj Golub case PROC_ARG: 1749c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)pss.ps_argvstr; 1750c5cfcb1cSMikolaj Golub vsize = pss.ps_nargvstr; 1751c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1752c5cfcb1cSMikolaj Golub return (ENOEXEC); 1753c5cfcb1cSMikolaj Golub size = vsize * sizeof(char *); 1754c5cfcb1cSMikolaj Golub break; 1755c5cfcb1cSMikolaj Golub case PROC_ENV: 1756c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)pss.ps_envstr; 1757c5cfcb1cSMikolaj Golub vsize = pss.ps_nenvstr; 1758c5cfcb1cSMikolaj Golub if (vsize > ARG_MAX) 1759c5cfcb1cSMikolaj Golub return (ENOEXEC); 1760c5cfcb1cSMikolaj Golub size = vsize * sizeof(char *); 1761c5cfcb1cSMikolaj Golub break; 1762c5cfcb1cSMikolaj Golub case PROC_AUX: 1763c5cfcb1cSMikolaj Golub /* 1764c5cfcb1cSMikolaj Golub * The aux array is just above env array on the stack. Check 1765c5cfcb1cSMikolaj Golub * that the address is naturally aligned. 1766c5cfcb1cSMikolaj Golub */ 1767c5cfcb1cSMikolaj Golub vptr = (vm_offset_t)pss.ps_envstr + (pss.ps_nenvstr + 1) 1768c5cfcb1cSMikolaj Golub * sizeof(char *); 1769c5cfcb1cSMikolaj Golub #if __ELF_WORD_SIZE == 64 1770c5cfcb1cSMikolaj Golub if (vptr % sizeof(uint64_t) != 0) 1771c5cfcb1cSMikolaj Golub #else 1772c5cfcb1cSMikolaj Golub if (vptr % sizeof(uint32_t) != 0) 1773c5cfcb1cSMikolaj Golub #endif 1774c5cfcb1cSMikolaj Golub return (ENOEXEC); 1775c5cfcb1cSMikolaj Golub /* 1776c5cfcb1cSMikolaj Golub * We count the array size reading the aux vectors from the 1777c5cfcb1cSMikolaj Golub * stack until AT_NULL vector is returned. So (to keep the code 1778c5cfcb1cSMikolaj Golub * simple) we read the process stack twice: the first time here 1779c5cfcb1cSMikolaj Golub * to find the size and the second time when copying the vectors 1780c5cfcb1cSMikolaj Golub * to the allocated proc_vector. 1781c5cfcb1cSMikolaj Golub */ 1782c5cfcb1cSMikolaj Golub for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) { 1783711fbd17SMark Johnston if (proc_readmem(td, p, ptr, &aux, sizeof(aux)) != 1784711fbd17SMark Johnston sizeof(aux)) 1785711fbd17SMark Johnston return (ENOMEM); 1786c5cfcb1cSMikolaj Golub if (aux.a_type == AT_NULL) 1787c5cfcb1cSMikolaj Golub break; 1788c5cfcb1cSMikolaj Golub ptr += sizeof(aux); 1789c5cfcb1cSMikolaj Golub } 1790c5cfcb1cSMikolaj Golub /* 1791c5cfcb1cSMikolaj Golub * If the PROC_AUXV_MAX entries are iterated over, and we have 1792c5cfcb1cSMikolaj Golub * not reached AT_NULL, it is most likely we are reading wrong 1793c5cfcb1cSMikolaj Golub * data: either the process doesn't have auxv array or data has 1794c5cfcb1cSMikolaj Golub * been modified. Return the error in this case. 1795c5cfcb1cSMikolaj Golub */ 1796c5cfcb1cSMikolaj Golub if (aux.a_type != AT_NULL) 1797c5cfcb1cSMikolaj Golub return (ENOEXEC); 1798c5cfcb1cSMikolaj Golub vsize = i + 1; 1799c5cfcb1cSMikolaj Golub size = vsize * sizeof(aux); 1800c5cfcb1cSMikolaj Golub break; 1801c5cfcb1cSMikolaj Golub default: 1802c5cfcb1cSMikolaj Golub KASSERT(0, ("Wrong proc vector type: %d", type)); 18037ad9baaeSMikolaj Golub return (EINVAL); /* In case we are built without INVARIANTS. */ 1804c5cfcb1cSMikolaj Golub } 1805c5cfcb1cSMikolaj Golub proc_vector = malloc(size, M_TEMP, M_WAITOK); 1806711fbd17SMark Johnston if (proc_readmem(td, p, vptr, proc_vector, size) != size) { 1807c5cfcb1cSMikolaj Golub free(proc_vector, M_TEMP); 1808711fbd17SMark Johnston return (ENOMEM); 1809c5cfcb1cSMikolaj Golub } 1810c5cfcb1cSMikolaj Golub *proc_vectorp = proc_vector; 1811c5cfcb1cSMikolaj Golub *vsizep = vsize; 1812c5cfcb1cSMikolaj Golub 1813c5cfcb1cSMikolaj Golub return (0); 1814c5cfcb1cSMikolaj Golub } 1815c5cfcb1cSMikolaj Golub 1816c5cfcb1cSMikolaj Golub #define GET_PS_STRINGS_CHUNK_SZ 256 /* Chunk size (bytes) for ps_strings operations. */ 1817c5cfcb1cSMikolaj Golub 1818c5cfcb1cSMikolaj Golub static int 1819c5cfcb1cSMikolaj Golub get_ps_strings(struct thread *td, struct proc *p, struct sbuf *sb, 1820fe7f89b7SMikolaj Golub enum proc_vector_type type) 1821c5cfcb1cSMikolaj Golub { 1822fe7f89b7SMikolaj Golub size_t done, len, nchr, vsize; 1823c5cfcb1cSMikolaj Golub int error, i; 1824c5cfcb1cSMikolaj Golub char **proc_vector, *sptr; 1825c5cfcb1cSMikolaj Golub char pss_string[GET_PS_STRINGS_CHUNK_SZ]; 1826c5cfcb1cSMikolaj Golub 1827c5cfcb1cSMikolaj Golub PROC_ASSERT_HELD(p); 1828c5cfcb1cSMikolaj Golub 1829c5cfcb1cSMikolaj Golub /* 1830c5cfcb1cSMikolaj Golub * We are not going to read more than 2 * (PATH_MAX + ARG_MAX) bytes. 1831c5cfcb1cSMikolaj Golub */ 1832c5cfcb1cSMikolaj Golub nchr = 2 * (PATH_MAX + ARG_MAX); 1833c5cfcb1cSMikolaj Golub 1834c5cfcb1cSMikolaj Golub error = get_proc_vector(td, p, &proc_vector, &vsize, type); 1835c5cfcb1cSMikolaj Golub if (error != 0) 1836c5cfcb1cSMikolaj Golub return (error); 1837c5cfcb1cSMikolaj Golub for (done = 0, i = 0; i < (int)vsize && done < nchr; i++) { 1838c5cfcb1cSMikolaj Golub /* 1839c5cfcb1cSMikolaj Golub * The program may have scribbled into its argv array, e.g. to 1840c5cfcb1cSMikolaj Golub * remove some arguments. If that has happened, break out 1841c5cfcb1cSMikolaj Golub * before trying to read from NULL. 1842c5cfcb1cSMikolaj Golub */ 1843c5cfcb1cSMikolaj Golub if (proc_vector[i] == NULL) 1844c5cfcb1cSMikolaj Golub break; 1845c5cfcb1cSMikolaj Golub for (sptr = proc_vector[i]; ; sptr += GET_PS_STRINGS_CHUNK_SZ) { 1846c5cfcb1cSMikolaj Golub error = proc_read_string(td, p, sptr, pss_string, 1847c5cfcb1cSMikolaj Golub sizeof(pss_string)); 1848c5cfcb1cSMikolaj Golub if (error != 0) 1849c5cfcb1cSMikolaj Golub goto done; 1850c5cfcb1cSMikolaj Golub len = strnlen(pss_string, GET_PS_STRINGS_CHUNK_SZ); 1851c5cfcb1cSMikolaj Golub if (done + len >= nchr) 1852c5cfcb1cSMikolaj Golub len = nchr - done - 1; 1853c5cfcb1cSMikolaj Golub sbuf_bcat(sb, pss_string, len); 1854c5cfcb1cSMikolaj Golub if (len != GET_PS_STRINGS_CHUNK_SZ) 1855c5cfcb1cSMikolaj Golub break; 1856c5cfcb1cSMikolaj Golub done += GET_PS_STRINGS_CHUNK_SZ; 1857c5cfcb1cSMikolaj Golub } 1858c5cfcb1cSMikolaj Golub sbuf_bcat(sb, "", 1); 1859c5cfcb1cSMikolaj Golub done += len + 1; 1860c5cfcb1cSMikolaj Golub } 1861c5cfcb1cSMikolaj Golub done: 1862c5cfcb1cSMikolaj Golub free(proc_vector, M_TEMP); 1863c5cfcb1cSMikolaj Golub return (error); 1864c5cfcb1cSMikolaj Golub } 1865c5cfcb1cSMikolaj Golub 1866c5cfcb1cSMikolaj Golub int 1867fe7f89b7SMikolaj Golub proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb) 1868c5cfcb1cSMikolaj Golub { 1869c5cfcb1cSMikolaj Golub 1870fe7f89b7SMikolaj Golub return (get_ps_strings(curthread, p, sb, PROC_ARG)); 1871c5cfcb1cSMikolaj Golub } 1872c5cfcb1cSMikolaj Golub 1873c5cfcb1cSMikolaj Golub int 1874fe7f89b7SMikolaj Golub proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb) 1875c5cfcb1cSMikolaj Golub { 1876c5cfcb1cSMikolaj Golub 1877fe7f89b7SMikolaj Golub return (get_ps_strings(curthread, p, sb, PROC_ENV)); 1878c5cfcb1cSMikolaj Golub } 1879c5cfcb1cSMikolaj Golub 18805ea21e69SMikolaj Golub int 18815ea21e69SMikolaj Golub proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb) 18825ea21e69SMikolaj Golub { 18835ea21e69SMikolaj Golub size_t vsize, size; 18845ea21e69SMikolaj Golub char **auxv; 18855ea21e69SMikolaj Golub int error; 18865ea21e69SMikolaj Golub 18875ea21e69SMikolaj Golub error = get_proc_vector(td, p, &auxv, &vsize, PROC_AUX); 18885ea21e69SMikolaj Golub if (error == 0) { 18895ea21e69SMikolaj Golub #ifdef COMPAT_FREEBSD32 18905ea21e69SMikolaj Golub if (SV_PROC_FLAG(p, SV_ILP32) != 0) 18915ea21e69SMikolaj Golub size = vsize * sizeof(Elf32_Auxinfo); 18925ea21e69SMikolaj Golub else 18935ea21e69SMikolaj Golub #endif 18945ea21e69SMikolaj Golub size = vsize * sizeof(Elf_Auxinfo); 189557c2505eSKonstantin Belousov if (sbuf_bcat(sb, auxv, size) != 0) 189657c2505eSKonstantin Belousov error = ENOMEM; 18975ea21e69SMikolaj Golub free(auxv, M_TEMP); 18985ea21e69SMikolaj Golub } 18995ea21e69SMikolaj Golub return (error); 19005ea21e69SMikolaj Golub } 19015ea21e69SMikolaj Golub 1902b9df5231SPoul-Henning Kamp /* 1903b9df5231SPoul-Henning Kamp * This sysctl allows a process to retrieve the argument list or process 1904b9df5231SPoul-Henning Kamp * title for another process without groping around in the address space 1905b9df5231SPoul-Henning Kamp * of the other process. It also allow a process to set its own "process 1906b9df5231SPoul-Henning Kamp * title to a string of its own choice. 1907b9df5231SPoul-Henning Kamp */ 1908b9df5231SPoul-Henning Kamp static int 190982d9ae4eSPoul-Henning Kamp sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS) 1910b9df5231SPoul-Henning Kamp { 1911b9df5231SPoul-Henning Kamp int *name = (int *)arg1; 1912b9df5231SPoul-Henning Kamp u_int namelen = arg2; 19138510f2a8SJohn Baldwin struct pargs *newpa, *pa; 1914b9df5231SPoul-Henning Kamp struct proc *p; 1915c5cfcb1cSMikolaj Golub struct sbuf sb; 1916fa3935bcSMikolaj Golub int flags, error = 0, error2; 1917baaa6ec7SMateusz Guzik pid_t pid; 1918b9df5231SPoul-Henning Kamp 1919b9df5231SPoul-Henning Kamp if (namelen != 1) 1920b9df5231SPoul-Henning Kamp return (EINVAL); 1921b9df5231SPoul-Henning Kamp 1922baaa6ec7SMateusz Guzik pid = (pid_t)name[0]; 1923baaa6ec7SMateusz Guzik /* 1924baaa6ec7SMateusz Guzik * If the query is for this process and it is single-threaded, there 1925baaa6ec7SMateusz Guzik * is nobody to modify pargs, thus we can just read. 1926baaa6ec7SMateusz Guzik */ 1927baaa6ec7SMateusz Guzik p = curproc; 19281b25176cSAntoine Brodin if (pid == p->p_pid && p->p_numthreads == 1 && req->newptr == NULL && 19291b25176cSAntoine Brodin (pa = p->p_args) != NULL) 19301b25176cSAntoine Brodin return (SYSCTL_OUT(req, pa->ar_args, pa->ar_length)); 1931baaa6ec7SMateusz Guzik 1932fa3935bcSMikolaj Golub flags = PGET_CANSEE; 1933fa3935bcSMikolaj Golub if (req->newptr != NULL) 1934fa3935bcSMikolaj Golub flags |= PGET_ISCURRENT; 1935baaa6ec7SMateusz Guzik error = pget(pid, flags, &p); 1936fa3935bcSMikolaj Golub if (error) 1937e76bad96SRobert Drehmel return (error); 1938b9df5231SPoul-Henning Kamp 19397b11fea6SAlfred Perlstein pa = p->p_args; 1940c5cfcb1cSMikolaj Golub if (pa != NULL) { 19417b11fea6SAlfred Perlstein pargs_hold(pa); 19427b11fea6SAlfred Perlstein PROC_UNLOCK(p); 19437b11fea6SAlfred Perlstein error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length); 19447b11fea6SAlfred Perlstein pargs_drop(pa); 1945c5cfcb1cSMikolaj Golub } else if ((p->p_flag & (P_WEXIT | P_SYSTEM)) == 0) { 1946c5cfcb1cSMikolaj Golub _PHOLD(p); 1947c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1948c5cfcb1cSMikolaj Golub sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req); 1949296f235dSIan Lepore sbuf_clear_flags(&sb, SBUF_INCLUDENUL); 1950fe7f89b7SMikolaj Golub error = proc_getargv(curthread, p, &sb); 1951c5cfcb1cSMikolaj Golub error2 = sbuf_finish(&sb); 1952c5cfcb1cSMikolaj Golub PRELE(p); 1953c5cfcb1cSMikolaj Golub sbuf_delete(&sb); 1954c5cfcb1cSMikolaj Golub if (error == 0 && error2 != 0) 1955c5cfcb1cSMikolaj Golub error = error2; 1956c5cfcb1cSMikolaj Golub } else { 1957c5cfcb1cSMikolaj Golub PROC_UNLOCK(p); 1958c5cfcb1cSMikolaj Golub } 19598510f2a8SJohn Baldwin if (error != 0 || req->newptr == NULL) 1960b9df5231SPoul-Henning Kamp return (error); 1961b9df5231SPoul-Henning Kamp 1962712dda7fSXin LI if (req->newlen > ps_arg_cache_limit - sizeof(struct pargs)) 19638510f2a8SJohn Baldwin return (ENOMEM); 1964d6eff083SKonstantin Belousov 1965d6eff083SKonstantin Belousov if (req->newlen == 0) { 1966d6eff083SKonstantin Belousov /* 1967d6eff083SKonstantin Belousov * Clear the argument pointer, so that we'll fetch arguments 1968d6eff083SKonstantin Belousov * with proc_getargv() until further notice. 1969d6eff083SKonstantin Belousov */ 1970d6eff083SKonstantin Belousov newpa = NULL; 1971d6eff083SKonstantin Belousov } else { 19724bc6471bSJohn Baldwin newpa = pargs_alloc(req->newlen); 19734bc6471bSJohn Baldwin error = SYSCTL_IN(req, newpa->ar_args, req->newlen); 19748510f2a8SJohn Baldwin if (error != 0) { 19754bc6471bSJohn Baldwin pargs_free(newpa); 1976b9df5231SPoul-Henning Kamp return (error); 1977b9df5231SPoul-Henning Kamp } 1978d6eff083SKonstantin Belousov } 19794bc6471bSJohn Baldwin PROC_LOCK(p); 19804bc6471bSJohn Baldwin pa = p->p_args; 19814bc6471bSJohn Baldwin p->p_args = newpa; 19824bc6471bSJohn Baldwin PROC_UNLOCK(p); 19834bc6471bSJohn Baldwin pargs_drop(pa); 19844bc6471bSJohn Baldwin return (0); 19854bc6471bSJohn Baldwin } 19864bc6471bSJohn Baldwin 1987fe769cddSDavid Schultz /* 1988c5cfcb1cSMikolaj Golub * This sysctl allows a process to retrieve environment of another process. 1989c5cfcb1cSMikolaj Golub */ 1990c5cfcb1cSMikolaj Golub static int 1991c5cfcb1cSMikolaj Golub sysctl_kern_proc_env(SYSCTL_HANDLER_ARGS) 1992c5cfcb1cSMikolaj Golub { 1993c5cfcb1cSMikolaj Golub int *name = (int *)arg1; 1994c5cfcb1cSMikolaj Golub u_int namelen = arg2; 1995c5cfcb1cSMikolaj Golub struct proc *p; 1996c5cfcb1cSMikolaj Golub struct sbuf sb; 1997c5cfcb1cSMikolaj Golub int error, error2; 1998c5cfcb1cSMikolaj Golub 1999c5cfcb1cSMikolaj Golub if (namelen != 1) 2000c5cfcb1cSMikolaj Golub return (EINVAL); 2001c5cfcb1cSMikolaj Golub 2002fa3935bcSMikolaj Golub error = pget((pid_t)name[0], PGET_WANTREAD, &p); 2003fa3935bcSMikolaj Golub if (error != 0) 2004c5cfcb1cSMikolaj Golub return (error); 2005c5cfcb1cSMikolaj Golub if ((p->p_flag & P_SYSTEM) != 0) { 2006fa3935bcSMikolaj Golub PRELE(p); 2007c5cfcb1cSMikolaj Golub return (0); 2008c5cfcb1cSMikolaj Golub } 2009fa3935bcSMikolaj Golub 2010c5cfcb1cSMikolaj Golub sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req); 2011296f235dSIan Lepore sbuf_clear_flags(&sb, SBUF_INCLUDENUL); 2012fe7f89b7SMikolaj Golub error = proc_getenvv(curthread, p, &sb); 2013c5cfcb1cSMikolaj Golub error2 = sbuf_finish(&sb); 2014c5cfcb1cSMikolaj Golub PRELE(p); 2015c5cfcb1cSMikolaj Golub sbuf_delete(&sb); 2016c5cfcb1cSMikolaj Golub return (error != 0 ? error : error2); 2017c5cfcb1cSMikolaj Golub } 2018c5cfcb1cSMikolaj Golub 2019c5cfcb1cSMikolaj Golub /* 2020c5cfcb1cSMikolaj Golub * This sysctl allows a process to retrieve ELF auxiliary vector of 2021c5cfcb1cSMikolaj Golub * another process. 2022c5cfcb1cSMikolaj Golub */ 2023c5cfcb1cSMikolaj Golub static int 2024c5cfcb1cSMikolaj Golub sysctl_kern_proc_auxv(SYSCTL_HANDLER_ARGS) 2025c5cfcb1cSMikolaj Golub { 2026c5cfcb1cSMikolaj Golub int *name = (int *)arg1; 2027c5cfcb1cSMikolaj Golub u_int namelen = arg2; 2028c5cfcb1cSMikolaj Golub struct proc *p; 20295ea21e69SMikolaj Golub struct sbuf sb; 20305ea21e69SMikolaj Golub int error, error2; 2031c5cfcb1cSMikolaj Golub 2032c5cfcb1cSMikolaj Golub if (namelen != 1) 2033c5cfcb1cSMikolaj Golub return (EINVAL); 2034c5cfcb1cSMikolaj Golub 2035fa3935bcSMikolaj Golub error = pget((pid_t)name[0], PGET_WANTREAD, &p); 2036fa3935bcSMikolaj Golub if (error != 0) 2037c5cfcb1cSMikolaj Golub return (error); 2038c5cfcb1cSMikolaj Golub if ((p->p_flag & P_SYSTEM) != 0) { 2039fa3935bcSMikolaj Golub PRELE(p); 2040c5cfcb1cSMikolaj Golub return (0); 2041c5cfcb1cSMikolaj Golub } 20425ea21e69SMikolaj Golub sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req); 20431eafc078SIan Lepore sbuf_clear_flags(&sb, SBUF_INCLUDENUL); 20445ea21e69SMikolaj Golub error = proc_getauxv(curthread, p, &sb); 20455ea21e69SMikolaj Golub error2 = sbuf_finish(&sb); 20464fd6053bSMikolaj Golub PRELE(p); 20475ea21e69SMikolaj Golub sbuf_delete(&sb); 20485ea21e69SMikolaj Golub return (error != 0 ? error : error2); 2049c5cfcb1cSMikolaj Golub } 2050c5cfcb1cSMikolaj Golub 2051c5cfcb1cSMikolaj Golub /* 2052fe769cddSDavid Schultz * This sysctl allows a process to retrieve the path of the executable for 2053fe769cddSDavid Schultz * itself or another process. 2054fe769cddSDavid Schultz */ 2055fe769cddSDavid Schultz static int 2056fe769cddSDavid Schultz sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS) 2057fe769cddSDavid Schultz { 2058fe769cddSDavid Schultz pid_t *pidp = (pid_t *)arg1; 2059fe769cddSDavid Schultz unsigned int arglen = arg2; 2060fe769cddSDavid Schultz struct proc *p; 2061fe769cddSDavid Schultz struct vnode *vp; 2062fe769cddSDavid Schultz char *retbuf, *freebuf; 20635050aa86SKonstantin Belousov int error; 2064fe769cddSDavid Schultz 2065fe769cddSDavid Schultz if (arglen != 1) 2066fe769cddSDavid Schultz return (EINVAL); 2067fe769cddSDavid Schultz if (*pidp == -1) { /* -1 means this process */ 2068fe769cddSDavid Schultz p = req->td->td_proc; 2069fe769cddSDavid Schultz } else { 2070fa3935bcSMikolaj Golub error = pget(*pidp, PGET_CANSEE, &p); 2071fa3935bcSMikolaj Golub if (error != 0) 2072fe769cddSDavid Schultz return (error); 2073fe769cddSDavid Schultz } 2074fe769cddSDavid Schultz 2075fe769cddSDavid Schultz vp = p->p_textvp; 2076965b55e2SRobert Watson if (vp == NULL) { 2077965b55e2SRobert Watson if (*pidp != -1) 2078965b55e2SRobert Watson PROC_UNLOCK(p); 2079965b55e2SRobert Watson return (0); 2080965b55e2SRobert Watson } 2081fe769cddSDavid Schultz vref(vp); 2082fe769cddSDavid Schultz if (*pidp != -1) 2083fe769cddSDavid Schultz PROC_UNLOCK(p); 2084fe769cddSDavid Schultz error = vn_fullpath(req->td, vp, &retbuf, &freebuf); 2085fe769cddSDavid Schultz vrele(vp); 2086fe769cddSDavid Schultz if (error) 2087fe769cddSDavid Schultz return (error); 2088fe769cddSDavid Schultz error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1); 2089fe769cddSDavid Schultz free(freebuf, M_TEMP); 2090fe769cddSDavid Schultz return (error); 2091fe769cddSDavid Schultz } 2092fe769cddSDavid Schultz 2093baf731e6SRobert Drehmel static int 2094baf731e6SRobert Drehmel sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS) 2095baf731e6SRobert Drehmel { 2096baf731e6SRobert Drehmel struct proc *p; 2097baf731e6SRobert Drehmel char *sv_name; 2098baf731e6SRobert Drehmel int *name; 2099baf731e6SRobert Drehmel int namelen; 2100e76bad96SRobert Drehmel int error; 2101baf731e6SRobert Drehmel 2102baf731e6SRobert Drehmel namelen = arg2; 2103baf731e6SRobert Drehmel if (namelen != 1) 2104baf731e6SRobert Drehmel return (EINVAL); 2105baf731e6SRobert Drehmel 2106baf731e6SRobert Drehmel name = (int *)arg1; 2107fa3935bcSMikolaj Golub error = pget((pid_t)name[0], PGET_CANSEE, &p); 2108fa3935bcSMikolaj Golub if (error != 0) 2109e76bad96SRobert Drehmel return (error); 2110baf731e6SRobert Drehmel sv_name = p->p_sysent->sv_name; 2111baf731e6SRobert Drehmel PROC_UNLOCK(p); 2112baf731e6SRobert Drehmel return (sysctl_handle_string(oidp, sv_name, 0, req)); 2113baf731e6SRobert Drehmel } 2114baf731e6SRobert Drehmel 211543151ee6SPeter Wemm #ifdef KINFO_OVMENTRY_SIZE 211643151ee6SPeter Wemm CTASSERT(sizeof(struct kinfo_ovmentry) == KINFO_OVMENTRY_SIZE); 211743151ee6SPeter Wemm #endif 211843151ee6SPeter Wemm 211943151ee6SPeter Wemm #ifdef COMPAT_FREEBSD7 2120cc43c38cSRobert Watson static int 212143151ee6SPeter Wemm sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_ARGS) 2122cc43c38cSRobert Watson { 2123cc43c38cSRobert Watson vm_map_entry_t entry, tmp_entry; 2124cc43c38cSRobert Watson unsigned int last_timestamp; 2125cc43c38cSRobert Watson char *fullpath, *freepath; 212643151ee6SPeter Wemm struct kinfo_ovmentry *kve; 21277a9c4d24SPeter Wemm struct vattr va; 21287a9c4d24SPeter Wemm struct ucred *cred; 2129cc43c38cSRobert Watson int error, *name; 2130cc43c38cSRobert Watson struct vnode *vp; 2131cc43c38cSRobert Watson struct proc *p; 2132cc43c38cSRobert Watson vm_map_t map; 2133c7462f43SKonstantin Belousov struct vmspace *vm; 2134baf731e6SRobert Drehmel 2135cc43c38cSRobert Watson name = (int *)arg1; 2136fa3935bcSMikolaj Golub error = pget((pid_t)name[0], PGET_WANTREAD, &p); 2137fa3935bcSMikolaj Golub if (error != 0) 2138cc43c38cSRobert Watson return (error); 2139c7462f43SKonstantin Belousov vm = vmspace_acquire_ref(p); 2140c7462f43SKonstantin Belousov if (vm == NULL) { 2141c7462f43SKonstantin Belousov PRELE(p); 2142c7462f43SKonstantin Belousov return (ESRCH); 2143c7462f43SKonstantin Belousov } 2144cc43c38cSRobert Watson kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK); 2145cc43c38cSRobert Watson 2146ca4aa8c3SSergey Kandaurov map = &vm->vm_map; 2147cc43c38cSRobert Watson vm_map_lock_read(map); 2148cc43c38cSRobert Watson for (entry = map->header.next; entry != &map->header; 2149cc43c38cSRobert Watson entry = entry->next) { 2150cc43c38cSRobert Watson vm_object_t obj, tobj, lobj; 2151cc43c38cSRobert Watson vm_offset_t addr; 2152cc43c38cSRobert Watson 2153cc43c38cSRobert Watson if (entry->eflags & MAP_ENTRY_IS_SUB_MAP) 2154cc43c38cSRobert Watson continue; 2155cc43c38cSRobert Watson 2156cc43c38cSRobert Watson bzero(kve, sizeof(*kve)); 2157cc43c38cSRobert Watson kve->kve_structsize = sizeof(*kve); 2158cc43c38cSRobert Watson 2159cc43c38cSRobert Watson kve->kve_private_resident = 0; 2160cc43c38cSRobert Watson obj = entry->object.vm_object; 2161cc43c38cSRobert Watson if (obj != NULL) { 2162bc403f03SAttilio Rao VM_OBJECT_RLOCK(obj); 2163cc43c38cSRobert Watson if (obj->shadow_count == 1) 2164cc43c38cSRobert Watson kve->kve_private_resident = 2165cc43c38cSRobert Watson obj->resident_page_count; 2166cc43c38cSRobert Watson } 2167cc43c38cSRobert Watson kve->kve_resident = 0; 2168cc43c38cSRobert Watson addr = entry->start; 2169cc43c38cSRobert Watson while (addr < entry->end) { 2170cc43c38cSRobert Watson if (pmap_extract(map->pmap, addr)) 2171cc43c38cSRobert Watson kve->kve_resident++; 2172cc43c38cSRobert Watson addr += PAGE_SIZE; 2173cc43c38cSRobert Watson } 2174cc43c38cSRobert Watson 2175cc43c38cSRobert Watson for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) { 217631608624SJohn Baldwin if (tobj != obj) { 2177bc403f03SAttilio Rao VM_OBJECT_RLOCK(tobj); 217831608624SJohn Baldwin kve->kve_offset += tobj->backing_object_offset; 217931608624SJohn Baldwin } 2180cc43c38cSRobert Watson if (lobj != obj) 2181bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(lobj); 2182cc43c38cSRobert Watson lobj = tobj; 2183cc43c38cSRobert Watson } 2184cc43c38cSRobert Watson 2185118d0afaSKonstantin Belousov kve->kve_start = (void*)entry->start; 2186118d0afaSKonstantin Belousov kve->kve_end = (void*)entry->end; 218731608624SJohn Baldwin kve->kve_offset += (off_t)entry->offset; 2188118d0afaSKonstantin Belousov 2189118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_READ) 2190118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_READ; 2191118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_WRITE) 2192118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_WRITE; 2193118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_EXECUTE) 2194118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_EXEC; 2195118d0afaSKonstantin Belousov 2196118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_COW) 2197118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_COW; 2198118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_NEEDS_COPY) 2199118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_NEEDS_COPY; 2200937912eaSAttilio Rao if (entry->eflags & MAP_ENTRY_NOCOREDUMP) 2201937912eaSAttilio Rao kve->kve_flags |= KVME_FLAG_NOCOREDUMP; 2202118d0afaSKonstantin Belousov 2203118d0afaSKonstantin Belousov last_timestamp = map->timestamp; 2204118d0afaSKonstantin Belousov vm_map_unlock_read(map); 2205118d0afaSKonstantin Belousov 22067a9c4d24SPeter Wemm kve->kve_fileid = 0; 22077a9c4d24SPeter Wemm kve->kve_fsid = 0; 2208cc43c38cSRobert Watson freepath = NULL; 2209cc43c38cSRobert Watson fullpath = ""; 2210cc43c38cSRobert Watson if (lobj) { 2211cc43c38cSRobert Watson vp = NULL; 2212cc43c38cSRobert Watson switch (lobj->type) { 2213cc43c38cSRobert Watson case OBJT_DEFAULT: 2214cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_DEFAULT; 2215cc43c38cSRobert Watson break; 2216cc43c38cSRobert Watson case OBJT_VNODE: 2217cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_VNODE; 2218cc43c38cSRobert Watson vp = lobj->handle; 2219cc43c38cSRobert Watson vref(vp); 2220cc43c38cSRobert Watson break; 2221cc43c38cSRobert Watson case OBJT_SWAP: 222263e4c6cdSEric van Gyzen if ((lobj->flags & OBJ_TMPFS_NODE) != 0) { 222363e4c6cdSEric van Gyzen kve->kve_type = KVME_TYPE_VNODE; 222463e4c6cdSEric van Gyzen if ((lobj->flags & OBJ_TMPFS) != 0) { 222563e4c6cdSEric van Gyzen vp = lobj->un_pager.swp.swp_tmpfs; 222663e4c6cdSEric van Gyzen vref(vp); 222763e4c6cdSEric van Gyzen } 222863e4c6cdSEric van Gyzen } else { 2229cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_SWAP; 223063e4c6cdSEric van Gyzen } 2231cc43c38cSRobert Watson break; 2232cc43c38cSRobert Watson case OBJT_DEVICE: 2233cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_DEVICE; 2234cc43c38cSRobert Watson break; 2235cc43c38cSRobert Watson case OBJT_PHYS: 2236cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_PHYS; 2237cc43c38cSRobert Watson break; 2238cc43c38cSRobert Watson case OBJT_DEAD: 2239cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_DEAD; 2240cc43c38cSRobert Watson break; 224101381811SJohn Baldwin case OBJT_SG: 224201381811SJohn Baldwin kve->kve_type = KVME_TYPE_SG; 224301381811SJohn Baldwin break; 2244cc43c38cSRobert Watson default: 2245cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_UNKNOWN; 2246cc43c38cSRobert Watson break; 2247cc43c38cSRobert Watson } 2248cc43c38cSRobert Watson if (lobj != obj) 2249bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(lobj); 2250cc43c38cSRobert Watson 2251cc43c38cSRobert Watson kve->kve_ref_count = obj->ref_count; 2252cc43c38cSRobert Watson kve->kve_shadow_count = obj->shadow_count; 2253bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(obj); 2254cc43c38cSRobert Watson if (vp != NULL) { 2255cc43c38cSRobert Watson vn_fullpath(curthread, vp, &fullpath, 2256cc43c38cSRobert Watson &freepath); 22577a9c4d24SPeter Wemm cred = curthread->td_ucred; 22582ff47c5fSJohn Baldwin vn_lock(vp, LK_SHARED | LK_RETRY); 22597a9c4d24SPeter Wemm if (VOP_GETATTR(vp, &va, cred) == 0) { 22607a9c4d24SPeter Wemm kve->kve_fileid = va.va_fileid; 226169921123SKonstantin Belousov /* truncate */ 22627a9c4d24SPeter Wemm kve->kve_fsid = va.va_fsid; 22637a9c4d24SPeter Wemm } 2264cc43c38cSRobert Watson vput(vp); 2265cc43c38cSRobert Watson } 2266cc43c38cSRobert Watson } else { 2267cc43c38cSRobert Watson kve->kve_type = KVME_TYPE_NONE; 2268cc43c38cSRobert Watson kve->kve_ref_count = 0; 2269cc43c38cSRobert Watson kve->kve_shadow_count = 0; 2270cc43c38cSRobert Watson } 2271cc43c38cSRobert Watson 2272cc43c38cSRobert Watson strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path)); 2273cc43c38cSRobert Watson if (freepath != NULL) 2274cc43c38cSRobert Watson free(freepath, M_TEMP); 2275cc43c38cSRobert Watson 2276cc43c38cSRobert Watson error = SYSCTL_OUT(req, kve, sizeof(*kve)); 2277cc43c38cSRobert Watson vm_map_lock_read(map); 2278cc43c38cSRobert Watson if (error) 2279cc43c38cSRobert Watson break; 228022a448c4SKonstantin Belousov if (last_timestamp != map->timestamp) { 2281cc43c38cSRobert Watson vm_map_lookup_entry(map, addr - 1, &tmp_entry); 2282cc43c38cSRobert Watson entry = tmp_entry; 2283cc43c38cSRobert Watson } 2284cc43c38cSRobert Watson } 2285cc43c38cSRobert Watson vm_map_unlock_read(map); 2286c7462f43SKonstantin Belousov vmspace_free(vm); 2287cc43c38cSRobert Watson PRELE(p); 2288cc43c38cSRobert Watson free(kve, M_TEMP); 2289cc43c38cSRobert Watson return (error); 2290cc43c38cSRobert Watson } 229143151ee6SPeter Wemm #endif /* COMPAT_FREEBSD7 */ 229243151ee6SPeter Wemm 229343151ee6SPeter Wemm #ifdef KINFO_VMENTRY_SIZE 229443151ee6SPeter Wemm CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE); 229543151ee6SPeter Wemm #endif 229643151ee6SPeter Wemm 2297baaa7969SKonstantin Belousov void 2298a62eb139SKonstantin Belousov kern_proc_vmmap_resident(vm_map_t map, vm_map_entry_t entry, 2299baaa7969SKonstantin Belousov int *resident_count, bool *super) 2300a62eb139SKonstantin Belousov { 2301a62eb139SKonstantin Belousov vm_object_t obj, tobj; 2302a62eb139SKonstantin Belousov vm_page_t m, m_adv; 2303a62eb139SKonstantin Belousov vm_offset_t addr; 2304a62eb139SKonstantin Belousov vm_paddr_t locked_pa; 2305a62eb139SKonstantin Belousov vm_pindex_t pi, pi_adv, pindex; 2306a62eb139SKonstantin Belousov 2307baaa7969SKonstantin Belousov *super = false; 2308baaa7969SKonstantin Belousov *resident_count = 0; 2309baaa7969SKonstantin Belousov if (vmmap_skip_res_cnt) 2310baaa7969SKonstantin Belousov return; 2311baaa7969SKonstantin Belousov 2312a62eb139SKonstantin Belousov locked_pa = 0; 2313a62eb139SKonstantin Belousov obj = entry->object.vm_object; 2314a62eb139SKonstantin Belousov addr = entry->start; 2315a62eb139SKonstantin Belousov m_adv = NULL; 2316d3a3b8b0SKonstantin Belousov pi = OFF_TO_IDX(entry->offset); 2317a62eb139SKonstantin Belousov for (; addr < entry->end; addr += IDX_TO_OFF(pi_adv), pi += pi_adv) { 2318a62eb139SKonstantin Belousov if (m_adv != NULL) { 2319a62eb139SKonstantin Belousov m = m_adv; 2320a62eb139SKonstantin Belousov } else { 2321d1780e8dSKonstantin Belousov pi_adv = atop(entry->end - addr); 2322a62eb139SKonstantin Belousov pindex = pi; 2323a62eb139SKonstantin Belousov for (tobj = obj;; tobj = tobj->backing_object) { 2324a62eb139SKonstantin Belousov m = vm_page_find_least(tobj, pindex); 2325a62eb139SKonstantin Belousov if (m != NULL) { 2326a62eb139SKonstantin Belousov if (m->pindex == pindex) 2327a62eb139SKonstantin Belousov break; 2328a62eb139SKonstantin Belousov if (pi_adv > m->pindex - pindex) { 2329a62eb139SKonstantin Belousov pi_adv = m->pindex - pindex; 2330a62eb139SKonstantin Belousov m_adv = m; 2331a62eb139SKonstantin Belousov } 2332a62eb139SKonstantin Belousov } 2333a62eb139SKonstantin Belousov if (tobj->backing_object == NULL) 2334a62eb139SKonstantin Belousov goto next; 2335a62eb139SKonstantin Belousov pindex += OFF_TO_IDX(tobj-> 2336a62eb139SKonstantin Belousov backing_object_offset); 2337a62eb139SKonstantin Belousov } 2338a62eb139SKonstantin Belousov } 2339a62eb139SKonstantin Belousov m_adv = NULL; 2340a62eb139SKonstantin Belousov if (m->psind != 0 && addr + pagesizes[1] <= entry->end && 2341a62eb139SKonstantin Belousov (addr & (pagesizes[1] - 1)) == 0 && 2342a62eb139SKonstantin Belousov (pmap_mincore(map->pmap, addr, &locked_pa) & 2343a62eb139SKonstantin Belousov MINCORE_SUPER) != 0) { 2344baaa7969SKonstantin Belousov *super = true; 2345d1780e8dSKonstantin Belousov pi_adv = atop(pagesizes[1]); 2346a62eb139SKonstantin Belousov } else { 2347a62eb139SKonstantin Belousov /* 2348a62eb139SKonstantin Belousov * We do not test the found page on validity. 2349a62eb139SKonstantin Belousov * Either the page is busy and being paged in, 2350a62eb139SKonstantin Belousov * or it was invalidated. The first case 2351a62eb139SKonstantin Belousov * should be counted as resident, the second 2352a62eb139SKonstantin Belousov * is not so clear; we do account both. 2353a62eb139SKonstantin Belousov */ 2354a62eb139SKonstantin Belousov pi_adv = 1; 2355a62eb139SKonstantin Belousov } 2356baaa7969SKonstantin Belousov *resident_count += pi_adv; 2357a62eb139SKonstantin Belousov next:; 2358a62eb139SKonstantin Belousov } 2359a62eb139SKonstantin Belousov PA_UNLOCK_COND(locked_pa); 2360a62eb139SKonstantin Belousov } 2361a62eb139SKonstantin Belousov 2362fe52cf54SMikolaj Golub /* 2363fe52cf54SMikolaj Golub * Must be called with the process locked and will return unlocked. 2364fe52cf54SMikolaj Golub */ 2365fe52cf54SMikolaj Golub int 2366e6b95927SConrad Meyer kern_proc_vmmap_out(struct proc *p, struct sbuf *sb, ssize_t maxlen, int flags) 236743151ee6SPeter Wemm { 236843151ee6SPeter Wemm vm_map_entry_t entry, tmp_entry; 2369a91831a2SKonstantin Belousov struct vattr va; 2370a91831a2SKonstantin Belousov vm_map_t map; 2371a91831a2SKonstantin Belousov vm_object_t obj, tobj, lobj; 237243151ee6SPeter Wemm char *fullpath, *freepath; 237343151ee6SPeter Wemm struct kinfo_vmentry *kve; 237443151ee6SPeter Wemm struct ucred *cred; 237543151ee6SPeter Wemm struct vnode *vp; 2376c7462f43SKonstantin Belousov struct vmspace *vm; 2377a91831a2SKonstantin Belousov vm_offset_t addr; 2378a91831a2SKonstantin Belousov unsigned int last_timestamp; 2379a91831a2SKonstantin Belousov int error; 2380baaa7969SKonstantin Belousov bool super; 238143151ee6SPeter Wemm 2382fe52cf54SMikolaj Golub PROC_LOCK_ASSERT(p, MA_OWNED); 2383fe52cf54SMikolaj Golub 2384fe52cf54SMikolaj Golub _PHOLD(p); 2385fe52cf54SMikolaj Golub PROC_UNLOCK(p); 2386c7462f43SKonstantin Belousov vm = vmspace_acquire_ref(p); 2387c7462f43SKonstantin Belousov if (vm == NULL) { 2388c7462f43SKonstantin Belousov PRELE(p); 2389c7462f43SKonstantin Belousov return (ESRCH); 2390c7462f43SKonstantin Belousov } 2391e6b95927SConrad Meyer kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK | M_ZERO); 239243151ee6SPeter Wemm 2393fe52cf54SMikolaj Golub error = 0; 2394ca4aa8c3SSergey Kandaurov map = &vm->vm_map; 239543151ee6SPeter Wemm vm_map_lock_read(map); 239643151ee6SPeter Wemm for (entry = map->header.next; entry != &map->header; 239743151ee6SPeter Wemm entry = entry->next) { 239843151ee6SPeter Wemm if (entry->eflags & MAP_ENTRY_IS_SUB_MAP) 239943151ee6SPeter Wemm continue; 240043151ee6SPeter Wemm 2401479fcb4eSKonstantin Belousov addr = entry->end; 240243151ee6SPeter Wemm bzero(kve, sizeof(*kve)); 240343151ee6SPeter Wemm obj = entry->object.vm_object; 240443151ee6SPeter Wemm if (obj != NULL) { 2405a91831a2SKonstantin Belousov for (tobj = obj; tobj != NULL; 2406a91831a2SKonstantin Belousov tobj = tobj->backing_object) { 2407a91831a2SKonstantin Belousov VM_OBJECT_RLOCK(tobj); 240831608624SJohn Baldwin kve->kve_offset += tobj->backing_object_offset; 2409a91831a2SKonstantin Belousov lobj = tobj; 2410a91831a2SKonstantin Belousov } 24113760e341SKonstantin Belousov if (obj->backing_object == NULL) 241243151ee6SPeter Wemm kve->kve_private_resident = 241343151ee6SPeter Wemm obj->resident_page_count; 2414baaa7969SKonstantin Belousov kern_proc_vmmap_resident(map, entry, 2415baaa7969SKonstantin Belousov &kve->kve_resident, &super); 2416baaa7969SKonstantin Belousov if (super) 2417baaa7969SKonstantin Belousov kve->kve_flags |= KVME_FLAG_SUPER; 2418a91831a2SKonstantin Belousov for (tobj = obj; tobj != NULL; 2419a91831a2SKonstantin Belousov tobj = tobj->backing_object) { 2420a91831a2SKonstantin Belousov if (tobj != obj && tobj != lobj) 2421a91831a2SKonstantin Belousov VM_OBJECT_RUNLOCK(tobj); 2422a91831a2SKonstantin Belousov } 2423a91831a2SKonstantin Belousov } else { 2424a91831a2SKonstantin Belousov lobj = NULL; 242543151ee6SPeter Wemm } 242643151ee6SPeter Wemm 2427118d0afaSKonstantin Belousov kve->kve_start = entry->start; 2428118d0afaSKonstantin Belousov kve->kve_end = entry->end; 242931608624SJohn Baldwin kve->kve_offset += entry->offset; 2430118d0afaSKonstantin Belousov 2431118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_READ) 2432118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_READ; 2433118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_WRITE) 2434118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_WRITE; 2435118d0afaSKonstantin Belousov if (entry->protection & VM_PROT_EXECUTE) 2436118d0afaSKonstantin Belousov kve->kve_protection |= KVME_PROT_EXEC; 2437118d0afaSKonstantin Belousov 2438118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_COW) 2439118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_COW; 2440118d0afaSKonstantin Belousov if (entry->eflags & MAP_ENTRY_NEEDS_COPY) 2441118d0afaSKonstantin Belousov kve->kve_flags |= KVME_FLAG_NEEDS_COPY; 2442937912eaSAttilio Rao if (entry->eflags & MAP_ENTRY_NOCOREDUMP) 2443937912eaSAttilio Rao kve->kve_flags |= KVME_FLAG_NOCOREDUMP; 2444599fc82bSGabor Pali if (entry->eflags & MAP_ENTRY_GROWS_UP) 2445599fc82bSGabor Pali kve->kve_flags |= KVME_FLAG_GROWS_UP; 2446599fc82bSGabor Pali if (entry->eflags & MAP_ENTRY_GROWS_DOWN) 2447599fc82bSGabor Pali kve->kve_flags |= KVME_FLAG_GROWS_DOWN; 2448118d0afaSKonstantin Belousov 2449118d0afaSKonstantin Belousov last_timestamp = map->timestamp; 2450118d0afaSKonstantin Belousov vm_map_unlock_read(map); 2451118d0afaSKonstantin Belousov 245243151ee6SPeter Wemm freepath = NULL; 245343151ee6SPeter Wemm fullpath = ""; 2454a91831a2SKonstantin Belousov if (lobj != NULL) { 245543151ee6SPeter Wemm vp = NULL; 245643151ee6SPeter Wemm switch (lobj->type) { 245743151ee6SPeter Wemm case OBJT_DEFAULT: 245843151ee6SPeter Wemm kve->kve_type = KVME_TYPE_DEFAULT; 245943151ee6SPeter Wemm break; 246043151ee6SPeter Wemm case OBJT_VNODE: 246143151ee6SPeter Wemm kve->kve_type = KVME_TYPE_VNODE; 246243151ee6SPeter Wemm vp = lobj->handle; 246343151ee6SPeter Wemm vref(vp); 246443151ee6SPeter Wemm break; 246543151ee6SPeter Wemm case OBJT_SWAP: 246663e4c6cdSEric van Gyzen if ((lobj->flags & OBJ_TMPFS_NODE) != 0) { 246763e4c6cdSEric van Gyzen kve->kve_type = KVME_TYPE_VNODE; 246863e4c6cdSEric van Gyzen if ((lobj->flags & OBJ_TMPFS) != 0) { 246963e4c6cdSEric van Gyzen vp = lobj->un_pager.swp.swp_tmpfs; 247063e4c6cdSEric van Gyzen vref(vp); 247163e4c6cdSEric van Gyzen } 247263e4c6cdSEric van Gyzen } else { 247343151ee6SPeter Wemm kve->kve_type = KVME_TYPE_SWAP; 247463e4c6cdSEric van Gyzen } 247543151ee6SPeter Wemm break; 247643151ee6SPeter Wemm case OBJT_DEVICE: 247743151ee6SPeter Wemm kve->kve_type = KVME_TYPE_DEVICE; 247843151ee6SPeter Wemm break; 247943151ee6SPeter Wemm case OBJT_PHYS: 248043151ee6SPeter Wemm kve->kve_type = KVME_TYPE_PHYS; 248143151ee6SPeter Wemm break; 248243151ee6SPeter Wemm case OBJT_DEAD: 248343151ee6SPeter Wemm kve->kve_type = KVME_TYPE_DEAD; 248443151ee6SPeter Wemm break; 248501381811SJohn Baldwin case OBJT_SG: 248601381811SJohn Baldwin kve->kve_type = KVME_TYPE_SG; 248701381811SJohn Baldwin break; 24882db08c03SJohn Baldwin case OBJT_MGTDEVICE: 24892db08c03SJohn Baldwin kve->kve_type = KVME_TYPE_MGTDEVICE; 24902db08c03SJohn Baldwin break; 249143151ee6SPeter Wemm default: 249243151ee6SPeter Wemm kve->kve_type = KVME_TYPE_UNKNOWN; 249343151ee6SPeter Wemm break; 249443151ee6SPeter Wemm } 249543151ee6SPeter Wemm if (lobj != obj) 2496bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(lobj); 249743151ee6SPeter Wemm 249843151ee6SPeter Wemm kve->kve_ref_count = obj->ref_count; 249943151ee6SPeter Wemm kve->kve_shadow_count = obj->shadow_count; 2500bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(obj); 250143151ee6SPeter Wemm if (vp != NULL) { 250243151ee6SPeter Wemm vn_fullpath(curthread, vp, &fullpath, 250343151ee6SPeter Wemm &freepath); 25040daf62d9SStanislav Sedov kve->kve_vn_type = vntype_to_kinfo(vp->v_type); 250543151ee6SPeter Wemm cred = curthread->td_ucred; 250643151ee6SPeter Wemm vn_lock(vp, LK_SHARED | LK_RETRY); 250743151ee6SPeter Wemm if (VOP_GETATTR(vp, &va, cred) == 0) { 25080daf62d9SStanislav Sedov kve->kve_vn_fileid = va.va_fileid; 25090daf62d9SStanislav Sedov kve->kve_vn_fsid = va.va_fsid; 251069921123SKonstantin Belousov kve->kve_vn_fsid_freebsd11 = 251169921123SKonstantin Belousov kve->kve_vn_fsid; /* truncate */ 25120daf62d9SStanislav Sedov kve->kve_vn_mode = 25130daf62d9SStanislav Sedov MAKEIMODE(va.va_type, va.va_mode); 25140daf62d9SStanislav Sedov kve->kve_vn_size = va.va_size; 25150daf62d9SStanislav Sedov kve->kve_vn_rdev = va.va_rdev; 251669921123SKonstantin Belousov kve->kve_vn_rdev_freebsd11 = 251769921123SKonstantin Belousov kve->kve_vn_rdev; /* truncate */ 25180daf62d9SStanislav Sedov kve->kve_status = KF_ATTR_VALID; 251943151ee6SPeter Wemm } 252043151ee6SPeter Wemm vput(vp); 252143151ee6SPeter Wemm } 252243151ee6SPeter Wemm } else { 252343151ee6SPeter Wemm kve->kve_type = KVME_TYPE_NONE; 252443151ee6SPeter Wemm kve->kve_ref_count = 0; 252543151ee6SPeter Wemm kve->kve_shadow_count = 0; 252643151ee6SPeter Wemm } 252743151ee6SPeter Wemm 252843151ee6SPeter Wemm strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path)); 252943151ee6SPeter Wemm if (freepath != NULL) 253043151ee6SPeter Wemm free(freepath, M_TEMP); 253143151ee6SPeter Wemm 253243151ee6SPeter Wemm /* Pack record size down */ 2533e6b95927SConrad Meyer if ((flags & KERN_VMMAP_PACK_KINFO) != 0) 2534e6b95927SConrad Meyer kve->kve_structsize = 2535e6b95927SConrad Meyer offsetof(struct kinfo_vmentry, kve_path) + 253643151ee6SPeter Wemm strlen(kve->kve_path) + 1; 2537e6b95927SConrad Meyer else 2538e6b95927SConrad Meyer kve->kve_structsize = sizeof(*kve); 253943151ee6SPeter Wemm kve->kve_structsize = roundup(kve->kve_structsize, 254043151ee6SPeter Wemm sizeof(uint64_t)); 2541e6b95927SConrad Meyer 2542e6b95927SConrad Meyer /* Halt filling and truncate rather than exceeding maxlen */ 2543e6b95927SConrad Meyer if (maxlen != -1 && maxlen < kve->kve_structsize) { 2544e6b95927SConrad Meyer error = 0; 2545e6b95927SConrad Meyer vm_map_lock_read(map); 2546e6b95927SConrad Meyer break; 2547e6b95927SConrad Meyer } else if (maxlen != -1) 2548e6b95927SConrad Meyer maxlen -= kve->kve_structsize; 2549e6b95927SConrad Meyer 255057c2505eSKonstantin Belousov if (sbuf_bcat(sb, kve, kve->kve_structsize) != 0) 255157c2505eSKonstantin Belousov error = ENOMEM; 255243151ee6SPeter Wemm vm_map_lock_read(map); 255357c2505eSKonstantin Belousov if (error != 0) 255443151ee6SPeter Wemm break; 255522a448c4SKonstantin Belousov if (last_timestamp != map->timestamp) { 255643151ee6SPeter Wemm vm_map_lookup_entry(map, addr - 1, &tmp_entry); 255743151ee6SPeter Wemm entry = tmp_entry; 255843151ee6SPeter Wemm } 255943151ee6SPeter Wemm } 256043151ee6SPeter Wemm vm_map_unlock_read(map); 2561c7462f43SKonstantin Belousov vmspace_free(vm); 256243151ee6SPeter Wemm PRELE(p); 256343151ee6SPeter Wemm free(kve, M_TEMP); 256443151ee6SPeter Wemm return (error); 256543151ee6SPeter Wemm } 2566cc43c38cSRobert Watson 2567fe52cf54SMikolaj Golub static int 2568fe52cf54SMikolaj Golub sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS) 2569fe52cf54SMikolaj Golub { 2570fe52cf54SMikolaj Golub struct proc *p; 2571fe52cf54SMikolaj Golub struct sbuf sb; 2572fe52cf54SMikolaj Golub int error, error2, *name; 2573fe52cf54SMikolaj Golub 2574fe52cf54SMikolaj Golub name = (int *)arg1; 2575fe52cf54SMikolaj Golub sbuf_new_for_sysctl(&sb, NULL, sizeof(struct kinfo_vmentry), req); 25761eafc078SIan Lepore sbuf_clear_flags(&sb, SBUF_INCLUDENUL); 2577fe52cf54SMikolaj Golub error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p); 2578fe52cf54SMikolaj Golub if (error != 0) { 2579fe52cf54SMikolaj Golub sbuf_delete(&sb); 2580fe52cf54SMikolaj Golub return (error); 2581fe52cf54SMikolaj Golub } 2582e6b95927SConrad Meyer error = kern_proc_vmmap_out(p, &sb, -1, KERN_VMMAP_PACK_KINFO); 2583fe52cf54SMikolaj Golub error2 = sbuf_finish(&sb); 2584fe52cf54SMikolaj Golub sbuf_delete(&sb); 2585fe52cf54SMikolaj Golub return (error != 0 ? error : error2); 2586fe52cf54SMikolaj Golub } 2587fe52cf54SMikolaj Golub 25881cc8c45cSRobert Watson #if defined(STACK) || defined(DDB) 25891cc8c45cSRobert Watson static int 25901cc8c45cSRobert Watson sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS) 25911cc8c45cSRobert Watson { 25921cc8c45cSRobert Watson struct kinfo_kstack *kkstp; 25931cc8c45cSRobert Watson int error, i, *name, numthreads; 25941cc8c45cSRobert Watson lwpid_t *lwpidarray; 25951cc8c45cSRobert Watson struct thread *td; 25961cc8c45cSRobert Watson struct stack *st; 25971cc8c45cSRobert Watson struct sbuf sb; 25981cc8c45cSRobert Watson struct proc *p; 25991cc8c45cSRobert Watson 26001cc8c45cSRobert Watson name = (int *)arg1; 2601fa3935bcSMikolaj Golub error = pget((pid_t)name[0], PGET_NOTINEXEC | PGET_WANTREAD, &p); 2602fa3935bcSMikolaj Golub if (error != 0) 26031cc8c45cSRobert Watson return (error); 26041cc8c45cSRobert Watson 26051cc8c45cSRobert Watson kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK); 2606f38c0c46SMark Johnston st = stack_create(M_WAITOK); 26071cc8c45cSRobert Watson 26081cc8c45cSRobert Watson lwpidarray = NULL; 2609374ae2a3SJeff Roberson PROC_LOCK(p); 261011748daeSMark Johnston do { 26111cc8c45cSRobert Watson if (lwpidarray != NULL) { 26121cc8c45cSRobert Watson free(lwpidarray, M_TEMP); 26131cc8c45cSRobert Watson lwpidarray = NULL; 26141cc8c45cSRobert Watson } 26151cc8c45cSRobert Watson numthreads = p->p_numthreads; 2616374ae2a3SJeff Roberson PROC_UNLOCK(p); 26171cc8c45cSRobert Watson lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP, 26181cc8c45cSRobert Watson M_WAITOK | M_ZERO); 2619374ae2a3SJeff Roberson PROC_LOCK(p); 262011748daeSMark Johnston } while (numthreads < p->p_numthreads); 26211cc8c45cSRobert Watson 26221cc8c45cSRobert Watson /* 26231cc8c45cSRobert Watson * XXXRW: During the below loop, execve(2) and countless other sorts 26241cc8c45cSRobert Watson * of changes could have taken place. Should we check to see if the 26251cc8c45cSRobert Watson * vmspace has been replaced, or the like, in order to prevent 26261cc8c45cSRobert Watson * giving a snapshot that spans, say, execve(2), with some threads 26271cc8c45cSRobert Watson * before and some after? Among other things, the credentials could 26281cc8c45cSRobert Watson * have changed, in which case the right to extract debug info might 26291cc8c45cSRobert Watson * no longer be assured. 26301cc8c45cSRobert Watson */ 263111748daeSMark Johnston i = 0; 26321cc8c45cSRobert Watson FOREACH_THREAD_IN_PROC(p, td) { 26331cc8c45cSRobert Watson KASSERT(i < numthreads, 26341cc8c45cSRobert Watson ("sysctl_kern_proc_kstack: numthreads")); 26351cc8c45cSRobert Watson lwpidarray[i] = td->td_tid; 26361cc8c45cSRobert Watson i++; 26371cc8c45cSRobert Watson } 26381cc8c45cSRobert Watson numthreads = i; 26391cc8c45cSRobert Watson for (i = 0; i < numthreads; i++) { 26401cc8c45cSRobert Watson td = thread_find(p, lwpidarray[i]); 26411cc8c45cSRobert Watson if (td == NULL) { 26421cc8c45cSRobert Watson continue; 26431cc8c45cSRobert Watson } 26441cc8c45cSRobert Watson bzero(kkstp, sizeof(*kkstp)); 26451cc8c45cSRobert Watson (void)sbuf_new(&sb, kkstp->kkst_trace, 26461cc8c45cSRobert Watson sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN); 26471cc8c45cSRobert Watson thread_lock(td); 26481cc8c45cSRobert Watson kkstp->kkst_tid = td->td_tid; 2649610141ceSMark Johnston if (TD_IS_SWAPPED(td)) { 26501cc8c45cSRobert Watson kkstp->kkst_state = KKST_STATE_SWAPPED; 2651610141ceSMark Johnston } else if (TD_IS_RUNNING(td)) { 2652610141ceSMark Johnston if (stack_save_td_running(st, td) == 0) 2653610141ceSMark Johnston kkstp->kkst_state = KKST_STATE_STACKOK; 2654610141ceSMark Johnston else 26551cc8c45cSRobert Watson kkstp->kkst_state = KKST_STATE_RUNNING; 2656610141ceSMark Johnston } else { 26571cc8c45cSRobert Watson kkstp->kkst_state = KKST_STATE_STACKOK; 26581cc8c45cSRobert Watson stack_save_td(st, td); 26591cc8c45cSRobert Watson } 26601cc8c45cSRobert Watson thread_unlock(td); 26611cc8c45cSRobert Watson PROC_UNLOCK(p); 26621cc8c45cSRobert Watson stack_sbuf_print(&sb, st); 26631cc8c45cSRobert Watson sbuf_finish(&sb); 26641cc8c45cSRobert Watson sbuf_delete(&sb); 26651cc8c45cSRobert Watson error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp)); 26661cc8c45cSRobert Watson PROC_LOCK(p); 26671cc8c45cSRobert Watson if (error) 26681cc8c45cSRobert Watson break; 26691cc8c45cSRobert Watson } 26701cc8c45cSRobert Watson _PRELE(p); 26711cc8c45cSRobert Watson PROC_UNLOCK(p); 26721cc8c45cSRobert Watson if (lwpidarray != NULL) 26731cc8c45cSRobert Watson free(lwpidarray, M_TEMP); 26741cc8c45cSRobert Watson stack_destroy(st); 26751cc8c45cSRobert Watson free(kkstp, M_TEMP); 26761cc8c45cSRobert Watson return (error); 26771cc8c45cSRobert Watson } 26781cc8c45cSRobert Watson #endif 26791cc8c45cSRobert Watson 2680254d03c5SBrooks Davis /* 2681254d03c5SBrooks Davis * This sysctl allows a process to retrieve the full list of groups from 2682254d03c5SBrooks Davis * itself or another process. 2683254d03c5SBrooks Davis */ 2684254d03c5SBrooks Davis static int 2685254d03c5SBrooks Davis sysctl_kern_proc_groups(SYSCTL_HANDLER_ARGS) 2686254d03c5SBrooks Davis { 2687254d03c5SBrooks Davis pid_t *pidp = (pid_t *)arg1; 2688254d03c5SBrooks Davis unsigned int arglen = arg2; 2689254d03c5SBrooks Davis struct proc *p; 2690254d03c5SBrooks Davis struct ucred *cred; 2691254d03c5SBrooks Davis int error; 2692254d03c5SBrooks Davis 2693254d03c5SBrooks Davis if (arglen != 1) 2694254d03c5SBrooks Davis return (EINVAL); 2695254d03c5SBrooks Davis if (*pidp == -1) { /* -1 means this process */ 2696254d03c5SBrooks Davis p = req->td->td_proc; 26972570cdd6SMateusz Guzik PROC_LOCK(p); 2698254d03c5SBrooks Davis } else { 2699fa3935bcSMikolaj Golub error = pget(*pidp, PGET_CANSEE, &p); 2700fa3935bcSMikolaj Golub if (error != 0) 2701254d03c5SBrooks Davis return (error); 2702254d03c5SBrooks Davis } 2703254d03c5SBrooks Davis 2704254d03c5SBrooks Davis cred = crhold(p->p_ucred); 2705254d03c5SBrooks Davis PROC_UNLOCK(p); 2706254d03c5SBrooks Davis 2707254d03c5SBrooks Davis error = SYSCTL_OUT(req, cred->cr_groups, 2708254d03c5SBrooks Davis cred->cr_ngroups * sizeof(gid_t)); 2709254d03c5SBrooks Davis crfree(cred); 2710254d03c5SBrooks Davis return (error); 2711254d03c5SBrooks Davis } 2712254d03c5SBrooks Davis 27139e7d0583SMikolaj Golub /* 27148854fe39SMikolaj Golub * This sysctl allows a process to retrieve or/and set the resource limit for 27159e7d0583SMikolaj Golub * another process. 27169e7d0583SMikolaj Golub */ 27179e7d0583SMikolaj Golub static int 27189e7d0583SMikolaj Golub sysctl_kern_proc_rlimit(SYSCTL_HANDLER_ARGS) 27199e7d0583SMikolaj Golub { 27209e7d0583SMikolaj Golub int *name = (int *)arg1; 27219e7d0583SMikolaj Golub u_int namelen = arg2; 27228854fe39SMikolaj Golub struct rlimit rlim; 27239e7d0583SMikolaj Golub struct proc *p; 27248854fe39SMikolaj Golub u_int which; 27258854fe39SMikolaj Golub int flags, error; 27269e7d0583SMikolaj Golub 27278854fe39SMikolaj Golub if (namelen != 2) 27289e7d0583SMikolaj Golub return (EINVAL); 27299e7d0583SMikolaj Golub 27308854fe39SMikolaj Golub which = (u_int)name[1]; 27318854fe39SMikolaj Golub if (which >= RLIM_NLIMITS) 27328854fe39SMikolaj Golub return (EINVAL); 27338854fe39SMikolaj Golub 27348854fe39SMikolaj Golub if (req->newptr != NULL && req->newlen != sizeof(rlim)) 27358854fe39SMikolaj Golub return (EINVAL); 27368854fe39SMikolaj Golub 27378854fe39SMikolaj Golub flags = PGET_HOLD | PGET_NOTWEXIT; 27388854fe39SMikolaj Golub if (req->newptr != NULL) 27398854fe39SMikolaj Golub flags |= PGET_CANDEBUG; 27408854fe39SMikolaj Golub else 27418854fe39SMikolaj Golub flags |= PGET_CANSEE; 27428854fe39SMikolaj Golub error = pget((pid_t)name[0], flags, &p); 2743fa3935bcSMikolaj Golub if (error != 0) 27449e7d0583SMikolaj Golub return (error); 27458854fe39SMikolaj Golub 27469e7d0583SMikolaj Golub /* 27478854fe39SMikolaj Golub * Retrieve limit. 27489e7d0583SMikolaj Golub */ 27498854fe39SMikolaj Golub if (req->oldptr != NULL) { 27508854fe39SMikolaj Golub PROC_LOCK(p); 2751f6f6d240SMateusz Guzik lim_rlimit_proc(p, which, &rlim); 27529e7d0583SMikolaj Golub PROC_UNLOCK(p); 27538854fe39SMikolaj Golub } 27548854fe39SMikolaj Golub error = SYSCTL_OUT(req, &rlim, sizeof(rlim)); 27558854fe39SMikolaj Golub if (error != 0) 27568854fe39SMikolaj Golub goto errout; 27578854fe39SMikolaj Golub 27588854fe39SMikolaj Golub /* 27598854fe39SMikolaj Golub * Set limit. 27608854fe39SMikolaj Golub */ 27618854fe39SMikolaj Golub if (req->newptr != NULL) { 27628854fe39SMikolaj Golub error = SYSCTL_IN(req, &rlim, sizeof(rlim)); 27638854fe39SMikolaj Golub if (error == 0) 27648854fe39SMikolaj Golub error = kern_proc_setrlimit(curthread, p, which, &rlim); 27659e7d0583SMikolaj Golub } 27669e7d0583SMikolaj Golub 27678854fe39SMikolaj Golub errout: 27688854fe39SMikolaj Golub PRELE(p); 27699e7d0583SMikolaj Golub return (error); 27709e7d0583SMikolaj Golub } 27719e7d0583SMikolaj Golub 27729732458fSMikolaj Golub /* 27739732458fSMikolaj Golub * This sysctl allows a process to retrieve ps_strings structure location of 27749732458fSMikolaj Golub * another process. 27759732458fSMikolaj Golub */ 27769732458fSMikolaj Golub static int 27779732458fSMikolaj Golub sysctl_kern_proc_ps_strings(SYSCTL_HANDLER_ARGS) 27789732458fSMikolaj Golub { 27799732458fSMikolaj Golub int *name = (int *)arg1; 27809732458fSMikolaj Golub u_int namelen = arg2; 27819732458fSMikolaj Golub struct proc *p; 27829732458fSMikolaj Golub vm_offset_t ps_strings; 27839732458fSMikolaj Golub int error; 27849732458fSMikolaj Golub #ifdef COMPAT_FREEBSD32 27859732458fSMikolaj Golub uint32_t ps_strings32; 27869732458fSMikolaj Golub #endif 27879732458fSMikolaj Golub 27889732458fSMikolaj Golub if (namelen != 1) 27899732458fSMikolaj Golub return (EINVAL); 27909732458fSMikolaj Golub 2791fa3935bcSMikolaj Golub error = pget((pid_t)name[0], PGET_CANDEBUG, &p); 2792fa3935bcSMikolaj Golub if (error != 0) 27939732458fSMikolaj Golub return (error); 27949732458fSMikolaj Golub #ifdef COMPAT_FREEBSD32 27959732458fSMikolaj Golub if ((req->flags & SCTL_MASK32) != 0) { 27969732458fSMikolaj Golub /* 27979732458fSMikolaj Golub * We return 0 if the 32 bit emulation request is for a 64 bit 27989732458fSMikolaj Golub * process. 27999732458fSMikolaj Golub */ 28009732458fSMikolaj Golub ps_strings32 = SV_PROC_FLAG(p, SV_ILP32) != 0 ? 28019732458fSMikolaj Golub PTROUT(p->p_sysent->sv_psstrings) : 0; 28029732458fSMikolaj Golub PROC_UNLOCK(p); 28039732458fSMikolaj Golub error = SYSCTL_OUT(req, &ps_strings32, sizeof(ps_strings32)); 28049732458fSMikolaj Golub return (error); 28059732458fSMikolaj Golub } 28069732458fSMikolaj Golub #endif 28079732458fSMikolaj Golub ps_strings = p->p_sysent->sv_psstrings; 28089732458fSMikolaj Golub PROC_UNLOCK(p); 28099732458fSMikolaj Golub error = SYSCTL_OUT(req, &ps_strings, sizeof(ps_strings)); 28109732458fSMikolaj Golub return (error); 28119732458fSMikolaj Golub } 28129732458fSMikolaj Golub 28136ce13747SMikolaj Golub /* 2814e0fcf639SMikolaj Golub * This sysctl allows a process to retrieve umask of another process. 28156ce13747SMikolaj Golub */ 28166ce13747SMikolaj Golub static int 28176ce13747SMikolaj Golub sysctl_kern_proc_umask(SYSCTL_HANDLER_ARGS) 28186ce13747SMikolaj Golub { 28196ce13747SMikolaj Golub int *name = (int *)arg1; 28206ce13747SMikolaj Golub u_int namelen = arg2; 28216ce13747SMikolaj Golub struct proc *p; 28226ce13747SMikolaj Golub int error; 28236ce13747SMikolaj Golub u_short fd_cmask; 2824cee09850SBartek Rutkowski pid_t pid; 28256ce13747SMikolaj Golub 28266ce13747SMikolaj Golub if (namelen != 1) 28276ce13747SMikolaj Golub return (EINVAL); 28286ce13747SMikolaj Golub 2829cee09850SBartek Rutkowski pid = (pid_t)name[0]; 2830cee09850SBartek Rutkowski p = curproc; 2831cee09850SBartek Rutkowski if (pid == p->p_pid || pid == 0) { 2832cee09850SBartek Rutkowski fd_cmask = p->p_fd->fd_cmask; 2833cee09850SBartek Rutkowski goto out; 2834cee09850SBartek Rutkowski } 2835cee09850SBartek Rutkowski 2836cee09850SBartek Rutkowski error = pget(pid, PGET_WANTREAD, &p); 28376ce13747SMikolaj Golub if (error != 0) 28386ce13747SMikolaj Golub return (error); 28396ce13747SMikolaj Golub 28406ce13747SMikolaj Golub fd_cmask = p->p_fd->fd_cmask; 28416ce13747SMikolaj Golub PRELE(p); 2842cee09850SBartek Rutkowski out: 2843e0fcf639SMikolaj Golub error = SYSCTL_OUT(req, &fd_cmask, sizeof(fd_cmask)); 28446ce13747SMikolaj Golub return (error); 28456ce13747SMikolaj Golub } 28466ce13747SMikolaj Golub 2847903712c9SMikolaj Golub /* 2848903712c9SMikolaj Golub * This sysctl allows a process to set and retrieve binary osreldate of 2849903712c9SMikolaj Golub * another process. 2850903712c9SMikolaj Golub */ 2851903712c9SMikolaj Golub static int 2852903712c9SMikolaj Golub sysctl_kern_proc_osrel(SYSCTL_HANDLER_ARGS) 2853903712c9SMikolaj Golub { 2854903712c9SMikolaj Golub int *name = (int *)arg1; 2855903712c9SMikolaj Golub u_int namelen = arg2; 2856903712c9SMikolaj Golub struct proc *p; 2857903712c9SMikolaj Golub int flags, error, osrel; 2858903712c9SMikolaj Golub 2859903712c9SMikolaj Golub if (namelen != 1) 2860903712c9SMikolaj Golub return (EINVAL); 2861903712c9SMikolaj Golub 2862903712c9SMikolaj Golub if (req->newptr != NULL && req->newlen != sizeof(osrel)) 2863903712c9SMikolaj Golub return (EINVAL); 2864903712c9SMikolaj Golub 2865903712c9SMikolaj Golub flags = PGET_HOLD | PGET_NOTWEXIT; 2866903712c9SMikolaj Golub if (req->newptr != NULL) 2867903712c9SMikolaj Golub flags |= PGET_CANDEBUG; 2868903712c9SMikolaj Golub else 2869903712c9SMikolaj Golub flags |= PGET_CANSEE; 2870903712c9SMikolaj Golub error = pget((pid_t)name[0], flags, &p); 2871903712c9SMikolaj Golub if (error != 0) 2872903712c9SMikolaj Golub return (error); 2873903712c9SMikolaj Golub 2874903712c9SMikolaj Golub error = SYSCTL_OUT(req, &p->p_osrel, sizeof(p->p_osrel)); 2875903712c9SMikolaj Golub if (error != 0) 2876903712c9SMikolaj Golub goto errout; 2877903712c9SMikolaj Golub 2878903712c9SMikolaj Golub if (req->newptr != NULL) { 2879903712c9SMikolaj Golub error = SYSCTL_IN(req, &osrel, sizeof(osrel)); 2880903712c9SMikolaj Golub if (error != 0) 2881903712c9SMikolaj Golub goto errout; 2882903712c9SMikolaj Golub if (osrel < 0) { 2883903712c9SMikolaj Golub error = EINVAL; 2884903712c9SMikolaj Golub goto errout; 2885903712c9SMikolaj Golub } 2886903712c9SMikolaj Golub p->p_osrel = osrel; 2887903712c9SMikolaj Golub } 2888903712c9SMikolaj Golub errout: 2889903712c9SMikolaj Golub PRELE(p); 2890903712c9SMikolaj Golub return (error); 2891903712c9SMikolaj Golub } 2892903712c9SMikolaj Golub 289380c3af4eSKonstantin Belousov static int 289480c3af4eSKonstantin Belousov sysctl_kern_proc_sigtramp(SYSCTL_HANDLER_ARGS) 289580c3af4eSKonstantin Belousov { 289680c3af4eSKonstantin Belousov int *name = (int *)arg1; 289780c3af4eSKonstantin Belousov u_int namelen = arg2; 289880c3af4eSKonstantin Belousov struct proc *p; 289980c3af4eSKonstantin Belousov struct kinfo_sigtramp kst; 290080c3af4eSKonstantin Belousov const struct sysentvec *sv; 290180c3af4eSKonstantin Belousov int error; 290280c3af4eSKonstantin Belousov #ifdef COMPAT_FREEBSD32 290380c3af4eSKonstantin Belousov struct kinfo_sigtramp32 kst32; 290480c3af4eSKonstantin Belousov #endif 290580c3af4eSKonstantin Belousov 290680c3af4eSKonstantin Belousov if (namelen != 1) 290780c3af4eSKonstantin Belousov return (EINVAL); 290880c3af4eSKonstantin Belousov 290980c3af4eSKonstantin Belousov error = pget((pid_t)name[0], PGET_CANDEBUG, &p); 291080c3af4eSKonstantin Belousov if (error != 0) 291180c3af4eSKonstantin Belousov return (error); 291280c3af4eSKonstantin Belousov sv = p->p_sysent; 291380c3af4eSKonstantin Belousov #ifdef COMPAT_FREEBSD32 291480c3af4eSKonstantin Belousov if ((req->flags & SCTL_MASK32) != 0) { 291580c3af4eSKonstantin Belousov bzero(&kst32, sizeof(kst32)); 291680c3af4eSKonstantin Belousov if (SV_PROC_FLAG(p, SV_ILP32)) { 291780c3af4eSKonstantin Belousov if (sv->sv_sigcode_base != 0) { 291880c3af4eSKonstantin Belousov kst32.ksigtramp_start = sv->sv_sigcode_base; 291980c3af4eSKonstantin Belousov kst32.ksigtramp_end = sv->sv_sigcode_base + 292080c3af4eSKonstantin Belousov *sv->sv_szsigcode; 292180c3af4eSKonstantin Belousov } else { 292280c3af4eSKonstantin Belousov kst32.ksigtramp_start = sv->sv_psstrings - 292380c3af4eSKonstantin Belousov *sv->sv_szsigcode; 292480c3af4eSKonstantin Belousov kst32.ksigtramp_end = sv->sv_psstrings; 292580c3af4eSKonstantin Belousov } 292680c3af4eSKonstantin Belousov } 292780c3af4eSKonstantin Belousov PROC_UNLOCK(p); 292880c3af4eSKonstantin Belousov error = SYSCTL_OUT(req, &kst32, sizeof(kst32)); 292980c3af4eSKonstantin Belousov return (error); 293080c3af4eSKonstantin Belousov } 293180c3af4eSKonstantin Belousov #endif 293280c3af4eSKonstantin Belousov bzero(&kst, sizeof(kst)); 293380c3af4eSKonstantin Belousov if (sv->sv_sigcode_base != 0) { 293480c3af4eSKonstantin Belousov kst.ksigtramp_start = (char *)sv->sv_sigcode_base; 293580c3af4eSKonstantin Belousov kst.ksigtramp_end = (char *)sv->sv_sigcode_base + 293680c3af4eSKonstantin Belousov *sv->sv_szsigcode; 293780c3af4eSKonstantin Belousov } else { 293880c3af4eSKonstantin Belousov kst.ksigtramp_start = (char *)sv->sv_psstrings - 293980c3af4eSKonstantin Belousov *sv->sv_szsigcode; 294080c3af4eSKonstantin Belousov kst.ksigtramp_end = (char *)sv->sv_psstrings; 294180c3af4eSKonstantin Belousov } 294280c3af4eSKonstantin Belousov PROC_UNLOCK(p); 294380c3af4eSKonstantin Belousov error = SYSCTL_OUT(req, &kst, sizeof(kst)); 294480c3af4eSKonstantin Belousov return (error); 294580c3af4eSKonstantin Belousov } 294680c3af4eSKonstantin Belousov 2947cc43c38cSRobert Watson SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table"); 29483ce93e4eSPoul-Henning Kamp 294924f87fdbSJohn Baldwin SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT| 295024f87fdbSJohn Baldwin CTLFLAG_MPSAFE, 0, 0, sysctl_kern_proc, "S,proc", 295124f87fdbSJohn Baldwin "Return entire process table"); 29523ce93e4eSPoul-Henning Kamp 295324f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD | CTLFLAG_MPSAFE, 2954078842c5SGarance A Drosehn sysctl_kern_proc, "Process table"); 2955078842c5SGarance A Drosehn 295624f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD | CTLFLAG_MPSAFE, 29573ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 29583ce93e4eSPoul-Henning Kamp 295924f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD | CTLFLAG_MPSAFE, 2960b8fdc89dSGarance A Drosehn sysctl_kern_proc, "Process table"); 2961b8fdc89dSGarance A Drosehn 296224f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD | 296324f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 296424f87fdbSJohn Baldwin 296524f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD | CTLFLAG_MPSAFE, 2966b8fdc89dSGarance A Drosehn sysctl_kern_proc, "Process table"); 2967b8fdc89dSGarance A Drosehn 296824f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD | CTLFLAG_MPSAFE, 29693ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 29703ce93e4eSPoul-Henning Kamp 297124f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD | CTLFLAG_MPSAFE, 29723ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 29733ce93e4eSPoul-Henning Kamp 297424f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD | CTLFLAG_MPSAFE, 29753ce93e4eSPoul-Henning Kamp sysctl_kern_proc, "Process table"); 29763ce93e4eSPoul-Henning Kamp 297724f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD | CTLFLAG_MPSAFE, 297830c6f34eSScott Long sysctl_kern_proc, "Return process table, no threads"); 297930c6f34eSScott Long 29800c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args, 2981aa32b5e0SEdward Tomasz Napierala CTLFLAG_RW | CTLFLAG_CAPWR | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, 29829b6d9dbaSPoul-Henning Kamp sysctl_kern_proc_args, "Process argument list"); 2983baf731e6SRobert Drehmel 298445efc9b4SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_ENV, env, CTLFLAG_RD | CTLFLAG_MPSAFE, 2985c5cfcb1cSMikolaj Golub sysctl_kern_proc_env, "Process environment"); 2986c5cfcb1cSMikolaj Golub 298745efc9b4SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_AUXV, auxv, CTLFLAG_RD | 298845efc9b4SMikolaj Golub CTLFLAG_MPSAFE, sysctl_kern_proc_auxv, "Process ELF auxiliary vector"); 2989c5cfcb1cSMikolaj Golub 299024f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD | 299124f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_pathname, "Process executable path"); 2992fe769cddSDavid Schultz 299324f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD | 299424f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_sv_name, 299524f87fdbSJohn Baldwin "Process syscall vector name (ABI type)"); 29962648efa6SDaniel Eischen 29970c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td, 299824f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 2999078842c5SGarance A Drosehn 30000c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td, 300124f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 30022648efa6SDaniel Eischen 30030c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td, 300424f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 3005b8fdc89dSGarance A Drosehn 30060c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD), 300724f87fdbSJohn Baldwin sid_td, CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 30080c898376SPoul-Henning Kamp 30090c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td, 301024f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 3011b8fdc89dSGarance A Drosehn 30120c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td, 301324f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 30142648efa6SDaniel Eischen 30150c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td, 301624f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 30172648efa6SDaniel Eischen 30180c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td, 301924f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table"); 30202648efa6SDaniel Eischen 30210c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td, 302224f87fdbSJohn Baldwin CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, 302324f87fdbSJohn Baldwin "Return process table, no threads"); 3024cc43c38cSRobert Watson 302543151ee6SPeter Wemm #ifdef COMPAT_FREEBSD7 302624f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_OVMMAP, ovmmap, CTLFLAG_RD | 302724f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_ovmmap, "Old Process vm map entries"); 302843151ee6SPeter Wemm #endif 302943151ee6SPeter Wemm 303024f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_VMMAP, vmmap, CTLFLAG_RD | 303124f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_vmmap, "Process vm map entries"); 30321cc8c45cSRobert Watson 30331cc8c45cSRobert Watson #if defined(STACK) || defined(DDB) 303424f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_KSTACK, kstack, CTLFLAG_RD | 303524f87fdbSJohn Baldwin CTLFLAG_MPSAFE, sysctl_kern_proc_kstack, "Process kernel stacks"); 30361cc8c45cSRobert Watson #endif 3037254d03c5SBrooks Davis 3038254d03c5SBrooks Davis static SYSCTL_NODE(_kern_proc, KERN_PROC_GROUPS, groups, CTLFLAG_RD | 3039254d03c5SBrooks Davis CTLFLAG_MPSAFE, sysctl_kern_proc_groups, "Process groups"); 30409e7d0583SMikolaj Golub 30418854fe39SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_RLIMIT, rlimit, CTLFLAG_RW | 30428854fe39SMikolaj Golub CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_rlimit, 30438854fe39SMikolaj Golub "Process resource limits"); 30449732458fSMikolaj Golub 304545efc9b4SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_PS_STRINGS, ps_strings, CTLFLAG_RD | 304645efc9b4SMikolaj Golub CTLFLAG_MPSAFE, sysctl_kern_proc_ps_strings, 304745efc9b4SMikolaj Golub "Process ps_strings location"); 30486ce13747SMikolaj Golub 3049e0fcf639SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_UMASK, umask, CTLFLAG_RD | 3050e0fcf639SMikolaj Golub CTLFLAG_MPSAFE, sysctl_kern_proc_umask, "Process umask"); 3051903712c9SMikolaj Golub 3052903712c9SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_OSREL, osrel, CTLFLAG_RW | 3053903712c9SMikolaj Golub CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_osrel, 3054903712c9SMikolaj Golub "Process binary osreldate"); 305580c3af4eSKonstantin Belousov 305680c3af4eSKonstantin Belousov static SYSCTL_NODE(_kern_proc, KERN_PROC_SIGTRAMP, sigtramp, CTLFLAG_RD | 305780c3af4eSKonstantin Belousov CTLFLAG_MPSAFE, sysctl_kern_proc_sigtramp, 305880c3af4eSKonstantin Belousov "Process signal trampoline location"); 30596ddcc233SKonstantin Belousov 30606ddcc233SKonstantin Belousov int allproc_gen; 30616ddcc233SKonstantin Belousov 30622dab579bSKonstantin Belousov /* 30632dab579bSKonstantin Belousov * stop_all_proc() purpose is to stop all process which have usermode, 30642dab579bSKonstantin Belousov * except current process for obvious reasons. This makes it somewhat 30652dab579bSKonstantin Belousov * unreliable when invoked from multithreaded process. The service 30662dab579bSKonstantin Belousov * must not be user-callable anyway. 30672dab579bSKonstantin Belousov */ 30686ddcc233SKonstantin Belousov void 30696ddcc233SKonstantin Belousov stop_all_proc(void) 30706ddcc233SKonstantin Belousov { 30716ddcc233SKonstantin Belousov struct proc *cp, *p; 30726ddcc233SKonstantin Belousov int r, gen; 30736ddcc233SKonstantin Belousov bool restart, seen_stopped, seen_exiting, stopped_some; 30746ddcc233SKonstantin Belousov 30756ddcc233SKonstantin Belousov cp = curproc; 30766ddcc233SKonstantin Belousov allproc_loop: 30776ddcc233SKonstantin Belousov sx_xlock(&allproc_lock); 30786ddcc233SKonstantin Belousov gen = allproc_gen; 30796ddcc233SKonstantin Belousov seen_exiting = seen_stopped = stopped_some = restart = false; 30806ddcc233SKonstantin Belousov LIST_REMOVE(cp, p_list); 30816ddcc233SKonstantin Belousov LIST_INSERT_HEAD(&allproc, cp, p_list); 30826ddcc233SKonstantin Belousov for (;;) { 30836ddcc233SKonstantin Belousov p = LIST_NEXT(cp, p_list); 30846ddcc233SKonstantin Belousov if (p == NULL) 30856ddcc233SKonstantin Belousov break; 30866ddcc233SKonstantin Belousov LIST_REMOVE(cp, p_list); 30876ddcc233SKonstantin Belousov LIST_INSERT_AFTER(p, cp, p_list); 30886ddcc233SKonstantin Belousov PROC_LOCK(p); 3089db57c70aSKonstantin Belousov if ((p->p_flag & (P_KPROC | P_SYSTEM | P_TOTAL_STOP)) != 0) { 30906ddcc233SKonstantin Belousov PROC_UNLOCK(p); 30916ddcc233SKonstantin Belousov continue; 30926ddcc233SKonstantin Belousov } 30936ddcc233SKonstantin Belousov if ((p->p_flag & P_WEXIT) != 0) { 30946ddcc233SKonstantin Belousov seen_exiting = true; 30956ddcc233SKonstantin Belousov PROC_UNLOCK(p); 30966ddcc233SKonstantin Belousov continue; 30976ddcc233SKonstantin Belousov } 30986ddcc233SKonstantin Belousov if (P_SHOULDSTOP(p) == P_STOPPED_SINGLE) { 30996ddcc233SKonstantin Belousov /* 31006ddcc233SKonstantin Belousov * Stopped processes are tolerated when there 31016ddcc233SKonstantin Belousov * are no other processes which might continue 31026ddcc233SKonstantin Belousov * them. P_STOPPED_SINGLE but not 31036ddcc233SKonstantin Belousov * P_TOTAL_STOP process still has at least one 31046ddcc233SKonstantin Belousov * thread running. 31056ddcc233SKonstantin Belousov */ 31066ddcc233SKonstantin Belousov seen_stopped = true; 31076ddcc233SKonstantin Belousov PROC_UNLOCK(p); 31086ddcc233SKonstantin Belousov continue; 31096ddcc233SKonstantin Belousov } 31106ddcc233SKonstantin Belousov _PHOLD(p); 31116ddcc233SKonstantin Belousov sx_xunlock(&allproc_lock); 31126ddcc233SKonstantin Belousov r = thread_single(p, SINGLE_ALLPROC); 31136ddcc233SKonstantin Belousov if (r != 0) 31146ddcc233SKonstantin Belousov restart = true; 31156ddcc233SKonstantin Belousov else 31166ddcc233SKonstantin Belousov stopped_some = true; 31176ddcc233SKonstantin Belousov _PRELE(p); 31186ddcc233SKonstantin Belousov PROC_UNLOCK(p); 31196ddcc233SKonstantin Belousov sx_xlock(&allproc_lock); 31206ddcc233SKonstantin Belousov } 31216ddcc233SKonstantin Belousov /* Catch forked children we did not see in iteration. */ 31226ddcc233SKonstantin Belousov if (gen != allproc_gen) 31236ddcc233SKonstantin Belousov restart = true; 31246ddcc233SKonstantin Belousov sx_xunlock(&allproc_lock); 31256ddcc233SKonstantin Belousov if (restart || stopped_some || seen_exiting || seen_stopped) { 31266ddcc233SKonstantin Belousov kern_yield(PRI_USER); 31276ddcc233SKonstantin Belousov goto allproc_loop; 31286ddcc233SKonstantin Belousov } 31296ddcc233SKonstantin Belousov } 31306ddcc233SKonstantin Belousov 31316ddcc233SKonstantin Belousov void 31326ddcc233SKonstantin Belousov resume_all_proc(void) 31336ddcc233SKonstantin Belousov { 31346ddcc233SKonstantin Belousov struct proc *cp, *p; 31356ddcc233SKonstantin Belousov 31366ddcc233SKonstantin Belousov cp = curproc; 31376ddcc233SKonstantin Belousov sx_xlock(&allproc_lock); 3138baaa7969SKonstantin Belousov again: 31396ddcc233SKonstantin Belousov LIST_REMOVE(cp, p_list); 31406ddcc233SKonstantin Belousov LIST_INSERT_HEAD(&allproc, cp, p_list); 31416ddcc233SKonstantin Belousov for (;;) { 31426ddcc233SKonstantin Belousov p = LIST_NEXT(cp, p_list); 31436ddcc233SKonstantin Belousov if (p == NULL) 31446ddcc233SKonstantin Belousov break; 31456ddcc233SKonstantin Belousov LIST_REMOVE(cp, p_list); 31466ddcc233SKonstantin Belousov LIST_INSERT_AFTER(p, cp, p_list); 31476ddcc233SKonstantin Belousov PROC_LOCK(p); 31486ddcc233SKonstantin Belousov if ((p->p_flag & P_TOTAL_STOP) != 0) { 31496ddcc233SKonstantin Belousov sx_xunlock(&allproc_lock); 31506ddcc233SKonstantin Belousov _PHOLD(p); 31516ddcc233SKonstantin Belousov thread_single_end(p, SINGLE_ALLPROC); 31526ddcc233SKonstantin Belousov _PRELE(p); 31536ddcc233SKonstantin Belousov PROC_UNLOCK(p); 31546ddcc233SKonstantin Belousov sx_xlock(&allproc_lock); 31556ddcc233SKonstantin Belousov } else { 31566ddcc233SKonstantin Belousov PROC_UNLOCK(p); 31576ddcc233SKonstantin Belousov } 31586ddcc233SKonstantin Belousov } 3159baaa7969SKonstantin Belousov /* Did the loop above missed any stopped process ? */ 31607938a442SBjoern A. Zeeb FOREACH_PROC_IN_SYSTEM(p) { 3161baaa7969SKonstantin Belousov /* No need for proc lock. */ 3162baaa7969SKonstantin Belousov if ((p->p_flag & P_TOTAL_STOP) != 0) 3163baaa7969SKonstantin Belousov goto again; 3164baaa7969SKonstantin Belousov } 31656ddcc233SKonstantin Belousov sx_xunlock(&allproc_lock); 31666ddcc233SKonstantin Belousov } 31676ddcc233SKonstantin Belousov 31682dab579bSKonstantin Belousov /* #define TOTAL_STOP_DEBUG 1 */ 31696ddcc233SKonstantin Belousov #ifdef TOTAL_STOP_DEBUG 31706ddcc233SKonstantin Belousov volatile static int ap_resume; 31716ddcc233SKonstantin Belousov #include <sys/mount.h> 31726ddcc233SKonstantin Belousov 31736ddcc233SKonstantin Belousov static int 31746ddcc233SKonstantin Belousov sysctl_debug_stop_all_proc(SYSCTL_HANDLER_ARGS) 31756ddcc233SKonstantin Belousov { 31766ddcc233SKonstantin Belousov int error, val; 31776ddcc233SKonstantin Belousov 31786ddcc233SKonstantin Belousov val = 0; 31796ddcc233SKonstantin Belousov ap_resume = 0; 31806ddcc233SKonstantin Belousov error = sysctl_handle_int(oidp, &val, 0, req); 31816ddcc233SKonstantin Belousov if (error != 0 || req->newptr == NULL) 31826ddcc233SKonstantin Belousov return (error); 31836ddcc233SKonstantin Belousov if (val != 0) { 31846ddcc233SKonstantin Belousov stop_all_proc(); 31856ddcc233SKonstantin Belousov syncer_suspend(); 31866ddcc233SKonstantin Belousov while (ap_resume == 0) 31876ddcc233SKonstantin Belousov ; 31886ddcc233SKonstantin Belousov syncer_resume(); 31896ddcc233SKonstantin Belousov resume_all_proc(); 31906ddcc233SKonstantin Belousov } 31916ddcc233SKonstantin Belousov return (0); 31926ddcc233SKonstantin Belousov } 31936ddcc233SKonstantin Belousov 31946ddcc233SKonstantin Belousov SYSCTL_PROC(_debug, OID_AUTO, stop_all_proc, CTLTYPE_INT | CTLFLAG_RW | 319583d7eb54SKonstantin Belousov CTLFLAG_MPSAFE, __DEVOLATILE(int *, &ap_resume), 0, 319683d7eb54SKonstantin Belousov sysctl_debug_stop_all_proc, "I", 31976ddcc233SKonstantin Belousov ""); 31986ddcc233SKonstantin Belousov #endif 3199