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