FreeBSD kernel kern code
kern_proc.c
Go to the documentation of this file.
1 /*-
2  * Copyright (c) 1982, 1986, 1989, 1991, 1993
3  * The Regents of the University of California. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 4. Neither the name of the University nor the names of its contributors
14  * may be used to endorse or promote products derived from this software
15  * without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
30  */
31 
32 #include <sys/cdefs.h>
33 __FBSDID("$BSDSUniX$");
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/elf.h>
45 #include <sys/exec.h>
46 #include <sys/kernel.h>
47 #include <sys/limits.h>
48 #include <sys/lock.h>
49 #include <sys/loginclass.h>
50 #include <sys/malloc.h>
51 #include <sys/mman.h>
52 #include <sys/mount.h>
53 #include <sys/mutex.h>
54 #include <sys/proc.h>
55 #include <sys/ptrace.h>
56 #include <sys/refcount.h>
57 #include <sys/resourcevar.h>
58 #include <sys/sbuf.h>
59 #include <sys/sysent.h>
60 #include <sys/sched.h>
61 #include <sys/smp.h>
62 #include <sys/stack.h>
63 #include <sys/stat.h>
64 #include <sys/sysctl.h>
65 #include <sys/filedesc.h>
66 #include <sys/tty.h>
67 #include <sys/signalvar.h>
68 #include <sys/sdt.h>
69 #include <sys/sx.h>
70 #include <sys/user.h>
71 #include <sys/jail.h>
72 #include <sys/vnode.h>
73 #include <sys/eventhandler.h>
74 
75 #ifdef DDB
76 #include <ddb/ddb.h>
77 #endif
78 
79 #include <vm/vm.h>
80 #include <vm/vm_param.h>
81 #include <vm/vm_extern.h>
82 #include <vm/pmap.h>
83 #include <vm/vm_map.h>
84 #include <vm/vm_object.h>
85 #include <vm/vm_page.h>
86 #include <vm/uma.h>
87 
88 #ifdef COMPAT_32BIT
89 #include <compat/compat32bit/compat32bit.h>
90 #include <compat/compat32bit/compat32bit_util.h>
91 #endif
92 
93 SDT_PROVIDER_DEFINE(proc);
94 SDT_PROBE_DEFINE4(proc, kernel, ctor, entry, "struct proc *", "int",
95  "void *", "int");
96 SDT_PROBE_DEFINE4(proc, kernel, ctor, return, "struct proc *", "int",
97  "void *", "int");
98 SDT_PROBE_DEFINE4(proc, kernel, dtor, entry, "struct proc *", "int",
99  "void *", "struct thread *");
100 SDT_PROBE_DEFINE3(proc, kernel, dtor, return, "struct proc *", "int",
101  "void *");
102 SDT_PROBE_DEFINE3(proc, kernel, init, entry, "struct proc *", "int",
103  "int");
104 SDT_PROBE_DEFINE3(proc, kernel, init, return, "struct proc *", "int",
105  "int");
106 
107 MALLOC_DEFINE(M_PGRP, "pgrp", "process group header");
108 MALLOC_DEFINE(M_SESSION, "session", "session header");
109 static MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
110 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
111 
112 static void doenterpgrp(struct proc *, struct pgrp *);
113 static void orphanpg(struct pgrp *pg);
114 static void fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp);
115 static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp);
116 static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp,
117  int preferthread);
118 static void pgadjustjobc(struct pgrp *pgrp, int entering);
119 static void pgdelete(struct pgrp *);
120 static int proc_ctor(void *mem, int size, void *arg, int flags);
121 static void proc_dtor(void *mem, int size, void *arg);
122 static int proc_init(void *mem, int size, int flags);
123 static void proc_fini(void *mem, int size);
124 static void pargs_free(struct pargs *pa);
125 static struct proc *zpfind_locked(pid_t pid);
126 
127 /*
128  * Other process lists
129  */
130 struct pidhashhead *pidhashtbl;
131 u_long pidhash;
132 struct pgrphashhead *pgrphashtbl;
133 u_long pgrphash;
134 struct proclist allproc;
135 struct proclist zombproc;
136 struct sx allproc_lock;
137 struct sx proctree_lock;
138 struct mtx ppeers_lock;
139 uma_zone_t proc_zone;
140 
141 int kstack_pages = KSTACK_PAGES;
142 SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD, &kstack_pages, 0,
143  "Kernel stack size in pages");
144 static int vmmap_skip_res_cnt = 0;
145 SYSCTL_INT(_kern, OID_AUTO, proc_vmmap_skip_resident_count, CTLFLAG_RW,
146  &vmmap_skip_res_cnt, 0,
147  "Skip calculation of the pages resident count in kern.proc.vmmap");
148 
149 CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
150 #ifdef COMPAT_32BIT
151 CTASSERT(sizeof(struct kinfo_proc32) == KINFO_PROC32_SIZE);
152 #endif
153 
154 /*
155  * Initialize global process hashing structures.
156  */
157 void
158 procinit()
159 {
160 
161  sx_init(&allproc_lock, "allproc");
162  sx_init(&proctree_lock, "proctree");
163  mtx_init(&ppeers_lock, "p_peers", NULL, MTX_DEF);
164  LIST_INIT(&allproc);
165  LIST_INIT(&zombproc);
166  pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
167  pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
168  proc_zone = uma_zcreate("PROC", sched_sizeof_proc(),
169  proc_ctor, proc_dtor, proc_init, proc_fini,
170  UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
171  uihashinit();
172 }
173 
174 /*
175  * Prepare a proc for use.
176  */
177 static int
178 proc_ctor(void *mem, int size, void *arg, int flags)
179 {
180  struct proc *p;
181 
182  p = (struct proc *)mem;
183  SDT_PROBE4(proc, kernel, ctor , entry, p, size, arg, flags);
184  EVENTHANDLER_INVOKE(process_ctor, p);
185  SDT_PROBE4(proc, kernel, ctor , return, p, size, arg, flags);
186  return (0);
187 }
188 
189 /*
190  * Reclaim a proc after use.
191  */
192 static void
193 proc_dtor(void *mem, int size, void *arg)
194 {
195  struct proc *p;
196  struct thread *td;
197 
198  /* INVARIANTS checks go here */
199  p = (struct proc *)mem;
200  td = FIRST_THREAD_IN_PROC(p);
201  SDT_PROBE4(proc, kernel, dtor, entry, p, size, arg, td);
202  if (td != NULL) {
203 #ifdef INVARIANTS
204  KASSERT((p->p_numthreads == 1),
205  ("bad number of threads in exiting process"));
206  KASSERT(STAILQ_EMPTY(&p->p_ktr), ("proc_dtor: non-empty p_ktr"));
207 #endif
208  /* Free all OSD associated to this thread. */
209  osd_thread_exit(td);
210  }
211  EVENTHANDLER_INVOKE(process_dtor, p);
212  if (p->p_ksi != NULL)
213  KASSERT(! KSI_ONQ(p->p_ksi), ("SIGCHLD queue"));
214  SDT_PROBE3(proc, kernel, dtor, return, p, size, arg);
215 }
216 
217 /*
218  * Initialize type-stable parts of a proc (when newly created).
219  */
220 static int
221 proc_init(void *mem, int size, int flags)
222 {
223  struct proc *p;
224 
225  p = (struct proc *)mem;
226  SDT_PROBE3(proc, kernel, init, entry, p, size, flags);
227  p->p_sched = (struct p_sched *)&p[1];
228  bzero(&p->p_mtx, sizeof(struct mtx));
229  mtx_init(&p->p_mtx, "process lock", NULL, MTX_DEF | MTX_DUPOK);
230  mtx_init(&p->p_slock, "process slock", NULL, MTX_SPIN | MTX_RECURSE);
231  cv_init(&p->p_pwait, "ppwait");
232  cv_init(&p->p_dbgwait, "dbgwait");
233  TAILQ_INIT(&p->p_threads); /* all threads in proc */
234  EVENTHANDLER_INVOKE(process_init, p);
235  p->p_stats = pstats_alloc();
236  SDT_PROBE3(proc, kernel, init, return, p, size, flags);
237  return (0);
238 }
239 
240 /*
241  * UMA should ensure that this function is never called.
242  * Freeing a proc structure would violate type stability.
243  */
244 static void
245 proc_fini(void *mem, int size)
246 {
247 #ifdef notnow
248  struct proc *p;
249 
250  p = (struct proc *)mem;
251  EVENTHANDLER_INVOKE(process_fini, p);
252  pstats_free(p->p_stats);
253  thread_free(FIRST_THREAD_IN_PROC(p));
254  mtx_destroy(&p->p_mtx);
255  if (p->p_ksi != NULL)
256  ksiginfo_free(p->p_ksi);
257 #else
258  panic("proc reclaimed");
259 #endif
260 }
261 
262 /*
263  * Is p an inferior of the current process?
264  */
265 int
266 inferior(struct proc *p)
267 {
268 
269  sx_assert(&proctree_lock, SX_LOCKED);
270  PROC_LOCK_ASSERT(p, MA_OWNED);
271  for (; p != curproc; p = proc_realparent(p)) {
272  if (p->p_pid == 0)
273  return (0);
274  }
275  return (1);
276 }
277 
278 struct proc *
279 pfind_locked(pid_t pid)
280 {
281  struct proc *p;
282 
283  sx_assert(&allproc_lock, SX_LOCKED);
284  LIST_FOREACH(p, PIDHASH(pid), p_hash) {
285  if (p->p_pid == pid) {
286  PROC_LOCK(p);
287  if (p->p_state == PRS_NEW) {
288  PROC_UNLOCK(p);
289  p = NULL;
290  }
291  break;
292  }
293  }
294  return (p);
295 }
296 
297 /*
298  * Locate a process by number; return only "live" processes -- i.e., neither
299  * zombies nor newly born but incompletely initialized processes. By not
300  * returning processes in the PRS_NEW state, we allow callers to avoid
301  * testing for that condition to avoid dereferencing p_ucred, et al.
302  */
303 struct proc *
304 pfind(pid_t pid)
305 {
306  struct proc *p;
307 
308  sx_slock(&allproc_lock);
309  p = pfind_locked(pid);
310  sx_sunlock(&allproc_lock);
311  return (p);
312 }
313 
314 static struct proc *
315 pfind_tid_locked(pid_t tid)
316 {
317  struct proc *p;
318  struct thread *td;
319 
320  sx_assert(&allproc_lock, SX_LOCKED);
321  FOREACH_PROC_IN_SYSTEM(p) {
322  PROC_LOCK(p);
323  if (p->p_state == PRS_NEW) {
324  PROC_UNLOCK(p);
325  continue;
326  }
327  FOREACH_THREAD_IN_PROC(p, td) {
328  if (td->td_tid == tid)
329  goto found;
330  }
331  PROC_UNLOCK(p);
332  }
333 found:
334  return (p);
335 }
336 
337 /*
338  * Locate a process group by number.
339  * The caller must hold proctree_lock.
340  */
341 struct pgrp *
342 pgfind(pgid)
343  register pid_t pgid;
344 {
345  register struct pgrp *pgrp;
346 
347  sx_assert(&proctree_lock, SX_LOCKED);
348 
349  LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash) {
350  if (pgrp->pg_id == pgid) {
351  PGRP_LOCK(pgrp);
352  return (pgrp);
353  }
354  }
355  return (NULL);
356 }
357 
358 /*
359  * Locate process and do additional manipulations, depending on flags.
360  */
361 int
362 pget(pid_t pid, int flags, struct proc **pp)
363 {
364  struct proc *p;
365  int error;
366 
367  sx_slock(&allproc_lock);
368  if (pid <= PID_MAX) {
369  p = pfind_locked(pid);
370  if (p == NULL && (flags & PGET_NOTWEXIT) == 0)
371  p = zpfind_locked(pid);
372  } else if ((flags & PGET_NOTID) == 0) {
373  p = pfind_tid_locked(pid);
374  } else {
375  p = NULL;
376  }
377  sx_sunlock(&allproc_lock);
378  if (p == NULL)
379  return (ESRCH);
380  if ((flags & PGET_CANSEE) != 0) {
381  error = p_cansee(curthread, p);
382  if (error != 0)
383  goto errout;
384  }
385  if ((flags & PGET_CANDEBUG) != 0) {
386  error = p_candebug(curthread, p);
387  if (error != 0)
388  goto errout;
389  }
390  if ((flags & PGET_ISCURRENT) != 0 && curproc != p) {
391  error = EPERM;
392  goto errout;
393  }
394  if ((flags & PGET_NOTWEXIT) != 0 && (p->p_flag & P_WEXIT) != 0) {
395  error = ESRCH;
396  goto errout;
397  }
398  if ((flags & PGET_NOTINEXEC) != 0 && (p->p_flag & P_INEXEC) != 0) {
399  /*
400  * XXXRW: Not clear ESRCH is the right error during proc
401  * execve().
402  */
403  error = ESRCH;
404  goto errout;
405  }
406  if ((flags & PGET_HOLD) != 0) {
407  _PHOLD(p);
408  PROC_UNLOCK(p);
409  }
410  *pp = p;
411  return (0);
412 errout:
413  PROC_UNLOCK(p);
414  return (error);
415 }
416 
417 /*
418  * Create a new process group.
419  * pgid must be equal to the pid of p.
420  * Begin a new session if required.
421  */
422 int
423 enterpgrp(p, pgid, pgrp, sess)
424  register struct proc *p;
425  pid_t pgid;
426  struct pgrp *pgrp;
427  struct session *sess;
428 {
429 
430  sx_assert(&proctree_lock, SX_XLOCKED);
431 
432  KASSERT(pgrp != NULL, ("enterpgrp: pgrp == NULL"));
433  KASSERT(p->p_pid == pgid,
434  ("enterpgrp: new pgrp and pid != pgid"));
435  KASSERT(pgfind(pgid) == NULL,
436  ("enterpgrp: pgrp with pgid exists"));
437  KASSERT(!SESS_LEADER(p),
438  ("enterpgrp: session leader attempted setpgrp"));
439 
440  mtx_init(&pgrp->pg_mtx, "process group", NULL, MTX_DEF | MTX_DUPOK);
441 
442  if (sess != NULL) {
443  /*
444  * new session
445  */
446  mtx_init(&sess->s_mtx, "session", NULL, MTX_DEF);
447  PROC_LOCK(p);
448  p->p_flag &= ~P_CONTROLT;
449  PROC_UNLOCK(p);
450  PGRP_LOCK(pgrp);
451  sess->s_leader = p;
452  sess->s_sid = p->p_pid;
453  refcount_init(&sess->s_count, 1);
454  sess->s_ttyvp = NULL;
455  sess->s_ttydp = NULL;
456  sess->s_ttyp = NULL;
457  bcopy(p->p_session->s_login, sess->s_login,
458  sizeof(sess->s_login));
459  pgrp->pg_session = sess;
460  KASSERT(p == curproc,
461  ("enterpgrp: mksession and p != curproc"));
462  } else {
463  pgrp->pg_session = p->p_session;
464  sess_hold(pgrp->pg_session);
465  PGRP_LOCK(pgrp);
466  }
467  pgrp->pg_id = pgid;
468  LIST_INIT(&pgrp->pg_members);
469 
470  /*
471  * As we have an exclusive lock of proctree_lock,
472  * this should not deadlock.
473  */
474  LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
475  pgrp->pg_jobc = 0;
476  SLIST_INIT(&pgrp->pg_sigiolst);
477  PGRP_UNLOCK(pgrp);
478 
479  doenterpgrp(p, pgrp);
480 
481  return (0);
482 }
483 
484 /*
485  * Move p to an existing process group
486  */
487 int
488 enterthispgrp(p, pgrp)
489  register struct proc *p;
490  struct pgrp *pgrp;
491 {
492 
493  sx_assert(&proctree_lock, SX_XLOCKED);
494  PROC_LOCK_ASSERT(p, MA_NOTOWNED);
495  PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
496  PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
497  SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
498  KASSERT(pgrp->pg_session == p->p_session,
499  ("%s: pgrp's session %p, p->p_session %p.\n",
500  __func__,
501  pgrp->pg_session,
502  p->p_session));
503  KASSERT(pgrp != p->p_pgrp,
504  ("%s: p belongs to pgrp.", __func__));
505 
506  doenterpgrp(p, pgrp);
507 
508  return (0);
509 }
510 
511 /*
512  * Move p to a process group
513  */
514 static void
515 doenterpgrp(p, pgrp)
516  struct proc *p;
517  struct pgrp *pgrp;
518 {
519  struct pgrp *savepgrp;
520 
521  sx_assert(&proctree_lock, SX_XLOCKED);
522  PROC_LOCK_ASSERT(p, MA_NOTOWNED);
523  PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
524  PGRP_LOCK_ASSERT(p->p_pgrp, MA_NOTOWNED);
525  SESS_LOCK_ASSERT(p->p_session, MA_NOTOWNED);
526 
527  savepgrp = p->p_pgrp;
528 
529  /*
530  * Adjust eligibility of affected pgrps to participate in job control.
531  * Increment eligibility counts before decrementing, otherwise we
532  * could reach 0 spuriously during the first call.
533  */
534  fixjobc(p, pgrp, 1);
535  fixjobc(p, p->p_pgrp, 0);
536 
537  PGRP_LOCK(pgrp);
538  PGRP_LOCK(savepgrp);
539  PROC_LOCK(p);
540  LIST_REMOVE(p, p_pglist);
541  p->p_pgrp = pgrp;
542  PROC_UNLOCK(p);
543  LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
544  PGRP_UNLOCK(savepgrp);
545  PGRP_UNLOCK(pgrp);
546  if (LIST_EMPTY(&savepgrp->pg_members))
547  pgdelete(savepgrp);
548 }
549 
550 /*
551  * remove process from process group
552  */
553 int
554 leavepgrp(p)
555  register struct proc *p;
556 {
557  struct pgrp *savepgrp;
558 
559  sx_assert(&proctree_lock, SX_XLOCKED);
560  savepgrp = p->p_pgrp;
561  PGRP_LOCK(savepgrp);
562  PROC_LOCK(p);
563  LIST_REMOVE(p, p_pglist);
564  p->p_pgrp = NULL;
565  PROC_UNLOCK(p);
566  PGRP_UNLOCK(savepgrp);
567  if (LIST_EMPTY(&savepgrp->pg_members))
568  pgdelete(savepgrp);
569  return (0);
570 }
571 
572 /*
573  * delete a process group
574  */
575 static void
576 pgdelete(pgrp)
577  register struct pgrp *pgrp;
578 {
579  struct session *savesess;
580  struct tty *tp;
581 
582  sx_assert(&proctree_lock, SX_XLOCKED);
583  PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
584  SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
585 
586  /*
587  * Reset any sigio structures pointing to us as a result of
588  * F_SETOWN with our pgid.
589  */
590  funsetownlst(&pgrp->pg_sigiolst);
591 
592  PGRP_LOCK(pgrp);
593  tp = pgrp->pg_session->s_ttyp;
594  LIST_REMOVE(pgrp, pg_hash);
595  savesess = pgrp->pg_session;
596  PGRP_UNLOCK(pgrp);
597 
598  /* Remove the reference to the pgrp before deallocating it. */
599  if (tp != NULL) {
600  tty_lock(tp);
601  tty_rel_pgrp(tp, pgrp);
602  }
603 
604  mtx_destroy(&pgrp->pg_mtx);
605  free(pgrp, M_PGRP);
606  sess_release(savesess);
607 }
608 
609 static void
610 pgadjustjobc(pgrp, entering)
611  struct pgrp *pgrp;
612  int entering;
613 {
614 
615  PGRP_LOCK(pgrp);
616  if (entering)
617  pgrp->pg_jobc++;
618  else {
619  --pgrp->pg_jobc;
620  if (pgrp->pg_jobc == 0)
621  orphanpg(pgrp);
622  }
623  PGRP_UNLOCK(pgrp);
624 }
625 
626 /*
627  * Adjust pgrp jobc counters when specified process changes process group.
628  * We count the number of processes in each process group that "qualify"
629  * the group for terminal job control (those with a parent in a different
630  * process group of the same session). If that count reaches zero, the
631  * process group becomes orphaned. Check both the specified process'
632  * process group and that of its children.
633  * entering == 0 => p is leaving specified group.
634  * entering == 1 => p is entering specified group.
635  */
636 void
637 fixjobc(p, pgrp, entering)
638  register struct proc *p;
639  register struct pgrp *pgrp;
640  int entering;
641 {
642  register struct pgrp *hispgrp;
643  register struct session *mysession;
644 
645  sx_assert(&proctree_lock, SX_LOCKED);
646  PROC_LOCK_ASSERT(p, MA_NOTOWNED);
647  PGRP_LOCK_ASSERT(pgrp, MA_NOTOWNED);
648  SESS_LOCK_ASSERT(pgrp->pg_session, MA_NOTOWNED);
649 
650  /*
651  * Check p's parent to see whether p qualifies its own process
652  * group; if so, adjust count for p's process group.
653  */
654  mysession = pgrp->pg_session;
655  if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
656  hispgrp->pg_session == mysession)
657  pgadjustjobc(pgrp, entering);
658 
659  /*
660  * Check this process' children to see whether they qualify
661  * their process groups; if so, adjust counts for children's
662  * process groups.
663  */
664  LIST_FOREACH(p, &p->p_children, p_sibling) {
665  hispgrp = p->p_pgrp;
666  if (hispgrp == pgrp ||
667  hispgrp->pg_session != mysession)
668  continue;
669  PROC_LOCK(p);
670  if (p->p_state == PRS_ZOMBIE) {
671  PROC_UNLOCK(p);
672  continue;
673  }
674  PROC_UNLOCK(p);
675  pgadjustjobc(hispgrp, entering);
676  }
677 }
678 
679 /*
680  * A process group has become orphaned;
681  * if there are any stopped processes in the group,
682  * hang-up all process in that group.
683  */
684 static void
685 orphanpg(pg)
686  struct pgrp *pg;
687 {
688  register struct proc *p;
689 
690  PGRP_LOCK_ASSERT(pg, MA_OWNED);
691 
692  LIST_FOREACH(p, &pg->pg_members, p_pglist) {
693  PROC_LOCK(p);
694  if (P_SHOULDSTOP(p) == P_STOPPED_SIG) {
695  PROC_UNLOCK(p);
696  LIST_FOREACH(p, &pg->pg_members, p_pglist) {
697  PROC_LOCK(p);
698  kern_psignal(p, SIGHUP);
699  kern_psignal(p, SIGCONT);
700  PROC_UNLOCK(p);
701  }
702  return;
703  }
704  PROC_UNLOCK(p);
705  }
706 }
707 
708 void
709 sess_hold(struct session *s)
710 {
711 
712  refcount_acquire(&s->s_count);
713 }
714 
715 void
716 sess_release(struct session *s)
717 {
718 
719  if (refcount_release(&s->s_count)) {
720  if (s->s_ttyp != NULL) {
721  tty_lock(s->s_ttyp);
722  tty_rel_sess(s->s_ttyp, s);
723  }
724  mtx_destroy(&s->s_mtx);
725  free(s, M_SESSION);
726  }
727 }
728 
729 #include "opt_ddb.h"
730 #ifdef DDB
731 #include <ddb/ddb.h>
732 
733 DB_SHOW_COMMAND(pgrpdump, pgrpdump)
734 {
735  register struct pgrp *pgrp;
736  register struct proc *p;
737  register int i;
738 
739  for (i = 0; i <= pgrphash; i++) {
740  if (!LIST_EMPTY(&pgrphashtbl[i])) {
741  printf("\tindx %d\n", i);
742  LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
743  printf(
744  "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
745  (void *)pgrp, (long)pgrp->pg_id,
746  (void *)pgrp->pg_session,
747  pgrp->pg_session->s_count,
748  (void *)LIST_FIRST(&pgrp->pg_members));
749  LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
750  printf("\t\tpid %ld addr %p pgrp %p\n",
751  (long)p->p_pid, (void *)p,
752  (void *)p->p_pgrp);
753  }
754  }
755  }
756  }
757 }
758 #endif /* DDB */
759 
760 /*
761  * Calculate the kinfo_proc members which contain process-wide
762  * informations.
763  * Must be called with the target process locked.
764  */
765 static void
766 fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp)
767 {
768  struct thread *td;
769 
770  PROC_LOCK_ASSERT(p, MA_OWNED);
771 
772  kp->ki_estcpu = 0;
773  kp->ki_pctcpu = 0;
774  FOREACH_THREAD_IN_PROC(p, td) {
775  thread_lock(td);
776  kp->ki_pctcpu += sched_pctcpu(td);
777  kp->ki_estcpu += td->td_estcpu;
778  thread_unlock(td);
779  }
780 }
781 
782 /*
783  * Clear kinfo_proc and fill in any information that is common
784  * to all threads in the process.
785  * Must be called with the target process locked.
786  */
787 static void
788 fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp)
789 {
790  struct thread *td0;
791  struct tty *tp;
792  struct session *sp;
793  struct ucred *cred;
794  struct sigacts *ps;
795 
796  PROC_LOCK_ASSERT(p, MA_OWNED);
797  bzero(kp, sizeof(*kp));
798 
799  kp->ki_structsize = sizeof(*kp);
800  kp->ki_paddr = p;
801  kp->ki_addr =/* p->p_addr; */0; /* XXX */
802  kp->ki_args = p->p_args;
803  kp->ki_textvp = p->p_textvp;
804 #ifdef KTRACE
805  kp->ki_tracep = p->p_tracevp;
806  kp->ki_traceflag = p->p_traceflag;
807 #endif
808  kp->ki_fd = p->p_fd;
809  kp->ki_vmspace = p->p_vmspace;
810  kp->ki_flag = p->p_flag;
811  kp->ki_flag2 = p->p_flag2;
812  cred = p->p_ucred;
813  if (cred) {
814  kp->ki_uid = cred->cr_uid;
815  kp->ki_ruid = cred->cr_ruid;
816  kp->ki_svuid = cred->cr_svuid;
817  kp->ki_cr_flags = 0;
818  if (cred->cr_flags & CRED_FLAG_CAPMODE)
819  kp->ki_cr_flags |= KI_CRF_CAPABILITY_MODE;
820  /* XXX bde doesn't like KI_NGROUPS */
821  if (cred->cr_ngroups > KI_NGROUPS) {
822  kp->ki_ngroups = KI_NGROUPS;
823  kp->ki_cr_flags |= KI_CRF_GRP_OVERFLOW;
824  } else
825  kp->ki_ngroups = cred->cr_ngroups;
826  bcopy(cred->cr_groups, kp->ki_groups,
827  kp->ki_ngroups * sizeof(gid_t));
828  kp->ki_rgid = cred->cr_rgid;
829  kp->ki_svgid = cred->cr_svgid;
830  /* If jailed(cred), emulate the old P_JAILED flag. */
831  if (jailed(cred)) {
832  kp->ki_flag |= P_JAILED;
833  /* If inside the jail, use 0 as a jail ID. */
834  if (cred->cr_prison != curthread->td_ucred->cr_prison)
835  kp->ki_jid = cred->cr_prison->pr_id;
836  }
837  strlcpy(kp->ki_loginclass, cred->cr_loginclass->lc_name,
838  sizeof(kp->ki_loginclass));
839  }
840  ps = p->p_sigacts;
841  if (ps) {
842  mtx_lock(&ps->ps_mtx);
843  kp->ki_sigignore = ps->ps_sigignore;
844  kp->ki_sigcatch = ps->ps_sigcatch;
845  mtx_unlock(&ps->ps_mtx);
846  }
847  if (p->p_state != PRS_NEW &&
848  p->p_state != PRS_ZOMBIE &&
849  p->p_vmspace != NULL) {
850  struct vmspace *vm = p->p_vmspace;
851 
852  kp->ki_size = vm->vm_map.size;
853  kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/
854  FOREACH_THREAD_IN_PROC(p, td0) {
855  if (!TD_IS_SWAPPED(td0))
856  kp->ki_rssize += td0->td_kstack_pages;
857  }
858  kp->ki_swrss = vm->vm_swrss;
859  kp->ki_tsize = vm->vm_tsize;
860  kp->ki_dsize = vm->vm_dsize;
861  kp->ki_ssize = vm->vm_ssize;
862  } else if (p->p_state == PRS_ZOMBIE)
863  kp->ki_stat = SZOMB;
864  if (kp->ki_flag & P_INMEM)
865  kp->ki_sflag = PS_INMEM;
866  else
867  kp->ki_sflag = 0;
868  /* Calculate legacy swtime as seconds since 'swtick'. */
869  kp->ki_swtime = (ticks - p->p_swtick) / hz;
870  kp->ki_pid = p->p_pid;
871  kp->ki_nice = p->p_nice;
872  kp->ki_fibnum = p->p_fibnum;
873  kp->ki_start = p->p_stats->p_start;
874  timevaladd(&kp->ki_start, &boottime);
875  PROC_SLOCK(p);
876  rufetch(p, &kp->ki_rusage);
877  kp->ki_runtime = cputick2usec(p->p_rux.rux_runtime);
878  calcru(p, &kp->ki_rusage.ru_utime, &kp->ki_rusage.ru_stime);
879  PROC_SUNLOCK(p);
880  calccru(p, &kp->ki_childutime, &kp->ki_childstime);
881  /* Some callers want child times in a single value. */
882  kp->ki_childtime = kp->ki_childstime;
883  timevaladd(&kp->ki_childtime, &kp->ki_childutime);
884 
885  FOREACH_THREAD_IN_PROC(p, td0)
886  kp->ki_cow += td0->td_cow;
887 
888  tp = NULL;
889  if (p->p_pgrp) {
890  kp->ki_pgid = p->p_pgrp->pg_id;
891  kp->ki_jobc = p->p_pgrp->pg_jobc;
892  sp = p->p_pgrp->pg_session;
893 
894  if (sp != NULL) {
895  kp->ki_sid = sp->s_sid;
896  SESS_LOCK(sp);
897  strlcpy(kp->ki_login, sp->s_login,
898  sizeof(kp->ki_login));
899  if (sp->s_ttyvp)
900  kp->ki_kiflag |= KI_CTTY;
901  if (SESS_LEADER(p))
902  kp->ki_kiflag |= KI_SLEADER;
903  /* XXX proctree_lock */
904  tp = sp->s_ttyp;
905  SESS_UNLOCK(sp);
906  }
907  }
908  if ((p->p_flag & P_CONTROLT) && tp != NULL) {
909  kp->ki_tdev = tty_udev(tp);
910  kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
911  if (tp->t_session)
912  kp->ki_tsid = tp->t_session->s_sid;
913  } else
914  kp->ki_tdev = NODEV;
915  if (p->p_comm[0] != '\0')
916  strlcpy(kp->ki_comm, p->p_comm, sizeof(kp->ki_comm));
917  if (p->p_sysent && p->p_sysent->sv_name != NULL &&
918  p->p_sysent->sv_name[0] != '\0')
919  strlcpy(kp->ki_emul, p->p_sysent->sv_name, sizeof(kp->ki_emul));
920  kp->ki_siglist = p->p_siglist;
921  kp->ki_xstat = p->p_xstat;
922  kp->ki_acflag = p->p_acflag;
923  kp->ki_lock = p->p_lock;
924  if (p->p_pptr)
925  kp->ki_ppid = p->p_pptr->p_pid;
926 }
927 
928 /*
929  * Fill in information that is thread specific. Must be called with
930  * target process locked. If 'preferthread' is set, overwrite certain
931  * process-related fields that are maintained for both threads and
932  * processes.
933  */
934 static void
935 fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread)
936 {
937  struct proc *p;
938 
939  p = td->td_proc;
940  kp->ki_tdaddr = td;
941  PROC_LOCK_ASSERT(p, MA_OWNED);
942 
943  if (preferthread)
944  PROC_SLOCK(p);
945  thread_lock(td);
946  if (td->td_wmesg != NULL)
947  strlcpy(kp->ki_wmesg, td->td_wmesg, sizeof(kp->ki_wmesg));
948  else
949  bzero(kp->ki_wmesg, sizeof(kp->ki_wmesg));
950  strlcpy(kp->ki_tdname, td->td_name, sizeof(kp->ki_tdname));
951  if (TD_ON_LOCK(td)) {
952  kp->ki_kiflag |= KI_LOCKBLOCK;
953  strlcpy(kp->ki_lockname, td->td_lockname,
954  sizeof(kp->ki_lockname));
955  } else {
956  kp->ki_kiflag &= ~KI_LOCKBLOCK;
957  bzero(kp->ki_lockname, sizeof(kp->ki_lockname));
958  }
959 
960  if (p->p_state == PRS_NORMAL) { /* approximate. */
961  if (TD_ON_RUNQ(td) ||
962  TD_CAN_RUN(td) ||
963  TD_IS_RUNNING(td)) {
964  kp->ki_stat = SRUN;
965  } else if (P_SHOULDSTOP(p)) {
966  kp->ki_stat = SSTOP;
967  } else if (TD_IS_SLEEPING(td)) {
968  kp->ki_stat = SSLEEP;
969  } else if (TD_ON_LOCK(td)) {
970  kp->ki_stat = SLOCK;
971  } else {
972  kp->ki_stat = SWAIT;
973  }
974  } else if (p->p_state == PRS_ZOMBIE) {
975  kp->ki_stat = SZOMB;
976  } else {
977  kp->ki_stat = SIDL;
978  }
979 
980  /* Things in the thread */
981  kp->ki_wchan = td->td_wchan;
982  kp->ki_pri.pri_level = td->td_priority;
983  kp->ki_pri.pri_native = td->td_base_pri;
984  kp->ki_lastcpu = td->td_lastcpu;
985  kp->ki_oncpu = td->td_oncpu;
986  kp->ki_tdflags = td->td_flags;
987  kp->ki_tid = td->td_tid;
988  kp->ki_numthreads = p->p_numthreads;
989  kp->ki_pcb = td->td_pcb;
990  kp->ki_kstack = (void *)td->td_kstack;
991  kp->ki_slptime = (ticks - td->td_slptick) / hz;
992  kp->ki_pri.pri_class = td->td_pri_class;
993  kp->ki_pri.pri_user = td->td_user_pri;
994 
995  if (preferthread) {
996  rufetchtd(td, &kp->ki_rusage);
997  kp->ki_runtime = cputick2usec(td->td_rux.rux_runtime);
998  kp->ki_pctcpu = sched_pctcpu(td);
999  kp->ki_estcpu = td->td_estcpu;
1000  kp->ki_cow = td->td_cow;
1001  }
1002 
1003  /* We can't get this anymore but ps etc never used it anyway. */
1004  kp->ki_rqindex = 0;
1005 
1006  if (preferthread)
1007  kp->ki_siglist = td->td_siglist;
1008  kp->ki_sigmask = td->td_sigmask;
1009  thread_unlock(td);
1010  if (preferthread)
1011  PROC_SUNLOCK(p);
1012 }
1013 
1014 /*
1015  * Fill in a kinfo_proc structure for the specified process.
1016  * Must be called with the target process locked.
1017  */
1018 void
1019 fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
1020 {
1021 
1022  MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
1023 
1024  fill_kinfo_proc_only(p, kp);
1025  fill_kinfo_thread(FIRST_THREAD_IN_PROC(p), kp, 0);
1026  fill_kinfo_aggregate(p, kp);
1027 }
1028 
1029 struct pstats *
1030 pstats_alloc(void)
1031 {
1032 
1033  return (malloc(sizeof(struct pstats), M_SUBPROC, M_ZERO|M_WAITOK));
1034 }
1035 
1036 /*
1037  * Copy parts of p_stats; zero the rest of p_stats (statistics).
1038  */
1039 void
1040 pstats_fork(struct pstats *src, struct pstats *dst)
1041 {
1042 
1043  bzero(&dst->pstat_startzero,
1044  __rangeof(struct pstats, pstat_startzero, pstat_endzero));
1045  bcopy(&src->pstat_startcopy, &dst->pstat_startcopy,
1046  __rangeof(struct pstats, pstat_startcopy, pstat_endcopy));
1047 }
1048 
1049 void
1050 pstats_free(struct pstats *ps)
1051 {
1052 
1053  free(ps, M_SUBPROC);
1054 }
1055 
1056 static struct proc *
1057 zpfind_locked(pid_t pid)
1058 {
1059  struct proc *p;
1060 
1061  sx_assert(&allproc_lock, SX_LOCKED);
1062  LIST_FOREACH(p, &zombproc, p_list) {
1063  if (p->p_pid == pid) {
1064  PROC_LOCK(p);
1065  break;
1066  }
1067  }
1068  return (p);
1069 }
1070 
1071 /*
1072  * Locate a zombie process by number
1073  */
1074 struct proc *
1075 zpfind(pid_t pid)
1076 {
1077  struct proc *p;
1078 
1079  sx_slock(&allproc_lock);
1080  p = zpfind_locked(pid);
1081  sx_sunlock(&allproc_lock);
1082  return (p);
1083 }
1084 
1085 #ifdef COMPAT_32BIT
1086 
1087 /*
1088  * This function is typically used to copy out the kernel address, so
1089  * it can be replaced by assignment of zero.
1090  */
1091 static inline uint32_t
1092 ptr32_trim(void *ptr)
1093 {
1094  uintptr_t uptr;
1095 
1096  uptr = (uintptr_t)ptr;
1097  return ((uptr > UINT_MAX) ? 0 : uptr);
1098 }
1099 
1100 #define PTRTRIM_CP(src,dst,fld) \
1101  do { (dst).fld = ptr32_trim((src).fld); } while (0)
1102 
1103 static void
1104 compat32bit_kinfo_proc_out(const struct kinfo_proc *ki, struct kinfo_proc32 *ki32)
1105 {
1106  int i;
1107 
1108  bzero(ki32, sizeof(struct kinfo_proc32));
1109  ki32->ki_structsize = sizeof(struct kinfo_proc32);
1110  CP(*ki, *ki32, ki_layout);
1111  PTRTRIM_CP(*ki, *ki32, ki_args);
1112  PTRTRIM_CP(*ki, *ki32, ki_paddr);
1113  PTRTRIM_CP(*ki, *ki32, ki_addr);
1114  PTRTRIM_CP(*ki, *ki32, ki_tracep);
1115  PTRTRIM_CP(*ki, *ki32, ki_textvp);
1116  PTRTRIM_CP(*ki, *ki32, ki_fd);
1117  PTRTRIM_CP(*ki, *ki32, ki_vmspace);
1118  PTRTRIM_CP(*ki, *ki32, ki_wchan);
1119  CP(*ki, *ki32, ki_pid);
1120  CP(*ki, *ki32, ki_ppid);
1121  CP(*ki, *ki32, ki_pgid);
1122  CP(*ki, *ki32, ki_tpgid);
1123  CP(*ki, *ki32, ki_sid);
1124  CP(*ki, *ki32, ki_tsid);
1125  CP(*ki, *ki32, ki_jobc);
1126  CP(*ki, *ki32, ki_tdev);
1127  CP(*ki, *ki32, ki_siglist);
1128  CP(*ki, *ki32, ki_sigmask);
1129  CP(*ki, *ki32, ki_sigignore);
1130  CP(*ki, *ki32, ki_sigcatch);
1131  CP(*ki, *ki32, ki_uid);
1132  CP(*ki, *ki32, ki_ruid);
1133  CP(*ki, *ki32, ki_svuid);
1134  CP(*ki, *ki32, ki_rgid);
1135  CP(*ki, *ki32, ki_svgid);
1136  CP(*ki, *ki32, ki_ngroups);
1137  for (i = 0; i < KI_NGROUPS; i++)
1138  CP(*ki, *ki32, ki_groups[i]);
1139  CP(*ki, *ki32, ki_size);
1140  CP(*ki, *ki32, ki_rssize);
1141  CP(*ki, *ki32, ki_swrss);
1142  CP(*ki, *ki32, ki_tsize);
1143  CP(*ki, *ki32, ki_dsize);
1144  CP(*ki, *ki32, ki_ssize);
1145  CP(*ki, *ki32, ki_xstat);
1146  CP(*ki, *ki32, ki_acflag);
1147  CP(*ki, *ki32, ki_pctcpu);
1148  CP(*ki, *ki32, ki_estcpu);
1149  CP(*ki, *ki32, ki_slptime);
1150  CP(*ki, *ki32, ki_swtime);
1151  CP(*ki, *ki32, ki_cow);
1152  CP(*ki, *ki32, ki_runtime);
1153  TV_CP(*ki, *ki32, ki_start);
1154  TV_CP(*ki, *ki32, ki_childtime);
1155  CP(*ki, *ki32, ki_flag);
1156  CP(*ki, *ki32, ki_kiflag);
1157  CP(*ki, *ki32, ki_traceflag);
1158  CP(*ki, *ki32, ki_stat);
1159  CP(*ki, *ki32, ki_nice);
1160  CP(*ki, *ki32, ki_lock);
1161  CP(*ki, *ki32, ki_rqindex);
1162  CP(*ki, *ki32, ki_oncpu);
1163  CP(*ki, *ki32, ki_lastcpu);
1164  bcopy(ki->ki_tdname, ki32->ki_tdname, TDNAMLEN + 1);
1165  bcopy(ki->ki_wmesg, ki32->ki_wmesg, WMESGLEN + 1);
1166  bcopy(ki->ki_login, ki32->ki_login, LOGNAMELEN + 1);
1167  bcopy(ki->ki_lockname, ki32->ki_lockname, LOCKNAMELEN + 1);
1168  bcopy(ki->ki_comm, ki32->ki_comm, COMMLEN + 1);
1169  bcopy(ki->ki_emul, ki32->ki_emul, KI_EMULNAMELEN + 1);
1170  bcopy(ki->ki_loginclass, ki32->ki_loginclass, LOGINCLASSLEN + 1);
1171  CP(*ki, *ki32, ki_flag2);
1172  CP(*ki, *ki32, ki_fibnum);
1173  CP(*ki, *ki32, ki_cr_flags);
1174  CP(*ki, *ki32, ki_jid);
1175  CP(*ki, *ki32, ki_numthreads);
1176  CP(*ki, *ki32, ki_tid);
1177  CP(*ki, *ki32, ki_pri);
1178  compat32bit_rusage_out(&ki->ki_rusage, &ki32->ki_rusage);
1179  compat32bit_rusage_out(&ki->ki_rusage_ch, &ki32->ki_rusage_ch);
1180  PTRTRIM_CP(*ki, *ki32, ki_pcb);
1181  PTRTRIM_CP(*ki, *ki32, ki_kstack);
1182  PTRTRIM_CP(*ki, *ki32, ki_udata);
1183  CP(*ki, *ki32, ki_sflag);
1184  CP(*ki, *ki32, ki_tdflags);
1185 }
1186 #endif
1187 
1188 int
1189 kern_proc_out(struct proc *p, struct sbuf *sb, int flags)
1190 {
1191  struct thread *td;
1192  struct kinfo_proc ki;
1193 #ifdef COMPAT_32BIT
1194  struct kinfo_proc32 ki32;
1195 #endif
1196  int error;
1197 
1198  PROC_LOCK_ASSERT(p, MA_OWNED);
1199  MPASS(FIRST_THREAD_IN_PROC(p) != NULL);
1200 
1201  error = 0;
1202  fill_kinfo_proc(p, &ki);
1203  if ((flags & KERN_PROC_NOTHREADS) != 0) {
1204 #ifdef COMPAT_32BIT
1205  if ((flags & KERN_PROC_MASK32) != 0) {
1206  compat32bit_kinfo_proc_out(&ki, &ki32);
1207  error = sbuf_bcat(sb, &ki32, sizeof(ki32));
1208  } else
1209 #endif
1210  error = sbuf_bcat(sb, &ki, sizeof(ki));
1211  } else {
1212  FOREACH_THREAD_IN_PROC(p, td) {
1213  fill_kinfo_thread(td, &ki, 1);
1214 #ifdef COMPAT_32BIT
1215  if ((flags & KERN_PROC_MASK32) != 0) {
1216  compat32bit_kinfo_proc_out(&ki, &ki32);
1217  error = sbuf_bcat(sb, &ki32, sizeof(ki32));
1218  } else
1219 #endif
1220  error = sbuf_bcat(sb, &ki, sizeof(ki));
1221  if (error)
1222  break;
1223  }
1224  }
1225  PROC_UNLOCK(p);
1226  return (error);
1227 }
1228 
1229 static int
1230 sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags,
1231  int doingzomb)
1232 {
1233  struct sbuf sb;
1234  struct kinfo_proc ki;
1235  struct proc *np;
1236  int error, error2;
1237  pid_t pid;
1238 
1239  pid = p->p_pid;
1240  sbuf_new_for_sysctl(&sb, (char *)&ki, sizeof(ki), req);
1241  error = kern_proc_out(p, &sb, flags);
1242  error2 = sbuf_finish(&sb);
1243  sbuf_delete(&sb);
1244  if (error != 0)
1245  return (error);
1246  else if (error2 != 0)
1247  return (error2);
1248  if (doingzomb)
1249  np = zpfind(pid);
1250  else {
1251  if (pid == 0)
1252  return (0);
1253  np = pfind(pid);
1254  }
1255  if (np == NULL)
1256  return (ESRCH);
1257  if (np != p) {
1258  PROC_UNLOCK(np);
1259  return (ESRCH);
1260  }
1261  PROC_UNLOCK(np);
1262  return (0);
1263 }
1264 
1265 static int
1266 sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
1267 {
1268  int *name = (int *)arg1;
1269  u_int namelen = arg2;
1270  struct proc *p;
1271  int flags, doingzomb, oid_number;
1272  int error = 0;
1273 
1274  oid_number = oidp->oid_number;
1275  if (oid_number != KERN_PROC_ALL &&
1276  (oid_number & KERN_PROC_INC_THREAD) == 0)
1277  flags = KERN_PROC_NOTHREADS;
1278  else {
1279  flags = 0;
1280  oid_number &= ~KERN_PROC_INC_THREAD;
1281  }
1282 #ifdef COMPAT_32BIT
1283  if (req->flags & SCTL_MASK32)
1284  flags |= KERN_PROC_MASK32;
1285 #endif
1286  if (oid_number == KERN_PROC_PID) {
1287  if (namelen != 1)
1288  return (EINVAL);
1289  error = sysctl_wire_old_buffer(req, 0);
1290  if (error)
1291  return (error);
1292  error = pget((pid_t)name[0], PGET_CANSEE, &p);
1293  if (error != 0)
1294  return (error);
1295  error = sysctl_out_proc(p, req, flags, 0);
1296  return (error);
1297  }
1298 
1299  switch (oid_number) {
1300  case KERN_PROC_ALL:
1301  if (namelen != 0)
1302  return (EINVAL);
1303  break;
1304  case KERN_PROC_PROC:
1305  if (namelen != 0 && namelen != 1)
1306  return (EINVAL);
1307  break;
1308  default:
1309  if (namelen != 1)
1310  return (EINVAL);
1311  break;
1312  }
1313 
1314  if (!req->oldptr) {
1315  /* overestimate by 5 procs */
1316  error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
1317  if (error)
1318  return (error);
1319  }
1320  error = sysctl_wire_old_buffer(req, 0);
1321  if (error != 0)
1322  return (error);
1323  sx_slock(&allproc_lock);
1324  for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
1325  if (!doingzomb)
1326  p = LIST_FIRST(&allproc);
1327  else
1328  p = LIST_FIRST(&zombproc);
1329  for (; p != 0; p = LIST_NEXT(p, p_list)) {
1330  /*
1331  * Skip embryonic processes.
1332  */
1333  PROC_LOCK(p);
1334  if (p->p_state == PRS_NEW) {
1335  PROC_UNLOCK(p);
1336  continue;
1337  }
1338  KASSERT(p->p_ucred != NULL,
1339  ("process credential is NULL for non-NEW proc"));
1340  /*
1341  * Show a user only appropriate processes.
1342  */
1343  if (p_cansee(curthread, p)) {
1344  PROC_UNLOCK(p);
1345  continue;
1346  }
1347  /*
1348  * TODO - make more efficient (see notes below).
1349  * do by session.
1350  */
1351  switch (oid_number) {
1352 
1353  case KERN_PROC_GID:
1354  if (p->p_ucred->cr_gid != (gid_t)name[0]) {
1355  PROC_UNLOCK(p);
1356  continue;
1357  }
1358  break;
1359 
1360  case KERN_PROC_PGRP:
1361  /* could do this by traversing pgrp */
1362  if (p->p_pgrp == NULL ||
1363  p->p_pgrp->pg_id != (pid_t)name[0]) {
1364  PROC_UNLOCK(p);
1365  continue;
1366  }
1367  break;
1368 
1369  case KERN_PROC_RGID:
1370  if (p->p_ucred->cr_rgid != (gid_t)name[0]) {
1371  PROC_UNLOCK(p);
1372  continue;
1373  }
1374  break;
1375 
1376  case KERN_PROC_SESSION:
1377  if (p->p_session == NULL ||
1378  p->p_session->s_sid != (pid_t)name[0]) {
1379  PROC_UNLOCK(p);
1380  continue;
1381  }
1382  break;
1383 
1384  case KERN_PROC_TTY:
1385  if ((p->p_flag & P_CONTROLT) == 0 ||
1386  p->p_session == NULL) {
1387  PROC_UNLOCK(p);
1388  continue;
1389  }
1390  /* XXX proctree_lock */
1391  SESS_LOCK(p->p_session);
1392  if (p->p_session->s_ttyp == NULL ||
1393  tty_udev(p->p_session->s_ttyp) !=
1394  (dev_t)name[0]) {
1395  SESS_UNLOCK(p->p_session);
1396  PROC_UNLOCK(p);
1397  continue;
1398  }
1399  SESS_UNLOCK(p->p_session);
1400  break;
1401 
1402  case KERN_PROC_UID:
1403  if (p->p_ucred->cr_uid != (uid_t)name[0]) {
1404  PROC_UNLOCK(p);
1405  continue;
1406  }
1407  break;
1408 
1409  case KERN_PROC_RUID:
1410  if (p->p_ucred->cr_ruid != (uid_t)name[0]) {
1411  PROC_UNLOCK(p);
1412  continue;
1413  }
1414  break;
1415 
1416  case KERN_PROC_PROC:
1417  break;
1418 
1419  default:
1420  break;
1421 
1422  }
1423 
1424  error = sysctl_out_proc(p, req, flags, doingzomb);
1425  if (error) {
1426  sx_sunlock(&allproc_lock);
1427  return (error);
1428  }
1429  }
1430  }
1431  sx_sunlock(&allproc_lock);
1432  return (0);
1433 }
1434 
1435 struct pargs *
1436 pargs_alloc(int len)
1437 {
1438  struct pargs *pa;
1439 
1440  pa = malloc(sizeof(struct pargs) + len, M_PARGS,
1441  M_WAITOK);
1442  refcount_init(&pa->ar_ref, 1);
1443  pa->ar_length = len;
1444  return (pa);
1445 }
1446 
1447 static void
1448 pargs_free(struct pargs *pa)
1449 {
1450 
1451  free(pa, M_PARGS);
1452 }
1453 
1454 void
1455 pargs_hold(struct pargs *pa)
1456 {
1457 
1458  if (pa == NULL)
1459  return;
1460  refcount_acquire(&pa->ar_ref);
1461 }
1462 
1463 void
1464 pargs_drop(struct pargs *pa)
1465 {
1466 
1467  if (pa == NULL)
1468  return;
1469  if (refcount_release(&pa->ar_ref))
1470  pargs_free(pa);
1471 }
1472 
1473 static int
1474 proc_read_mem(struct thread *td, struct proc *p, vm_offset_t offset, void* buf,
1475  size_t len)
1476 {
1477  struct iovec iov;
1478  struct uio uio;
1479 
1480  iov.iov_base = (caddr_t)buf;
1481  iov.iov_len = len;
1482  uio.uio_iov = &iov;
1483  uio.uio_iovcnt = 1;
1484  uio.uio_offset = offset;
1485  uio.uio_resid = (ssize_t)len;
1486  uio.uio_segflg = UIO_SYSSPACE;
1487  uio.uio_rw = UIO_READ;
1488  uio.uio_td = td;
1489 
1490  return (proc_rwmem(p, &uio));
1491 }
1492 
1493 static int
1494 proc_read_string(struct thread *td, struct proc *p, const char *sptr, char *buf,
1495  size_t len)
1496 {
1497  size_t i;
1498  int error;
1499 
1500  error = proc_read_mem(td, p, (vm_offset_t)sptr, buf, len);
1501  /*
1502  * Reading the chunk may validly return EFAULT if the string is shorter
1503  * than the chunk and is aligned at the end of the page, assuming the
1504  * next page is not mapped. So if EFAULT is returned do a fallback to
1505  * one byte read loop.
1506  */
1507  if (error == EFAULT) {
1508  for (i = 0; i < len; i++, buf++, sptr++) {
1509  error = proc_read_mem(td, p, (vm_offset_t)sptr, buf, 1);
1510  if (error != 0)
1511  return (error);
1512  if (*buf == '\0')
1513  break;
1514  }
1515  error = 0;
1516  }
1517  return (error);
1518 }
1519 
1520 #define PROC_AUXV_MAX 256 /* Safety limit on auxv size. */
1521 
1522 enum proc_vector_type {
1523  PROC_ARG,
1524  PROC_ENV,
1525  PROC_AUX,
1526 };
1527 
1528 #ifdef COMPAT_32BIT
1529 static int
1530 get_proc_vector32(struct thread *td, struct proc *p, char ***proc_vectorp,
1531  size_t *vsizep, enum proc_vector_type type)
1532 {
1533  struct compat32bit_ps_strings pss;
1534  Elf32_Auxinfo aux;
1535  vm_offset_t vptr, ptr;
1536  uint32_t *proc_vector32;
1537  char **proc_vector;
1538  size_t vsize, size;
1539  int i, error;
1540 
1541  error = proc_read_mem(td, p, (vm_offset_t)(p->p_sysent->sv_psstrings),
1542  &pss, sizeof(pss));
1543  if (error != 0)
1544  return (error);
1545  switch (type) {
1546  case PROC_ARG:
1547  vptr = (vm_offset_t)PTRIN(pss.ps_argvstr);
1548  vsize = pss.ps_nargvstr;
1549  if (vsize > ARG_MAX)
1550  return (ENOEXEC);
1551  size = vsize * sizeof(int32_t);
1552  break;
1553  case PROC_ENV:
1554  vptr = (vm_offset_t)PTRIN(pss.ps_envstr);
1555  vsize = pss.ps_nenvstr;
1556  if (vsize > ARG_MAX)
1557  return (ENOEXEC);
1558  size = vsize * sizeof(int32_t);
1559  break;
1560  case PROC_AUX:
1561  vptr = (vm_offset_t)PTRIN(pss.ps_envstr) +
1562  (pss.ps_nenvstr + 1) * sizeof(int32_t);
1563  if (vptr % 4 != 0)
1564  return (ENOEXEC);
1565  for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
1566  error = proc_read_mem(td, p, ptr, &aux, sizeof(aux));
1567  if (error != 0)
1568  return (error);
1569  if (aux.a_type == AT_NULL)
1570  break;
1571  ptr += sizeof(aux);
1572  }
1573  if (aux.a_type != AT_NULL)
1574  return (ENOEXEC);
1575  vsize = i + 1;
1576  size = vsize * sizeof(aux);
1577  break;
1578  default:
1579  KASSERT(0, ("Wrong proc vector type: %d", type));
1580  return (EINVAL);
1581  }
1582  proc_vector32 = malloc(size, M_TEMP, M_WAITOK);
1583  error = proc_read_mem(td, p, vptr, proc_vector32, size);
1584  if (error != 0)
1585  goto done;
1586  if (type == PROC_AUX) {
1587  *proc_vectorp = (char **)proc_vector32;
1588  *vsizep = vsize;
1589  return (0);
1590  }
1591  proc_vector = malloc(vsize * sizeof(char *), M_TEMP, M_WAITOK);
1592  for (i = 0; i < (int)vsize; i++)
1593  proc_vector[i] = PTRIN(proc_vector32[i]);
1594  *proc_vectorp = proc_vector;
1595  *vsizep = vsize;
1596 done:
1597  free(proc_vector32, M_TEMP);
1598  return (error);
1599 }
1600 #endif
1601 
1602 static int
1603 get_proc_vector(struct thread *td, struct proc *p, char ***proc_vectorp,
1604  size_t *vsizep, enum proc_vector_type type)
1605 {
1606  struct ps_strings pss;
1607  Elf_Auxinfo aux;
1608  vm_offset_t vptr, ptr;
1609  char **proc_vector;
1610  size_t vsize, size;
1611  int error, i;
1612 
1613 #ifdef COMPAT_32BIT
1614  if (SV_PROC_FLAG(p, SV_ILP32) != 0)
1615  return (get_proc_vector32(td, p, proc_vectorp, vsizep, type));
1616 #endif
1617  error = proc_read_mem(td, p, (vm_offset_t)(p->p_sysent->sv_psstrings),
1618  &pss, sizeof(pss));
1619  if (error != 0)
1620  return (error);
1621  switch (type) {
1622  case PROC_ARG:
1623  vptr = (vm_offset_t)pss.ps_argvstr;
1624  vsize = pss.ps_nargvstr;
1625  if (vsize > ARG_MAX)
1626  return (ENOEXEC);
1627  size = vsize * sizeof(char *);
1628  break;
1629  case PROC_ENV:
1630  vptr = (vm_offset_t)pss.ps_envstr;
1631  vsize = pss.ps_nenvstr;
1632  if (vsize > ARG_MAX)
1633  return (ENOEXEC);
1634  size = vsize * sizeof(char *);
1635  break;
1636  case PROC_AUX:
1637  /*
1638  * The aux array is just above env array on the stack. Check
1639  * that the address is naturally aligned.
1640  */
1641  vptr = (vm_offset_t)pss.ps_envstr + (pss.ps_nenvstr + 1)
1642  * sizeof(char *);
1643 #if __ELF_WORD_SIZE == 64
1644  if (vptr % sizeof(uint64_t) != 0)
1645 #else
1646  if (vptr % sizeof(uint32_t) != 0)
1647 #endif
1648  return (ENOEXEC);
1649  /*
1650  * We count the array size reading the aux vectors from the
1651  * stack until AT_NULL vector is returned. So (to keep the code
1652  * simple) we read the process stack twice: the first time here
1653  * to find the size and the second time when copying the vectors
1654  * to the allocated proc_vector.
1655  */
1656  for (ptr = vptr, i = 0; i < PROC_AUXV_MAX; i++) {
1657  error = proc_read_mem(td, p, ptr, &aux, sizeof(aux));
1658  if (error != 0)
1659  return (error);
1660  if (aux.a_type == AT_NULL)
1661  break;
1662  ptr += sizeof(aux);
1663  }
1664  /*
1665  * If the PROC_AUXV_MAX entries are iterated over, and we have
1666  * not reached AT_NULL, it is most likely we are reading wrong
1667  * data: either the process doesn't have auxv array or data has
1668  * been modified. Return the error in this case.
1669  */
1670  if (aux.a_type != AT_NULL)
1671  return (ENOEXEC);
1672  vsize = i + 1;
1673  size = vsize * sizeof(aux);
1674  break;
1675  default:
1676  KASSERT(0, ("Wrong proc vector type: %d", type));
1677  return (EINVAL); /* In case we are built without INVARIANTS. */
1678  }
1679  proc_vector = malloc(size, M_TEMP, M_WAITOK);
1680  if (proc_vector == NULL)
1681  return (ENOMEM);
1682  error = proc_read_mem(td, p, vptr, proc_vector, size);
1683  if (error != 0) {
1684  free(proc_vector, M_TEMP);
1685  return (error);
1686  }
1687  *proc_vectorp = proc_vector;
1688  *vsizep = vsize;
1689 
1690  return (0);
1691 }
1692 
1693 #define GET_PS_STRINGS_CHUNK_SZ 256 /* Chunk size (bytes) for ps_strings operations. */
1694 
1695 static int
1696 get_ps_strings(struct thread *td, struct proc *p, struct sbuf *sb,
1697  enum proc_vector_type type)
1698 {
1699  size_t done, len, nchr, vsize;
1700  int error, i;
1701  char **proc_vector, *sptr;
1702  char pss_string[GET_PS_STRINGS_CHUNK_SZ];
1703 
1704  PROC_ASSERT_HELD(p);
1705 
1706  /*
1707  * We are not going to read more than 2 * (PATH_MAX + ARG_MAX) bytes.
1708  */
1709  nchr = 2 * (PATH_MAX + ARG_MAX);
1710 
1711  error = get_proc_vector(td, p, &proc_vector, &vsize, type);
1712  if (error != 0)
1713  return (error);
1714  for (done = 0, i = 0; i < (int)vsize && done < nchr; i++) {
1715  /*
1716  * The program may have scribbled into its argv array, e.g. to
1717  * remove some arguments. If that has happened, break out
1718  * before trying to read from NULL.
1719  */
1720  if (proc_vector[i] == NULL)
1721  break;
1722  for (sptr = proc_vector[i]; ; sptr += GET_PS_STRINGS_CHUNK_SZ) {
1723  error = proc_read_string(td, p, sptr, pss_string,
1724  sizeof(pss_string));
1725  if (error != 0)
1726  goto done;
1727  len = strnlen(pss_string, GET_PS_STRINGS_CHUNK_SZ);
1728  if (done + len >= nchr)
1729  len = nchr - done - 1;
1730  sbuf_bcat(sb, pss_string, len);
1731  if (len != GET_PS_STRINGS_CHUNK_SZ)
1732  break;
1733  done += GET_PS_STRINGS_CHUNK_SZ;
1734  }
1735  sbuf_bcat(sb, "", 1);
1736  done += len + 1;
1737  }
1738 done:
1739  free(proc_vector, M_TEMP);
1740  return (error);
1741 }
1742 
1743 int
1744 proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb)
1745 {
1746 
1747  return (get_ps_strings(curthread, p, sb, PROC_ARG));
1748 }
1749 
1750 int
1751 proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb)
1752 {
1753 
1754  return (get_ps_strings(curthread, p, sb, PROC_ENV));
1755 }
1756 
1757 int
1758 proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb)
1759 {
1760  size_t vsize, size;
1761  char **auxv;
1762  int error;
1763 
1764  error = get_proc_vector(td, p, &auxv, &vsize, PROC_AUX);
1765  if (error == 0) {
1766 #ifdef COMPAT_32BIT
1767  if (SV_PROC_FLAG(p, SV_ILP32) != 0)
1768  size = vsize * sizeof(Elf32_Auxinfo);
1769  else
1770 #endif
1771  size = vsize * sizeof(Elf_Auxinfo);
1772  error = sbuf_bcat(sb, auxv, size);
1773  free(auxv, M_TEMP);
1774  }
1775  return (error);
1776 }
1777 
1778 /*
1779  * This sysctl allows a process to retrieve the argument list or process
1780  * title for another process without groping around in the address space
1781  * of the other process. It also allow a process to set its own "process
1782  * title to a string of its own choice.
1783  */
1784 static int
1785 sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
1786 {
1787  int *name = (int *)arg1;
1788  u_int namelen = arg2;
1789  struct pargs *newpa, *pa;
1790  struct proc *p;
1791  struct sbuf sb;
1792  int flags, error = 0, error2;
1793 
1794  if (namelen != 1)
1795  return (EINVAL);
1796 
1797  flags = PGET_CANSEE;
1798  if (req->newptr != NULL)
1799  flags |= PGET_ISCURRENT;
1800  error = pget((pid_t)name[0], flags, &p);
1801  if (error)
1802  return (error);
1803 
1804  pa = p->p_args;
1805  if (pa != NULL) {
1806  pargs_hold(pa);
1807  PROC_UNLOCK(p);
1808  error = SYSCTL_OUT(req, pa->ar_args, pa->ar_length);
1809  pargs_drop(pa);
1810  } else if ((p->p_flag & (P_WEXIT | P_SYSTEM)) == 0) {
1811  _PHOLD(p);
1812  PROC_UNLOCK(p);
1813  sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
1814  error = proc_getargv(curthread, p, &sb);
1815  error2 = sbuf_finish(&sb);
1816  PRELE(p);
1817  sbuf_delete(&sb);
1818  if (error == 0 && error2 != 0)
1819  error = error2;
1820  } else {
1821  PROC_UNLOCK(p);
1822  }
1823  if (error != 0 || req->newptr == NULL)
1824  return (error);
1825 
1826  if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit)
1827  return (ENOMEM);
1828  newpa = pargs_alloc(req->newlen);
1829  error = SYSCTL_IN(req, newpa->ar_args, req->newlen);
1830  if (error != 0) {
1831  pargs_free(newpa);
1832  return (error);
1833  }
1834  PROC_LOCK(p);
1835  pa = p->p_args;
1836  p->p_args = newpa;
1837  PROC_UNLOCK(p);
1838  pargs_drop(pa);
1839  return (0);
1840 }
1841 
1842 /*
1843  * This sysctl allows a process to retrieve environment of another process.
1844  */
1845 static int
1846 sysctl_kern_proc_env(SYSCTL_HANDLER_ARGS)
1847 {
1848  int *name = (int *)arg1;
1849  u_int namelen = arg2;
1850  struct proc *p;
1851  struct sbuf sb;
1852  int error, error2;
1853 
1854  if (namelen != 1)
1855  return (EINVAL);
1856 
1857  error = pget((pid_t)name[0], PGET_WANTREAD, &p);
1858  if (error != 0)
1859  return (error);
1860  if ((p->p_flag & P_SYSTEM) != 0) {
1861  PRELE(p);
1862  return (0);
1863  }
1864 
1865  sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
1866  error = proc_getenvv(curthread, p, &sb);
1867  error2 = sbuf_finish(&sb);
1868  PRELE(p);
1869  sbuf_delete(&sb);
1870  return (error != 0 ? error : error2);
1871 }
1872 
1873 /*
1874  * This sysctl allows a process to retrieve ELF auxiliary vector of
1875  * another process.
1876  */
1877 static int
1878 sysctl_kern_proc_auxv(SYSCTL_HANDLER_ARGS)
1879 {
1880  int *name = (int *)arg1;
1881  u_int namelen = arg2;
1882  struct proc *p;
1883  struct sbuf sb;
1884  int error, error2;
1885 
1886  if (namelen != 1)
1887  return (EINVAL);
1888 
1889  error = pget((pid_t)name[0], PGET_WANTREAD, &p);
1890  if (error != 0)
1891  return (error);
1892  if ((p->p_flag & P_SYSTEM) != 0) {
1893  PRELE(p);
1894  return (0);
1895  }
1896  sbuf_new_for_sysctl(&sb, NULL, GET_PS_STRINGS_CHUNK_SZ, req);
1897  error = proc_getauxv(curthread, p, &sb);
1898  error2 = sbuf_finish(&sb);
1899  PRELE(p);
1900  sbuf_delete(&sb);
1901  return (error != 0 ? error : error2);
1902 }
1903 
1904 /*
1905  * This sysctl allows a process to retrieve the path of the executable for
1906  * itself or another process.
1907  */
1908 static int
1909 sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS)
1910 {
1911  pid_t *pidp = (pid_t *)arg1;
1912  unsigned int arglen = arg2;
1913  struct proc *p;
1914  struct vnode *vp;
1915  char *retbuf, *freebuf;
1916  int error, vfslocked;
1917 
1918  if (arglen != 1)
1919  return (EINVAL);
1920  if (*pidp == -1) { /* -1 means this process */
1921  p = req->td->td_proc;
1922  } else {
1923  error = pget(*pidp, PGET_CANSEE, &p);
1924  if (error != 0)
1925  return (error);
1926  }
1927 
1928  vp = p->p_textvp;
1929  if (vp == NULL) {
1930  if (*pidp != -1)
1931  PROC_UNLOCK(p);
1932  return (0);
1933  }
1934  vref(vp);
1935  if (*pidp != -1)
1936  PROC_UNLOCK(p);
1937  error = vn_fullpath(req->td, vp, &retbuf, &freebuf);
1938  vfslocked = VFS_LOCK_GIANT(vp->v_mount);
1939  vrele(vp);
1940  VFS_UNLOCK_GIANT(vfslocked);
1941  if (error)
1942  return (error);
1943  error = SYSCTL_OUT(req, retbuf, strlen(retbuf) + 1);
1944  free(freebuf, M_TEMP);
1945  return (error);
1946 }
1947 
1948 static int
1949 sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS)
1950 {
1951  struct proc *p;
1952  char *sv_name;
1953  int *name;
1954  int namelen;
1955  int error;
1956 
1957  namelen = arg2;
1958  if (namelen != 1)
1959  return (EINVAL);
1960 
1961  name = (int *)arg1;
1962  error = pget((pid_t)name[0], PGET_CANSEE, &p);
1963  if (error != 0)
1964  return (error);
1965  sv_name = p->p_sysent->sv_name;
1966  PROC_UNLOCK(p);
1967  return (sysctl_handle_string(oidp, sv_name, 0, req));
1968 }
1969 
1970 #ifdef KINFO_OVMENTRY_SIZE
1971 CTASSERT(sizeof(struct kinfo_ovmentry) == KINFO_OVMENTRY_SIZE);
1972 #endif
1973 
1974 #ifdef COMPAT_FREEBSD7
1975 static int
1976 sysctl_kern_proc_ovmmap(SYSCTL_HANDLER_ARGS)
1977 {
1978  vm_map_entry_t entry, tmp_entry;
1979  unsigned int last_timestamp;
1980  char *fullpath, *freepath;
1981  struct kinfo_ovmentry *kve;
1982  struct vattr va;
1983  struct ucred *cred;
1984  int error, *name;
1985  struct vnode *vp;
1986  struct proc *p;
1987  vm_map_t map;
1988  struct vmspace *vm;
1989 
1990  name = (int *)arg1;
1991  error = pget((pid_t)name[0], PGET_WANTREAD, &p);
1992  if (error != 0)
1993  return (error);
1994  vm = vmspace_acquire_ref(p);
1995  if (vm == NULL) {
1996  PRELE(p);
1997  return (ESRCH);
1998  }
1999  kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK);
2000 
2001  map = &vm->vm_map;
2002  vm_map_lock_read(map);
2003  for (entry = map->header.next; entry != &map->header;
2004  entry = entry->next) {
2005  vm_object_t obj, tobj, lobj;
2006  vm_offset_t addr;
2007  int vfslocked;
2008 
2009  if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
2010  continue;
2011 
2012  bzero(kve, sizeof(*kve));
2013  kve->kve_structsize = sizeof(*kve);
2014 
2015  kve->kve_private_resident = 0;
2016  obj = entry->object.vm_object;
2017  if (obj != NULL) {
2018  VM_OBJECT_LOCK(obj);
2019  if (obj->shadow_count == 1)
2020  kve->kve_private_resident =
2021  obj->resident_page_count;
2022  }
2023  kve->kve_resident = 0;
2024  addr = entry->start;
2025  while (addr < entry->end) {
2026  if (pmap_extract(map->pmap, addr))
2027  kve->kve_resident++;
2028  addr += PAGE_SIZE;
2029  }
2030 
2031  for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) {
2032  if (tobj != obj)
2033  VM_OBJECT_LOCK(tobj);
2034  if (lobj != obj)
2035  VM_OBJECT_UNLOCK(lobj);
2036  lobj = tobj;
2037  }
2038 
2039  kve->kve_start = (void*)entry->start;
2040  kve->kve_end = (void*)entry->end;
2041  kve->kve_offset = (off_t)entry->offset;
2042 
2043  if (entry->protection & VM_PROT_READ)
2044  kve->kve_protection |= KVME_PROT_READ;
2045  if (entry->protection & VM_PROT_WRITE)
2046  kve->kve_protection |= KVME_PROT_WRITE;
2047  if (entry->protection & VM_PROT_EXECUTE)
2048  kve->kve_protection |= KVME_PROT_EXEC;
2049 
2050  if (entry->eflags & MAP_ENTRY_COW)
2051  kve->kve_flags |= KVME_FLAG_COW;
2052  if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
2053  kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
2054  if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
2055  kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
2056 
2057  last_timestamp = map->timestamp;
2058  vm_map_unlock_read(map);
2059 
2060  kve->kve_fileid = 0;
2061  kve->kve_fsid = 0;
2062  freepath = NULL;
2063  fullpath = "";
2064  if (lobj) {
2065  vp = NULL;
2066  switch (lobj->type) {
2067  case OBJT_DEFAULT:
2068  kve->kve_type = KVME_TYPE_DEFAULT;
2069  break;
2070  case OBJT_VNODE:
2071  kve->kve_type = KVME_TYPE_VNODE;
2072  vp = lobj->handle;
2073  vref(vp);
2074  break;
2075  case OBJT_SWAP:
2076  kve->kve_type = KVME_TYPE_SWAP;
2077  break;
2078  case OBJT_DEVICE:
2079  kve->kve_type = KVME_TYPE_DEVICE;
2080  break;
2081  case OBJT_PHYS:
2082  kve->kve_type = KVME_TYPE_PHYS;
2083  break;
2084  case OBJT_DEAD:
2085  kve->kve_type = KVME_TYPE_DEAD;
2086  break;
2087  case OBJT_SG:
2088  kve->kve_type = KVME_TYPE_SG;
2089  break;
2090  default:
2091  kve->kve_type = KVME_TYPE_UNKNOWN;
2092  break;
2093  }
2094  if (lobj != obj)
2095  VM_OBJECT_UNLOCK(lobj);
2096 
2097  kve->kve_ref_count = obj->ref_count;
2098  kve->kve_shadow_count = obj->shadow_count;
2099  VM_OBJECT_UNLOCK(obj);
2100  if (vp != NULL) {
2101  vn_fullpath(curthread, vp, &fullpath,
2102  &freepath);
2103  cred = curthread->td_ucred;
2104  vfslocked = VFS_LOCK_GIANT(vp->v_mount);
2105  vn_lock(vp, LK_SHARED | LK_RETRY);
2106  if (VOP_GETATTR(vp, &va, cred) == 0) {
2107  kve->kve_fileid = va.va_fileid;
2108  kve->kve_fsid = va.va_fsid;
2109  }
2110  vput(vp);
2111  VFS_UNLOCK_GIANT(vfslocked);
2112  }
2113  } else {
2114  kve->kve_type = KVME_TYPE_NONE;
2115  kve->kve_ref_count = 0;
2116  kve->kve_shadow_count = 0;
2117  }
2118 
2119  strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
2120  if (freepath != NULL)
2121  free(freepath, M_TEMP);
2122 
2123  error = SYSCTL_OUT(req, kve, sizeof(*kve));
2124  vm_map_lock_read(map);
2125  if (error)
2126  break;
2127  if (last_timestamp != map->timestamp) {
2128  vm_map_lookup_entry(map, addr - 1, &tmp_entry);
2129  entry = tmp_entry;
2130  }
2131  }
2132  vm_map_unlock_read(map);
2133  vmspace_free(vm);
2134  PRELE(p);
2135  free(kve, M_TEMP);
2136  return (error);
2137 }
2138 #endif /* COMPAT_FREEBSD7 */
2139 
2140 #ifdef KINFO_VMENTRY_SIZE
2141 CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE);
2142 #endif
2143 
2144 /*
2145  * Must be called with the process locked and will return unlocked.
2146  */
2147 int
2148 kern_proc_vmmap_out(struct proc *p, struct sbuf *sb)
2149 {
2150  vm_map_entry_t entry, tmp_entry;
2151  unsigned int last_timestamp;
2152  char *fullpath, *freepath;
2153  struct kinfo_vmentry *kve;
2154  struct vattr va;
2155  struct ucred *cred;
2156  int error;
2157  struct vnode *vp;
2158  struct vmspace *vm;
2159  vm_map_t map;
2160 
2161  PROC_LOCK_ASSERT(p, MA_OWNED);
2162 
2163  _PHOLD(p);
2164  PROC_UNLOCK(p);
2165  vm = vmspace_acquire_ref(p);
2166  if (vm == NULL) {
2167  PRELE(p);
2168  return (ESRCH);
2169  }
2170  kve = malloc(sizeof(*kve), M_TEMP, M_WAITOK);
2171 
2172  error = 0;
2173  map = &vm->vm_map;
2174  vm_map_lock_read(map);
2175  for (entry = map->header.next; entry != &map->header;
2176  entry = entry->next) {
2177  vm_object_t obj, tobj, lobj;
2178  vm_offset_t addr;
2179  vm_paddr_t locked_pa;
2180  int vfslocked, mincoreinfo;
2181 
2182  if (entry->eflags & MAP_ENTRY_IS_SUB_MAP)
2183  continue;
2184 
2185  bzero(kve, sizeof(*kve));
2186 
2187  kve->kve_private_resident = 0;
2188  obj = entry->object.vm_object;
2189  if (obj != NULL) {
2190  VM_OBJECT_LOCK(obj);
2191  if (obj->shadow_count == 1)
2192  kve->kve_private_resident =
2193  obj->resident_page_count;
2194  }
2195  kve->kve_resident = 0;
2196  addr = entry->start;
2197  if (vmmap_skip_res_cnt)
2198  goto skip_resident_count;
2199  while (addr < entry->end) {
2200  locked_pa = 0;
2201  mincoreinfo = pmap_mincore(map->pmap, addr, &locked_pa);
2202  if (locked_pa != 0)
2203  vm_page_unlock(PHYS_TO_VM_PAGE(locked_pa));
2204  if (mincoreinfo & MINCORE_INCORE)
2205  kve->kve_resident++;
2206  if (mincoreinfo & MINCORE_SUPER)
2207  kve->kve_flags |= KVME_FLAG_SUPER;
2208  addr += PAGE_SIZE;
2209  }
2210 
2211 skip_resident_count:
2212  for (lobj = tobj = obj; tobj; tobj = tobj->backing_object) {
2213  if (tobj != obj)
2214  VM_OBJECT_LOCK(tobj);
2215  if (lobj != obj)
2216  VM_OBJECT_UNLOCK(lobj);
2217  lobj = tobj;
2218  }
2219 
2220  kve->kve_start = entry->start;
2221  kve->kve_end = entry->end;
2222  kve->kve_offset = entry->offset;
2223 
2224  if (entry->protection & VM_PROT_READ)
2225  kve->kve_protection |= KVME_PROT_READ;
2226  if (entry->protection & VM_PROT_WRITE)
2227  kve->kve_protection |= KVME_PROT_WRITE;
2228  if (entry->protection & VM_PROT_EXECUTE)
2229  kve->kve_protection |= KVME_PROT_EXEC;
2230 
2231  if (entry->eflags & MAP_ENTRY_COW)
2232  kve->kve_flags |= KVME_FLAG_COW;
2233  if (entry->eflags & MAP_ENTRY_NEEDS_COPY)
2234  kve->kve_flags |= KVME_FLAG_NEEDS_COPY;
2235  if (entry->eflags & MAP_ENTRY_NOCOREDUMP)
2236  kve->kve_flags |= KVME_FLAG_NOCOREDUMP;
2237  if (entry->eflags & MAP_ENTRY_GROWS_UP)
2238  kve->kve_flags |= KVME_FLAG_GROWS_UP;
2239  if (entry->eflags & MAP_ENTRY_GROWS_DOWN)
2240  kve->kve_flags |= KVME_FLAG_GROWS_DOWN;
2241 
2242  last_timestamp = map->timestamp;
2243  vm_map_unlock_read(map);
2244 
2245  freepath = NULL;
2246  fullpath = "";
2247  if (lobj) {
2248  vp = NULL;
2249  switch (lobj->type) {
2250  case OBJT_DEFAULT:
2251  kve->kve_type = KVME_TYPE_DEFAULT;
2252  break;
2253  case OBJT_VNODE:
2254  kve->kve_type = KVME_TYPE_VNODE;
2255  vp = lobj->handle;
2256  vref(vp);
2257  break;
2258  case OBJT_SWAP:
2259  kve->kve_type = KVME_TYPE_SWAP;
2260  break;
2261  case OBJT_DEVICE:
2262  kve->kve_type = KVME_TYPE_DEVICE;
2263  break;
2264  case OBJT_PHYS:
2265  kve->kve_type = KVME_TYPE_PHYS;
2266  break;
2267  case OBJT_DEAD:
2268  kve->kve_type = KVME_TYPE_DEAD;
2269  break;
2270  case OBJT_SG:
2271  kve->kve_type = KVME_TYPE_SG;
2272  break;
2273  case OBJT_MGTDEVICE:
2274  kve->kve_type = KVME_TYPE_MGTDEVICE;
2275  break;
2276  default:
2277  kve->kve_type = KVME_TYPE_UNKNOWN;
2278  break;
2279  }
2280  if (lobj != obj)
2281  VM_OBJECT_UNLOCK(lobj);
2282 
2283  kve->kve_ref_count = obj->ref_count;
2284  kve->kve_shadow_count = obj->shadow_count;
2285  VM_OBJECT_UNLOCK(obj);
2286  if (vp != NULL) {
2287  vn_fullpath(curthread, vp, &fullpath,
2288  &freepath);
2289  kve->kve_vn_type = vntype_to_kinfo(vp->v_type);
2290  cred = curthread->td_ucred;
2291  vfslocked = VFS_LOCK_GIANT(vp->v_mount);
2292  vn_lock(vp, LK_SHARED | LK_RETRY);
2293  if (VOP_GETATTR(vp, &va, cred) == 0) {
2294  kve->kve_vn_fileid = va.va_fileid;
2295  kve->kve_vn_fsid = va.va_fsid;
2296  kve->kve_vn_mode =
2297  MAKEIMODE(va.va_type, va.va_mode);
2298  kve->kve_vn_size = va.va_size;
2299  kve->kve_vn_rdev = va.va_rdev;
2300  kve->kve_status = KF_ATTR_VALID;
2301  }
2302  vput(vp);
2303  VFS_UNLOCK_GIANT(vfslocked);
2304  }
2305  } else {
2306  kve->kve_type = KVME_TYPE_NONE;
2307  kve->kve_ref_count = 0;
2308  kve->kve_shadow_count = 0;
2309  }
2310 
2311  strlcpy(kve->kve_path, fullpath, sizeof(kve->kve_path));
2312  if (freepath != NULL)
2313  free(freepath, M_TEMP);
2314 
2315  /* Pack record size down */
2316  kve->kve_structsize = offsetof(struct kinfo_vmentry, kve_path) +
2317  strlen(kve->kve_path) + 1;
2318  kve->kve_structsize = roundup(kve->kve_structsize,
2319  sizeof(uint64_t));
2320  error = sbuf_bcat(sb, kve, kve->kve_structsize);
2321  vm_map_lock_read(map);
2322  if (error)
2323  break;
2324  if (last_timestamp != map->timestamp) {
2325  vm_map_lookup_entry(map, addr - 1, &tmp_entry);
2326  entry = tmp_entry;
2327  }
2328  }
2329  vm_map_unlock_read(map);
2330  vmspace_free(vm);
2331  PRELE(p);
2332  free(kve, M_TEMP);
2333  return (error);
2334 }
2335 
2336 static int
2337 sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS)
2338 {
2339  struct proc *p;
2340  struct sbuf sb;
2341  int error, error2, *name;
2342 
2343  name = (int *)arg1;
2344  sbuf_new_for_sysctl(&sb, NULL, sizeof(struct kinfo_vmentry), req);
2345  error = pget((pid_t)name[0], PGET_CANDEBUG | PGET_NOTWEXIT, &p);
2346  if (error != 0) {
2347  sbuf_delete(&sb);
2348  return (error);
2349  }
2350  error = kern_proc_vmmap_out(p, &sb);
2351  error2 = sbuf_finish(&sb);
2352  sbuf_delete(&sb);
2353  return (error != 0 ? error : error2);
2354 }
2355 
2356 #if defined(STACK) || defined(DDB)
2357 static int
2358 sysctl_kern_proc_kstack(SYSCTL_HANDLER_ARGS)
2359 {
2360  struct kinfo_kstack *kkstp;
2361  int error, i, *name, numthreads;
2362  lwpid_t *lwpidarray;
2363  struct thread *td;
2364  struct stack *st;
2365  struct sbuf sb;
2366  struct proc *p;
2367 
2368  name = (int *)arg1;
2369  error = pget((pid_t)name[0], PGET_NOTINEXEC | PGET_WANTREAD, &p);
2370  if (error != 0)
2371  return (error);
2372 
2373  kkstp = malloc(sizeof(*kkstp), M_TEMP, M_WAITOK);
2374  st = stack_create();
2375 
2376  lwpidarray = NULL;
2377  numthreads = 0;
2378  PROC_LOCK(p);
2379 repeat:
2380  if (numthreads < p->p_numthreads) {
2381  if (lwpidarray != NULL) {
2382  free(lwpidarray, M_TEMP);
2383  lwpidarray = NULL;
2384  }
2385  numthreads = p->p_numthreads;
2386  PROC_UNLOCK(p);
2387  lwpidarray = malloc(sizeof(*lwpidarray) * numthreads, M_TEMP,
2388  M_WAITOK | M_ZERO);
2389  PROC_LOCK(p);
2390  goto repeat;
2391  }
2392  i = 0;
2393 
2394  /*
2395  * XXXRW: During the below loop, execve(2) and countless other sorts
2396  * of changes could have taken place. Should we check to see if the
2397  * vmspace has been replaced, or the like, in order to prevent
2398  * giving a snapshot that spans, say, execve(2), with some threads
2399  * before and some after? Among other things, the credentials could
2400  * have changed, in which case the right to extract debug info might
2401  * no longer be assured.
2402  */
2403  FOREACH_THREAD_IN_PROC(p, td) {
2404  KASSERT(i < numthreads,
2405  ("sysctl_kern_proc_kstack: numthreads"));
2406  lwpidarray[i] = td->td_tid;
2407  i++;
2408  }
2409  numthreads = i;
2410  for (i = 0; i < numthreads; i++) {
2411  td = thread_find(p, lwpidarray[i]);
2412  if (td == NULL) {
2413  continue;
2414  }
2415  bzero(kkstp, sizeof(*kkstp));
2416  (void)sbuf_new(&sb, kkstp->kkst_trace,
2417  sizeof(kkstp->kkst_trace), SBUF_FIXEDLEN);
2418  thread_lock(td);
2419  kkstp->kkst_tid = td->td_tid;
2420  if (TD_IS_SWAPPED(td))
2421  kkstp->kkst_state = KKST_STATE_SWAPPED;
2422  else if (TD_IS_RUNNING(td))
2423  kkstp->kkst_state = KKST_STATE_RUNNING;
2424  else {
2425  kkstp->kkst_state = KKST_STATE_STACKOK;
2426  stack_save_td(st, td);
2427  }
2428  thread_unlock(td);
2429  PROC_UNLOCK(p);
2430  stack_sbuf_print(&sb, st);
2431  sbuf_finish(&sb);
2432  sbuf_delete(&sb);
2433  error = SYSCTL_OUT(req, kkstp, sizeof(*kkstp));
2434  PROC_LOCK(p);
2435  if (error)
2436  break;
2437  }
2438  _PRELE(p);
2439  PROC_UNLOCK(p);
2440  if (lwpidarray != NULL)
2441  free(lwpidarray, M_TEMP);
2442  stack_destroy(st);
2443  free(kkstp, M_TEMP);
2444  return (error);
2445 }
2446 #endif
2447 
2448 /*
2449  * This sysctl allows a process to retrieve the full list of groups from
2450  * itself or another process.
2451  */
2452 static int
2453 sysctl_kern_proc_groups(SYSCTL_HANDLER_ARGS)
2454 {
2455  pid_t *pidp = (pid_t *)arg1;
2456  unsigned int arglen = arg2;
2457  struct proc *p;
2458  struct ucred *cred;
2459  int error;
2460 
2461  if (arglen != 1)
2462  return (EINVAL);
2463  if (*pidp == -1) { /* -1 means this process */
2464  p = req->td->td_proc;
2465  } else {
2466  error = pget(*pidp, PGET_CANSEE, &p);
2467  if (error != 0)
2468  return (error);
2469  }
2470 
2471  cred = crhold(p->p_ucred);
2472  if (*pidp != -1)
2473  PROC_UNLOCK(p);
2474 
2475  error = SYSCTL_OUT(req, cred->cr_groups,
2476  cred->cr_ngroups * sizeof(gid_t));
2477  crfree(cred);
2478  return (error);
2479 }
2480 
2481 /*
2482  * This sysctl allows a process to retrieve or/and set the resource limit for
2483  * another process.
2484  */
2485 static int
2486 sysctl_kern_proc_rlimit(SYSCTL_HANDLER_ARGS)
2487 {
2488  int *name = (int *)arg1;
2489  u_int namelen = arg2;
2490  struct rlimit rlim;
2491  struct proc *p;
2492  u_int which;
2493  int flags, error;
2494 
2495  if (namelen != 2)
2496  return (EINVAL);
2497 
2498  which = (u_int)name[1];
2499  if (which >= RLIM_NLIMITS)
2500  return (EINVAL);
2501 
2502  if (req->newptr != NULL && req->newlen != sizeof(rlim))
2503  return (EINVAL);
2504 
2505  flags = PGET_HOLD | PGET_NOTWEXIT;
2506  if (req->newptr != NULL)
2507  flags |= PGET_CANDEBUG;
2508  else
2509  flags |= PGET_CANSEE;
2510  error = pget((pid_t)name[0], flags, &p);
2511  if (error != 0)
2512  return (error);
2513 
2514  /*
2515  * Retrieve limit.
2516  */
2517  if (req->oldptr != NULL) {
2518  PROC_LOCK(p);
2519  lim_rlimit(p, which, &rlim);
2520  PROC_UNLOCK(p);
2521  }
2522  error = SYSCTL_OUT(req, &rlim, sizeof(rlim));
2523  if (error != 0)
2524  goto errout;
2525 
2526  /*
2527  * Set limit.
2528  */
2529  if (req->newptr != NULL) {
2530  error = SYSCTL_IN(req, &rlim, sizeof(rlim));
2531  if (error == 0)
2532  error = kern_proc_setrlimit(curthread, p, which, &rlim);
2533  }
2534 
2535 errout:
2536  PRELE(p);
2537  return (error);
2538 }
2539 
2540 /*
2541  * This sysctl allows a process to retrieve ps_strings structure location of
2542  * another process.
2543  */
2544 static int
2545 sysctl_kern_proc_ps_strings(SYSCTL_HANDLER_ARGS)
2546 {
2547  int *name = (int *)arg1;
2548  u_int namelen = arg2;
2549  struct proc *p;
2550  vm_offset_t ps_strings;
2551  int error;
2552 #ifdef COMPAT_32BIT
2553  uint32_t ps_strings32;
2554 #endif
2555 
2556  if (namelen != 1)
2557  return (EINVAL);
2558 
2559  error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
2560  if (error != 0)
2561  return (error);
2562 #ifdef COMPAT_32BIT
2563  if ((req->flags & SCTL_MASK32) != 0) {
2564  /*
2565  * We return 0 if the 32 bit emulation request is for a 64 bit
2566  * process.
2567  */
2568  ps_strings32 = SV_PROC_FLAG(p, SV_ILP32) != 0 ?
2569  PTROUT(p->p_sysent->sv_psstrings) : 0;
2570  PROC_UNLOCK(p);
2571  error = SYSCTL_OUT(req, &ps_strings32, sizeof(ps_strings32));
2572  return (error);
2573  }
2574 #endif
2575  ps_strings = p->p_sysent->sv_psstrings;
2576  PROC_UNLOCK(p);
2577  error = SYSCTL_OUT(req, &ps_strings, sizeof(ps_strings));
2578  return (error);
2579 }
2580 
2581 /*
2582  * This sysctl allows a process to retrieve umask of another process.
2583  */
2584 static int
2585 sysctl_kern_proc_umask(SYSCTL_HANDLER_ARGS)
2586 {
2587  int *name = (int *)arg1;
2588  u_int namelen = arg2;
2589  struct proc *p;
2590  int error;
2591  u_short fd_cmask;
2592 
2593  if (namelen != 1)
2594  return (EINVAL);
2595 
2596  error = pget((pid_t)name[0], PGET_WANTREAD, &p);
2597  if (error != 0)
2598  return (error);
2599 
2600  FILEDESC_SLOCK(p->p_fd);
2601  fd_cmask = p->p_fd->fd_cmask;
2602  FILEDESC_SUNLOCK(p->p_fd);
2603  PRELE(p);
2604  error = SYSCTL_OUT(req, &fd_cmask, sizeof(fd_cmask));
2605  return (error);
2606 }
2607 
2608 /*
2609  * This sysctl allows a process to set and retrieve binary osreldate of
2610  * another process.
2611  */
2612 static int
2613 sysctl_kern_proc_osrel(SYSCTL_HANDLER_ARGS)
2614 {
2615  int *name = (int *)arg1;
2616  u_int namelen = arg2;
2617  struct proc *p;
2618  int flags, error, osrel;
2619 
2620  if (namelen != 1)
2621  return (EINVAL);
2622 
2623  if (req->newptr != NULL && req->newlen != sizeof(osrel))
2624  return (EINVAL);
2625 
2626  flags = PGET_HOLD | PGET_NOTWEXIT;
2627  if (req->newptr != NULL)
2628  flags |= PGET_CANDEBUG;
2629  else
2630  flags |= PGET_CANSEE;
2631  error = pget((pid_t)name[0], flags, &p);
2632  if (error != 0)
2633  return (error);
2634 
2635  error = SYSCTL_OUT(req, &p->p_osrel, sizeof(p->p_osrel));
2636  if (error != 0)
2637  goto errout;
2638 
2639  if (req->newptr != NULL) {
2640  error = SYSCTL_IN(req, &osrel, sizeof(osrel));
2641  if (error != 0)
2642  goto errout;
2643  if (osrel < 0) {
2644  error = EINVAL;
2645  goto errout;
2646  }
2647  p->p_osrel = osrel;
2648  }
2649 errout:
2650  PRELE(p);
2651  return (error);
2652 }
2653 
2654 static int
2655 sysctl_kern_proc_sigtramp(SYSCTL_HANDLER_ARGS)
2656 {
2657  int *name = (int *)arg1;
2658  u_int namelen = arg2;
2659  struct proc *p;
2660  struct kinfo_sigtramp kst;
2661  const struct sysentvec *sv;
2662  int error;
2663 #ifdef COMPAT_32BIT
2664  struct kinfo_sigtramp32 kst32;
2665 #endif
2666 
2667  if (namelen != 1)
2668  return (EINVAL);
2669 
2670  error = pget((pid_t)name[0], PGET_CANDEBUG, &p);
2671  if (error != 0)
2672  return (error);
2673  sv = p->p_sysent;
2674 #ifdef COMPAT_32BIT
2675  if ((req->flags & SCTL_MASK32) != 0) {
2676  bzero(&kst32, sizeof(kst32));
2677  if (SV_PROC_FLAG(p, SV_ILP32)) {
2678  if (sv->sv_sigcode_base != 0) {
2679  kst32.ksigtramp_start = sv->sv_sigcode_base;
2680  kst32.ksigtramp_end = sv->sv_sigcode_base +
2681  *sv->sv_szsigcode;
2682  } else {
2683  kst32.ksigtramp_start = sv->sv_psstrings -
2684  *sv->sv_szsigcode;
2685  kst32.ksigtramp_end = sv->sv_psstrings;
2686  }
2687  }
2688  PROC_UNLOCK(p);
2689  error = SYSCTL_OUT(req, &kst32, sizeof(kst32));
2690  return (error);
2691  }
2692 #endif
2693  bzero(&kst, sizeof(kst));
2694  if (sv->sv_sigcode_base != 0) {
2695  kst.ksigtramp_start = (char *)sv->sv_sigcode_base;
2696  kst.ksigtramp_end = (char *)sv->sv_sigcode_base +
2697  *sv->sv_szsigcode;
2698  } else {
2699  kst.ksigtramp_start = (char *)sv->sv_psstrings -
2700  *sv->sv_szsigcode;
2701  kst.ksigtramp_end = (char *)sv->sv_psstrings;
2702  }
2703  PROC_UNLOCK(p);
2704  error = SYSCTL_OUT(req, &kst, sizeof(kst));
2705  return (error);
2706 }
2707 
2708 SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0, "Process table");
2709 
2710 SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT|
2711  CTLFLAG_MPSAFE, 0, 0, sysctl_kern_proc, "S,proc",
2712  "Return entire process table");
2713 
2714 static SYSCTL_NODE(_kern_proc, KERN_PROC_GID, gid, CTLFLAG_RD | CTLFLAG_MPSAFE,
2715  sysctl_kern_proc, "Process table");
2716 
2717 static SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD | CTLFLAG_MPSAFE,
2718  sysctl_kern_proc, "Process table");
2719 
2720 static SYSCTL_NODE(_kern_proc, KERN_PROC_RGID, rgid, CTLFLAG_RD | CTLFLAG_MPSAFE,
2721  sysctl_kern_proc, "Process table");
2722 
2723 static SYSCTL_NODE(_kern_proc, KERN_PROC_SESSION, sid, CTLFLAG_RD |
2724  CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2725 
2726 static SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD | CTLFLAG_MPSAFE,
2727  sysctl_kern_proc, "Process table");
2728 
2729 static SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD | CTLFLAG_MPSAFE,
2730  sysctl_kern_proc, "Process table");
2731 
2732 static SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD | CTLFLAG_MPSAFE,
2733  sysctl_kern_proc, "Process table");
2734 
2735 static SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD | CTLFLAG_MPSAFE,
2736  sysctl_kern_proc, "Process table");
2737 
2738 static SYSCTL_NODE(_kern_proc, KERN_PROC_PROC, proc, CTLFLAG_RD | CTLFLAG_MPSAFE,
2739  sysctl_kern_proc, "Return process table, no threads");
2740 
2741 static SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args,
2742  CTLFLAG_RW | CTLFLAG_ANYBODY | CTLFLAG_MPSAFE,
2743  sysctl_kern_proc_args, "Process argument list");
2744 
2745 static SYSCTL_NODE(_kern_proc, KERN_PROC_ENV, env, CTLFLAG_RD | CTLFLAG_MPSAFE,
2746  sysctl_kern_proc_env, "Process environment");
2747 
2748 static SYSCTL_NODE(_kern_proc, KERN_PROC_AUXV, auxv, CTLFLAG_RD |
2749  CTLFLAG_MPSAFE, sysctl_kern_proc_auxv, "Process ELF auxiliary vector");
2750 
2751 static SYSCTL_NODE(_kern_proc, KERN_PROC_PATHNAME, pathname, CTLFLAG_RD |
2752  CTLFLAG_MPSAFE, sysctl_kern_proc_pathname, "Process executable path");
2753 
2754 static SYSCTL_NODE(_kern_proc, KERN_PROC_SV_NAME, sv_name, CTLFLAG_RD |
2755  CTLFLAG_MPSAFE, sysctl_kern_proc_sv_name,
2756  "Process syscall vector name (ABI type)");
2757 
2758 static SYSCTL_NODE(_kern_proc, (KERN_PROC_GID | KERN_PROC_INC_THREAD), gid_td,
2759  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2760 
2761 static SYSCTL_NODE(_kern_proc, (KERN_PROC_PGRP | KERN_PROC_INC_THREAD), pgrp_td,
2762  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2763 
2764 static SYSCTL_NODE(_kern_proc, (KERN_PROC_RGID | KERN_PROC_INC_THREAD), rgid_td,
2765  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2766 
2767 static SYSCTL_NODE(_kern_proc, (KERN_PROC_SESSION | KERN_PROC_INC_THREAD),
2768  sid_td, CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2769 
2770 static SYSCTL_NODE(_kern_proc, (KERN_PROC_TTY | KERN_PROC_INC_THREAD), tty_td,
2771  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2772 
2773 static SYSCTL_NODE(_kern_proc, (KERN_PROC_UID | KERN_PROC_INC_THREAD), uid_td,
2774  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2775 
2776 static SYSCTL_NODE(_kern_proc, (KERN_PROC_RUID | KERN_PROC_INC_THREAD), ruid_td,
2777  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2778 
2779 static SYSCTL_NODE(_kern_proc, (KERN_PROC_PID | KERN_PROC_INC_THREAD), pid_td,
2780  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc, "Process table");
2781 
2782 static SYSCTL_NODE(_kern_proc, (KERN_PROC_PROC | KERN_PROC_INC_THREAD), proc_td,
2783  CTLFLAG_RD | CTLFLAG_MPSAFE, sysctl_kern_proc,
2784  "Return process table, no threads");
2785 
2786 #ifdef COMPAT_FREEBSD7
2787 static SYSCTL_NODE(_kern_proc, KERN_PROC_OVMMAP, ovmmap, CTLFLAG_RD |
2788  CTLFLAG_MPSAFE, sysctl_kern_proc_ovmmap, "Old Process vm map entries");
2789 #endif
2790 
2791 static SYSCTL_NODE(_kern_proc, KERN_PROC_VMMAP, vmmap, CTLFLAG_RD |
2792  CTLFLAG_MPSAFE, sysctl_kern_proc_vmmap, "Process vm map entries");
2793 
2794 #if defined(STACK) || defined(DDB)
2795 static SYSCTL_NODE(_kern_proc, KERN_PROC_KSTACK, kstack, CTLFLAG_RD |
2796  CTLFLAG_MPSAFE, sysctl_kern_proc_kstack, "Process kernel stacks");
2797 #endif
2798 
2799 static SYSCTL_NODE(_kern_proc, KERN_PROC_GROUPS, groups, CTLFLAG_RD |
2800  CTLFLAG_MPSAFE, sysctl_kern_proc_groups, "Process groups");
2801 
2802 static SYSCTL_NODE(_kern_proc, KERN_PROC_RLIMIT, rlimit, CTLFLAG_RW |
2803  CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_rlimit,
2804  "Process resource limits");
2805 
2806 static SYSCTL_NODE(_kern_proc, KERN_PROC_PS_STRINGS, ps_strings, CTLFLAG_RD |
2807  CTLFLAG_MPSAFE, sysctl_kern_proc_ps_strings,
2808  "Process ps_strings location");
2809 
2810 static SYSCTL_NODE(_kern_proc, KERN_PROC_UMASK, umask, CTLFLAG_RD |
2811  CTLFLAG_MPSAFE, sysctl_kern_proc_umask, "Process umask");
2812 
2813 static SYSCTL_NODE(_kern_proc, KERN_PROC_OSREL, osrel, CTLFLAG_RW |
2814  CTLFLAG_ANYBODY | CTLFLAG_MPSAFE, sysctl_kern_proc_osrel,
2815  "Process binary osreldate");
2816 
2817 static SYSCTL_NODE(_kern_proc, KERN_PROC_SIGTRAMP, sigtramp, CTLFLAG_RD |
2818  CTLFLAG_MPSAFE, sysctl_kern_proc_sigtramp,
2819  "Process signal trampoline location");
allproc
struct proclist allproc
Definition: kern_proc.c:134
proc_realparent
struct proc * proc_realparent(struct proc *child)
Definition: kern_exit.c:103
rufetch
void rufetch(struct proc *p, struct rusage *ru)
Definition: kern_resource.c:1076
sysctl_kern_proc_osrel
static int sysctl_kern_proc_osrel(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:2613
enterpgrp
int enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, struct session *sess)
Definition: kern_proc.c:423
SYSCTL_NODE
SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD, 0,"Process table")
buf
struct buf * buf
Definition: vfs_bio.c:97
pfind_locked
struct proc * pfind_locked(pid_t pid)
Definition: kern_proc.c:279
hashinit
void * hashinit(int elements, struct malloc_type *type, u_long *hashmask)
Definition: subr_hash.c:83
CTASSERT
CTASSERT(sizeof(struct kinfo_proc)==KINFO_PROC_SIZE)
stack_sbuf_print
void stack_sbuf_print(struct sbuf *sb, struct stack *st)
Definition: subr_stack.c:170
sysctl_kern_proc_vmmap
static int sysctl_kern_proc_vmmap(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:2337
PROC_ARG
Definition: kern_proc.c:1523
ps_arg_cache_limit
u_long ps_arg_cache_limit
Definition: kern_exec.c:121
sysctl_kern_proc_sigtramp
static int sysctl_kern_proc_sigtramp(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:2655
sess_hold
void sess_hold(struct session *s)
Definition: kern_proc.c:709
fixjobc
void fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
Definition: kern_proc.c:637
pargs_free
static void pargs_free(struct pargs *pa)
Definition: kern_proc.c:1448
vmmap_skip_res_cnt
static int vmmap_skip_res_cnt
Definition: kern_proc.c:144
p_candebug
int p_candebug(struct thread *td, struct proc *p)
Definition: kern_prot.c:1627
pstats_fork
void pstats_fork(struct pstats *src, struct pstats *dst)
Definition: kern_proc.c:1040
proc_rwmem
int proc_rwmem(struct proc *p, struct uio *uio)
Definition: sys_process.c:242
SDT_PROVIDER_DEFINE
SDT_PROVIDER_DEFINE(proc)
malloc
void * malloc(unsigned long size, struct malloc_type *mtp, int flags)
Definition: kern_malloc.c:454
fill_kinfo_proc_only
static void fill_kinfo_proc_only(struct proc *p, struct kinfo_proc *kp)
Definition: kern_proc.c:788
sess_release
void sess_release(struct session *s)
Definition: kern_proc.c:716
leavepgrp
int leavepgrp(struct proc *p)
Definition: kern_proc.c:554
pargs_drop
void pargs_drop(struct pargs *pa)
Definition: kern_proc.c:1464
pidhash
u_long pidhash
Definition: kern_proc.c:131
sysctl_kern_proc_ps_strings
static int sysctl_kern_proc_ps_strings(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:2545
panic
void panic(const char *fmt,...)
Definition: kern_shutdown.c:557
__FBSDID
__FBSDID("$BSDSUniX$")
proc_getenvv
int proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb)
Definition: kern_proc.c:1751
get_proc_vector
static int get_proc_vector(struct thread *td, struct proc *p, char ***proc_vectorp, size_t *vsizep, enum proc_vector_type type)
Definition: kern_proc.c:1603
sysctl_kern_proc
static int sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:1266
funsetownlst
void funsetownlst(struct sigiolst *sigiolst)
Definition: kern_descrip.c:1026
ppeers_lock
struct mtx ppeers_lock
Definition: kern_proc.c:138
stack_destroy
void stack_destroy(struct stack *st)
Definition: subr_stack.c:62
vn_fullpath
int vn_fullpath(struct thread *td, struct vnode *vn, char **retbuf, char **freebuf)
Definition: vfs_cache.c:1133
name
const char * name
Definition: kern_fail.c:97
maxproc
int maxproc
Definition: subr_param.c:87
PROC_AUXV_MAX
#define PROC_AUXV_MAX
Definition: kern_proc.c:1520
pgadjustjobc
static void pgadjustjobc(struct pgrp *pgrp, int entering)
Definition: kern_proc.c:610
sysctl_kern_proc_args
static int sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:1785
proc_ctor
static int proc_ctor(void *mem, int size, void *arg, int flags)
Definition: kern_proc.c:178
kern_psignal
void kern_psignal(struct proc *p, int sig)
Definition: kern_sig.c:1975
proc_zone
uma_zone_t proc_zone
Definition: kern_proc.c:139
type
int * type
Definition: cpufreq_if.m:98
tty_rel_sess
void tty_rel_sess(struct tty *tp, struct session *sess)
Definition: tty.c:1083
sysctl_handle_string
int sysctl_handle_string(SYSCTL_HANDLER_ARGS)
Definition: kern_sysctl.c:1121
doenterpgrp
static void doenterpgrp(struct proc *, struct pgrp *)
Definition: kern_proc.c:515
pstats_free
void pstats_free(struct pstats *ps)
Definition: kern_proc.c:1050
fill_kinfo_aggregate
static void fill_kinfo_aggregate(struct proc *p, struct kinfo_proc *kp)
Definition: kern_proc.c:766
proc_vector_type
proc_vector_type
Definition: kern_proc.c:1522
thread_free
void thread_free(struct thread *td)
Definition: kern_thread.c:374
sysctl_kern_proc_env
static int sysctl_kern_proc_env(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:1846
pfind
struct proc * pfind(pid_t pid)
Definition: kern_proc.c:304
vref
void vref(struct vnode *vp)
Definition: vfs_subr.c:2302
procinit
void procinit()
Definition: kern_proc.c:158
SDT_PROBE_DEFINE3
SDT_PROBE_DEFINE3(proc, kernel, dtor, return,"struct proc *","int","void *")
GET_PS_STRINGS_CHUNK_SZ
#define GET_PS_STRINGS_CHUNK_SZ
Definition: kern_proc.c:1693
allproc_lock
struct sx allproc_lock
Definition: kern_proc.c:136
calccru
void calccru(struct proc *p, struct timeval *up, struct timeval *sp)
Definition: kern_resource.c:809
get_ps_strings
static int get_ps_strings(struct thread *td, struct proc *p, struct sbuf *sb, enum proc_vector_type type)
Definition: kern_proc.c:1696
vput
void vput(struct vnode *vp)
Definition: vfs_subr.c:2428
vntype_to_kinfo
int vntype_to_kinfo(int vtype)
Definition: kern_descrip.c:3598
tty_udev
dev_t tty_udev(struct tty *tp)
Definition: tty.c:1758
inferior
int inferior(struct proc *p)
Definition: kern_proc.c:266
uihashinit
void uihashinit()
Definition: kern_resource.c:1205
cputick2usec
uint64_t cputick2usec(uint64_t tick)
Definition: kern_tc.c:975
orphanpg
static void orphanpg(struct pgrp *pg)
Definition: kern_proc.c:685
pgrphashtbl
struct pgrphashhead * pgrphashtbl
Definition: kern_proc.c:132
enterthispgrp
int enterthispgrp(struct proc *p, struct pgrp *pgrp)
Definition: kern_proc.c:488
jailed
int jailed(struct ucred *cred)
Definition: kern_jail.c:3474
MALLOC_DEFINE
MALLOC_DEFINE(M_PGRP,"pgrp","process group header")
kern_proc_out
int kern_proc_out(struct proc *p, struct sbuf *sb, int flags)
Definition: kern_proc.c:1189
proc_fini
static void proc_fini(void *mem, int size)
Definition: kern_proc.c:245
zpfind_locked
static struct proc * zpfind_locked(pid_t pid)
Definition: kern_proc.c:1057
pstats_alloc
struct pstats * pstats_alloc(void)
Definition: kern_proc.c:1030
crfree
void crfree(struct ucred *cr)
Definition: kern_prot.c:1835
fill_kinfo_proc
void fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
Definition: kern_proc.c:1019
timevaladd
void timevaladd(struct timeval *t1, const struct timeval *t2)
Definition: kern_time.c:876
boottime
struct timeval boottime
Definition: kern_tc.c:98
sysctl_kern_proc_auxv
static int sysctl_kern_proc_auxv(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:1878
sysctl_kern_proc_pathname
static int sysctl_kern_proc_pathname(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:1909
pgdelete
static void pgdelete(struct pgrp *)
Definition: kern_proc.c:576
pgfind
struct pgrp * pgfind(pid_t pgid)
Definition: kern_proc.c:342
sysctl_kern_proc_rlimit
static int sysctl_kern_proc_rlimit(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:2486
PROC_ENV
Definition: kern_proc.c:1524
lim_rlimit
void lim_rlimit(struct proc *p, int which, struct rlimit *rlp)
Definition: kern_resource.c:1193
sysctl_kern_proc_sv_name
static int sysctl_kern_proc_sv_name(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:1949
PROC_AUX
Definition: kern_proc.c:1525
sbuf_new
struct sbuf * sbuf_new(struct sbuf *s, char *buf, int length, int flags)
Definition: subr_sbuf.c:211
ksiginfo_free
void ksiginfo_free(ksiginfo_t *ksi)
Definition: kern_sig.c:255
pidhashtbl
struct pidhashhead * pidhashtbl
Definition: kern_proc.c:130
cv_init
void cv_init(struct cv *cvp, const char *desc)
Definition: kern_condvar.c:63
crhold
struct ucred * crhold(struct ucred *cr)
Definition: kern_prot.c:1824
SDT_PROBE_DEFINE4
SDT_PROBE_DEFINE4(proc, kernel, ctor, entry,"struct proc *","int","void *","int")
kern_proc_vmmap_out
int kern_proc_vmmap_out(struct proc *p, struct sbuf *sb)
Definition: kern_proc.c:2148
zombproc
struct proclist zombproc
Definition: kern_proc.c:135
rufetchtd
void rufetchtd(struct thread *td, struct rusage *ru)
Definition: kern_resource.c:857
SYSCTL_INT
SYSCTL_INT(_kern, OID_AUTO, kstack_pages, CTLFLAG_RD,&kstack_pages, 0,"Kernel stack size in pages")
free
void free(void *addr, struct malloc_type *mtp)
Definition: kern_malloc.c:554
printf
int printf(const char *fmt,...)
Definition: subr_prf.c:367
sbuf_delete
void sbuf_delete(struct sbuf *s)
Definition: subr_sbuf.c:753
pargs_alloc
struct pargs * pargs_alloc(int len)
Definition: kern_proc.c:1436
sysctl_kern_proc_groups
static int sysctl_kern_proc_groups(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:2453
kstack_pages
int kstack_pages
Definition: kern_proc.c:141
sysctl_wire_old_buffer
int sysctl_wire_old_buffer(struct sysctl_req *req, size_t len)
Definition: kern_sysctl.c:1364
mtx_init
void mtx_init(struct mtx *m, const char *name, const char *type, int opts)
Definition: kern_mutex.c:837
tty_rel_pgrp
void tty_rel_pgrp(struct tty *tp, struct pgrp *pg)
Definition: tty.c:1071
vrele
void vrele(struct vnode *vp)
Definition: vfs_subr.c:2416
pfind_tid_locked
static struct proc * pfind_tid_locked(pid_t tid)
Definition: kern_proc.c:315
sbuf_bcat
int sbuf_bcat(struct sbuf *s, const void *buf, size_t len)
Definition: subr_sbuf.c:389
kern_proc_setrlimit
int kern_proc_setrlimit(struct thread *td, struct proc *p, u_int which, struct rlimit *limp)
Definition: kern_resource.c:659
sbuf_finish
int sbuf_finish(struct sbuf *s)
Definition: subr_sbuf.c:694
pget
int pget(pid_t pid, int flags, struct proc **pp)
Definition: kern_proc.c:362
pgrphash
u_long pgrphash
Definition: kern_proc.c:133
sched_sizeof_proc
int sched_sizeof_proc(void)
Definition: sched_4bsd.c:1570
thread_find
struct thread * thread_find(struct proc *p, lwpid_t tid)
Definition: kern_thread.c:992
fill_kinfo_thread
static void fill_kinfo_thread(struct thread *td, struct kinfo_proc *kp, int preferthread)
Definition: kern_proc.c:935
stack_create
struct stack * stack_create(void)
Definition: subr_stack.c:53
ticks
volatile int ticks
Definition: kern_clock.c:387
proc_read_mem
static int proc_read_mem(struct thread *td, struct proc *p, vm_offset_t offset, void *buf, size_t len)
Definition: kern_proc.c:1474
proctree_lock
struct sx proctree_lock
Definition: kern_proc.c:137
sysctl_kern_proc_umask
static int sysctl_kern_proc_umask(SYSCTL_HANDLER_ARGS)
Definition: kern_proc.c:2585
calcru
void calcru(struct proc *p, struct timeval *up, struct timeval *sp)
Definition: kern_resource.c:825
zpfind
struct proc * zpfind(pid_t pid)
Definition: kern_proc.c:1075
mtx_destroy
void mtx_destroy(struct mtx *m)
Definition: kern_mutex.c:884
SYSCTL_PROC
SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT|CTLFLAG_MPSAFE, 0, 0, sysctl_kern_proc,"S,proc","Return entire process table")
proc_getargv
int proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb)
Definition: kern_proc.c:1744
sysctl_out_proc
static int sysctl_out_proc(struct proc *p, struct sysctl_req *req, int flags, int doingzomb)
Definition: kern_proc.c:1230
proc_init
static int proc_init(void *mem, int size, int flags)
Definition: kern_proc.c:221
p_cansee
int p_cansee(struct thread *td, struct proc *p)
Definition: kern_prot.c:1426
pargs_hold
void pargs_hold(struct pargs *pa)
Definition: kern_proc.c:1455
proc_getauxv
int proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb)
Definition: kern_proc.c:1758
sbuf_new_for_sysctl
struct sbuf * sbuf_new_for_sysctl(struct sbuf *s, char *buf, int length, struct sysctl_req *req)
Definition: kern_sysctl.c:1676
proc_read_string
static int proc_read_string(struct thread *td, struct proc *p, const char *sptr, char *buf, size_t len)
Definition: kern_proc.c:1494
hz
int hz
Definition: subr_param.c:84
proc_dtor
static void proc_dtor(void *mem, int size, void *arg)
Definition: kern_proc.c:193
sched_pctcpu
fixpt_t sched_pctcpu(struct thread *td)
Definition: sched_4bsd.c:1582