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