2 * Copyright (c) 1982, 1986, 1989, 1991, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
36 #include "opt_kdtrace.h"
37 #include "opt_ktrace.h"
38 #include "opt_kstack_pages.h"
39 #include "opt_stack.h"
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/kernel.h>
45 #include <sys/malloc.h>
46 #include <sys/mount.h>
47 #include <sys/mutex.h>
49 #include <sys/refcount.h>
51 #include <sys/sysent.h>
52 #include <sys/sched.h>
54 #include <sys/stack.h>
55 #include <sys/sysctl.h>
56 #include <sys/filedesc.h>
58 #include <sys/signalvar.h>
63 #include <sys/vnode.h>
64 #include <sys/eventhandler.h>
67 #include <sys/ktrace.h>
75 #include <vm/vm_extern.h>
77 #include <vm/vm_map.h>
78 #include <vm/vm_object.h>
81 SDT_PROVIDER_DEFINE(proc
);
82 SDT_PROBE_DEFINE(proc
, kernel
, ctor
, entry
);
83 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, entry
, 0, "struct proc *");
84 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, entry
, 1, "int");
85 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, entry
, 2, "void *");
86 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, entry
, 3, "int");
87 SDT_PROBE_DEFINE(proc
, kernel
, ctor
, return);
88 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, return, 0, "struct proc *");
89 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, return, 1, "int");
90 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, return, 2, "void *");
91 SDT_PROBE_ARGTYPE(proc
, kernel
, ctor
, return, 3, "int");
92 SDT_PROBE_DEFINE(proc
, kernel
, dtor
, entry
);
93 SDT_PROBE_ARGTYPE(proc
, kernel
, dtor
, entry
, 0, "struct proc *");
94 SDT_PROBE_ARGTYPE(proc
, kernel
, dtor
, entry
, 1, "int");
95 SDT_PROBE_ARGTYPE(proc
, kernel
, dtor
, entry
, 2, "void *");
96 SDT_PROBE_ARGTYPE(proc
, kernel
, dtor
, entry
, 3, "struct thread *");
97 SDT_PROBE_DEFINE(proc
, kernel
, dtor
, return);
98 SDT_PROBE_ARGTYPE(proc
, kernel
, dtor
, return, 0, "struct proc *");
99 SDT_PROBE_ARGTYPE(proc
, kernel
, dtor
, return, 1, "int");
100 SDT_PROBE_ARGTYPE(proc
, kernel
, dtor
, return, 2, "void *");
101 SDT_PROBE_DEFINE(proc
, kernel
, init
, entry
);
102 SDT_PROBE_ARGTYPE(proc
, kernel
, init
, entry
, 0, "struct proc *");
103 SDT_PROBE_ARGTYPE(proc
, kernel
, init
, entry
, 1, "int");
104 SDT_PROBE_ARGTYPE(proc
, kernel
, init
, entry
, 2, "int");
105 SDT_PROBE_DEFINE(proc
, kernel
, init
, return);
106 SDT_PROBE_ARGTYPE(proc
, kernel
, init
, return, 0, "struct proc *");
107 SDT_PROBE_ARGTYPE(proc
, kernel
, init
, return, 1, "int");
108 SDT_PROBE_ARGTYPE(proc
, kernel
, init
, return, 2, "int");
110 MALLOC_DEFINE(M_PGRP
, "pgrp", "process group header");
111 MALLOC_DEFINE(M_SESSION
, "session", "session header");
112 static MALLOC_DEFINE(M_PROC
, "proc", "Proc structures");
113 MALLOC_DEFINE(M_SUBPROC
, "subproc", "Proc sub-structures");
115 static void doenterpgrp(struct proc
*, struct pgrp
*);
116 static void orphanpg(struct pgrp
*pg
);
117 static void fill_kinfo_proc_only(struct proc
*p
, struct kinfo_proc
*kp
);
118 static void fill_kinfo_thread(struct thread
*td
, struct kinfo_proc
*kp
,
120 static void pgadjustjobc(struct pgrp
*pgrp
, int entering
);
121 static void pgdelete(struct pgrp
*);
122 static int proc_ctor(void *mem
, int size
, void *arg
, int flags
);
123 static void proc_dtor(void *mem
, int size
, void *arg
);
124 static int proc_init(void *mem
, int size
, int flags
);
125 static void proc_fini(void *mem
, int size
);
126 static void pargs_free(struct pargs
*pa
);
129 * Other process lists
131 struct pidhashhead
*pidhashtbl
;
133 struct pgrphashhead
*pgrphashtbl
;
135 struct proclist allproc
;
136 struct proclist zombproc
;
137 struct sx allproc_lock
;
138 struct sx proctree_lock
;
139 struct mtx ppeers_lock
;
140 uma_zone_t proc_zone
;
141 uma_zone_t ithread_zone
;
143 int kstack_pages
= KSTACK_PAGES
;
144 SYSCTL_INT(_kern
, OID_AUTO
, kstack_pages
, CTLFLAG_RD
, &kstack_pages
, 0, "");
146 CTASSERT(sizeof(struct kinfo_proc
) == KINFO_PROC_SIZE
);
149 * Initialize global process hashing structures.
155 sx_init(&allproc_lock
, "allproc");
156 sx_init(&proctree_lock
, "proctree");
157 mtx_init(&ppeers_lock
, "p_peers", NULL
, MTX_DEF
);
159 LIST_INIT(&zombproc
);
160 pidhashtbl
= hashinit(maxproc
/ 4, M_PROC
, &pidhash
);
161 pgrphashtbl
= hashinit(maxproc
/ 4, M_PROC
, &pgrphash
);
162 proc_zone
= uma_zcreate("PROC", sched_sizeof_proc(),
163 proc_ctor
, proc_dtor
, proc_init
, proc_fini
,
164 UMA_ALIGN_PTR
, UMA_ZONE_NOFREE
);
169 * Prepare a proc for use.
172 proc_ctor(void *mem
, int size
, void *arg
, int flags
)
176 p
= (struct proc
*)mem
;
177 SDT_PROBE(proc
, kernel
, ctor
, entry
, p
, size
, arg
, flags
, 0);
178 EVENTHANDLER_INVOKE(process_ctor
, p
);
179 SDT_PROBE(proc
, kernel
, ctor
, return, p
, size
, arg
, flags
, 0);
184 * Reclaim a proc after use.
187 proc_dtor(void *mem
, int size
, void *arg
)
192 /* INVARIANTS checks go here */
193 p
= (struct proc
*)mem
;
194 td
= FIRST_THREAD_IN_PROC(p
);
195 SDT_PROBE(proc
, kernel
, dtor
, entry
, p
, size
, arg
, td
, 0);
198 KASSERT((p
->p_numthreads
== 1),
199 ("bad number of threads in exiting process"));
200 KASSERT(STAILQ_EMPTY(&p
->p_ktr
), ("proc_dtor: non-empty p_ktr"));
202 /* Dispose of an alternate kstack, if it exists.
203 * XXX What if there are more than one thread in the proc?
204 * The first thread in the proc is special and not
205 * freed, so you gotta do this here.
207 if (((p
->p_flag
& P_KTHREAD
) != 0) && (td
->td_altkstack
!= 0))
208 vm_thread_dispose_altkstack(td
);
210 EVENTHANDLER_INVOKE(process_dtor
, p
);
211 if (p
->p_ksi
!= NULL
)
212 KASSERT(! KSI_ONQ(p
->p_ksi
), ("SIGCHLD queue"));
213 SDT_PROBE(proc
, kernel
, dtor
, return, p
, size
, arg
, 0, 0);
217 * Initialize type-stable parts of a proc (when newly created).
220 proc_init(void *mem
, int size
, int flags
)
224 p
= (struct proc
*)mem
;
225 SDT_PROBE(proc
, kernel
, init
, entry
, p
, size
, flags
, 0, 0);
226 p
->p_sched
= (struct p_sched
*)&p
[1];
227 bzero(&p
->p_mtx
, sizeof(struct mtx
));
228 mtx_init(&p
->p_mtx
, "process lock", NULL
, MTX_DEF
| MTX_DUPOK
);
229 mtx_init(&p
->p_slock
, "process slock", NULL
, MTX_SPIN
| MTX_RECURSE
);
230 TAILQ_INIT(&p
->p_threads
); /* all threads in proc */
231 EVENTHANDLER_INVOKE(process_init
, p
);
232 p
->p_stats
= pstats_alloc();
233 SDT_PROBE(proc
, kernel
, init
, return, p
, size
, flags
, 0, 0);
238 * UMA should ensure that this function is never called.
239 * Freeing a proc structure would violate type stability.
242 proc_fini(void *mem
, int size
)
247 p
= (struct proc
*)mem
;
248 EVENTHANDLER_INVOKE(process_fini
, p
);
249 pstats_free(p
->p_stats
);
250 thread_free(FIRST_THREAD_IN_PROC(p
));
251 mtx_destroy(&p
->p_mtx
);
252 if (p
->p_ksi
!= NULL
)
253 ksiginfo_free(p
->p_ksi
);
255 panic("proc reclaimed");
260 * Is p an inferior of the current process?
264 register struct proc
*p
;
267 sx_assert(&proctree_lock
, SX_LOCKED
);
268 for (; p
!= curproc
; p
= p
->p_pptr
)
275 * Locate a process by number; return only "live" processes -- i.e., neither
276 * zombies nor newly born but incompletely initialized processes. By not
277 * returning processes in the PRS_NEW state, we allow callers to avoid
278 * testing for that condition to avoid dereferencing p_ucred, et al.
284 register struct proc
*p
;
286 sx_slock(&allproc_lock
);
287 LIST_FOREACH(p
, PIDHASH(pid
), p_hash
)
288 if (p
->p_pid
== pid
) {
289 if (p
->p_state
== PRS_NEW
) {
296 sx_sunlock(&allproc_lock
);
301 * Locate a process group by number.
302 * The caller must hold proctree_lock.
308 register struct pgrp
*pgrp
;
310 sx_assert(&proctree_lock
, SX_LOCKED
);
312 LIST_FOREACH(pgrp
, PGRPHASH(pgid
), pg_hash
) {
313 if (pgrp
->pg_id
== pgid
) {
322 * Create a new process group.
323 * pgid must be equal to the pid of p.
324 * Begin a new session if required.
327 enterpgrp(p
, pgid
, pgrp
, sess
)
328 register struct proc
*p
;
331 struct session
*sess
;
335 sx_assert(&proctree_lock
, SX_XLOCKED
);
337 KASSERT(pgrp
!= NULL
, ("enterpgrp: pgrp == NULL"));
338 KASSERT(p
->p_pid
== pgid
,
339 ("enterpgrp: new pgrp and pid != pgid"));
341 pgrp2
= pgfind(pgid
);
343 KASSERT(pgrp2
== NULL
,
344 ("enterpgrp: pgrp with pgid exists"));
345 KASSERT(!SESS_LEADER(p
),
346 ("enterpgrp: session leader attempted setpgrp"));
348 mtx_init(&pgrp
->pg_mtx
, "process group", NULL
, MTX_DEF
| MTX_DUPOK
);
354 mtx_init(&sess
->s_mtx
, "session", NULL
, MTX_DEF
);
356 p
->p_flag
&= ~P_CONTROLT
;
360 sess
->s_sid
= p
->p_pid
;
361 refcount_init(&sess
->s_count
, 1);
362 sess
->s_ttyvp
= NULL
;
364 bcopy(p
->p_session
->s_login
, sess
->s_login
,
365 sizeof(sess
->s_login
));
366 pgrp
->pg_session
= sess
;
367 KASSERT(p
== curproc
,
368 ("enterpgrp: mksession and p != curproc"));
370 pgrp
->pg_session
= p
->p_session
;
371 sess_hold(pgrp
->pg_session
);
375 LIST_INIT(&pgrp
->pg_members
);
378 * As we have an exclusive lock of proctree_lock,
379 * this should not deadlock.
381 LIST_INSERT_HEAD(PGRPHASH(pgid
), pgrp
, pg_hash
);
383 SLIST_INIT(&pgrp
->pg_sigiolst
);
386 doenterpgrp(p
, pgrp
);
392 * Move p to an existing process group
395 enterthispgrp(p
, pgrp
)
396 register struct proc
*p
;
400 sx_assert(&proctree_lock
, SX_XLOCKED
);
401 PROC_LOCK_ASSERT(p
, MA_NOTOWNED
);
402 PGRP_LOCK_ASSERT(pgrp
, MA_NOTOWNED
);
403 PGRP_LOCK_ASSERT(p
->p_pgrp
, MA_NOTOWNED
);
404 SESS_LOCK_ASSERT(p
->p_session
, MA_NOTOWNED
);
405 KASSERT(pgrp
->pg_session
== p
->p_session
,
406 ("%s: pgrp's session %p, p->p_session %p.\n",
410 KASSERT(pgrp
!= p
->p_pgrp
,
411 ("%s: p belongs to pgrp.", __func__
));
413 doenterpgrp(p
, pgrp
);
419 * Move p to a process group
426 struct pgrp
*savepgrp
;
428 sx_assert(&proctree_lock
, SX_XLOCKED
);
429 PROC_LOCK_ASSERT(p
, MA_NOTOWNED
);
430 PGRP_LOCK_ASSERT(pgrp
, MA_NOTOWNED
);
431 PGRP_LOCK_ASSERT(p
->p_pgrp
, MA_NOTOWNED
);
432 SESS_LOCK_ASSERT(p
->p_session
, MA_NOTOWNED
);
434 savepgrp
= p
->p_pgrp
;
437 * Adjust eligibility of affected pgrps to participate in job control.
438 * Increment eligibility counts before decrementing, otherwise we
439 * could reach 0 spuriously during the first call.
442 fixjobc(p
, p
->p_pgrp
, 0);
447 LIST_REMOVE(p
, p_pglist
);
450 LIST_INSERT_HEAD(&pgrp
->pg_members
, p
, p_pglist
);
451 PGRP_UNLOCK(savepgrp
);
453 if (LIST_EMPTY(&savepgrp
->pg_members
))
458 * remove process from process group
462 register struct proc
*p
;
464 struct pgrp
*savepgrp
;
466 sx_assert(&proctree_lock
, SX_XLOCKED
);
467 savepgrp
= p
->p_pgrp
;
470 LIST_REMOVE(p
, p_pglist
);
473 PGRP_UNLOCK(savepgrp
);
474 if (LIST_EMPTY(&savepgrp
->pg_members
))
480 * delete a process group
484 register struct pgrp
*pgrp
;
486 struct session
*savesess
;
489 sx_assert(&proctree_lock
, SX_XLOCKED
);
490 PGRP_LOCK_ASSERT(pgrp
, MA_NOTOWNED
);
491 SESS_LOCK_ASSERT(pgrp
->pg_session
, MA_NOTOWNED
);
494 * Reset any sigio structures pointing to us as a result of
495 * F_SETOWN with our pgid.
497 funsetownlst(&pgrp
->pg_sigiolst
);
500 tp
= pgrp
->pg_session
->s_ttyp
;
501 LIST_REMOVE(pgrp
, pg_hash
);
502 savesess
= pgrp
->pg_session
;
505 /* Remove the reference to the pgrp before deallocating it. */
508 tty_rel_pgrp(tp
, pgrp
);
512 mtx_destroy(&pgrp
->pg_mtx
);
514 sess_release(savesess
);
518 pgadjustjobc(pgrp
, entering
)
528 if (pgrp
->pg_jobc
== 0)
535 * Adjust pgrp jobc counters when specified process changes process group.
536 * We count the number of processes in each process group that "qualify"
537 * the group for terminal job control (those with a parent in a different
538 * process group of the same session). If that count reaches zero, the
539 * process group becomes orphaned. Check both the specified process'
540 * process group and that of its children.
541 * entering == 0 => p is leaving specified group.
542 * entering == 1 => p is entering specified group.
545 fixjobc(p
, pgrp
, entering
)
546 register struct proc
*p
;
547 register struct pgrp
*pgrp
;
550 register struct pgrp
*hispgrp
;
551 register struct session
*mysession
;
553 sx_assert(&proctree_lock
, SX_LOCKED
);
554 PROC_LOCK_ASSERT(p
, MA_NOTOWNED
);
555 PGRP_LOCK_ASSERT(pgrp
, MA_NOTOWNED
);
556 SESS_LOCK_ASSERT(pgrp
->pg_session
, MA_NOTOWNED
);
559 * Check p's parent to see whether p qualifies its own process
560 * group; if so, adjust count for p's process group.
562 mysession
= pgrp
->pg_session
;
563 if ((hispgrp
= p
->p_pptr
->p_pgrp
) != pgrp
&&
564 hispgrp
->pg_session
== mysession
)
565 pgadjustjobc(pgrp
, entering
);
568 * Check this process' children to see whether they qualify
569 * their process groups; if so, adjust counts for children's
572 LIST_FOREACH(p
, &p
->p_children
, p_sibling
) {
574 if (hispgrp
== pgrp
||
575 hispgrp
->pg_session
!= mysession
)
578 if (p
->p_state
== PRS_ZOMBIE
) {
583 pgadjustjobc(hispgrp
, entering
);
588 * A process group has become orphaned;
589 * if there are any stopped processes in the group,
590 * hang-up all process in that group.
596 register struct proc
*p
;
598 PGRP_LOCK_ASSERT(pg
, MA_OWNED
);
600 LIST_FOREACH(p
, &pg
->pg_members
, p_pglist
) {
602 if (P_SHOULDSTOP(p
)) {
604 LIST_FOREACH(p
, &pg
->pg_members
, p_pglist
) {
617 sess_hold(struct session
*s
)
620 refcount_acquire(&s
->s_count
);
624 sess_release(struct session
*s
)
627 if (refcount_release(&s
->s_count
)) {
628 if (s
->s_ttyp
!= NULL
) {
630 tty_rel_sess(s
->s_ttyp
, s
);
632 mtx_destroy(&s
->s_mtx
);
641 DB_SHOW_COMMAND(pgrpdump
, pgrpdump
)
643 register struct pgrp
*pgrp
;
644 register struct proc
*p
;
647 for (i
= 0; i
<= pgrphash
; i
++) {
648 if (!LIST_EMPTY(&pgrphashtbl
[i
])) {
649 printf("\tindx %d\n", i
);
650 LIST_FOREACH(pgrp
, &pgrphashtbl
[i
], pg_hash
) {
652 "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
653 (void *)pgrp
, (long)pgrp
->pg_id
,
654 (void *)pgrp
->pg_session
,
655 pgrp
->pg_session
->s_count
,
656 (void *)LIST_FIRST(&pgrp
->pg_members
));
657 LIST_FOREACH(p
, &pgrp
->pg_members
, p_pglist
) {
658 printf("\t\tpid %ld addr %p pgrp %p\n",
659 (long)p
->p_pid
, (void *)p
,
669 * Clear kinfo_proc and fill in any information that is common
670 * to all threads in the process.
671 * Must be called with the target process locked.
674 fill_kinfo_proc_only(struct proc
*p
, struct kinfo_proc
*kp
)
682 PROC_LOCK_ASSERT(p
, MA_OWNED
);
683 bzero(kp
, sizeof(*kp
));
685 kp
->ki_structsize
= sizeof(*kp
);
687 kp
->ki_addr
=/* p->p_addr; */0; /* XXX */
688 kp
->ki_args
= p
->p_args
;
689 kp
->ki_textvp
= p
->p_textvp
;
691 kp
->ki_tracep
= p
->p_tracevp
;
692 mtx_lock(&ktrace_mtx
);
693 kp
->ki_traceflag
= p
->p_traceflag
;
694 mtx_unlock(&ktrace_mtx
);
697 kp
->ki_vmspace
= p
->p_vmspace
;
698 kp
->ki_flag
= p
->p_flag
;
701 kp
->ki_uid
= cred
->cr_uid
;
702 kp
->ki_ruid
= cred
->cr_ruid
;
703 kp
->ki_svuid
= cred
->cr_svuid
;
704 /* XXX bde doesn't like KI_NGROUPS */
705 kp
->ki_ngroups
= min(cred
->cr_ngroups
, KI_NGROUPS
);
706 bcopy(cred
->cr_groups
, kp
->ki_groups
,
707 kp
->ki_ngroups
* sizeof(gid_t
));
708 kp
->ki_rgid
= cred
->cr_rgid
;
709 kp
->ki_svgid
= cred
->cr_svgid
;
710 /* If jailed(cred), emulate the old P_JAILED flag. */
712 kp
->ki_flag
|= P_JAILED
;
713 /* If inside a jail, use 0 as a jail ID. */
714 if (!jailed(curthread
->td_ucred
))
715 kp
->ki_jid
= cred
->cr_prison
->pr_id
;
720 mtx_lock(&ps
->ps_mtx
);
721 kp
->ki_sigignore
= ps
->ps_sigignore
;
722 kp
->ki_sigcatch
= ps
->ps_sigcatch
;
723 mtx_unlock(&ps
->ps_mtx
);
726 if (p
->p_state
!= PRS_NEW
&&
727 p
->p_state
!= PRS_ZOMBIE
&&
728 p
->p_vmspace
!= NULL
) {
729 struct vmspace
*vm
= p
->p_vmspace
;
731 kp
->ki_size
= vm
->vm_map
.size
;
732 kp
->ki_rssize
= vmspace_resident_count(vm
); /*XXX*/
733 FOREACH_THREAD_IN_PROC(p
, td0
) {
734 if (!TD_IS_SWAPPED(td0
))
735 kp
->ki_rssize
+= td0
->td_kstack_pages
;
736 if (td0
->td_altkstack_obj
!= NULL
)
737 kp
->ki_rssize
+= td0
->td_altkstack_pages
;
739 kp
->ki_swrss
= vm
->vm_swrss
;
740 kp
->ki_tsize
= vm
->vm_tsize
;
741 kp
->ki_dsize
= vm
->vm_dsize
;
742 kp
->ki_ssize
= vm
->vm_ssize
;
743 } else if (p
->p_state
== PRS_ZOMBIE
)
745 if (kp
->ki_flag
& P_INMEM
)
746 kp
->ki_sflag
= PS_INMEM
;
749 /* Calculate legacy swtime as seconds since 'swtick'. */
750 kp
->ki_swtime
= (ticks
- p
->p_swtick
) / hz
;
751 kp
->ki_pid
= p
->p_pid
;
752 kp
->ki_nice
= p
->p_nice
;
753 rufetch(p
, &kp
->ki_rusage
);
754 kp
->ki_runtime
= cputick2usec(p
->p_rux
.rux_runtime
);
756 if ((p
->p_flag
& P_INMEM
) && p
->p_stats
!= NULL
) {
757 kp
->ki_start
= p
->p_stats
->p_start
;
758 timevaladd(&kp
->ki_start
, &boottime
);
760 calcru(p
, &kp
->ki_rusage
.ru_utime
, &kp
->ki_rusage
.ru_stime
);
762 calccru(p
, &kp
->ki_childutime
, &kp
->ki_childstime
);
764 /* Some callers want child-times in a single value */
765 kp
->ki_childtime
= kp
->ki_childstime
;
766 timevaladd(&kp
->ki_childtime
, &kp
->ki_childutime
);
770 kp
->ki_pgid
= p
->p_pgrp
->pg_id
;
771 kp
->ki_jobc
= p
->p_pgrp
->pg_jobc
;
772 sp
= p
->p_pgrp
->pg_session
;
775 kp
->ki_sid
= sp
->s_sid
;
777 strlcpy(kp
->ki_login
, sp
->s_login
,
778 sizeof(kp
->ki_login
));
780 kp
->ki_kiflag
|= KI_CTTY
;
782 kp
->ki_kiflag
|= KI_SLEADER
;
783 /* XXX proctree_lock */
788 if ((p
->p_flag
& P_CONTROLT
) && tp
!= NULL
) {
789 kp
->ki_tdev
= tty_udev(tp
);
790 kp
->ki_tpgid
= tp
->t_pgrp
? tp
->t_pgrp
->pg_id
: NO_PID
;
792 kp
->ki_tsid
= tp
->t_session
->s_sid
;
795 if (p
->p_comm
[0] != '\0')
796 strlcpy(kp
->ki_comm
, p
->p_comm
, sizeof(kp
->ki_comm
));
797 if (p
->p_sysent
&& p
->p_sysent
->sv_name
!= NULL
&&
798 p
->p_sysent
->sv_name
[0] != '\0')
799 strlcpy(kp
->ki_emul
, p
->p_sysent
->sv_name
, sizeof(kp
->ki_emul
));
800 kp
->ki_siglist
= p
->p_siglist
;
801 kp
->ki_xstat
= p
->p_xstat
;
802 kp
->ki_acflag
= p
->p_acflag
;
803 kp
->ki_lock
= p
->p_lock
;
805 kp
->ki_ppid
= p
->p_pptr
->p_pid
;
809 * Fill in information that is thread specific. Must be called with p_slock
810 * locked. If 'preferthread' is set, overwrite certain process-related
811 * fields that are maintained for both threads and processes.
814 fill_kinfo_thread(struct thread
*td
, struct kinfo_proc
*kp
, int preferthread
)
819 PROC_LOCK_ASSERT(p
, MA_OWNED
);
822 if (td
->td_wmesg
!= NULL
)
823 strlcpy(kp
->ki_wmesg
, td
->td_wmesg
, sizeof(kp
->ki_wmesg
));
825 bzero(kp
->ki_wmesg
, sizeof(kp
->ki_wmesg
));
826 if (td
->td_name
[0] != '\0')
827 strlcpy(kp
->ki_ocomm
, td
->td_name
, sizeof(kp
->ki_ocomm
));
828 if (TD_ON_LOCK(td
)) {
829 kp
->ki_kiflag
|= KI_LOCKBLOCK
;
830 strlcpy(kp
->ki_lockname
, td
->td_lockname
,
831 sizeof(kp
->ki_lockname
));
833 kp
->ki_kiflag
&= ~KI_LOCKBLOCK
;
834 bzero(kp
->ki_lockname
, sizeof(kp
->ki_lockname
));
837 if (p
->p_state
== PRS_NORMAL
) { /* approximate. */
838 if (TD_ON_RUNQ(td
) ||
842 } else if (P_SHOULDSTOP(p
)) {
844 } else if (TD_IS_SLEEPING(td
)) {
845 kp
->ki_stat
= SSLEEP
;
846 } else if (TD_ON_LOCK(td
)) {
851 } else if (p
->p_state
== PRS_ZOMBIE
) {
857 /* Things in the thread */
858 kp
->ki_wchan
= td
->td_wchan
;
859 kp
->ki_pri
.pri_level
= td
->td_priority
;
860 kp
->ki_pri
.pri_native
= td
->td_base_pri
;
861 kp
->ki_lastcpu
= td
->td_lastcpu
;
862 kp
->ki_oncpu
= td
->td_oncpu
;
863 kp
->ki_tdflags
= td
->td_flags
;
864 kp
->ki_tid
= td
->td_tid
;
865 kp
->ki_numthreads
= p
->p_numthreads
;
866 kp
->ki_pcb
= td
->td_pcb
;
867 kp
->ki_kstack
= (void *)td
->td_kstack
;
868 kp
->ki_pctcpu
= sched_pctcpu(td
);
869 kp
->ki_estcpu
= td
->td_estcpu
;
870 kp
->ki_slptime
= (ticks
- td
->td_slptick
) / hz
;
871 kp
->ki_pri
.pri_class
= td
->td_pri_class
;
872 kp
->ki_pri
.pri_user
= td
->td_user_pri
;
875 kp
->ki_runtime
= cputick2usec(td
->td_runtime
);
877 /* We can't get this anymore but ps etc never used it anyway. */
880 SIGSETOR(kp
->ki_siglist
, td
->td_siglist
);
881 kp
->ki_sigmask
= td
->td_sigmask
;
886 * Fill in a kinfo_proc structure for the specified process.
887 * Must be called with the target process locked.
890 fill_kinfo_proc(struct proc
*p
, struct kinfo_proc
*kp
)
893 fill_kinfo_proc_only(p
, kp
);
894 if (FIRST_THREAD_IN_PROC(p
) != NULL
)
895 fill_kinfo_thread(FIRST_THREAD_IN_PROC(p
), kp
, 0);
902 return (malloc(sizeof(struct pstats
), M_SUBPROC
, M_ZERO
|M_WAITOK
));
906 * Copy parts of p_stats; zero the rest of p_stats (statistics).
909 pstats_fork(struct pstats
*src
, struct pstats
*dst
)
912 bzero(&dst
->pstat_startzero
,
913 __rangeof(struct pstats
, pstat_startzero
, pstat_endzero
));
914 bcopy(&src
->pstat_startcopy
, &dst
->pstat_startcopy
,
915 __rangeof(struct pstats
, pstat_startcopy
, pstat_endcopy
));
919 pstats_free(struct pstats
*ps
)
926 * Locate a zombie process by number
933 sx_slock(&allproc_lock
);
934 LIST_FOREACH(p
, &zombproc
, p_list
)
935 if (p
->p_pid
== pid
) {
939 sx_sunlock(&allproc_lock
);
943 #define KERN_PROC_ZOMBMASK 0x3
944 #define KERN_PROC_NOTHREADS 0x4
947 * Must be called with the process locked and will return with it unlocked.
950 sysctl_out_proc(struct proc
*p
, struct sysctl_req
*req
, int flags
)
953 struct kinfo_proc kinfo_proc
;
956 pid_t pid
= p
->p_pid
;
958 PROC_LOCK_ASSERT(p
, MA_OWNED
);
960 fill_kinfo_proc_only(p
, &kinfo_proc
);
961 if (flags
& KERN_PROC_NOTHREADS
) {
962 if (FIRST_THREAD_IN_PROC(p
) != NULL
)
963 fill_kinfo_thread(FIRST_THREAD_IN_PROC(p
),
965 error
= SYSCTL_OUT(req
, (caddr_t
)&kinfo_proc
,
968 if (FIRST_THREAD_IN_PROC(p
) != NULL
)
969 FOREACH_THREAD_IN_PROC(p
, td
) {
970 fill_kinfo_thread(td
, &kinfo_proc
, 1);
971 error
= SYSCTL_OUT(req
, (caddr_t
)&kinfo_proc
,
977 error
= SYSCTL_OUT(req
, (caddr_t
)&kinfo_proc
,
983 if (flags
& KERN_PROC_ZOMBMASK
)
1001 sysctl_kern_proc(SYSCTL_HANDLER_ARGS
)
1003 int *name
= (int*) arg1
;
1004 u_int namelen
= arg2
;
1006 int flags
, doingzomb
, oid_number
;
1009 oid_number
= oidp
->oid_number
;
1010 if (oid_number
!= KERN_PROC_ALL
&&
1011 (oid_number
& KERN_PROC_INC_THREAD
) == 0)
1012 flags
= KERN_PROC_NOTHREADS
;
1015 oid_number
&= ~KERN_PROC_INC_THREAD
;
1017 if (oid_number
== KERN_PROC_PID
) {
1020 error
= sysctl_wire_old_buffer(req
, 0);
1023 p
= pfind((pid_t
)name
[0]);
1026 if ((error
= p_cansee(curthread
, p
))) {
1030 error
= sysctl_out_proc(p
, req
, flags
);
1034 switch (oid_number
) {
1039 case KERN_PROC_PROC
:
1040 if (namelen
!= 0 && namelen
!= 1)
1050 /* overestimate by 5 procs */
1051 error
= SYSCTL_OUT(req
, 0, sizeof (struct kinfo_proc
) * 5);
1055 error
= sysctl_wire_old_buffer(req
, 0);
1058 sx_slock(&allproc_lock
);
1059 for (doingzomb
=0 ; doingzomb
< 2 ; doingzomb
++) {
1061 p
= LIST_FIRST(&allproc
);
1063 p
= LIST_FIRST(&zombproc
);
1064 for (; p
!= 0; p
= LIST_NEXT(p
, p_list
)) {
1066 * Skip embryonic processes.
1069 if (p
->p_state
== PRS_NEW
) {
1075 KASSERT(p
->p_ucred
!= NULL
,
1076 ("process credential is NULL for non-NEW proc"));
1078 * Show a user only appropriate processes.
1080 if (p_cansee(curthread
, p
)) {
1085 * TODO - make more efficient (see notes below).
1088 switch (oid_number
) {
1091 if (p
->p_ucred
->cr_gid
!= (gid_t
)name
[0]) {
1097 case KERN_PROC_PGRP
:
1098 /* could do this by traversing pgrp */
1099 if (p
->p_pgrp
== NULL
||
1100 p
->p_pgrp
->pg_id
!= (pid_t
)name
[0]) {
1106 case KERN_PROC_RGID
:
1107 if (p
->p_ucred
->cr_rgid
!= (gid_t
)name
[0]) {
1113 case KERN_PROC_SESSION
:
1114 if (p
->p_session
== NULL
||
1115 p
->p_session
->s_sid
!= (pid_t
)name
[0]) {
1122 if ((p
->p_flag
& P_CONTROLT
) == 0 ||
1123 p
->p_session
== NULL
) {
1127 /* XXX proctree_lock */
1128 SESS_LOCK(p
->p_session
);
1129 if (p
->p_session
->s_ttyp
== NULL
||
1130 tty_udev(p
->p_session
->s_ttyp
) !=
1132 SESS_UNLOCK(p
->p_session
);
1136 SESS_UNLOCK(p
->p_session
);
1140 if (p
->p_ucred
->cr_uid
!= (uid_t
)name
[0]) {
1146 case KERN_PROC_RUID
:
1147 if (p
->p_ucred
->cr_ruid
!= (uid_t
)name
[0]) {
1153 case KERN_PROC_PROC
:
1161 error
= sysctl_out_proc(p
, req
, flags
| doingzomb
);
1163 sx_sunlock(&allproc_lock
);
1168 sx_sunlock(&allproc_lock
);
1173 pargs_alloc(int len
)
1177 MALLOC(pa
, struct pargs
*, sizeof(struct pargs
) + len
, M_PARGS
,
1179 refcount_init(&pa
->ar_ref
, 1);
1180 pa
->ar_length
= len
;
1185 pargs_free(struct pargs
*pa
)
1192 pargs_hold(struct pargs
*pa
)
1197 refcount_acquire(&pa
->ar_ref
);
1201 pargs_drop(struct pargs
*pa
)
1206 if (refcount_release(&pa
->ar_ref
))
1211 * This sysctl allows a process to retrieve the argument list or process
1212 * title for another process without groping around in the address space
1213 * of the other process. It also allow a process to set its own "process
1214 * title to a string of its own choice.
1217 sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS
)
1219 int *name
= (int*) arg1
;
1220 u_int namelen
= arg2
;
1221 struct pargs
*newpa
, *pa
;
1228 p
= pfind((pid_t
)name
[0]);
1232 if ((error
= p_cansee(curthread
, p
)) != 0) {
1237 if (req
->newptr
&& curproc
!= p
) {
1245 if (req
->oldptr
!= NULL
&& pa
!= NULL
)
1246 error
= SYSCTL_OUT(req
, pa
->ar_args
, pa
->ar_length
);
1248 if (error
!= 0 || req
->newptr
== NULL
)
1251 if (req
->newlen
+ sizeof(struct pargs
) > ps_arg_cache_limit
)
1253 newpa
= pargs_alloc(req
->newlen
);
1254 error
= SYSCTL_IN(req
, newpa
->ar_args
, req
->newlen
);
1268 * This sysctl allows a process to retrieve the path of the executable for
1269 * itself or another process.
1272 sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS
)
1274 pid_t
*pidp
= (pid_t
*)arg1
;
1275 unsigned int arglen
= arg2
;
1278 char *retbuf
, *freebuf
;
1283 if (*pidp
== -1) { /* -1 means this process */
1284 p
= req
->td
->td_proc
;
1289 if ((error
= p_cansee(curthread
, p
)) != 0) {
1304 error
= vn_fullpath(req
->td
, vp
, &retbuf
, &freebuf
);
1308 error
= SYSCTL_OUT(req
, retbuf
, strlen(retbuf
) + 1);
1309 free(freebuf
, M_TEMP
);
1314 sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS
)
1327 if ((p
= pfind((pid_t
)name
[0])) == NULL
)
1329 if ((error
= p_cansee(curthread
, p
))) {
1333 sv_name
= p
->p_sysent
->sv_name
;
1335 return (sysctl_handle_string(oidp
, sv_name
, 0, req
));
1339 sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS
)
1341 vm_map_entry_t entry
, tmp_entry
;
1342 unsigned int last_timestamp
;
1343 char *fullpath
, *freepath
;
1344 struct kinfo_vmentry
*kve
;
1351 if ((p
= pfind((pid_t
)name
[0])) == NULL
)
1353 if (p
->p_flag
& P_WEXIT
) {
1357 if ((error
= p_candebug(curthread
, p
))) {
1364 kve
= malloc(sizeof(*kve
), M_TEMP
, M_WAITOK
);
1366 map
= &p
->p_vmspace
->vm_map
; /* XXXRW: More locking required? */
1367 vm_map_lock_read(map
);
1368 for (entry
= map
->header
.next
; entry
!= &map
->header
;
1369 entry
= entry
->next
) {
1370 vm_object_t obj
, tobj
, lobj
;
1374 if (entry
->eflags
& MAP_ENTRY_IS_SUB_MAP
)
1377 bzero(kve
, sizeof(*kve
));
1378 kve
->kve_structsize
= sizeof(*kve
);
1380 kve
->kve_private_resident
= 0;
1381 obj
= entry
->object
.vm_object
;
1383 VM_OBJECT_LOCK(obj
);
1384 if (obj
->shadow_count
== 1)
1385 kve
->kve_private_resident
=
1386 obj
->resident_page_count
;
1388 kve
->kve_resident
= 0;
1389 addr
= entry
->start
;
1390 while (addr
< entry
->end
) {
1391 if (pmap_extract(map
->pmap
, addr
))
1392 kve
->kve_resident
++;
1396 for (lobj
= tobj
= obj
; tobj
; tobj
= tobj
->backing_object
) {
1398 VM_OBJECT_LOCK(tobj
);
1400 VM_OBJECT_UNLOCK(lobj
);
1408 switch(lobj
->type
) {
1410 kve
->kve_type
= KVME_TYPE_DEFAULT
;
1413 kve
->kve_type
= KVME_TYPE_VNODE
;
1418 kve
->kve_type
= KVME_TYPE_SWAP
;
1421 kve
->kve_type
= KVME_TYPE_DEVICE
;
1424 kve
->kve_type
= KVME_TYPE_PHYS
;
1427 kve
->kve_type
= KVME_TYPE_DEAD
;
1430 kve
->kve_type
= KVME_TYPE_UNKNOWN
;
1434 VM_OBJECT_UNLOCK(lobj
);
1436 kve
->kve_ref_count
= obj
->ref_count
;
1437 kve
->kve_shadow_count
= obj
->shadow_count
;
1438 VM_OBJECT_UNLOCK(obj
);
1440 vfslocked
= VFS_LOCK_GIANT(vp
->v_mount
);
1441 vn_lock(vp
, LK_EXCLUSIVE
| LK_RETRY
);
1442 vn_fullpath(curthread
, vp
, &fullpath
,
1445 VFS_UNLOCK_GIANT(vfslocked
);
1448 kve
->kve_type
= KVME_TYPE_NONE
;
1449 kve
->kve_ref_count
= 0;
1450 kve
->kve_shadow_count
= 0;
1453 kve
->kve_start
= (void*)entry
->start
;
1454 kve
->kve_end
= (void*)entry
->end
;
1456 if (entry
->protection
& VM_PROT_READ
)
1457 kve
->kve_protection
|= KVME_PROT_READ
;
1458 if (entry
->protection
& VM_PROT_WRITE
)
1459 kve
->kve_protection
|= KVME_PROT_WRITE
;
1460 if (entry
->protection
& VM_PROT_EXECUTE
)
1461 kve
->kve_protection
|= KVME_PROT_EXEC
;
1463 if (entry
->eflags
& MAP_ENTRY_COW
)
1464 kve
->kve_flags
|= KVME_FLAG_COW
;
1465 if (entry
->eflags
& MAP_ENTRY_NEEDS_COPY
)
1466 kve
->kve_flags
|= KVME_FLAG_NEEDS_COPY
;
1468 strlcpy(kve
->kve_path
, fullpath
, sizeof(kve
->kve_path
));
1469 if (freepath
!= NULL
)
1470 free(freepath
, M_TEMP
);
1472 last_timestamp
= map
->timestamp
;
1473 vm_map_unlock_read(map
);
1474 error
= SYSCTL_OUT(req
, kve
, sizeof(*kve
));
1475 vm_map_lock_read(map
);
1478 if (last_timestamp
+ 1 != map
->timestamp
) {
1479 vm_map_lookup_entry(map
, addr
- 1, &tmp_entry
);
1483 vm_map_unlock_read(map
);
1489 #if defined(STACK) || defined(DDB)
1491 sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS
)
1493 struct kinfo_kstack
*kkstp
;
1494 int error
, i
, *name
, numthreads
;
1495 lwpid_t
*lwpidarray
;
1502 if ((p
= pfind((pid_t
)name
[0])) == NULL
)
1504 /* XXXRW: Not clear ESRCH is the right error during proc execve(). */
1505 if (p
->p_flag
& P_WEXIT
|| p
->p_flag
& P_INEXEC
) {
1509 if ((error
= p_candebug(curthread
, p
))) {
1516 kkstp
= malloc(sizeof(*kkstp
), M_TEMP
, M_WAITOK
);
1517 st
= stack_create();
1523 if (numthreads
< p
->p_numthreads
) {
1524 if (lwpidarray
!= NULL
) {
1525 free(lwpidarray
, M_TEMP
);
1528 numthreads
= p
->p_numthreads
;
1530 lwpidarray
= malloc(sizeof(*lwpidarray
) * numthreads
, M_TEMP
,
1538 * XXXRW: During the below loop, execve(2) and countless other sorts
1539 * of changes could have taken place. Should we check to see if the
1540 * vmspace has been replaced, or the like, in order to prevent
1541 * giving a snapshot that spans, say, execve(2), with some threads
1542 * before and some after? Among other things, the credentials could
1543 * have changed, in which case the right to extract debug info might
1544 * no longer be assured.
1546 FOREACH_THREAD_IN_PROC(p
, td
) {
1547 KASSERT(i
< numthreads
,
1548 ("sysctl_kern_proc_kstack: numthreads"));
1549 lwpidarray
[i
] = td
->td_tid
;
1553 for (i
= 0; i
< numthreads
; i
++) {
1554 td
= thread_find(p
, lwpidarray
[i
]);
1558 bzero(kkstp
, sizeof(*kkstp
));
1559 (void)sbuf_new(&sb
, kkstp
->kkst_trace
,
1560 sizeof(kkstp
->kkst_trace
), SBUF_FIXEDLEN
);
1562 kkstp
->kkst_tid
= td
->td_tid
;
1563 if (TD_IS_SWAPPED(td
))
1564 kkstp
->kkst_state
= KKST_STATE_SWAPPED
;
1565 else if (TD_IS_RUNNING(td
))
1566 kkstp
->kkst_state
= KKST_STATE_RUNNING
;
1568 kkstp
->kkst_state
= KKST_STATE_STACKOK
;
1569 stack_save_td(st
, td
);
1573 stack_sbuf_print(&sb
, st
);
1576 error
= SYSCTL_OUT(req
, kkstp
, sizeof(*kkstp
));
1583 if (lwpidarray
!= NULL
)
1584 free(lwpidarray
, M_TEMP
);
1586 free(kkstp
, M_TEMP
);
1591 SYSCTL_NODE(_kern
, KERN_PROC
, proc
, CTLFLAG_RD
, 0, "Process table");
1593 SYSCTL_PROC(_kern_proc
, KERN_PROC_ALL
, all
, CTLFLAG_RD
|CTLTYPE_STRUCT
,
1594 0, 0, sysctl_kern_proc
, "S,proc", "Return entire process table");
1596 static SYSCTL_NODE(_kern_proc
, KERN_PROC_GID
, gid
, CTLFLAG_RD
,
1597 sysctl_kern_proc
, "Process table");
1599 static SYSCTL_NODE(_kern_proc
, KERN_PROC_PGRP
, pgrp
, CTLFLAG_RD
,
1600 sysctl_kern_proc
, "Process table");
1602 static SYSCTL_NODE(_kern_proc
, KERN_PROC_RGID
, rgid
, CTLFLAG_RD
,
1603 sysctl_kern_proc
, "Process table");
1605 static SYSCTL_NODE(_kern_proc
, KERN_PROC_SESSION
, sid
, CTLFLAG_RD
,
1606 sysctl_kern_proc
, "Process table");
1608 static SYSCTL_NODE(_kern_proc
, KERN_PROC_TTY
, tty
, CTLFLAG_RD
,
1609 sysctl_kern_proc
, "Process table");
1611 static SYSCTL_NODE(_kern_proc
, KERN_PROC_UID
, uid
, CTLFLAG_RD
,
1612 sysctl_kern_proc
, "Process table");
1614 static SYSCTL_NODE(_kern_proc
, KERN_PROC_RUID
, ruid
, CTLFLAG_RD
,
1615 sysctl_kern_proc
, "Process table");
1617 static SYSCTL_NODE(_kern_proc
, KERN_PROC_PID
, pid
, CTLFLAG_RD
,
1618 sysctl_kern_proc
, "Process table");
1620 static SYSCTL_NODE(_kern_proc
, KERN_PROC_PROC
, proc
, CTLFLAG_RD
,
1621 sysctl_kern_proc
, "Return process table, no threads");
1623 static SYSCTL_NODE(_kern_proc
, KERN_PROC_ARGS
, args
,
1624 CTLFLAG_RW
| CTLFLAG_ANYBODY
,
1625 sysctl_kern_proc_args
, "Process argument list");
1627 static SYSCTL_NODE(_kern_proc
, KERN_PROC_PATHNAME
, pathname
, CTLFLAG_RD
,
1628 sysctl_kern_proc_pathname
, "Process executable path");
1630 static SYSCTL_NODE(_kern_proc
, KERN_PROC_SV_NAME
, sv_name
, CTLFLAG_RD
,
1631 sysctl_kern_proc_sv_name
, "Process syscall vector name (ABI type)");
1633 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_GID
| KERN_PROC_INC_THREAD
), gid_td
,
1634 CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1636 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_PGRP
| KERN_PROC_INC_THREAD
), pgrp_td
,
1637 CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1639 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_RGID
| KERN_PROC_INC_THREAD
), rgid_td
,
1640 CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1642 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_SESSION
| KERN_PROC_INC_THREAD
),
1643 sid_td
, CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1645 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_TTY
| KERN_PROC_INC_THREAD
), tty_td
,
1646 CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1648 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_UID
| KERN_PROC_INC_THREAD
), uid_td
,
1649 CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1651 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_RUID
| KERN_PROC_INC_THREAD
), ruid_td
,
1652 CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1654 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_PID
| KERN_PROC_INC_THREAD
), pid_td
,
1655 CTLFLAG_RD
, sysctl_kern_proc
, "Process table");
1657 static SYSCTL_NODE(_kern_proc
, (KERN_PROC_PROC
| KERN_PROC_INC_THREAD
), proc_td
,
1658 CTLFLAG_RD
, sysctl_kern_proc
, "Return process table, no threads");
1660 static SYSCTL_NODE(_kern_proc
, KERN_PROC_VMMAP
, vmmap
, CTLFLAG_RD
,
1661 sysctl_kern_proc_vmmap
, "Process vm map entries");
1663 #if defined(STACK) || defined(DDB)
1664 static SYSCTL_NODE(_kern_proc
, KERN_PROC_KSTACK
, kstack
, CTLFLAG_RD
,
1665 sysctl_kern_proc_kstack
, "Process kernel stacks");