xref: /freebsd/sys/kern/kern_proc.c (revision 2570cdd60504003f1afee9ea127b28e1d08aac70)
19454b2d8SWarner Losh /*-
2df8bae1dSRodney W. Grimes  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3df8bae1dSRodney W. Grimes  *	The Regents of the University of California.  All rights reserved.
4df8bae1dSRodney W. Grimes  *
5df8bae1dSRodney W. Grimes  * Redistribution and use in source and binary forms, with or without
6df8bae1dSRodney W. Grimes  * modification, are permitted provided that the following conditions
7df8bae1dSRodney W. Grimes  * are met:
8df8bae1dSRodney W. Grimes  * 1. Redistributions of source code must retain the above copyright
9df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer.
10df8bae1dSRodney W. Grimes  * 2. Redistributions in binary form must reproduce the above copyright
11df8bae1dSRodney W. Grimes  *    notice, this list of conditions and the following disclaimer in the
12df8bae1dSRodney W. Grimes  *    documentation and/or other materials provided with the distribution.
13df8bae1dSRodney W. Grimes  * 4. Neither the name of the University nor the names of its contributors
14df8bae1dSRodney W. Grimes  *    may be used to endorse or promote products derived from this software
15df8bae1dSRodney W. Grimes  *    without specific prior written permission.
16df8bae1dSRodney W. Grimes  *
17df8bae1dSRodney W. Grimes  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18df8bae1dSRodney W. Grimes  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19df8bae1dSRodney W. Grimes  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20df8bae1dSRodney W. Grimes  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21df8bae1dSRodney W. Grimes  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22df8bae1dSRodney W. Grimes  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23df8bae1dSRodney W. Grimes  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24df8bae1dSRodney W. Grimes  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25df8bae1dSRodney W. Grimes  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26df8bae1dSRodney W. Grimes  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27df8bae1dSRodney W. Grimes  * SUCH DAMAGE.
28df8bae1dSRodney W. Grimes  *
29b75356e1SJeffrey Hsu  *	@(#)kern_proc.c	8.7 (Berkeley) 2/14/95
30df8bae1dSRodney W. Grimes  */
31df8bae1dSRodney W. Grimes 
32677b542eSDavid E. O'Brien #include <sys/cdefs.h>
33677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
34677b542eSDavid E. O'Brien 
3543151ee6SPeter Wemm #include "opt_compat.h"
36cc43c38cSRobert Watson #include "opt_ddb.h"
376c84de02SJohn Baldwin #include "opt_ktrace.h"
38b9f009b0SPeter Wemm #include "opt_kstack_pages.h"
391cc8c45cSRobert Watson #include "opt_stack.h"
406c84de02SJohn Baldwin 
41df8bae1dSRodney W. Grimes #include <sys/param.h>
42df8bae1dSRodney W. Grimes #include <sys/systm.h>
43c5cfcb1cSMikolaj Golub #include <sys/elf.h>
44c5cfcb1cSMikolaj Golub #include <sys/exec.h>
45df8bae1dSRodney W. Grimes #include <sys/kernel.h>
4605e06d11SKonstantin Belousov #include <sys/limits.h>
47fb919e4dSMark Murray #include <sys/lock.h>
487123f4cdSEdward Tomasz Napierala #include <sys/loginclass.h>
49df8bae1dSRodney W. Grimes #include <sys/malloc.h>
505384d089SMikolaj Golub #include <sys/mman.h>
51cc43c38cSRobert Watson #include <sys/mount.h>
52fb919e4dSMark Murray #include <sys/mutex.h>
53b9df5231SPoul-Henning Kamp #include <sys/proc.h>
54c5cfcb1cSMikolaj Golub #include <sys/ptrace.h>
5555b4a5aeSJohn Baldwin #include <sys/refcount.h>
569e7d0583SMikolaj Golub #include <sys/resourcevar.h>
5789f6b863SAttilio Rao #include <sys/rwlock.h>
58cc43c38cSRobert Watson #include <sys/sbuf.h>
59baf731e6SRobert Drehmel #include <sys/sysent.h>
60de028f5aSJeff Roberson #include <sys/sched.h>
61165d2b99SJulian Elischer #include <sys/smp.h>
621cc8c45cSRobert Watson #include <sys/stack.h>
636ce13747SMikolaj Golub #include <sys/stat.h>
64fb919e4dSMark Murray #include <sys/sysctl.h>
6562d6ce3aSDon Lewis #include <sys/filedesc.h>
66df8bae1dSRodney W. Grimes #include <sys/tty.h>
67bb56ec4aSPoul-Henning Kamp #include <sys/signalvar.h>
685d217f17SJohn Birrell #include <sys/sdt.h>
691005a129SJohn Baldwin #include <sys/sx.h>
70fb919e4dSMark Murray #include <sys/user.h>
71fb919e4dSMark Murray #include <sys/jail.h>
72fe769cddSDavid Schultz #include <sys/vnode.h>
734a62a3e5SRandall Stewart #include <sys/eventhandler.h>
74fb919e4dSMark Murray 
75cc43c38cSRobert Watson #ifdef DDB
76cc43c38cSRobert Watson #include <ddb/ddb.h>
77cc43c38cSRobert Watson #endif
78cc43c38cSRobert Watson 
79efeaf95aSDavid Greenman #include <vm/vm.h>
801c771f92SKonstantin Belousov #include <vm/vm_param.h>
81a136efe9SPeter Wemm #include <vm/vm_extern.h>
82efeaf95aSDavid Greenman #include <vm/pmap.h>
83efeaf95aSDavid Greenman #include <vm/vm_map.h>
84cc43c38cSRobert Watson #include <vm/vm_object.h>
855384d089SMikolaj Golub #include <vm/vm_page.h>
86c897b813SJeff Roberson #include <vm/uma.h>
87df8bae1dSRodney W. Grimes 
8805e06d11SKonstantin Belousov #ifdef COMPAT_FREEBSD32
8905e06d11SKonstantin Belousov #include <compat/freebsd32/freebsd32.h>
9005e06d11SKonstantin Belousov #include <compat/freebsd32/freebsd32_util.h>
9105e06d11SKonstantin Belousov #endif
9205e06d11SKonstantin Belousov 
935d217f17SJohn Birrell SDT_PROVIDER_DEFINE(proc);
94d9fae5abSAndriy Gapon SDT_PROBE_DEFINE4(proc, kernel, ctor, entry, "struct proc *", "int",
957b77e1feSMark Johnston     "void *", "int");
96d9fae5abSAndriy Gapon SDT_PROBE_DEFINE4(proc, kernel, ctor, return, "struct proc *", "int",
977b77e1feSMark Johnston     "void *", "int");
98d9fae5abSAndriy Gapon SDT_PROBE_DEFINE4(proc, kernel, dtor, entry, "struct proc *", "int",
997b77e1feSMark Johnston     "void *", "struct thread *");
100d9fae5abSAndriy Gapon SDT_PROBE_DEFINE3(proc, kernel, dtor, return, "struct proc *", "int",
1017b77e1feSMark Johnston     "void *");
102d9fae5abSAndriy Gapon SDT_PROBE_DEFINE3(proc, kernel, init, entry, "struct proc *", "int",
1037b77e1feSMark Johnston     "int");
104d9fae5abSAndriy Gapon SDT_PROBE_DEFINE3(proc, kernel, init, return, "struct proc *", "int",
1057b77e1feSMark Johnston     "int");
1065d217f17SJohn Birrell 
107f591779bSSeigo Tanimura MALLOC_DEFINE(M_PGRP, "pgrp", "process group header");
108a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SESSION, "session", "session header");
109876a94eeSBruce Evans static MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
110a1c995b6SPoul-Henning Kamp MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
11155166637SPoul-Henning Kamp 
1124d77a549SAlfred Perlstein static void doenterpgrp(struct proc *, struct pgrp *);
1134d77a549SAlfred Perlstein static void orphanpg(struct pgrp *pg);
114f8d90480SAttilio Rao static void fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp);
1155032ff81SDon Lewis static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp);
116d92909c1SRobert Watson static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp,
117d92909c1SRobert Watson     int preferthread);
11802e878d9SJohn Baldwin static void pgadjustjobc(struct pgrp *pgrp, int entering);
11902e878d9SJohn Baldwin static void pgdelete(struct pgrp *);
120b23f72e9SBrian Feldman static int proc_ctor(void *mem, int size, void *arg, int flags);
121a136efe9SPeter Wemm static void proc_dtor(void *mem, int size, void *arg);
122b23f72e9SBrian Feldman static int proc_init(void *mem, int size, int flags);
123a136efe9SPeter Wemm static void proc_fini(void *mem, int size);
12458e8af1bSKonstantin Belousov static void pargs_free(struct pargs *pa);
125134eb42eSKonstantin Belousov static struct proc *zpfind_locked(pid_t pid);
126a136efe9SPeter Wemm 
127df8bae1dSRodney W. Grimes /*
128b75356e1SJeffrey Hsu  * Other process lists
129b75356e1SJeffrey Hsu  */
130b75356e1SJeffrey Hsu struct pidhashhead *pidhashtbl;
131b75356e1SJeffrey Hsu u_long pidhash;
132b75356e1SJeffrey Hsu struct pgrphashhead *pgrphashtbl;
133b75356e1SJeffrey Hsu u_long pgrphash;
134b75356e1SJeffrey Hsu struct proclist allproc;
135b75356e1SJeffrey Hsu struct proclist zombproc;
1361005a129SJohn Baldwin struct sx allproc_lock;
1371005a129SJohn Baldwin struct sx proctree_lock;
138c6544064SJohn Baldwin struct mtx ppeers_lock;
139c897b813SJeff Roberson uma_zone_t proc_zone;
140b75356e1SJeffrey Hsu 
141b9f009b0SPeter Wemm int kstack_pages = KSTACK_PAGES;
142b389be97SRebecca Cran SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0,
143b389be97SRebecca Cran     "Kernel stack size in pages");
144a91831a2SKonstantin Belousov static int vmmap_skip_res_cnt = 0;
145a91831a2SKonstantin Belousov SYSCTL_INT(_kern, OID_AUTO, proc_vmmap_skip_resident_count, CTLFLAG_RW,
146a91831a2SKonstantin Belousov     &vmmap_skip_res_cnt, 0,
147a91831a2SKonstantin Belousov     "Skip calculation of the pages resident count in kern.proc.vmmap");
148b9f009b0SPeter Wemm 
149a30d7c60SJake Burkholder CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
150ed780687SKonstantin Belousov #ifdef COMPAT_FREEBSD32
151ed780687SKonstantin Belousov CTASSERT(sizeof(struct kinfo_proc32) == KINFO_PROC32_SIZE);
152ed780687SKonstantin Belousov #endif
153a30d7c60SJake Burkholder 
154b75356e1SJeffrey Hsu /*
155b75356e1SJeffrey Hsu  * Initialize global process hashing structures.
156df8bae1dSRodney W. Grimes  */
15726f9a767SRodney W. Grimes void
158b75356e1SJeffrey Hsu procinit()
159df8bae1dSRodney W. Grimes {
160df8bae1dSRodney W. Grimes 
1611005a129SJohn Baldwin 	sx_init(&allproc_lock, "allproc");
1621005a129SJohn Baldwin 	sx_init(&proctree_lock, "proctree");
163c6544064SJohn Baldwin 	mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF);
164b75356e1SJeffrey Hsu 	LIST_INIT(&allproc);
165b75356e1SJeffrey Hsu 	LIST_INIT(&zombproc);
166b75356e1SJeffrey Hsu 	pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
167b75356e1SJeffrey Hsu 	pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
168de028f5aSJeff Roberson 	proc_zone = uma_zcreate("PROC", sched_sizeof_proc(),
169a136efe9SPeter Wemm 	    proc_ctor, proc_dtor, proc_init, proc_fini,
170a136efe9SPeter Wemm 	    UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
171f535380cSDon Lewis 	uihashinit();
172df8bae1dSRodney W. Grimes }
173df8bae1dSRodney W. Grimes 
174df8bae1dSRodney W. Grimes /*
175a136efe9SPeter Wemm  * Prepare a proc for use.
176a136efe9SPeter Wemm  */
177b23f72e9SBrian Feldman static int
178b23f72e9SBrian Feldman proc_ctor(void *mem, int size, void *arg, int flags)
179a136efe9SPeter Wemm {
180a136efe9SPeter Wemm 	struct proc *p;
181a136efe9SPeter Wemm 
182a136efe9SPeter Wemm 	p = (struct proc *)mem;
1835d217f17SJohn Birrell 	SDT_PROBE(proc, kernel, ctor , entry, p, size, arg, flags, 0);
1844a62a3e5SRandall Stewart 	EVENTHANDLER_INVOKE(process_ctor, p);
1855d217f17SJohn Birrell 	SDT_PROBE(proc, kernel, ctor , return, p, size, arg, flags, 0);
186b23f72e9SBrian Feldman 	return (0);
187a136efe9SPeter Wemm }
188a136efe9SPeter Wemm 
189a136efe9SPeter Wemm /*
190a136efe9SPeter Wemm  * Reclaim a proc after use.
191a136efe9SPeter Wemm  */
192a136efe9SPeter Wemm static void
193a136efe9SPeter Wemm proc_dtor(void *mem, int size, void *arg)
194a136efe9SPeter Wemm {
195a136efe9SPeter Wemm 	struct proc *p;
1961faf202eSJulian Elischer 	struct thread *td;
197a136efe9SPeter Wemm 
1981faf202eSJulian Elischer 	/* INVARIANTS checks go here */
199a136efe9SPeter Wemm 	p = (struct proc *)mem;
200ed062c8dSJulian Elischer 	td = FIRST_THREAD_IN_PROC(p);
2015d217f17SJohn Birrell 	SDT_PROBE(proc, kernel, dtor, entry, p, size, arg, td, 0);
20289b57fcfSKonstantin Belousov 	if (td != NULL) {
203ed062c8dSJulian Elischer #ifdef INVARIANTS
2041faf202eSJulian Elischer 		KASSERT((p->p_numthreads == 1),
2051faf202eSJulian Elischer 		    ("bad number of threads in exiting process"));
2062c255e9dSRobert Watson 		KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr"));
207ed062c8dSJulian Elischer #endif
2081ba4a712SPawel Jakub Dawidek 		/* Free all OSD associated to this thread. */
2091ba4a712SPawel Jakub Dawidek 		osd_thread_exit(td);
21089b57fcfSKonstantin Belousov 	}
2114a62a3e5SRandall Stewart 	EVENTHANDLER_INVOKE(process_dtor, p);
212ebceaf6dSDavid Xu 	if (p->p_ksi != NULL)
213ebceaf6dSDavid Xu 		KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue"));
2145d217f17SJohn Birrell 	SDT_PROBE(proc, kernel, dtor, return, p, size, arg, 0, 0);
215a136efe9SPeter Wemm }
216a136efe9SPeter Wemm 
217a136efe9SPeter Wemm /*
218a136efe9SPeter Wemm  * Initialize type-stable parts of a proc (when newly created).
219a136efe9SPeter Wemm  */
220b23f72e9SBrian Feldman static int
221b23f72e9SBrian Feldman proc_init(void *mem, int size, int flags)
222a136efe9SPeter Wemm {
223a136efe9SPeter Wemm 	struct proc *p;
224a136efe9SPeter Wemm 
225a136efe9SPeter Wemm 	p = (struct proc *)mem;
2265d217f17SJohn Birrell 	SDT_PROBE(proc, kernel, init, entry, p, size, flags, 0, 0);
227de028f5aSJeff Roberson 	p->p_sched = (struct p_sched *)&p[1];
2287d447c95SJohn Baldwin 	bzero(&p->p_mtx, sizeof(struct mtx));
2297d447c95SJohn Baldwin 	mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK);
230982d11f8SJeff Roberson 	mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE);
231aeb32571SKonstantin Belousov 	cv_init(&p->p_pwait, "ppwait");
2326fa39a73SKonstantin Belousov 	cv_init(&p->p_dbgwait, "dbgwait");
23389b57fcfSKonstantin Belousov 	TAILQ_INIT(&p->p_threads);	     /* all threads in proc */
2344a62a3e5SRandall Stewart 	EVENTHANDLER_INVOKE(process_init, p);
2358b059651SDavid Schultz 	p->p_stats = pstats_alloc();
2365d217f17SJohn Birrell 	SDT_PROBE(proc, kernel, init, return, p, size, flags, 0, 0);
237b23f72e9SBrian Feldman 	return (0);
238a136efe9SPeter Wemm }
239a136efe9SPeter Wemm 
240a136efe9SPeter Wemm /*
2418daa8c60SDavid Schultz  * UMA should ensure that this function is never called.
2428daa8c60SDavid Schultz  * Freeing a proc structure would violate type stability.
243a136efe9SPeter Wemm  */
244a136efe9SPeter Wemm static void
245a136efe9SPeter Wemm proc_fini(void *mem, int size)
246a136efe9SPeter Wemm {
247f55ab994SJohn Baldwin #ifdef notnow
248f55ab994SJohn Baldwin 	struct proc *p;
249a136efe9SPeter Wemm 
250f55ab994SJohn Baldwin 	p = (struct proc *)mem;
2514a62a3e5SRandall Stewart 	EVENTHANDLER_INVOKE(process_fini, p);
252f55ab994SJohn Baldwin 	pstats_free(p->p_stats);
253f55ab994SJohn Baldwin 	thread_free(FIRST_THREAD_IN_PROC(p));
254f55ab994SJohn Baldwin 	mtx_destroy(&p->p_mtx);
255ebceaf6dSDavid Xu 	if (p->p_ksi != NULL)
256ebceaf6dSDavid Xu 		ksiginfo_free(p->p_ksi);
257f55ab994SJohn Baldwin #else
2588daa8c60SDavid Schultz 	panic("proc reclaimed");
259f55ab994SJohn Baldwin #endif
260a136efe9SPeter Wemm }
261a136efe9SPeter Wemm 
262a136efe9SPeter Wemm /*
263df8bae1dSRodney W. Grimes  * Is p an inferior of the current process?
264df8bae1dSRodney W. Grimes  */
2651a432a2fSDima Ruban int
266d7359980SKonstantin Belousov inferior(struct proc *p)
267df8bae1dSRodney W. Grimes {
268df8bae1dSRodney W. Grimes 
2695b29d6e9SJohn Baldwin 	sx_assert(&proctree_lock, SX_LOCKED);
270d7359980SKonstantin Belousov 	PROC_LOCK_ASSERT(p, MA_OWNED);
271d7359980SKonstantin Belousov 	for (; p != curproc; p = proc_realparent(p)) {
27200f13cb3SJohn Baldwin 		if (p->p_pid == 0)
27300f13cb3SJohn Baldwin 			return (0);
274d7359980SKonstantin Belousov 	}
27500f13cb3SJohn Baldwin 	return (1);
276df8bae1dSRodney W. Grimes }
277df8bae1dSRodney W. Grimes 
278df8bae1dSRodney W. Grimes struct proc *
279134eb42eSKonstantin Belousov pfind_locked(pid_t pid)
280df8bae1dSRodney W. Grimes {
281134eb42eSKonstantin Belousov 	struct proc *p;
282df8bae1dSRodney W. Grimes 
283134eb42eSKonstantin Belousov 	sx_assert(&allproc_lock, SX_LOCKED);
284134eb42eSKonstantin Belousov 	LIST_FOREACH(p, PIDHASH(pid), p_hash) {
28533a9ed9dSJohn Baldwin 		if (p->p_pid == pid) {
28633a9ed9dSJohn Baldwin 			PROC_LOCK(p);
2878e6fa660SJohn Baldwin 			if (p->p_state == PRS_NEW) {
2888e6fa660SJohn Baldwin 				PROC_UNLOCK(p);
2898e6fa660SJohn Baldwin 				p = NULL;
2908e6fa660SJohn Baldwin 			}
291553629ebSJake Burkholder 			break;
29233a9ed9dSJohn Baldwin 		}
293134eb42eSKonstantin Belousov 	}
294134eb42eSKonstantin Belousov 	return (p);
295134eb42eSKonstantin Belousov }
296134eb42eSKonstantin Belousov 
297134eb42eSKonstantin Belousov /*
298134eb42eSKonstantin Belousov  * Locate a process by number; return only "live" processes -- i.e., neither
299134eb42eSKonstantin Belousov  * zombies nor newly born but incompletely initialized processes.  By not
300134eb42eSKonstantin Belousov  * returning processes in the PRS_NEW state, we allow callers to avoid
301134eb42eSKonstantin Belousov  * testing for that condition to avoid dereferencing p_ucred, et al.
302134eb42eSKonstantin Belousov  */
303134eb42eSKonstantin Belousov struct proc *
304134eb42eSKonstantin Belousov pfind(pid_t pid)
305134eb42eSKonstantin Belousov {
306134eb42eSKonstantin Belousov 	struct proc *p;
307134eb42eSKonstantin Belousov 
308134eb42eSKonstantin Belousov 	sx_slock(&allproc_lock);
309134eb42eSKonstantin Belousov 	p = pfind_locked(pid);
31098ab1489SJeffrey Hsu 	sx_sunlock(&allproc_lock);
311df8bae1dSRodney W. Grimes 	return (p);
312df8bae1dSRodney W. Grimes }
313df8bae1dSRodney W. Grimes 
314b3bfb267SKonstantin Belousov static struct proc *
315134eb42eSKonstantin Belousov pfind_tid_locked(pid_t tid)
316b3bfb267SKonstantin Belousov {
317b3bfb267SKonstantin Belousov 	struct proc *p;
318b3bfb267SKonstantin Belousov 	struct thread *td;
319b3bfb267SKonstantin Belousov 
320134eb42eSKonstantin Belousov 	sx_assert(&allproc_lock, SX_LOCKED);
321b3bfb267SKonstantin Belousov 	FOREACH_PROC_IN_SYSTEM(p) {
322b3bfb267SKonstantin Belousov 		PROC_LOCK(p);
323b3bfb267SKonstantin Belousov 		if (p->p_state == PRS_NEW) {
324b3bfb267SKonstantin Belousov 			PROC_UNLOCK(p);
325b3bfb267SKonstantin Belousov 			continue;
326b3bfb267SKonstantin Belousov 		}
327b3bfb267SKonstantin Belousov 		FOREACH_THREAD_IN_PROC(p, td) {
328b3bfb267SKonstantin Belousov 			if (td->td_tid == tid)
329b3bfb267SKonstantin Belousov 				goto found;
330b3bfb267SKonstantin Belousov 		}
331b3bfb267SKonstantin Belousov 		PROC_UNLOCK(p);
332b3bfb267SKonstantin Belousov 	}
333b3bfb267SKonstantin Belousov found:
334b3bfb267SKonstantin Belousov 	return (p);
335b3bfb267SKonstantin Belousov }
336b3bfb267SKonstantin Belousov 
337df8bae1dSRodney W. Grimes /*
338f591779bSSeigo Tanimura  * Locate a process group by number.
339f089b570SJohn Baldwin  * The caller must hold proctree_lock.
340df8bae1dSRodney W. Grimes  */
341df8bae1dSRodney W. Grimes struct pgrp *
342df8bae1dSRodney W. Grimes pgfind(pgid)
343df8bae1dSRodney W. Grimes 	register pid_t pgid;
344df8bae1dSRodney W. Grimes {
345df8bae1dSRodney W. Grimes 	register struct pgrp *pgrp;
346df8bae1dSRodney W. Grimes 
347f089b570SJohn Baldwin 	sx_assert(&proctree_lock, SX_LOCKED);
348f591779bSSeigo Tanimura 
349f591779bSSeigo Tanimura 	LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) {
350f591779bSSeigo Tanimura 		if (pgrp->pg_id == pgid) {
351f591779bSSeigo Tanimura 			PGRP_LOCK(pgrp);
352df8bae1dSRodney W. Grimes 			return (pgrp);
353f591779bSSeigo Tanimura 		}
354f591779bSSeigo Tanimura 	}
355df8bae1dSRodney W. Grimes 	return (NULL);
356df8bae1dSRodney W. Grimes }
357df8bae1dSRodney W. Grimes 
358df8bae1dSRodney W. Grimes /*
359fa3935bcSMikolaj Golub  * Locate process and do additional manipulations, depending on flags.
360fa3935bcSMikolaj Golub  */
361fa3935bcSMikolaj Golub int
362fa3935bcSMikolaj Golub pget(pid_t pid, int flags, struct proc **pp)
363fa3935bcSMikolaj Golub {
364fa3935bcSMikolaj Golub 	struct proc *p;
365fa3935bcSMikolaj Golub 	int error;
366fa3935bcSMikolaj Golub 
367134eb42eSKonstantin Belousov 	sx_slock(&allproc_lock);
3684f666417SPawel Jakub Dawidek 	if (pid <= PID_MAX) {
369134eb42eSKonstantin Belousov 		p = pfind_locked(pid);
370134eb42eSKonstantin Belousov 		if (p == NULL && (flags & PGET_NOTWEXIT) == 0)
371134eb42eSKonstantin Belousov 			p = zpfind_locked(pid);
3724f666417SPawel Jakub Dawidek 	} else if ((flags & PGET_NOTID) == 0) {
3734f666417SPawel Jakub Dawidek 		p = pfind_tid_locked(pid);
3744f666417SPawel Jakub Dawidek 	} else {
3754f666417SPawel Jakub Dawidek 		p = NULL;
3764f666417SPawel Jakub Dawidek 	}
377134eb42eSKonstantin Belousov 	sx_sunlock(&allproc_lock);
378fa3935bcSMikolaj Golub 	if (p == NULL)
379fa3935bcSMikolaj Golub 		return (ESRCH);
380fa3935bcSMikolaj Golub 	if ((flags & PGET_CANSEE) != 0) {
381fa3935bcSMikolaj Golub 		error = p_cansee(curthread, p);
382fa3935bcSMikolaj Golub 		if (error != 0)
383fa3935bcSMikolaj Golub 			goto errout;
384fa3935bcSMikolaj Golub 	}
385fa3935bcSMikolaj Golub 	if ((flags & PGET_CANDEBUG) != 0) {
386fa3935bcSMikolaj Golub 		error = p_candebug(curthread, p);
387fa3935bcSMikolaj Golub 		if (error != 0)
388fa3935bcSMikolaj Golub 			goto errout;
389fa3935bcSMikolaj Golub 	}
390fa3935bcSMikolaj Golub 	if ((flags & PGET_ISCURRENT) != 0 && curproc != p) {
391fa3935bcSMikolaj Golub 		error = EPERM;
392fa3935bcSMikolaj Golub 		goto errout;
393fa3935bcSMikolaj Golub 	}
394fa3935bcSMikolaj Golub 	if ((flags & PGET_NOTWEXIT) != 0 && (p->p_flag & P_WEXIT) != 0) {
395fa3935bcSMikolaj Golub 		error = ESRCH;
396fa3935bcSMikolaj Golub 		goto errout;
397fa3935bcSMikolaj Golub 	}
398fa3935bcSMikolaj Golub 	if ((flags & PGET_NOTINEXEC) != 0 && (p->p_flag & P_INEXEC) != 0) {
399fa3935bcSMikolaj Golub 		/*
400fa3935bcSMikolaj Golub 		 * XXXRW: Not clear ESRCH is the right error during proc
401fa3935bcSMikolaj Golub 		 * execve().
402fa3935bcSMikolaj Golub 		 */
403fa3935bcSMikolaj Golub 		error = ESRCH;
404fa3935bcSMikolaj Golub 		goto errout;
405fa3935bcSMikolaj Golub 	}
406fa3935bcSMikolaj Golub 	if ((flags & PGET_HOLD) != 0) {
407fa3935bcSMikolaj Golub 		_PHOLD(p);
408fa3935bcSMikolaj Golub 		PROC_UNLOCK(p);
409fa3935bcSMikolaj Golub 	}
410fa3935bcSMikolaj Golub 	*pp = p;
411fa3935bcSMikolaj Golub 	return (0);
412fa3935bcSMikolaj Golub errout:
413fa3935bcSMikolaj Golub 	PROC_UNLOCK(p);
414fa3935bcSMikolaj Golub 	return (error);
415fa3935bcSMikolaj Golub }
416fa3935bcSMikolaj Golub 
417fa3935bcSMikolaj Golub /*
418f591779bSSeigo Tanimura  * Create a new process group.
419f591779bSSeigo Tanimura  * pgid must be equal to the pid of p.
420f591779bSSeigo Tanimura  * Begin a new session if required.
421df8bae1dSRodney W. Grimes  */
42226f9a767SRodney W. Grimes int
423f591779bSSeigo Tanimura enterpgrp(p, pgid, pgrp, sess)
424df8bae1dSRodney W. Grimes 	register struct proc *p;
425df8bae1dSRodney W. Grimes 	pid_t pgid;
426f591779bSSeigo Tanimura 	struct pgrp *pgrp;
427f591779bSSeigo Tanimura 	struct session *sess;
428df8bae1dSRodney W. Grimes {
429df8bae1dSRodney W. Grimes 
430f089b570SJohn Baldwin 	sx_assert(&proctree_lock, SX_XLOCKED);
431f591779bSSeigo Tanimura 
432f591779bSSeigo Tanimura 	KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL"));
433f591779bSSeigo Tanimura 	KASSERT(p->p_pid == pgid,
434f591779bSSeigo Tanimura 	    ("enterpgrp: new pgrp and pid != pgid"));
4354419a8a8SMateusz Guzik 	KASSERT(pgfind(pgid) == NULL,
436f591779bSSeigo Tanimura 	    ("enterpgrp: pgrp with pgid exists"));
4375526d2d9SEivind Eklund 	KASSERT(!SESS_LEADER(p),
4385526d2d9SEivind Eklund 	    ("enterpgrp: session leader attempted setpgrp"));
439219cbf59SEivind Eklund 
4406008862bSJohn Baldwin 	mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
441df8bae1dSRodney W. Grimes 
442f591779bSSeigo Tanimura 	if (sess != NULL) {
443df8bae1dSRodney W. Grimes 		/*
444df8bae1dSRodney W. Grimes 		 * new session
445df8bae1dSRodney W. Grimes 		 */
4466008862bSJohn Baldwin 		mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF);
447f591779bSSeigo Tanimura 		PROC_LOCK(p);
448f591779bSSeigo Tanimura 		p->p_flag &= ~P_CONTROLT;
449f591779bSSeigo Tanimura 		PROC_UNLOCK(p);
450f591779bSSeigo Tanimura 		PGRP_LOCK(pgrp);
451df8bae1dSRodney W. Grimes 		sess->s_leader = p;
452643a8daaSDon Lewis 		sess->s_sid = p->p_pid;
453bc093719SEd Schouten 		refcount_init(&sess->s_count, 1);
454df8bae1dSRodney W. Grimes 		sess->s_ttyvp = NULL;
4558dc9b4cfSEd Schouten 		sess->s_ttydp = NULL;
456df8bae1dSRodney W. Grimes 		sess->s_ttyp = NULL;
457df8bae1dSRodney W. Grimes 		bcopy(p->p_session->s_login, sess->s_login,
458df8bae1dSRodney W. Grimes 			    sizeof(sess->s_login));
459df8bae1dSRodney W. Grimes 		pgrp->pg_session = sess;
4605526d2d9SEivind Eklund 		KASSERT(p == curproc,
4615526d2d9SEivind Eklund 		    ("enterpgrp: mksession and p != curproc"));
462df8bae1dSRodney W. Grimes 	} else {
463df8bae1dSRodney W. Grimes 		pgrp->pg_session = p->p_session;
464bc093719SEd Schouten 		sess_hold(pgrp->pg_session);
465f591779bSSeigo Tanimura 		PGRP_LOCK(pgrp);
466df8bae1dSRodney W. Grimes 	}
467df8bae1dSRodney W. Grimes 	pgrp->pg_id = pgid;
468b75356e1SJeffrey Hsu 	LIST_INIT(&pgrp->pg_members);
469f591779bSSeigo Tanimura 
470f591779bSSeigo Tanimura 	/*
471f089b570SJohn Baldwin 	 * As we have an exclusive lock of proctree_lock,
472f591779bSSeigo Tanimura 	 * this should not deadlock.
473f591779bSSeigo Tanimura 	 */
474b75356e1SJeffrey Hsu 	LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
475df8bae1dSRodney W. Grimes 	pgrp->pg_jobc = 0;
476831d27a9SDon Lewis 	SLIST_INIT(&pgrp->pg_sigiolst);
477f591779bSSeigo Tanimura 	PGRP_UNLOCK(pgrp);
478f591779bSSeigo Tanimura 
479f591779bSSeigo Tanimura 	doenterpgrp(p, pgrp);
480f591779bSSeigo Tanimura 
481df8bae1dSRodney W. Grimes 	return (0);
482f591779bSSeigo Tanimura }
483f591779bSSeigo Tanimura 
484f591779bSSeigo Tanimura /*
485f591779bSSeigo Tanimura  * Move p to an existing process group
486f591779bSSeigo Tanimura  */
487f591779bSSeigo Tanimura int
488f591779bSSeigo Tanimura enterthispgrp(p, pgrp)
489f591779bSSeigo Tanimura 	register struct proc *p;
490f591779bSSeigo Tanimura 	struct pgrp *pgrp;
491f591779bSSeigo Tanimura {
492f089b570SJohn Baldwin 
493f089b570SJohn Baldwin 	sx_assert(&proctree_lock, SX_XLOCKED);
494f591779bSSeigo Tanimura 	PROC_LOCK_ASSERT(p, MA_NOTOWNED);
495f591779bSSeigo Tanimura 	PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
496f591779bSSeigo Tanimura 	PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
497f591779bSSeigo Tanimura 	SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
498f591779bSSeigo Tanimura 	KASSERT(pgrp->pg_session == p->p_session,
499f591779bSSeigo Tanimura 		("%s: pgrp's session %p, p->p_session %p.\n",
500f591779bSSeigo Tanimura 		__func__,
501f591779bSSeigo Tanimura 		pgrp->pg_session,
502f591779bSSeigo Tanimura 		p->p_session));
503f591779bSSeigo Tanimura 	KASSERT(pgrp != p->p_pgrp,
504f591779bSSeigo Tanimura 		("%s: p belongs to pgrp.", __func__));
505f591779bSSeigo Tanimura 
506f591779bSSeigo Tanimura 	doenterpgrp(p, pgrp);
507f591779bSSeigo Tanimura 
508f591779bSSeigo Tanimura 	return (0);
509f591779bSSeigo Tanimura }
510f591779bSSeigo Tanimura 
511f591779bSSeigo Tanimura /*
512f591779bSSeigo Tanimura  * Move p to a process group
513f591779bSSeigo Tanimura  */
514f591779bSSeigo Tanimura static void
515f591779bSSeigo Tanimura doenterpgrp(p, pgrp)
516f591779bSSeigo Tanimura 	struct proc *p;
517f591779bSSeigo Tanimura 	struct pgrp *pgrp;
518f591779bSSeigo Tanimura {
519f591779bSSeigo Tanimura 	struct pgrp *savepgrp;
520f591779bSSeigo Tanimura 
521f089b570SJohn Baldwin 	sx_assert(&proctree_lock, SX_XLOCKED);
522f591779bSSeigo Tanimura 	PROC_LOCK_ASSERT(p, MA_NOTOWNED);
523f591779bSSeigo Tanimura 	PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
524f591779bSSeigo Tanimura 	PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
525f591779bSSeigo Tanimura 	SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
526f591779bSSeigo Tanimura 
527f591779bSSeigo Tanimura 	savepgrp = p->p_pgrp;
528df8bae1dSRodney W. Grimes 
529df8bae1dSRodney W. Grimes 	/*
530df8bae1dSRodney W. Grimes 	 * Adjust eligibility of affected pgrps to participate in job control.
531df8bae1dSRodney W. Grimes 	 * Increment eligibility counts before decrementing, otherwise we
532df8bae1dSRodney W. Grimes 	 * could reach 0 spuriously during the first call.
533df8bae1dSRodney W. Grimes 	 */
534df8bae1dSRodney W. Grimes 	fixjobc(p, pgrp, 1);
535df8bae1dSRodney W. Grimes 	fixjobc(p, p->p_pgrp, 0);
536df8bae1dSRodney W. Grimes 
537f591779bSSeigo Tanimura 	PGRP_LOCK(pgrp);
538f591779bSSeigo Tanimura 	PGRP_LOCK(savepgrp);
53915e9ec51SJohn Baldwin 	PROC_LOCK(p);
540b75356e1SJeffrey Hsu 	LIST_REMOVE(p, p_pglist);
541df8bae1dSRodney W. Grimes 	p->p_pgrp = pgrp;
54215e9ec51SJohn Baldwin 	PROC_UNLOCK(p);
543f591779bSSeigo Tanimura 	LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
544f591779bSSeigo Tanimura 	PGRP_UNLOCK(savepgrp);
545f591779bSSeigo Tanimura 	PGRP_UNLOCK(pgrp);
546f591779bSSeigo Tanimura 	if (LIST_EMPTY(&savepgrp->pg_members))
547f591779bSSeigo Tanimura 		pgdelete(savepgrp);
548df8bae1dSRodney W. Grimes }
549df8bae1dSRodney W. Grimes 
550df8bae1dSRodney W. Grimes /*
551df8bae1dSRodney W. Grimes  * remove process from process group
552df8bae1dSRodney W. Grimes  */
55326f9a767SRodney W. Grimes int
554df8bae1dSRodney W. Grimes leavepgrp(p)
555df8bae1dSRodney W. Grimes 	register struct proc *p;
556df8bae1dSRodney W. Grimes {
557f591779bSSeigo Tanimura 	struct pgrp *savepgrp;
558df8bae1dSRodney W. Grimes 
559f089b570SJohn Baldwin 	sx_assert(&proctree_lock, SX_XLOCKED);
560f591779bSSeigo Tanimura 	savepgrp = p->p_pgrp;
561f591779bSSeigo Tanimura 	PGRP_LOCK(savepgrp);
56215e9ec51SJohn Baldwin 	PROC_LOCK(p);
563b75356e1SJeffrey Hsu 	LIST_REMOVE(p, p_pglist);
56415e9ec51SJohn Baldwin 	p->p_pgrp = NULL;
56515e9ec51SJohn Baldwin 	PROC_UNLOCK(p);
566f591779bSSeigo Tanimura 	PGRP_UNLOCK(savepgrp);
567f591779bSSeigo Tanimura 	if (LIST_EMPTY(&savepgrp->pg_members))
568f591779bSSeigo Tanimura 		pgdelete(savepgrp);
569df8bae1dSRodney W. Grimes 	return (0);
570df8bae1dSRodney W. Grimes }
571df8bae1dSRodney W. Grimes 
572df8bae1dSRodney W. Grimes /*
573df8bae1dSRodney W. Grimes  * delete a process group
574df8bae1dSRodney W. Grimes  */
57587b6de2bSPoul-Henning Kamp static void
576df8bae1dSRodney W. Grimes pgdelete(pgrp)
577df8bae1dSRodney W. Grimes 	register struct pgrp *pgrp;
578df8bae1dSRodney W. Grimes {
579f591779bSSeigo Tanimura 	struct session *savesess;
580bc093719SEd Schouten 	struct tty *tp;
581f591779bSSeigo Tanimura 
582f089b570SJohn Baldwin 	sx_assert(&proctree_lock, SX_XLOCKED);
583f591779bSSeigo Tanimura 	PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
584f591779bSSeigo Tanimura 	SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
585f591779bSSeigo Tanimura 
586831d27a9SDon Lewis 	/*
587831d27a9SDon Lewis 	 * Reset any sigio structures pointing to us as a result of
588831d27a9SDon Lewis 	 * F_SETOWN with our pgid.
589831d27a9SDon Lewis 	 */
590831d27a9SDon Lewis 	funsetownlst(&pgrp->pg_sigiolst);
591831d27a9SDon Lewis 
592e649887bSAlfred Perlstein 	PGRP_LOCK(pgrp);
593bc093719SEd Schouten 	tp = pgrp->pg_session->s_ttyp;
594b75356e1SJeffrey Hsu 	LIST_REMOVE(pgrp, pg_hash);
595f591779bSSeigo Tanimura 	savesess = pgrp->pg_session;
596f591779bSSeigo Tanimura 	PGRP_UNLOCK(pgrp);
597bc093719SEd Schouten 
598bc093719SEd Schouten 	/* Remove the reference to the pgrp before deallocating it. */
599bc093719SEd Schouten 	if (tp != NULL) {
600bc093719SEd Schouten 		tty_lock(tp);
601bc093719SEd Schouten 		tty_rel_pgrp(tp, pgrp);
602bc093719SEd Schouten 	}
603bc093719SEd Schouten 
6046041fa0aSSeigo Tanimura 	mtx_destroy(&pgrp->pg_mtx);
6051ede983cSDag-Erling Smørgrav 	free(pgrp, M_PGRP);
606bc093719SEd Schouten 	sess_release(savesess);
607df8bae1dSRodney W. Grimes }
608df8bae1dSRodney W. Grimes 
60902e878d9SJohn Baldwin static void
61002e878d9SJohn Baldwin pgadjustjobc(pgrp, entering)
61102e878d9SJohn Baldwin 	struct pgrp *pgrp;
61202e878d9SJohn Baldwin 	int entering;
61302e878d9SJohn Baldwin {
61402e878d9SJohn Baldwin 
61502e878d9SJohn Baldwin 	PGRP_LOCK(pgrp);
61602e878d9SJohn Baldwin 	if (entering)
61702e878d9SJohn Baldwin 		pgrp->pg_jobc++;
61802e878d9SJohn Baldwin 	else {
61902e878d9SJohn Baldwin 		--pgrp->pg_jobc;
62002e878d9SJohn Baldwin 		if (pgrp->pg_jobc == 0)
62102e878d9SJohn Baldwin 			orphanpg(pgrp);
62202e878d9SJohn Baldwin 	}
62302e878d9SJohn Baldwin 	PGRP_UNLOCK(pgrp);
62402e878d9SJohn Baldwin }
62502e878d9SJohn Baldwin 
626df8bae1dSRodney W. Grimes /*
627df8bae1dSRodney W. Grimes  * Adjust pgrp jobc counters when specified process changes process group.
628df8bae1dSRodney W. Grimes  * We count the number of processes in each process group that "qualify"
629df8bae1dSRodney W. Grimes  * the group for terminal job control (those with a parent in a different
630df8bae1dSRodney W. Grimes  * process group of the same session).  If that count reaches zero, the
631df8bae1dSRodney W. Grimes  * process group becomes orphaned.  Check both the specified process'
632df8bae1dSRodney W. Grimes  * process group and that of its children.
633df8bae1dSRodney W. Grimes  * entering == 0 => p is leaving specified group.
634df8bae1dSRodney W. Grimes  * entering == 1 => p is entering specified group.
635df8bae1dSRodney W. Grimes  */
63626f9a767SRodney W. Grimes void
637df8bae1dSRodney W. Grimes fixjobc(p, pgrp, entering)
638df8bae1dSRodney W. Grimes 	register struct proc *p;
639df8bae1dSRodney W. Grimes 	register struct pgrp *pgrp;
640df8bae1dSRodney W. Grimes 	int entering;
641df8bae1dSRodney W. Grimes {
642df8bae1dSRodney W. Grimes 	register struct pgrp *hispgrp;
643f591779bSSeigo Tanimura 	register struct session *mysession;
644f591779bSSeigo Tanimura 
645f089b570SJohn Baldwin 	sx_assert(&proctree_lock, SX_LOCKED);
646f591779bSSeigo Tanimura 	PROC_LOCK_ASSERT(p, MA_NOTOWNED);
647f591779bSSeigo Tanimura 	PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
648f591779bSSeigo Tanimura 	SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
649df8bae1dSRodney W. Grimes 
650df8bae1dSRodney W. Grimes 	/*
651df8bae1dSRodney W. Grimes 	 * Check p's parent to see whether p qualifies its own process
652df8bae1dSRodney W. Grimes 	 * group; if so, adjust count for p's process group.
653df8bae1dSRodney W. Grimes 	 */
654f591779bSSeigo Tanimura 	mysession = pgrp->pg_session;
655df8bae1dSRodney W. Grimes 	if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
65602e878d9SJohn Baldwin 	    hispgrp->pg_session == mysession)
65702e878d9SJohn Baldwin 		pgadjustjobc(pgrp, entering);
658df8bae1dSRodney W. Grimes 
659df8bae1dSRodney W. Grimes 	/*
660df8bae1dSRodney W. Grimes 	 * Check this process' children to see whether they qualify
661df8bae1dSRodney W. Grimes 	 * their process groups; if so, adjust counts for children's
662df8bae1dSRodney W. Grimes 	 * process groups.
663df8bae1dSRodney W. Grimes 	 */
664f591779bSSeigo Tanimura 	LIST_FOREACH(p, &p->p_children, p_sibling) {
66502e878d9SJohn Baldwin 		hispgrp = p->p_pgrp;
66602e878d9SJohn Baldwin 		if (hispgrp == pgrp ||
66702e878d9SJohn Baldwin 		    hispgrp->pg_session != mysession)
66802e878d9SJohn Baldwin 			continue;
66902e878d9SJohn Baldwin 		PROC_LOCK(p);
67002e878d9SJohn Baldwin 		if (p->p_state == PRS_ZOMBIE) {
67102e878d9SJohn Baldwin 			PROC_UNLOCK(p);
67202e878d9SJohn Baldwin 			continue;
673df8bae1dSRodney W. Grimes 		}
67402e878d9SJohn Baldwin 		PROC_UNLOCK(p);
67502e878d9SJohn Baldwin 		pgadjustjobc(hispgrp, entering);
676f591779bSSeigo Tanimura 	}
677dfd5dee1SPeter Wemm }
678df8bae1dSRodney W. Grimes 
679df8bae1dSRodney W. Grimes /*
680df8bae1dSRodney W. Grimes  * A process group has become orphaned;
681df8bae1dSRodney W. Grimes  * if there are any stopped processes in the group,
682df8bae1dSRodney W. Grimes  * hang-up all process in that group.
683df8bae1dSRodney W. Grimes  */
684df8bae1dSRodney W. Grimes static void
685df8bae1dSRodney W. Grimes orphanpg(pg)
686df8bae1dSRodney W. Grimes 	struct pgrp *pg;
687df8bae1dSRodney W. Grimes {
688df8bae1dSRodney W. Grimes 	register struct proc *p;
689df8bae1dSRodney W. Grimes 
690f591779bSSeigo Tanimura 	PGRP_LOCK_ASSERT(pg, MA_OWNED);
691f591779bSSeigo Tanimura 
6921b727751SPoul-Henning Kamp 	LIST_FOREACH(p, &pg->pg_members, p_pglist) {
69302e878d9SJohn Baldwin 		PROC_LOCK(p);
694e602ba25SJulian Elischer 		if (P_SHOULDSTOP(p)) {
69502e878d9SJohn Baldwin 			PROC_UNLOCK(p);
6961b727751SPoul-Henning Kamp 			LIST_FOREACH(p, &pg->pg_members, p_pglist) {
69715e9ec51SJohn Baldwin 				PROC_LOCK(p);
6988451d0ddSKip Macy 				kern_psignal(p, SIGHUP);
6998451d0ddSKip Macy 				kern_psignal(p, SIGCONT);
70015e9ec51SJohn Baldwin 				PROC_UNLOCK(p);
701df8bae1dSRodney W. Grimes 			}
702df8bae1dSRodney W. Grimes 			return;
703df8bae1dSRodney W. Grimes 		}
70402e878d9SJohn Baldwin 		PROC_UNLOCK(p);
705df8bae1dSRodney W. Grimes 	}
706df8bae1dSRodney W. Grimes }
707df8bae1dSRodney W. Grimes 
708572b4402SPoul-Henning Kamp void
709bc093719SEd Schouten sess_hold(struct session *s)
710572b4402SPoul-Henning Kamp {
711572b4402SPoul-Henning Kamp 
712bc093719SEd Schouten 	refcount_acquire(&s->s_count);
713bc093719SEd Schouten }
714bc093719SEd Schouten 
715bc093719SEd Schouten void
716bc093719SEd Schouten sess_release(struct session *s)
717bc093719SEd Schouten {
718bc093719SEd Schouten 
719bc093719SEd Schouten 	if (refcount_release(&s->s_count)) {
720bc093719SEd Schouten 		if (s->s_ttyp != NULL) {
721bc093719SEd Schouten 			tty_lock(s->s_ttyp);
722bc093719SEd Schouten 			tty_rel_sess(s->s_ttyp, s);
723bc093719SEd Schouten 		}
724572b4402SPoul-Henning Kamp 		mtx_destroy(&s->s_mtx);
7251ede983cSDag-Erling Smørgrav 		free(s, M_SESSION);
726572b4402SPoul-Henning Kamp 	}
727572b4402SPoul-Henning Kamp }
728572b4402SPoul-Henning Kamp 
729831031ceSBruce Evans #ifdef DDB
730831031ceSBruce Evans 
731831031ceSBruce Evans DB_SHOW_COMMAND(pgrpdump, pgrpdump)
732df8bae1dSRodney W. Grimes {
733df8bae1dSRodney W. Grimes 	register struct pgrp *pgrp;
734df8bae1dSRodney W. Grimes 	register struct proc *p;
735876a94eeSBruce Evans 	register int i;
736df8bae1dSRodney W. Grimes 
737b75356e1SJeffrey Hsu 	for (i = 0; i <= pgrphash; i++) {
7381b727751SPoul-Henning Kamp 		if (!LIST_EMPTY(&pgrphashtbl[i])) {
739df8bae1dSRodney W. Grimes 			printf("\tindx %d\n", i);
7401b727751SPoul-Henning Kamp 			LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
741ac1e407bSBruce Evans 				printf(
742ac1e407bSBruce Evans 			"\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
743ac1e407bSBruce Evans 				    (void *)pgrp, (long)pgrp->pg_id,
744ac1e407bSBruce Evans 				    (void *)pgrp->pg_session,
745b75356e1SJeffrey Hsu 				    pgrp->pg_session->s_count,
7461b727751SPoul-Henning Kamp 				    (void *)LIST_FIRST(&pgrp->pg_members));
7471b727751SPoul-Henning Kamp 				LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
748ac1e407bSBruce Evans 					printf("\t\tpid %ld addr %p pgrp %p\n",
749ac1e407bSBruce Evans 					    (long)p->p_pid, (void *)p,
750ac1e407bSBruce Evans 					    (void *)p->p_pgrp);
751df8bae1dSRodney W. Grimes 				}
752df8bae1dSRodney W. Grimes 			}
753df8bae1dSRodney W. Grimes 		}
754df8bae1dSRodney W. Grimes 	}
755df8bae1dSRodney W. Grimes }
756831031ceSBruce Evans #endif /* DDB */
757972f9b20SPoul-Henning Kamp 
758972f9b20SPoul-Henning Kamp /*
759f8d90480SAttilio Rao  * Calculate the kinfo_proc members which contain process-wide
760f8d90480SAttilio Rao  * informations.
761f8d90480SAttilio Rao  * Must be called with the target process locked.
762f8d90480SAttilio Rao  */
763f8d90480SAttilio Rao static void
764f8d90480SAttilio Rao fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp)
765f8d90480SAttilio Rao {
766f8d90480SAttilio Rao 	struct thread *td;
767f8d90480SAttilio Rao 
768f8d90480SAttilio Rao 	PROC_LOCK_ASSERT(p, MA_OWNED);
769f8d90480SAttilio Rao 
770f8d90480SAttilio Rao 	kp->ki_estcpu = 0;
771f8d90480SAttilio Rao 	kp->ki_pctcpu = 0;
772f8d90480SAttilio Rao 	FOREACH_THREAD_IN_PROC(p, td) {
773f8d90480SAttilio Rao 		thread_lock(td);
774f8d90480SAttilio Rao 		kp->ki_pctcpu += sched_pctcpu(td);
775f8d90480SAttilio Rao 		kp->ki_estcpu += td->td_estcpu;
776f8d90480SAttilio Rao 		thread_unlock(td);
777f8d90480SAttilio Rao 	}
778f8d90480SAttilio Rao }
779f8d90480SAttilio Rao 
780f8d90480SAttilio Rao /*
7815032ff81SDon Lewis  * Clear kinfo_proc and fill in any information that is common
7825032ff81SDon Lewis  * to all threads in the process.
78365c9b430SJohn Baldwin  * Must be called with the target process locked.
784972f9b20SPoul-Henning Kamp  */
7855032ff81SDon Lewis static void
7865032ff81SDon Lewis fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp)
787972f9b20SPoul-Henning Kamp {
7884093529dSJeff Roberson 	struct thread *td0;
7891f7d2501SKirk McKusick 	struct tty *tp;
7901f7d2501SKirk McKusick 	struct session *sp;
791d079d0a0SPawel Jakub Dawidek 	struct ucred *cred;
79290af4afaSJohn Baldwin 	struct sigacts *ps;
793972f9b20SPoul-Henning Kamp 
7948b04bbefSMateusz Guzik 	/* For proc_realparent. */
7958b04bbefSMateusz Guzik 	sx_assert(&proctree_lock, SX_LOCKED);
796374ae2a3SJeff Roberson 	PROC_LOCK_ASSERT(p, MA_OWNED);
7971f7d2501SKirk McKusick 	bzero(kp, sizeof(*kp));
798972f9b20SPoul-Henning Kamp 
7991f7d2501SKirk McKusick 	kp->ki_structsize = sizeof(*kp);
8001f7d2501SKirk McKusick 	kp->ki_paddr = p;
8016617724cSJeff Roberson 	kp->ki_addr =/* p->p_addr; */0; /* XXX */
8021f7d2501SKirk McKusick 	kp->ki_args = p->p_args;
8031f7d2501SKirk McKusick 	kp->ki_textvp = p->p_textvp;
8046c84de02SJohn Baldwin #ifdef KTRACE
805a5881ea5SJohn Baldwin 	kp->ki_tracep = p->p_tracevp;
8066c84de02SJohn Baldwin 	kp->ki_traceflag = p->p_traceflag;
8076c84de02SJohn Baldwin #endif
8081f7d2501SKirk McKusick 	kp->ki_fd = p->p_fd;
8091f7d2501SKirk McKusick 	kp->ki_vmspace = p->p_vmspace;
810cefcecbeSPawel Jakub Dawidek 	kp->ki_flag = p->p_flag;
81155648840SJohn Baldwin 	kp->ki_flag2 = p->p_flag2;
812d079d0a0SPawel Jakub Dawidek 	cred = p->p_ucred;
813d079d0a0SPawel Jakub Dawidek 	if (cred) {
814d079d0a0SPawel Jakub Dawidek 		kp->ki_uid = cred->cr_uid;
815d079d0a0SPawel Jakub Dawidek 		kp->ki_ruid = cred->cr_ruid;
816d079d0a0SPawel Jakub Dawidek 		kp->ki_svuid = cred->cr_svuid;
81796fcc75fSRobert Watson 		kp->ki_cr_flags = 0;
81896fcc75fSRobert Watson 		if (cred->cr_flags & CRED_FLAG_CAPMODE)
81996fcc75fSRobert Watson 			kp->ki_cr_flags |= KI_CRF_CAPABILITY_MODE;
8201b5768beSBrooks Davis 		/* XXX bde doesn't like KI_NGROUPS */
8211b5768beSBrooks Davis 		if (cred->cr_ngroups > KI_NGROUPS) {
8221b5768beSBrooks Davis 			kp->ki_ngroups = KI_NGROUPS;
8231b5768beSBrooks Davis 			kp->ki_cr_flags |= KI_CRF_GRP_OVERFLOW;
8241b5768beSBrooks Davis 		} else
825838d9858SBrooks Davis 			kp->ki_ngroups = cred->cr_ngroups;
8261b5768beSBrooks Davis 		bcopy(cred->cr_groups, kp->ki_groups,
8271b5768beSBrooks Davis 		    kp->ki_ngroups * sizeof(gid_t));
828d079d0a0SPawel Jakub Dawidek 		kp->ki_rgid = cred->cr_rgid;
829d079d0a0SPawel Jakub Dawidek 		kp->ki_svgid = cred->cr_svgid;
830cefcecbeSPawel Jakub Dawidek 		/* If jailed(cred), emulate the old P_JAILED flag. */
831c78941e6SPawel Jakub Dawidek 		if (jailed(cred)) {
832cefcecbeSPawel Jakub Dawidek 			kp->ki_flag |= P_JAILED;
8330304c731SJamie Gritton 			/* If inside the jail, use 0 as a jail ID. */
8340304c731SJamie Gritton 			if (cred->cr_prison != curthread->td_ucred->cr_prison)
835c78941e6SPawel Jakub Dawidek 				kp->ki_jid = cred->cr_prison->pr_id;
836c78941e6SPawel Jakub Dawidek 		}
8377123f4cdSEdward Tomasz Napierala 		strlcpy(kp->ki_loginclass, cred->cr_loginclass->lc_name,
8387123f4cdSEdward Tomasz Napierala 		    sizeof(kp->ki_loginclass));
839972f9b20SPoul-Henning Kamp 	}
84090af4afaSJohn Baldwin 	ps = p->p_sigacts;
841d079d0a0SPawel Jakub Dawidek 	if (ps) {
84290af4afaSJohn Baldwin 		mtx_lock(&ps->ps_mtx);
84390af4afaSJohn Baldwin 		kp->ki_sigignore = ps->ps_sigignore;
84490af4afaSJohn Baldwin 		kp->ki_sigcatch = ps->ps_sigcatch;
84590af4afaSJohn Baldwin 		mtx_unlock(&ps->ps_mtx);
846d8c85307SJulian Elischer 	}
847e602ba25SJulian Elischer 	if (p->p_state != PRS_NEW &&
848e602ba25SJulian Elischer 	    p->p_state != PRS_ZOMBIE &&
849e602ba25SJulian Elischer 	    p->p_vmspace != NULL) {
8501f7d2501SKirk McKusick 		struct vmspace *vm = p->p_vmspace;
851cd73303cSDavid Greenman 
8521f7d2501SKirk McKusick 		kp->ki_size = vm->vm_map.size;
8531f7d2501SKirk McKusick 		kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/
854ceff7f2aSTim J. Robbins 		FOREACH_THREAD_IN_PROC(p, td0) {
855ceff7f2aSTim J. Robbins 			if (!TD_IS_SWAPPED(td0))
856ceff7f2aSTim J. Robbins 				kp->ki_rssize += td0->td_kstack_pages;
857ceff7f2aSTim J. Robbins 		}
8581f7d2501SKirk McKusick 		kp->ki_swrss = vm->vm_swrss;
8591f7d2501SKirk McKusick 		kp->ki_tsize = vm->vm_tsize;
8601f7d2501SKirk McKusick 		kp->ki_dsize = vm->vm_dsize;
8611f7d2501SKirk McKusick 		kp->ki_ssize = vm->vm_ssize;
8625032ff81SDon Lewis 	} else if (p->p_state == PRS_ZOMBIE)
8635032ff81SDon Lewis 		kp->ki_stat = SZOMB;
864b61ce5b0SJeff Roberson 	if (kp->ki_flag & P_INMEM)
865b61ce5b0SJeff Roberson 		kp->ki_sflag = PS_INMEM;
866b61ce5b0SJeff Roberson 	else
867b61ce5b0SJeff Roberson 		kp->ki_sflag = 0;
86854b0e65fSJeff Roberson 	/* Calculate legacy swtime as seconds since 'swtick'. */
86954b0e65fSJeff Roberson 	kp->ki_swtime = (ticks - p->p_swtick) / hz;
870cebabef0SPawel Jakub Dawidek 	kp->ki_pid = p->p_pid;
871cebabef0SPawel Jakub Dawidek 	kp->ki_nice = p->p_nice;
8725e9ccc87SWill Andrews 	kp->ki_fibnum = p->p_fibnum;
87378c85e8dSJohn Baldwin 	kp->ki_start = p->p_stats->p_start;
87478c85e8dSJohn Baldwin 	timevaladd(&kp->ki_start, &boottime);
875a1fe14bcSAttilio Rao 	PROC_SLOCK(p);
8768e6fa660SJohn Baldwin 	rufetch(p, &kp->ki_rusage);
8778e6fa660SJohn Baldwin 	kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime);
87878c85e8dSJohn Baldwin 	calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime);
879a1fe14bcSAttilio Rao 	PROC_SUNLOCK(p);
88078c85e8dSJohn Baldwin 	calccru(p, &kp->ki_childutime, &kp->ki_childstime);
881a37e14e1SEdward Tomasz Napierala 	/* Some callers want child times in a single value. */
88278c85e8dSJohn Baldwin 	kp->ki_childtime = kp->ki_childstime;
88378c85e8dSJohn Baldwin 	timevaladd(&kp->ki_childtime, &kp->ki_childutime);
884a37e14e1SEdward Tomasz Napierala 
8854d34e019SKonstantin Belousov 	FOREACH_THREAD_IN_PROC(p, td0)
8864d34e019SKonstantin Belousov 		kp->ki_cow += td0->td_cow;
8874d34e019SKonstantin Belousov 
888f591779bSSeigo Tanimura 	tp = NULL;
8891f7d2501SKirk McKusick 	if (p->p_pgrp) {
8901f7d2501SKirk McKusick 		kp->ki_pgid = p->p_pgrp->pg_id;
8911f7d2501SKirk McKusick 		kp->ki_jobc = p->p_pgrp->pg_jobc;
8921f7d2501SKirk McKusick 		sp = p->p_pgrp->pg_session;
8931f7d2501SKirk McKusick 
8941f7d2501SKirk McKusick 		if (sp != NULL) {
8951f7d2501SKirk McKusick 			kp->ki_sid = sp->s_sid;
896f591779bSSeigo Tanimura 			SESS_LOCK(sp);
897e80fb434SRobert Drehmel 			strlcpy(kp->ki_login, sp->s_login,
898e80fb434SRobert Drehmel 			    sizeof(kp->ki_login));
8991f7d2501SKirk McKusick 			if (sp->s_ttyvp)
900b8e6bf1eSJohn Baldwin 				kp->ki_kiflag |= KI_CTTY;
9011f7d2501SKirk McKusick 			if (SESS_LEADER(p))
9021f7d2501SKirk McKusick 				kp->ki_kiflag |= KI_SLEADER;
903bc093719SEd Schouten 			/* XXX proctree_lock */
904f591779bSSeigo Tanimura 			tp = sp->s_ttyp;
905f591779bSSeigo Tanimura 			SESS_UNLOCK(sp);
906cd73303cSDavid Greenman 		}
907cd73303cSDavid Greenman 	}
908f591779bSSeigo Tanimura 	if ((p->p_flag & P_CONTROLT) && tp != NULL) {
909bc093719SEd Schouten 		kp->ki_tdev = tty_udev(tp);
9101f7d2501SKirk McKusick 		kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
9111f7d2501SKirk McKusick 		if (tp->t_session)
9121f7d2501SKirk McKusick 			kp->ki_tsid = tp->t_session->s_sid;
913972f9b20SPoul-Henning Kamp 	} else
914f3732fd1SPoul-Henning Kamp 		kp->ki_tdev = NODEV;
91513b762a3SEd Maste 	if (p->p_comm[0] != '\0')
916e80fb434SRobert Drehmel 		strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));
917078842c5SGarance A Drosehn 	if (p->p_sysent && p->p_sysent->sv_name != NULL &&
918078842c5SGarance A Drosehn 	    p->p_sysent->sv_name[0] != '\0')
919078842c5SGarance A Drosehn 		strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul));
9201d9c5696SJuli Mallett 	kp->ki_siglist = p->p_siglist;
9211f7d2501SKirk McKusick 	kp->ki_xstat = p->p_xstat;
9221f7d2501SKirk McKusick 	kp->ki_acflag = p->p_acflag;
9231f7d2501SKirk McKusick 	kp->ki_lock = p->p_lock;
9245b5477d7SGleb Smirnoff 	if (p->p_pptr) {
9258b04bbefSMateusz Guzik 		kp->ki_ppid = proc_realparent(p)->p_pid;
9268b04bbefSMateusz Guzik 		if (p->p_flag & P_TRACED)
9278b04bbefSMateusz Guzik 			kp->ki_tracer = p->p_pptr->p_pid;
928972f9b20SPoul-Henning Kamp 	}
9295b5477d7SGleb Smirnoff }
930972f9b20SPoul-Henning Kamp 
9315032ff81SDon Lewis /*
93200305546SKonstantin Belousov  * Fill in information that is thread specific.  Must be called with
93300305546SKonstantin Belousov  * target process locked.  If 'preferthread' is set, overwrite certain
93400305546SKonstantin Belousov  * process-related fields that are maintained for both threads and
93500305546SKonstantin Belousov  * processes.
9365032ff81SDon Lewis  */
9375032ff81SDon Lewis static void
938d92909c1SRobert Watson fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread)
9395032ff81SDon Lewis {
9405032ff81SDon Lewis 	struct proc *p;
9415032ff81SDon Lewis 
9425032ff81SDon Lewis 	p = td->td_proc;
9436239ef1dSEd Maste 	kp->ki_tdaddr = td;
944374ae2a3SJeff Roberson 	PROC_LOCK_ASSERT(p, MA_OWNED);
9455032ff81SDon Lewis 
9462417d97eSJohn Baldwin 	if (preferthread)
9472417d97eSJohn Baldwin 		PROC_SLOCK(p);
948982d11f8SJeff Roberson 	thread_lock(td);
9495032ff81SDon Lewis 	if (td->td_wmesg != NULL)
9505032ff81SDon Lewis 		strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg));
9515032ff81SDon Lewis 	else
9525032ff81SDon Lewis 		bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg));
953925af544SBjoern A. Zeeb 	strlcpy(kp->ki_tdname, td->td_name, sizeof(kp->ki_tdname));
9545032ff81SDon Lewis 	if (TD_ON_LOCK(td)) {
9555032ff81SDon Lewis 		kp->ki_kiflag |= KI_LOCKBLOCK;
9565032ff81SDon Lewis 		strlcpy(kp->ki_lockname, td->td_lockname,
9575032ff81SDon Lewis 		    sizeof(kp->ki_lockname));
9585032ff81SDon Lewis 	} else {
9595032ff81SDon Lewis 		kp->ki_kiflag &= ~KI_LOCKBLOCK;
9605032ff81SDon Lewis 		bzero(kp->ki_lockname, sizeof(kp->ki_lockname));
9615032ff81SDon Lewis 	}
9625032ff81SDon Lewis 
9636617724cSJeff Roberson 	if (p->p_state == PRS_NORMAL) { /* approximate. */
9645032ff81SDon Lewis 		if (TD_ON_RUNQ(td) ||
9655032ff81SDon Lewis 		    TD_CAN_RUN(td) ||
9665032ff81SDon Lewis 		    TD_IS_RUNNING(td)) {
9675032ff81SDon Lewis 			kp->ki_stat = SRUN;
9685032ff81SDon Lewis 		} else if (P_SHOULDSTOP(p)) {
9695032ff81SDon Lewis 			kp->ki_stat = SSTOP;
9705032ff81SDon Lewis 		} else if (TD_IS_SLEEPING(td)) {
9715032ff81SDon Lewis 			kp->ki_stat = SSLEEP;
9725032ff81SDon Lewis 		} else if (TD_ON_LOCK(td)) {
9735032ff81SDon Lewis 			kp->ki_stat = SLOCK;
9745032ff81SDon Lewis 		} else {
9755032ff81SDon Lewis 			kp->ki_stat = SWAIT;
9765032ff81SDon Lewis 		}
9773357835aSDavid Xu 	} else if (p->p_state == PRS_ZOMBIE) {
9783357835aSDavid Xu 		kp->ki_stat = SZOMB;
9795032ff81SDon Lewis 	} else {
9805032ff81SDon Lewis 		kp->ki_stat = SIDL;
9815032ff81SDon Lewis 	}
9825032ff81SDon Lewis 
9835032ff81SDon Lewis 	/* Things in the thread */
9845032ff81SDon Lewis 	kp->ki_wchan = td->td_wchan;
9855032ff81SDon Lewis 	kp->ki_pri.pri_level = td->td_priority;
9865032ff81SDon Lewis 	kp->ki_pri.pri_native = td->td_base_pri;
9875032ff81SDon Lewis 	kp->ki_lastcpu = td->td_lastcpu;
9885032ff81SDon Lewis 	kp->ki_oncpu = td->td_oncpu;
9895032ff81SDon Lewis 	kp->ki_tdflags = td->td_flags;
9905032ff81SDon Lewis 	kp->ki_tid = td->td_tid;
9915032ff81SDon Lewis 	kp->ki_numthreads = p->p_numthreads;
9925032ff81SDon Lewis 	kp->ki_pcb = td->td_pcb;
9935032ff81SDon Lewis 	kp->ki_kstack = (void *)td->td_kstack;
99454b0e65fSJeff Roberson 	kp->ki_slptime = (ticks - td->td_slptick) / hz;
9958460a577SJohn Birrell 	kp->ki_pri.pri_class = td->td_pri_class;
9968460a577SJohn Birrell 	kp->ki_pri.pri_user = td->td_user_pri;
9975032ff81SDon Lewis 
998f8d90480SAttilio Rao 	if (preferthread) {
9992417d97eSJohn Baldwin 		rufetchtd(td, &kp->ki_rusage);
1000213c077fSKonstantin Belousov 		kp->ki_runtime = cputick2usec(td->td_rux.rux_runtime);
1001f8d90480SAttilio Rao 		kp->ki_pctcpu = sched_pctcpu(td);
1002f8d90480SAttilio Rao 		kp->ki_estcpu = td->td_estcpu;
10034d34e019SKonstantin Belousov 		kp->ki_cow = td->td_cow;
1004f8d90480SAttilio Rao 	}
1005d92909c1SRobert Watson 
10065032ff81SDon Lewis 	/* We can't get this anymore but ps etc never used it anyway. */
10075032ff81SDon Lewis 	kp->ki_rqindex = 0;
10085032ff81SDon Lewis 
100900305546SKonstantin Belousov 	if (preferthread)
101000305546SKonstantin Belousov 		kp->ki_siglist = td->td_siglist;
10115032ff81SDon Lewis 	kp->ki_sigmask = td->td_sigmask;
1012982d11f8SJeff Roberson 	thread_unlock(td);
10132417d97eSJohn Baldwin 	if (preferthread)
10142417d97eSJohn Baldwin 		PROC_SUNLOCK(p);
10155032ff81SDon Lewis }
10165032ff81SDon Lewis 
10175032ff81SDon Lewis /*
10185032ff81SDon Lewis  * Fill in a kinfo_proc structure for the specified process.
10195032ff81SDon Lewis  * Must be called with the target process locked.
10205032ff81SDon Lewis  */
10215032ff81SDon Lewis void
10225032ff81SDon Lewis fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
10235032ff81SDon Lewis {
10245032ff81SDon Lewis 
1025f8d90480SAttilio Rao 	MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
1026f8d90480SAttilio Rao 
10275032ff81SDon Lewis 	fill_kinfo_proc_only(p, kp);
1028d92909c1SRobert Watson 	fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0);
1029f8d90480SAttilio Rao 	fill_kinfo_aggregate(p, kp);
10305032ff81SDon Lewis }
10315032ff81SDon Lewis 
10328b059651SDavid Schultz struct pstats *
10338b059651SDavid Schultz pstats_alloc(void)
10348b059651SDavid Schultz {
10358b059651SDavid Schultz 
10368b059651SDavid Schultz 	return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK));
10378b059651SDavid Schultz }
10388b059651SDavid Schultz 
10398b059651SDavid Schultz /*
10408b059651SDavid Schultz  * Copy parts of p_stats; zero the rest of p_stats (statistics).
10418b059651SDavid Schultz  */
10428b059651SDavid Schultz void
10438b059651SDavid Schultz pstats_fork(struct pstats *src, struct pstats *dst)
10448b059651SDavid Schultz {
10458b059651SDavid Schultz 
10468b059651SDavid Schultz 	bzero(&dst->pstat_startzero,
10476db36923SDavid Schultz 	    __rangeof(struct pstats, pstat_startzero, pstat_endzero));
10488b059651SDavid Schultz 	bcopy(&src->pstat_startcopy, &dst->pstat_startcopy,
10496db36923SDavid Schultz 	    __rangeof(struct pstats, pstat_startcopy, pstat_endcopy));
10508b059651SDavid Schultz }
10518b059651SDavid Schultz 
10528b059651SDavid Schultz void
10538b059651SDavid Schultz pstats_free(struct pstats *ps)
10548b059651SDavid Schultz {
10558b059651SDavid Schultz 
10568b059651SDavid Schultz 	free(ps, M_SUBPROC);
10578b059651SDavid Schultz }
10588b059651SDavid Schultz 
1059134eb42eSKonstantin Belousov static struct proc *
1060134eb42eSKonstantin Belousov zpfind_locked(pid_t pid)
1061134eb42eSKonstantin Belousov {
1062134eb42eSKonstantin Belousov 	struct proc *p;
1063134eb42eSKonstantin Belousov 
1064134eb42eSKonstantin Belousov 	sx_assert(&allproc_lock, SX_LOCKED);
1065134eb42eSKonstantin Belousov 	LIST_FOREACH(p, &zombproc, p_list) {
1066134eb42eSKonstantin Belousov 		if (p->p_pid == pid) {
1067134eb42eSKonstantin Belousov 			PROC_LOCK(p);
1068134eb42eSKonstantin Belousov 			break;
1069134eb42eSKonstantin Belousov 		}
1070134eb42eSKonstantin Belousov 	}
1071134eb42eSKonstantin Belousov 	return (p);
1072134eb42eSKonstantin Belousov }
1073134eb42eSKonstantin Belousov 
10748b059651SDavid Schultz /*
107542a4ed99SJohn Baldwin  * Locate a zombie process by number
107642a4ed99SJohn Baldwin  */
107742a4ed99SJohn Baldwin struct proc *
10783ce93e4eSPoul-Henning Kamp zpfind(pid_t pid)
10793ce93e4eSPoul-Henning Kamp {
10803ce93e4eSPoul-Henning Kamp 	struct proc *p;
10813ce93e4eSPoul-Henning Kamp 
10821005a129SJohn Baldwin 	sx_slock(&allproc_lock);
1083134eb42eSKonstantin Belousov 	p = zpfind_locked(pid);
10841005a129SJohn Baldwin 	sx_sunlock(&allproc_lock);
10853ce93e4eSPoul-Henning Kamp 	return (p);
10863ce93e4eSPoul-Henning Kamp }
10873ce93e4eSPoul-Henning Kamp 
108805e06d11SKonstantin Belousov #ifdef COMPAT_FREEBSD32
108905e06d11SKonstantin Belousov 
109005e06d11SKonstantin Belousov /*
109105e06d11SKonstantin Belousov  * This function is typically used to copy out the kernel address, so
109205e06d11SKonstantin Belousov  * it can be replaced by assignment of zero.
109305e06d11SKonstantin Belousov  */
109405e06d11SKonstantin Belousov static inline uint32_t
109505e06d11SKonstantin Belousov ptr32_trim(void *ptr)
109605e06d11SKonstantin Belousov {
109705e06d11SKonstantin Belousov 	uintptr_t uptr;
109805e06d11SKonstantin Belousov 
109905e06d11SKonstantin Belousov 	uptr = (uintptr_t)ptr;
110005e06d11SKonstantin Belousov 	return ((uptr > UINT_MAX) ? 0 : uptr);
110105e06d11SKonstantin Belousov }
110205e06d11SKonstantin Belousov 
110305e06d11SKonstantin Belousov #define PTRTRIM_CP(src,dst,fld) \
110405e06d11SKonstantin Belousov 	do { (dst).fld = ptr32_trim((src).fld); } while (0)
110505e06d11SKonstantin Belousov 
110605e06d11SKonstantin Belousov static void
110705e06d11SKonstantin Belousov freebsd32_kinfo_proc_out(const struct kinfo_proc *ki, struct kinfo_proc32 *ki32)
110805e06d11SKonstantin Belousov {
110905e06d11SKonstantin Belousov 	int i;
111005e06d11SKonstantin Belousov 
111105e06d11SKonstantin Belousov 	bzero(ki32, sizeof(struct kinfo_proc32));
111205e06d11SKonstantin Belousov 	ki32->ki_structsize = sizeof(struct kinfo_proc32);
111305e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_layout);
111405e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_args);
111505e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_paddr);
111605e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_addr);
111705e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_tracep);
111805e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_textvp);
111905e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_fd);
112005e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_vmspace);
112105e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_wchan);
112205e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_pid);
112305e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_ppid);
112405e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_pgid);
112505e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_tpgid);
112605e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_sid);
112705e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_tsid);
112805e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_jobc);
112905e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_tdev);
113005e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_siglist);
113105e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_sigmask);
113205e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_sigignore);
113305e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_sigcatch);
113405e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_uid);
113505e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_ruid);
113605e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_svuid);
113705e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_rgid);
113805e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_svgid);
113905e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_ngroups);
114005e06d11SKonstantin Belousov 	for (i = 0; i < KI_NGROUPS; i++)
114105e06d11SKonstantin Belousov 		CP(*ki, *ki32, ki_groups[i]);
114205e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_size);
114305e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_rssize);
114405e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_swrss);
114505e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_tsize);
114605e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_dsize);
114705e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_ssize);
114805e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_xstat);
114905e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_acflag);
115005e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_pctcpu);
115105e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_estcpu);
115205e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_slptime);
115305e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_swtime);
1154371778a3SKonstantin Belousov 	CP(*ki, *ki32, ki_cow);
115505e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_runtime);
115605e06d11SKonstantin Belousov 	TV_CP(*ki, *ki32, ki_start);
115705e06d11SKonstantin Belousov 	TV_CP(*ki, *ki32, ki_childtime);
115805e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_flag);
115905e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_kiflag);
116005e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_traceflag);
116105e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_stat);
116205e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_nice);
116305e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_lock);
116405e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_rqindex);
116505e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_oncpu);
116605e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_lastcpu);
1167925af544SBjoern A. Zeeb 	bcopy(ki->ki_tdname, ki32->ki_tdname, TDNAMLEN + 1);
116805e06d11SKonstantin Belousov 	bcopy(ki->ki_wmesg, ki32->ki_wmesg, WMESGLEN + 1);
116905e06d11SKonstantin Belousov 	bcopy(ki->ki_login, ki32->ki_login, LOGNAMELEN + 1);
117005e06d11SKonstantin Belousov 	bcopy(ki->ki_lockname, ki32->ki_lockname, LOCKNAMELEN + 1);
117105e06d11SKonstantin Belousov 	bcopy(ki->ki_comm, ki32->ki_comm, COMMLEN + 1);
117205e06d11SKonstantin Belousov 	bcopy(ki->ki_emul, ki32->ki_emul, KI_EMULNAMELEN + 1);
11737123f4cdSEdward Tomasz Napierala 	bcopy(ki->ki_loginclass, ki32->ki_loginclass, LOGINCLASSLEN + 1);
11748b04bbefSMateusz Guzik 	CP(*ki, *ki32, ki_tracer);
117555648840SJohn Baldwin 	CP(*ki, *ki32, ki_flag2);
11765e9ccc87SWill Andrews 	CP(*ki, *ki32, ki_fibnum);
117705e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_cr_flags);
117805e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_jid);
117905e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_numthreads);
118005e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_tid);
118105e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_pri);
118205e06d11SKonstantin Belousov 	freebsd32_rusage_out(&ki->ki_rusage, &ki32->ki_rusage);
118305e06d11SKonstantin Belousov 	freebsd32_rusage_out(&ki->ki_rusage_ch, &ki32->ki_rusage_ch);
118405e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_pcb);
118505e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_kstack);
118605e06d11SKonstantin Belousov 	PTRTRIM_CP(*ki, *ki32, ki_udata);
118705e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_sflag);
118805e06d11SKonstantin Belousov 	CP(*ki, *ki32, ki_tdflags);
118905e06d11SKonstantin Belousov }
119005e06d11SKonstantin Belousov #endif
119105e06d11SKonstantin Belousov 
1192fe52cf54SMikolaj Golub int
1193fe52cf54SMikolaj Golub kern_proc_out(struct proc *p, struct sbuf *sb, int flags)
11943ce93e4eSPoul-Henning Kamp {
119530c6f34eSScott Long 	struct thread *td;
1196fe52cf54SMikolaj Golub 	struct kinfo_proc ki;
1197fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32
1198fe52cf54SMikolaj Golub 	struct kinfo_proc32 ki32;
1199fe52cf54SMikolaj Golub #endif
1200fe52cf54SMikolaj Golub 	int error;
12013ce93e4eSPoul-Henning Kamp 
120265c9b430SJohn Baldwin 	PROC_LOCK_ASSERT(p, MA_OWNED);
1203f8d90480SAttilio Rao 	MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
120430c6f34eSScott Long 
1205fe52cf54SMikolaj Golub 	error = 0;
1206fe52cf54SMikolaj Golub 	fill_kinfo_proc(p, &ki);
1207fe52cf54SMikolaj Golub 	if ((flags & KERN_PROC_NOTHREADS) != 0) {
1208fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32
1209fe52cf54SMikolaj Golub 		if ((flags & KERN_PROC_MASK32) != 0) {
1210fe52cf54SMikolaj Golub 			freebsd32_kinfo_proc_out(&ki, &ki32);
1211fe52cf54SMikolaj Golub 			error = sbuf_bcat(sb, &ki32, sizeof(ki32));
1212fe52cf54SMikolaj Golub 		} else
1213fe52cf54SMikolaj Golub #endif
1214fe52cf54SMikolaj Golub 			error = sbuf_bcat(sb, &ki, sizeof(ki));
1215fe52cf54SMikolaj Golub 	} else {
121630c6f34eSScott Long 		FOREACH_THREAD_IN_PROC(p, td) {
1217fe52cf54SMikolaj Golub 			fill_kinfo_thread(td, &ki, 1);
1218fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32
1219fe52cf54SMikolaj Golub 			if ((flags & KERN_PROC_MASK32) != 0) {
1220fe52cf54SMikolaj Golub 				freebsd32_kinfo_proc_out(&ki, &ki32);
1221fe52cf54SMikolaj Golub 				error = sbuf_bcat(sb, &ki32, sizeof(ki32));
1222fe52cf54SMikolaj Golub 			} else
1223fe52cf54SMikolaj Golub #endif
1224fe52cf54SMikolaj Golub 				error = sbuf_bcat(sb, &ki, sizeof(ki));
122530c6f34eSScott Long 			if (error)
122630c6f34eSScott Long 				break;
122730c6f34eSScott Long 		}
122830c6f34eSScott Long 	}
122930c6f34eSScott Long 	PROC_UNLOCK(p);
12303ce93e4eSPoul-Henning Kamp 	return (error);
1231fe52cf54SMikolaj Golub }
1232fe52cf54SMikolaj Golub 
1233fe52cf54SMikolaj Golub static int
1234fe52cf54SMikolaj Golub sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags,
1235fe52cf54SMikolaj Golub     int doingzomb)
1236fe52cf54SMikolaj Golub {
1237fe52cf54SMikolaj Golub 	struct sbuf sb;
1238fe52cf54SMikolaj Golub 	struct kinfo_proc ki;
1239fe52cf54SMikolaj Golub 	struct proc *np;
1240fe52cf54SMikolaj Golub 	int error, error2;
1241fe52cf54SMikolaj Golub 	pid_t pid;
1242fe52cf54SMikolaj Golub 
1243fe52cf54SMikolaj Golub 	pid = p->p_pid;
1244fe52cf54SMikolaj Golub 	sbuf_new_for_sysctl(&sb, (char *)&ki, sizeof(ki), req);
1245fe52cf54SMikolaj Golub 	error = kern_proc_out(p, &sb, flags);
1246fe52cf54SMikolaj Golub 	error2 = sbuf_finish(&sb);
1247fe52cf54SMikolaj Golub 	sbuf_delete(&sb);
1248fe52cf54SMikolaj Golub 	if (error != 0)
1249fe52cf54SMikolaj Golub 		return (error);
1250fe52cf54SMikolaj Golub 	else if (error2 != 0)
1251fe52cf54SMikolaj Golub 		return (error2);
1252fe52cf54SMikolaj Golub 	if (doingzomb)
125333a9ed9dSJohn Baldwin 		np = zpfind(pid);
125433a9ed9dSJohn Baldwin 	else {
125533a9ed9dSJohn Baldwin 		if (pid == 0)
125633a9ed9dSJohn Baldwin 			return (0);
125733a9ed9dSJohn Baldwin 		np = pfind(pid);
125833a9ed9dSJohn Baldwin 	}
125933a9ed9dSJohn Baldwin 	if (np == NULL)
1260f308bdddSKevin Lo 		return (ESRCH);
126133a9ed9dSJohn Baldwin 	if (np != p) {
126233a9ed9dSJohn Baldwin 		PROC_UNLOCK(np);
1263f308bdddSKevin Lo 		return (ESRCH);
126433a9ed9dSJohn Baldwin 	}
126533a9ed9dSJohn Baldwin 	PROC_UNLOCK(np);
12663ce93e4eSPoul-Henning Kamp 	return (0);
12673ce93e4eSPoul-Henning Kamp }
12683ce93e4eSPoul-Henning Kamp 
1269972f9b20SPoul-Henning Kamp static int
127082d9ae4eSPoul-Henning Kamp sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
1271972f9b20SPoul-Henning Kamp {
1272972f9b20SPoul-Henning Kamp 	int *name = (int *)arg1;
1273972f9b20SPoul-Henning Kamp 	u_int namelen = arg2;
1274972f9b20SPoul-Henning Kamp 	struct proc *p;
12752648efa6SDaniel Eischen 	int flags, doingzomb, oid_number;
1276972f9b20SPoul-Henning Kamp 	int error = 0;
1277972f9b20SPoul-Henning Kamp 
12782648efa6SDaniel Eischen 	oid_number = oidp->oid_number;
12792648efa6SDaniel Eischen 	if (oid_number != KERN_PROC_ALL &&
12802648efa6SDaniel Eischen 	    (oid_number & KERN_PROC_INC_THREAD) == 0)
12812648efa6SDaniel Eischen 		flags = KERN_PROC_NOTHREADS;
12822648efa6SDaniel Eischen 	else {
12832648efa6SDaniel Eischen 		flags = 0;
12842648efa6SDaniel Eischen 		oid_number &= ~KERN_PROC_INC_THREAD;
12852648efa6SDaniel Eischen 	}
1286fe52cf54SMikolaj Golub #ifdef COMPAT_FREEBSD32
1287fe52cf54SMikolaj Golub 	if (req->flags & SCTL_MASK32)
1288fe52cf54SMikolaj Golub 		flags |= KERN_PROC_MASK32;
1289fe52cf54SMikolaj Golub #endif
12902648efa6SDaniel Eischen 	if (oid_number == KERN_PROC_PID) {
12913ce93e4eSPoul-Henning Kamp 		if (namelen != 1)
1292972f9b20SPoul-Henning Kamp 			return (EINVAL);
12935032ff81SDon Lewis 		error = sysctl_wire_old_buffer(req, 0);
12945032ff81SDon Lewis 		if (error)
12955032ff81SDon Lewis 			return (error);
12968b04bbefSMateusz Guzik 		sx_slock(&proctree_lock);
1297fa3935bcSMikolaj Golub 		error = pget((pid_t)name[0], PGET_CANSEE, &p);
12988b04bbefSMateusz Guzik 		if (error == 0)
1299fe52cf54SMikolaj Golub 			error = sysctl_out_proc(p, req, flags, 0);
13008b04bbefSMateusz Guzik 		sx_sunlock(&proctree_lock);
13013ce93e4eSPoul-Henning Kamp 		return (error);
13023ce93e4eSPoul-Henning Kamp 	}
13033ddaef40STim J. Robbins 
13042648efa6SDaniel Eischen 	switch (oid_number) {
13053ddaef40STim J. Robbins 	case KERN_PROC_ALL:
13063ddaef40STim J. Robbins 		if (namelen != 0)
13073ce93e4eSPoul-Henning Kamp 			return (EINVAL);
13083ddaef40STim J. Robbins 		break;
130925e247afSPeter Wemm 	case KERN_PROC_PROC:
131025e247afSPeter Wemm 		if (namelen != 0 && namelen != 1)
131125e247afSPeter Wemm 			return (EINVAL);
131225e247afSPeter Wemm 		break;
13133ddaef40STim J. Robbins 	default:
13143ddaef40STim J. Robbins 		if (namelen != 1)
13153ddaef40STim J. Robbins 			return (EINVAL);
13163ddaef40STim J. Robbins 		break;
13173ddaef40STim J. Robbins 	}
13183ce93e4eSPoul-Henning Kamp 
1319972f9b20SPoul-Henning Kamp 	if (!req->oldptr) {
13203ce93e4eSPoul-Henning Kamp 		/* overestimate by 5 procs */
1321972f9b20SPoul-Henning Kamp 		error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
1322972f9b20SPoul-Henning Kamp 		if (error)
1323972f9b20SPoul-Henning Kamp 			return (error);
1324972f9b20SPoul-Henning Kamp 	}
132547934cefSDon Lewis 	error = sysctl_wire_old_buffer(req, 0);
132647934cefSDon Lewis 	if (error != 0)
132747934cefSDon Lewis 		return (error);
13288b04bbefSMateusz Guzik 	sx_slock(&proctree_lock);
13291005a129SJohn Baldwin 	sx_slock(&allproc_lock);
13303ce93e4eSPoul-Henning Kamp 	for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
13313ce93e4eSPoul-Henning Kamp 		if (!doingzomb)
13321b727751SPoul-Henning Kamp 			p = LIST_FIRST(&allproc);
13333ce93e4eSPoul-Henning Kamp 		else
13341b727751SPoul-Henning Kamp 			p = LIST_FIRST(&zombproc);
13351b727751SPoul-Henning Kamp 		for (; p != 0; p = LIST_NEXT(p, p_list)) {
133602e878d9SJohn Baldwin 			/*
133702e878d9SJohn Baldwin 			 * Skip embryonic processes.
133802e878d9SJohn Baldwin 			 */
13398e6fa660SJohn Baldwin 			PROC_LOCK(p);
134002e878d9SJohn Baldwin 			if (p->p_state == PRS_NEW) {
13418e6fa660SJohn Baldwin 				PROC_UNLOCK(p);
134202e878d9SJohn Baldwin 				continue;
134302e878d9SJohn Baldwin 			}
1344b241b0a2SJuli Mallett 			KASSERT(p->p_ucred != NULL,
1345b241b0a2SJuli Mallett 			    ("process credential is NULL for non-NEW proc"));
1346972f9b20SPoul-Henning Kamp 			/*
1347387d2c03SRobert Watson 			 * Show a user only appropriate processes.
134803f808c5SPaul Saab 			 */
1349f44d9e24SJohn Baldwin 			if (p_cansee(curthread, p)) {
135065c9b430SJohn Baldwin 				PROC_UNLOCK(p);
135103f808c5SPaul Saab 				continue;
135265c9b430SJohn Baldwin 			}
135303f808c5SPaul Saab 			/*
1354972f9b20SPoul-Henning Kamp 			 * TODO - make more efficient (see notes below).
1355972f9b20SPoul-Henning Kamp 			 * do by session.
1356972f9b20SPoul-Henning Kamp 			 */
13572648efa6SDaniel Eischen 			switch (oid_number) {
1358972f9b20SPoul-Henning Kamp 
1359078842c5SGarance A Drosehn 			case KERN_PROC_GID:
1360b241b0a2SJuli Mallett 				if (p->p_ucred->cr_gid != (gid_t)name[0]) {
1361078842c5SGarance A Drosehn 					PROC_UNLOCK(p);
1362078842c5SGarance A Drosehn 					continue;
1363078842c5SGarance A Drosehn 				}
1364078842c5SGarance A Drosehn 				break;
1365078842c5SGarance A Drosehn 
1366972f9b20SPoul-Henning Kamp 			case KERN_PROC_PGRP:
1367972f9b20SPoul-Henning Kamp 				/* could do this by traversing pgrp */
13683ce93e4eSPoul-Henning Kamp 				if (p->p_pgrp == NULL ||
1369f591779bSSeigo Tanimura 				    p->p_pgrp->pg_id != (pid_t)name[0]) {
1370f591779bSSeigo Tanimura 					PROC_UNLOCK(p);
1371972f9b20SPoul-Henning Kamp 					continue;
1372f591779bSSeigo Tanimura 				}
1373972f9b20SPoul-Henning Kamp 				break;
1374972f9b20SPoul-Henning Kamp 
1375b8fdc89dSGarance A Drosehn 			case KERN_PROC_RGID:
1376b241b0a2SJuli Mallett 				if (p->p_ucred->cr_rgid != (gid_t)name[0]) {
1377b8fdc89dSGarance A Drosehn 					PROC_UNLOCK(p);
1378b8fdc89dSGarance A Drosehn 					continue;
1379b8fdc89dSGarance A Drosehn 				}
1380b8fdc89dSGarance A Drosehn 				break;
1381b8fdc89dSGarance A Drosehn 
1382b8fdc89dSGarance A Drosehn 			case KERN_PROC_SESSION:
1383b8fdc89dSGarance A Drosehn 				if (p->p_session == NULL ||
1384b8fdc89dSGarance A Drosehn 				    p->p_session->s_sid != (pid_t)name[0]) {
1385b8fdc89dSGarance A Drosehn 					PROC_UNLOCK(p);
1386b8fdc89dSGarance A Drosehn 					continue;
1387b8fdc89dSGarance A Drosehn 				}
1388b8fdc89dSGarance A Drosehn 				break;
1389b8fdc89dSGarance A Drosehn 
1390972f9b20SPoul-Henning Kamp 			case KERN_PROC_TTY:
1391972f9b20SPoul-Henning Kamp 				if ((p->p_flag & P_CONTROLT) == 0 ||
1392f591779bSSeigo Tanimura 				    p->p_session == NULL) {
1393f591779bSSeigo Tanimura 					PROC_UNLOCK(p);
1394972f9b20SPoul-Henning Kamp 					continue;
1395f591779bSSeigo Tanimura 				}
1396bc093719SEd Schouten 				/* XXX proctree_lock */
1397f591779bSSeigo Tanimura 				SESS_LOCK(p->p_session);
1398f591779bSSeigo Tanimura 				if (p->p_session->s_ttyp == NULL ||
1399bc093719SEd Schouten 				    tty_udev(p->p_session->s_ttyp) !=
1400f3732fd1SPoul-Henning Kamp 				    (dev_t)name[0]) {
1401f591779bSSeigo Tanimura 					SESS_UNLOCK(p->p_session);
1402f591779bSSeigo Tanimura 					PROC_UNLOCK(p);
1403f591779bSSeigo Tanimura 					continue;
1404f591779bSSeigo Tanimura 				}
1405f591779bSSeigo Tanimura 				SESS_UNLOCK(p->p_session);
1406972f9b20SPoul-Henning Kamp 				break;
1407972f9b20SPoul-Henning Kamp 
1408972f9b20SPoul-Henning Kamp 			case KERN_PROC_UID:
1409b241b0a2SJuli Mallett 				if (p->p_ucred->cr_uid != (uid_t)name[0]) {
141065c9b430SJohn Baldwin 					PROC_UNLOCK(p);
1411972f9b20SPoul-Henning Kamp 					continue;
141265c9b430SJohn Baldwin 				}
1413972f9b20SPoul-Henning Kamp 				break;
1414972f9b20SPoul-Henning Kamp 
1415972f9b20SPoul-Henning Kamp 			case KERN_PROC_RUID:
1416b241b0a2SJuli Mallett 				if (p->p_ucred->cr_ruid != (uid_t)name[0]) {
141765c9b430SJohn Baldwin 					PROC_UNLOCK(p);
1418972f9b20SPoul-Henning Kamp 					continue;
141965c9b430SJohn Baldwin 				}
1420972f9b20SPoul-Henning Kamp 				break;
142130c6f34eSScott Long 
142230c6f34eSScott Long 			case KERN_PROC_PROC:
142330c6f34eSScott Long 				break;
142430c6f34eSScott Long 
142530c6f34eSScott Long 			default:
142630c6f34eSScott Long 				break;
142730c6f34eSScott Long 
1428972f9b20SPoul-Henning Kamp 			}
1429972f9b20SPoul-Henning Kamp 
1430fe52cf54SMikolaj Golub 			error = sysctl_out_proc(p, req, flags, doingzomb);
1431553629ebSJake Burkholder 			if (error) {
14321005a129SJohn Baldwin 				sx_sunlock(&allproc_lock);
14338b04bbefSMateusz Guzik 				sx_sunlock(&proctree_lock);
1434972f9b20SPoul-Henning Kamp 				return (error);
1435972f9b20SPoul-Henning Kamp 			}
1436972f9b20SPoul-Henning Kamp 		}
1437553629ebSJake Burkholder 	}
14381005a129SJohn Baldwin 	sx_sunlock(&allproc_lock);
14398b04bbefSMateusz Guzik 	sx_sunlock(&proctree_lock);
1440972f9b20SPoul-Henning Kamp 	return (0);
1441972f9b20SPoul-Henning Kamp }
1442972f9b20SPoul-Henning Kamp 
1443c1508b28SAlfred Perlstein struct pargs *
1444c1508b28SAlfred Perlstein pargs_alloc(int len)
1445c1508b28SAlfred Perlstein {
1446c1508b28SAlfred Perlstein 	struct pargs *pa;
1447c1508b28SAlfred Perlstein 
14481ede983cSDag-Erling Smørgrav 	pa = malloc(sizeof(struct pargs) + len, M_PARGS,
1449a163d034SWarner Losh 		M_WAITOK);
145055b4a5aeSJohn Baldwin 	refcount_init(&pa->ar_ref, 1);
1451c1508b28SAlfred Perlstein 	pa->ar_length = len;
1452c1508b28SAlfred Perlstein 	return (pa);
1453c1508b28SAlfred Perlstein }
1454c1508b28SAlfred Perlstein 
145558e8af1bSKonstantin Belousov static void
1456c1508b28SAlfred Perlstein pargs_free(struct pargs *pa)
1457c1508b28SAlfred Perlstein {
1458c1508b28SAlfred Perlstein 
14591ede983cSDag-Erling Smørgrav 	free(pa, M_PARGS);
1460c1508b28SAlfred Perlstein }
1461c1508b28SAlfred Perlstein 
1462c1508b28SAlfred Perlstein void
1463c1508b28SAlfred Perlstein pargs_hold(struct pargs *pa)
1464c1508b28SAlfred Perlstein {
1465c1508b28SAlfred Perlstein 
1466c1508b28SAlfred Perlstein 	if (pa == NULL)
1467c1508b28SAlfred Perlstein 		return;
146855b4a5aeSJohn Baldwin 	refcount_acquire(&pa->ar_ref);
1469c1508b28SAlfred Perlstein }
1470c1508b28SAlfred Perlstein 
1471c1508b28SAlfred Perlstein void
1472c1508b28SAlfred Perlstein pargs_drop(struct pargs *pa)
1473c1508b28SAlfred Perlstein {
1474c1508b28SAlfred Perlstein 
1475c1508b28SAlfred Perlstein 	if (pa == NULL)
1476c1508b28SAlfred Perlstein 		return;
147755b4a5aeSJohn Baldwin 	if (refcount_release(&pa->ar_ref))
1478c1508b28SAlfred Perlstein 		pargs_free(pa);
1479c1508b28SAlfred Perlstein }
1480c1508b28SAlfred Perlstein 
1481c5cfcb1cSMikolaj Golub static int
1482c5cfcb1cSMikolaj Golub proc_read_mem(struct thread *td, struct proc *p, vm_offset_t offset, void* buf,
1483c5cfcb1cSMikolaj Golub     size_t len)
1484c5cfcb1cSMikolaj Golub {
1485c5cfcb1cSMikolaj Golub 	struct iovec iov;
1486c5cfcb1cSMikolaj Golub 	struct uio uio;
1487c5cfcb1cSMikolaj Golub 
1488c5cfcb1cSMikolaj Golub 	iov.iov_base = (caddr_t)buf;
1489c5cfcb1cSMikolaj Golub 	iov.iov_len = len;
1490c5cfcb1cSMikolaj Golub 	uio.uio_iov = &iov;
1491c5cfcb1cSMikolaj Golub 	uio.uio_iovcnt = 1;
1492c5cfcb1cSMikolaj Golub 	uio.uio_offset = offset;
1493c5cfcb1cSMikolaj Golub 	uio.uio_resid = (ssize_t)len;
1494c5cfcb1cSMikolaj Golub 	uio.uio_segflg = UIO_SYSSPACE;
1495c5cfcb1cSMikolaj Golub 	uio.uio_rw = UIO_READ;
1496c5cfcb1cSMikolaj Golub 	uio.uio_td = td;
1497c5cfcb1cSMikolaj Golub 
1498c5cfcb1cSMikolaj Golub 	return (proc_rwmem(p, &uio));
1499c5cfcb1cSMikolaj Golub }
1500c5cfcb1cSMikolaj Golub 
1501c5cfcb1cSMikolaj Golub static int
1502c5cfcb1cSMikolaj Golub proc_read_string(struct thread *td, struct proc *p, const char *sptr, char *buf,
1503c5cfcb1cSMikolaj Golub     size_t len)
1504c5cfcb1cSMikolaj Golub {
1505c5cfcb1cSMikolaj Golub 	size_t i;
1506c5cfcb1cSMikolaj Golub 	int error;
1507c5cfcb1cSMikolaj Golub 
1508c5cfcb1cSMikolaj Golub 	error = proc_read_mem(td, p, (vm_offset_t)sptr, buf, len);
1509c5cfcb1cSMikolaj Golub 	/*
1510c5cfcb1cSMikolaj Golub 	 * Reading the chunk may validly return EFAULT if the string is shorter
1511c5cfcb1cSMikolaj Golub 	 * than the chunk and is aligned at the end of the page, assuming the
1512c5cfcb1cSMikolaj Golub 	 * next page is not mapped.  So if EFAULT is returned do a fallback to
1513c5cfcb1cSMikolaj Golub 	 * one byte read loop.
1514c5cfcb1cSMikolaj Golub 	 */
1515c5cfcb1cSMikolaj Golub 	if (error == EFAULT) {
1516c5cfcb1cSMikolaj Golub 		for (i = 0; i < len; i++, buf++, sptr++) {
1517c5cfcb1cSMikolaj Golub 			error = proc_read_mem(td, p, (vm_offset_t)sptr, buf, 1);
1518c5cfcb1cSMikolaj Golub 			if (error != 0)
1519c5cfcb1cSMikolaj Golub 				return (error);
1520c5cfcb1cSMikolaj Golub 			if (*buf == '\0')
1521c5cfcb1cSMikolaj Golub 				break;
1522c5cfcb1cSMikolaj Golub 		}
1523c5cfcb1cSMikolaj Golub 		error = 0;
1524c5cfcb1cSMikolaj Golub 	}
1525c5cfcb1cSMikolaj Golub 	return (error);
1526c5cfcb1cSMikolaj Golub }
1527c5cfcb1cSMikolaj Golub 
1528c5cfcb1cSMikolaj Golub #define PROC_AUXV_MAX	256	/* Safety limit on auxv size. */
1529c5cfcb1cSMikolaj Golub 
1530c5cfcb1cSMikolaj Golub enum proc_vector_type {
1531c5cfcb1cSMikolaj Golub 	PROC_ARG,
1532c5cfcb1cSMikolaj Golub 	PROC_ENV,
1533c5cfcb1cSMikolaj Golub 	PROC_AUX,
1534c5cfcb1cSMikolaj Golub };
1535c5cfcb1cSMikolaj Golub 
1536c5cfcb1cSMikolaj Golub #ifdef COMPAT_FREEBSD32
1537c5cfcb1cSMikolaj Golub static int
1538c5cfcb1cSMikolaj Golub get_proc_vector32(struct thread *td, struct proc *p, char ***proc_vectorp,
1539c5cfcb1cSMikolaj Golub     size_t *vsizep, enum proc_vector_type type)
1540c5cfcb1cSMikolaj Golub {
1541c5cfcb1cSMikolaj Golub 	struct freebsd32_ps_strings pss;
1542c5cfcb1cSMikolaj Golub 	Elf32_Auxinfo aux;
1543c5cfcb1cSMikolaj Golub 	vm_offset_t vptr, ptr;
1544c5cfcb1cSMikolaj Golub 	uint32_t *proc_vector32;
1545c5cfcb1cSMikolaj Golub 	char **proc_vector;
1546c5cfcb1cSMikolaj Golub 	size_t vsize, size;
1547c5cfcb1cSMikolaj Golub 	int i, error;
1548c5cfcb1cSMikolaj Golub 
1549c5cfcb1cSMikolaj Golub 	error = proc_read_mem(td, p, (vm_offset_t)(p->p_sysent->sv_psstrings),
1550c5cfcb1cSMikolaj Golub 	    &pss, sizeof(pss));
1551c5cfcb1cSMikolaj Golub 	if (error != 0)
1552c5cfcb1cSMikolaj Golub 		return (error);
1553c5cfcb1cSMikolaj Golub 	switch (type) {
1554c5cfcb1cSMikolaj Golub 	case PROC_ARG:
1555c5cfcb1cSMikolaj Golub 		vptr = (vm_offset_t)PTRIN(pss.ps_argvstr);
1556c5cfcb1cSMikolaj Golub 		vsize = pss.ps_nargvstr;
1557c5cfcb1cSMikolaj Golub 		if (vsize > ARG_MAX)
1558c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1559c5cfcb1cSMikolaj Golub 		size = vsize * sizeof(int32_t);
1560c5cfcb1cSMikolaj Golub 		break;
1561c5cfcb1cSMikolaj Golub 	case PROC_ENV:
1562c5cfcb1cSMikolaj Golub 		vptr = (vm_offset_t)PTRIN(pss.ps_envstr);
1563c5cfcb1cSMikolaj Golub 		vsize = pss.ps_nenvstr;
1564c5cfcb1cSMikolaj Golub 		if (vsize > ARG_MAX)
1565c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1566c5cfcb1cSMikolaj Golub 		size = vsize * sizeof(int32_t);
1567c5cfcb1cSMikolaj Golub 		break;
1568c5cfcb1cSMikolaj Golub 	case PROC_AUX:
1569c5cfcb1cSMikolaj Golub 		vptr = (vm_offset_t)PTRIN(pss.ps_envstr) +
1570c5cfcb1cSMikolaj Golub 		    (pss.ps_nenvstr + 1) * sizeof(int32_t);
1571c5cfcb1cSMikolaj Golub 		if (vptr % 4 != 0)
1572c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1573c5cfcb1cSMikolaj Golub 		for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
1574c5cfcb1cSMikolaj Golub 			error = proc_read_mem(td, p, ptr, &aux, sizeof(aux));
1575c5cfcb1cSMikolaj Golub 			if (error != 0)
1576c5cfcb1cSMikolaj Golub 				return (error);
1577c5cfcb1cSMikolaj Golub 			if (aux.a_type == AT_NULL)
1578c5cfcb1cSMikolaj Golub 				break;
1579c5cfcb1cSMikolaj Golub 			ptr += sizeof(aux);
1580c5cfcb1cSMikolaj Golub 		}
1581c5cfcb1cSMikolaj Golub 		if (aux.a_type != AT_NULL)
1582c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1583c5cfcb1cSMikolaj Golub 		vsize = i + 1;
1584c5cfcb1cSMikolaj Golub 		size = vsize * sizeof(aux);
1585c5cfcb1cSMikolaj Golub 		break;
1586c5cfcb1cSMikolaj Golub 	default:
1587c5cfcb1cSMikolaj Golub 		KASSERT(0, ("Wrong proc vector type: %d", type));
15887ad9baaeSMikolaj Golub 		return (EINVAL);
1589c5cfcb1cSMikolaj Golub 	}
1590c5cfcb1cSMikolaj Golub 	proc_vector32 = malloc(size, M_TEMP, M_WAITOK);
1591c5cfcb1cSMikolaj Golub 	error = proc_read_mem(td, p, vptr, proc_vector32, size);
1592c5cfcb1cSMikolaj Golub 	if (error != 0)
1593c5cfcb1cSMikolaj Golub 		goto done;
1594c5cfcb1cSMikolaj Golub 	if (type == PROC_AUX) {
1595c5cfcb1cSMikolaj Golub 		*proc_vectorp = (char **)proc_vector32;
1596c5cfcb1cSMikolaj Golub 		*vsizep = vsize;
1597c5cfcb1cSMikolaj Golub 		return (0);
1598c5cfcb1cSMikolaj Golub 	}
1599c5cfcb1cSMikolaj Golub 	proc_vector = malloc(vsize * sizeof(char *), M_TEMP, M_WAITOK);
1600c5cfcb1cSMikolaj Golub 	for (i = 0; i < (int)vsize; i++)
1601c5cfcb1cSMikolaj Golub 		proc_vector[i] = PTRIN(proc_vector32[i]);
1602c5cfcb1cSMikolaj Golub 	*proc_vectorp = proc_vector;
1603c5cfcb1cSMikolaj Golub 	*vsizep = vsize;
1604c5cfcb1cSMikolaj Golub done:
1605c5cfcb1cSMikolaj Golub 	free(proc_vector32, M_TEMP);
1606c5cfcb1cSMikolaj Golub 	return (error);
1607c5cfcb1cSMikolaj Golub }
1608c5cfcb1cSMikolaj Golub #endif
1609c5cfcb1cSMikolaj Golub 
1610c5cfcb1cSMikolaj Golub static int
1611c5cfcb1cSMikolaj Golub get_proc_vector(struct thread *td, struct proc *p, char ***proc_vectorp,
1612c5cfcb1cSMikolaj Golub     size_t *vsizep, enum proc_vector_type type)
1613c5cfcb1cSMikolaj Golub {
1614c5cfcb1cSMikolaj Golub 	struct ps_strings pss;
1615c5cfcb1cSMikolaj Golub 	Elf_Auxinfo aux;
1616c5cfcb1cSMikolaj Golub 	vm_offset_t vptr, ptr;
1617c5cfcb1cSMikolaj Golub 	char **proc_vector;
1618c5cfcb1cSMikolaj Golub 	size_t vsize, size;
1619c5cfcb1cSMikolaj Golub 	int error, i;
1620c5cfcb1cSMikolaj Golub 
1621c5cfcb1cSMikolaj Golub #ifdef COMPAT_FREEBSD32
1622c5cfcb1cSMikolaj Golub 	if (SV_PROC_FLAG(p, SV_ILP32) != 0)
1623c5cfcb1cSMikolaj Golub 		return (get_proc_vector32(td, p, proc_vectorp, vsizep, type));
1624c5cfcb1cSMikolaj Golub #endif
1625c5cfcb1cSMikolaj Golub 	error = proc_read_mem(td, p, (vm_offset_t)(p->p_sysent->sv_psstrings),
1626c5cfcb1cSMikolaj Golub 	    &pss, sizeof(pss));
1627c5cfcb1cSMikolaj Golub 	if (error != 0)
1628c5cfcb1cSMikolaj Golub 		return (error);
1629c5cfcb1cSMikolaj Golub 	switch (type) {
1630c5cfcb1cSMikolaj Golub 	case PROC_ARG:
1631c5cfcb1cSMikolaj Golub 		vptr = (vm_offset_t)pss.ps_argvstr;
1632c5cfcb1cSMikolaj Golub 		vsize = pss.ps_nargvstr;
1633c5cfcb1cSMikolaj Golub 		if (vsize > ARG_MAX)
1634c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1635c5cfcb1cSMikolaj Golub 		size = vsize * sizeof(char *);
1636c5cfcb1cSMikolaj Golub 		break;
1637c5cfcb1cSMikolaj Golub 	case PROC_ENV:
1638c5cfcb1cSMikolaj Golub 		vptr = (vm_offset_t)pss.ps_envstr;
1639c5cfcb1cSMikolaj Golub 		vsize = pss.ps_nenvstr;
1640c5cfcb1cSMikolaj Golub 		if (vsize > ARG_MAX)
1641c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1642c5cfcb1cSMikolaj Golub 		size = vsize * sizeof(char *);
1643c5cfcb1cSMikolaj Golub 		break;
1644c5cfcb1cSMikolaj Golub 	case PROC_AUX:
1645c5cfcb1cSMikolaj Golub 		/*
1646c5cfcb1cSMikolaj Golub 		 * The aux array is just above env array on the stack. Check
1647c5cfcb1cSMikolaj Golub 		 * that the address is naturally aligned.
1648c5cfcb1cSMikolaj Golub 		 */
1649c5cfcb1cSMikolaj Golub 		vptr = (vm_offset_t)pss.ps_envstr + (pss.ps_nenvstr + 1)
1650c5cfcb1cSMikolaj Golub 		    * sizeof(char *);
1651c5cfcb1cSMikolaj Golub #if __ELF_WORD_SIZE == 64
1652c5cfcb1cSMikolaj Golub 		if (vptr % sizeof(uint64_t) != 0)
1653c5cfcb1cSMikolaj Golub #else
1654c5cfcb1cSMikolaj Golub 		if (vptr % sizeof(uint32_t) != 0)
1655c5cfcb1cSMikolaj Golub #endif
1656c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1657c5cfcb1cSMikolaj Golub 		/*
1658c5cfcb1cSMikolaj Golub 		 * We count the array size reading the aux vectors from the
1659c5cfcb1cSMikolaj Golub 		 * stack until AT_NULL vector is returned.  So (to keep the code
1660c5cfcb1cSMikolaj Golub 		 * simple) we read the process stack twice: the first time here
1661c5cfcb1cSMikolaj Golub 		 * to find the size and the second time when copying the vectors
1662c5cfcb1cSMikolaj Golub 		 * to the allocated proc_vector.
1663c5cfcb1cSMikolaj Golub 		 */
1664c5cfcb1cSMikolaj Golub 		for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
1665c5cfcb1cSMikolaj Golub 			error = proc_read_mem(td, p, ptr, &aux, sizeof(aux));
1666c5cfcb1cSMikolaj Golub 			if (error != 0)
1667c5cfcb1cSMikolaj Golub 				return (error);
1668c5cfcb1cSMikolaj Golub 			if (aux.a_type == AT_NULL)
1669c5cfcb1cSMikolaj Golub 				break;
1670c5cfcb1cSMikolaj Golub 			ptr += sizeof(aux);
1671c5cfcb1cSMikolaj Golub 		}
1672c5cfcb1cSMikolaj Golub 		/*
1673c5cfcb1cSMikolaj Golub 		 * If the PROC_AUXV_MAX entries are iterated over, and we have
1674c5cfcb1cSMikolaj Golub 		 * not reached AT_NULL, it is most likely we are reading wrong
1675c5cfcb1cSMikolaj Golub 		 * data: either the process doesn't have auxv array or data has
1676c5cfcb1cSMikolaj Golub 		 * been modified. Return the error in this case.
1677c5cfcb1cSMikolaj Golub 		 */
1678c5cfcb1cSMikolaj Golub 		if (aux.a_type != AT_NULL)
1679c5cfcb1cSMikolaj Golub 			return (ENOEXEC);
1680c5cfcb1cSMikolaj Golub 		vsize = i + 1;
1681c5cfcb1cSMikolaj Golub 		size = vsize * sizeof(aux);
1682c5cfcb1cSMikolaj Golub 		break;
1683c5cfcb1cSMikolaj Golub 	default:
1684c5cfcb1cSMikolaj Golub 		KASSERT(0, ("Wrong proc vector type: %d", type));
16857ad9baaeSMikolaj Golub 		return (EINVAL); /* In case we are built without INVARIANTS. */
1686c5cfcb1cSMikolaj Golub 	}
1687c5cfcb1cSMikolaj Golub 	proc_vector = malloc(size, M_TEMP, M_WAITOK);
1688c5cfcb1cSMikolaj Golub 	if (proc_vector == NULL)
1689c5cfcb1cSMikolaj Golub 		return (ENOMEM);
1690c5cfcb1cSMikolaj Golub 	error = proc_read_mem(td, p, vptr, proc_vector, size);
1691c5cfcb1cSMikolaj Golub 	if (error != 0) {
1692c5cfcb1cSMikolaj Golub 		free(proc_vector, M_TEMP);
1693c5cfcb1cSMikolaj Golub 		return (error);
1694c5cfcb1cSMikolaj Golub 	}
1695c5cfcb1cSMikolaj Golub 	*proc_vectorp = proc_vector;
1696c5cfcb1cSMikolaj Golub 	*vsizep = vsize;
1697c5cfcb1cSMikolaj Golub 
1698c5cfcb1cSMikolaj Golub 	return (0);
1699c5cfcb1cSMikolaj Golub }
1700c5cfcb1cSMikolaj Golub 
1701c5cfcb1cSMikolaj Golub #define GET_PS_STRINGS_CHUNK_SZ	256	/* Chunk size (bytes) for ps_strings operations. */
1702c5cfcb1cSMikolaj Golub 
1703c5cfcb1cSMikolaj Golub static int
1704c5cfcb1cSMikolaj Golub get_ps_strings(struct thread *td, struct proc *p, struct sbuf *sb,
1705fe7f89b7SMikolaj Golub     enum proc_vector_type type)
1706c5cfcb1cSMikolaj Golub {
1707fe7f89b7SMikolaj Golub 	size_t done, len, nchr, vsize;
1708c5cfcb1cSMikolaj Golub 	int error, i;
1709c5cfcb1cSMikolaj Golub 	char **proc_vector, *sptr;
1710c5cfcb1cSMikolaj Golub 	char pss_string[GET_PS_STRINGS_CHUNK_SZ];
1711c5cfcb1cSMikolaj Golub 
1712c5cfcb1cSMikolaj Golub 	PROC_ASSERT_HELD(p);
1713c5cfcb1cSMikolaj Golub 
1714c5cfcb1cSMikolaj Golub 	/*
1715c5cfcb1cSMikolaj Golub 	 * We are not going to read more than 2 * (PATH_MAX + ARG_MAX) bytes.
1716c5cfcb1cSMikolaj Golub 	 */
1717c5cfcb1cSMikolaj Golub 	nchr = 2 * (PATH_MAX + ARG_MAX);
1718c5cfcb1cSMikolaj Golub 
1719c5cfcb1cSMikolaj Golub 	error = get_proc_vector(td, p, &proc_vector, &vsize, type);
1720c5cfcb1cSMikolaj Golub 	if (error != 0)
1721c5cfcb1cSMikolaj Golub 		return (error);
1722c5cfcb1cSMikolaj Golub 	for (done = 0, i = 0; i < (int)vsize && done < nchr; i++) {
1723c5cfcb1cSMikolaj Golub 		/*
1724c5cfcb1cSMikolaj Golub 		 * The program may have scribbled into its argv array, e.g. to
1725c5cfcb1cSMikolaj Golub 		 * remove some arguments.  If that has happened, break out
1726c5cfcb1cSMikolaj Golub 		 * before trying to read from NULL.
1727c5cfcb1cSMikolaj Golub 		 */
1728c5cfcb1cSMikolaj Golub 		if (proc_vector[i] == NULL)
1729c5cfcb1cSMikolaj Golub 			break;
1730c5cfcb1cSMikolaj Golub 		for (sptr = proc_vector[i]; ; sptr += GET_PS_STRINGS_CHUNK_SZ) {
1731c5cfcb1cSMikolaj Golub 			error = proc_read_string(td, p, sptr, pss_string,
1732c5cfcb1cSMikolaj Golub 			    sizeof(pss_string));
1733c5cfcb1cSMikolaj Golub 			if (error != 0)
1734c5cfcb1cSMikolaj Golub 				goto done;
1735c5cfcb1cSMikolaj Golub 			len = strnlen(pss_string, GET_PS_STRINGS_CHUNK_SZ);
1736c5cfcb1cSMikolaj Golub 			if (done + len >= nchr)
1737c5cfcb1cSMikolaj Golub 				len = nchr - done - 1;
1738c5cfcb1cSMikolaj Golub 			sbuf_bcat(sb, pss_string, len);
1739c5cfcb1cSMikolaj Golub 			if (len != GET_PS_STRINGS_CHUNK_SZ)
1740c5cfcb1cSMikolaj Golub 				break;
1741c5cfcb1cSMikolaj Golub 			done += GET_PS_STRINGS_CHUNK_SZ;
1742c5cfcb1cSMikolaj Golub 		}
1743c5cfcb1cSMikolaj Golub 		sbuf_bcat(sb, "", 1);
1744c5cfcb1cSMikolaj Golub 		done += len + 1;
1745c5cfcb1cSMikolaj Golub 	}
1746c5cfcb1cSMikolaj Golub done:
1747c5cfcb1cSMikolaj Golub 	free(proc_vector, M_TEMP);
1748c5cfcb1cSMikolaj Golub 	return (error);
1749c5cfcb1cSMikolaj Golub }
1750c5cfcb1cSMikolaj Golub 
1751c5cfcb1cSMikolaj Golub int
1752fe7f89b7SMikolaj Golub proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb)
1753c5cfcb1cSMikolaj Golub {
1754c5cfcb1cSMikolaj Golub 
1755fe7f89b7SMikolaj Golub 	return (get_ps_strings(curthread, p, sb, PROC_ARG));
1756c5cfcb1cSMikolaj Golub }
1757c5cfcb1cSMikolaj Golub 
1758c5cfcb1cSMikolaj Golub int
1759fe7f89b7SMikolaj Golub proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb)
1760c5cfcb1cSMikolaj Golub {
1761c5cfcb1cSMikolaj Golub 
1762fe7f89b7SMikolaj Golub 	return (get_ps_strings(curthread, p, sb, PROC_ENV));
1763c5cfcb1cSMikolaj Golub }
1764c5cfcb1cSMikolaj Golub 
17655ea21e69SMikolaj Golub int
17665ea21e69SMikolaj Golub proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb)
17675ea21e69SMikolaj Golub {
17685ea21e69SMikolaj Golub 	size_t vsize, size;
17695ea21e69SMikolaj Golub 	char **auxv;
17705ea21e69SMikolaj Golub 	int error;
17715ea21e69SMikolaj Golub 
17725ea21e69SMikolaj Golub 	error = get_proc_vector(td, p, &auxv, &vsize, PROC_AUX);
17735ea21e69SMikolaj Golub 	if (error == 0) {
17745ea21e69SMikolaj Golub #ifdef COMPAT_FREEBSD32
17755ea21e69SMikolaj Golub 		if (SV_PROC_FLAG(p, SV_ILP32) != 0)
17765ea21e69SMikolaj Golub 			size = vsize * sizeof(Elf32_Auxinfo);
17775ea21e69SMikolaj Golub 		else
17785ea21e69SMikolaj Golub #endif
17795ea21e69SMikolaj Golub 			size = vsize * sizeof(Elf_Auxinfo);
17805ea21e69SMikolaj Golub 		error = sbuf_bcat(sb, auxv, size);
17815ea21e69SMikolaj Golub 		free(auxv, M_TEMP);
17825ea21e69SMikolaj Golub 	}
17835ea21e69SMikolaj Golub 	return (error);
17845ea21e69SMikolaj Golub }
17855ea21e69SMikolaj Golub 
1786b9df5231SPoul-Henning Kamp /*
1787b9df5231SPoul-Henning Kamp  * This sysctl allows a process to retrieve the argument list or process
1788b9df5231SPoul-Henning Kamp  * title for another process without groping around in the address space
1789b9df5231SPoul-Henning Kamp  * of the other process.  It also allow a process to set its own "process
1790b9df5231SPoul-Henning Kamp  * title to a string of its own choice.
1791b9df5231SPoul-Henning Kamp  */
1792b9df5231SPoul-Henning Kamp static int
179382d9ae4eSPoul-Henning Kamp sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
1794b9df5231SPoul-Henning Kamp {
1795b9df5231SPoul-Henning Kamp 	int *name = (int *)arg1;
1796b9df5231SPoul-Henning Kamp 	u_int namelen = arg2;
17978510f2a8SJohn Baldwin 	struct pargs *newpa, *pa;
1798b9df5231SPoul-Henning Kamp 	struct proc *p;
1799c5cfcb1cSMikolaj Golub 	struct sbuf sb;
1800fa3935bcSMikolaj Golub 	int flags, error = 0, error2;
1801b9df5231SPoul-Henning Kamp 
1802b9df5231SPoul-Henning Kamp 	if (namelen != 1)
1803b9df5231SPoul-Henning Kamp 		return (EINVAL);
1804b9df5231SPoul-Henning Kamp 
1805fa3935bcSMikolaj Golub 	flags = PGET_CANSEE;
1806fa3935bcSMikolaj Golub 	if (req->newptr != NULL)
1807fa3935bcSMikolaj Golub 		flags |= PGET_ISCURRENT;
1808fa3935bcSMikolaj Golub 	error = pget((pid_t)name[0], flags, &p);
1809fa3935bcSMikolaj Golub 	if (error)
1810e76bad96SRobert Drehmel 		return (error);
1811b9df5231SPoul-Henning Kamp 
18127b11fea6SAlfred Perlstein 	pa = p->p_args;
1813c5cfcb1cSMikolaj Golub 	if (pa != NULL) {
18147b11fea6SAlfred Perlstein 		pargs_hold(pa);
18157b11fea6SAlfred Perlstein 		PROC_UNLOCK(p);
18167b11fea6SAlfred Perlstein 		error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length);
18177b11fea6SAlfred Perlstein 		pargs_drop(pa);
1818c5cfcb1cSMikolaj Golub 	} else if ((p->p_flag & (P_WEXIT | P_SYSTEM)) == 0) {
1819c5cfcb1cSMikolaj Golub 		_PHOLD(p);
1820c5cfcb1cSMikolaj Golub 		PROC_UNLOCK(p);
1821c5cfcb1cSMikolaj Golub 		sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
1822fe7f89b7SMikolaj Golub 		error = proc_getargv(curthread, p, &sb);
1823c5cfcb1cSMikolaj Golub 		error2 = sbuf_finish(&sb);
1824c5cfcb1cSMikolaj Golub 		PRELE(p);
1825c5cfcb1cSMikolaj Golub 		sbuf_delete(&sb);
1826c5cfcb1cSMikolaj Golub 		if (error == 0 && error2 != 0)
1827c5cfcb1cSMikolaj Golub 			error = error2;
1828c5cfcb1cSMikolaj Golub 	} else {
1829c5cfcb1cSMikolaj Golub 		PROC_UNLOCK(p);
1830c5cfcb1cSMikolaj Golub 	}
18318510f2a8SJohn Baldwin 	if (error != 0 || req->newptr == NULL)
1832b9df5231SPoul-Henning Kamp 		return (error);
1833b9df5231SPoul-Henning Kamp 
1834b9df5231SPoul-Henning Kamp 	if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit)
18358510f2a8SJohn Baldwin 		return (ENOMEM);
18364bc6471bSJohn Baldwin 	newpa = pargs_alloc(req->newlen);
18374bc6471bSJohn Baldwin 	error = SYSCTL_IN(req, newpa->ar_args, req->newlen);
18388510f2a8SJohn Baldwin 	if (error != 0) {
18394bc6471bSJohn Baldwin 		pargs_free(newpa);
1840b9df5231SPoul-Henning Kamp 		return (error);
1841b9df5231SPoul-Henning Kamp 	}
18424bc6471bSJohn Baldwin 	PROC_LOCK(p);
18434bc6471bSJohn Baldwin 	pa = p->p_args;
18444bc6471bSJohn Baldwin 	p->p_args = newpa;
18454bc6471bSJohn Baldwin 	PROC_UNLOCK(p);
18464bc6471bSJohn Baldwin 	pargs_drop(pa);
18474bc6471bSJohn Baldwin 	return (0);
18484bc6471bSJohn Baldwin }
18494bc6471bSJohn Baldwin 
1850fe769cddSDavid Schultz /*
1851c5cfcb1cSMikolaj Golub  * This sysctl allows a process to retrieve environment of another process.
1852c5cfcb1cSMikolaj Golub  */
1853c5cfcb1cSMikolaj Golub static int
1854c5cfcb1cSMikolaj Golub sysctl_kern_proc_env(SYSCTL_HANDLER_ARGS)
1855c5cfcb1cSMikolaj Golub {
1856c5cfcb1cSMikolaj Golub 	int *name = (int *)arg1;
1857c5cfcb1cSMikolaj Golub 	u_int namelen = arg2;
1858c5cfcb1cSMikolaj Golub 	struct proc *p;
1859c5cfcb1cSMikolaj Golub 	struct sbuf sb;
1860c5cfcb1cSMikolaj Golub 	int error, error2;
1861c5cfcb1cSMikolaj Golub 
1862c5cfcb1cSMikolaj Golub 	if (namelen != 1)
1863c5cfcb1cSMikolaj Golub 		return (EINVAL);
1864c5cfcb1cSMikolaj Golub 
1865fa3935bcSMikolaj Golub 	error = pget((pid_t)name[0], PGET_WANTREAD, &p);
1866fa3935bcSMikolaj Golub 	if (error != 0)
1867c5cfcb1cSMikolaj Golub 		return (error);
1868c5cfcb1cSMikolaj Golub 	if ((p->p_flag & P_SYSTEM) != 0) {
1869fa3935bcSMikolaj Golub 		PRELE(p);
1870c5cfcb1cSMikolaj Golub 		return (0);
1871c5cfcb1cSMikolaj Golub 	}
1872fa3935bcSMikolaj Golub 
1873c5cfcb1cSMikolaj Golub 	sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
1874fe7f89b7SMikolaj Golub 	error = proc_getenvv(curthread, p, &sb);
1875c5cfcb1cSMikolaj Golub 	error2 = sbuf_finish(&sb);
1876c5cfcb1cSMikolaj Golub 	PRELE(p);
1877c5cfcb1cSMikolaj Golub 	sbuf_delete(&sb);
1878c5cfcb1cSMikolaj Golub 	return (error != 0 ? error : error2);
1879c5cfcb1cSMikolaj Golub }
1880c5cfcb1cSMikolaj Golub 
1881c5cfcb1cSMikolaj Golub /*
1882c5cfcb1cSMikolaj Golub  * This sysctl allows a process to retrieve ELF auxiliary vector of
1883c5cfcb1cSMikolaj Golub  * another process.
1884c5cfcb1cSMikolaj Golub  */
1885c5cfcb1cSMikolaj Golub static int
1886c5cfcb1cSMikolaj Golub sysctl_kern_proc_auxv(SYSCTL_HANDLER_ARGS)
1887c5cfcb1cSMikolaj Golub {
1888c5cfcb1cSMikolaj Golub 	int *name = (int *)arg1;
1889c5cfcb1cSMikolaj Golub 	u_int namelen = arg2;
1890c5cfcb1cSMikolaj Golub 	struct proc *p;
18915ea21e69SMikolaj Golub 	struct sbuf sb;
18925ea21e69SMikolaj Golub 	int error, error2;
1893c5cfcb1cSMikolaj Golub 
1894c5cfcb1cSMikolaj Golub 	if (namelen != 1)
1895c5cfcb1cSMikolaj Golub 		return (EINVAL);
1896c5cfcb1cSMikolaj Golub 
1897fa3935bcSMikolaj Golub 	error = pget((pid_t)name[0], PGET_WANTREAD, &p);
1898fa3935bcSMikolaj Golub 	if (error != 0)
1899c5cfcb1cSMikolaj Golub 		return (error);
1900c5cfcb1cSMikolaj Golub 	if ((p->p_flag & P_SYSTEM) != 0) {
1901fa3935bcSMikolaj Golub 		PRELE(p);
1902c5cfcb1cSMikolaj Golub 		return (0);
1903c5cfcb1cSMikolaj Golub 	}
19045ea21e69SMikolaj Golub 	sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
19055ea21e69SMikolaj Golub 	error = proc_getauxv(curthread, p, &sb);
19065ea21e69SMikolaj Golub 	error2 = sbuf_finish(&sb);
19074fd6053bSMikolaj Golub 	PRELE(p);
19085ea21e69SMikolaj Golub 	sbuf_delete(&sb);
19095ea21e69SMikolaj Golub 	return (error != 0 ? error : error2);
1910c5cfcb1cSMikolaj Golub }
1911c5cfcb1cSMikolaj Golub 
1912c5cfcb1cSMikolaj Golub /*
1913fe769cddSDavid Schultz  * This sysctl allows a process to retrieve the path of the executable for
1914fe769cddSDavid Schultz  * itself or another process.
1915fe769cddSDavid Schultz  */
1916fe769cddSDavid Schultz static int
1917fe769cddSDavid Schultz sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS)
1918fe769cddSDavid Schultz {
1919fe769cddSDavid Schultz 	pid_t *pidp = (pid_t *)arg1;
1920fe769cddSDavid Schultz 	unsigned int arglen = arg2;
1921fe769cddSDavid Schultz 	struct proc *p;
1922fe769cddSDavid Schultz 	struct vnode *vp;
1923fe769cddSDavid Schultz 	char *retbuf, *freebuf;
19245050aa86SKonstantin Belousov 	int error;
1925fe769cddSDavid Schultz 
1926fe769cddSDavid Schultz 	if (arglen != 1)
1927fe769cddSDavid Schultz 		return (EINVAL);
1928fe769cddSDavid Schultz 	if (*pidp == -1) {	/* -1 means this process */
1929fe769cddSDavid Schultz 		p = req->td->td_proc;
1930fe769cddSDavid Schultz 	} else {
1931fa3935bcSMikolaj Golub 		error = pget(*pidp, PGET_CANSEE, &p);
1932fa3935bcSMikolaj Golub 		if (error != 0)
1933fe769cddSDavid Schultz 			return (error);
1934fe769cddSDavid Schultz 	}
1935fe769cddSDavid Schultz 
1936fe769cddSDavid Schultz 	vp = p->p_textvp;
1937965b55e2SRobert Watson 	if (vp == NULL) {
1938965b55e2SRobert Watson 		if (*pidp != -1)
1939965b55e2SRobert Watson 			PROC_UNLOCK(p);
1940965b55e2SRobert Watson 		return (0);
1941965b55e2SRobert Watson 	}
1942fe769cddSDavid Schultz 	vref(vp);
1943fe769cddSDavid Schultz 	if (*pidp != -1)
1944fe769cddSDavid Schultz 		PROC_UNLOCK(p);
1945fe769cddSDavid Schultz 	error = vn_fullpath(req->td, vp, &retbuf, &freebuf);
1946fe769cddSDavid Schultz 	vrele(vp);
1947fe769cddSDavid Schultz 	if (error)
1948fe769cddSDavid Schultz 		return (error);
1949fe769cddSDavid Schultz 	error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1);
1950fe769cddSDavid Schultz 	free(freebuf, M_TEMP);
1951fe769cddSDavid Schultz 	return (error);
1952fe769cddSDavid Schultz }
1953fe769cddSDavid Schultz 
1954baf731e6SRobert Drehmel static int
1955baf731e6SRobert Drehmel sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS)
1956baf731e6SRobert Drehmel {
1957baf731e6SRobert Drehmel 	struct proc *p;
1958baf731e6SRobert Drehmel 	char *sv_name;
1959baf731e6SRobert Drehmel 	int *name;
1960baf731e6SRobert Drehmel 	int namelen;
1961e76bad96SRobert Drehmel 	int error;
1962baf731e6SRobert Drehmel 
1963baf731e6SRobert Drehmel 	namelen = arg2;
1964baf731e6SRobert Drehmel 	if (namelen != 1)
1965baf731e6SRobert Drehmel 		return (EINVAL);
1966baf731e6SRobert Drehmel 
1967baf731e6SRobert Drehmel 	name = (int *)arg1;
1968fa3935bcSMikolaj Golub 	error = pget((pid_t)name[0], PGET_CANSEE, &p);
1969fa3935bcSMikolaj Golub 	if (error != 0)
1970e76bad96SRobert Drehmel 		return (error);
1971baf731e6SRobert Drehmel 	sv_name = p->p_sysent->sv_name;
1972baf731e6SRobert Drehmel 	PROC_UNLOCK(p);
1973baf731e6SRobert Drehmel 	return (sysctl_handle_string(oidp, sv_name, 0, req));
1974baf731e6SRobert Drehmel }
1975baf731e6SRobert Drehmel 
197643151ee6SPeter Wemm #ifdef KINFO_OVMENTRY_SIZE
197743151ee6SPeter Wemm CTASSERT(sizeof(struct kinfo_ovmentry) == KINFO_OVMENTRY_SIZE);
197843151ee6SPeter Wemm #endif
197943151ee6SPeter Wemm 
198043151ee6SPeter Wemm #ifdef COMPAT_FREEBSD7
1981cc43c38cSRobert Watson static int
198243151ee6SPeter Wemm sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_ARGS)
1983cc43c38cSRobert Watson {
1984cc43c38cSRobert Watson 	vm_map_entry_t entry, tmp_entry;
1985cc43c38cSRobert Watson 	unsigned int last_timestamp;
1986cc43c38cSRobert Watson 	char *fullpath, *freepath;
198743151ee6SPeter Wemm 	struct kinfo_ovmentry *kve;
19887a9c4d24SPeter Wemm 	struct vattr va;
19897a9c4d24SPeter Wemm 	struct ucred *cred;
1990cc43c38cSRobert Watson 	int error, *name;
1991cc43c38cSRobert Watson 	struct vnode *vp;
1992cc43c38cSRobert Watson 	struct proc *p;
1993cc43c38cSRobert Watson 	vm_map_t map;
1994c7462f43SKonstantin Belousov 	struct vmspace *vm;
1995baf731e6SRobert Drehmel 
1996cc43c38cSRobert Watson 	name = (int *)arg1;
1997fa3935bcSMikolaj Golub 	error = pget((pid_t)name[0], PGET_WANTREAD, &p);
1998fa3935bcSMikolaj Golub 	if (error != 0)
1999cc43c38cSRobert Watson 		return (error);
2000c7462f43SKonstantin Belousov 	vm = vmspace_acquire_ref(p);
2001c7462f43SKonstantin Belousov 	if (vm == NULL) {
2002c7462f43SKonstantin Belousov 		PRELE(p);
2003c7462f43SKonstantin Belousov 		return (ESRCH);
2004c7462f43SKonstantin Belousov 	}
2005cc43c38cSRobert Watson 	kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK);
2006cc43c38cSRobert Watson 
2007ca4aa8c3SSergey Kandaurov 	map = &vm->vm_map;
2008cc43c38cSRobert Watson 	vm_map_lock_read(map);
2009cc43c38cSRobert Watson 	for (entry = map->header.next; entry != &map->header;
2010cc43c38cSRobert Watson 	    entry = entry->next) {
2011cc43c38cSRobert Watson 		vm_object_t obj, tobj, lobj;
2012cc43c38cSRobert Watson 		vm_offset_t addr;
2013cc43c38cSRobert Watson 
2014cc43c38cSRobert Watson 		if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
2015cc43c38cSRobert Watson 			continue;
2016cc43c38cSRobert Watson 
2017cc43c38cSRobert Watson 		bzero(kve, sizeof(*kve));
2018cc43c38cSRobert Watson 		kve->kve_structsize = sizeof(*kve);
2019cc43c38cSRobert Watson 
2020cc43c38cSRobert Watson 		kve->kve_private_resident = 0;
2021cc43c38cSRobert Watson 		obj = entry->object.vm_object;
2022cc43c38cSRobert Watson 		if (obj != NULL) {
2023bc403f03SAttilio Rao 			VM_OBJECT_RLOCK(obj);
2024cc43c38cSRobert Watson 			if (obj->shadow_count == 1)
2025cc43c38cSRobert Watson 				kve->kve_private_resident =
2026cc43c38cSRobert Watson 				    obj->resident_page_count;
2027cc43c38cSRobert Watson 		}
2028cc43c38cSRobert Watson 		kve->kve_resident = 0;
2029cc43c38cSRobert Watson 		addr = entry->start;
2030cc43c38cSRobert Watson 		while (addr < entry->end) {
2031cc43c38cSRobert Watson 			if (pmap_extract(map->pmap, addr))
2032cc43c38cSRobert Watson 				kve->kve_resident++;
2033cc43c38cSRobert Watson 			addr += PAGE_SIZE;
2034cc43c38cSRobert Watson 		}
2035cc43c38cSRobert Watson 
2036cc43c38cSRobert Watson 		for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) {
2037cc43c38cSRobert Watson 			if (tobj != obj)
2038bc403f03SAttilio Rao 				VM_OBJECT_RLOCK(tobj);
2039cc43c38cSRobert Watson 			if (lobj != obj)
2040bc403f03SAttilio Rao 				VM_OBJECT_RUNLOCK(lobj);
2041cc43c38cSRobert Watson 			lobj = tobj;
2042cc43c38cSRobert Watson 		}
2043cc43c38cSRobert Watson 
2044118d0afaSKonstantin Belousov 		kve->kve_start = (void*)entry->start;
2045118d0afaSKonstantin Belousov 		kve->kve_end = (void*)entry->end;
2046118d0afaSKonstantin Belousov 		kve->kve_offset = (off_t)entry->offset;
2047118d0afaSKonstantin Belousov 
2048118d0afaSKonstantin Belousov 		if (entry->protection & VM_PROT_READ)
2049118d0afaSKonstantin Belousov 			kve->kve_protection |= KVME_PROT_READ;
2050118d0afaSKonstantin Belousov 		if (entry->protection & VM_PROT_WRITE)
2051118d0afaSKonstantin Belousov 			kve->kve_protection |= KVME_PROT_WRITE;
2052118d0afaSKonstantin Belousov 		if (entry->protection & VM_PROT_EXECUTE)
2053118d0afaSKonstantin Belousov 			kve->kve_protection |= KVME_PROT_EXEC;
2054118d0afaSKonstantin Belousov 
2055118d0afaSKonstantin Belousov 		if (entry->eflags & MAP_ENTRY_COW)
2056118d0afaSKonstantin Belousov 			kve->kve_flags |= KVME_FLAG_COW;
2057118d0afaSKonstantin Belousov 		if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
2058118d0afaSKonstantin Belousov 			kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
2059937912eaSAttilio Rao 		if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
2060937912eaSAttilio Rao 			kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
2061118d0afaSKonstantin Belousov 
2062118d0afaSKonstantin Belousov 		last_timestamp = map->timestamp;
2063118d0afaSKonstantin Belousov 		vm_map_unlock_read(map);
2064118d0afaSKonstantin Belousov 
20657a9c4d24SPeter Wemm 		kve->kve_fileid = 0;
20667a9c4d24SPeter Wemm 		kve->kve_fsid = 0;
2067cc43c38cSRobert Watson 		freepath = NULL;
2068cc43c38cSRobert Watson 		fullpath = "";
2069cc43c38cSRobert Watson 		if (lobj) {
2070cc43c38cSRobert Watson 			vp = NULL;
2071cc43c38cSRobert Watson 			switch (lobj->type) {
2072cc43c38cSRobert Watson 			case OBJT_DEFAULT:
2073cc43c38cSRobert Watson 				kve->kve_type = KVME_TYPE_DEFAULT;
2074cc43c38cSRobert Watson 				break;
2075cc43c38cSRobert Watson 			case OBJT_VNODE:
2076cc43c38cSRobert Watson 				kve->kve_type = KVME_TYPE_VNODE;
2077cc43c38cSRobert Watson 				vp = lobj->handle;
2078cc43c38cSRobert Watson 				vref(vp);
2079cc43c38cSRobert Watson 				break;
2080cc43c38cSRobert Watson 			case OBJT_SWAP:
2081cc43c38cSRobert Watson 				kve->kve_type = KVME_TYPE_SWAP;
2082cc43c38cSRobert Watson 				break;
2083cc43c38cSRobert Watson 			case OBJT_DEVICE:
2084cc43c38cSRobert Watson 				kve->kve_type = KVME_TYPE_DEVICE;
2085cc43c38cSRobert Watson 				break;
2086cc43c38cSRobert Watson 			case OBJT_PHYS:
2087cc43c38cSRobert Watson 				kve->kve_type = KVME_TYPE_PHYS;
2088cc43c38cSRobert Watson 				break;
2089cc43c38cSRobert Watson 			case OBJT_DEAD:
2090cc43c38cSRobert Watson 				kve->kve_type = KVME_TYPE_DEAD;
2091cc43c38cSRobert Watson 				break;
209201381811SJohn Baldwin 			case OBJT_SG:
209301381811SJohn Baldwin 				kve->kve_type = KVME_TYPE_SG;
209401381811SJohn Baldwin 				break;
2095cc43c38cSRobert Watson 			default:
2096cc43c38cSRobert Watson 				kve->kve_type = KVME_TYPE_UNKNOWN;
2097cc43c38cSRobert Watson 				break;
2098cc43c38cSRobert Watson 			}
2099cc43c38cSRobert Watson 			if (lobj != obj)
2100bc403f03SAttilio Rao 				VM_OBJECT_RUNLOCK(lobj);
2101cc43c38cSRobert Watson 
2102cc43c38cSRobert Watson 			kve->kve_ref_count = obj->ref_count;
2103cc43c38cSRobert Watson 			kve->kve_shadow_count = obj->shadow_count;
2104bc403f03SAttilio Rao 			VM_OBJECT_RUNLOCK(obj);
2105cc43c38cSRobert Watson 			if (vp != NULL) {
2106cc43c38cSRobert Watson 				vn_fullpath(curthread, vp, &fullpath,
2107cc43c38cSRobert Watson 				    &freepath);
21087a9c4d24SPeter Wemm 				cred = curthread->td_ucred;
21092ff47c5fSJohn Baldwin 				vn_lock(vp, LK_SHARED | LK_RETRY);
21107a9c4d24SPeter Wemm 				if (VOP_GETATTR(vp, &va, cred) == 0) {
21117a9c4d24SPeter Wemm 					kve->kve_fileid = va.va_fileid;
21127a9c4d24SPeter Wemm 					kve->kve_fsid = va.va_fsid;
21137a9c4d24SPeter Wemm 				}
2114cc43c38cSRobert Watson 				vput(vp);
2115cc43c38cSRobert Watson 			}
2116cc43c38cSRobert Watson 		} else {
2117cc43c38cSRobert Watson 			kve->kve_type = KVME_TYPE_NONE;
2118cc43c38cSRobert Watson 			kve->kve_ref_count = 0;
2119cc43c38cSRobert Watson 			kve->kve_shadow_count = 0;
2120cc43c38cSRobert Watson 		}
2121cc43c38cSRobert Watson 
2122cc43c38cSRobert Watson 		strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
2123cc43c38cSRobert Watson 		if (freepath != NULL)
2124cc43c38cSRobert Watson 			free(freepath, M_TEMP);
2125cc43c38cSRobert Watson 
2126cc43c38cSRobert Watson 		error = SYSCTL_OUT(req, kve, sizeof(*kve));
2127cc43c38cSRobert Watson 		vm_map_lock_read(map);
2128cc43c38cSRobert Watson 		if (error)
2129cc43c38cSRobert Watson 			break;
213022a448c4SKonstantin Belousov 		if (last_timestamp != map->timestamp) {
2131cc43c38cSRobert Watson 			vm_map_lookup_entry(map, addr - 1, &tmp_entry);
2132cc43c38cSRobert Watson 			entry = tmp_entry;
2133cc43c38cSRobert Watson 		}
2134cc43c38cSRobert Watson 	}
2135cc43c38cSRobert Watson 	vm_map_unlock_read(map);
2136c7462f43SKonstantin Belousov 	vmspace_free(vm);
2137cc43c38cSRobert Watson 	PRELE(p);
2138cc43c38cSRobert Watson 	free(kve, M_TEMP);
2139cc43c38cSRobert Watson 	return (error);
2140cc43c38cSRobert Watson }
214143151ee6SPeter Wemm #endif	/* COMPAT_FREEBSD7 */
214243151ee6SPeter Wemm 
214343151ee6SPeter Wemm #ifdef KINFO_VMENTRY_SIZE
214443151ee6SPeter Wemm CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE);
214543151ee6SPeter Wemm #endif
214643151ee6SPeter Wemm 
2147a62eb139SKonstantin Belousov static void
2148a62eb139SKonstantin Belousov kern_proc_vmmap_resident(vm_map_t map, vm_map_entry_t entry,
2149a62eb139SKonstantin Belousov     struct kinfo_vmentry *kve)
2150a62eb139SKonstantin Belousov {
2151a62eb139SKonstantin Belousov 	vm_object_t obj, tobj;
2152a62eb139SKonstantin Belousov 	vm_page_t m, m_adv;
2153a62eb139SKonstantin Belousov 	vm_offset_t addr;
2154a62eb139SKonstantin Belousov 	vm_paddr_t locked_pa;
2155a62eb139SKonstantin Belousov 	vm_pindex_t pi, pi_adv, pindex;
2156a62eb139SKonstantin Belousov 
2157a62eb139SKonstantin Belousov 	locked_pa = 0;
2158a62eb139SKonstantin Belousov 	obj = entry->object.vm_object;
2159a62eb139SKonstantin Belousov 	addr = entry->start;
2160a62eb139SKonstantin Belousov 	m_adv = NULL;
2161d3a3b8b0SKonstantin Belousov 	pi = OFF_TO_IDX(entry->offset);
2162a62eb139SKonstantin Belousov 	for (; addr < entry->end; addr += IDX_TO_OFF(pi_adv), pi += pi_adv) {
2163a62eb139SKonstantin Belousov 		if (m_adv != NULL) {
2164a62eb139SKonstantin Belousov 			m = m_adv;
2165a62eb139SKonstantin Belousov 		} else {
2166a62eb139SKonstantin Belousov 			pi_adv = OFF_TO_IDX(entry->end - addr);
2167a62eb139SKonstantin Belousov 			pindex = pi;
2168a62eb139SKonstantin Belousov 			for (tobj = obj;; tobj = tobj->backing_object) {
2169a62eb139SKonstantin Belousov 				m = vm_page_find_least(tobj, pindex);
2170a62eb139SKonstantin Belousov 				if (m != NULL) {
2171a62eb139SKonstantin Belousov 					if (m->pindex == pindex)
2172a62eb139SKonstantin Belousov 						break;
2173a62eb139SKonstantin Belousov 					if (pi_adv > m->pindex - pindex) {
2174a62eb139SKonstantin Belousov 						pi_adv = m->pindex - pindex;
2175a62eb139SKonstantin Belousov 						m_adv = m;
2176a62eb139SKonstantin Belousov 					}
2177a62eb139SKonstantin Belousov 				}
2178a62eb139SKonstantin Belousov 				if (tobj->backing_object == NULL)
2179a62eb139SKonstantin Belousov 					goto next;
2180a62eb139SKonstantin Belousov 				pindex += OFF_TO_IDX(tobj->
2181a62eb139SKonstantin Belousov 				    backing_object_offset);
2182a62eb139SKonstantin Belousov 			}
2183a62eb139SKonstantin Belousov 		}
2184a62eb139SKonstantin Belousov 		m_adv = NULL;
2185a62eb139SKonstantin Belousov 		if (m->psind != 0 && addr + pagesizes[1] <= entry->end &&
2186a62eb139SKonstantin Belousov 		    (addr & (pagesizes[1] - 1)) == 0 &&
2187a62eb139SKonstantin Belousov 		    (pmap_mincore(map->pmap, addr, &locked_pa) &
2188a62eb139SKonstantin Belousov 		    MINCORE_SUPER) != 0) {
2189a62eb139SKonstantin Belousov 			kve->kve_flags |= KVME_FLAG_SUPER;
2190a62eb139SKonstantin Belousov 			pi_adv = OFF_TO_IDX(pagesizes[1]);
2191a62eb139SKonstantin Belousov 		} else {
2192a62eb139SKonstantin Belousov 			/*
2193a62eb139SKonstantin Belousov 			 * We do not test the found page on validity.
2194a62eb139SKonstantin Belousov 			 * Either the page is busy and being paged in,
2195a62eb139SKonstantin Belousov 			 * or it was invalidated.  The first case
2196a62eb139SKonstantin Belousov 			 * should be counted as resident, the second
2197a62eb139SKonstantin Belousov 			 * is not so clear; we do account both.
2198a62eb139SKonstantin Belousov 			 */
2199a62eb139SKonstantin Belousov 			pi_adv = 1;
2200a62eb139SKonstantin Belousov 		}
2201a62eb139SKonstantin Belousov 		kve->kve_resident += pi_adv;
2202a62eb139SKonstantin Belousov next:;
2203a62eb139SKonstantin Belousov 	}
2204a62eb139SKonstantin Belousov 	PA_UNLOCK_COND(locked_pa);
2205a62eb139SKonstantin Belousov }
2206a62eb139SKonstantin Belousov 
2207fe52cf54SMikolaj Golub /*
2208fe52cf54SMikolaj Golub  * Must be called with the process locked and will return unlocked.
2209fe52cf54SMikolaj Golub  */
2210fe52cf54SMikolaj Golub int
2211fe52cf54SMikolaj Golub kern_proc_vmmap_out(struct proc *p, struct sbuf *sb)
221243151ee6SPeter Wemm {
221343151ee6SPeter Wemm 	vm_map_entry_t entry, tmp_entry;
2214a91831a2SKonstantin Belousov 	struct vattr va;
2215a91831a2SKonstantin Belousov 	vm_map_t map;
2216a91831a2SKonstantin Belousov 	vm_object_t obj, tobj, lobj;
221743151ee6SPeter Wemm 	char *fullpath, *freepath;
221843151ee6SPeter Wemm 	struct kinfo_vmentry *kve;
221943151ee6SPeter Wemm 	struct ucred *cred;
222043151ee6SPeter Wemm 	struct vnode *vp;
2221c7462f43SKonstantin Belousov 	struct vmspace *vm;
2222a91831a2SKonstantin Belousov 	vm_offset_t addr;
2223a91831a2SKonstantin Belousov 	unsigned int last_timestamp;
2224a91831a2SKonstantin Belousov 	int error;
222543151ee6SPeter Wemm 
2226fe52cf54SMikolaj Golub 	PROC_LOCK_ASSERT(p, MA_OWNED);
2227fe52cf54SMikolaj Golub 
2228fe52cf54SMikolaj Golub 	_PHOLD(p);
2229fe52cf54SMikolaj Golub 	PROC_UNLOCK(p);
2230c7462f43SKonstantin Belousov 	vm = vmspace_acquire_ref(p);
2231c7462f43SKonstantin Belousov 	if (vm == NULL) {
2232c7462f43SKonstantin Belousov 		PRELE(p);
2233c7462f43SKonstantin Belousov 		return (ESRCH);
2234c7462f43SKonstantin Belousov 	}
223543151ee6SPeter Wemm 	kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK);
223643151ee6SPeter Wemm 
2237fe52cf54SMikolaj Golub 	error = 0;
2238ca4aa8c3SSergey Kandaurov 	map = &vm->vm_map;
223943151ee6SPeter Wemm 	vm_map_lock_read(map);
224043151ee6SPeter Wemm 	for (entry = map->header.next; entry != &map->header;
224143151ee6SPeter Wemm 	    entry = entry->next) {
224243151ee6SPeter Wemm 		if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
224343151ee6SPeter Wemm 			continue;
224443151ee6SPeter Wemm 
2245479fcb4eSKonstantin Belousov 		addr = entry->end;
224643151ee6SPeter Wemm 		bzero(kve, sizeof(*kve));
224743151ee6SPeter Wemm 		obj = entry->object.vm_object;
224843151ee6SPeter Wemm 		if (obj != NULL) {
2249a91831a2SKonstantin Belousov 			for (tobj = obj; tobj != NULL;
2250a91831a2SKonstantin Belousov 			    tobj = tobj->backing_object) {
2251a91831a2SKonstantin Belousov 				VM_OBJECT_RLOCK(tobj);
2252a91831a2SKonstantin Belousov 				lobj = tobj;
2253a91831a2SKonstantin Belousov 			}
22543760e341SKonstantin Belousov 			if (obj->backing_object == NULL)
225543151ee6SPeter Wemm 				kve->kve_private_resident =
225643151ee6SPeter Wemm 				    obj->resident_page_count;
2257a62eb139SKonstantin Belousov 			if (!vmmap_skip_res_cnt)
2258a62eb139SKonstantin Belousov 				kern_proc_vmmap_resident(map, entry, kve);
2259a91831a2SKonstantin Belousov 			for (tobj = obj; tobj != NULL;
2260a91831a2SKonstantin Belousov 			    tobj = tobj->backing_object) {
2261a91831a2SKonstantin Belousov 				if (tobj != obj && tobj != lobj)
2262a91831a2SKonstantin Belousov 					VM_OBJECT_RUNLOCK(tobj);
2263a91831a2SKonstantin Belousov 			}
2264a91831a2SKonstantin Belousov 		} else {
2265a91831a2SKonstantin Belousov 			lobj = NULL;
226643151ee6SPeter Wemm 		}
226743151ee6SPeter Wemm 
2268118d0afaSKonstantin Belousov 		kve->kve_start = entry->start;
2269118d0afaSKonstantin Belousov 		kve->kve_end = entry->end;
2270118d0afaSKonstantin Belousov 		kve->kve_offset = entry->offset;
2271118d0afaSKonstantin Belousov 
2272118d0afaSKonstantin Belousov 		if (entry->protection & VM_PROT_READ)
2273118d0afaSKonstantin Belousov 			kve->kve_protection |= KVME_PROT_READ;
2274118d0afaSKonstantin Belousov 		if (entry->protection & VM_PROT_WRITE)
2275118d0afaSKonstantin Belousov 			kve->kve_protection |= KVME_PROT_WRITE;
2276118d0afaSKonstantin Belousov 		if (entry->protection & VM_PROT_EXECUTE)
2277118d0afaSKonstantin Belousov 			kve->kve_protection |= KVME_PROT_EXEC;
2278118d0afaSKonstantin Belousov 
2279118d0afaSKonstantin Belousov 		if (entry->eflags & MAP_ENTRY_COW)
2280118d0afaSKonstantin Belousov 			kve->kve_flags |= KVME_FLAG_COW;
2281118d0afaSKonstantin Belousov 		if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
2282118d0afaSKonstantin Belousov 			kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
2283937912eaSAttilio Rao 		if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
2284937912eaSAttilio Rao 			kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
2285599fc82bSGabor Pali 		if (entry->eflags & MAP_ENTRY_GROWS_UP)
2286599fc82bSGabor Pali 			kve->kve_flags |= KVME_FLAG_GROWS_UP;
2287599fc82bSGabor Pali 		if (entry->eflags & MAP_ENTRY_GROWS_DOWN)
2288599fc82bSGabor Pali 			kve->kve_flags |= KVME_FLAG_GROWS_DOWN;
2289118d0afaSKonstantin Belousov 
2290118d0afaSKonstantin Belousov 		last_timestamp = map->timestamp;
2291118d0afaSKonstantin Belousov 		vm_map_unlock_read(map);
2292118d0afaSKonstantin Belousov 
229343151ee6SPeter Wemm 		freepath = NULL;
229443151ee6SPeter Wemm 		fullpath = "";
2295a91831a2SKonstantin Belousov 		if (lobj != NULL) {
229643151ee6SPeter Wemm 			vp = NULL;
229743151ee6SPeter Wemm 			switch (lobj->type) {
229843151ee6SPeter Wemm 			case OBJT_DEFAULT:
229943151ee6SPeter Wemm 				kve->kve_type = KVME_TYPE_DEFAULT;
230043151ee6SPeter Wemm 				break;
230143151ee6SPeter Wemm 			case OBJT_VNODE:
230243151ee6SPeter Wemm 				kve->kve_type = KVME_TYPE_VNODE;
230343151ee6SPeter Wemm 				vp = lobj->handle;
230443151ee6SPeter Wemm 				vref(vp);
230543151ee6SPeter Wemm 				break;
230643151ee6SPeter Wemm 			case OBJT_SWAP:
230743151ee6SPeter Wemm 				kve->kve_type = KVME_TYPE_SWAP;
230843151ee6SPeter Wemm 				break;
230943151ee6SPeter Wemm 			case OBJT_DEVICE:
231043151ee6SPeter Wemm 				kve->kve_type = KVME_TYPE_DEVICE;
231143151ee6SPeter Wemm 				break;
231243151ee6SPeter Wemm 			case OBJT_PHYS:
231343151ee6SPeter Wemm 				kve->kve_type = KVME_TYPE_PHYS;
231443151ee6SPeter Wemm 				break;
231543151ee6SPeter Wemm 			case OBJT_DEAD:
231643151ee6SPeter Wemm 				kve->kve_type = KVME_TYPE_DEAD;
231743151ee6SPeter Wemm 				break;
231801381811SJohn Baldwin 			case OBJT_SG:
231901381811SJohn Baldwin 				kve->kve_type = KVME_TYPE_SG;
232001381811SJohn Baldwin 				break;
23212db08c03SJohn Baldwin 			case OBJT_MGTDEVICE:
23222db08c03SJohn Baldwin 				kve->kve_type = KVME_TYPE_MGTDEVICE;
23232db08c03SJohn Baldwin 				break;
232443151ee6SPeter Wemm 			default:
232543151ee6SPeter Wemm 				kve->kve_type = KVME_TYPE_UNKNOWN;
232643151ee6SPeter Wemm 				break;
232743151ee6SPeter Wemm 			}
232843151ee6SPeter Wemm 			if (lobj != obj)
2329bc403f03SAttilio Rao 				VM_OBJECT_RUNLOCK(lobj);
233043151ee6SPeter Wemm 
233143151ee6SPeter Wemm 			kve->kve_ref_count = obj->ref_count;
233243151ee6SPeter Wemm 			kve->kve_shadow_count = obj->shadow_count;
2333bc403f03SAttilio Rao 			VM_OBJECT_RUNLOCK(obj);
233443151ee6SPeter Wemm 			if (vp != NULL) {
233543151ee6SPeter Wemm 				vn_fullpath(curthread, vp, &fullpath,
233643151ee6SPeter Wemm 				    &freepath);
23370daf62d9SStanislav Sedov 				kve->kve_vn_type = vntype_to_kinfo(vp->v_type);
233843151ee6SPeter Wemm 				cred = curthread->td_ucred;
233943151ee6SPeter Wemm 				vn_lock(vp, LK_SHARED | LK_RETRY);
234043151ee6SPeter Wemm 				if (VOP_GETATTR(vp, &va, cred) == 0) {
23410daf62d9SStanislav Sedov 					kve->kve_vn_fileid = va.va_fileid;
23420daf62d9SStanislav Sedov 					kve->kve_vn_fsid = va.va_fsid;
23430daf62d9SStanislav Sedov 					kve->kve_vn_mode =
23440daf62d9SStanislav Sedov 					    MAKEIMODE(va.va_type, va.va_mode);
23450daf62d9SStanislav Sedov 					kve->kve_vn_size = va.va_size;
23460daf62d9SStanislav Sedov 					kve->kve_vn_rdev = va.va_rdev;
23470daf62d9SStanislav Sedov 					kve->kve_status = KF_ATTR_VALID;
234843151ee6SPeter Wemm 				}
234943151ee6SPeter Wemm 				vput(vp);
235043151ee6SPeter Wemm 			}
235143151ee6SPeter Wemm 		} else {
235243151ee6SPeter Wemm 			kve->kve_type = KVME_TYPE_NONE;
235343151ee6SPeter Wemm 			kve->kve_ref_count = 0;
235443151ee6SPeter Wemm 			kve->kve_shadow_count = 0;
235543151ee6SPeter Wemm 		}
235643151ee6SPeter Wemm 
235743151ee6SPeter Wemm 		strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
235843151ee6SPeter Wemm 		if (freepath != NULL)
235943151ee6SPeter Wemm 			free(freepath, M_TEMP);
236043151ee6SPeter Wemm 
236143151ee6SPeter Wemm 		/* Pack record size down */
236243151ee6SPeter Wemm 		kve->kve_structsize = offsetof(struct kinfo_vmentry, kve_path) +
236343151ee6SPeter Wemm 		    strlen(kve->kve_path) + 1;
236443151ee6SPeter Wemm 		kve->kve_structsize = roundup(kve->kve_structsize,
236543151ee6SPeter Wemm 		    sizeof(uint64_t));
2366fe52cf54SMikolaj Golub 		error = sbuf_bcat(sb, kve, kve->kve_structsize);
236743151ee6SPeter Wemm 		vm_map_lock_read(map);
236843151ee6SPeter Wemm 		if (error)
236943151ee6SPeter Wemm 			break;
237022a448c4SKonstantin Belousov 		if (last_timestamp != map->timestamp) {
237143151ee6SPeter Wemm 			vm_map_lookup_entry(map, addr - 1, &tmp_entry);
237243151ee6SPeter Wemm 			entry = tmp_entry;
237343151ee6SPeter Wemm 		}
237443151ee6SPeter Wemm 	}
237543151ee6SPeter Wemm 	vm_map_unlock_read(map);
2376c7462f43SKonstantin Belousov 	vmspace_free(vm);
237743151ee6SPeter Wemm 	PRELE(p);
237843151ee6SPeter Wemm 	free(kve, M_TEMP);
237943151ee6SPeter Wemm 	return (error);
238043151ee6SPeter Wemm }
2381cc43c38cSRobert Watson 
2382fe52cf54SMikolaj Golub static int
2383fe52cf54SMikolaj Golub sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS)
2384fe52cf54SMikolaj Golub {
2385fe52cf54SMikolaj Golub 	struct proc *p;
2386fe52cf54SMikolaj Golub 	struct sbuf sb;
2387fe52cf54SMikolaj Golub 	int error, error2, *name;
2388fe52cf54SMikolaj Golub 
2389fe52cf54SMikolaj Golub 	name = (int *)arg1;
2390fe52cf54SMikolaj Golub 	sbuf_new_for_sysctl(&sb, NULL, sizeof(struct kinfo_vmentry), req);
2391fe52cf54SMikolaj Golub 	error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
2392fe52cf54SMikolaj Golub 	if (error != 0) {
2393fe52cf54SMikolaj Golub 		sbuf_delete(&sb);
2394fe52cf54SMikolaj Golub 		return (error);
2395fe52cf54SMikolaj Golub 	}
2396fe52cf54SMikolaj Golub 	error = kern_proc_vmmap_out(p, &sb);
2397fe52cf54SMikolaj Golub 	error2 = sbuf_finish(&sb);
2398fe52cf54SMikolaj Golub 	sbuf_delete(&sb);
2399fe52cf54SMikolaj Golub 	return (error != 0 ? error : error2);
2400fe52cf54SMikolaj Golub }
2401fe52cf54SMikolaj Golub 
24021cc8c45cSRobert Watson #if defined(STACK) || defined(DDB)
24031cc8c45cSRobert Watson static int
24041cc8c45cSRobert Watson sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS)
24051cc8c45cSRobert Watson {
24061cc8c45cSRobert Watson 	struct kinfo_kstack *kkstp;
24071cc8c45cSRobert Watson 	int error, i, *name, numthreads;
24081cc8c45cSRobert Watson 	lwpid_t *lwpidarray;
24091cc8c45cSRobert Watson 	struct thread *td;
24101cc8c45cSRobert Watson 	struct stack *st;
24111cc8c45cSRobert Watson 	struct sbuf sb;
24121cc8c45cSRobert Watson 	struct proc *p;
24131cc8c45cSRobert Watson 
24141cc8c45cSRobert Watson 	name = (int *)arg1;
2415fa3935bcSMikolaj Golub 	error = pget((pid_t)name[0], PGET_NOTINEXEC | PGET_WANTREAD, &p);
2416fa3935bcSMikolaj Golub 	if (error != 0)
24171cc8c45cSRobert Watson 		return (error);
24181cc8c45cSRobert Watson 
24191cc8c45cSRobert Watson 	kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK);
24201cc8c45cSRobert Watson 	st = stack_create();
24211cc8c45cSRobert Watson 
24221cc8c45cSRobert Watson 	lwpidarray = NULL;
24231cc8c45cSRobert Watson 	numthreads = 0;
2424374ae2a3SJeff Roberson 	PROC_LOCK(p);
24251cc8c45cSRobert Watson repeat:
24261cc8c45cSRobert Watson 	if (numthreads < p->p_numthreads) {
24271cc8c45cSRobert Watson 		if (lwpidarray != NULL) {
24281cc8c45cSRobert Watson 			free(lwpidarray, M_TEMP);
24291cc8c45cSRobert Watson 			lwpidarray = NULL;
24301cc8c45cSRobert Watson 		}
24311cc8c45cSRobert Watson 		numthreads = p->p_numthreads;
2432374ae2a3SJeff Roberson 		PROC_UNLOCK(p);
24331cc8c45cSRobert Watson 		lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP,
24341cc8c45cSRobert Watson 		    M_WAITOK | M_ZERO);
2435374ae2a3SJeff Roberson 		PROC_LOCK(p);
24361cc8c45cSRobert Watson 		goto repeat;
24371cc8c45cSRobert Watson 	}
24381cc8c45cSRobert Watson 	i = 0;
24391cc8c45cSRobert Watson 
24401cc8c45cSRobert Watson 	/*
24411cc8c45cSRobert Watson 	 * XXXRW: During the below loop, execve(2) and countless other sorts
24421cc8c45cSRobert Watson 	 * of changes could have taken place.  Should we check to see if the
24431cc8c45cSRobert Watson 	 * vmspace has been replaced, or the like, in order to prevent
24441cc8c45cSRobert Watson 	 * giving a snapshot that spans, say, execve(2), with some threads
24451cc8c45cSRobert Watson 	 * before and some after?  Among other things, the credentials could
24461cc8c45cSRobert Watson 	 * have changed, in which case the right to extract debug info might
24471cc8c45cSRobert Watson 	 * no longer be assured.
24481cc8c45cSRobert Watson 	 */
24491cc8c45cSRobert Watson 	FOREACH_THREAD_IN_PROC(p, td) {
24501cc8c45cSRobert Watson 		KASSERT(i < numthreads,
24511cc8c45cSRobert Watson 		    ("sysctl_kern_proc_kstack: numthreads"));
24521cc8c45cSRobert Watson 		lwpidarray[i] = td->td_tid;
24531cc8c45cSRobert Watson 		i++;
24541cc8c45cSRobert Watson 	}
24551cc8c45cSRobert Watson 	numthreads = i;
24561cc8c45cSRobert Watson 	for (i = 0; i < numthreads; i++) {
24571cc8c45cSRobert Watson 		td = thread_find(p, lwpidarray[i]);
24581cc8c45cSRobert Watson 		if (td == NULL) {
24591cc8c45cSRobert Watson 			continue;
24601cc8c45cSRobert Watson 		}
24611cc8c45cSRobert Watson 		bzero(kkstp, sizeof(*kkstp));
24621cc8c45cSRobert Watson 		(void)sbuf_new(&sb, kkstp->kkst_trace,
24631cc8c45cSRobert Watson 		    sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN);
24641cc8c45cSRobert Watson 		thread_lock(td);
24651cc8c45cSRobert Watson 		kkstp->kkst_tid = td->td_tid;
24661cc8c45cSRobert Watson 		if (TD_IS_SWAPPED(td))
24671cc8c45cSRobert Watson 			kkstp->kkst_state = KKST_STATE_SWAPPED;
24681cc8c45cSRobert Watson 		else if (TD_IS_RUNNING(td))
24691cc8c45cSRobert Watson 			kkstp->kkst_state = KKST_STATE_RUNNING;
24701cc8c45cSRobert Watson 		else {
24711cc8c45cSRobert Watson 			kkstp->kkst_state = KKST_STATE_STACKOK;
24721cc8c45cSRobert Watson 			stack_save_td(st, td);
24731cc8c45cSRobert Watson 		}
24741cc8c45cSRobert Watson 		thread_unlock(td);
24751cc8c45cSRobert Watson 		PROC_UNLOCK(p);
24761cc8c45cSRobert Watson 		stack_sbuf_print(&sb, st);
24771cc8c45cSRobert Watson 		sbuf_finish(&sb);
24781cc8c45cSRobert Watson 		sbuf_delete(&sb);
24791cc8c45cSRobert Watson 		error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp));
24801cc8c45cSRobert Watson 		PROC_LOCK(p);
24811cc8c45cSRobert Watson 		if (error)
24821cc8c45cSRobert Watson 			break;
24831cc8c45cSRobert Watson 	}
24841cc8c45cSRobert Watson 	_PRELE(p);
24851cc8c45cSRobert Watson 	PROC_UNLOCK(p);
24861cc8c45cSRobert Watson 	if (lwpidarray != NULL)
24871cc8c45cSRobert Watson 		free(lwpidarray, M_TEMP);
24881cc8c45cSRobert Watson 	stack_destroy(st);
24891cc8c45cSRobert Watson 	free(kkstp, M_TEMP);
24901cc8c45cSRobert Watson 	return (error);
24911cc8c45cSRobert Watson }
24921cc8c45cSRobert Watson #endif
24931cc8c45cSRobert Watson 
2494254d03c5SBrooks Davis /*
2495254d03c5SBrooks Davis  * This sysctl allows a process to retrieve the full list of groups from
2496254d03c5SBrooks Davis  * itself or another process.
2497254d03c5SBrooks Davis  */
2498254d03c5SBrooks Davis static int
2499254d03c5SBrooks Davis sysctl_kern_proc_groups(SYSCTL_HANDLER_ARGS)
2500254d03c5SBrooks Davis {
2501254d03c5SBrooks Davis 	pid_t *pidp = (pid_t *)arg1;
2502254d03c5SBrooks Davis 	unsigned int arglen = arg2;
2503254d03c5SBrooks Davis 	struct proc *p;
2504254d03c5SBrooks Davis 	struct ucred *cred;
2505254d03c5SBrooks Davis 	int error;
2506254d03c5SBrooks Davis 
2507254d03c5SBrooks Davis 	if (arglen != 1)
2508254d03c5SBrooks Davis 		return (EINVAL);
2509254d03c5SBrooks Davis 	if (*pidp == -1) {	/* -1 means this process */
2510254d03c5SBrooks Davis 		p = req->td->td_proc;
2511*2570cdd6SMateusz Guzik 		PROC_LOCK(p);
2512254d03c5SBrooks Davis 	} else {
2513fa3935bcSMikolaj Golub 		error = pget(*pidp, PGET_CANSEE, &p);
2514fa3935bcSMikolaj Golub 		if (error != 0)
2515254d03c5SBrooks Davis 			return (error);
2516254d03c5SBrooks Davis 	}
2517254d03c5SBrooks Davis 
2518254d03c5SBrooks Davis 	cred = crhold(p->p_ucred);
2519254d03c5SBrooks Davis 	PROC_UNLOCK(p);
2520254d03c5SBrooks Davis 
2521254d03c5SBrooks Davis 	error = SYSCTL_OUT(req, cred->cr_groups,
2522254d03c5SBrooks Davis 	    cred->cr_ngroups * sizeof(gid_t));
2523254d03c5SBrooks Davis 	crfree(cred);
2524254d03c5SBrooks Davis 	return (error);
2525254d03c5SBrooks Davis }
2526254d03c5SBrooks Davis 
25279e7d0583SMikolaj Golub /*
25288854fe39SMikolaj Golub  * This sysctl allows a process to retrieve or/and set the resource limit for
25299e7d0583SMikolaj Golub  * another process.
25309e7d0583SMikolaj Golub  */
25319e7d0583SMikolaj Golub static int
25329e7d0583SMikolaj Golub sysctl_kern_proc_rlimit(SYSCTL_HANDLER_ARGS)
25339e7d0583SMikolaj Golub {
25349e7d0583SMikolaj Golub 	int *name = (int *)arg1;
25359e7d0583SMikolaj Golub 	u_int namelen = arg2;
25368854fe39SMikolaj Golub 	struct rlimit rlim;
25379e7d0583SMikolaj Golub 	struct proc *p;
25388854fe39SMikolaj Golub 	u_int which;
25398854fe39SMikolaj Golub 	int flags, error;
25409e7d0583SMikolaj Golub 
25418854fe39SMikolaj Golub 	if (namelen != 2)
25429e7d0583SMikolaj Golub 		return (EINVAL);
25439e7d0583SMikolaj Golub 
25448854fe39SMikolaj Golub 	which = (u_int)name[1];
25458854fe39SMikolaj Golub 	if (which >= RLIM_NLIMITS)
25468854fe39SMikolaj Golub 		return (EINVAL);
25478854fe39SMikolaj Golub 
25488854fe39SMikolaj Golub 	if (req->newptr != NULL && req->newlen != sizeof(rlim))
25498854fe39SMikolaj Golub 		return (EINVAL);
25508854fe39SMikolaj Golub 
25518854fe39SMikolaj Golub 	flags = PGET_HOLD | PGET_NOTWEXIT;
25528854fe39SMikolaj Golub 	if (req->newptr != NULL)
25538854fe39SMikolaj Golub 		flags |= PGET_CANDEBUG;
25548854fe39SMikolaj Golub 	else
25558854fe39SMikolaj Golub 		flags |= PGET_CANSEE;
25568854fe39SMikolaj Golub 	error = pget((pid_t)name[0], flags, &p);
2557fa3935bcSMikolaj Golub 	if (error != 0)
25589e7d0583SMikolaj Golub 		return (error);
25598854fe39SMikolaj Golub 
25609e7d0583SMikolaj Golub 	/*
25618854fe39SMikolaj Golub 	 * Retrieve limit.
25629e7d0583SMikolaj Golub 	 */
25638854fe39SMikolaj Golub 	if (req->oldptr != NULL) {
25648854fe39SMikolaj Golub 		PROC_LOCK(p);
25658854fe39SMikolaj Golub 		lim_rlimit(p, which, &rlim);
25669e7d0583SMikolaj Golub 		PROC_UNLOCK(p);
25678854fe39SMikolaj Golub 	}
25688854fe39SMikolaj Golub 	error = SYSCTL_OUT(req, &rlim, sizeof(rlim));
25698854fe39SMikolaj Golub 	if (error != 0)
25708854fe39SMikolaj Golub 		goto errout;
25718854fe39SMikolaj Golub 
25728854fe39SMikolaj Golub 	/*
25738854fe39SMikolaj Golub 	 * Set limit.
25748854fe39SMikolaj Golub 	 */
25758854fe39SMikolaj Golub 	if (req->newptr != NULL) {
25768854fe39SMikolaj Golub 		error = SYSCTL_IN(req, &rlim, sizeof(rlim));
25778854fe39SMikolaj Golub 		if (error == 0)
25788854fe39SMikolaj Golub 			error = kern_proc_setrlimit(curthread, p, which, &rlim);
25799e7d0583SMikolaj Golub 	}
25809e7d0583SMikolaj Golub 
25818854fe39SMikolaj Golub errout:
25828854fe39SMikolaj Golub 	PRELE(p);
25839e7d0583SMikolaj Golub 	return (error);
25849e7d0583SMikolaj Golub }
25859e7d0583SMikolaj Golub 
25869732458fSMikolaj Golub /*
25879732458fSMikolaj Golub  * This sysctl allows a process to retrieve ps_strings structure location of
25889732458fSMikolaj Golub  * another process.
25899732458fSMikolaj Golub  */
25909732458fSMikolaj Golub static int
25919732458fSMikolaj Golub sysctl_kern_proc_ps_strings(SYSCTL_HANDLER_ARGS)
25929732458fSMikolaj Golub {
25939732458fSMikolaj Golub 	int *name = (int *)arg1;
25949732458fSMikolaj Golub 	u_int namelen = arg2;
25959732458fSMikolaj Golub 	struct proc *p;
25969732458fSMikolaj Golub 	vm_offset_t ps_strings;
25979732458fSMikolaj Golub 	int error;
25989732458fSMikolaj Golub #ifdef COMPAT_FREEBSD32
25999732458fSMikolaj Golub 	uint32_t ps_strings32;
26009732458fSMikolaj Golub #endif
26019732458fSMikolaj Golub 
26029732458fSMikolaj Golub 	if (namelen != 1)
26039732458fSMikolaj Golub 		return (EINVAL);
26049732458fSMikolaj Golub 
2605fa3935bcSMikolaj Golub 	error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
2606fa3935bcSMikolaj Golub 	if (error != 0)
26079732458fSMikolaj Golub 		return (error);
26089732458fSMikolaj Golub #ifdef COMPAT_FREEBSD32
26099732458fSMikolaj Golub 	if ((req->flags & SCTL_MASK32) != 0) {
26109732458fSMikolaj Golub 		/*
26119732458fSMikolaj Golub 		 * We return 0 if the 32 bit emulation request is for a 64 bit
26129732458fSMikolaj Golub 		 * process.
26139732458fSMikolaj Golub 		 */
26149732458fSMikolaj Golub 		ps_strings32 = SV_PROC_FLAG(p, SV_ILP32) != 0 ?
26159732458fSMikolaj Golub 		    PTROUT(p->p_sysent->sv_psstrings) : 0;
26169732458fSMikolaj Golub 		PROC_UNLOCK(p);
26179732458fSMikolaj Golub 		error = SYSCTL_OUT(req, &ps_strings32, sizeof(ps_strings32));
26189732458fSMikolaj Golub 		return (error);
26199732458fSMikolaj Golub 	}
26209732458fSMikolaj Golub #endif
26219732458fSMikolaj Golub 	ps_strings = p->p_sysent->sv_psstrings;
26229732458fSMikolaj Golub 	PROC_UNLOCK(p);
26239732458fSMikolaj Golub 	error = SYSCTL_OUT(req, &ps_strings, sizeof(ps_strings));
26249732458fSMikolaj Golub 	return (error);
26259732458fSMikolaj Golub }
26269732458fSMikolaj Golub 
26276ce13747SMikolaj Golub /*
2628e0fcf639SMikolaj Golub  * This sysctl allows a process to retrieve umask of another process.
26296ce13747SMikolaj Golub  */
26306ce13747SMikolaj Golub static int
26316ce13747SMikolaj Golub sysctl_kern_proc_umask(SYSCTL_HANDLER_ARGS)
26326ce13747SMikolaj Golub {
26336ce13747SMikolaj Golub 	int *name = (int *)arg1;
26346ce13747SMikolaj Golub 	u_int namelen = arg2;
26356ce13747SMikolaj Golub 	struct proc *p;
26366ce13747SMikolaj Golub 	int error;
26376ce13747SMikolaj Golub 	u_short fd_cmask;
26386ce13747SMikolaj Golub 
26396ce13747SMikolaj Golub 	if (namelen != 1)
26406ce13747SMikolaj Golub 		return (EINVAL);
26416ce13747SMikolaj Golub 
26426ce13747SMikolaj Golub 	error = pget((pid_t)name[0], PGET_WANTREAD, &p);
26436ce13747SMikolaj Golub 	if (error != 0)
26446ce13747SMikolaj Golub 		return (error);
26456ce13747SMikolaj Golub 
26466ce13747SMikolaj Golub 	FILEDESC_SLOCK(p->p_fd);
26476ce13747SMikolaj Golub 	fd_cmask = p->p_fd->fd_cmask;
26486ce13747SMikolaj Golub 	FILEDESC_SUNLOCK(p->p_fd);
26496ce13747SMikolaj Golub 	PRELE(p);
2650e0fcf639SMikolaj Golub 	error = SYSCTL_OUT(req, &fd_cmask, sizeof(fd_cmask));
26516ce13747SMikolaj Golub 	return (error);
26526ce13747SMikolaj Golub }
26536ce13747SMikolaj Golub 
2654903712c9SMikolaj Golub /*
2655903712c9SMikolaj Golub  * This sysctl allows a process to set and retrieve binary osreldate of
2656903712c9SMikolaj Golub  * another process.
2657903712c9SMikolaj Golub  */
2658903712c9SMikolaj Golub static int
2659903712c9SMikolaj Golub sysctl_kern_proc_osrel(SYSCTL_HANDLER_ARGS)
2660903712c9SMikolaj Golub {
2661903712c9SMikolaj Golub 	int *name = (int *)arg1;
2662903712c9SMikolaj Golub 	u_int namelen = arg2;
2663903712c9SMikolaj Golub 	struct proc *p;
2664903712c9SMikolaj Golub 	int flags, error, osrel;
2665903712c9SMikolaj Golub 
2666903712c9SMikolaj Golub 	if (namelen != 1)
2667903712c9SMikolaj Golub 		return (EINVAL);
2668903712c9SMikolaj Golub 
2669903712c9SMikolaj Golub 	if (req->newptr != NULL && req->newlen != sizeof(osrel))
2670903712c9SMikolaj Golub 		return (EINVAL);
2671903712c9SMikolaj Golub 
2672903712c9SMikolaj Golub 	flags = PGET_HOLD | PGET_NOTWEXIT;
2673903712c9SMikolaj Golub 	if (req->newptr != NULL)
2674903712c9SMikolaj Golub 		flags |= PGET_CANDEBUG;
2675903712c9SMikolaj Golub 	else
2676903712c9SMikolaj Golub 		flags |= PGET_CANSEE;
2677903712c9SMikolaj Golub 	error = pget((pid_t)name[0], flags, &p);
2678903712c9SMikolaj Golub 	if (error != 0)
2679903712c9SMikolaj Golub 		return (error);
2680903712c9SMikolaj Golub 
2681903712c9SMikolaj Golub 	error = SYSCTL_OUT(req, &p->p_osrel, sizeof(p->p_osrel));
2682903712c9SMikolaj Golub 	if (error != 0)
2683903712c9SMikolaj Golub 		goto errout;
2684903712c9SMikolaj Golub 
2685903712c9SMikolaj Golub 	if (req->newptr != NULL) {
2686903712c9SMikolaj Golub 		error = SYSCTL_IN(req, &osrel, sizeof(osrel));
2687903712c9SMikolaj Golub 		if (error != 0)
2688903712c9SMikolaj Golub 			goto errout;
2689903712c9SMikolaj Golub 		if (osrel < 0) {
2690903712c9SMikolaj Golub 			error = EINVAL;
2691903712c9SMikolaj Golub 			goto errout;
2692903712c9SMikolaj Golub 		}
2693903712c9SMikolaj Golub 		p->p_osrel = osrel;
2694903712c9SMikolaj Golub 	}
2695903712c9SMikolaj Golub errout:
2696903712c9SMikolaj Golub 	PRELE(p);
2697903712c9SMikolaj Golub 	return (error);
2698903712c9SMikolaj Golub }
2699903712c9SMikolaj Golub 
270080c3af4eSKonstantin Belousov static int
270180c3af4eSKonstantin Belousov sysctl_kern_proc_sigtramp(SYSCTL_HANDLER_ARGS)
270280c3af4eSKonstantin Belousov {
270380c3af4eSKonstantin Belousov 	int *name = (int *)arg1;
270480c3af4eSKonstantin Belousov 	u_int namelen = arg2;
270580c3af4eSKonstantin Belousov 	struct proc *p;
270680c3af4eSKonstantin Belousov 	struct kinfo_sigtramp kst;
270780c3af4eSKonstantin Belousov 	const struct sysentvec *sv;
270880c3af4eSKonstantin Belousov 	int error;
270980c3af4eSKonstantin Belousov #ifdef COMPAT_FREEBSD32
271080c3af4eSKonstantin Belousov 	struct kinfo_sigtramp32 kst32;
271180c3af4eSKonstantin Belousov #endif
271280c3af4eSKonstantin Belousov 
271380c3af4eSKonstantin Belousov 	if (namelen != 1)
271480c3af4eSKonstantin Belousov 		return (EINVAL);
271580c3af4eSKonstantin Belousov 
271680c3af4eSKonstantin Belousov 	error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
271780c3af4eSKonstantin Belousov 	if (error != 0)
271880c3af4eSKonstantin Belousov 		return (error);
271980c3af4eSKonstantin Belousov 	sv = p->p_sysent;
272080c3af4eSKonstantin Belousov #ifdef COMPAT_FREEBSD32
272180c3af4eSKonstantin Belousov 	if ((req->flags & SCTL_MASK32) != 0) {
272280c3af4eSKonstantin Belousov 		bzero(&kst32, sizeof(kst32));
272380c3af4eSKonstantin Belousov 		if (SV_PROC_FLAG(p, SV_ILP32)) {
272480c3af4eSKonstantin Belousov 			if (sv->sv_sigcode_base != 0) {
272580c3af4eSKonstantin Belousov 				kst32.ksigtramp_start = sv->sv_sigcode_base;
272680c3af4eSKonstantin Belousov 				kst32.ksigtramp_end = sv->sv_sigcode_base +
272780c3af4eSKonstantin Belousov 				    *sv->sv_szsigcode;
272880c3af4eSKonstantin Belousov 			} else {
272980c3af4eSKonstantin Belousov 				kst32.ksigtramp_start = sv->sv_psstrings -
273080c3af4eSKonstantin Belousov 				    *sv->sv_szsigcode;
273180c3af4eSKonstantin Belousov 				kst32.ksigtramp_end = sv->sv_psstrings;
273280c3af4eSKonstantin Belousov 			}
273380c3af4eSKonstantin Belousov 		}
273480c3af4eSKonstantin Belousov 		PROC_UNLOCK(p);
273580c3af4eSKonstantin Belousov 		error = SYSCTL_OUT(req, &kst32, sizeof(kst32));
273680c3af4eSKonstantin Belousov 		return (error);
273780c3af4eSKonstantin Belousov 	}
273880c3af4eSKonstantin Belousov #endif
273980c3af4eSKonstantin Belousov 	bzero(&kst, sizeof(kst));
274080c3af4eSKonstantin Belousov 	if (sv->sv_sigcode_base != 0) {
274180c3af4eSKonstantin Belousov 		kst.ksigtramp_start = (char *)sv->sv_sigcode_base;
274280c3af4eSKonstantin Belousov 		kst.ksigtramp_end = (char *)sv->sv_sigcode_base +
274380c3af4eSKonstantin Belousov 		    *sv->sv_szsigcode;
274480c3af4eSKonstantin Belousov 	} else {
274580c3af4eSKonstantin Belousov 		kst.ksigtramp_start = (char *)sv->sv_psstrings -
274680c3af4eSKonstantin Belousov 		    *sv->sv_szsigcode;
274780c3af4eSKonstantin Belousov 		kst.ksigtramp_end = (char *)sv->sv_psstrings;
274880c3af4eSKonstantin Belousov 	}
274980c3af4eSKonstantin Belousov 	PROC_UNLOCK(p);
275080c3af4eSKonstantin Belousov 	error = SYSCTL_OUT(req, &kst, sizeof(kst));
275180c3af4eSKonstantin Belousov 	return (error);
275280c3af4eSKonstantin Belousov }
275380c3af4eSKonstantin Belousov 
2754cc43c38cSRobert Watson SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD,  0, "Process table");
27553ce93e4eSPoul-Henning Kamp 
275624f87fdbSJohn Baldwin SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT|
275724f87fdbSJohn Baldwin 	CTLFLAG_MPSAFE, 0, 0, sysctl_kern_proc, "S,proc",
275824f87fdbSJohn Baldwin 	"Return entire process table");
27593ce93e4eSPoul-Henning Kamp 
276024f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD | CTLFLAG_MPSAFE,
2761078842c5SGarance A Drosehn 	sysctl_kern_proc, "Process table");
2762078842c5SGarance A Drosehn 
276324f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD | CTLFLAG_MPSAFE,
27643ce93e4eSPoul-Henning Kamp 	sysctl_kern_proc, "Process table");
27653ce93e4eSPoul-Henning Kamp 
276624f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD | CTLFLAG_MPSAFE,
2767b8fdc89dSGarance A Drosehn 	sysctl_kern_proc, "Process table");
2768b8fdc89dSGarance A Drosehn 
276924f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD |
277024f87fdbSJohn Baldwin 	CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
277124f87fdbSJohn Baldwin 
277224f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD | CTLFLAG_MPSAFE,
2773b8fdc89dSGarance A Drosehn 	sysctl_kern_proc, "Process table");
2774b8fdc89dSGarance A Drosehn 
277524f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD | CTLFLAG_MPSAFE,
27763ce93e4eSPoul-Henning Kamp 	sysctl_kern_proc, "Process table");
27773ce93e4eSPoul-Henning Kamp 
277824f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD | CTLFLAG_MPSAFE,
27793ce93e4eSPoul-Henning Kamp 	sysctl_kern_proc, "Process table");
27803ce93e4eSPoul-Henning Kamp 
278124f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD | CTLFLAG_MPSAFE,
27823ce93e4eSPoul-Henning Kamp 	sysctl_kern_proc, "Process table");
27833ce93e4eSPoul-Henning Kamp 
278424f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD | CTLFLAG_MPSAFE,
278530c6f34eSScott Long 	sysctl_kern_proc, "Return process table, no threads");
278630c6f34eSScott Long 
27870c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args,
278824f87fdbSJohn Baldwin 	CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE,
27899b6d9dbaSPoul-Henning Kamp 	sysctl_kern_proc_args, "Process argument list");
2790baf731e6SRobert Drehmel 
279145efc9b4SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_ENV, env, CTLFLAG_RD | CTLFLAG_MPSAFE,
2792c5cfcb1cSMikolaj Golub 	sysctl_kern_proc_env, "Process environment");
2793c5cfcb1cSMikolaj Golub 
279445efc9b4SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_AUXV, auxv, CTLFLAG_RD |
279545efc9b4SMikolaj Golub 	CTLFLAG_MPSAFE, sysctl_kern_proc_auxv, "Process ELF auxiliary vector");
2796c5cfcb1cSMikolaj Golub 
279724f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD |
279824f87fdbSJohn Baldwin 	CTLFLAG_MPSAFE, sysctl_kern_proc_pathname, "Process executable path");
2799fe769cddSDavid Schultz 
280024f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD |
280124f87fdbSJohn Baldwin 	CTLFLAG_MPSAFE, sysctl_kern_proc_sv_name,
280224f87fdbSJohn Baldwin 	"Process syscall vector name (ABI type)");
28032648efa6SDaniel Eischen 
28040c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td,
280524f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2806078842c5SGarance A Drosehn 
28070c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td,
280824f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
28092648efa6SDaniel Eischen 
28100c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td,
281124f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2812b8fdc89dSGarance A Drosehn 
28130c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD),
281424f87fdbSJohn Baldwin 	sid_td, CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
28150c898376SPoul-Henning Kamp 
28160c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td,
281724f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2818b8fdc89dSGarance A Drosehn 
28190c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td,
282024f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
28212648efa6SDaniel Eischen 
28220c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td,
282324f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
28242648efa6SDaniel Eischen 
28250c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td,
282624f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
28272648efa6SDaniel Eischen 
28280c898376SPoul-Henning Kamp static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td,
282924f87fdbSJohn Baldwin 	CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc,
283024f87fdbSJohn Baldwin 	"Return process table, no threads");
2831cc43c38cSRobert Watson 
283243151ee6SPeter Wemm #ifdef COMPAT_FREEBSD7
283324f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_OVMMAP, ovmmap, CTLFLAG_RD |
283424f87fdbSJohn Baldwin 	CTLFLAG_MPSAFE, sysctl_kern_proc_ovmmap, "Old Process vm map entries");
283543151ee6SPeter Wemm #endif
283643151ee6SPeter Wemm 
283724f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_VMMAP, vmmap, CTLFLAG_RD |
283824f87fdbSJohn Baldwin 	CTLFLAG_MPSAFE, sysctl_kern_proc_vmmap, "Process vm map entries");
28391cc8c45cSRobert Watson 
28401cc8c45cSRobert Watson #if defined(STACK) || defined(DDB)
284124f87fdbSJohn Baldwin static SYSCTL_NODE(_kern_proc, KERN_PROC_KSTACK, kstack, CTLFLAG_RD |
284224f87fdbSJohn Baldwin 	CTLFLAG_MPSAFE, sysctl_kern_proc_kstack, "Process kernel stacks");
28431cc8c45cSRobert Watson #endif
2844254d03c5SBrooks Davis 
2845254d03c5SBrooks Davis static SYSCTL_NODE(_kern_proc, KERN_PROC_GROUPS, groups, CTLFLAG_RD |
2846254d03c5SBrooks Davis 	CTLFLAG_MPSAFE, sysctl_kern_proc_groups, "Process groups");
28479e7d0583SMikolaj Golub 
28488854fe39SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_RLIMIT, rlimit, CTLFLAG_RW |
28498854fe39SMikolaj Golub 	CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_rlimit,
28508854fe39SMikolaj Golub 	"Process resource limits");
28519732458fSMikolaj Golub 
285245efc9b4SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_PS_STRINGS, ps_strings, CTLFLAG_RD |
285345efc9b4SMikolaj Golub 	CTLFLAG_MPSAFE, sysctl_kern_proc_ps_strings,
285445efc9b4SMikolaj Golub 	"Process ps_strings location");
28556ce13747SMikolaj Golub 
2856e0fcf639SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_UMASK, umask, CTLFLAG_RD |
2857e0fcf639SMikolaj Golub 	CTLFLAG_MPSAFE, sysctl_kern_proc_umask, "Process umask");
2858903712c9SMikolaj Golub 
2859903712c9SMikolaj Golub static SYSCTL_NODE(_kern_proc, KERN_PROC_OSREL, osrel, CTLFLAG_RW |
2860903712c9SMikolaj Golub 	CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_osrel,
2861903712c9SMikolaj Golub 	"Process binary osreldate");
286280c3af4eSKonstantin Belousov 
286380c3af4eSKonstantin Belousov static SYSCTL_NODE(_kern_proc, KERN_PROC_SIGTRAMP, sigtramp, CTLFLAG_RD |
286480c3af4eSKonstantin Belousov 	CTLFLAG_MPSAFE, sysctl_kern_proc_sigtramp,
286580c3af4eSKonstantin Belousov 	"Process signal trampoline location");
2866