Add threads to the process-retrieval sysctls so they show up in top, ps, etc.
[dragonfly.git] / sys / kern / kern_proc.c
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  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  *      @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
34  * $FreeBSD: src/sys/kern/kern_proc.c,v 1.63.2.9 2003/05/08 07:47:16 kbyanc Exp $
35  * $DragonFly: src/sys/kern/kern_proc.c,v 1.9 2003/06/30 23:54:02 dillon Exp $
36  */
37
38 #include <sys/param.h>
39 #include <sys/systm.h>
40 #include <sys/kernel.h>
41 #include <sys/sysctl.h>
42 #include <sys/malloc.h>
43 #include <sys/proc.h>
44 #include <sys/filedesc.h>
45 #include <sys/tty.h>
46 #include <sys/signalvar.h>
47 #include <vm/vm.h>
48 #include <sys/lock.h>
49 #include <vm/pmap.h>
50 #include <vm/vm_map.h>
51 #include <sys/user.h>
52 #include <vm/vm_zone.h>
53
54 static MALLOC_DEFINE(M_PGRP, "pgrp", "process group header");
55 MALLOC_DEFINE(M_SESSION, "session", "session header");
56 static MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
57 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
58
59 static int ps_showallprocs = 1;
60 static int ps_showallthreads = 1;
61 SYSCTL_INT(_kern, OID_AUTO, ps_showallprocs, CTLFLAG_RW,
62     &ps_showallprocs, 0, "");
63 SYSCTL_INT(_kern, OID_AUTO, ps_showallthreads, CTLFLAG_RW,
64     &ps_showallthreads, 0, "");
65
66 static void pgdelete    __P((struct pgrp *));
67
68 static void     orphanpg __P((struct pgrp *pg));
69
70 /*
71  * Other process lists
72  */
73 struct pidhashhead *pidhashtbl;
74 u_long pidhash;
75 struct pgrphashhead *pgrphashtbl;
76 u_long pgrphash;
77 struct proclist allproc;
78 struct proclist zombproc;
79 vm_zone_t proc_zone;
80 vm_zone_t thread_zone;
81
82 /*
83  * Initialize global process hashing structures.
84  */
85 void
86 procinit()
87 {
88
89         LIST_INIT(&allproc);
90         LIST_INIT(&zombproc);
91         pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
92         pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
93         proc_zone = zinit("PROC", sizeof (struct proc), 0, 0, 5);
94         thread_zone = zinit("THREAD", sizeof (struct thread), 0, 0, 5);
95         uihashinit();
96 }
97
98 /*
99  * Is p an inferior of the current process?
100  */
101 int
102 inferior(p)
103         register struct proc *p;
104 {
105
106         for (; p != curproc; p = p->p_pptr)
107                 if (p->p_pid == 0)
108                         return (0);
109         return (1);
110 }
111
112 /*
113  * Locate a process by number
114  */
115 struct proc *
116 pfind(pid)
117         register pid_t pid;
118 {
119         register struct proc *p;
120
121         LIST_FOREACH(p, PIDHASH(pid), p_hash)
122                 if (p->p_pid == pid)
123                         return (p);
124         return (NULL);
125 }
126
127 /*
128  * Locate a process group by number
129  */
130 struct pgrp *
131 pgfind(pgid)
132         register pid_t pgid;
133 {
134         register struct pgrp *pgrp;
135
136         LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash)
137                 if (pgrp->pg_id == pgid)
138                         return (pgrp);
139         return (NULL);
140 }
141
142 /*
143  * Move p to a new or existing process group (and session)
144  */
145 int
146 enterpgrp(p, pgid, mksess)
147         register struct proc *p;
148         pid_t pgid;
149         int mksess;
150 {
151         register struct pgrp *pgrp = pgfind(pgid);
152
153         KASSERT(pgrp == NULL || !mksess,
154             ("enterpgrp: setsid into non-empty pgrp"));
155         KASSERT(!SESS_LEADER(p),
156             ("enterpgrp: session leader attempted setpgrp"));
157
158         if (pgrp == NULL) {
159                 pid_t savepid = p->p_pid;
160                 struct proc *np;
161                 /*
162                  * new process group
163                  */
164                 KASSERT(p->p_pid == pgid,
165                     ("enterpgrp: new pgrp and pid != pgid"));
166                 if ((np = pfind(savepid)) == NULL || np != p)
167                         return (ESRCH);
168                 MALLOC(pgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP,
169                     M_WAITOK);
170                 if (mksess) {
171                         register struct session *sess;
172
173                         /*
174                          * new session
175                          */
176                         MALLOC(sess, struct session *, sizeof(struct session),
177                             M_SESSION, M_WAITOK);
178                         sess->s_leader = p;
179                         sess->s_sid = p->p_pid;
180                         sess->s_count = 1;
181                         sess->s_ttyvp = NULL;
182                         sess->s_ttyp = NULL;
183                         bcopy(p->p_session->s_login, sess->s_login,
184                             sizeof(sess->s_login));
185                         p->p_flag &= ~P_CONTROLT;
186                         pgrp->pg_session = sess;
187                         KASSERT(p == curproc,
188                             ("enterpgrp: mksession and p != curproc"));
189                 } else {
190                         pgrp->pg_session = p->p_session;
191                         pgrp->pg_session->s_count++;
192                 }
193                 pgrp->pg_id = pgid;
194                 LIST_INIT(&pgrp->pg_members);
195                 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
196                 pgrp->pg_jobc = 0;
197                 SLIST_INIT(&pgrp->pg_sigiolst);
198         } else if (pgrp == p->p_pgrp)
199                 return (0);
200
201         /*
202          * Adjust eligibility of affected pgrps to participate in job control.
203          * Increment eligibility counts before decrementing, otherwise we
204          * could reach 0 spuriously during the first call.
205          */
206         fixjobc(p, pgrp, 1);
207         fixjobc(p, p->p_pgrp, 0);
208
209         LIST_REMOVE(p, p_pglist);
210         if (LIST_EMPTY(&p->p_pgrp->pg_members))
211                 pgdelete(p->p_pgrp);
212         p->p_pgrp = pgrp;
213         LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
214         return (0);
215 }
216
217 /*
218  * remove process from process group
219  */
220 int
221 leavepgrp(p)
222         register struct proc *p;
223 {
224
225         LIST_REMOVE(p, p_pglist);
226         if (LIST_EMPTY(&p->p_pgrp->pg_members))
227                 pgdelete(p->p_pgrp);
228         p->p_pgrp = 0;
229         return (0);
230 }
231
232 /*
233  * delete a process group
234  */
235 static void
236 pgdelete(pgrp)
237         register struct pgrp *pgrp;
238 {
239
240         /*
241          * Reset any sigio structures pointing to us as a result of
242          * F_SETOWN with our pgid.
243          */
244         funsetownlst(&pgrp->pg_sigiolst);
245
246         if (pgrp->pg_session->s_ttyp != NULL &&
247             pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
248                 pgrp->pg_session->s_ttyp->t_pgrp = NULL;
249         LIST_REMOVE(pgrp, pg_hash);
250         if (--pgrp->pg_session->s_count == 0)
251                 FREE(pgrp->pg_session, M_SESSION);
252         FREE(pgrp, M_PGRP);
253 }
254
255 /*
256  * Adjust pgrp jobc counters when specified process changes process group.
257  * We count the number of processes in each process group that "qualify"
258  * the group for terminal job control (those with a parent in a different
259  * process group of the same session).  If that count reaches zero, the
260  * process group becomes orphaned.  Check both the specified process'
261  * process group and that of its children.
262  * entering == 0 => p is leaving specified group.
263  * entering == 1 => p is entering specified group.
264  */
265 void
266 fixjobc(p, pgrp, entering)
267         register struct proc *p;
268         register struct pgrp *pgrp;
269         int entering;
270 {
271         register struct pgrp *hispgrp;
272         register struct session *mysession = pgrp->pg_session;
273
274         /*
275          * Check p's parent to see whether p qualifies its own process
276          * group; if so, adjust count for p's process group.
277          */
278         if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
279             hispgrp->pg_session == mysession) {
280                 if (entering)
281                         pgrp->pg_jobc++;
282                 else if (--pgrp->pg_jobc == 0)
283                         orphanpg(pgrp);
284         }
285
286         /*
287          * Check this process' children to see whether they qualify
288          * their process groups; if so, adjust counts for children's
289          * process groups.
290          */
291         LIST_FOREACH(p, &p->p_children, p_sibling)
292                 if ((hispgrp = p->p_pgrp) != pgrp &&
293                     hispgrp->pg_session == mysession &&
294                     p->p_stat != SZOMB) {
295                         if (entering)
296                                 hispgrp->pg_jobc++;
297                         else if (--hispgrp->pg_jobc == 0)
298                                 orphanpg(hispgrp);
299                 }
300 }
301
302 /*
303  * A process group has become orphaned;
304  * if there are any stopped processes in the group,
305  * hang-up all process in that group.
306  */
307 static void
308 orphanpg(pg)
309         struct pgrp *pg;
310 {
311         register struct proc *p;
312
313         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
314                 if (p->p_stat == SSTOP) {
315                         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
316                                 psignal(p, SIGHUP);
317                                 psignal(p, SIGCONT);
318                         }
319                         return;
320                 }
321         }
322 }
323
324 #include "opt_ddb.h"
325 #ifdef DDB
326 #include <ddb/ddb.h>
327
328 DB_SHOW_COMMAND(pgrpdump, pgrpdump)
329 {
330         register struct pgrp *pgrp;
331         register struct proc *p;
332         register int i;
333
334         for (i = 0; i <= pgrphash; i++) {
335                 if (!LIST_EMPTY(&pgrphashtbl[i])) {
336                         printf("\tindx %d\n", i);
337                         LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
338                                 printf(
339                         "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
340                                     (void *)pgrp, (long)pgrp->pg_id,
341                                     (void *)pgrp->pg_session,
342                                     pgrp->pg_session->s_count,
343                                     (void *)LIST_FIRST(&pgrp->pg_members));
344                                 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
345                                         printf("\t\tpid %ld addr %p pgrp %p\n", 
346                                             (long)p->p_pid, (void *)p,
347                                             (void *)p->p_pgrp);
348                                 }
349                         }
350                 }
351         }
352 }
353 #endif /* DDB */
354
355 /*
356  * Fill in an eproc structure for the specified thread.
357  */
358 void
359 fill_eproc_td(thread_t td, struct eproc *ep, struct proc *xp)
360 {
361         bzero(ep, sizeof(*ep));
362
363         ep->e_uticks = td->td_uticks;
364         ep->e_sticks = td->td_sticks;
365         ep->e_iticks = td->td_iticks;
366         ep->e_tdev = NOUDEV;
367         if (td->td_wmesg) {
368                 strncpy(ep->e_wmesg, td->td_wmesg, WMESGLEN);
369                 ep->e_wmesg[WMESGLEN] = 0;
370         }
371
372         /*
373          * Fake up portions of the proc structure copied out by the sysctl
374          * to return useful information.  Note that using td_pri directly
375          * is messy because it includes critial section data so we fake
376          * up an rtprio.prio for threads.
377          */
378         if (xp) {
379                 *xp = *initproc;
380                 xp->p_rtprio.type = RTP_PRIO_THREAD;
381                 xp->p_rtprio.prio = td->td_pri & TDPRI_MASK;
382                 xp->p_pid = -1;
383         }
384 }
385
386 /*
387  * Fill in an eproc structure for the specified process.
388  */
389 void
390 fill_eproc(struct proc *p, struct eproc *ep)
391 {
392         struct tty *tp;
393
394         fill_eproc_td(p->p_thread, ep, NULL);
395
396         ep->e_paddr = p;
397         if (p->p_ucred) {
398                 ep->e_ucred = *p->p_ucred;
399         }
400         if (p->p_procsig) {
401                 ep->e_procsig = *p->p_procsig;
402         }
403         if (p->p_stat != SIDL && p->p_stat != SZOMB && p->p_vmspace != NULL) {
404                 register struct vmspace *vm = p->p_vmspace;
405                 ep->e_vm = *vm;
406                 ep->e_vm.vm_rssize = vmspace_resident_count(vm); /*XXX*/
407         }
408         if ((p->p_flag & P_INMEM) && p->p_stats)
409                 ep->e_stats = *p->p_stats;
410         if (p->p_pptr)
411                 ep->e_ppid = p->p_pptr->p_pid;
412         if (p->p_pgrp) {
413                 ep->e_pgid = p->p_pgrp->pg_id;
414                 ep->e_jobc = p->p_pgrp->pg_jobc;
415                 ep->e_sess = p->p_pgrp->pg_session;
416
417                 if (ep->e_sess) {
418                         bcopy(ep->e_sess->s_login, ep->e_login, sizeof(ep->e_login));
419                         if (ep->e_sess->s_ttyvp)
420                                 ep->e_flag = EPROC_CTTY;
421                         if (p->p_session && SESS_LEADER(p))
422                                 ep->e_flag |= EPROC_SLEADER;
423                 }
424         }
425         if ((p->p_flag & P_CONTROLT) &&
426             (ep->e_sess != NULL) &&
427             ((tp = ep->e_sess->s_ttyp) != NULL)) {
428                 ep->e_tdev = dev2udev(tp->t_dev);
429                 ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
430                 ep->e_tsess = tp->t_session;
431         } else {
432                 ep->e_tdev = NOUDEV;
433         }
434 }
435
436 struct proc *
437 zpfind(pid_t pid)
438 {
439         struct proc *p;
440
441         LIST_FOREACH(p, &zombproc, p_list)
442                 if (p->p_pid == pid)
443                         return (p);
444         return (NULL);
445 }
446
447 static int
448 sysctl_out_proc(struct proc *p, struct thread *td, struct sysctl_req *req, int doingzomb)
449 {
450         struct eproc eproc;
451         struct proc xproc;
452         int error;
453 #if 0
454         pid_t pid = p->p_pid;
455 #endif
456
457         if (p) {
458                 td = p->p_thread;
459                 fill_eproc(p, &eproc);
460                 xproc = *p;
461         } else if (td) {
462                 fill_eproc_td(td, &eproc, &xproc);
463         }
464         error = SYSCTL_OUT(req,(caddr_t)&xproc, sizeof(struct proc));
465         if (error)
466                 return (error);
467         error = SYSCTL_OUT(req,(caddr_t)&eproc, sizeof(eproc));
468         if (error)
469                 return (error);
470         error = SYSCTL_OUT(req,(caddr_t)td, sizeof(struct thread));
471         if (error)
472                 return (error);
473 #if 0
474         if (!doingzomb && pid && (pfind(pid) != p))
475                 return EAGAIN;
476         if (doingzomb && zpfind(pid) != p)
477                 return EAGAIN;
478 #endif
479         return (0);
480 }
481
482 static int
483 sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
484 {
485         int *name = (int*) arg1;
486         u_int namelen = arg2;
487         struct proc *p;
488         struct thread *td;
489         int doingzomb;
490         int error = 0;
491         struct ucred *cr1 = curproc->p_ucred;
492
493         if (oidp->oid_number == KERN_PROC_PID) {
494                 if (namelen != 1) 
495                         return (EINVAL);
496                 p = pfind((pid_t)name[0]);
497                 if (!p)
498                         return (0);
499                 if (!PRISON_CHECK(cr1, p->p_ucred))
500                         return (0);
501                 error = sysctl_out_proc(p, NULL, req, 0);
502                 return (error);
503         }
504         if (oidp->oid_number == KERN_PROC_ALL && !namelen)
505                 ;
506         else if (oidp->oid_number != KERN_PROC_ALL && namelen == 1)
507                 ;
508         else
509                 return (EINVAL);
510         
511         if (!req->oldptr) {
512                 /* overestimate by 5 procs */
513                 error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
514                 if (error)
515                         return (error);
516         }
517         for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
518                 if (!doingzomb)
519                         p = LIST_FIRST(&allproc);
520                 else
521                         p = LIST_FIRST(&zombproc);
522                 for (; p != 0; p = LIST_NEXT(p, p_list)) {
523                         /*
524                          * Show a user only their processes.
525                          */
526                         if ((!ps_showallprocs) && p_trespass(cr1, p->p_ucred))
527                                 continue;
528                         /*
529                          * Skip embryonic processes.
530                          */
531                         if (p->p_stat == SIDL)
532                                 continue;
533                         /*
534                          * TODO - make more efficient (see notes below).
535                          * do by session.
536                          */
537                         switch (oidp->oid_number) {
538                         case KERN_PROC_PGRP:
539                                 /* could do this by traversing pgrp */
540                                 if (p->p_pgrp == NULL || 
541                                     p->p_pgrp->pg_id != (pid_t)name[0])
542                                         continue;
543                                 break;
544
545                         case KERN_PROC_TTY:
546                                 if ((p->p_flag & P_CONTROLT) == 0 ||
547                                     p->p_session == NULL ||
548                                     p->p_session->s_ttyp == NULL ||
549                                     dev2udev(p->p_session->s_ttyp->t_dev) != 
550                                         (udev_t)name[0])
551                                         continue;
552                                 break;
553
554                         case KERN_PROC_UID:
555                                 if (p->p_ucred == NULL || 
556                                     p->p_ucred->cr_uid != (uid_t)name[0])
557                                         continue;
558                                 break;
559
560                         case KERN_PROC_RUID:
561                                 if (p->p_ucred == NULL || 
562                                     p->p_ucred->cr_ruid != (uid_t)name[0])
563                                         continue;
564                                 break;
565                         }
566
567                         if (!PRISON_CHECK(cr1, p->p_ucred))
568                                 continue;
569                         PHOLD(p);
570                         error = sysctl_out_proc(p, NULL, req, doingzomb);
571                         PRELE(p);
572                         if (error)
573                                 return (error);
574                 }
575         }
576         if (ps_showallthreads) {
577                 TAILQ_FOREACH(td, &mycpu->gd_tdallq, td_allq) {
578                         if (td->td_proc)
579                                 continue;
580                         switch (oidp->oid_number) {
581                         case KERN_PROC_PGRP:
582                         case KERN_PROC_TTY:
583                         case KERN_PROC_UID:
584                         case KERN_PROC_RUID:
585                                 continue;
586                         default:
587                                 break;
588                         }
589                         lwkt_hold(td);
590                         error = sysctl_out_proc(NULL, td, req, doingzomb);
591                         lwkt_rele(td);
592                         if (error)
593                                 return (error);
594                 }
595         }
596         return (0);
597 }
598
599 /*
600  * This sysctl allows a process to retrieve the argument list or process
601  * title for another process without groping around in the address space
602  * of the other process.  It also allow a process to set its own "process 
603  * title to a string of its own choice.
604  */
605 static int
606 sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
607 {
608         int *name = (int*) arg1;
609         u_int namelen = arg2;
610         struct proc *p;
611         struct pargs *pa;
612         int error = 0;
613         struct ucred *cr1 = curproc->p_ucred;
614
615         if (namelen != 1) 
616                 return (EINVAL);
617
618         p = pfind((pid_t)name[0]);
619         if (!p)
620                 return (0);
621
622         if ((!ps_argsopen) && p_trespass(cr1, p->p_ucred))
623                 return (0);
624
625         if (req->newptr && curproc != p)
626                 return (EPERM);
627
628         if (req->oldptr && p->p_args != NULL)
629                 error = SYSCTL_OUT(req, p->p_args->ar_args, p->p_args->ar_length);
630         if (req->newptr == NULL)
631                 return (error);
632
633         if (p->p_args && --p->p_args->ar_ref == 0) 
634                 FREE(p->p_args, M_PARGS);
635         p->p_args = NULL;
636
637         if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit)
638                 return (error);
639
640         MALLOC(pa, struct pargs *, sizeof(struct pargs) + req->newlen, 
641             M_PARGS, M_WAITOK);
642         pa->ar_ref = 1;
643         pa->ar_length = req->newlen;
644         error = SYSCTL_IN(req, pa->ar_args, req->newlen);
645         if (!error)
646                 p->p_args = pa;
647         else
648                 FREE(pa, M_PARGS);
649         return (error);
650 }
651
652 SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD,  0, "Process table");
653
654 SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT,
655         0, 0, sysctl_kern_proc, "S,proc", "Return entire process table");
656
657 SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD, 
658         sysctl_kern_proc, "Process table");
659
660 SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD, 
661         sysctl_kern_proc, "Process table");
662
663 SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD, 
664         sysctl_kern_proc, "Process table");
665
666 SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD, 
667         sysctl_kern_proc, "Process table");
668
669 SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD, 
670         sysctl_kern_proc, "Process table");
671
672 SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args, CTLFLAG_RW | CTLFLAG_ANYBODY,
673         sysctl_kern_proc_args, "Process argument list");