proc->thread stage 2: MAJOR revamping of system calls, ucred, jail API,
[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.4 2003/06/23 17:55:41 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 SYSCTL_INT(_kern, OID_AUTO, ps_showallprocs, CTLFLAG_RW,
61     &ps_showallprocs, 0, "");
62
63 static void pgdelete    __P((struct pgrp *));
64
65 static void     orphanpg __P((struct pgrp *pg));
66
67 /*
68  * Other process lists
69  */
70 struct pidhashhead *pidhashtbl;
71 u_long pidhash;
72 struct pgrphashhead *pgrphashtbl;
73 u_long pgrphash;
74 struct proclist allproc;
75 struct proclist zombproc;
76 vm_zone_t proc_zone;
77 vm_zone_t thread_zone;
78
79 /*
80  * Initialize global process hashing structures.
81  */
82 void
83 procinit()
84 {
85
86         LIST_INIT(&allproc);
87         LIST_INIT(&zombproc);
88         pidhashtbl = hashinit(maxproc / 4, M_PROC, &pidhash);
89         pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
90         proc_zone = zinit("PROC", sizeof (struct proc), 0, 0, 5);
91         thread_zone = zinit("THREAD", sizeof (struct thread), 0, 0, 5);
92         uihashinit();
93 }
94
95 /*
96  * Is p an inferior of the current process?
97  */
98 int
99 inferior(p)
100         register struct proc *p;
101 {
102
103         for (; p != curproc; p = p->p_pptr)
104                 if (p->p_pid == 0)
105                         return (0);
106         return (1);
107 }
108
109 /*
110  * Locate a process by number
111  */
112 struct proc *
113 pfind(pid)
114         register pid_t pid;
115 {
116         register struct proc *p;
117
118         LIST_FOREACH(p, PIDHASH(pid), p_hash)
119                 if (p->p_pid == pid)
120                         return (p);
121         return (NULL);
122 }
123
124 /*
125  * Locate a process group by number
126  */
127 struct pgrp *
128 pgfind(pgid)
129         register pid_t pgid;
130 {
131         register struct pgrp *pgrp;
132
133         LIST_FOREACH(pgrp, PGRPHASH(pgid), pg_hash)
134                 if (pgrp->pg_id == pgid)
135                         return (pgrp);
136         return (NULL);
137 }
138
139 /*
140  * Move p to a new or existing process group (and session)
141  */
142 int
143 enterpgrp(p, pgid, mksess)
144         register struct proc *p;
145         pid_t pgid;
146         int mksess;
147 {
148         register struct pgrp *pgrp = pgfind(pgid);
149
150         KASSERT(pgrp == NULL || !mksess,
151             ("enterpgrp: setsid into non-empty pgrp"));
152         KASSERT(!SESS_LEADER(p),
153             ("enterpgrp: session leader attempted setpgrp"));
154
155         if (pgrp == NULL) {
156                 pid_t savepid = p->p_pid;
157                 struct proc *np;
158                 /*
159                  * new process group
160                  */
161                 KASSERT(p->p_pid == pgid,
162                     ("enterpgrp: new pgrp and pid != pgid"));
163                 if ((np = pfind(savepid)) == NULL || np != p)
164                         return (ESRCH);
165                 MALLOC(pgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP,
166                     M_WAITOK);
167                 if (mksess) {
168                         register struct session *sess;
169
170                         /*
171                          * new session
172                          */
173                         MALLOC(sess, struct session *, sizeof(struct session),
174                             M_SESSION, M_WAITOK);
175                         sess->s_leader = p;
176                         sess->s_sid = p->p_pid;
177                         sess->s_count = 1;
178                         sess->s_ttyvp = NULL;
179                         sess->s_ttyp = NULL;
180                         bcopy(p->p_session->s_login, sess->s_login,
181                             sizeof(sess->s_login));
182                         p->p_flag &= ~P_CONTROLT;
183                         pgrp->pg_session = sess;
184                         KASSERT(p == curproc,
185                             ("enterpgrp: mksession and p != curproc"));
186                 } else {
187                         pgrp->pg_session = p->p_session;
188                         pgrp->pg_session->s_count++;
189                 }
190                 pgrp->pg_id = pgid;
191                 LIST_INIT(&pgrp->pg_members);
192                 LIST_INSERT_HEAD(PGRPHASH(pgid), pgrp, pg_hash);
193                 pgrp->pg_jobc = 0;
194                 SLIST_INIT(&pgrp->pg_sigiolst);
195         } else if (pgrp == p->p_pgrp)
196                 return (0);
197
198         /*
199          * Adjust eligibility of affected pgrps to participate in job control.
200          * Increment eligibility counts before decrementing, otherwise we
201          * could reach 0 spuriously during the first call.
202          */
203         fixjobc(p, pgrp, 1);
204         fixjobc(p, p->p_pgrp, 0);
205
206         LIST_REMOVE(p, p_pglist);
207         if (LIST_EMPTY(&p->p_pgrp->pg_members))
208                 pgdelete(p->p_pgrp);
209         p->p_pgrp = pgrp;
210         LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
211         return (0);
212 }
213
214 /*
215  * remove process from process group
216  */
217 int
218 leavepgrp(p)
219         register struct proc *p;
220 {
221
222         LIST_REMOVE(p, p_pglist);
223         if (LIST_EMPTY(&p->p_pgrp->pg_members))
224                 pgdelete(p->p_pgrp);
225         p->p_pgrp = 0;
226         return (0);
227 }
228
229 /*
230  * delete a process group
231  */
232 static void
233 pgdelete(pgrp)
234         register struct pgrp *pgrp;
235 {
236
237         /*
238          * Reset any sigio structures pointing to us as a result of
239          * F_SETOWN with our pgid.
240          */
241         funsetownlst(&pgrp->pg_sigiolst);
242
243         if (pgrp->pg_session->s_ttyp != NULL &&
244             pgrp->pg_session->s_ttyp->t_pgrp == pgrp)
245                 pgrp->pg_session->s_ttyp->t_pgrp = NULL;
246         LIST_REMOVE(pgrp, pg_hash);
247         if (--pgrp->pg_session->s_count == 0)
248                 FREE(pgrp->pg_session, M_SESSION);
249         FREE(pgrp, M_PGRP);
250 }
251
252 /*
253  * Adjust pgrp jobc counters when specified process changes process group.
254  * We count the number of processes in each process group that "qualify"
255  * the group for terminal job control (those with a parent in a different
256  * process group of the same session).  If that count reaches zero, the
257  * process group becomes orphaned.  Check both the specified process'
258  * process group and that of its children.
259  * entering == 0 => p is leaving specified group.
260  * entering == 1 => p is entering specified group.
261  */
262 void
263 fixjobc(p, pgrp, entering)
264         register struct proc *p;
265         register struct pgrp *pgrp;
266         int entering;
267 {
268         register struct pgrp *hispgrp;
269         register struct session *mysession = pgrp->pg_session;
270
271         /*
272          * Check p's parent to see whether p qualifies its own process
273          * group; if so, adjust count for p's process group.
274          */
275         if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
276             hispgrp->pg_session == mysession) {
277                 if (entering)
278                         pgrp->pg_jobc++;
279                 else if (--pgrp->pg_jobc == 0)
280                         orphanpg(pgrp);
281         }
282
283         /*
284          * Check this process' children to see whether they qualify
285          * their process groups; if so, adjust counts for children's
286          * process groups.
287          */
288         LIST_FOREACH(p, &p->p_children, p_sibling)
289                 if ((hispgrp = p->p_pgrp) != pgrp &&
290                     hispgrp->pg_session == mysession &&
291                     p->p_stat != SZOMB) {
292                         if (entering)
293                                 hispgrp->pg_jobc++;
294                         else if (--hispgrp->pg_jobc == 0)
295                                 orphanpg(hispgrp);
296                 }
297 }
298
299 /*
300  * A process group has become orphaned;
301  * if there are any stopped processes in the group,
302  * hang-up all process in that group.
303  */
304 static void
305 orphanpg(pg)
306         struct pgrp *pg;
307 {
308         register struct proc *p;
309
310         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
311                 if (p->p_stat == SSTOP) {
312                         LIST_FOREACH(p, &pg->pg_members, p_pglist) {
313                                 psignal(p, SIGHUP);
314                                 psignal(p, SIGCONT);
315                         }
316                         return;
317                 }
318         }
319 }
320
321 #include "opt_ddb.h"
322 #ifdef DDB
323 #include <ddb/ddb.h>
324
325 DB_SHOW_COMMAND(pgrpdump, pgrpdump)
326 {
327         register struct pgrp *pgrp;
328         register struct proc *p;
329         register int i;
330
331         for (i = 0; i <= pgrphash; i++) {
332                 if (!LIST_EMPTY(&pgrphashtbl[i])) {
333                         printf("\tindx %d\n", i);
334                         LIST_FOREACH(pgrp, &pgrphashtbl[i], pg_hash) {
335                                 printf(
336                         "\tpgrp %p, pgid %ld, sess %p, sesscnt %d, mem %p\n",
337                                     (void *)pgrp, (long)pgrp->pg_id,
338                                     (void *)pgrp->pg_session,
339                                     pgrp->pg_session->s_count,
340                                     (void *)LIST_FIRST(&pgrp->pg_members));
341                                 LIST_FOREACH(p, &pgrp->pg_members, p_pglist) {
342                                         printf("\t\tpid %ld addr %p pgrp %p\n", 
343                                             (long)p->p_pid, (void *)p,
344                                             (void *)p->p_pgrp);
345                                 }
346                         }
347                 }
348         }
349 }
350 #endif /* DDB */
351
352 /*
353  * Fill in an eproc structure for the specified process.
354  */
355 void
356 fill_eproc(p, ep)
357         register struct proc *p;
358         register struct eproc *ep;
359 {
360         register struct tty *tp;
361
362         bzero(ep, sizeof(*ep));
363
364         ep->e_paddr = p;
365         if (p->p_ucred) {
366                 ep->e_ucred = *p->p_ucred;
367         }
368         if (p->p_procsig) {
369                 ep->e_procsig = *p->p_procsig;
370         }
371         if (p->p_stat != SIDL && p->p_stat != SZOMB && p->p_vmspace != NULL) {
372                 register struct vmspace *vm = p->p_vmspace;
373                 ep->e_vm = *vm;
374                 ep->e_vm.vm_rssize = vmspace_resident_count(vm); /*XXX*/
375         }
376         if ((p->p_flag & P_INMEM) && p->p_stats)
377                 ep->e_stats = *p->p_stats;
378         if (p->p_pptr)
379                 ep->e_ppid = p->p_pptr->p_pid;
380         if (p->p_pgrp) {
381                 ep->e_pgid = p->p_pgrp->pg_id;
382                 ep->e_jobc = p->p_pgrp->pg_jobc;
383                 ep->e_sess = p->p_pgrp->pg_session;
384
385                 if (ep->e_sess) {
386                         bcopy(ep->e_sess->s_login, ep->e_login, sizeof(ep->e_login));
387                         if (ep->e_sess->s_ttyvp)
388                                 ep->e_flag = EPROC_CTTY;
389                         if (p->p_session && SESS_LEADER(p))
390                                 ep->e_flag |= EPROC_SLEADER;
391                 }
392         }
393         if ((p->p_flag & P_CONTROLT) &&
394             (ep->e_sess != NULL) &&
395             ((tp = ep->e_sess->s_ttyp) != NULL)) {
396                 ep->e_tdev = dev2udev(tp->t_dev);
397                 ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
398                 ep->e_tsess = tp->t_session;
399         } else
400                 ep->e_tdev = NOUDEV;
401         if (p->p_wmesg) {
402                 strncpy(ep->e_wmesg, p->p_wmesg, WMESGLEN);
403                 ep->e_wmesg[WMESGLEN] = 0;
404         }
405 }
406
407 struct proc *
408 zpfind(pid_t pid)
409 {
410         struct proc *p;
411
412         LIST_FOREACH(p, &zombproc, p_list)
413                 if (p->p_pid == pid)
414                         return (p);
415         return (NULL);
416 }
417
418
419 static int
420 sysctl_out_proc(struct proc *p, struct sysctl_req *req, int doingzomb)
421 {
422         struct eproc eproc;
423         int error;
424         pid_t pid = p->p_pid;
425
426         fill_eproc(p, &eproc);
427         error = SYSCTL_OUT(req,(caddr_t)p, sizeof(struct proc));
428         if (error)
429                 return (error);
430         error = SYSCTL_OUT(req,(caddr_t)&eproc, sizeof(eproc));
431         if (error)
432                 return (error);
433         if (!doingzomb && pid && (pfind(pid) != p))
434                 return EAGAIN;
435         if (doingzomb && zpfind(pid) != p)
436                 return EAGAIN;
437         return (0);
438 }
439
440 static int
441 sysctl_kern_proc(SYSCTL_HANDLER_ARGS)
442 {
443         int *name = (int*) arg1;
444         u_int namelen = arg2;
445         struct proc *p;
446         int doingzomb;
447         int error = 0;
448         struct ucred *cr1 = curproc->p_ucred;
449
450         if (oidp->oid_number == KERN_PROC_PID) {
451                 if (namelen != 1) 
452                         return (EINVAL);
453                 p = pfind((pid_t)name[0]);
454                 if (!p)
455                         return (0);
456                 if (!PRISON_CHECK(cr1, p->p_ucred))
457                         return (0);
458                 error = sysctl_out_proc(p, req, 0);
459                 return (error);
460         }
461         if (oidp->oid_number == KERN_PROC_ALL && !namelen)
462                 ;
463         else if (oidp->oid_number != KERN_PROC_ALL && namelen == 1)
464                 ;
465         else
466                 return (EINVAL);
467         
468         if (!req->oldptr) {
469                 /* overestimate by 5 procs */
470                 error = SYSCTL_OUT(req, 0, sizeof (struct kinfo_proc) * 5);
471                 if (error)
472                         return (error);
473         }
474         for (doingzomb=0 ; doingzomb < 2 ; doingzomb++) {
475                 if (!doingzomb)
476                         p = LIST_FIRST(&allproc);
477                 else
478                         p = LIST_FIRST(&zombproc);
479                 for (; p != 0; p = LIST_NEXT(p, p_list)) {
480                         /*
481                          * Show a user only their processes.
482                          */
483                         if ((!ps_showallprocs) && p_trespass(cr1, p->p_ucred))
484                                 continue;
485                         /*
486                          * Skip embryonic processes.
487                          */
488                         if (p->p_stat == SIDL)
489                                 continue;
490                         /*
491                          * TODO - make more efficient (see notes below).
492                          * do by session.
493                          */
494                         switch (oidp->oid_number) {
495
496                         case KERN_PROC_PGRP:
497                                 /* could do this by traversing pgrp */
498                                 if (p->p_pgrp == NULL || 
499                                     p->p_pgrp->pg_id != (pid_t)name[0])
500                                         continue;
501                                 break;
502
503                         case KERN_PROC_TTY:
504                                 if ((p->p_flag & P_CONTROLT) == 0 ||
505                                     p->p_session == NULL ||
506                                     p->p_session->s_ttyp == NULL ||
507                                     dev2udev(p->p_session->s_ttyp->t_dev) != 
508                                         (udev_t)name[0])
509                                         continue;
510                                 break;
511
512                         case KERN_PROC_UID:
513                                 if (p->p_ucred == NULL || 
514                                     p->p_ucred->cr_uid != (uid_t)name[0])
515                                         continue;
516                                 break;
517
518                         case KERN_PROC_RUID:
519                                 if (p->p_ucred == NULL || 
520                                     p->p_ucred->cr_ruid != (uid_t)name[0])
521                                         continue;
522                                 break;
523                         }
524
525                         if (!PRISON_CHECK(cr1, p->p_ucred))
526                                 continue;
527
528                         error = sysctl_out_proc(p, req, doingzomb);
529                         if (error)
530                                 return (error);
531                 }
532         }
533         return (0);
534 }
535
536 /*
537  * This sysctl allows a process to retrieve the argument list or process
538  * title for another process without groping around in the address space
539  * of the other process.  It also allow a process to set its own "process 
540  * title to a string of its own choice.
541  */
542 static int
543 sysctl_kern_proc_args(SYSCTL_HANDLER_ARGS)
544 {
545         int *name = (int*) arg1;
546         u_int namelen = arg2;
547         struct proc *p;
548         struct pargs *pa;
549         int error = 0;
550         struct ucred *cr1 = curproc->p_ucred;
551
552         if (namelen != 1) 
553                 return (EINVAL);
554
555         p = pfind((pid_t)name[0]);
556         if (!p)
557                 return (0);
558
559         if ((!ps_argsopen) && p_trespass(cr1, p->p_ucred))
560                 return (0);
561
562         if (req->newptr && curproc != p)
563                 return (EPERM);
564
565         if (req->oldptr && p->p_args != NULL)
566                 error = SYSCTL_OUT(req, p->p_args->ar_args, p->p_args->ar_length);
567         if (req->newptr == NULL)
568                 return (error);
569
570         if (p->p_args && --p->p_args->ar_ref == 0) 
571                 FREE(p->p_args, M_PARGS);
572         p->p_args = NULL;
573
574         if (req->newlen + sizeof(struct pargs) > ps_arg_cache_limit)
575                 return (error);
576
577         MALLOC(pa, struct pargs *, sizeof(struct pargs) + req->newlen, 
578             M_PARGS, M_WAITOK);
579         pa->ar_ref = 1;
580         pa->ar_length = req->newlen;
581         error = SYSCTL_IN(req, pa->ar_args, req->newlen);
582         if (!error)
583                 p->p_args = pa;
584         else
585                 FREE(pa, M_PARGS);
586         return (error);
587 }
588
589 SYSCTL_NODE(_kern, KERN_PROC, proc, CTLFLAG_RD,  0, "Process table");
590
591 SYSCTL_PROC(_kern_proc, KERN_PROC_ALL, all, CTLFLAG_RD|CTLTYPE_STRUCT,
592         0, 0, sysctl_kern_proc, "S,proc", "Return entire process table");
593
594 SYSCTL_NODE(_kern_proc, KERN_PROC_PGRP, pgrp, CTLFLAG_RD, 
595         sysctl_kern_proc, "Process table");
596
597 SYSCTL_NODE(_kern_proc, KERN_PROC_TTY, tty, CTLFLAG_RD, 
598         sysctl_kern_proc, "Process table");
599
600 SYSCTL_NODE(_kern_proc, KERN_PROC_UID, uid, CTLFLAG_RD, 
601         sysctl_kern_proc, "Process table");
602
603 SYSCTL_NODE(_kern_proc, KERN_PROC_RUID, ruid, CTLFLAG_RD, 
604         sysctl_kern_proc, "Process table");
605
606 SYSCTL_NODE(_kern_proc, KERN_PROC_PID, pid, CTLFLAG_RD, 
607         sysctl_kern_proc, "Process table");
608
609 SYSCTL_NODE(_kern_proc, KERN_PROC_ARGS, args, CTLFLAG_RW | CTLFLAG_ANYBODY,
610         sysctl_kern_proc_args, "Process argument list");