xref: /freebsd/sys/kern/kern_proc.c (revision 2c054ce9242ce359b90ac244d87fa4bb71189161)
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