kern_exit.c revision 1.194 1 /* $NetBSD: kern_exit.c,v 1.194 2007/11/30 23:05:43 ad Exp $ */
2
3 /*-
4 * Copyright (c) 1998, 1999, 2006, 2007 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, and by Andrew Doran.
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.194 2007/11/30 23:05:43 ad 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/aio.h>
86 #include <sys/systm.h>
87 #include <sys/ioctl.h>
88 #include <sys/tty.h>
89 #include <sys/time.h>
90 #include <sys/resource.h>
91 #include <sys/kernel.h>
92 #include <sys/proc.h>
93 #include <sys/buf.h>
94 #include <sys/wait.h>
95 #include <sys/file.h>
96 #include <sys/vnode.h>
97 #include <sys/syslog.h>
98 #include <sys/malloc.h>
99 #include <sys/pool.h>
100 #include <sys/resourcevar.h>
101 #if defined(PERFCTRS)
102 #include <sys/pmc.h>
103 #endif
104 #include <sys/ptrace.h>
105 #include <sys/acct.h>
106 #include <sys/filedesc.h>
107 #include <sys/ras.h>
108 #include <sys/signalvar.h>
109 #include <sys/sched.h>
110 #include <sys/mount.h>
111 #include <sys/syscallargs.h>
112 #include <sys/systrace.h>
113 #include <sys/kauth.h>
114 #include <sys/sleepq.h>
115 #include <sys/lockdebug.h>
116 #include <sys/ktrace.h>
117 #include <sys/cpu.h>
118 #include <sys/lwpctl.h>
119 #include <sys/atomic.h>
120
121 #include <uvm/uvm_extern.h>
122
123 #define DEBUG_EXIT
124
125 #ifdef DEBUG_EXIT
126 int debug_exit = 0;
127 #define DPRINTF(x) if (debug_exit) printf x
128 #else
129 #define DPRINTF(x)
130 #endif
131
132 static int find_stopped_child(struct proc *, pid_t, int, struct proc **, int *);
133 static void proc_free(struct proc *, struct rusage *);
134
135 /*
136 * Fill in the appropriate signal information, and signal the parent.
137 */
138 static void
139 exit_psignal(struct proc *p, struct proc *pp, ksiginfo_t *ksi)
140 {
141
142 KSI_INIT(ksi);
143 if ((ksi->ksi_signo = P_EXITSIG(p)) == SIGCHLD) {
144 if (WIFSIGNALED(p->p_xstat)) {
145 if (WCOREDUMP(p->p_xstat))
146 ksi->ksi_code = CLD_DUMPED;
147 else
148 ksi->ksi_code = CLD_KILLED;
149 } else {
150 ksi->ksi_code = CLD_EXITED;
151 }
152 }
153 /*
154 * We fill those in, even for non-SIGCHLD.
155 * It's safe to access p->p_cred unlocked here.
156 */
157 ksi->ksi_pid = p->p_pid;
158 ksi->ksi_uid = kauth_cred_geteuid(p->p_cred);
159 ksi->ksi_status = p->p_xstat;
160 /* XXX: is this still valid? */
161 ksi->ksi_utime = p->p_stats->p_ru.ru_utime.tv_sec;
162 ksi->ksi_stime = p->p_stats->p_ru.ru_stime.tv_sec;
163 }
164
165 /*
166 * exit --
167 * Death of process.
168 */
169 int
170 sys_exit(struct lwp *l, void *v, register_t *retval)
171 {
172 struct sys_exit_args /* {
173 syscallarg(int) rval;
174 } */ *uap = v;
175 struct proc *p = l->l_proc;
176
177 /* Don't call exit1() multiple times in the same process. */
178 mutex_enter(&p->p_smutex);
179 if (p->p_sflag & PS_WEXIT) {
180 mutex_exit(&p->p_smutex);
181 lwp_exit(l);
182 }
183
184 /* exit1() will release the mutex. */
185 exit1(l, W_EXITCODE(SCARG(uap, rval), 0));
186 /* NOTREACHED */
187 return (0);
188 }
189
190 /*
191 * Exit: deallocate address space and other resources, change proc state
192 * to zombie, and unlink proc from allproc and parent's lists. Save exit
193 * status and rusage for wait(). Check for child processes and orphan them.
194 *
195 * Must be called with p->p_smutex held. Does not return.
196 */
197 void
198 exit1(struct lwp *l, int rv)
199 {
200 struct proc *p, *q, *nq;
201 ksiginfo_t ksi;
202 ksiginfoq_t kq;
203 int wakeinit;
204
205 p = l->l_proc;
206
207 KASSERT(mutex_owned(&p->p_smutex));
208
209 if (__predict_false(p == initproc))
210 panic("init died (signal %d, exit %d)",
211 WTERMSIG(rv), WEXITSTATUS(rv));
212
213 p->p_sflag |= PS_WEXIT;
214
215 /*
216 * Force all other LWPs to exit before we do. Only then can we
217 * begin to tear down the rest of the process state.
218 */
219 if (p->p_nlwps > 1)
220 exit_lwps(l);
221
222 ksiginfo_queue_init(&kq);
223
224 /*
225 * If we have been asked to stop on exit, do so now.
226 */
227 if (p->p_sflag & PS_STOPEXIT) {
228 KERNEL_UNLOCK_ALL(l, &l->l_biglocks);
229 sigclearall(p, &contsigmask, &kq);
230 p->p_waited = 0;
231 membar_producer();
232 p->p_stat = SSTOP;
233 lwp_lock(l);
234 p->p_nrlwps--;
235 l->l_stat = LSSTOP;
236 mutex_exit(&p->p_smutex);
237 mi_switch(l);
238 KERNEL_LOCK(l->l_biglocks, l);
239 } else
240 mutex_exit(&p->p_smutex);
241
242 /* Destroy any lwpctl info. */
243 if (p->p_lwpctl != NULL)
244 lwp_ctl_exit();
245
246 /* Destroy all AIO works */
247 aio_exit(p, p->p_aio);
248
249 /*
250 * Drain all remaining references that procfs, ptrace and others may
251 * have on the process.
252 */
253 rw_enter(&p->p_reflock, RW_WRITER);
254
255 /*
256 * Bin any remaining signals and mark the process as dying so it will
257 * not be found for, e.g. signals.
258 */
259 mutex_enter(&p->p_smutex);
260 sigfillset(&p->p_sigctx.ps_sigignore);
261 sigclearall(p, NULL, &kq);
262 p->p_stat = SDYING;
263 mutex_exit(&p->p_smutex);
264 ksiginfo_queue_drain(&kq);
265
266 DPRINTF(("exit1: %d.%d exiting.\n", p->p_pid, l->l_lid));
267
268 #ifdef PGINPROF
269 vmsizmon();
270 #endif
271 timers_free(p, TIMERS_ALL);
272 #if defined(__HAVE_RAS)
273 ras_purgeall();
274 #endif
275
276 /*
277 * Close open files, release open-file table and free signal
278 * actions. This may block!
279 */
280 fdfree(l);
281 cwdfree(p->p_cwdi);
282 p->p_cwdi = NULL;
283 doexithooks(p);
284 sigactsfree(p->p_sigacts);
285
286 /*
287 * Write out accounting data.
288 */
289 (void)acct_process(l);
290
291 #ifdef KTRACE
292 /*
293 * Release trace file.
294 */
295 if (p->p_tracep != NULL) {
296 mutex_enter(&ktrace_lock);
297 ktrderef(p);
298 mutex_exit(&ktrace_lock);
299 }
300 #endif
301 #ifdef SYSTRACE
302 systrace_sys_exit(p);
303 #endif
304
305 /*
306 * If emulation has process exit hook, call it now.
307 * Set the exit status now so that the exit hook has
308 * an opportunity to tweak it (COMPAT_LINUX requires
309 * this for thread group emulation)
310 */
311 p->p_xstat = rv;
312 if (p->p_emul->e_proc_exit)
313 (*p->p_emul->e_proc_exit)(p);
314
315 /* Collect child u-areas. */
316 uvm_uarea_drain(false);
317
318 /*
319 * Free the VM resources we're still holding on to.
320 * We must do this from a valid thread because doing
321 * so may block. This frees vmspace, which we don't
322 * need anymore. The only remaining lwp is the one
323 * we run at this moment, nothing runs in userland
324 * anymore.
325 */
326 uvm_proc_exit(p);
327
328 /*
329 * While we can still block, and mark the LWP as unswappable to
330 * prevent conflicts with the with the swapper. We also shouldn't
331 * be swapped out, because we are about to exit and will release
332 * memory.
333 */
334 uvm_lwp_hold(l);
335
336 /*
337 * Stop profiling.
338 */
339 if ((p->p_stflag & PST_PROFIL) != 0) {
340 mutex_spin_enter(&p->p_stmutex);
341 stopprofclock(p);
342 mutex_spin_exit(&p->p_stmutex);
343 }
344
345 /*
346 * If parent is waiting for us to exit or exec, P_PPWAIT is set; we
347 * wake up the parent early to avoid deadlock. We can do this once
348 * the VM resources are released.
349 */
350 mutex_enter(&proclist_lock);
351
352 mutex_enter(&p->p_smutex);
353 if (p->p_sflag & PS_PPWAIT) {
354 p->p_sflag &= ~PS_PPWAIT;
355 cv_broadcast(&p->p_pptr->p_waitcv);
356 }
357 mutex_exit(&p->p_smutex);
358
359 if (SESS_LEADER(p)) {
360 struct vnode *vprele = NULL, *vprevoke = NULL;
361 struct session *sp = p->p_session;
362 struct tty *tp;
363
364 if (sp->s_ttyvp) {
365 /*
366 * Controlling process.
367 * Signal foreground pgrp,
368 * drain controlling terminal
369 * and revoke access to controlling terminal.
370 */
371 tp = sp->s_ttyp;
372 mutex_spin_enter(&tty_lock);
373 if (tp->t_session == sp) {
374 if (tp->t_pgrp) {
375 mutex_enter(&proclist_mutex);
376 pgsignal(tp->t_pgrp, SIGHUP, 1);
377 mutex_exit(&proclist_mutex);
378 }
379 /* we can't guarantee the revoke will do this */
380 tp->t_pgrp = NULL;
381 tp->t_session = NULL;
382 mutex_spin_exit(&tty_lock);
383 SESSRELE(sp);
384 mutex_exit(&proclist_lock);
385 (void) ttywait(tp);
386 mutex_enter(&proclist_lock);
387
388 /*
389 * The tty could have been revoked
390 * if we blocked.
391 */
392 vprevoke = sp->s_ttyvp;
393 } else
394 mutex_spin_exit(&tty_lock);
395 vprele = sp->s_ttyvp;
396 sp->s_ttyvp = NULL;
397 /*
398 * s_ttyp is not zero'd; we use this to indicate
399 * that the session once had a controlling terminal.
400 * (for logging and informational purposes)
401 */
402 }
403 sp->s_leader = NULL;
404
405 if (vprevoke != NULL || vprele != NULL) {
406 mutex_exit(&proclist_lock);
407 if (vprevoke != NULL)
408 VOP_REVOKE(vprevoke, REVOKEALL);
409 if (vprele != NULL)
410 vrele(vprele);
411 mutex_enter(&proclist_lock);
412 }
413 }
414 mutex_enter(&proclist_mutex);
415 fixjobc(p, p->p_pgrp, 0);
416 mutex_exit(&proclist_mutex);
417
418 /*
419 * Finalize the last LWP's specificdata, as well as the
420 * specificdata for the proc itself.
421 */
422 lwp_finispecific(l);
423 proc_finispecific(p);
424
425 /*
426 * Notify interested parties of our demise.
427 */
428 KNOTE(&p->p_klist, NOTE_EXIT);
429
430 #if PERFCTRS
431 /*
432 * Save final PMC information in parent process & clean up.
433 */
434 if (PMC_ENABLED(p)) {
435 pmc_save_context(p);
436 pmc_accumulate(p->p_pptr, p);
437 pmc_process_exit(p);
438 }
439 #endif
440
441 /*
442 * Reset p_opptr pointer of all former children which got
443 * traced by another process and were reparented. We reset
444 * it to NULL here; the trace detach code then reparents
445 * the child to initproc. We only check allproc list, since
446 * eventual former children on zombproc list won't reference
447 * p_opptr anymore.
448 */
449 if (p->p_slflag & PSL_CHTRACED) {
450 PROCLIST_FOREACH(q, &allproc) {
451 if (q->p_opptr == p)
452 q->p_opptr = NULL;
453 }
454 }
455
456 /*
457 * Give orphaned children to init(8).
458 */
459 q = LIST_FIRST(&p->p_children);
460 wakeinit = (q != NULL);
461 for (; q != NULL; q = nq) {
462 nq = LIST_NEXT(q, p_sibling);
463
464 /*
465 * Traced processes are killed since their existence
466 * means someone is screwing up. Since we reset the
467 * trace flags, the logic in sys_wait4() would not be
468 * triggered to reparent the process to its
469 * original parent, so we must do this here.
470 */
471 if (q->p_slflag & PSL_TRACED) {
472 mutex_enter(&p->p_smutex);
473 q->p_slflag &= ~(PSL_TRACED|PSL_FSTRACE|PSL_SYSCALL);
474 mutex_exit(&p->p_smutex);
475 if (q->p_opptr != q->p_pptr) {
476 struct proc *t = q->p_opptr;
477 proc_reparent(q, t ? t : initproc);
478 q->p_opptr = NULL;
479 } else
480 proc_reparent(q, initproc);
481 killproc(q, "orphaned traced process");
482 } else
483 proc_reparent(q, initproc);
484 }
485
486 /*
487 * Move proc from allproc to zombproc, it's now nearly ready to be
488 * collected by parent.
489 */
490 mutex_enter(&proclist_mutex);
491 LIST_REMOVE(l, l_list);
492 LIST_REMOVE(p, p_list);
493 LIST_INSERT_HEAD(&zombproc, p, p_list);
494
495 /*
496 * Mark the process as dead. We must do this before we signal
497 * the parent.
498 */
499 p->p_stat = SDEAD;
500
501 /* Put in front of parent's sibling list for parent to collect it */
502 q = p->p_pptr;
503 q->p_nstopchild++;
504 if (LIST_FIRST(&q->p_children) != p) {
505 /* Put child where it can be found quickly */
506 LIST_REMOVE(p, p_sibling);
507 LIST_INSERT_HEAD(&q->p_children, p, p_sibling);
508 }
509 mutex_exit(&proclist_mutex);
510
511 /*
512 * Notify parent that we're gone. If parent has the P_NOCLDWAIT
513 * flag set, notify init instead (and hope it will handle
514 * this situation).
515 */
516 mutex_enter(&q->p_mutex);
517 if (q->p_flag & (PK_NOCLDWAIT|PK_CLDSIGIGN)) {
518 proc_reparent(p, initproc);
519 wakeinit = 1;
520
521 /*
522 * If this was the last child of our parent, notify
523 * parent, so in case he was wait(2)ing, he will
524 * continue.
525 */
526 if (LIST_FIRST(&q->p_children) == NULL)
527 cv_broadcast(&q->p_waitcv);
528 }
529 mutex_exit(&q->p_mutex);
530
531 /* Reload parent pointer, since p may have been reparented above */
532 q = p->p_pptr;
533
534 if ((p->p_slflag & PSL_FSTRACE) == 0 && p->p_exitsig != 0) {
535 exit_psignal(p, q, &ksi);
536 mutex_enter(&proclist_mutex);
537 kpsignal(q, &ksi, NULL);
538 mutex_exit(&proclist_mutex);
539 }
540
541 /* Calculate the final rusage info. */
542 calcru(p, &p->p_stats->p_ru.ru_utime, &p->p_stats->p_ru.ru_stime,
543 NULL, NULL);
544
545 if (wakeinit)
546 cv_broadcast(&initproc->p_waitcv);
547
548 callout_destroy(&l->l_timeout_ch);
549
550 /*
551 * Remaining lwp resources will be freed in lwp_exit2() once we've
552 * switch to idle context; at that point, we will be marked as a
553 * full blown zombie.
554 *
555 * XXXSMP disable preemption.
556 */
557 mutex_enter(&p->p_smutex);
558 lwp_drainrefs(l);
559 lwp_lock(l);
560 l->l_prflag &= ~LPR_DETACHED;
561 l->l_stat = LSZOMB;
562 lwp_unlock(l);
563 KASSERT(curlwp == l);
564 KASSERT(p->p_nrlwps == 1);
565 KASSERT(p->p_nlwps == 1);
566 p->p_stat = SZOMB;
567 p->p_nrlwps--;
568 p->p_nzlwps++;
569 p->p_ndlwps = 0;
570 mutex_exit(&p->p_smutex);
571
572 /*
573 * Signal the parent to collect us, and drop the proclist lock.
574 * Drop debugger/procfs lock; no new references can be gained.
575 */
576 cv_broadcast(&p->p_pptr->p_waitcv);
577 mutex_exit(&proclist_lock);
578 rw_exit(&p->p_reflock);
579
580 /* Verify that we hold no locks other than the kernel lock. */
581 #ifdef MULTIPROCESSOR
582 LOCKDEBUG_BARRIER(&kernel_lock, 0);
583 #else
584 LOCKDEBUG_BARRIER(NULL, 0);
585 #endif
586
587 /*
588 * NOTE: WE ARE NO LONGER ALLOWED TO SLEEP!
589 */
590
591 /*
592 * Give machine-dependent code a chance to free any MD LWP
593 * resources. This must be done before uvm_lwp_exit(), in
594 * case these resources are in the PCB.
595 */
596 #ifndef __NO_CPU_LWP_FREE
597 cpu_lwp_free(l, 1);
598 #endif
599 pmap_deactivate(l);
600
601 /* This process no longer needs to hold the kernel lock. */
602 #ifdef notyet
603 /* XXXSMP hold in lwp_userret() */
604 KERNEL_UNLOCK_LAST(l);
605 #else
606 KERNEL_UNLOCK_ALL(l, NULL);
607 #endif
608
609 lwp_exit_switchaway(l);
610 }
611
612 void
613 exit_lwps(struct lwp *l)
614 {
615 struct proc *p;
616 struct lwp *l2;
617 int error;
618 lwpid_t waited;
619 #if defined(MULTIPROCESSOR)
620 int nlocks;
621 #endif
622
623 KERNEL_UNLOCK_ALL(l, &nlocks);
624
625 p = l->l_proc;
626 KASSERT(mutex_owned(&p->p_smutex));
627
628 retry:
629 /*
630 * Interrupt LWPs in interruptable sleep, unsuspend suspended
631 * LWPs and then wait for everyone else to finish.
632 */
633 LIST_FOREACH(l2, &p->p_lwps, l_sibling) {
634 if (l2 == l)
635 continue;
636 lwp_lock(l2);
637 l2->l_flag |= LW_WEXIT;
638 if ((l2->l_stat == LSSLEEP && (l2->l_flag & LW_SINTR)) ||
639 l2->l_stat == LSSUSPENDED || l2->l_stat == LSSTOP) {
640 /* setrunnable() will release the lock. */
641 setrunnable(l2);
642 DPRINTF(("exit_lwps: Made %d.%d runnable\n",
643 p->p_pid, l2->l_lid));
644 continue;
645 }
646 lwp_unlock(l2);
647 }
648 while (p->p_nlwps > 1) {
649 DPRINTF(("exit_lwps: waiting for %d LWPs (%d zombies)\n",
650 p->p_nlwps, p->p_nzlwps));
651 error = lwp_wait1(l, 0, &waited, LWPWAIT_EXITCONTROL);
652 if (p->p_nlwps == 1)
653 break;
654 if (error == EDEADLK) {
655 /*
656 * LWPs can get suspended/slept behind us.
657 * (eg. sa_setwoken)
658 * kick them again and retry.
659 */
660 goto retry;
661 }
662 if (error)
663 panic("exit_lwps: lwp_wait1 failed with error %d",
664 error);
665 DPRINTF(("exit_lwps: Got LWP %d from lwp_wait1()\n", waited));
666 }
667
668 #if defined(MULTIPROCESSOR)
669 if (nlocks > 0) {
670 mutex_exit(&p->p_smutex);
671 KERNEL_LOCK(nlocks, l);
672 mutex_enter(&p->p_smutex);
673 }
674 #endif /* defined(MULTIPROCESSOR) */
675 KASSERT(p->p_nlwps == 1);
676 }
677
678 int
679 do_sys_wait(struct lwp *l, int *pid, int *status, int options,
680 struct rusage *ru, int *was_zombie)
681 {
682 struct proc *child;
683 int error;
684
685 mutex_enter(&proclist_lock);
686
687 error = find_stopped_child(l->l_proc, *pid, options, &child, status);
688
689 if (child == NULL) {
690 mutex_exit(&proclist_lock);
691 *pid = 0;
692 return error;
693 }
694
695 *pid = child->p_pid;
696
697 if (child->p_stat == SZOMB) {
698 /* proc_free() will release the proclist_lock. */
699 *was_zombie = 1;
700 if (options & WNOWAIT)
701 mutex_exit(&proclist_lock);
702 else {
703 KERNEL_LOCK(1, l); /* XXXSMP */
704 proc_free(child, ru);
705 KERNEL_UNLOCK_ONE(l); /* XXXSMP */
706 }
707 } else {
708 /* Child state must have been SSTOP. */
709 *was_zombie = 0;
710 mutex_exit(&proclist_lock);
711 *status = W_STOPCODE(*status);
712 }
713
714 return 0;
715 }
716
717 int
718 sys_wait4(struct lwp *l, void *v, register_t *retval)
719 {
720 struct sys_wait4_args /* {
721 syscallarg(int) pid;
722 syscallarg(int *) status;
723 syscallarg(int) options;
724 syscallarg(struct rusage *) rusage;
725 } */ *uap = v;
726 int status, error;
727 int was_zombie;
728 struct rusage ru;
729
730 error = do_sys_wait(l, &SCARG(uap, pid), &status, SCARG(uap, options),
731 SCARG(uap, rusage) != NULL ? &ru : NULL, &was_zombie);
732
733 retval[0] = SCARG(uap, pid);
734 if (SCARG(uap, pid) == 0)
735 return error;
736
737 if (SCARG(uap, rusage))
738 error = copyout(&ru, SCARG(uap, rusage), sizeof(ru));
739
740 if (error == 0 && SCARG(uap, status))
741 error = copyout(&status, SCARG(uap, status), sizeof(status));
742
743 return error;
744 }
745
746 /*
747 * Scan list of child processes for a child process that has stopped or
748 * exited. Used by sys_wait4 and 'compat' equivalents.
749 *
750 * Must be called with the proclist_lock held, and may release
751 * while waiting.
752 */
753 static int
754 find_stopped_child(struct proc *parent, pid_t pid, int options,
755 struct proc **child_p, int *status_p)
756 {
757 struct proc *child, *dead;
758 int error;
759
760 KASSERT(mutex_owned(&proclist_lock));
761
762 if (options & ~(WUNTRACED|WNOHANG|WALTSIG|WALLSIG)
763 && !(options & WOPTSCHECKED)) {
764 *child_p = NULL;
765 return EINVAL;
766 }
767
768 if (pid == 0 && !(options & WOPTSCHECKED))
769 pid = -parent->p_pgid;
770
771 for (;;) {
772 error = ECHILD;
773 dead = NULL;
774
775 mutex_enter(&proclist_mutex);
776 LIST_FOREACH(child, &parent->p_children, p_sibling) {
777 if (pid >= 0) {
778 if (child->p_pid != pid) {
779 child = p_find(pid, PFIND_ZOMBIE |
780 PFIND_LOCKED);
781 if (child == NULL ||
782 child->p_pptr != parent) {
783 child = NULL;
784 break;
785 }
786 }
787 } else if (pid != WAIT_ANY && child->p_pgid != -pid) {
788 /* Child not in correct pgrp */
789 continue;
790 }
791
792 /*
793 * Wait for processes with p_exitsig != SIGCHLD
794 * processes only if WALTSIG is set; wait for
795 * processes with p_exitsig == SIGCHLD only
796 * if WALTSIG is clear.
797 */
798 if (((options & WALLSIG) == 0) &&
799 (options & WALTSIG ? child->p_exitsig == SIGCHLD
800 : P_EXITSIG(child) != SIGCHLD)){
801 if (child->p_pid == pid) {
802 child = NULL;
803 break;
804 }
805 continue;
806 }
807
808 error = 0;
809 if ((options & WNOZOMBIE) == 0) {
810 if (child->p_stat == SZOMB)
811 break;
812 if (child->p_stat == SDEAD) {
813 /*
814 * We may occasionally arrive here
815 * after receiving a signal, but
816 * immediatley before the child
817 * process is zombified. The wait
818 * will be short, so avoid returning
819 * to userspace.
820 */
821 dead = child;
822 }
823 }
824
825 if (child->p_stat == SSTOP &&
826 child->p_waited == 0 &&
827 (child->p_slflag & PSL_TRACED ||
828 options & WUNTRACED)) {
829 if ((options & WNOWAIT) == 0) {
830 child->p_waited = 1;
831 parent->p_nstopchild--;
832 }
833 break;
834 }
835 if (parent->p_nstopchild == 0 || child->p_pid == pid) {
836 child = NULL;
837 break;
838 }
839 }
840
841 if (child != NULL || error != 0 ||
842 ((options & WNOHANG) != 0 && dead == NULL)) {
843 if (child != NULL) {
844 *status_p = child->p_xstat;
845 }
846 mutex_exit(&proclist_mutex);
847 *child_p = child;
848 return error;
849 }
850
851 /*
852 * Wait for another child process to stop.
853 */
854 mutex_exit(&proclist_lock);
855 error = cv_wait_sig(&parent->p_waitcv, &proclist_mutex);
856 mutex_exit(&proclist_mutex);
857 mutex_enter(&proclist_lock);
858
859 if (error != 0) {
860 *child_p = NULL;
861 return error;
862 }
863 }
864 }
865
866 /*
867 * Free a process after parent has taken all the state info. Must be called
868 * with the proclist lock held, and will release before returning.
869 *
870 * *ru is returned to the caller, and must be freed by the caller.
871 */
872 static void
873 proc_free(struct proc *p, struct rusage *ru)
874 {
875 struct proc *parent;
876 struct lwp *l;
877 ksiginfo_t ksi;
878 kauth_cred_t cred1, cred2;
879 uid_t uid;
880
881 KASSERT(mutex_owned(&proclist_lock));
882 KASSERT(p->p_nlwps == 1);
883 KASSERT(p->p_nzlwps == 1);
884 KASSERT(p->p_nrlwps == 0);
885 KASSERT(p->p_stat == SZOMB);
886
887 /*
888 * If we got the child via ptrace(2) or procfs, and
889 * the parent is different (meaning the process was
890 * attached, rather than run as a child), then we need
891 * to give it back to the old parent, and send the
892 * parent the exit signal. The rest of the cleanup
893 * will be done when the old parent waits on the child.
894 */
895 if ((p->p_slflag & PSL_TRACED) != 0) {
896 parent = p->p_pptr;
897 if (p->p_opptr != parent){
898 mutex_enter(&p->p_smutex);
899 p->p_slflag &= ~(PSL_TRACED|PSL_FSTRACE|PSL_SYSCALL);
900 mutex_exit(&p->p_smutex);
901 parent = p->p_opptr;
902 if (parent == NULL)
903 parent = initproc;
904 proc_reparent(p, parent);
905 p->p_opptr = NULL;
906 if (p->p_exitsig != 0) {
907 exit_psignal(p, parent, &ksi);
908 mutex_enter(&proclist_mutex);
909 kpsignal(parent, &ksi, NULL);
910 mutex_exit(&proclist_mutex);
911 }
912 cv_broadcast(&parent->p_waitcv);
913 mutex_exit(&proclist_lock);
914 return;
915 }
916 }
917
918 /*
919 * Finally finished with old proc entry. Unlink it from its process
920 * group.
921 */
922 leavepgrp(p);
923
924 parent = p->p_pptr;
925 sched_proc_exit(parent, p);
926 /*
927 * Add child times of exiting process onto its own times.
928 * This cannot be done any earlier else it might get done twice.
929 */
930 ruadd(&p->p_stats->p_ru, &p->p_stats->p_cru);
931 ruadd(&parent->p_stats->p_cru, &p->p_stats->p_ru);
932 if (ru != NULL)
933 *ru = p->p_stats->p_ru;
934 p->p_xstat = 0;
935
936 /*
937 * At this point we are going to start freeing the final resources.
938 * If anyone tries to access the proc structure after here they will
939 * get a shock - bits are missing. Attempt to make it hard! We
940 * don't bother with any further locking past this point.
941 */
942 mutex_enter(&proclist_mutex);
943 p->p_stat = SIDL; /* not even a zombie any more */
944 LIST_REMOVE(p, p_list); /* off zombproc */
945 parent = p->p_pptr;
946 p->p_pptr->p_nstopchild--;
947 mutex_exit(&proclist_mutex);
948 LIST_REMOVE(p, p_sibling);
949
950 /*
951 * Let pid be reallocated.
952 */
953 proc_free_pid(p);
954 mutex_exit(&proclist_lock);
955
956 l = LIST_FIRST(&p->p_lwps);
957
958 /*
959 * Delay release until after lwp_free.
960 */
961 cred2 = l->l_cred;
962
963 /*
964 * Free the last LWP's resources.
965 *
966 * lwp_free ensures the LWP is no longer running on another CPU.
967 */
968 lwp_free(l, false, true);
969
970 /*
971 * Now no one except us can reach the process p.
972 */
973
974 /*
975 * Decrement the count of procs running with this uid.
976 */
977 cred1 = p->p_cred;
978 uid = kauth_cred_getuid(cred1);
979 (void)chgproccnt(uid, -1);
980
981 /*
982 * Release substructures.
983 */
984
985 limfree(p->p_limit);
986 pstatsfree(p->p_stats);
987 kauth_cred_free(cred1);
988 kauth_cred_free(cred2);
989
990 /*
991 * Release reference to text vnode
992 */
993 if (p->p_textvp)
994 vrele(p->p_textvp);
995
996 mutex_destroy(&p->p_raslock);
997 mutex_destroy(&p->p_mutex);
998 mutex_destroy(&p->p_stmutex);
999 mutex_destroy(&p->p_smutex);
1000 cv_destroy(&p->p_waitcv);
1001 cv_destroy(&p->p_lwpcv);
1002 rw_destroy(&p->p_reflock);
1003
1004 pool_put(&proc_pool, p);
1005
1006 /*
1007 * Collect child u-areas.
1008 */
1009 uvm_uarea_drain(false);
1010 }
1011
1012 /*
1013 * make process 'parent' the new parent of process 'child'.
1014 *
1015 * Must be called with proclist_lock lock held.
1016 */
1017 void
1018 proc_reparent(struct proc *child, struct proc *parent)
1019 {
1020
1021 KASSERT(mutex_owned(&proclist_lock));
1022
1023 if (child->p_pptr == parent)
1024 return;
1025
1026 mutex_enter(&proclist_mutex);
1027 if (child->p_stat == SZOMB ||
1028 (child->p_stat == SSTOP && !child->p_waited)) {
1029 child->p_pptr->p_nstopchild--;
1030 parent->p_nstopchild++;
1031 }
1032 mutex_exit(&proclist_mutex);
1033 if (parent == initproc)
1034 child->p_exitsig = SIGCHLD;
1035
1036 LIST_REMOVE(child, p_sibling);
1037 LIST_INSERT_HEAD(&parent->p_children, child, p_sibling);
1038 child->p_pptr = parent;
1039 }
1040