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