kern_proc.c revision 1.65 1 /* $NetBSD: kern_proc.c,v 1.65 2003/08/07 16:31:47 agc Exp $ */
2
3 /*-
4 * Copyright (c) 1999 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9 * NASA Ames Research Center.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40 /*
41 * Copyright (c) 1982, 1986, 1989, 1991, 1993
42 * The Regents of the University of California. All rights reserved.
43 *
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
46 * are met:
47 * 1. Redistributions of source code must retain the above copyright
48 * notice, this list of conditions and the following disclaimer.
49 * 2. Redistributions in binary form must reproduce the above copyright
50 * notice, this list of conditions and the following disclaimer in the
51 * documentation and/or other materials provided with the distribution.
52 * 3. Neither the name of the University nor the names of its contributors
53 * may be used to endorse or promote products derived from this software
54 * without specific prior written permission.
55 *
56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
66 * SUCH DAMAGE.
67 *
68 * @(#)kern_proc.c 8.7 (Berkeley) 2/14/95
69 */
70
71 #include <sys/cdefs.h>
72 __KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.65 2003/08/07 16:31:47 agc Exp $");
73
74 #include "opt_kstack.h"
75
76 #include <sys/param.h>
77 #include <sys/systm.h>
78 #include <sys/kernel.h>
79 #include <sys/proc.h>
80 #include <sys/resourcevar.h>
81 #include <sys/buf.h>
82 #include <sys/acct.h>
83 #include <sys/wait.h>
84 #include <sys/file.h>
85 #include <ufs/ufs/quota.h>
86 #include <sys/uio.h>
87 #include <sys/malloc.h>
88 #include <sys/pool.h>
89 #include <sys/mbuf.h>
90 #include <sys/ioctl.h>
91 #include <sys/tty.h>
92 #include <sys/signalvar.h>
93 #include <sys/ras.h>
94 #include <sys/sa.h>
95 #include <sys/savar.h>
96
97 static void pg_delete(pid_t);
98
99 /*
100 * Structure associated with user cacheing.
101 */
102 struct uidinfo {
103 LIST_ENTRY(uidinfo) ui_hash;
104 uid_t ui_uid;
105 long ui_proccnt;
106 };
107 #define UIHASH(uid) (&uihashtbl[(uid) & uihash])
108 LIST_HEAD(uihashhead, uidinfo) *uihashtbl;
109 u_long uihash; /* size of hash table - 1 */
110
111 /*
112 * Other process lists
113 */
114
115 struct proclist allproc;
116 struct proclist zombproc; /* resources have been freed */
117
118
119 /*
120 * Process list locking:
121 *
122 * We have two types of locks on the proclists: read locks and write
123 * locks. Read locks can be used in interrupt context, so while we
124 * hold the write lock, we must also block clock interrupts to
125 * lock out any scheduling changes that may happen in interrupt
126 * context.
127 *
128 * The proclist lock locks the following structures:
129 *
130 * allproc
131 * zombproc
132 * pid_table
133 */
134 struct lock proclist_lock;
135
136 /*
137 * List of processes that has called exit, but need to be reaped.
138 * Locking of this proclist is special; it's accessed in a
139 * critical section of process exit, and thus locking it can't
140 * modify interrupt state.
141 * We use a simple spin lock for this proclist.
142 * Processes on this proclist are also on zombproc.
143 */
144 struct simplelock deadproc_slock;
145 struct deadprocs deadprocs = SLIST_HEAD_INITIALIZER(deadprocs);
146
147 /*
148 * pid to proc lookup is done by indexing the pid_table array.
149 * Since pid numbers are only allocated when an empty slot
150 * has been found, there is no need to search any lists ever.
151 * (an orphaned pgrp will lock the slot, a session will lock
152 * the pgrp with the same number.)
153 * If the table is too small it is reallocated with twice the
154 * previous size and the entries 'unzipped' into the two halves.
155 * A linked list of free entries is passed through the pt_proc
156 * field of 'free' items - set odd to be an invalid ptr.
157 */
158
159 struct pid_table {
160 struct proc *pt_proc;
161 struct pgrp *pt_pgrp;
162 };
163 #if 1 /* strongly typed cast - should be a noop */
164 static __inline uint p2u(struct proc *p) { return (uint)(uintptr_t)p; };
165 #else
166 #define p2u(p) ((uint)p)
167 #endif
168 #define P_VALID(p) (!(p2u(p) & 1))
169 #define P_NEXT(p) (p2u(p) >> 1)
170 #define P_FREE(pid) ((struct proc *)(uintptr_t)((pid) << 1 | 1))
171
172 #define INITIAL_PID_TABLE_SIZE (1 << 5)
173 static struct pid_table *pid_table;
174 static uint pid_tbl_mask = INITIAL_PID_TABLE_SIZE - 1;
175 static uint pid_alloc_lim; /* max we allocate before growing table */
176 static uint pid_alloc_cnt; /* number of allocated pids */
177
178 /* links through free slots - never empty! */
179 static uint next_free_pt, last_free_pt;
180 static pid_t pid_max = PID_MAX; /* largest value we allocate */
181
182 struct pool proc_pool;
183 struct pool lwp_pool;
184 struct pool lwp_uc_pool;
185 struct pool pcred_pool;
186 struct pool plimit_pool;
187 struct pool pstats_pool;
188 struct pool pgrp_pool;
189 struct pool rusage_pool;
190 struct pool ras_pool;
191 struct pool sadata_pool;
192 struct pool saupcall_pool;
193 struct pool ptimer_pool;
194
195 MALLOC_DEFINE(M_EMULDATA, "emuldata", "Per-process emulation data");
196 MALLOC_DEFINE(M_PROC, "proc", "Proc structures");
197 MALLOC_DEFINE(M_SESSION, "session", "session header");
198 MALLOC_DEFINE(M_SUBPROC, "subproc", "Proc sub-structures");
199
200 /*
201 * The process list descriptors, used during pid allocation and
202 * by sysctl. No locking on this data structure is needed since
203 * it is completely static.
204 */
205 const struct proclist_desc proclists[] = {
206 { &allproc },
207 { &zombproc },
208 { NULL },
209 };
210
211 static void orphanpg __P((struct pgrp *));
212 #ifdef DEBUG
213 void pgrpdump __P((void));
214 #endif
215
216 /*
217 * Initialize global process hashing structures.
218 */
219 void
220 procinit(void)
221 {
222 const struct proclist_desc *pd;
223 int i;
224 #define LINK_EMPTY ((PID_MAX + INITIAL_PID_TABLE_SIZE) & ~(INITIAL_PID_TABLE_SIZE - 1))
225
226 for (pd = proclists; pd->pd_list != NULL; pd++)
227 LIST_INIT(pd->pd_list);
228
229 spinlockinit(&proclist_lock, "proclk", 0);
230
231 simple_lock_init(&deadproc_slock);
232
233 pid_table = malloc(INITIAL_PID_TABLE_SIZE * sizeof *pid_table,
234 M_PROC, M_WAITOK);
235 /* Set free list running through table...
236 Preset 'use count' above PID_MAX so we allocate pid 1 next. */
237 for (i = 0; i <= pid_tbl_mask; i++) {
238 pid_table[i].pt_proc = P_FREE(LINK_EMPTY + i + 1);
239 pid_table[i].pt_pgrp = 0;
240 }
241 /* slot 0 is just grabbed */
242 next_free_pt = 1;
243 /* Need to fix last entry. */
244 last_free_pt = pid_tbl_mask;
245 pid_table[last_free_pt].pt_proc = P_FREE(LINK_EMPTY);
246 /* point at which we grow table - to avoid reusing pids too often */
247 pid_alloc_lim = pid_tbl_mask - 1;
248 #undef LINK_EMPTY
249
250 LIST_INIT(&alllwp);
251 LIST_INIT(&deadlwp);
252 LIST_INIT(&zomblwp);
253
254 uihashtbl =
255 hashinit(maxproc / 16, HASH_LIST, M_PROC, M_WAITOK, &uihash);
256
257 pool_init(&proc_pool, sizeof(struct proc), 0, 0, 0, "procpl",
258 &pool_allocator_nointr);
259 pool_init(&lwp_pool, sizeof(struct lwp), 0, 0, 0, "lwppl",
260 &pool_allocator_nointr);
261 pool_init(&lwp_uc_pool, sizeof(ucontext_t), 0, 0, 0, "lwpucpl",
262 &pool_allocator_nointr);
263 pool_init(&pgrp_pool, sizeof(struct pgrp), 0, 0, 0, "pgrppl",
264 &pool_allocator_nointr);
265 pool_init(&pcred_pool, sizeof(struct pcred), 0, 0, 0, "pcredpl",
266 &pool_allocator_nointr);
267 pool_init(&plimit_pool, sizeof(struct plimit), 0, 0, 0, "plimitpl",
268 &pool_allocator_nointr);
269 pool_init(&pstats_pool, sizeof(struct pstats), 0, 0, 0, "pstatspl",
270 &pool_allocator_nointr);
271 pool_init(&rusage_pool, sizeof(struct rusage), 0, 0, 0, "rusgepl",
272 &pool_allocator_nointr);
273 pool_init(&ras_pool, sizeof(struct ras), 0, 0, 0, "raspl",
274 &pool_allocator_nointr);
275 pool_init(&sadata_pool, sizeof(struct sadata), 0, 0, 0, "sadatapl",
276 &pool_allocator_nointr);
277 pool_init(&saupcall_pool, sizeof(struct sadata_upcall), 0, 0, 0,
278 "saupcpl",
279 &pool_allocator_nointr);
280 pool_init(&ptimer_pool, sizeof(struct ptimer), 0, 0, 0, "ptimerpl",
281 &pool_allocator_nointr);
282 }
283
284 /*
285 * Acquire a read lock on the proclist.
286 */
287 void
288 proclist_lock_read(void)
289 {
290 int error;
291
292 error = spinlockmgr(&proclist_lock, LK_SHARED, NULL);
293 #ifdef DIAGNOSTIC
294 if (__predict_false(error != 0))
295 panic("proclist_lock_read: failed to acquire lock");
296 #endif
297 }
298
299 /*
300 * Release a read lock on the proclist.
301 */
302 void
303 proclist_unlock_read(void)
304 {
305
306 (void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
307 }
308
309 /*
310 * Acquire a write lock on the proclist.
311 */
312 int
313 proclist_lock_write(void)
314 {
315 int s, error;
316
317 s = splclock();
318 error = spinlockmgr(&proclist_lock, LK_EXCLUSIVE, NULL);
319 #ifdef DIAGNOSTIC
320 if (__predict_false(error != 0))
321 panic("proclist_lock: failed to acquire lock");
322 #endif
323 return (s);
324 }
325
326 /*
327 * Release a write lock on the proclist.
328 */
329 void
330 proclist_unlock_write(int s)
331 {
332
333 (void) spinlockmgr(&proclist_lock, LK_RELEASE, NULL);
334 splx(s);
335 }
336
337 /*
338 * Change the count associated with number of processes
339 * a given user is using.
340 */
341 int
342 chgproccnt(uid_t uid, int diff)
343 {
344 struct uidinfo *uip;
345 struct uihashhead *uipp;
346
347 uipp = UIHASH(uid);
348
349 LIST_FOREACH(uip, uipp, ui_hash)
350 if (uip->ui_uid == uid)
351 break;
352
353 if (uip) {
354 uip->ui_proccnt += diff;
355 if (uip->ui_proccnt > 0)
356 return (uip->ui_proccnt);
357 if (uip->ui_proccnt < 0)
358 panic("chgproccnt: procs < 0");
359 LIST_REMOVE(uip, ui_hash);
360 FREE(uip, M_PROC);
361 return (0);
362 }
363 if (diff <= 0) {
364 if (diff == 0)
365 return(0);
366 panic("chgproccnt: lost user");
367 }
368 MALLOC(uip, struct uidinfo *, sizeof(*uip), M_PROC, M_WAITOK);
369 LIST_INSERT_HEAD(uipp, uip, ui_hash);
370 uip->ui_uid = uid;
371 uip->ui_proccnt = diff;
372 return (diff);
373 }
374
375 /*
376 * Check that the specifies process group in in the session of the
377 * specified process.
378 * Treats -ve ids as process ids.
379 * Used to validate TIOCSPGRP requests.
380 */
381 int
382 pgid_in_session(struct proc *p, pid_t pg_id)
383 {
384 struct pgrp *pgrp;
385
386 if (pg_id < 0) {
387 struct proc *p1 = pfind(-pg_id);
388 if (p1 == NULL)
389 return EINVAL;
390 pgrp = p1->p_pgrp;
391 } else {
392 pgrp = pgfind(pg_id);
393 if (pgrp == NULL)
394 return EINVAL;
395 }
396 if (pgrp->pg_session != p->p_pgrp->pg_session)
397 return EPERM;
398 return 0;
399 }
400
401 /*
402 * Is p an inferior of q?
403 */
404 int
405 inferior(struct proc *p, struct proc *q)
406 {
407
408 for (; p != q; p = p->p_pptr)
409 if (p->p_pid == 0)
410 return (0);
411 return (1);
412 }
413
414 /*
415 * Locate a process by number
416 */
417 struct proc *
418 pfind(pid_t pid)
419 {
420 struct proc *p;
421
422 proclist_lock_read();
423 p = pid_table[pid & pid_tbl_mask].pt_proc;
424 /* Only allow live processes to be found by pid. */
425 if (!P_VALID(p) || p->p_pid != pid ||
426 !((1 << SACTIVE | 1 << SSTOP) & 1 << p->p_stat))
427 p = 0;
428
429 /* XXX MP - need to have a reference count... */
430 proclist_unlock_read();
431 return p;
432 }
433
434
435 /*
436 * Locate a process group by number
437 */
438 struct pgrp *
439 pgfind(pid_t pgid)
440 {
441 struct pgrp *pgrp;
442
443 proclist_lock_read();
444 pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp;
445 /*
446 * Can't look up a pgrp that only exists because the session
447 * hasn't died yet (traditional)
448 */
449 if (pgrp == NULL || pgrp->pg_id != pgid
450 || LIST_EMPTY(&pgrp->pg_members))
451 pgrp = 0;
452
453 /* XXX MP - need to have a reference count... */
454 proclist_unlock_read();
455 return pgrp;
456 }
457
458 /*
459 * Set entry for process 0
460 */
461 void
462 proc0_insert(struct proc *p, struct lwp *l, struct pgrp *pgrp,
463 struct session *sess)
464 {
465 int s;
466
467 LIST_INIT(&p->p_lwps);
468 LIST_INSERT_HEAD(&p->p_lwps, l, l_sibling);
469 p->p_nlwps = 1;
470
471 s = proclist_lock_write();
472
473 pid_table[0].pt_proc = p;
474 LIST_INSERT_HEAD(&allproc, p, p_list);
475 LIST_INSERT_HEAD(&alllwp, l, l_list);
476
477 p->p_pgrp = pgrp;
478 pid_table[0].pt_pgrp = pgrp;
479 LIST_INIT(&pgrp->pg_members);
480 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
481
482 pgrp->pg_session = sess;
483 sess->s_count = 1;
484 sess->s_sid = 0;
485 sess->s_leader = p;
486
487 proclist_unlock_write(s);
488 }
489
490 static void
491 expand_pid_table(void)
492 {
493 uint pt_size = pid_tbl_mask + 1;
494 struct pid_table *n_pt, *new_pt;
495 struct proc *proc;
496 struct pgrp *pgrp;
497 int i;
498 int s;
499 pid_t pid;
500
501 new_pt = malloc(pt_size * 2 * sizeof *new_pt, M_PROC, M_WAITOK);
502
503 s = proclist_lock_write();
504 if (pt_size != pid_tbl_mask + 1) {
505 /* Another process beat us to it... */
506 proclist_unlock_write(s);
507 FREE(new_pt, M_PROC);
508 return;
509 }
510
511 /*
512 * Copy entries from old table into new one.
513 * If 'pid' is 'odd' we need to place in the upper half,
514 * even pid's to the lower half.
515 * Free items stay in the low half so we don't have to
516 * fixup the reference to them.
517 * We stuff free items on the front of the freelist
518 * because we can't write to unmodified entries.
519 * Processing the table backwards maintians a semblance
520 * of issueing pid numbers that increase with time.
521 */
522 i = pt_size - 1;
523 n_pt = new_pt + i;
524 for (; ; i--, n_pt--) {
525 proc = pid_table[i].pt_proc;
526 pgrp = pid_table[i].pt_pgrp;
527 if (!P_VALID(proc)) {
528 /* Up 'use count' so that link is valid */
529 pid = (P_NEXT(proc) + pt_size) & ~pt_size;
530 proc = P_FREE(pid);
531 if (pgrp)
532 pid = pgrp->pg_id;
533 } else
534 pid = proc->p_pid;
535
536 /* Save entry in appropriate half of table */
537 n_pt[pid & pt_size].pt_proc = proc;
538 n_pt[pid & pt_size].pt_pgrp = pgrp;
539
540 /* Put other piece on start of free list */
541 pid = (pid ^ pt_size) & ~pid_tbl_mask;
542 n_pt[pid & pt_size].pt_proc =
543 P_FREE((pid & ~pt_size) | next_free_pt);
544 n_pt[pid & pt_size].pt_pgrp = 0;
545 next_free_pt = i | (pid & pt_size);
546 if (i == 0)
547 break;
548 }
549
550 /* Switch tables */
551 n_pt = pid_table;
552 pid_table = new_pt;
553 pid_tbl_mask = pt_size * 2 - 1;
554
555 /*
556 * pid_max starts as PID_MAX (= 30000), once we have 16384
557 * allocated pids we need it to be larger!
558 */
559 if (pid_tbl_mask > PID_MAX) {
560 pid_max = pid_tbl_mask * 2 + 1;
561 pid_alloc_lim |= pid_alloc_lim << 1;
562 } else
563 pid_alloc_lim <<= 1; /* doubles number of free slots... */
564
565 proclist_unlock_write(s);
566 FREE(n_pt, M_PROC);
567 }
568
569 struct proc *
570 proc_alloc(void)
571 {
572 struct proc *p;
573 int s;
574 int nxt;
575 pid_t pid;
576 struct pid_table *pt;
577
578 p = pool_get(&proc_pool, PR_WAITOK);
579 p->p_stat = SIDL; /* protect against others */
580
581 /* allocate next free pid */
582
583 for (;;expand_pid_table()) {
584 if (__predict_false(pid_alloc_cnt >= pid_alloc_lim))
585 /* ensure pids cycle through 2000+ values */
586 continue;
587 s = proclist_lock_write();
588 pt = &pid_table[next_free_pt];
589 #ifdef DIAGNOSTIC
590 if (__predict_false(P_VALID(pt->pt_proc) || pt->pt_pgrp))
591 panic("proc_alloc: slot busy");
592 #endif
593 nxt = P_NEXT(pt->pt_proc);
594 if (nxt & pid_tbl_mask)
595 break;
596 /* Table full - expand (NB last entry not used....) */
597 proclist_unlock_write(s);
598 }
599
600 /* pid is 'saved use count' + 'size' + entry */
601 pid = (nxt & ~pid_tbl_mask) + pid_tbl_mask + 1 + next_free_pt;
602 if ((uint)pid > (uint)pid_max)
603 pid &= pid_tbl_mask;
604 p->p_pid = pid;
605 next_free_pt = nxt & pid_tbl_mask;
606
607 /* Grab table slot */
608 pt->pt_proc = p;
609 pid_alloc_cnt++;
610
611 proclist_unlock_write(s);
612
613 return p;
614 }
615
616 /*
617 * Free last resources of a process - called from proc_free (in kern_exit.c)
618 */
619 void
620 proc_free_mem(struct proc *p)
621 {
622 int s;
623 pid_t pid = p->p_pid;
624 struct pid_table *pt;
625
626 s = proclist_lock_write();
627
628 pt = &pid_table[pid & pid_tbl_mask];
629 #ifdef DIAGNOSTIC
630 if (__predict_false(pt->pt_proc != p))
631 panic("proc_free: pid_table mismatch, pid %x, proc %p",
632 pid, p);
633 #endif
634 /* save pid use count in slot */
635 pt->pt_proc = P_FREE(pid & ~pid_tbl_mask);
636
637 if (pt->pt_pgrp == NULL) {
638 /* link last freed entry onto ours */
639 pid &= pid_tbl_mask;
640 pt = &pid_table[last_free_pt];
641 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pid);
642 last_free_pt = pid;
643 pid_alloc_cnt--;
644 }
645
646 nprocs--;
647 proclist_unlock_write(s);
648
649 pool_put(&proc_pool, p);
650 }
651
652 /*
653 * Move p to a new or existing process group (and session)
654 *
655 * If we are creating a new pgrp, the pgid should equal
656 * the calling processes pid.
657 * If is only valid to enter a process group that is in the session
658 * of the process.
659 * Also mksess should only be set if we are creating a process group
660 *
661 * Only called from sys_setsid, sys_setpgid/sys_setprp and the
662 * SYSV setpgrp support for hpux == enterpgrp(curproc, curproc->p_pid)
663 */
664 int
665 enterpgrp(struct proc *p, pid_t pgid, int mksess)
666 {
667 struct pgrp *new_pgrp, *pgrp;
668 struct session *sess;
669 struct proc *curp = curproc;
670 pid_t pid = p->p_pid;
671 int rval;
672 int s;
673 pid_t pg_id = NO_PGID;
674
675 /* Allocate data areas we might need before doing any validity checks */
676 proclist_lock_read(); /* Because pid_table might change */
677 if (pid_table[pgid & pid_tbl_mask].pt_pgrp == 0) {
678 proclist_unlock_read();
679 new_pgrp = pool_get(&pgrp_pool, PR_WAITOK);
680 } else {
681 proclist_unlock_read();
682 new_pgrp = NULL;
683 }
684 if (mksess)
685 MALLOC(sess, struct session *, sizeof(struct session),
686 M_SESSION, M_WAITOK);
687 else
688 sess = NULL;
689
690 s = proclist_lock_write();
691 rval = EPERM; /* most common error (to save typing) */
692
693 /* Check pgrp exists or can be created */
694 pgrp = pid_table[pgid & pid_tbl_mask].pt_pgrp;
695 if (pgrp != NULL && pgrp->pg_id != pgid)
696 goto done;
697
698 /* Can only set another process under restricted circumstances. */
699 if (p != curp) {
700 /* must exist and be one of our children... */
701 if (p != pid_table[pid & pid_tbl_mask].pt_proc
702 || !inferior(p, curp)) {
703 rval = ESRCH;
704 goto done;
705 }
706 /* ... in the same session... */
707 if (sess != NULL || p->p_session != curp->p_session)
708 goto done;
709 /* ... existing pgid must be in same session ... */
710 if (pgrp != NULL && pgrp->pg_session != p->p_session)
711 goto done;
712 /* ... and not done an exec. */
713 if (p->p_flag & P_EXEC) {
714 rval = EACCES;
715 goto done;
716 }
717 }
718
719 /* Changing the process group/session of a session
720 leader is definitely off limits. */
721 if (SESS_LEADER(p)) {
722 if (sess == NULL && p->p_pgrp == pgrp)
723 /* unless it's a definite noop */
724 rval = 0;
725 goto done;
726 }
727
728 /* Can only create a process group with id of process */
729 if (pgrp == NULL && pgid != pid)
730 goto done;
731
732 /* Can only create a session if creating pgrp */
733 if (sess != NULL && pgrp != NULL)
734 goto done;
735
736 /* Check we allocated memory for a pgrp... */
737 if (pgrp == NULL && new_pgrp == NULL)
738 goto done;
739
740 /* Don't attach to 'zombie' pgrp */
741 if (pgrp != NULL && LIST_EMPTY(&pgrp->pg_members))
742 goto done;
743
744 /* Expect to succeed now */
745 rval = 0;
746
747 if (pgrp == p->p_pgrp)
748 /* nothing to do */
749 goto done;
750
751 /* Ok all setup, link up required structures */
752 if (pgrp == NULL) {
753 pgrp = new_pgrp;
754 new_pgrp = 0;
755 if (sess != NULL) {
756 sess->s_sid = p->p_pid;
757 sess->s_leader = p;
758 sess->s_count = 1;
759 sess->s_ttyvp = NULL;
760 sess->s_ttyp = NULL;
761 sess->s_flags = p->p_session->s_flags & ~S_LOGIN_SET;
762 memcpy(sess->s_login, p->p_session->s_login,
763 sizeof(sess->s_login));
764 p->p_flag &= ~P_CONTROLT;
765 } else {
766 sess = p->p_pgrp->pg_session;
767 SESSHOLD(sess);
768 }
769 pgrp->pg_session = sess;
770 sess = 0;
771
772 pgrp->pg_id = pgid;
773 LIST_INIT(&pgrp->pg_members);
774 #ifdef DIAGNOSTIC
775 if (__predict_false(pid_table[pgid & pid_tbl_mask].pt_pgrp))
776 panic("enterpgrp: pgrp table slot in use");
777 if (__predict_false(mksess && p != curp))
778 panic("enterpgrp: mksession and p != curproc");
779 #endif
780 pid_table[pgid & pid_tbl_mask].pt_pgrp = pgrp;
781 pgrp->pg_jobc = 0;
782 }
783
784 /*
785 * Adjust eligibility of affected pgrps to participate in job control.
786 * Increment eligibility counts before decrementing, otherwise we
787 * could reach 0 spuriously during the first call.
788 */
789 fixjobc(p, pgrp, 1);
790 fixjobc(p, p->p_pgrp, 0);
791
792 /* Move process to requested group */
793 LIST_REMOVE(p, p_pglist);
794 if (LIST_EMPTY(&p->p_pgrp->pg_members))
795 /* defer delete until we've dumped the lock */
796 pg_id = p->p_pgrp->pg_id;
797 p->p_pgrp = pgrp;
798 LIST_INSERT_HEAD(&pgrp->pg_members, p, p_pglist);
799
800 done:
801 proclist_unlock_write(s);
802 if (sess != NULL)
803 free(sess, M_SESSION);
804 if (new_pgrp != NULL)
805 pool_put(&pgrp_pool, new_pgrp);
806 if (pg_id != NO_PGID)
807 pg_delete(pg_id);
808 #ifdef DEBUG_PGRP
809 if (__predict_false(rval))
810 printf("enterpgrp(%d,%d,%d), curproc %d, rval %d\n",
811 pid, pgid, mksess, curp->p_pid, rval);
812 #endif
813 return rval;
814 }
815
816 /*
817 * remove process from process group
818 */
819 int
820 leavepgrp(struct proc *p)
821 {
822 int s = proclist_lock_write();
823 struct pgrp *pgrp;
824 pid_t pg_id;
825
826 pgrp = p->p_pgrp;
827 LIST_REMOVE(p, p_pglist);
828 p->p_pgrp = 0;
829 pg_id = LIST_EMPTY(&pgrp->pg_members) ? pgrp->pg_id : NO_PGID;
830 proclist_unlock_write(s);
831
832 if (pg_id != NO_PGID)
833 pg_delete(pg_id);
834 return 0;
835 }
836
837 static void
838 pg_free(pid_t pg_id)
839 {
840 struct pgrp *pgrp;
841 struct pid_table *pt;
842 int s;
843
844 s = proclist_lock_write();
845 pt = &pid_table[pg_id & pid_tbl_mask];
846 pgrp = pt->pt_pgrp;
847 #ifdef DIAGNOSTIC
848 if (__predict_false(!pgrp || pgrp->pg_id != pg_id
849 || !LIST_EMPTY(&pgrp->pg_members)))
850 panic("pg_free: process group absent or has members");
851 #endif
852 pt->pt_pgrp = 0;
853
854 if (!P_VALID(pt->pt_proc)) {
855 /* orphaned pgrp, put slot onto free list */
856 #ifdef DIAGNOSTIC
857 if (__predict_false(P_NEXT(pt->pt_proc) & pid_tbl_mask))
858 panic("pg_free: process slot on free list");
859 #endif
860
861 pg_id &= pid_tbl_mask;
862 pt = &pid_table[last_free_pt];
863 pt->pt_proc = P_FREE(P_NEXT(pt->pt_proc) | pg_id);
864 last_free_pt = pg_id;
865 pid_alloc_cnt--;
866 }
867 proclist_unlock_write(s);
868
869 pool_put(&pgrp_pool, pgrp);
870 }
871
872 /*
873 * delete a process group
874 */
875 static void
876 pg_delete(pid_t pg_id)
877 {
878 struct pgrp *pgrp;
879 struct tty *ttyp;
880 struct session *ss;
881 int s;
882
883 s = proclist_lock_write();
884 pgrp = pid_table[pg_id & pid_tbl_mask].pt_pgrp;
885 if (pgrp == NULL || pgrp->pg_id != pg_id ||
886 !LIST_EMPTY(&pgrp->pg_members)) {
887 proclist_unlock_write(s);
888 return;
889 }
890
891 /* Remove reference (if any) from tty to this process group */
892 ttyp = pgrp->pg_session->s_ttyp;
893 if (ttyp != NULL && ttyp->t_pgrp == pgrp)
894 ttyp->t_pgrp = NULL;
895
896 ss = pgrp->pg_session;
897
898 if (ss->s_sid == pgrp->pg_id) {
899 proclist_unlock_write(s);
900 SESSRELE(ss);
901 /* pgrp freed by sessdelete() if last reference */
902 return;
903 }
904
905 proclist_unlock_write(s);
906 SESSRELE(ss);
907 pg_free(pg_id);
908 }
909
910 /*
911 * Delete session - called from SESSRELE when s_count becomes zero.
912 */
913 void
914 sessdelete(struct session *ss)
915 {
916 /*
917 * We keep the pgrp with the same id as the session in
918 * order to stop a process being given the same pid.
919 * Since the pgrp holds a reference to the session, it
920 * must be a 'zombie' pgrp by now.
921 */
922
923 pg_free(ss->s_sid);
924
925 FREE(ss, M_SESSION);
926 }
927
928 /*
929 * Adjust pgrp jobc counters when specified process changes process group.
930 * We count the number of processes in each process group that "qualify"
931 * the group for terminal job control (those with a parent in a different
932 * process group of the same session). If that count reaches zero, the
933 * process group becomes orphaned. Check both the specified process'
934 * process group and that of its children.
935 * entering == 0 => p is leaving specified group.
936 * entering == 1 => p is entering specified group.
937 */
938 void
939 fixjobc(struct proc *p, struct pgrp *pgrp, int entering)
940 {
941 struct pgrp *hispgrp;
942 struct session *mysession = pgrp->pg_session;
943
944 /*
945 * Check p's parent to see whether p qualifies its own process
946 * group; if so, adjust count for p's process group.
947 */
948 if ((hispgrp = p->p_pptr->p_pgrp) != pgrp &&
949 hispgrp->pg_session == mysession) {
950 if (entering)
951 pgrp->pg_jobc++;
952 else if (--pgrp->pg_jobc == 0)
953 orphanpg(pgrp);
954 }
955
956 /*
957 * Check this process' children to see whether they qualify
958 * their process groups; if so, adjust counts for children's
959 * process groups.
960 */
961 LIST_FOREACH(p, &p->p_children, p_sibling) {
962 if ((hispgrp = p->p_pgrp) != pgrp &&
963 hispgrp->pg_session == mysession &&
964 P_ZOMBIE(p) == 0) {
965 if (entering)
966 hispgrp->pg_jobc++;
967 else if (--hispgrp->pg_jobc == 0)
968 orphanpg(hispgrp);
969 }
970 }
971 }
972
973 /*
974 * A process group has become orphaned;
975 * if there are any stopped processes in the group,
976 * hang-up all process in that group.
977 */
978 static void
979 orphanpg(struct pgrp *pg)
980 {
981 struct proc *p;
982
983 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
984 if (p->p_stat == SSTOP) {
985 LIST_FOREACH(p, &pg->pg_members, p_pglist) {
986 psignal(p, SIGHUP);
987 psignal(p, SIGCONT);
988 }
989 return;
990 }
991 }
992 }
993
994 /* mark process as suid/sgid, reset some values to defaults */
995 void
996 p_sugid(struct proc *p)
997 {
998 struct plimit *newlim;
999
1000 p->p_flag |= P_SUGID;
1001 /* reset what needs to be reset in plimit */
1002 if (p->p_limit->pl_corename != defcorename) {
1003 if (p->p_limit->p_refcnt > 1 &&
1004 (p->p_limit->p_lflags & PL_SHAREMOD) == 0) {
1005 newlim = limcopy(p->p_limit);
1006 limfree(p->p_limit);
1007 p->p_limit = newlim;
1008 }
1009 free(p->p_limit->pl_corename, M_TEMP);
1010 p->p_limit->pl_corename = defcorename;
1011 }
1012 }
1013
1014 #ifdef DDB
1015 #include <ddb/db_output.h>
1016 void pidtbl_dump(void);
1017 void
1018 pidtbl_dump(void)
1019 {
1020 struct pid_table *pt;
1021 struct proc *p;
1022 struct pgrp *pgrp;
1023 int id;
1024
1025 db_printf("pid table %p size %x, next %x, last %x\n",
1026 pid_table, pid_tbl_mask+1,
1027 next_free_pt, last_free_pt);
1028 for (pt = pid_table, id = 0; id <= pid_tbl_mask; id++, pt++) {
1029 p = pt->pt_proc;
1030 if (!P_VALID(p) && !pt->pt_pgrp)
1031 continue;
1032 db_printf(" id %x: ", id);
1033 if (P_VALID(p))
1034 db_printf("proc %p id %d (0x%x) %s\n",
1035 p, p->p_pid, p->p_pid, p->p_comm);
1036 else
1037 db_printf("next %x use %x\n",
1038 P_NEXT(p) & pid_tbl_mask,
1039 P_NEXT(p) & ~pid_tbl_mask);
1040 if ((pgrp = pt->pt_pgrp)) {
1041 db_printf("\tsession %p, sid %d, count %d, login %s\n",
1042 pgrp->pg_session, pgrp->pg_session->s_sid,
1043 pgrp->pg_session->s_count,
1044 pgrp->pg_session->s_login);
1045 db_printf("\tpgrp %p, pg_id %d, pg_jobc %d, members %p\n",
1046 pgrp, pgrp->pg_id, pgrp->pg_jobc,
1047 pgrp->pg_members.lh_first);
1048 for (p = pgrp->pg_members.lh_first; p != 0;
1049 p = p->p_pglist.le_next) {
1050 db_printf("\t\tpid %d addr %p pgrp %p %s\n",
1051 p->p_pid, p, p->p_pgrp, p->p_comm);
1052 }
1053 }
1054 }
1055 }
1056 #endif /* DDB */
1057
1058 #ifdef KSTACK_CHECK_MAGIC
1059 #include <sys/user.h>
1060
1061 #define KSTACK_MAGIC 0xdeadbeaf
1062
1063 /* XXX should be per process basis? */
1064 int kstackleftmin = KSTACK_SIZE;
1065 int kstackleftthres = KSTACK_SIZE / 8; /* warn if remaining stack is
1066 less than this */
1067
1068 void
1069 kstack_setup_magic(const struct lwp *l)
1070 {
1071 u_int32_t *ip;
1072 u_int32_t const *end;
1073
1074 KASSERT(l != NULL);
1075 KASSERT(l != &lwp0);
1076
1077 /*
1078 * fill all the stack with magic number
1079 * so that later modification on it can be detected.
1080 */
1081 ip = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
1082 end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1083 for (; ip < end; ip++) {
1084 *ip = KSTACK_MAGIC;
1085 }
1086 }
1087
1088 void
1089 kstack_check_magic(const struct lwp *l)
1090 {
1091 u_int32_t const *ip, *end;
1092 int stackleft;
1093
1094 KASSERT(l != NULL);
1095
1096 /* don't check proc0 */ /*XXX*/
1097 if (l == &lwp0)
1098 return;
1099
1100 #ifdef __MACHINE_STACK_GROWS_UP
1101 /* stack grows upwards (eg. hppa) */
1102 ip = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1103 end = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
1104 for (ip--; ip >= end; ip--)
1105 if (*ip != KSTACK_MAGIC)
1106 break;
1107
1108 stackleft = (caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE - (caddr_t)ip;
1109 #else /* __MACHINE_STACK_GROWS_UP */
1110 /* stack grows downwards (eg. i386) */
1111 ip = (u_int32_t *)KSTACK_LOWEST_ADDR(l);
1112 end = (u_int32_t *)((caddr_t)KSTACK_LOWEST_ADDR(l) + KSTACK_SIZE);
1113 for (; ip < end; ip++)
1114 if (*ip != KSTACK_MAGIC)
1115 break;
1116
1117 stackleft = (caddr_t)ip - KSTACK_LOWEST_ADDR(l);
1118 #endif /* __MACHINE_STACK_GROWS_UP */
1119
1120 if (kstackleftmin > stackleft) {
1121 kstackleftmin = stackleft;
1122 if (stackleft < kstackleftthres)
1123 printf("warning: kernel stack left %d bytes"
1124 "(pid %u:lid %u)\n", stackleft,
1125 (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
1126 }
1127
1128 if (stackleft <= 0) {
1129 panic("magic on the top of kernel stack changed for "
1130 "pid %u, lid %u: maybe kernel stack overflow",
1131 (u_int)l->l_proc->p_pid, (u_int)l->l_lid);
1132 }
1133 }
1134 #endif /* KSTACK_CHECK_MAGIC */
1135