kern_exit.c revision 1.156 1 /* $NetBSD: kern_exit.c,v 1.156 2006/05/14 21:15:11 elad Exp $ */
2
3 /*-
4 * Copyright (c) 1998, 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 * (c) UNIX System Laboratories, Inc.
44 * All or some portions of this file are derived from material licensed
45 * to the University of California by American Telephone and Telegraph
46 * Co. or Unix System Laboratories, Inc. and are reproduced herein with
47 * the permission of UNIX System Laboratories, Inc.
48 *
49 * Redistribution and use in source and binary forms, with or without
50 * modification, are permitted provided that the following conditions
51 * are met:
52 * 1. Redistributions of source code must retain the above copyright
53 * notice, this list of conditions and the following disclaimer.
54 * 2. Redistributions in binary form must reproduce the above copyright
55 * notice, this list of conditions and the following disclaimer in the
56 * documentation and/or other materials provided with the distribution.
57 * 3. Neither the name of the University nor the names of its contributors
58 * may be used to endorse or promote products derived from this software
59 * without specific prior written permission.
60 *
61 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
62 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
63 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
64 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
65 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
66 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
67 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
68 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
69 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
70 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
71 * SUCH DAMAGE.
72 *
73 * @(#)kern_exit.c 8.10 (Berkeley) 2/23/95
74 */
75
76 #include <sys/cdefs.h>
77 __KERNEL_RCSID(0, "$NetBSD: kern_exit.c,v 1.156 2006/05/14 21:15:11 elad Exp $");
78
79 #include "opt_ktrace.h"
80 #include "opt_perfctrs.h"
81 #include "opt_systrace.h"
82 #include "opt_sysv.h"
83
84 #include <sys/param.h>
85 #include <sys/systm.h>
86 #include <sys/ioctl.h>
87 #include <sys/proc.h>
88 #include <sys/tty.h>
89 #include <sys/time.h>
90 #include <sys/resource.h>
91 #include <sys/kernel.h>
92 #include <sys/ktrace.h>
93 #include <sys/proc.h>
94 #include <sys/buf.h>
95 #include <sys/wait.h>
96 #include <sys/file.h>
97 #include <sys/vnode.h>
98 #include <sys/syslog.h>
99 #include <sys/malloc.h>
100 #include <sys/pool.h>
101 #include <sys/resourcevar.h>
102 #if defined(PERFCTRS)
103 #include <sys/pmc.h>
104 #endif
105 #include <sys/ptrace.h>
106 #include <sys/acct.h>
107 #include <sys/filedesc.h>
108 #include <sys/ras.h>
109 #include <sys/signalvar.h>
110 #include <sys/sched.h>
111 #include <sys/sa.h>
112 #include <sys/savar.h>
113 #include <sys/mount.h>
114 #include <sys/syscallargs.h>
115 #include <sys/systrace.h>
116 #include <sys/kauth.h>
117
118 #include <machine/cpu.h>
119
120 #include <uvm/uvm_extern.h>
121
122 #define DEBUG_EXIT
123
124 #ifdef DEBUG_EXIT
125 int debug_exit = 0;
126 #define DPRINTF(x) if (debug_exit) printf x
127 #else
128 #define DPRINTF(x)
129 #endif
130
131 static void lwp_exit_hook(struct lwp *, void *);
132
133 /*
134 * Fill in the appropriate signal information, and signal the parent.
135 */
136 static void
137 exit_psignal(struct proc *p, struct proc *pp, ksiginfo_t *ksi)
138 {
139
140 (void)memset(ksi, 0, sizeof(ksiginfo_t));
141 if ((ksi->ksi_signo = P_EXITSIG(p)) == SIGCHLD) {
142 if (WIFSIGNALED(p->p_xstat)) {
143 if (WCOREDUMP(p->p_xstat))
144 ksi->ksi_code = CLD_DUMPED;
145 else
146 ksi->ksi_code = CLD_KILLED;
147 } else {
148 ksi->ksi_code = CLD_EXITED;
149 }
150 }
151 /*
152 * we fill those in, even for non-SIGCHLD.
153 */
154 ksi->ksi_pid = p->p_pid;
155 ksi->ksi_uid = kauth_cred_geteuid(p->p_cred);
156 ksi->ksi_status = p->p_xstat;
157 /* XXX: is this still valid? */
158 ksi->ksi_utime = p->p_ru->ru_utime.tv_sec;
159 ksi->ksi_stime = p->p_ru->ru_stime.tv_sec;
160 }
161
162 /*
163 * exit --
164 * Death of process.
165 */
166 int
167 sys_exit(struct lwp *l, void *v, register_t *retval)
168 {
169 struct sys_exit_args /* {
170 syscallarg(int) rval;
171 } */ *uap = v;
172
173 /* Don't call exit1() multiple times in the same process.*/
174 if (l->l_proc->p_flag & P_WEXIT)
175 lwp_exit(l);
176
177 exit1(l, W_EXITCODE(SCARG(uap, rval), 0));
178 /* NOTREACHED */
179 return (0);
180 }
181
182 /*
183 * Exit: deallocate address space and other resources, change proc state
184 * to zombie, and unlink proc from allproc and parent's lists. Save exit
185 * status and rusage for wait(). Check for child processes and orphan them.
186 */
187 void
188 exit1(struct lwp *l, int rv)
189 {
190 struct proc *p, *q, *nq;
191 int s, sa;
192 struct plimit *plim;
193 struct pstats *pstats;
194 struct sigacts *ps;
195 ksiginfo_t ksi;
196 int do_psignal = 0;
197
198 p = l->l_proc;
199
200 if (__predict_false(p == initproc))
201 panic("init died (signal %d, exit %d)",
202 WTERMSIG(rv), WEXITSTATUS(rv));
203
204 p->p_flag |= P_WEXIT;
205 if (p->p_flag & P_STOPEXIT) {
206 sigminusset(&contsigmask, &p->p_sigctx.ps_siglist);
207 SCHED_LOCK(s);
208 p->p_stat = SSTOP;
209 l->l_stat = LSSTOP;
210 p->p_nrlwps--;
211 mi_switch(l, NULL);
212 SCHED_ASSERT_UNLOCKED();
213 splx(s);
214 }
215
216 DPRINTF(("exit1: %d.%d exiting.\n", p->p_pid, l->l_lid));
217 /*
218 * Disable scheduler activation upcalls.
219 * We're trying to get out of here.
220 */
221 sa = 0;
222 if (p->p_sa != NULL) {
223 l->l_flag &= ~L_SA;
224 #if 0
225 p->p_flag &= ~P_SA;
226 #endif
227 sa = 1;
228 }
229
230 #ifdef PGINPROF
231 vmsizmon();
232 #endif
233 if (p->p_flag & P_PROFIL)
234 stopprofclock(p);
235 p->p_ru = pool_get(&rusage_pool, PR_WAITOK);
236 /*
237 * If parent is waiting for us to exit or exec, P_PPWAIT is set; we
238 * wake up the parent early to avoid deadlock.
239 */
240 if (p->p_flag & P_PPWAIT) {
241 p->p_flag &= ~P_PPWAIT;
242 wakeup(p->p_pptr);
243 }
244 sigfillset(&p->p_sigctx.ps_sigignore);
245 sigemptyset(&p->p_sigctx.ps_siglist);
246 p->p_sigctx.ps_sigcheck = 0;
247 timers_free(p, TIMERS_ALL);
248
249 if (sa || (p->p_nlwps > 1)) {
250 exit_lwps(l);
251
252 /*
253 * Collect thread u-areas.
254 */
255 uvm_uarea_drain(FALSE);
256 }
257
258 #if defined(__HAVE_RAS)
259 ras_purgeall(p);
260 #endif
261
262 /*
263 * Close open files and release open-file table.
264 * This may block!
265 */
266 fdfree(l);
267 cwdfree(p->p_cwdi);
268 p->p_cwdi = 0;
269
270 doexithooks(p);
271
272 if (SESS_LEADER(p)) {
273 struct session *sp = p->p_session;
274 struct tty *tp;
275
276 if (sp->s_ttyvp) {
277 /*
278 * Controlling process.
279 * Signal foreground pgrp,
280 * drain controlling terminal
281 * and revoke access to controlling terminal.
282 */
283 tp = sp->s_ttyp;
284 s = spltty();
285 TTY_LOCK(tp);
286 if (tp->t_session == sp) {
287 if (tp->t_pgrp)
288 pgsignal(tp->t_pgrp, SIGHUP, 1);
289 /* we can't guarantee the revoke will do this */
290 tp->t_pgrp = NULL;
291 tp->t_session = NULL;
292 TTY_UNLOCK(tp);
293 splx(s);
294 SESSRELE(sp);
295 (void) ttywait(tp);
296 /*
297 * The tty could have been revoked
298 * if we blocked.
299 */
300 if (sp->s_ttyvp)
301 VOP_REVOKE(sp->s_ttyvp, REVOKEALL);
302 } else {
303 TTY_UNLOCK(tp);
304 splx(s);
305 }
306 if (sp->s_ttyvp)
307 vrele(sp->s_ttyvp);
308 sp->s_ttyvp = NULL;
309 /*
310 * s_ttyp is not zero'd; we use this to indicate
311 * that the session once had a controlling terminal.
312 * (for logging and informational purposes)
313 */
314 }
315 sp->s_leader = NULL;
316 }
317 fixjobc(p, p->p_pgrp, 0);
318 (void)acct_process(l);
319 #ifdef KTRACE
320 /*
321 * release trace file
322 */
323 ktrderef(p);
324 #endif
325 #ifdef SYSTRACE
326 systrace_sys_exit(p);
327 #endif
328 /*
329 * If emulation has process exit hook, call it now.
330 */
331 if (p->p_emul->e_proc_exit)
332 (*p->p_emul->e_proc_exit)(p);
333
334 /*
335 * Free the VM resources we're still holding on to.
336 * We must do this from a valid thread because doing
337 * so may block. This frees vmspace, which we don't
338 * need anymore. The only remaining lwp is the one
339 * we run at this moment, nothing runs in userland
340 * anymore.
341 */
342 uvm_proc_exit(p);
343
344 /*
345 * Give machine-dependent code a chance to free any
346 * MD LWP resources while we can still block. This must be done
347 * before uvm_lwp_exit(), in case these resources are in the
348 * PCB.
349 * THIS IS LAST BLOCKING OPERATION.
350 */
351 #ifndef __NO_CPU_LWP_FREE
352 cpu_lwp_free(l, 1);
353 #endif
354
355 pmap_deactivate(l);
356
357 /*
358 * NOTE: WE ARE NO LONGER ALLOWED TO SLEEP!
359 */
360
361 /*
362 * Save exit status and final rusage info, adding in child rusage
363 * info and self times.
364 * In order to pick up the time for the current execution, we must
365 * do this before unlinking the lwp from l_list.
366 */
367 p->p_xstat = rv;
368 *p->p_ru = p->p_stats->p_ru;
369 calcru(p, &p->p_ru->ru_utime, &p->p_ru->ru_stime, NULL);
370 ruadd(p->p_ru, &p->p_stats->p_cru);
371
372 /*
373 * Notify interested parties of our demise.
374 */
375 KNOTE(&p->p_klist, NOTE_EXIT);
376
377 #if PERFCTRS
378 /*
379 * Save final PMC information in parent process & clean up.
380 */
381 if (PMC_ENABLED(p)) {
382 pmc_save_context(p);
383 pmc_accumulate(p->p_pptr, p);
384 pmc_process_exit(p);
385 }
386 #endif
387
388 s = proclist_lock_write();
389 /*
390 * Reset p_opptr pointer of all former children which got
391 * traced by another process and were reparented. We reset
392 * it to NULL here; the trace detach code then reparents
393 * the child to initproc. We only check allproc list, since
394 * eventual former children on zombproc list won't reference
395 * p_opptr anymore.
396 */
397 if (p->p_flag & P_CHTRACED) {
398 PROCLIST_FOREACH(q, &allproc) {
399 if (q->p_opptr == p)
400 q->p_opptr = NULL;
401 }
402 }
403
404 /*
405 * Give orphaned children to init(8).
406 */
407 q = LIST_FIRST(&p->p_children);
408 if (q) /* only need this if any child is SZOMB */
409 wakeup(initproc);
410 for (; q != NULL; q = nq) {
411 nq = LIST_NEXT(q, p_sibling);
412
413 /*
414 * Traced processes are killed since their existence
415 * means someone is screwing up. Since we reset the
416 * trace flags, the logic in sys_wait4() would not be
417 * triggered to reparent the process to its
418 * original parent, so we must do this here.
419 */
420 if (q->p_flag & P_TRACED) {
421 if (q->p_opptr != q->p_pptr) {
422 struct proc *t = q->p_opptr;
423 proc_reparent(q, t ? t : initproc);
424 q->p_opptr = NULL;
425 } else
426 proc_reparent(q, initproc);
427 q->p_flag &= ~(P_TRACED|P_WAITED|P_FSTRACE|P_SYSCALL);
428 killproc(q, "orphaned traced process");
429 } else {
430 proc_reparent(q, initproc);
431 }
432 }
433
434 /*
435 * Move proc from allproc to zombproc, it's now ready
436 * to be collected by parent. Remaining lwp resources
437 * will be freed in lwp_exit2() once we've switch to idle
438 * context.
439 * Changing the state to SZOMB stops it being found by pfind().
440 */
441 LIST_REMOVE(p, p_list);
442 LIST_INSERT_HEAD(&zombproc, p, p_list);
443 p->p_stat = SZOMB;
444
445 LIST_REMOVE(l, l_list);
446 LIST_REMOVE(l, l_sibling);
447 l->l_flag |= L_DETACHED; /* detached from proc too */
448 l->l_stat = LSDEAD;
449
450 KASSERT(p->p_nrlwps == 1);
451 KASSERT(p->p_nlwps == 1);
452 p->p_nrlwps--;
453 p->p_nlwps--;
454
455 /* Put in front of parent's sibling list for parent to collect it */
456 q = p->p_pptr;
457 q->p_nstopchild++;
458 if (LIST_FIRST(&q->p_children) != p) {
459 /* Put child where it can be found quickly */
460 LIST_REMOVE(p, p_sibling);
461 LIST_INSERT_HEAD(&q->p_children, p, p_sibling);
462 }
463
464 /*
465 * Notify parent that we're gone. If parent has the P_NOCLDWAIT
466 * flag set, notify init instead (and hope it will handle
467 * this situation).
468 */
469 if (q->p_flag & (P_NOCLDWAIT|P_CLDSIGIGN)) {
470 proc_reparent(p, initproc);
471
472 /*
473 * If this was the last child of our parent, notify
474 * parent, so in case he was wait(2)ing, he will
475 * continue.
476 */
477 if (LIST_FIRST(&q->p_children) == NULL)
478 wakeup(q);
479 }
480
481 /*
482 * Clear curlwp after we've done all operations
483 * that could block, and before tearing down the rest
484 * of the process state that might be used from clock, etc.
485 * Also, can't clear curlwp while we're still runnable,
486 * as we're not on a run queue (we are current, just not
487 * a proper proc any longer!).
488 *
489 * Other substructures are freed from wait().
490 */
491 curlwp = NULL;
492
493 /* Delay release until after dropping the proclist lock */
494 plim = p->p_limit;
495 pstats = p->p_stats;
496 ps = p->p_sigacts;
497
498 p->p_limit = NULL;
499 p->p_stats = NULL;
500 p->p_sigacts = NULL;
501
502 /* Reload parent pointer, since p may have been reparented above */
503 q = p->p_pptr;
504
505 if ((p->p_flag & P_FSTRACE) == 0 && p->p_exitsig != 0) {
506 exit_psignal(p, q, &ksi);
507 do_psignal = 1;
508 }
509
510 /*
511 * Once we release the proclist lock, we shouldn't touch the
512 * process structure anymore, since it's now on the zombie
513 * list and available for collection by the parent.
514 */
515 proclist_unlock_write(s);
516
517 if (do_psignal)
518 kpsignal(q, &ksi, NULL);
519
520 /* Wake up the parent so it can get exit status. */
521 wakeup(q);
522
523 /* Release substructures */
524 sigactsfree(ps);
525 limfree(plim);
526 pstatsfree(pstats);
527
528 #ifdef DEBUG
529 /* Nothing should use the process link anymore */
530 l->l_proc = NULL;
531 #endif
532
533 /* This process no longer needs to hold the kernel lock. */
534 KERNEL_PROC_UNLOCK(l);
535
536 /*
537 * Finally, call machine-dependent code to switch to a new
538 * context (possibly the idle context). Once we are no longer
539 * using the dead lwp's stack, lwp_exit2() will be called
540 * to arrange for the resources to be released.
541 *
542 * Note that cpu_exit() will end with a call equivalent to
543 * cpu_switch(), finishing our execution (pun intended).
544 */
545
546 uvmexp.swtch++;
547 cpu_exit(l);
548 }
549
550 void
551 exit_lwps(struct lwp *l)
552 {
553 struct proc *p;
554 struct lwp *l2;
555 struct sadata_vp *vp;
556 int s, error;
557 lwpid_t waited;
558
559 p = l->l_proc;
560
561 /* XXX SMP
562 * This would be the right place to IPI any LWPs running on
563 * other processors so that they can notice the userret exit hook.
564 */
565 p->p_userret = lwp_exit_hook;
566 p->p_userret_arg = NULL;
567
568 if (p->p_sa) {
569 SLIST_FOREACH(vp, &p->p_sa->sa_vps, savp_next) {
570 /*
571 * Make SA-cached LWPs normal process runnable
572 * LWPs so that they'll also self-destruct.
573 */
574 DPRINTF(("exit_lwps: Making cached LWPs of %d on VP %d runnable: ",
575 p->p_pid, vp->savp_id));
576 SCHED_LOCK(s);
577 while ((l2 = sa_getcachelwp(vp)) != 0) {
578 l2->l_priority = l2->l_usrpri;
579 setrunnable(l2);
580 DPRINTF(("%d ", l2->l_lid));
581 }
582 SCHED_UNLOCK(s);
583 DPRINTF(("\n"));
584
585 /*
586 * Clear wokenq, the LWPs on the queue will
587 * run below.
588 */
589 vp->savp_wokenq_head = NULL;
590 }
591 }
592
593 retry:
594 /*
595 * Interrupt LWPs in interruptable sleep, unsuspend suspended
596 * LWPs, make detached LWPs undetached (so we can wait for
597 * them) and then wait for everyone else to finish.
598 */
599 LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
600 l2->l_flag &= ~(L_DETACHED|L_SA);
601
602 SCHED_LOCK(s);
603 if ((l2->l_stat == LSSLEEP && (l2->l_flag & L_SINTR)) ||
604 l2->l_stat == LSSUSPENDED || l2->l_stat == LSSTOP) {
605 setrunnable(l2);
606 DPRINTF(("exit_lwps: Made %d.%d runnable\n",
607 p->p_pid, l2->l_lid));
608 }
609 SCHED_UNLOCK(s);
610 }
611
612
613 while (p->p_nlwps > 1) {
614 DPRINTF(("exit_lwps: waiting for %d LWPs (%d runnable, %d zombies)\n",
615 p->p_nlwps, p->p_nrlwps, p->p_nzlwps));
616 error = lwp_wait1(l, 0, &waited, LWPWAIT_EXITCONTROL);
617 if (error == EDEADLK) {
618 /*
619 * LWPs can get suspended/slept behind us.
620 * (eg. sa_setwoken)
621 * kick them again and retry.
622 */
623 goto retry;
624 }
625 if (error)
626 panic("exit_lwps: lwp_wait1 failed with error %d",
627 error);
628 DPRINTF(("exit_lwps: Got LWP %d from lwp_wait1()\n", waited));
629 }
630
631 p->p_userret = NULL;
632 }
633
634 /* Wrapper function for use in p_userret */
635 static void
636 lwp_exit_hook(struct lwp *l, void *arg)
637 {
638 KERNEL_PROC_LOCK(l);
639 lwp_exit(l);
640 }
641
642 int
643 sys_wait4(struct lwp *l, void *v, register_t *retval)
644 {
645 struct sys_wait4_args /* {
646 syscallarg(int) pid;
647 syscallarg(int *) status;
648 syscallarg(int) options;
649 syscallarg(struct rusage *) rusage;
650 } */ *uap = v;
651 struct proc *child, *parent;
652 int status, error;
653
654 parent = l->l_proc;
655
656 if (SCARG(uap, pid) == 0)
657 SCARG(uap, pid) = -parent->p_pgid;
658 if (SCARG(uap, options) & ~(WUNTRACED|WNOHANG|WALTSIG|WALLSIG))
659 return (EINVAL);
660
661 error = find_stopped_child(parent, SCARG(uap,pid), SCARG(uap,options),
662 &child);
663 if (error != 0)
664 return error;
665 if (child == NULL) {
666 *retval = 0;
667 return 0;
668 }
669
670 /*
671 * Collect child u-areas.
672 */
673 uvm_uarea_drain(FALSE);
674
675 retval[0] = child->p_pid;
676
677 if (P_ZOMBIE(child)) {
678 if (SCARG(uap, status)) {
679 status = child->p_xstat; /* convert to int */
680 error = copyout(&status, SCARG(uap, status),
681 sizeof(status));
682 if (error)
683 return (error);
684 }
685 if (SCARG(uap, rusage)) {
686 error = copyout(child->p_ru, SCARG(uap, rusage),
687 sizeof(struct rusage));
688 if (error)
689 return (error);
690 }
691
692 proc_free(child);
693 return 0;
694 }
695
696 /* child state must be SSTOP */
697 if (SCARG(uap, status)) {
698 status = W_STOPCODE(child->p_xstat);
699 return copyout(&status, SCARG(uap, status), sizeof(status));
700 }
701 return 0;
702 }
703
704 /*
705 * Scan list of child processes for a child process that has stopped or
706 * exited. Used by sys_wait4 and 'compat' equivalents.
707 */
708 int
709 find_stopped_child(struct proc *parent, pid_t pid, int options,
710 struct proc **child_p)
711 {
712 struct proc *child;
713 int error;
714
715 for (;;) {
716 proclist_lock_read();
717 error = ECHILD;
718 LIST_FOREACH(child, &parent->p_children, p_sibling) {
719 if (pid >= 0) {
720 if (child->p_pid != pid) {
721 child = p_find(pid, PFIND_ZOMBIE |
722 PFIND_LOCKED);
723 if (child == NULL
724 || child->p_pptr != parent) {
725 child = NULL;
726 break;
727 }
728 }
729 } else
730 if (pid != WAIT_ANY && child->p_pgid != -pid)
731 /* child not in correct pgrp */
732 continue;
733 /*
734 * Wait for processes with p_exitsig != SIGCHLD
735 * processes only if WALTSIG is set; wait for
736 * processes with p_exitsig == SIGCHLD only
737 * if WALTSIG is clear.
738 */
739 if (((options & WALLSIG) == 0) &&
740 (options & WALTSIG ? child->p_exitsig == SIGCHLD
741 : P_EXITSIG(child) != SIGCHLD)){
742 if (child->p_pid == pid) {
743 child = NULL;
744 break;
745 }
746 continue;
747 }
748
749 error = 0;
750 if (child->p_stat == SZOMB && !(options & WNOZOMBIE))
751 break;
752
753 if (child->p_stat == SSTOP &&
754 (child->p_flag & P_WAITED) == 0 &&
755 (child->p_flag & P_TRACED || options & WUNTRACED)) {
756 if ((options & WNOWAIT) == 0) {
757 child->p_flag |= P_WAITED;
758 parent->p_nstopchild--;
759 }
760 break;
761 }
762 if (parent->p_nstopchild == 0 || child->p_pid == pid) {
763 child = NULL;
764 break;
765 }
766 }
767 proclist_unlock_read();
768 if (child != NULL || error != 0 || options & WNOHANG) {
769 *child_p = child;
770 return error;
771 }
772 error = tsleep(parent, PWAIT | PCATCH, "wait", 0);
773 if (error != 0)
774 return error;
775 }
776 }
777
778 /*
779 * Free a process after parent has taken all the state info.
780 */
781 void
782 proc_free(struct proc *p)
783 {
784 struct proc *parent = p->p_pptr;
785 ksiginfo_t ksi;
786 int s;
787
788 KASSERT(p->p_nlwps == 0);
789 KASSERT(p->p_nzlwps == 0);
790 KASSERT(p->p_nrlwps == 0);
791 KASSERT(LIST_EMPTY(&p->p_lwps));
792
793 /*
794 * If we got the child via ptrace(2) or procfs, and
795 * the parent is different (meaning the process was
796 * attached, rather than run as a child), then we need
797 * to give it back to the old parent, and send the
798 * parent the exit signal. The rest of the cleanup
799 * will be done when the old parent waits on the child.
800 */
801 if ((p->p_flag & P_TRACED) && p->p_opptr != parent){
802 parent = p->p_opptr;
803 if (parent == NULL)
804 parent = initproc;
805 proc_reparent(p, parent);
806 p->p_opptr = NULL;
807 p->p_flag &= ~(P_TRACED|P_WAITED|P_FSTRACE|P_SYSCALL);
808 if (p->p_exitsig != 0) {
809 exit_psignal(p, parent, &ksi);
810 kpsignal(parent, &ksi, NULL);
811 }
812 wakeup(parent);
813 return;
814 }
815
816 scheduler_wait_hook(parent, p);
817 p->p_xstat = 0;
818
819 ruadd(&parent->p_stats->p_cru, p->p_ru);
820
821 /*
822 * At this point we are going to start freeing the final resources.
823 * If anyone tries to access the proc structure after here they
824 * will get a shock - bits are missing.
825 * Attempt to make it hard!
826 */
827
828 p->p_stat = SIDL; /* not even a zombie any more */
829
830 pool_put(&rusage_pool, p->p_ru);
831
832 /*
833 * Finally finished with old proc entry.
834 * Unlink it from its process group and free it.
835 */
836 leavepgrp(p);
837
838 s = proclist_lock_write();
839 LIST_REMOVE(p, p_list); /* off zombproc */
840 p->p_pptr->p_nstopchild--;
841 LIST_REMOVE(p, p_sibling);
842 proclist_unlock_write(s);
843
844 /*
845 * Decrement the count of procs running with this uid.
846 */
847 (void)chgproccnt(kauth_cred_getuid(p->p_cred), -1);
848
849 /*
850 * Free up credentials.
851 */
852 kauth_cred_free(p->p_cred);
853
854 /*
855 * Release reference to text vnode
856 */
857 if (p->p_textvp)
858 vrele(p->p_textvp);
859
860 /* Release any SA state. */
861 if (p->p_sa)
862 sa_release(p);
863
864 /* Free proc structure and let pid be reallocated */
865 proc_free_mem(p);
866 }
867
868 /*
869 * make process 'parent' the new parent of process 'child'.
870 *
871 * Must be called with proclist_lock_write() held.
872 */
873 void
874 proc_reparent(struct proc *child, struct proc *parent)
875 {
876
877 if (child->p_pptr == parent)
878 return;
879
880 if (child->p_stat == SZOMB
881 || (child->p_stat == SSTOP && !(child->p_flag & P_WAITED))) {
882 child->p_pptr->p_nstopchild--;
883 parent->p_nstopchild++;
884 }
885 if (parent == initproc)
886 child->p_exitsig = SIGCHLD;
887
888 LIST_REMOVE(child, p_sibling);
889 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
890 child->p_pptr = parent;
891 }
892