35#include "opt_ddb.h"
36#include "opt_kdtrace.h"
37#include "opt_ktrace.h"
38#include "opt_kstack_pages.h"
39#include "opt_stack.h"
40
41#include <sys/param.h>
42#include <sys/systm.h>
43#include <sys/kernel.h>
44#include <sys/lock.h>
45#include <sys/malloc.h>
46#include <sys/mount.h>
47#include <sys/mutex.h>
48#include <sys/proc.h>
49#include <sys/refcount.h>
50#include <sys/sbuf.h>
51#include <sys/sysent.h>
52#include <sys/sched.h>
53#include <sys/smp.h>
54#include <sys/stack.h>
55#include <sys/sysctl.h>
56#include <sys/filedesc.h>
57#include <sys/tty.h>
58#include <sys/signalvar.h>
59#include <sys/sdt.h>
60#include <sys/sx.h>
61#include <sys/user.h>
62#include <sys/jail.h>
63#include <sys/vnode.h>
64#include <sys/eventhandler.h>
65#ifdef KTRACE
66#include <sys/uio.h>
67#include <sys/ktrace.h>
68#endif
69
70#ifdef DDB
71#include <ddb/ddb.h>
72#endif
73
74#include <vm/vm.h>
75#include <vm/vm_extern.h>
76#include <vm/pmap.h>
77#include <vm/vm_map.h>
78#include <vm/vm_object.h>
79#include <vm/uma.h>
80
81SDT_PROVIDER_DEFINE(proc);
82SDT_PROBE_DEFINE(proc, kernel, ctor, entry);
83SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 0, "struct proc *");
84SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 1, "int");
85SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 2, "void *");
86SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 3, "int");
87SDT_PROBE_DEFINE(proc, kernel, ctor, return);
88SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 0, "struct proc *");
89SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 1, "int");
90SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 2, "void *");
91SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 3, "int");
92SDT_PROBE_DEFINE(proc, kernel, dtor, entry);
93SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 0, "struct proc *");
94SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 1, "int");
95SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 2, "void *");
96SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 3, "struct thread *");
97SDT_PROBE_DEFINE(proc, kernel, dtor, return);
98SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 0, "struct proc *");
99SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 1, "int");
100SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 2, "void *");
101SDT_PROBE_DEFINE(proc, kernel, init, entry);
102SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 0, "struct proc *");
103SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 1, "int");
104SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 2, "int");
105SDT_PROBE_DEFINE(proc, kernel, init, return);
106SDT_PROBE_ARGTYPE(proc, kernel, init, return, 0, "struct proc *");
107SDT_PROBE_ARGTYPE(proc, kernel, init, return, 1, "int");
108SDT_PROBE_ARGTYPE(proc, kernel, init, return, 2, "int");
109
110MALLOC_DEFINE(M_PGRP, "pgrp", "process group header");
111MALLOC_DEFINE(M_SESSION, "session", "session header");
112static MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
113MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
114
115static void doenterpgrp(struct proc *, struct pgrp *);
116static void orphanpg(struct pgrp *pg);
117static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp);
118static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp,
119 int preferthread);
120static void pgadjustjobc(struct pgrp *pgrp, int entering);
121static void pgdelete(struct pgrp *);
122static int proc_ctor(void *mem, int size, void *arg, int flags);
123static void proc_dtor(void *mem, int size, void *arg);
124static int proc_init(void *mem, int size, int flags);
125static void proc_fini(void *mem, int size);
126static void pargs_free(struct pargs *pa);
127
128/*
129 * Other process lists
130 */
131struct pidhashhead *pidhashtbl;
132u_long pidhash;
133struct pgrphashhead *pgrphashtbl;
134u_long pgrphash;
135struct proclist allproc;
136struct proclist zombproc;
137struct sx allproc_lock;
138struct sx proctree_lock;
139struct mtx ppeers_lock;
140uma_zone_t proc_zone;
141uma_zone_t ithread_zone;
142
143int kstack_pages = KSTACK_PAGES;
144SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0, "");
145
146CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
147
148/*
149 * Initialize global process hashing structures.
150 */
151void
152procinit()
153{
154
155 sx_init(&allproc_lock, "allproc");
156 sx_init(&proctree_lock, "proctree");
157 mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF);
158 LIST_INIT(&allproc);
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);
165 uihashinit();
166}
167
168/*
169 * Prepare a proc for use.
170 */
171static int
172proc_ctor(void *mem, int size, void *arg, int flags)
173{
174 struct proc *p;
175
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);
180 return (0);
181}
182
183/*
184 * Reclaim a proc after use.
185 */
186static void
187proc_dtor(void *mem, int size, void *arg)
188{
189 struct proc *p;
190 struct thread *td;
191
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);
196 if (td != NULL) {
197#ifdef INVARIANTS
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"));
201#endif
202 /* Free all OSD associated to this thread. */
203 osd_thread_exit(td);
204
205 /* Dispose of an alternate kstack, if it exists.
206 * XXX What if there are more than one thread in the proc?
207 * The first thread in the proc is special and not
208 * freed, so you gotta do this here.
209 */
210 if (((p->p_flag & P_KTHREAD) != 0) && (td->td_altkstack != 0))
211 vm_thread_dispose_altkstack(td);
212 }
213 EVENTHANDLER_INVOKE(process_dtor, p);
214 if (p->p_ksi != NULL)
215 KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue"));
216 SDT_PROBE(proc, kernel, dtor, return, p, size, arg, 0, 0);
217}
218
219/*
220 * Initialize type-stable parts of a proc (when newly created).
221 */
222static int
223proc_init(void *mem, int size, int flags)
224{
225 struct proc *p;
226
227 p = (struct proc *)mem;
228 SDT_PROBE(proc, kernel, init, entry, p, size, flags, 0, 0);
229 p->p_sched = (struct p_sched *)&p[1];
230 bzero(&p->p_mtx, sizeof(struct mtx));
231 mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK);
232 mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE);
233 TAILQ_INIT(&p->p_threads); /* all threads in proc */
234 EVENTHANDLER_INVOKE(process_init, p);
235 p->p_stats = pstats_alloc();
236 SDT_PROBE(proc, kernel, init, return, p, size, flags, 0, 0);
237 return (0);
238}
239
240/*
241 * UMA should ensure that this function is never called.
242 * Freeing a proc structure would violate type stability.
243 */
244static void
245proc_fini(void *mem, int size)
246{
247#ifdef notnow
248 struct proc *p;
249
250 p = (struct proc *)mem;
251 EVENTHANDLER_INVOKE(process_fini, p);
252 pstats_free(p->p_stats);
253 thread_free(FIRST_THREAD_IN_PROC(p));
254 mtx_destroy(&p->p_mtx);
255 if (p->p_ksi != NULL)
256 ksiginfo_free(p->p_ksi);
257#else
258 panic("proc reclaimed");
259#endif
260}
261
262/*
263 * Is p an inferior of the current process?
264 */
265int
266inferior(p)
267 register struct proc *p;
268{
269
270 sx_assert(&proctree_lock, SX_LOCKED);
271 for (; p != curproc; p = p->p_pptr)
272 if (p->p_pid == 0)
273 return (0);
274 return (1);
275}
276
277/*
278 * Locate a process by number; return only "live" processes -- i.e., neither
279 * zombies nor newly born but incompletely initialized processes. By not
280 * returning processes in the PRS_NEW state, we allow callers to avoid
281 * testing for that condition to avoid dereferencing p_ucred, et al.
282 */
283struct proc *
284pfind(pid)
285 register pid_t pid;
286{
287 register struct proc *p;
288
289 sx_slock(&allproc_lock);
290 LIST_FOREACH(p, PIDHASH(pid), p_hash)
291 if (p->p_pid == pid) {
292 if (p->p_state == PRS_NEW) {
293 p = NULL;
294 break;
295 }
296 PROC_LOCK(p);
297 break;
298 }
299 sx_sunlock(&allproc_lock);
300 return (p);
301}
302
303/*
304 * Locate a process group by number.
305 * The caller must hold proctree_lock.
306 */
307struct pgrp *
308pgfind(pgid)
309 register pid_t pgid;
310{
311 register struct pgrp *pgrp;
312
313 sx_assert(&proctree_lock, SX_LOCKED);
314
315 LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) {
316 if (pgrp->pg_id == pgid) {
317 PGRP_LOCK(pgrp);
318 return (pgrp);
319 }
320 }
321 return (NULL);
322}
323
324/*
325 * Create a new process group.
326 * pgid must be equal to the pid of p.
327 * Begin a new session if required.
328 */
329int
330enterpgrp(p, pgid, pgrp, sess)
331 register struct proc *p;
332 pid_t pgid;
333 struct pgrp *pgrp;
334 struct session *sess;
335{
336 struct pgrp *pgrp2;
337
338 sx_assert(&proctree_lock, SX_XLOCKED);
339
340 KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL"));
341 KASSERT(p->p_pid == pgid,
342 ("enterpgrp: new pgrp and pid != pgid"));
343
344 pgrp2 = pgfind(pgid);
345
346 KASSERT(pgrp2 == NULL,
347 ("enterpgrp: pgrp with pgid exists"));
348 KASSERT(!SESS_LEADER(p),
349 ("enterpgrp: session leader attempted setpgrp"));
350
351 mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
352
353 if (sess != NULL) {
354 /*
355 * new session
356 */
357 mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF);
358 PROC_LOCK(p);
359 p->p_flag &= ~P_CONTROLT;
360 PROC_UNLOCK(p);
361 PGRP_LOCK(pgrp);
362 sess->s_leader = p;
363 sess->s_sid = p->p_pid;
364 refcount_init(&sess->s_count, 1);
365 sess->s_ttyvp = NULL;
366 sess->s_ttyp = NULL;
367 bcopy(p->p_session->s_login, sess->s_login,
368 sizeof(sess->s_login));
369 pgrp->pg_session = sess;
370 KASSERT(p == curproc,
371 ("enterpgrp: mksession and p != curproc"));
372 } else {
373 pgrp->pg_session = p->p_session;
374 sess_hold(pgrp->pg_session);
375 PGRP_LOCK(pgrp);
376 }
377 pgrp->pg_id = pgid;
378 LIST_INIT(&pgrp->pg_members);
379
380 /*
381 * As we have an exclusive lock of proctree_lock,
382 * this should not deadlock.
383 */
384 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
385 pgrp->pg_jobc = 0;
386 SLIST_INIT(&pgrp->pg_sigiolst);
387 PGRP_UNLOCK(pgrp);
388
389 doenterpgrp(p, pgrp);
390
391 return (0);
392}
393
394/*
395 * Move p to an existing process group
396 */
397int
398enterthispgrp(p, pgrp)
399 register struct proc *p;
400 struct pgrp *pgrp;
401{
402
403 sx_assert(&proctree_lock, SX_XLOCKED);
404 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
405 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
406 PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
407 SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
408 KASSERT(pgrp->pg_session == p->p_session,
409 ("%s: pgrp's session %p, p->p_session %p.\n",
410 __func__,
411 pgrp->pg_session,
412 p->p_session));
413 KASSERT(pgrp != p->p_pgrp,
414 ("%s: p belongs to pgrp.", __func__));
415
416 doenterpgrp(p, pgrp);
417
418 return (0);
419}
420
421/*
422 * Move p to a process group
423 */
424static void
425doenterpgrp(p, pgrp)
426 struct proc *p;
427 struct pgrp *pgrp;
428{
429 struct pgrp *savepgrp;
430
431 sx_assert(&proctree_lock, SX_XLOCKED);
432 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
433 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
434 PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
435 SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
436
437 savepgrp = p->p_pgrp;
438
439 /*
440 * Adjust eligibility of affected pgrps to participate in job control.
441 * Increment eligibility counts before decrementing, otherwise we
442 * could reach 0 spuriously during the first call.
443 */
444 fixjobc(p, pgrp, 1);
445 fixjobc(p, p->p_pgrp, 0);
446
447 PGRP_LOCK(pgrp);
448 PGRP_LOCK(savepgrp);
449 PROC_LOCK(p);
450 LIST_REMOVE(p, p_pglist);
451 p->p_pgrp = pgrp;
452 PROC_UNLOCK(p);
453 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
454 PGRP_UNLOCK(savepgrp);
455 PGRP_UNLOCK(pgrp);
456 if (LIST_EMPTY(&savepgrp->pg_members))
457 pgdelete(savepgrp);
458}
459
460/*
461 * remove process from process group
462 */
463int
464leavepgrp(p)
465 register struct proc *p;
466{
467 struct pgrp *savepgrp;
468
469 sx_assert(&proctree_lock, SX_XLOCKED);
470 savepgrp = p->p_pgrp;
471 PGRP_LOCK(savepgrp);
472 PROC_LOCK(p);
473 LIST_REMOVE(p, p_pglist);
474 p->p_pgrp = NULL;
475 PROC_UNLOCK(p);
476 PGRP_UNLOCK(savepgrp);
477 if (LIST_EMPTY(&savepgrp->pg_members))
478 pgdelete(savepgrp);
479 return (0);
480}
481
482/*
483 * delete a process group
484 */
485static void
486pgdelete(pgrp)
487 register struct pgrp *pgrp;
488{
489 struct session *savesess;
490 struct tty *tp;
491
492 sx_assert(&proctree_lock, SX_XLOCKED);
493 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
494 SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
495
496 /*
497 * Reset any sigio structures pointing to us as a result of
498 * F_SETOWN with our pgid.
499 */
500 funsetownlst(&pgrp->pg_sigiolst);
501
502 PGRP_LOCK(pgrp);
503 tp = pgrp->pg_session->s_ttyp;
504 LIST_REMOVE(pgrp, pg_hash);
505 savesess = pgrp->pg_session;
506 PGRP_UNLOCK(pgrp);
507
508 /* Remove the reference to the pgrp before deallocating it. */
509 if (tp != NULL) {
510 tty_lock(tp);
511 tty_rel_pgrp(tp, pgrp);
512 }
513
514 mtx_destroy(&pgrp->pg_mtx);
515 free(pgrp, M_PGRP);
516 sess_release(savesess);
517}
518
519static void
520pgadjustjobc(pgrp, entering)
521 struct pgrp *pgrp;
522 int entering;
523{
524
525 PGRP_LOCK(pgrp);
526 if (entering)
527 pgrp->pg_jobc++;
528 else {
529 --pgrp->pg_jobc;
530 if (pgrp->pg_jobc == 0)
531 orphanpg(pgrp);
532 }
533 PGRP_UNLOCK(pgrp);
534}
535
536/*
537 * Adjust pgrp jobc counters when specified process changes process group.
538 * We count the number of processes in each process group that "qualify"
539 * the group for terminal job control (those with a parent in a different
540 * process group of the same session). If that count reaches zero, the
541 * process group becomes orphaned. Check both the specified process'
542 * process group and that of its children.
543 * entering == 0 => p is leaving specified group.
544 * entering == 1 => p is entering specified group.
545 */
546void
547fixjobc(p, pgrp, entering)
548 register struct proc *p;
549 register struct pgrp *pgrp;
550 int entering;
551{
552 register struct pgrp *hispgrp;
553 register struct session *mysession;
554
555 sx_assert(&proctree_lock, SX_LOCKED);
556 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
557 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
558 SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
559
560 /*
561 * Check p's parent to see whether p qualifies its own process
562 * group; if so, adjust count for p's process group.
563 */
564 mysession = pgrp->pg_session;
565 if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
566 hispgrp->pg_session == mysession)
567 pgadjustjobc(pgrp, entering);
568
569 /*
570 * Check this process' children to see whether they qualify
571 * their process groups; if so, adjust counts for children's
572 * process groups.
573 */
574 LIST_FOREACH(p, &p->p_children, p_sibling) {
575 hispgrp = p->p_pgrp;
576 if (hispgrp == pgrp ||
577 hispgrp->pg_session != mysession)
578 continue;
579 PROC_LOCK(p);
580 if (p->p_state == PRS_ZOMBIE) {
581 PROC_UNLOCK(p);
582 continue;
583 }
584 PROC_UNLOCK(p);
585 pgadjustjobc(hispgrp, entering);
586 }
587}
588
589/*
590 * A process group has become orphaned;
591 * if there are any stopped processes in the group,
592 * hang-up all process in that group.
593 */
594static void
595orphanpg(pg)
596 struct pgrp *pg;
597{
598 register struct proc *p;
599
600 PGRP_LOCK_ASSERT(pg, MA_OWNED);
601
602 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
603 PROC_LOCK(p);
604 if (P_SHOULDSTOP(p)) {
605 PROC_UNLOCK(p);
606 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
607 PROC_LOCK(p);
608 psignal(p, SIGHUP);
609 psignal(p, SIGCONT);
610 PROC_UNLOCK(p);
611 }
612 return;
613 }
614 PROC_UNLOCK(p);
615 }
616}
617
618void
619sess_hold(struct session *s)
620{
621
622 refcount_acquire(&s->s_count);
623}
624
625void
626sess_release(struct session *s)
627{
628
629 if (refcount_release(&s->s_count)) {
630 if (s->s_ttyp != NULL) {
631 tty_lock(s->s_ttyp);
632 tty_rel_sess(s->s_ttyp, s);
633 }
634 mtx_destroy(&s->s_mtx);
635 free(s, M_SESSION);
636 }
637}
638
639#include "opt_ddb.h"
640#ifdef DDB
641#include <ddb/ddb.h>
642
643DB_SHOW_COMMAND(pgrpdump, pgrpdump)
644{
645 register struct pgrp *pgrp;
646 register struct proc *p;
647 register int i;
648
649 for (i = 0; i <= pgrphash; i++) {
650 if (!LIST_EMPTY(&pgrphashtbl[i])) {
651 printf("\tindx %d\n", i);
652 LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
653 printf(
654 "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
655 (void *)pgrp, (long)pgrp->pg_id,
656 (void *)pgrp->pg_session,
657 pgrp->pg_session->s_count,
658 (void *)LIST_FIRST(&pgrp->pg_members));
659 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
660 printf("\t\tpid %ld addr %p pgrp %p\n",
661 (long)p->p_pid, (void *)p,
662 (void *)p->p_pgrp);
663 }
664 }
665 }
666 }
667}
668#endif /* DDB */
669
670/*
671 * Clear kinfo_proc and fill in any information that is common
672 * to all threads in the process.
673 * Must be called with the target process locked.
674 */
675static void
676fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp)
677{
678 struct thread *td0;
679 struct tty *tp;
680 struct session *sp;
681 struct ucred *cred;
682 struct sigacts *ps;
683
684 PROC_LOCK_ASSERT(p, MA_OWNED);
685 bzero(kp, sizeof(*kp));
686
687 kp->ki_structsize = sizeof(*kp);
688 kp->ki_paddr = p;
689 kp->ki_addr =/* p->p_addr; */0; /* XXX */
690 kp->ki_args = p->p_args;
691 kp->ki_textvp = p->p_textvp;
692#ifdef KTRACE
693 kp->ki_tracep = p->p_tracevp;
694 mtx_lock(&ktrace_mtx);
695 kp->ki_traceflag = p->p_traceflag;
696 mtx_unlock(&ktrace_mtx);
697#endif
698 kp->ki_fd = p->p_fd;
699 kp->ki_vmspace = p->p_vmspace;
700 kp->ki_flag = p->p_flag;
701 cred = p->p_ucred;
702 if (cred) {
703 kp->ki_uid = cred->cr_uid;
704 kp->ki_ruid = cred->cr_ruid;
705 kp->ki_svuid = cred->cr_svuid;
706 /* XXX bde doesn't like KI_NGROUPS */
707 kp->ki_ngroups = min(cred->cr_ngroups, KI_NGROUPS);
708 bcopy(cred->cr_groups, kp->ki_groups,
709 kp->ki_ngroups * sizeof(gid_t));
710 kp->ki_rgid = cred->cr_rgid;
711 kp->ki_svgid = cred->cr_svgid;
712 /* If jailed(cred), emulate the old P_JAILED flag. */
713 if (jailed(cred)) {
714 kp->ki_flag |= P_JAILED;
715 /* If inside a jail, use 0 as a jail ID. */
716 if (!jailed(curthread->td_ucred))
717 kp->ki_jid = cred->cr_prison->pr_id;
718 }
719 }
720 ps = p->p_sigacts;
721 if (ps) {
722 mtx_lock(&ps->ps_mtx);
723 kp->ki_sigignore = ps->ps_sigignore;
724 kp->ki_sigcatch = ps->ps_sigcatch;
725 mtx_unlock(&ps->ps_mtx);
726 }
727 PROC_SLOCK(p);
728 if (p->p_state != PRS_NEW &&
729 p->p_state != PRS_ZOMBIE &&
730 p->p_vmspace != NULL) {
731 struct vmspace *vm = p->p_vmspace;
732
733 kp->ki_size = vm->vm_map.size;
734 kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/
735 FOREACH_THREAD_IN_PROC(p, td0) {
736 if (!TD_IS_SWAPPED(td0))
737 kp->ki_rssize += td0->td_kstack_pages;
738 if (td0->td_altkstack_obj != NULL)
739 kp->ki_rssize += td0->td_altkstack_pages;
740 }
741 kp->ki_swrss = vm->vm_swrss;
742 kp->ki_tsize = vm->vm_tsize;
743 kp->ki_dsize = vm->vm_dsize;
744 kp->ki_ssize = vm->vm_ssize;
745 } else if (p->p_state == PRS_ZOMBIE)
746 kp->ki_stat = SZOMB;
747 if (kp->ki_flag & P_INMEM)
748 kp->ki_sflag = PS_INMEM;
749 else
750 kp->ki_sflag = 0;
751 /* Calculate legacy swtime as seconds since 'swtick'. */
752 kp->ki_swtime = (ticks - p->p_swtick) / hz;
753 kp->ki_pid = p->p_pid;
754 kp->ki_nice = p->p_nice;
755 rufetch(p, &kp->ki_rusage);
756 kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime);
757 PROC_SUNLOCK(p);
758 if ((p->p_flag & P_INMEM) && p->p_stats != NULL) {
759 kp->ki_start = p->p_stats->p_start;
760 timevaladd(&kp->ki_start, &boottime);
761 PROC_SLOCK(p);
762 calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime);
763 PROC_SUNLOCK(p);
764 calccru(p, &kp->ki_childutime, &kp->ki_childstime);
765
766 /* Some callers want child-times in a single value */
767 kp->ki_childtime = kp->ki_childstime;
768 timevaladd(&kp->ki_childtime, &kp->ki_childutime);
769 }
770 tp = NULL;
771 if (p->p_pgrp) {
772 kp->ki_pgid = p->p_pgrp->pg_id;
773 kp->ki_jobc = p->p_pgrp->pg_jobc;
774 sp = p->p_pgrp->pg_session;
775
776 if (sp != NULL) {
777 kp->ki_sid = sp->s_sid;
778 SESS_LOCK(sp);
779 strlcpy(kp->ki_login, sp->s_login,
780 sizeof(kp->ki_login));
781 if (sp->s_ttyvp)
782 kp->ki_kiflag |= KI_CTTY;
783 if (SESS_LEADER(p))
784 kp->ki_kiflag |= KI_SLEADER;
785 /* XXX proctree_lock */
786 tp = sp->s_ttyp;
787 SESS_UNLOCK(sp);
788 }
789 }
790 if ((p->p_flag & P_CONTROLT) && tp != NULL) {
791 kp->ki_tdev = tty_udev(tp);
792 kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
793 if (tp->t_session)
794 kp->ki_tsid = tp->t_session->s_sid;
795 } else
796 kp->ki_tdev = NODEV;
797 if (p->p_comm[0] != '\0')
798 strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));
799 if (p->p_sysent && p->p_sysent->sv_name != NULL &&
800 p->p_sysent->sv_name[0] != '\0')
801 strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul));
802 kp->ki_siglist = p->p_siglist;
803 kp->ki_xstat = p->p_xstat;
804 kp->ki_acflag = p->p_acflag;
805 kp->ki_lock = p->p_lock;
806 if (p->p_pptr)
807 kp->ki_ppid = p->p_pptr->p_pid;
808}
809
810/*
811 * Fill in information that is thread specific. Must be called with p_slock
812 * locked. If 'preferthread' is set, overwrite certain process-related
813 * fields that are maintained for both threads and processes.
814 */
815static void
816fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread)
817{
818 struct proc *p;
819
820 p = td->td_proc;
821 PROC_LOCK_ASSERT(p, MA_OWNED);
822
823 thread_lock(td);
824 if (td->td_wmesg != NULL)
825 strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg));
826 else
827 bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg));
828 if (td->td_name[0] != '\0')
829 strlcpy(kp->ki_ocomm, td->td_name, sizeof(kp->ki_ocomm));
830 if (TD_ON_LOCK(td)) {
831 kp->ki_kiflag |= KI_LOCKBLOCK;
832 strlcpy(kp->ki_lockname, td->td_lockname,
833 sizeof(kp->ki_lockname));
834 } else {
835 kp->ki_kiflag &= ~KI_LOCKBLOCK;
836 bzero(kp->ki_lockname, sizeof(kp->ki_lockname));
837 }
838
839 if (p->p_state == PRS_NORMAL) { /* approximate. */
840 if (TD_ON_RUNQ(td) ||
841 TD_CAN_RUN(td) ||
842 TD_IS_RUNNING(td)) {
843 kp->ki_stat = SRUN;
844 } else if (P_SHOULDSTOP(p)) {
845 kp->ki_stat = SSTOP;
846 } else if (TD_IS_SLEEPING(td)) {
847 kp->ki_stat = SSLEEP;
848 } else if (TD_ON_LOCK(td)) {
849 kp->ki_stat = SLOCK;
850 } else {
851 kp->ki_stat = SWAIT;
852 }
853 } else if (p->p_state == PRS_ZOMBIE) {
854 kp->ki_stat = SZOMB;
855 } else {
856 kp->ki_stat = SIDL;
857 }
858
859 /* Things in the thread */
860 kp->ki_wchan = td->td_wchan;
861 kp->ki_pri.pri_level = td->td_priority;
862 kp->ki_pri.pri_native = td->td_base_pri;
863 kp->ki_lastcpu = td->td_lastcpu;
864 kp->ki_oncpu = td->td_oncpu;
865 kp->ki_tdflags = td->td_flags;
866 kp->ki_tid = td->td_tid;
867 kp->ki_numthreads = p->p_numthreads;
868 kp->ki_pcb = td->td_pcb;
869 kp->ki_kstack = (void *)td->td_kstack;
870 kp->ki_pctcpu = sched_pctcpu(td);
871 kp->ki_estcpu = td->td_estcpu;
872 kp->ki_slptime = (ticks - td->td_slptick) / hz;
873 kp->ki_pri.pri_class = td->td_pri_class;
874 kp->ki_pri.pri_user = td->td_user_pri;
875
876 if (preferthread)
877 kp->ki_runtime = cputick2usec(td->td_runtime);
878
879 /* We can't get this anymore but ps etc never used it anyway. */
880 kp->ki_rqindex = 0;
881
882 SIGSETOR(kp->ki_siglist, td->td_siglist);
883 kp->ki_sigmask = td->td_sigmask;
884 thread_unlock(td);
885}
886
887/*
888 * Fill in a kinfo_proc structure for the specified process.
889 * Must be called with the target process locked.
890 */
891void
892fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
893{
894
895 fill_kinfo_proc_only(p, kp);
896 if (FIRST_THREAD_IN_PROC(p) != NULL)
897 fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0);
898}
899
900struct pstats *
901pstats_alloc(void)
902{
903
904 return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK));
905}
906
907/*
908 * Copy parts of p_stats; zero the rest of p_stats (statistics).
909 */
910void
911pstats_fork(struct pstats *src, struct pstats *dst)
912{
913
914 bzero(&dst->pstat_startzero,
915 __rangeof(struct pstats, pstat_startzero, pstat_endzero));
916 bcopy(&src->pstat_startcopy, &dst->pstat_startcopy,
917 __rangeof(struct pstats, pstat_startcopy, pstat_endcopy));
918}
919
920void
921pstats_free(struct pstats *ps)
922{
923
924 free(ps, M_SUBPROC);
925}
926
927/*
928 * Locate a zombie process by number
929 */
930struct proc *
931zpfind(pid_t pid)
932{
933 struct proc *p;
934
935 sx_slock(&allproc_lock);
936 LIST_FOREACH(p, &zombproc, p_list)
937 if (p->p_pid == pid) {
938 PROC_LOCK(p);
939 break;
940 }
941 sx_sunlock(&allproc_lock);
942 return (p);
943}
944
945#define KERN_PROC_ZOMBMASK 0x3
946#define KERN_PROC_NOTHREADS 0x4
947
948/*
949 * Must be called with the process locked and will return with it unlocked.
950 */
951static int
952sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags)
953{
954 struct thread *td;
955 struct kinfo_proc kinfo_proc;
956 int error = 0;
957 struct proc *np;
958 pid_t pid = p->p_pid;
959
960 PROC_LOCK_ASSERT(p, MA_OWNED);
961
962 fill_kinfo_proc_only(p, &kinfo_proc);
963 if (flags & KERN_PROC_NOTHREADS) {
964 if (FIRST_THREAD_IN_PROC(p) != NULL)
965 fill_kinfo_thread(FIRST_THREAD_IN_PROC(p),
966 &kinfo_proc, 0);
967 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc,
968 sizeof(kinfo_proc));
969 } else {
970 if (FIRST_THREAD_IN_PROC(p) != NULL)
971 FOREACH_THREAD_IN_PROC(p, td) {
972 fill_kinfo_thread(td, &kinfo_proc, 1);
973 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc,
974 sizeof(kinfo_proc));
975 if (error)
976 break;
977 }
978 else
979 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc,
980 sizeof(kinfo_proc));
981 }
982 PROC_UNLOCK(p);
983 if (error)
984 return (error);
985 if (flags & KERN_PROC_ZOMBMASK)
986 np = zpfind(pid);
987 else {
988 if (pid == 0)
989 return (0);
990 np = pfind(pid);
991 }
992 if (np == NULL)
993 return (ESRCH);
994 if (np != p) {
995 PROC_UNLOCK(np);
996 return (ESRCH);
997 }
998 PROC_UNLOCK(np);
999 return (0);
1000}
1001
1002static int
1003sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
1004{
1005 int *name = (int*) arg1;
1006 u_int namelen = arg2;
1007 struct proc *p;
1008 int flags, doingzomb, oid_number;
1009 int error = 0;
1010
1011 oid_number = oidp->oid_number;
1012 if (oid_number != KERN_PROC_ALL &&
1013 (oid_number & KERN_PROC_INC_THREAD) == 0)
1014 flags = KERN_PROC_NOTHREADS;
1015 else {
1016 flags = 0;
1017 oid_number &= ~KERN_PROC_INC_THREAD;
1018 }
1019 if (oid_number == KERN_PROC_PID) {
1020 if (namelen != 1)
1021 return (EINVAL);
1022 error = sysctl_wire_old_buffer(req, 0);
1023 if (error)
1024 return (error);
1025 p = pfind((pid_t)name[0]);
1026 if (!p)
1027 return (ESRCH);
1028 if ((error = p_cansee(curthread, p))) {
1029 PROC_UNLOCK(p);
1030 return (error);
1031 }
1032 error = sysctl_out_proc(p, req, flags);
1033 return (error);
1034 }
1035
1036 switch (oid_number) {
1037 case KERN_PROC_ALL:
1038 if (namelen != 0)
1039 return (EINVAL);
1040 break;
1041 case KERN_PROC_PROC:
1042 if (namelen != 0 && namelen != 1)
1043 return (EINVAL);
1044 break;
1045 default:
1046 if (namelen != 1)
1047 return (EINVAL);
1048 break;
1049 }
1050
1051 if (!req->oldptr) {
1052 /* overestimate by 5 procs */
1053 error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
1054 if (error)
1055 return (error);
1056 }
1057 error = sysctl_wire_old_buffer(req, 0);
1058 if (error != 0)
1059 return (error);
1060 sx_slock(&allproc_lock);
1061 for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
1062 if (!doingzomb)
1063 p = LIST_FIRST(&allproc);
1064 else
1065 p = LIST_FIRST(&zombproc);
1066 for (; p != 0; p = LIST_NEXT(p, p_list)) {
1067 /*
1068 * Skip embryonic processes.
1069 */
1070 PROC_SLOCK(p);
1071 if (p->p_state == PRS_NEW) {
1072 PROC_SUNLOCK(p);
1073 continue;
1074 }
1075 PROC_SUNLOCK(p);
1076 PROC_LOCK(p);
1077 KASSERT(p->p_ucred != NULL,
1078 ("process credential is NULL for non-NEW proc"));
1079 /*
1080 * Show a user only appropriate processes.
1081 */
1082 if (p_cansee(curthread, p)) {
1083 PROC_UNLOCK(p);
1084 continue;
1085 }
1086 /*
1087 * TODO - make more efficient (see notes below).
1088 * do by session.
1089 */
1090 switch (oid_number) {
1091
1092 case KERN_PROC_GID:
1093 if (p->p_ucred->cr_gid != (gid_t)name[0]) {
1094 PROC_UNLOCK(p);
1095 continue;
1096 }
1097 break;
1098
1099 case KERN_PROC_PGRP:
1100 /* could do this by traversing pgrp */
1101 if (p->p_pgrp == NULL ||
1102 p->p_pgrp->pg_id != (pid_t)name[0]) {
1103 PROC_UNLOCK(p);
1104 continue;
1105 }
1106 break;
1107
1108 case KERN_PROC_RGID:
1109 if (p->p_ucred->cr_rgid != (gid_t)name[0]) {
1110 PROC_UNLOCK(p);
1111 continue;
1112 }
1113 break;
1114
1115 case KERN_PROC_SESSION:
1116 if (p->p_session == NULL ||
1117 p->p_session->s_sid != (pid_t)name[0]) {
1118 PROC_UNLOCK(p);
1119 continue;
1120 }
1121 break;
1122
1123 case KERN_PROC_TTY:
1124 if ((p->p_flag & P_CONTROLT) == 0 ||
1125 p->p_session == NULL) {
1126 PROC_UNLOCK(p);
1127 continue;
1128 }
1129 /* XXX proctree_lock */
1130 SESS_LOCK(p->p_session);
1131 if (p->p_session->s_ttyp == NULL ||
1132 tty_udev(p->p_session->s_ttyp) !=
1133 (dev_t)name[0]) {
1134 SESS_UNLOCK(p->p_session);
1135 PROC_UNLOCK(p);
1136 continue;
1137 }
1138 SESS_UNLOCK(p->p_session);
1139 break;
1140
1141 case KERN_PROC_UID:
1142 if (p->p_ucred->cr_uid != (uid_t)name[0]) {
1143 PROC_UNLOCK(p);
1144 continue;
1145 }
1146 break;
1147
1148 case KERN_PROC_RUID:
1149 if (p->p_ucred->cr_ruid != (uid_t)name[0]) {
1150 PROC_UNLOCK(p);
1151 continue;
1152 }
1153 break;
1154
1155 case KERN_PROC_PROC:
1156 break;
1157
1158 default:
1159 break;
1160
1161 }
1162
1163 error = sysctl_out_proc(p, req, flags | doingzomb);
1164 if (error) {
1165 sx_sunlock(&allproc_lock);
1166 return (error);
1167 }
1168 }
1169 }
1170 sx_sunlock(&allproc_lock);
1171 return (0);
1172}
1173
1174struct pargs *
1175pargs_alloc(int len)
1176{
1177 struct pargs *pa;
1178
1179 pa = malloc(sizeof(struct pargs) + len, M_PARGS,
1180 M_WAITOK);
1181 refcount_init(&pa->ar_ref, 1);
1182 pa->ar_length = len;
1183 return (pa);
1184}
1185
1186static void
1187pargs_free(struct pargs *pa)
1188{
1189
1190 free(pa, M_PARGS);
1191}
1192
1193void
1194pargs_hold(struct pargs *pa)
1195{
1196
1197 if (pa == NULL)
1198 return;
1199 refcount_acquire(&pa->ar_ref);
1200}
1201
1202void
1203pargs_drop(struct pargs *pa)
1204{
1205
1206 if (pa == NULL)
1207 return;
1208 if (refcount_release(&pa->ar_ref))
1209 pargs_free(pa);
1210}
1211
1212/*
1213 * This sysctl allows a process to retrieve the argument list or process
1214 * title for another process without groping around in the address space
1215 * of the other process. It also allow a process to set its own "process
1216 * title to a string of its own choice.
1217 */
1218static int
1219sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
1220{
1221 int *name = (int*) arg1;
1222 u_int namelen = arg2;
1223 struct pargs *newpa, *pa;
1224 struct proc *p;
1225 int error = 0;
1226
1227 if (namelen != 1)
1228 return (EINVAL);
1229
1230 p = pfind((pid_t)name[0]);
1231 if (!p)
1232 return (ESRCH);
1233
1234 if ((error = p_cansee(curthread, p)) != 0) {
1235 PROC_UNLOCK(p);
1236 return (error);
1237 }
1238
1239 if (req->newptr && curproc != p) {
1240 PROC_UNLOCK(p);
1241 return (EPERM);
1242 }
1243
1244 pa = p->p_args;
1245 pargs_hold(pa);
1246 PROC_UNLOCK(p);
1247 if (req->oldptr != NULL && pa != NULL)
1248 error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length);
1249 pargs_drop(pa);
1250 if (error != 0 || req->newptr == NULL)
1251 return (error);
1252
1253 if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit)
1254 return (ENOMEM);
1255 newpa = pargs_alloc(req->newlen);
1256 error = SYSCTL_IN(req, newpa->ar_args, req->newlen);
1257 if (error != 0) {
1258 pargs_free(newpa);
1259 return (error);
1260 }
1261 PROC_LOCK(p);
1262 pa = p->p_args;
1263 p->p_args = newpa;
1264 PROC_UNLOCK(p);
1265 pargs_drop(pa);
1266 return (0);
1267}
1268
1269/*
1270 * This sysctl allows a process to retrieve the path of the executable for
1271 * itself or another process.
1272 */
1273static int
1274sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS)
1275{
1276 pid_t *pidp = (pid_t *)arg1;
1277 unsigned int arglen = arg2;
1278 struct proc *p;
1279 struct vnode *vp;
1280 char *retbuf, *freebuf;
1281 int error;
1282
1283 if (arglen != 1)
1284 return (EINVAL);
1285 if (*pidp == -1) { /* -1 means this process */
1286 p = req->td->td_proc;
1287 } else {
1288 p = pfind(*pidp);
1289 if (p == NULL)
1290 return (ESRCH);
1291 if ((error = p_cansee(curthread, p)) != 0) {
1292 PROC_UNLOCK(p);
1293 return (error);
1294 }
1295 }
1296
1297 vp = p->p_textvp;
1298 if (vp == NULL) {
1299 if (*pidp != -1)
1300 PROC_UNLOCK(p);
1301 return (0);
1302 }
1303 vref(vp);
1304 if (*pidp != -1)
1305 PROC_UNLOCK(p);
1306 error = vn_fullpath(req->td, vp, &retbuf, &freebuf);
1307 vrele(vp);
1308 if (error)
1309 return (error);
1310 error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1);
1311 free(freebuf, M_TEMP);
1312 return (error);
1313}
1314
1315static int
1316sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS)
1317{
1318 struct proc *p;
1319 char *sv_name;
1320 int *name;
1321 int namelen;
1322 int error;
1323
1324 namelen = arg2;
1325 if (namelen != 1)
1326 return (EINVAL);
1327
1328 name = (int *)arg1;
1329 if ((p = pfind((pid_t)name[0])) == NULL)
1330 return (ESRCH);
1331 if ((error = p_cansee(curthread, p))) {
1332 PROC_UNLOCK(p);
1333 return (error);
1334 }
1335 sv_name = p->p_sysent->sv_name;
1336 PROC_UNLOCK(p);
1337 return (sysctl_handle_string(oidp, sv_name, 0, req));
1338}
1339
| 36#include "opt_ddb.h"
37#include "opt_kdtrace.h"
38#include "opt_ktrace.h"
39#include "opt_kstack_pages.h"
40#include "opt_stack.h"
41
42#include <sys/param.h>
43#include <sys/systm.h>
44#include <sys/kernel.h>
45#include <sys/lock.h>
46#include <sys/malloc.h>
47#include <sys/mount.h>
48#include <sys/mutex.h>
49#include <sys/proc.h>
50#include <sys/refcount.h>
51#include <sys/sbuf.h>
52#include <sys/sysent.h>
53#include <sys/sched.h>
54#include <sys/smp.h>
55#include <sys/stack.h>
56#include <sys/sysctl.h>
57#include <sys/filedesc.h>
58#include <sys/tty.h>
59#include <sys/signalvar.h>
60#include <sys/sdt.h>
61#include <sys/sx.h>
62#include <sys/user.h>
63#include <sys/jail.h>
64#include <sys/vnode.h>
65#include <sys/eventhandler.h>
66#ifdef KTRACE
67#include <sys/uio.h>
68#include <sys/ktrace.h>
69#endif
70
71#ifdef DDB
72#include <ddb/ddb.h>
73#endif
74
75#include <vm/vm.h>
76#include <vm/vm_extern.h>
77#include <vm/pmap.h>
78#include <vm/vm_map.h>
79#include <vm/vm_object.h>
80#include <vm/uma.h>
81
82SDT_PROVIDER_DEFINE(proc);
83SDT_PROBE_DEFINE(proc, kernel, ctor, entry);
84SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 0, "struct proc *");
85SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 1, "int");
86SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 2, "void *");
87SDT_PROBE_ARGTYPE(proc, kernel, ctor, entry, 3, "int");
88SDT_PROBE_DEFINE(proc, kernel, ctor, return);
89SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 0, "struct proc *");
90SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 1, "int");
91SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 2, "void *");
92SDT_PROBE_ARGTYPE(proc, kernel, ctor, return, 3, "int");
93SDT_PROBE_DEFINE(proc, kernel, dtor, entry);
94SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 0, "struct proc *");
95SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 1, "int");
96SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 2, "void *");
97SDT_PROBE_ARGTYPE(proc, kernel, dtor, entry, 3, "struct thread *");
98SDT_PROBE_DEFINE(proc, kernel, dtor, return);
99SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 0, "struct proc *");
100SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 1, "int");
101SDT_PROBE_ARGTYPE(proc, kernel, dtor, return, 2, "void *");
102SDT_PROBE_DEFINE(proc, kernel, init, entry);
103SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 0, "struct proc *");
104SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 1, "int");
105SDT_PROBE_ARGTYPE(proc, kernel, init, entry, 2, "int");
106SDT_PROBE_DEFINE(proc, kernel, init, return);
107SDT_PROBE_ARGTYPE(proc, kernel, init, return, 0, "struct proc *");
108SDT_PROBE_ARGTYPE(proc, kernel, init, return, 1, "int");
109SDT_PROBE_ARGTYPE(proc, kernel, init, return, 2, "int");
110
111MALLOC_DEFINE(M_PGRP, "pgrp", "process group header");
112MALLOC_DEFINE(M_SESSION, "session", "session header");
113static MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
114MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
115
116static void doenterpgrp(struct proc *, struct pgrp *);
117static void orphanpg(struct pgrp *pg);
118static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp);
119static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp,
120 int preferthread);
121static void pgadjustjobc(struct pgrp *pgrp, int entering);
122static void pgdelete(struct pgrp *);
123static int proc_ctor(void *mem, int size, void *arg, int flags);
124static void proc_dtor(void *mem, int size, void *arg);
125static int proc_init(void *mem, int size, int flags);
126static void proc_fini(void *mem, int size);
127static void pargs_free(struct pargs *pa);
128
129/*
130 * Other process lists
131 */
132struct pidhashhead *pidhashtbl;
133u_long pidhash;
134struct pgrphashhead *pgrphashtbl;
135u_long pgrphash;
136struct proclist allproc;
137struct proclist zombproc;
138struct sx allproc_lock;
139struct sx proctree_lock;
140struct mtx ppeers_lock;
141uma_zone_t proc_zone;
142uma_zone_t ithread_zone;
143
144int kstack_pages = KSTACK_PAGES;
145SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0, "");
146
147CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
148
149/*
150 * Initialize global process hashing structures.
151 */
152void
153procinit()
154{
155
156 sx_init(&allproc_lock, "allproc");
157 sx_init(&proctree_lock, "proctree");
158 mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF);
159 LIST_INIT(&allproc);
160 LIST_INIT(&zombproc);
161 pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
162 pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
163 proc_zone = uma_zcreate("PROC", sched_sizeof_proc(),
164 proc_ctor, proc_dtor, proc_init, proc_fini,
165 UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
166 uihashinit();
167}
168
169/*
170 * Prepare a proc for use.
171 */
172static int
173proc_ctor(void *mem, int size, void *arg, int flags)
174{
175 struct proc *p;
176
177 p = (struct proc *)mem;
178 SDT_PROBE(proc, kernel, ctor , entry, p, size, arg, flags, 0);
179 EVENTHANDLER_INVOKE(process_ctor, p);
180 SDT_PROBE(proc, kernel, ctor , return, p, size, arg, flags, 0);
181 return (0);
182}
183
184/*
185 * Reclaim a proc after use.
186 */
187static void
188proc_dtor(void *mem, int size, void *arg)
189{
190 struct proc *p;
191 struct thread *td;
192
193 /* INVARIANTS checks go here */
194 p = (struct proc *)mem;
195 td = FIRST_THREAD_IN_PROC(p);
196 SDT_PROBE(proc, kernel, dtor, entry, p, size, arg, td, 0);
197 if (td != NULL) {
198#ifdef INVARIANTS
199 KASSERT((p->p_numthreads == 1),
200 ("bad number of threads in exiting process"));
201 KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr"));
202#endif
203 /* Free all OSD associated to this thread. */
204 osd_thread_exit(td);
205
206 /* Dispose of an alternate kstack, if it exists.
207 * XXX What if there are more than one thread in the proc?
208 * The first thread in the proc is special and not
209 * freed, so you gotta do this here.
210 */
211 if (((p->p_flag & P_KTHREAD) != 0) && (td->td_altkstack != 0))
212 vm_thread_dispose_altkstack(td);
213 }
214 EVENTHANDLER_INVOKE(process_dtor, p);
215 if (p->p_ksi != NULL)
216 KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue"));
217 SDT_PROBE(proc, kernel, dtor, return, p, size, arg, 0, 0);
218}
219
220/*
221 * Initialize type-stable parts of a proc (when newly created).
222 */
223static int
224proc_init(void *mem, int size, int flags)
225{
226 struct proc *p;
227
228 p = (struct proc *)mem;
229 SDT_PROBE(proc, kernel, init, entry, p, size, flags, 0, 0);
230 p->p_sched = (struct p_sched *)&p[1];
231 bzero(&p->p_mtx, sizeof(struct mtx));
232 mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK);
233 mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE);
234 TAILQ_INIT(&p->p_threads); /* all threads in proc */
235 EVENTHANDLER_INVOKE(process_init, p);
236 p->p_stats = pstats_alloc();
237 SDT_PROBE(proc, kernel, init, return, p, size, flags, 0, 0);
238 return (0);
239}
240
241/*
242 * UMA should ensure that this function is never called.
243 * Freeing a proc structure would violate type stability.
244 */
245static void
246proc_fini(void *mem, int size)
247{
248#ifdef notnow
249 struct proc *p;
250
251 p = (struct proc *)mem;
252 EVENTHANDLER_INVOKE(process_fini, p);
253 pstats_free(p->p_stats);
254 thread_free(FIRST_THREAD_IN_PROC(p));
255 mtx_destroy(&p->p_mtx);
256 if (p->p_ksi != NULL)
257 ksiginfo_free(p->p_ksi);
258#else
259 panic("proc reclaimed");
260#endif
261}
262
263/*
264 * Is p an inferior of the current process?
265 */
266int
267inferior(p)
268 register struct proc *p;
269{
270
271 sx_assert(&proctree_lock, SX_LOCKED);
272 for (; p != curproc; p = p->p_pptr)
273 if (p->p_pid == 0)
274 return (0);
275 return (1);
276}
277
278/*
279 * Locate a process by number; return only "live" processes -- i.e., neither
280 * zombies nor newly born but incompletely initialized processes. By not
281 * returning processes in the PRS_NEW state, we allow callers to avoid
282 * testing for that condition to avoid dereferencing p_ucred, et al.
283 */
284struct proc *
285pfind(pid)
286 register pid_t pid;
287{
288 register struct proc *p;
289
290 sx_slock(&allproc_lock);
291 LIST_FOREACH(p, PIDHASH(pid), p_hash)
292 if (p->p_pid == pid) {
293 if (p->p_state == PRS_NEW) {
294 p = NULL;
295 break;
296 }
297 PROC_LOCK(p);
298 break;
299 }
300 sx_sunlock(&allproc_lock);
301 return (p);
302}
303
304/*
305 * Locate a process group by number.
306 * The caller must hold proctree_lock.
307 */
308struct pgrp *
309pgfind(pgid)
310 register pid_t pgid;
311{
312 register struct pgrp *pgrp;
313
314 sx_assert(&proctree_lock, SX_LOCKED);
315
316 LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) {
317 if (pgrp->pg_id == pgid) {
318 PGRP_LOCK(pgrp);
319 return (pgrp);
320 }
321 }
322 return (NULL);
323}
324
325/*
326 * Create a new process group.
327 * pgid must be equal to the pid of p.
328 * Begin a new session if required.
329 */
330int
331enterpgrp(p, pgid, pgrp, sess)
332 register struct proc *p;
333 pid_t pgid;
334 struct pgrp *pgrp;
335 struct session *sess;
336{
337 struct pgrp *pgrp2;
338
339 sx_assert(&proctree_lock, SX_XLOCKED);
340
341 KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL"));
342 KASSERT(p->p_pid == pgid,
343 ("enterpgrp: new pgrp and pid != pgid"));
344
345 pgrp2 = pgfind(pgid);
346
347 KASSERT(pgrp2 == NULL,
348 ("enterpgrp: pgrp with pgid exists"));
349 KASSERT(!SESS_LEADER(p),
350 ("enterpgrp: session leader attempted setpgrp"));
351
352 mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
353
354 if (sess != NULL) {
355 /*
356 * new session
357 */
358 mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF);
359 PROC_LOCK(p);
360 p->p_flag &= ~P_CONTROLT;
361 PROC_UNLOCK(p);
362 PGRP_LOCK(pgrp);
363 sess->s_leader = p;
364 sess->s_sid = p->p_pid;
365 refcount_init(&sess->s_count, 1);
366 sess->s_ttyvp = NULL;
367 sess->s_ttyp = NULL;
368 bcopy(p->p_session->s_login, sess->s_login,
369 sizeof(sess->s_login));
370 pgrp->pg_session = sess;
371 KASSERT(p == curproc,
372 ("enterpgrp: mksession and p != curproc"));
373 } else {
374 pgrp->pg_session = p->p_session;
375 sess_hold(pgrp->pg_session);
376 PGRP_LOCK(pgrp);
377 }
378 pgrp->pg_id = pgid;
379 LIST_INIT(&pgrp->pg_members);
380
381 /*
382 * As we have an exclusive lock of proctree_lock,
383 * this should not deadlock.
384 */
385 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
386 pgrp->pg_jobc = 0;
387 SLIST_INIT(&pgrp->pg_sigiolst);
388 PGRP_UNLOCK(pgrp);
389
390 doenterpgrp(p, pgrp);
391
392 return (0);
393}
394
395/*
396 * Move p to an existing process group
397 */
398int
399enterthispgrp(p, pgrp)
400 register struct proc *p;
401 struct pgrp *pgrp;
402{
403
404 sx_assert(&proctree_lock, SX_XLOCKED);
405 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
406 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
407 PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
408 SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
409 KASSERT(pgrp->pg_session == p->p_session,
410 ("%s: pgrp's session %p, p->p_session %p.\n",
411 __func__,
412 pgrp->pg_session,
413 p->p_session));
414 KASSERT(pgrp != p->p_pgrp,
415 ("%s: p belongs to pgrp.", __func__));
416
417 doenterpgrp(p, pgrp);
418
419 return (0);
420}
421
422/*
423 * Move p to a process group
424 */
425static void
426doenterpgrp(p, pgrp)
427 struct proc *p;
428 struct pgrp *pgrp;
429{
430 struct pgrp *savepgrp;
431
432 sx_assert(&proctree_lock, SX_XLOCKED);
433 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
434 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
435 PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
436 SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
437
438 savepgrp = p->p_pgrp;
439
440 /*
441 * Adjust eligibility of affected pgrps to participate in job control.
442 * Increment eligibility counts before decrementing, otherwise we
443 * could reach 0 spuriously during the first call.
444 */
445 fixjobc(p, pgrp, 1);
446 fixjobc(p, p->p_pgrp, 0);
447
448 PGRP_LOCK(pgrp);
449 PGRP_LOCK(savepgrp);
450 PROC_LOCK(p);
451 LIST_REMOVE(p, p_pglist);
452 p->p_pgrp = pgrp;
453 PROC_UNLOCK(p);
454 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
455 PGRP_UNLOCK(savepgrp);
456 PGRP_UNLOCK(pgrp);
457 if (LIST_EMPTY(&savepgrp->pg_members))
458 pgdelete(savepgrp);
459}
460
461/*
462 * remove process from process group
463 */
464int
465leavepgrp(p)
466 register struct proc *p;
467{
468 struct pgrp *savepgrp;
469
470 sx_assert(&proctree_lock, SX_XLOCKED);
471 savepgrp = p->p_pgrp;
472 PGRP_LOCK(savepgrp);
473 PROC_LOCK(p);
474 LIST_REMOVE(p, p_pglist);
475 p->p_pgrp = NULL;
476 PROC_UNLOCK(p);
477 PGRP_UNLOCK(savepgrp);
478 if (LIST_EMPTY(&savepgrp->pg_members))
479 pgdelete(savepgrp);
480 return (0);
481}
482
483/*
484 * delete a process group
485 */
486static void
487pgdelete(pgrp)
488 register struct pgrp *pgrp;
489{
490 struct session *savesess;
491 struct tty *tp;
492
493 sx_assert(&proctree_lock, SX_XLOCKED);
494 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
495 SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
496
497 /*
498 * Reset any sigio structures pointing to us as a result of
499 * F_SETOWN with our pgid.
500 */
501 funsetownlst(&pgrp->pg_sigiolst);
502
503 PGRP_LOCK(pgrp);
504 tp = pgrp->pg_session->s_ttyp;
505 LIST_REMOVE(pgrp, pg_hash);
506 savesess = pgrp->pg_session;
507 PGRP_UNLOCK(pgrp);
508
509 /* Remove the reference to the pgrp before deallocating it. */
510 if (tp != NULL) {
511 tty_lock(tp);
512 tty_rel_pgrp(tp, pgrp);
513 }
514
515 mtx_destroy(&pgrp->pg_mtx);
516 free(pgrp, M_PGRP);
517 sess_release(savesess);
518}
519
520static void
521pgadjustjobc(pgrp, entering)
522 struct pgrp *pgrp;
523 int entering;
524{
525
526 PGRP_LOCK(pgrp);
527 if (entering)
528 pgrp->pg_jobc++;
529 else {
530 --pgrp->pg_jobc;
531 if (pgrp->pg_jobc == 0)
532 orphanpg(pgrp);
533 }
534 PGRP_UNLOCK(pgrp);
535}
536
537/*
538 * Adjust pgrp jobc counters when specified process changes process group.
539 * We count the number of processes in each process group that "qualify"
540 * the group for terminal job control (those with a parent in a different
541 * process group of the same session). If that count reaches zero, the
542 * process group becomes orphaned. Check both the specified process'
543 * process group and that of its children.
544 * entering == 0 => p is leaving specified group.
545 * entering == 1 => p is entering specified group.
546 */
547void
548fixjobc(p, pgrp, entering)
549 register struct proc *p;
550 register struct pgrp *pgrp;
551 int entering;
552{
553 register struct pgrp *hispgrp;
554 register struct session *mysession;
555
556 sx_assert(&proctree_lock, SX_LOCKED);
557 PROC_LOCK_ASSERT(p, MA_NOTOWNED);
558 PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
559 SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
560
561 /*
562 * Check p's parent to see whether p qualifies its own process
563 * group; if so, adjust count for p's process group.
564 */
565 mysession = pgrp->pg_session;
566 if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
567 hispgrp->pg_session == mysession)
568 pgadjustjobc(pgrp, entering);
569
570 /*
571 * Check this process' children to see whether they qualify
572 * their process groups; if so, adjust counts for children's
573 * process groups.
574 */
575 LIST_FOREACH(p, &p->p_children, p_sibling) {
576 hispgrp = p->p_pgrp;
577 if (hispgrp == pgrp ||
578 hispgrp->pg_session != mysession)
579 continue;
580 PROC_LOCK(p);
581 if (p->p_state == PRS_ZOMBIE) {
582 PROC_UNLOCK(p);
583 continue;
584 }
585 PROC_UNLOCK(p);
586 pgadjustjobc(hispgrp, entering);
587 }
588}
589
590/*
591 * A process group has become orphaned;
592 * if there are any stopped processes in the group,
593 * hang-up all process in that group.
594 */
595static void
596orphanpg(pg)
597 struct pgrp *pg;
598{
599 register struct proc *p;
600
601 PGRP_LOCK_ASSERT(pg, MA_OWNED);
602
603 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
604 PROC_LOCK(p);
605 if (P_SHOULDSTOP(p)) {
606 PROC_UNLOCK(p);
607 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
608 PROC_LOCK(p);
609 psignal(p, SIGHUP);
610 psignal(p, SIGCONT);
611 PROC_UNLOCK(p);
612 }
613 return;
614 }
615 PROC_UNLOCK(p);
616 }
617}
618
619void
620sess_hold(struct session *s)
621{
622
623 refcount_acquire(&s->s_count);
624}
625
626void
627sess_release(struct session *s)
628{
629
630 if (refcount_release(&s->s_count)) {
631 if (s->s_ttyp != NULL) {
632 tty_lock(s->s_ttyp);
633 tty_rel_sess(s->s_ttyp, s);
634 }
635 mtx_destroy(&s->s_mtx);
636 free(s, M_SESSION);
637 }
638}
639
640#include "opt_ddb.h"
641#ifdef DDB
642#include <ddb/ddb.h>
643
644DB_SHOW_COMMAND(pgrpdump, pgrpdump)
645{
646 register struct pgrp *pgrp;
647 register struct proc *p;
648 register int i;
649
650 for (i = 0; i <= pgrphash; i++) {
651 if (!LIST_EMPTY(&pgrphashtbl[i])) {
652 printf("\tindx %d\n", i);
653 LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
654 printf(
655 "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
656 (void *)pgrp, (long)pgrp->pg_id,
657 (void *)pgrp->pg_session,
658 pgrp->pg_session->s_count,
659 (void *)LIST_FIRST(&pgrp->pg_members));
660 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
661 printf("\t\tpid %ld addr %p pgrp %p\n",
662 (long)p->p_pid, (void *)p,
663 (void *)p->p_pgrp);
664 }
665 }
666 }
667 }
668}
669#endif /* DDB */
670
671/*
672 * Clear kinfo_proc and fill in any information that is common
673 * to all threads in the process.
674 * Must be called with the target process locked.
675 */
676static void
677fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp)
678{
679 struct thread *td0;
680 struct tty *tp;
681 struct session *sp;
682 struct ucred *cred;
683 struct sigacts *ps;
684
685 PROC_LOCK_ASSERT(p, MA_OWNED);
686 bzero(kp, sizeof(*kp));
687
688 kp->ki_structsize = sizeof(*kp);
689 kp->ki_paddr = p;
690 kp->ki_addr =/* p->p_addr; */0; /* XXX */
691 kp->ki_args = p->p_args;
692 kp->ki_textvp = p->p_textvp;
693#ifdef KTRACE
694 kp->ki_tracep = p->p_tracevp;
695 mtx_lock(&ktrace_mtx);
696 kp->ki_traceflag = p->p_traceflag;
697 mtx_unlock(&ktrace_mtx);
698#endif
699 kp->ki_fd = p->p_fd;
700 kp->ki_vmspace = p->p_vmspace;
701 kp->ki_flag = p->p_flag;
702 cred = p->p_ucred;
703 if (cred) {
704 kp->ki_uid = cred->cr_uid;
705 kp->ki_ruid = cred->cr_ruid;
706 kp->ki_svuid = cred->cr_svuid;
707 /* XXX bde doesn't like KI_NGROUPS */
708 kp->ki_ngroups = min(cred->cr_ngroups, KI_NGROUPS);
709 bcopy(cred->cr_groups, kp->ki_groups,
710 kp->ki_ngroups * sizeof(gid_t));
711 kp->ki_rgid = cred->cr_rgid;
712 kp->ki_svgid = cred->cr_svgid;
713 /* If jailed(cred), emulate the old P_JAILED flag. */
714 if (jailed(cred)) {
715 kp->ki_flag |= P_JAILED;
716 /* If inside a jail, use 0 as a jail ID. */
717 if (!jailed(curthread->td_ucred))
718 kp->ki_jid = cred->cr_prison->pr_id;
719 }
720 }
721 ps = p->p_sigacts;
722 if (ps) {
723 mtx_lock(&ps->ps_mtx);
724 kp->ki_sigignore = ps->ps_sigignore;
725 kp->ki_sigcatch = ps->ps_sigcatch;
726 mtx_unlock(&ps->ps_mtx);
727 }
728 PROC_SLOCK(p);
729 if (p->p_state != PRS_NEW &&
730 p->p_state != PRS_ZOMBIE &&
731 p->p_vmspace != NULL) {
732 struct vmspace *vm = p->p_vmspace;
733
734 kp->ki_size = vm->vm_map.size;
735 kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/
736 FOREACH_THREAD_IN_PROC(p, td0) {
737 if (!TD_IS_SWAPPED(td0))
738 kp->ki_rssize += td0->td_kstack_pages;
739 if (td0->td_altkstack_obj != NULL)
740 kp->ki_rssize += td0->td_altkstack_pages;
741 }
742 kp->ki_swrss = vm->vm_swrss;
743 kp->ki_tsize = vm->vm_tsize;
744 kp->ki_dsize = vm->vm_dsize;
745 kp->ki_ssize = vm->vm_ssize;
746 } else if (p->p_state == PRS_ZOMBIE)
747 kp->ki_stat = SZOMB;
748 if (kp->ki_flag & P_INMEM)
749 kp->ki_sflag = PS_INMEM;
750 else
751 kp->ki_sflag = 0;
752 /* Calculate legacy swtime as seconds since 'swtick'. */
753 kp->ki_swtime = (ticks - p->p_swtick) / hz;
754 kp->ki_pid = p->p_pid;
755 kp->ki_nice = p->p_nice;
756 rufetch(p, &kp->ki_rusage);
757 kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime);
758 PROC_SUNLOCK(p);
759 if ((p->p_flag & P_INMEM) && p->p_stats != NULL) {
760 kp->ki_start = p->p_stats->p_start;
761 timevaladd(&kp->ki_start, &boottime);
762 PROC_SLOCK(p);
763 calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime);
764 PROC_SUNLOCK(p);
765 calccru(p, &kp->ki_childutime, &kp->ki_childstime);
766
767 /* Some callers want child-times in a single value */
768 kp->ki_childtime = kp->ki_childstime;
769 timevaladd(&kp->ki_childtime, &kp->ki_childutime);
770 }
771 tp = NULL;
772 if (p->p_pgrp) {
773 kp->ki_pgid = p->p_pgrp->pg_id;
774 kp->ki_jobc = p->p_pgrp->pg_jobc;
775 sp = p->p_pgrp->pg_session;
776
777 if (sp != NULL) {
778 kp->ki_sid = sp->s_sid;
779 SESS_LOCK(sp);
780 strlcpy(kp->ki_login, sp->s_login,
781 sizeof(kp->ki_login));
782 if (sp->s_ttyvp)
783 kp->ki_kiflag |= KI_CTTY;
784 if (SESS_LEADER(p))
785 kp->ki_kiflag |= KI_SLEADER;
786 /* XXX proctree_lock */
787 tp = sp->s_ttyp;
788 SESS_UNLOCK(sp);
789 }
790 }
791 if ((p->p_flag & P_CONTROLT) && tp != NULL) {
792 kp->ki_tdev = tty_udev(tp);
793 kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
794 if (tp->t_session)
795 kp->ki_tsid = tp->t_session->s_sid;
796 } else
797 kp->ki_tdev = NODEV;
798 if (p->p_comm[0] != '\0')
799 strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));
800 if (p->p_sysent && p->p_sysent->sv_name != NULL &&
801 p->p_sysent->sv_name[0] != '\0')
802 strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul));
803 kp->ki_siglist = p->p_siglist;
804 kp->ki_xstat = p->p_xstat;
805 kp->ki_acflag = p->p_acflag;
806 kp->ki_lock = p->p_lock;
807 if (p->p_pptr)
808 kp->ki_ppid = p->p_pptr->p_pid;
809}
810
811/*
812 * Fill in information that is thread specific. Must be called with p_slock
813 * locked. If 'preferthread' is set, overwrite certain process-related
814 * fields that are maintained for both threads and processes.
815 */
816static void
817fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread)
818{
819 struct proc *p;
820
821 p = td->td_proc;
822 PROC_LOCK_ASSERT(p, MA_OWNED);
823
824 thread_lock(td);
825 if (td->td_wmesg != NULL)
826 strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg));
827 else
828 bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg));
829 if (td->td_name[0] != '\0')
830 strlcpy(kp->ki_ocomm, td->td_name, sizeof(kp->ki_ocomm));
831 if (TD_ON_LOCK(td)) {
832 kp->ki_kiflag |= KI_LOCKBLOCK;
833 strlcpy(kp->ki_lockname, td->td_lockname,
834 sizeof(kp->ki_lockname));
835 } else {
836 kp->ki_kiflag &= ~KI_LOCKBLOCK;
837 bzero(kp->ki_lockname, sizeof(kp->ki_lockname));
838 }
839
840 if (p->p_state == PRS_NORMAL) { /* approximate. */
841 if (TD_ON_RUNQ(td) ||
842 TD_CAN_RUN(td) ||
843 TD_IS_RUNNING(td)) {
844 kp->ki_stat = SRUN;
845 } else if (P_SHOULDSTOP(p)) {
846 kp->ki_stat = SSTOP;
847 } else if (TD_IS_SLEEPING(td)) {
848 kp->ki_stat = SSLEEP;
849 } else if (TD_ON_LOCK(td)) {
850 kp->ki_stat = SLOCK;
851 } else {
852 kp->ki_stat = SWAIT;
853 }
854 } else if (p->p_state == PRS_ZOMBIE) {
855 kp->ki_stat = SZOMB;
856 } else {
857 kp->ki_stat = SIDL;
858 }
859
860 /* Things in the thread */
861 kp->ki_wchan = td->td_wchan;
862 kp->ki_pri.pri_level = td->td_priority;
863 kp->ki_pri.pri_native = td->td_base_pri;
864 kp->ki_lastcpu = td->td_lastcpu;
865 kp->ki_oncpu = td->td_oncpu;
866 kp->ki_tdflags = td->td_flags;
867 kp->ki_tid = td->td_tid;
868 kp->ki_numthreads = p->p_numthreads;
869 kp->ki_pcb = td->td_pcb;
870 kp->ki_kstack = (void *)td->td_kstack;
871 kp->ki_pctcpu = sched_pctcpu(td);
872 kp->ki_estcpu = td->td_estcpu;
873 kp->ki_slptime = (ticks - td->td_slptick) / hz;
874 kp->ki_pri.pri_class = td->td_pri_class;
875 kp->ki_pri.pri_user = td->td_user_pri;
876
877 if (preferthread)
878 kp->ki_runtime = cputick2usec(td->td_runtime);
879
880 /* We can't get this anymore but ps etc never used it anyway. */
881 kp->ki_rqindex = 0;
882
883 SIGSETOR(kp->ki_siglist, td->td_siglist);
884 kp->ki_sigmask = td->td_sigmask;
885 thread_unlock(td);
886}
887
888/*
889 * Fill in a kinfo_proc structure for the specified process.
890 * Must be called with the target process locked.
891 */
892void
893fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
894{
895
896 fill_kinfo_proc_only(p, kp);
897 if (FIRST_THREAD_IN_PROC(p) != NULL)
898 fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0);
899}
900
901struct pstats *
902pstats_alloc(void)
903{
904
905 return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK));
906}
907
908/*
909 * Copy parts of p_stats; zero the rest of p_stats (statistics).
910 */
911void
912pstats_fork(struct pstats *src, struct pstats *dst)
913{
914
915 bzero(&dst->pstat_startzero,
916 __rangeof(struct pstats, pstat_startzero, pstat_endzero));
917 bcopy(&src->pstat_startcopy, &dst->pstat_startcopy,
918 __rangeof(struct pstats, pstat_startcopy, pstat_endcopy));
919}
920
921void
922pstats_free(struct pstats *ps)
923{
924
925 free(ps, M_SUBPROC);
926}
927
928/*
929 * Locate a zombie process by number
930 */
931struct proc *
932zpfind(pid_t pid)
933{
934 struct proc *p;
935
936 sx_slock(&allproc_lock);
937 LIST_FOREACH(p, &zombproc, p_list)
938 if (p->p_pid == pid) {
939 PROC_LOCK(p);
940 break;
941 }
942 sx_sunlock(&allproc_lock);
943 return (p);
944}
945
946#define KERN_PROC_ZOMBMASK 0x3
947#define KERN_PROC_NOTHREADS 0x4
948
949/*
950 * Must be called with the process locked and will return with it unlocked.
951 */
952static int
953sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags)
954{
955 struct thread *td;
956 struct kinfo_proc kinfo_proc;
957 int error = 0;
958 struct proc *np;
959 pid_t pid = p->p_pid;
960
961 PROC_LOCK_ASSERT(p, MA_OWNED);
962
963 fill_kinfo_proc_only(p, &kinfo_proc);
964 if (flags & KERN_PROC_NOTHREADS) {
965 if (FIRST_THREAD_IN_PROC(p) != NULL)
966 fill_kinfo_thread(FIRST_THREAD_IN_PROC(p),
967 &kinfo_proc, 0);
968 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc,
969 sizeof(kinfo_proc));
970 } else {
971 if (FIRST_THREAD_IN_PROC(p) != NULL)
972 FOREACH_THREAD_IN_PROC(p, td) {
973 fill_kinfo_thread(td, &kinfo_proc, 1);
974 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc,
975 sizeof(kinfo_proc));
976 if (error)
977 break;
978 }
979 else
980 error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc,
981 sizeof(kinfo_proc));
982 }
983 PROC_UNLOCK(p);
984 if (error)
985 return (error);
986 if (flags & KERN_PROC_ZOMBMASK)
987 np = zpfind(pid);
988 else {
989 if (pid == 0)
990 return (0);
991 np = pfind(pid);
992 }
993 if (np == NULL)
994 return (ESRCH);
995 if (np != p) {
996 PROC_UNLOCK(np);
997 return (ESRCH);
998 }
999 PROC_UNLOCK(np);
1000 return (0);
1001}
1002
1003static int
1004sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
1005{
1006 int *name = (int*) arg1;
1007 u_int namelen = arg2;
1008 struct proc *p;
1009 int flags, doingzomb, oid_number;
1010 int error = 0;
1011
1012 oid_number = oidp->oid_number;
1013 if (oid_number != KERN_PROC_ALL &&
1014 (oid_number & KERN_PROC_INC_THREAD) == 0)
1015 flags = KERN_PROC_NOTHREADS;
1016 else {
1017 flags = 0;
1018 oid_number &= ~KERN_PROC_INC_THREAD;
1019 }
1020 if (oid_number == KERN_PROC_PID) {
1021 if (namelen != 1)
1022 return (EINVAL);
1023 error = sysctl_wire_old_buffer(req, 0);
1024 if (error)
1025 return (error);
1026 p = pfind((pid_t)name[0]);
1027 if (!p)
1028 return (ESRCH);
1029 if ((error = p_cansee(curthread, p))) {
1030 PROC_UNLOCK(p);
1031 return (error);
1032 }
1033 error = sysctl_out_proc(p, req, flags);
1034 return (error);
1035 }
1036
1037 switch (oid_number) {
1038 case KERN_PROC_ALL:
1039 if (namelen != 0)
1040 return (EINVAL);
1041 break;
1042 case KERN_PROC_PROC:
1043 if (namelen != 0 && namelen != 1)
1044 return (EINVAL);
1045 break;
1046 default:
1047 if (namelen != 1)
1048 return (EINVAL);
1049 break;
1050 }
1051
1052 if (!req->oldptr) {
1053 /* overestimate by 5 procs */
1054 error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
1055 if (error)
1056 return (error);
1057 }
1058 error = sysctl_wire_old_buffer(req, 0);
1059 if (error != 0)
1060 return (error);
1061 sx_slock(&allproc_lock);
1062 for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
1063 if (!doingzomb)
1064 p = LIST_FIRST(&allproc);
1065 else
1066 p = LIST_FIRST(&zombproc);
1067 for (; p != 0; p = LIST_NEXT(p, p_list)) {
1068 /*
1069 * Skip embryonic processes.
1070 */
1071 PROC_SLOCK(p);
1072 if (p->p_state == PRS_NEW) {
1073 PROC_SUNLOCK(p);
1074 continue;
1075 }
1076 PROC_SUNLOCK(p);
1077 PROC_LOCK(p);
1078 KASSERT(p->p_ucred != NULL,
1079 ("process credential is NULL for non-NEW proc"));
1080 /*
1081 * Show a user only appropriate processes.
1082 */
1083 if (p_cansee(curthread, p)) {
1084 PROC_UNLOCK(p);
1085 continue;
1086 }
1087 /*
1088 * TODO - make more efficient (see notes below).
1089 * do by session.
1090 */
1091 switch (oid_number) {
1092
1093 case KERN_PROC_GID:
1094 if (p->p_ucred->cr_gid != (gid_t)name[0]) {
1095 PROC_UNLOCK(p);
1096 continue;
1097 }
1098 break;
1099
1100 case KERN_PROC_PGRP:
1101 /* could do this by traversing pgrp */
1102 if (p->p_pgrp == NULL ||
1103 p->p_pgrp->pg_id != (pid_t)name[0]) {
1104 PROC_UNLOCK(p);
1105 continue;
1106 }
1107 break;
1108
1109 case KERN_PROC_RGID:
1110 if (p->p_ucred->cr_rgid != (gid_t)name[0]) {
1111 PROC_UNLOCK(p);
1112 continue;
1113 }
1114 break;
1115
1116 case KERN_PROC_SESSION:
1117 if (p->p_session == NULL ||
1118 p->p_session->s_sid != (pid_t)name[0]) {
1119 PROC_UNLOCK(p);
1120 continue;
1121 }
1122 break;
1123
1124 case KERN_PROC_TTY:
1125 if ((p->p_flag & P_CONTROLT) == 0 ||
1126 p->p_session == NULL) {
1127 PROC_UNLOCK(p);
1128 continue;
1129 }
1130 /* XXX proctree_lock */
1131 SESS_LOCK(p->p_session);
1132 if (p->p_session->s_ttyp == NULL ||
1133 tty_udev(p->p_session->s_ttyp) !=
1134 (dev_t)name[0]) {
1135 SESS_UNLOCK(p->p_session);
1136 PROC_UNLOCK(p);
1137 continue;
1138 }
1139 SESS_UNLOCK(p->p_session);
1140 break;
1141
1142 case KERN_PROC_UID:
1143 if (p->p_ucred->cr_uid != (uid_t)name[0]) {
1144 PROC_UNLOCK(p);
1145 continue;
1146 }
1147 break;
1148
1149 case KERN_PROC_RUID:
1150 if (p->p_ucred->cr_ruid != (uid_t)name[0]) {
1151 PROC_UNLOCK(p);
1152 continue;
1153 }
1154 break;
1155
1156 case KERN_PROC_PROC:
1157 break;
1158
1159 default:
1160 break;
1161
1162 }
1163
1164 error = sysctl_out_proc(p, req, flags | doingzomb);
1165 if (error) {
1166 sx_sunlock(&allproc_lock);
1167 return (error);
1168 }
1169 }
1170 }
1171 sx_sunlock(&allproc_lock);
1172 return (0);
1173}
1174
1175struct pargs *
1176pargs_alloc(int len)
1177{
1178 struct pargs *pa;
1179
1180 pa = malloc(sizeof(struct pargs) + len, M_PARGS,
1181 M_WAITOK);
1182 refcount_init(&pa->ar_ref, 1);
1183 pa->ar_length = len;
1184 return (pa);
1185}
1186
1187static void
1188pargs_free(struct pargs *pa)
1189{
1190
1191 free(pa, M_PARGS);
1192}
1193
1194void
1195pargs_hold(struct pargs *pa)
1196{
1197
1198 if (pa == NULL)
1199 return;
1200 refcount_acquire(&pa->ar_ref);
1201}
1202
1203void
1204pargs_drop(struct pargs *pa)
1205{
1206
1207 if (pa == NULL)
1208 return;
1209 if (refcount_release(&pa->ar_ref))
1210 pargs_free(pa);
1211}
1212
1213/*
1214 * This sysctl allows a process to retrieve the argument list or process
1215 * title for another process without groping around in the address space
1216 * of the other process. It also allow a process to set its own "process
1217 * title to a string of its own choice.
1218 */
1219static int
1220sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
1221{
1222 int *name = (int*) arg1;
1223 u_int namelen = arg2;
1224 struct pargs *newpa, *pa;
1225 struct proc *p;
1226 int error = 0;
1227
1228 if (namelen != 1)
1229 return (EINVAL);
1230
1231 p = pfind((pid_t)name[0]);
1232 if (!p)
1233 return (ESRCH);
1234
1235 if ((error = p_cansee(curthread, p)) != 0) {
1236 PROC_UNLOCK(p);
1237 return (error);
1238 }
1239
1240 if (req->newptr && curproc != p) {
1241 PROC_UNLOCK(p);
1242 return (EPERM);
1243 }
1244
1245 pa = p->p_args;
1246 pargs_hold(pa);
1247 PROC_UNLOCK(p);
1248 if (req->oldptr != NULL && pa != NULL)
1249 error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length);
1250 pargs_drop(pa);
1251 if (error != 0 || req->newptr == NULL)
1252 return (error);
1253
1254 if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit)
1255 return (ENOMEM);
1256 newpa = pargs_alloc(req->newlen);
1257 error = SYSCTL_IN(req, newpa->ar_args, req->newlen);
1258 if (error != 0) {
1259 pargs_free(newpa);
1260 return (error);
1261 }
1262 PROC_LOCK(p);
1263 pa = p->p_args;
1264 p->p_args = newpa;
1265 PROC_UNLOCK(p);
1266 pargs_drop(pa);
1267 return (0);
1268}
1269
1270/*
1271 * This sysctl allows a process to retrieve the path of the executable for
1272 * itself or another process.
1273 */
1274static int
1275sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS)
1276{
1277 pid_t *pidp = (pid_t *)arg1;
1278 unsigned int arglen = arg2;
1279 struct proc *p;
1280 struct vnode *vp;
1281 char *retbuf, *freebuf;
1282 int error;
1283
1284 if (arglen != 1)
1285 return (EINVAL);
1286 if (*pidp == -1) { /* -1 means this process */
1287 p = req->td->td_proc;
1288 } else {
1289 p = pfind(*pidp);
1290 if (p == NULL)
1291 return (ESRCH);
1292 if ((error = p_cansee(curthread, p)) != 0) {
1293 PROC_UNLOCK(p);
1294 return (error);
1295 }
1296 }
1297
1298 vp = p->p_textvp;
1299 if (vp == NULL) {
1300 if (*pidp != -1)
1301 PROC_UNLOCK(p);
1302 return (0);
1303 }
1304 vref(vp);
1305 if (*pidp != -1)
1306 PROC_UNLOCK(p);
1307 error = vn_fullpath(req->td, vp, &retbuf, &freebuf);
1308 vrele(vp);
1309 if (error)
1310 return (error);
1311 error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1);
1312 free(freebuf, M_TEMP);
1313 return (error);
1314}
1315
1316static int
1317sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS)
1318{
1319 struct proc *p;
1320 char *sv_name;
1321 int *name;
1322 int namelen;
1323 int error;
1324
1325 namelen = arg2;
1326 if (namelen != 1)
1327 return (EINVAL);
1328
1329 name = (int *)arg1;
1330 if ((p = pfind((pid_t)name[0])) == NULL)
1331 return (ESRCH);
1332 if ((error = p_cansee(curthread, p))) {
1333 PROC_UNLOCK(p);
1334 return (error);
1335 }
1336 sv_name = p->p_sysent->sv_name;
1337 PROC_UNLOCK(p);
1338 return (sysctl_handle_string(oidp, sv_name, 0, req));
1339}
1340
|
1501#if defined(STACK) || defined(DDB)
1502static int
1503sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS)
1504{
1505 struct kinfo_kstack *kkstp;
1506 int error, i, *name, numthreads;
1507 lwpid_t *lwpidarray;
1508 struct thread *td;
1509 struct stack *st;
1510 struct sbuf sb;
1511 struct proc *p;
1512
1513 name = (int *)arg1;
1514 if ((p = pfind((pid_t)name[0])) == NULL)
1515 return (ESRCH);
1516 /* XXXRW: Not clear ESRCH is the right error during proc execve(). */
1517 if (p->p_flag & P_WEXIT || p->p_flag & P_INEXEC) {
1518 PROC_UNLOCK(p);
1519 return (ESRCH);
1520 }
1521 if ((error = p_candebug(curthread, p))) {
1522 PROC_UNLOCK(p);
1523 return (error);
1524 }
1525 _PHOLD(p);
1526 PROC_UNLOCK(p);
1527
1528 kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK);
1529 st = stack_create();
1530
1531 lwpidarray = NULL;
1532 numthreads = 0;
1533 PROC_LOCK(p);
1534repeat:
1535 if (numthreads < p->p_numthreads) {
1536 if (lwpidarray != NULL) {
1537 free(lwpidarray, M_TEMP);
1538 lwpidarray = NULL;
1539 }
1540 numthreads = p->p_numthreads;
1541 PROC_UNLOCK(p);
1542 lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP,
1543 M_WAITOK | M_ZERO);
1544 PROC_LOCK(p);
1545 goto repeat;
1546 }
1547 i = 0;
1548
1549 /*
1550 * XXXRW: During the below loop, execve(2) and countless other sorts
1551 * of changes could have taken place. Should we check to see if the
1552 * vmspace has been replaced, or the like, in order to prevent
1553 * giving a snapshot that spans, say, execve(2), with some threads
1554 * before and some after? Among other things, the credentials could
1555 * have changed, in which case the right to extract debug info might
1556 * no longer be assured.
1557 */
1558 FOREACH_THREAD_IN_PROC(p, td) {
1559 KASSERT(i < numthreads,
1560 ("sysctl_kern_proc_kstack: numthreads"));
1561 lwpidarray[i] = td->td_tid;
1562 i++;
1563 }
1564 numthreads = i;
1565 for (i = 0; i < numthreads; i++) {
1566 td = thread_find(p, lwpidarray[i]);
1567 if (td == NULL) {
1568 continue;
1569 }
1570 bzero(kkstp, sizeof(*kkstp));
1571 (void)sbuf_new(&sb, kkstp->kkst_trace,
1572 sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN);
1573 thread_lock(td);
1574 kkstp->kkst_tid = td->td_tid;
1575 if (TD_IS_SWAPPED(td))
1576 kkstp->kkst_state = KKST_STATE_SWAPPED;
1577 else if (TD_IS_RUNNING(td))
1578 kkstp->kkst_state = KKST_STATE_RUNNING;
1579 else {
1580 kkstp->kkst_state = KKST_STATE_STACKOK;
1581 stack_save_td(st, td);
1582 }
1583 thread_unlock(td);
1584 PROC_UNLOCK(p);
1585 stack_sbuf_print(&sb, st);
1586 sbuf_finish(&sb);
1587 sbuf_delete(&sb);
1588 error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp));
1589 PROC_LOCK(p);
1590 if (error)
1591 break;
1592 }
1593 _PRELE(p);
1594 PROC_UNLOCK(p);
1595 if (lwpidarray != NULL)
1596 free(lwpidarray, M_TEMP);
1597 stack_destroy(st);
1598 free(kkstp, M_TEMP);
1599 return (error);
1600}
1601#endif
1602
1603SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table");
1604
1605SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT,
1606 0, 0, sysctl_kern_proc, "S,proc", "Return entire process table");
1607
1608static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD,
1609 sysctl_kern_proc, "Process table");
1610
1611static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD,
1612 sysctl_kern_proc, "Process table");
1613
1614static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD,
1615 sysctl_kern_proc, "Process table");
1616
1617static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD,
1618 sysctl_kern_proc, "Process table");
1619
1620static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD,
1621 sysctl_kern_proc, "Process table");
1622
1623static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD,
1624 sysctl_kern_proc, "Process table");
1625
1626static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD,
1627 sysctl_kern_proc, "Process table");
1628
1629static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD,
1630 sysctl_kern_proc, "Process table");
1631
1632static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD,
1633 sysctl_kern_proc, "Return process table, no threads");
1634
1635static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args,
1636 CTLFLAG_RW | CTLFLAG_ANYBODY,
1637 sysctl_kern_proc_args, "Process argument list");
1638
1639static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD,
1640 sysctl_kern_proc_pathname, "Process executable path");
1641
1642static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD,
1643 sysctl_kern_proc_sv_name, "Process syscall vector name (ABI type)");
1644
1645static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td,
1646 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1647
1648static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td,
1649 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1650
1651static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td,
1652 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1653
1654static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD),
1655 sid_td, CTLFLAG_RD, sysctl_kern_proc, "Process table");
1656
1657static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td,
1658 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1659
1660static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td,
1661 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1662
1663static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td,
1664 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1665
1666static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td,
1667 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1668
1669static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td,
1670 CTLFLAG_RD, sysctl_kern_proc, "Return process table, no threads");
1671
| 1677#if defined(STACK) || defined(DDB)
1678static int
1679sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS)
1680{
1681 struct kinfo_kstack *kkstp;
1682 int error, i, *name, numthreads;
1683 lwpid_t *lwpidarray;
1684 struct thread *td;
1685 struct stack *st;
1686 struct sbuf sb;
1687 struct proc *p;
1688
1689 name = (int *)arg1;
1690 if ((p = pfind((pid_t)name[0])) == NULL)
1691 return (ESRCH);
1692 /* XXXRW: Not clear ESRCH is the right error during proc execve(). */
1693 if (p->p_flag & P_WEXIT || p->p_flag & P_INEXEC) {
1694 PROC_UNLOCK(p);
1695 return (ESRCH);
1696 }
1697 if ((error = p_candebug(curthread, p))) {
1698 PROC_UNLOCK(p);
1699 return (error);
1700 }
1701 _PHOLD(p);
1702 PROC_UNLOCK(p);
1703
1704 kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK);
1705 st = stack_create();
1706
1707 lwpidarray = NULL;
1708 numthreads = 0;
1709 PROC_LOCK(p);
1710repeat:
1711 if (numthreads < p->p_numthreads) {
1712 if (lwpidarray != NULL) {
1713 free(lwpidarray, M_TEMP);
1714 lwpidarray = NULL;
1715 }
1716 numthreads = p->p_numthreads;
1717 PROC_UNLOCK(p);
1718 lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP,
1719 M_WAITOK | M_ZERO);
1720 PROC_LOCK(p);
1721 goto repeat;
1722 }
1723 i = 0;
1724
1725 /*
1726 * XXXRW: During the below loop, execve(2) and countless other sorts
1727 * of changes could have taken place. Should we check to see if the
1728 * vmspace has been replaced, or the like, in order to prevent
1729 * giving a snapshot that spans, say, execve(2), with some threads
1730 * before and some after? Among other things, the credentials could
1731 * have changed, in which case the right to extract debug info might
1732 * no longer be assured.
1733 */
1734 FOREACH_THREAD_IN_PROC(p, td) {
1735 KASSERT(i < numthreads,
1736 ("sysctl_kern_proc_kstack: numthreads"));
1737 lwpidarray[i] = td->td_tid;
1738 i++;
1739 }
1740 numthreads = i;
1741 for (i = 0; i < numthreads; i++) {
1742 td = thread_find(p, lwpidarray[i]);
1743 if (td == NULL) {
1744 continue;
1745 }
1746 bzero(kkstp, sizeof(*kkstp));
1747 (void)sbuf_new(&sb, kkstp->kkst_trace,
1748 sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN);
1749 thread_lock(td);
1750 kkstp->kkst_tid = td->td_tid;
1751 if (TD_IS_SWAPPED(td))
1752 kkstp->kkst_state = KKST_STATE_SWAPPED;
1753 else if (TD_IS_RUNNING(td))
1754 kkstp->kkst_state = KKST_STATE_RUNNING;
1755 else {
1756 kkstp->kkst_state = KKST_STATE_STACKOK;
1757 stack_save_td(st, td);
1758 }
1759 thread_unlock(td);
1760 PROC_UNLOCK(p);
1761 stack_sbuf_print(&sb, st);
1762 sbuf_finish(&sb);
1763 sbuf_delete(&sb);
1764 error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp));
1765 PROC_LOCK(p);
1766 if (error)
1767 break;
1768 }
1769 _PRELE(p);
1770 PROC_UNLOCK(p);
1771 if (lwpidarray != NULL)
1772 free(lwpidarray, M_TEMP);
1773 stack_destroy(st);
1774 free(kkstp, M_TEMP);
1775 return (error);
1776}
1777#endif
1778
1779SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table");
1780
1781SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT,
1782 0, 0, sysctl_kern_proc, "S,proc", "Return entire process table");
1783
1784static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD,
1785 sysctl_kern_proc, "Process table");
1786
1787static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD,
1788 sysctl_kern_proc, "Process table");
1789
1790static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD,
1791 sysctl_kern_proc, "Process table");
1792
1793static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD,
1794 sysctl_kern_proc, "Process table");
1795
1796static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD,
1797 sysctl_kern_proc, "Process table");
1798
1799static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD,
1800 sysctl_kern_proc, "Process table");
1801
1802static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD,
1803 sysctl_kern_proc, "Process table");
1804
1805static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD,
1806 sysctl_kern_proc, "Process table");
1807
1808static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD,
1809 sysctl_kern_proc, "Return process table, no threads");
1810
1811static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args,
1812 CTLFLAG_RW | CTLFLAG_ANYBODY,
1813 sysctl_kern_proc_args, "Process argument list");
1814
1815static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD,
1816 sysctl_kern_proc_pathname, "Process executable path");
1817
1818static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD,
1819 sysctl_kern_proc_sv_name, "Process syscall vector name (ABI type)");
1820
1821static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td,
1822 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1823
1824static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td,
1825 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1826
1827static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td,
1828 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1829
1830static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD),
1831 sid_td, CTLFLAG_RD, sysctl_kern_proc, "Process table");
1832
1833static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td,
1834 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1835
1836static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td,
1837 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1838
1839static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td,
1840 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1841
1842static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td,
1843 CTLFLAG_RD, sysctl_kern_proc, "Process table");
1844
1845static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td,
1846 CTLFLAG_RD, sysctl_kern_proc, "Return process table, no threads");
1847
|