1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2011, Joyent, Inc. All rights reserved.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28
29 #include <sys/types.h>
30 #include <sys/param.h>
31 #include <sys/sysmacros.h>
32 #include <sys/systm.h>
33 #include <sys/cred.h>
34 #include <sys/user.h>
35 #include <sys/errno.h>
36 #include <sys/proc.h>
37 #include <sys/ucontext.h>
38 #include <sys/procfs.h>
39 #include <sys/vnode.h>
40 #include <sys/acct.h>
41 #include <sys/var.h>
42 #include <sys/cmn_err.h>
43 #include <sys/debug.h>
44 #include <sys/wait.h>
45 #include <sys/siginfo.h>
46 #include <sys/procset.h>
47 #include <sys/class.h>
48 #include <sys/file.h>
49 #include <sys/session.h>
50 #include <sys/kmem.h>
51 #include <sys/vtrace.h>
52 #include <sys/prsystm.h>
53 #include <sys/ipc.h>
54 #include <sys/sem_impl.h>
55 #include <c2/audit.h>
56 #include <sys/aio_impl.h>
57 #include <vm/as.h>
58 #include <sys/poll.h>
59 #include <sys/door.h>
60 #include <sys/lwpchan_impl.h>
61 #include <sys/utrap.h>
62 #include <sys/task.h>
63 #include <sys/exacct.h>
64 #include <sys/cyclic.h>
65 #include <sys/schedctl.h>
66 #include <sys/rctl.h>
67 #include <sys/contract_impl.h>
68 #include <sys/contract/process_impl.h>
69 #include <sys/list.h>
70 #include <sys/dtrace.h>
71 #include <sys/pool.h>
72 #include <sys/sdt.h>
73 #include <sys/corectl.h>
74 #include <sys/brand.h>
75 #include <sys/libc_kernel.h>
76
77 /*
78 * convert code/data pair into old style wait status
79 */
80 int
81 wstat(int code, int data)
82 {
83 int stat = (data & 0377);
84
85 switch (code) {
86 case CLD_EXITED:
87 stat <<= 8;
88 break;
89 case CLD_DUMPED:
90 stat |= WCOREFLG;
91 break;
92 case CLD_KILLED:
93 break;
94 case CLD_TRAPPED:
95 case CLD_STOPPED:
96 stat <<= 8;
97 stat |= WSTOPFLG;
98 break;
99 case CLD_CONTINUED:
100 stat = WCONTFLG;
101 break;
102 default:
103 cmn_err(CE_PANIC, "wstat: bad code");
104 /* NOTREACHED */
105 }
106 return (stat);
107 }
108
109 static char *
110 exit_reason(char *buf, size_t bufsz, int what, int why)
111 {
112 switch (why) {
113 case CLD_EXITED:
114 (void) snprintf(buf, bufsz, "exited with status %d", what);
115 break;
116 case CLD_KILLED:
117 (void) snprintf(buf, bufsz, "exited on fatal signal %d", what);
118 break;
119 case CLD_DUMPED:
120 (void) snprintf(buf, bufsz, "core dumped on signal %d", what);
121 break;
122 default:
123 (void) snprintf(buf, bufsz, "encountered unknown error "
124 "(%d, %d)", why, what);
125 break;
126 }
127
128 return (buf);
129 }
130
131 /*
132 * exit system call: pass back caller's arg.
133 */
134 void
135 rexit(int rval)
136 {
137 exit(CLD_EXITED, rval);
138 }
139
140 /*
141 * Called by proc_exit() when a zone's init exits, presumably because
142 * it failed. As long as the given zone is still in the "running"
143 * state, we will re-exec() init, but first we need to reset things
144 * which are usually inherited across exec() but will break init's
145 * assumption that it is being exec()'d from a virgin process. Most
146 * importantly this includes closing all file descriptors (exec only
147 * closes those marked close-on-exec) and resetting signals (exec only
148 * resets handled signals, and we need to clear any signals which
149 * killed init). Anything else that exec(2) says would be inherited,
150 * but would affect the execution of init, needs to be reset.
151 */
152 static int
153 restart_init(int what, int why)
154 {
155 kthread_t *t = curthread;
156 klwp_t *lwp = ttolwp(t);
157 proc_t *p = ttoproc(t);
158 user_t *up = PTOU(p);
159
160 vnode_t *oldcd, *oldrd;
161 int i, err;
162 char reason_buf[64];
163
164 /*
165 * Let zone admin (and global zone admin if this is for a non-global
166 * zone) know that init has failed and will be restarted.
167 */
168 zcmn_err(p->p_zone->zone_id, CE_WARN,
169 "init(1M) %s: restarting automatically",
170 exit_reason(reason_buf, sizeof (reason_buf), what, why));
171
172 if (!INGLOBALZONE(p)) {
173 cmn_err(CE_WARN, "init(1M) for zone %s (pid %d) %s: "
174 "restarting automatically",
175 p->p_zone->zone_name, p->p_pid, reason_buf);
176 }
177
178 /*
179 * Remove any fpollinfo_t's for this (last) thread from our file
180 * descriptors so closeall() can ASSERT() that they're all gone.
181 * Then close all open file descriptors in the process.
182 */
183 pollcleanup();
184 closeall(P_FINFO(p));
185
186 /*
187 * Grab p_lock and begin clearing miscellaneous global process
188 * state that needs to be reset before we exec the new init(1M).
189 */
190
191 mutex_enter(&p->p_lock);
192 prbarrier(p);
193
194 p->p_flag &= ~(SKILLED | SEXTKILLED | SEXITING | SDOCORE);
195 up->u_cmask = CMASK;
196
197 sigemptyset(&t->t_hold);
198 sigemptyset(&t->t_sig);
199 sigemptyset(&t->t_extsig);
200
201 sigemptyset(&p->p_sig);
202 sigemptyset(&p->p_extsig);
203
204 sigdelq(p, t, 0);
205 sigdelq(p, NULL, 0);
206
207 if (p->p_killsqp) {
208 siginfofree(p->p_killsqp);
209 p->p_killsqp = NULL;
210 }
211
212 /*
213 * Reset any signals that are ignored back to the default disposition.
214 * Other u_signal members will be cleared when exec calls sigdefault().
215 */
216 for (i = 1; i < NSIG; i++) {
217 if (up->u_signal[i - 1] == SIG_IGN) {
218 up->u_signal[i - 1] = SIG_DFL;
219 sigemptyset(&up->u_sigmask[i - 1]);
220 }
221 }
222
223 /*
224 * Clear the current signal, any signal info associated with it, and
225 * any signal information from contracts and/or contract templates.
226 */
227 lwp->lwp_cursig = 0;
228 lwp->lwp_extsig = 0;
229 if (lwp->lwp_curinfo != NULL) {
230 siginfofree(lwp->lwp_curinfo);
231 lwp->lwp_curinfo = NULL;
232 }
233 lwp_ctmpl_clear(lwp);
234
235 /*
236 * Reset both the process root directory and the current working
237 * directory to the root of the zone just as we do during boot.
238 */
239 VN_HOLD(p->p_zone->zone_rootvp);
240 oldrd = up->u_rdir;
241 up->u_rdir = p->p_zone->zone_rootvp;
242
243 VN_HOLD(p->p_zone->zone_rootvp);
244 oldcd = up->u_cdir;
245 up->u_cdir = p->p_zone->zone_rootvp;
246
247 if (up->u_cwd != NULL) {
248 refstr_rele(up->u_cwd);
249 up->u_cwd = NULL;
250 }
251
252 mutex_exit(&p->p_lock);
253
254 if (oldrd != NULL)
255 VN_RELE(oldrd);
256 if (oldcd != NULL)
257 VN_RELE(oldcd);
258
259 /* Free the controlling tty. (freectty() always assumes curproc.) */
260 ASSERT(p == curproc);
261 (void) freectty(B_TRUE);
262
263 /*
264 * Now exec() the new init(1M) on top of the current process. If we
265 * succeed, the caller will treat this like a successful system call.
266 * If we fail, we issue messages and the caller will proceed with exit.
267 */
268 err = exec_init(p->p_zone->zone_initname, NULL);
269
270 if (err == 0)
271 return (0);
272
273 zcmn_err(p->p_zone->zone_id, CE_WARN,
274 "failed to restart init(1M) (err=%d): system reboot required", err);
275
276 if (!INGLOBALZONE(p)) {
277 cmn_err(CE_WARN, "failed to restart init(1M) for zone %s "
278 "(pid %d, err=%d): zoneadm(1M) boot required",
279 p->p_zone->zone_name, p->p_pid, err);
280 }
281
282 return (-1);
283 }
284
285 /*
286 * Release resources.
287 * Enter zombie state.
288 * Wake up parent and init processes,
289 * and dispose of children.
290 */
291 void
292 exit(int why, int what)
293 {
294 /*
295 * If proc_exit() fails, then some other lwp in the process
296 * got there first. We just have to call lwp_exit() to allow
297 * the other lwp to finish exiting the process. Otherwise we're
298 * restarting init, and should return.
299 */
300 if (proc_exit(why, what) != 0) {
301 mutex_enter(&curproc->p_lock);
302 ASSERT(curproc->p_flag & SEXITLWPS);
303 lwp_exit();
304 /* NOTREACHED */
305 }
306 }
307
308 /*
309 * Set the SEXITING flag on the process, after making sure /proc does
310 * not have it locked. This is done in more places than proc_exit(),
311 * so it is a separate function.
312 */
313 void
314 proc_is_exiting(proc_t *p)
315 {
316 mutex_enter(&p->p_lock);
317 prbarrier(p);
318 p->p_flag |= SEXITING;
319 mutex_exit(&p->p_lock);
320 }
321
322 /*
323 * Return value:
324 * 1 - exitlwps() failed, call (or continue) lwp_exit()
325 * 0 - restarting init. Return through system call path
326 */
327 int
328 proc_exit(int why, int what)
329 {
330 kthread_t *t = curthread;
331 klwp_t *lwp = ttolwp(t);
332 proc_t *p = ttoproc(t);
333 zone_t *z = p->p_zone;
334 timeout_id_t tmp_id;
335 int rv;
336 proc_t *q;
337 task_t *tk;
338 vnode_t *exec_vp, *execdir_vp, *cdir, *rdir;
339 sigqueue_t *sqp;
340 lwpdir_t *lwpdir;
341 uint_t lwpdir_sz;
342 tidhash_t *tidhash;
343 uint_t tidhash_sz;
344 ret_tidhash_t *ret_tidhash;
345 refstr_t *cwd;
346 hrtime_t hrutime, hrstime;
347 int evaporate;
348
349 /*
350 * Stop and discard the process's lwps except for the current one,
351 * unless some other lwp beat us to it. If exitlwps() fails then
352 * return and the calling lwp will call (or continue in) lwp_exit().
353 */
354 proc_is_exiting(p);
355 if (exitlwps(0) != 0)
356 return (1);
357
358 mutex_enter(&p->p_lock);
359 if (p->p_ttime > 0) {
360 /*
361 * Account any remaining ticks charged to this process
362 * on its way out.
363 */
364 (void) task_cpu_time_incr(p->p_task, p->p_ttime);
365 p->p_ttime = 0;
366 }
367 mutex_exit(&p->p_lock);
368
369 DTRACE_PROC(lwp__exit);
370 DTRACE_PROC1(exit, int, why);
371
372 /*
373 * Will perform any brand specific proc exit processing, since this
374 * is always the last lwp, will also perform lwp_exit and free brand
375 * data
376 */
377 if (PROC_IS_BRANDED(p)) {
378 lwp_detach_brand_hdlrs(lwp);
379 brand_clearbrand(p, B_FALSE);
380 }
381
382 /*
383 * Don't let init exit unless zone_start_init() failed its exec, or
384 * we are shutting down the zone or the machine.
385 *
386 * Since we are single threaded, we don't need to lock the
387 * following accesses to zone_proc_initpid.
388 */
389 if (p->p_pid == z->zone_proc_initpid) {
390 if (z->zone_boot_err == 0 &&
391 zone_status_get(z) < ZONE_IS_SHUTTING_DOWN &&
392 zone_status_get(global_zone) < ZONE_IS_SHUTTING_DOWN) {
393 if (z->zone_restart_init == B_TRUE) {
394 if (restart_init(what, why) == 0)
395 return (0);
396 } else {
397 (void) zone_kadmin(A_SHUTDOWN, AD_HALT, NULL,
398 CRED());
399 }
400 }
401
402 /*
403 * Since we didn't or couldn't restart init, we clear
404 * the zone's init state and proceed with exit
405 * processing.
406 */
407 z->zone_proc_initpid = -1;
408 }
409
410 lwp_pcb_exit();
411
412 /*
413 * Allocate a sigqueue now, before we grab locks.
414 * It will be given to sigcld(), below.
415 * Special case: If we will be making the process disappear
416 * without a trace because it is either:
417 * * an exiting SSYS process, or
418 * * a posix_spawn() vfork child who requests it,
419 * we don't bother to allocate a useless sigqueue.
420 */
421 evaporate = (p->p_flag & SSYS) || ((p->p_flag & SVFORK) &&
422 why == CLD_EXITED && what == _EVAPORATE);
423 if (!evaporate)
424 sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);
425
426 /*
427 * revoke any doors created by the process.
428 */
429 if (p->p_door_list)
430 door_exit();
431
432 /*
433 * Release schedctl data structures.
434 */
435 if (p->p_pagep)
436 schedctl_proc_cleanup();
437
438 /*
439 * make sure all pending kaio has completed.
440 */
441 if (p->p_aio)
442 aio_cleanup_exit();
443
444 /*
445 * discard the lwpchan cache.
446 */
447 if (p->p_lcp != NULL)
448 lwpchan_destroy_cache(0);
449
450 /*
451 * Clean up any DTrace helper actions or probes for the process.
452 */
453 if (p->p_dtrace_helpers != NULL) {
454 ASSERT(dtrace_helpers_cleanup != NULL);
455 (*dtrace_helpers_cleanup)();
456 }
457
458 /*
459 * Clean up any signalfd state for the process.
460 */
461 if (p->p_sigfd != NULL) {
462 VERIFY(sigfd_exit_helper != NULL);
463 (*sigfd_exit_helper)();
464 }
465
466 /* untimeout the realtime timers */
467 if (p->p_itimer != NULL)
468 timer_exit();
469
470 if ((tmp_id = p->p_alarmid) != 0) {
471 p->p_alarmid = 0;
472 (void) untimeout(tmp_id);
473 }
474
475 /*
476 * Remove any fpollinfo_t's for this (last) thread from our file
477 * descriptors so closeall() can ASSERT() that they're all gone.
478 */
479 pollcleanup();
480
481 if (p->p_rprof_cyclic != CYCLIC_NONE) {
482 mutex_enter(&cpu_lock);
483 cyclic_remove(p->p_rprof_cyclic);
484 mutex_exit(&cpu_lock);
485 }
486
487 mutex_enter(&p->p_lock);
488
489 /*
490 * Clean up any DTrace probes associated with this process.
491 */
492 if (p->p_dtrace_probes) {
493 ASSERT(dtrace_fasttrap_exit_ptr != NULL);
494 dtrace_fasttrap_exit_ptr(p);
495 }
496
497 while ((tmp_id = p->p_itimerid) != 0) {
498 p->p_itimerid = 0;
499 mutex_exit(&p->p_lock);
500 (void) untimeout(tmp_id);
501 mutex_enter(&p->p_lock);
502 }
503
504 lwp_cleanup();
505
506 /*
507 * We are about to exit; prevent our resource associations from
508 * being changed.
509 */
510 pool_barrier_enter();
511
512 /*
513 * Block the process against /proc now that we have really
514 * acquired p->p_lock (to manipulate p_tlist at least).
515 */
516 prbarrier(p);
517
518 sigfillset(&p->p_ignore);
519 sigemptyset(&p->p_siginfo);
520 sigemptyset(&p->p_sig);
521 sigemptyset(&p->p_extsig);
522 sigemptyset(&t->t_sig);
523 sigemptyset(&t->t_extsig);
524 sigemptyset(&p->p_sigmask);
525 sigdelq(p, t, 0);
526 lwp->lwp_cursig = 0;
527 lwp->lwp_extsig = 0;
528 p->p_flag &= ~(SKILLED | SEXTKILLED);
529 if (lwp->lwp_curinfo) {
530 siginfofree(lwp->lwp_curinfo);
531 lwp->lwp_curinfo = NULL;
532 }
533
534 t->t_proc_flag |= TP_LWPEXIT;
535 ASSERT(p->p_lwpcnt == 1 && p->p_zombcnt == 0);
536 prlwpexit(t); /* notify /proc */
537 lwp_hash_out(p, t->t_tid);
538 prexit(p);
539
540 p->p_lwpcnt = 0;
541 p->p_tlist = NULL;
542 sigqfree(p);
543 term_mstate(t);
544 p->p_mterm = gethrtime();
545
546 exec_vp = p->p_exec;
547 execdir_vp = p->p_execdir;
548 p->p_exec = NULLVP;
549 p->p_execdir = NULLVP;
550 mutex_exit(&p->p_lock);
551
552 pr_free_watched_pages(p);
553
554 closeall(P_FINFO(p));
555
556 /* Free the controlling tty. (freectty() always assumes curproc.) */
557 ASSERT(p == curproc);
558 (void) freectty(B_TRUE);
559
560 #if defined(__sparc)
561 if (p->p_utraps != NULL)
562 utrap_free(p);
563 #endif
564 if (p->p_semacct) /* IPC semaphore exit */
565 semexit(p);
566 rv = wstat(why, what);
567
568 acct(rv & 0xff);
569 exacct_commit_proc(p, rv);
570
571 /*
572 * Release any resources associated with C2 auditing
573 */
574 if (AU_AUDITING()) {
575 /*
576 * audit exit system call
577 */
578 audit_exit(why, what);
579 }
580
581 /*
582 * Free address space.
583 */
584 relvm();
585
586 if (exec_vp) {
587 /*
588 * Close this executable which has been opened when the process
589 * was created by getproc().
590 */
591 (void) VOP_CLOSE(exec_vp, FREAD, 1, (offset_t)0, CRED(), NULL);
592 VN_RELE(exec_vp);
593 }
594 if (execdir_vp)
595 VN_RELE(execdir_vp);
596
597 /*
598 * Release held contracts.
599 */
600 contract_exit(p);
601
602 /*
603 * Depart our encapsulating process contract.
604 */
605 if ((p->p_flag & SSYS) == 0) {
606 ASSERT(p->p_ct_process);
607 contract_process_exit(p->p_ct_process, p, rv);
608 }
609
610 /*
611 * Remove pool association, and block if requested by pool_do_bind.
612 */
613 mutex_enter(&p->p_lock);
614 ASSERT(p->p_pool->pool_ref > 0);
615 atomic_dec_32(&p->p_pool->pool_ref);
616 p->p_pool = pool_default;
617 /*
618 * Now that our address space has been freed and all other threads
619 * in this process have exited, set the PEXITED pool flag. This
620 * tells the pools subsystems to ignore this process if it was
621 * requested to rebind this process to a new pool.
622 */
623 p->p_poolflag |= PEXITED;
624 pool_barrier_exit();
625 mutex_exit(&p->p_lock);
626
627 mutex_enter(&pidlock);
628
629 /*
630 * Delete this process from the newstate list of its parent. We
631 * will put it in the right place in the sigcld in the end.
632 */
633 delete_ns(p->p_parent, p);
634
635 /*
636 * Reassign the orphans to the next of kin.
637 * Don't rearrange init's orphanage.
638 */
639 if ((q = p->p_orphan) != NULL && p != proc_init) {
640
641 proc_t *nokp = p->p_nextofkin;
642
643 for (;;) {
644 q->p_nextofkin = nokp;
645 if (q->p_nextorph == NULL)
646 break;
647 q = q->p_nextorph;
648 }
649 q->p_nextorph = nokp->p_orphan;
650 nokp->p_orphan = p->p_orphan;
651 p->p_orphan = NULL;
652 }
653
654 /*
655 * Reassign the children to init.
656 * Don't try to assign init's children to init.
657 */
658 if ((q = p->p_child) != NULL && p != proc_init) {
659 struct proc *np;
660 struct proc *initp = proc_init;
661 boolean_t setzonetop = B_FALSE;
662
663 if (!INGLOBALZONE(curproc))
664 setzonetop = B_TRUE;
665
666 pgdetach(p);
667
668 do {
669 np = q->p_sibling;
670 /*
671 * Delete it from its current parent new state
672 * list and add it to init new state list
673 */
674 delete_ns(q->p_parent, q);
675
676 q->p_ppid = 1;
677 q->p_pidflag &= ~(CLDNOSIGCHLD | CLDWAITPID);
678 if (setzonetop) {
679 mutex_enter(&q->p_lock);
680 q->p_flag |= SZONETOP;
681 mutex_exit(&q->p_lock);
682 }
683 q->p_parent = initp;
684
685 /*
686 * Since q will be the first child,
687 * it will not have a previous sibling.
688 */
689 q->p_psibling = NULL;
690 if (initp->p_child) {
691 initp->p_child->p_psibling = q;
692 }
693 q->p_sibling = initp->p_child;
694 initp->p_child = q;
695 if (q->p_proc_flag & P_PR_PTRACE) {
696 mutex_enter(&q->p_lock);
697 sigtoproc(q, NULL, SIGKILL);
698 mutex_exit(&q->p_lock);
699 }
700 /*
701 * sigcld() will add the child to parents
702 * newstate list.
703 */
704 if (q->p_stat == SZOMB)
705 sigcld(q, NULL);
706 } while ((q = np) != NULL);
707
708 p->p_child = NULL;
709 ASSERT(p->p_child_ns == NULL);
710 }
711
712 TRACE_1(TR_FAC_PROC, TR_PROC_EXIT, "proc_exit: %p", p);
713
714 mutex_enter(&p->p_lock);
715 CL_EXIT(curthread); /* tell the scheduler that curthread is exiting */
716
717 /*
718 * Have our task accummulate our resource usage data before they
719 * become contaminated by p_cacct etc., and before we renounce
720 * membership of the task.
721 *
722 * We do this regardless of whether or not task accounting is active.
723 * This is to avoid having nonsense data reported for this task if
724 * task accounting is subsequently enabled. The overhead is minimal;
725 * by this point, this process has accounted for the usage of all its
726 * LWPs. We nonetheless do the work here, and under the protection of
727 * pidlock, so that the movement of the process's usage to the task
728 * happens at the same time as the removal of the process from the
729 * task, from the point of view of exacct_snapshot_task_usage().
730 */
731 exacct_update_task_mstate(p);
732
733 hrutime = mstate_aggr_state(p, LMS_USER);
734 hrstime = mstate_aggr_state(p, LMS_SYSTEM);
735 p->p_utime = (clock_t)NSEC_TO_TICK(hrutime) + p->p_cutime;
736 p->p_stime = (clock_t)NSEC_TO_TICK(hrstime) + p->p_cstime;
737
738 p->p_acct[LMS_USER] += p->p_cacct[LMS_USER];
739 p->p_acct[LMS_SYSTEM] += p->p_cacct[LMS_SYSTEM];
740 p->p_acct[LMS_TRAP] += p->p_cacct[LMS_TRAP];
741 p->p_acct[LMS_TFAULT] += p->p_cacct[LMS_TFAULT];
742 p->p_acct[LMS_DFAULT] += p->p_cacct[LMS_DFAULT];
743 p->p_acct[LMS_KFAULT] += p->p_cacct[LMS_KFAULT];
744 p->p_acct[LMS_USER_LOCK] += p->p_cacct[LMS_USER_LOCK];
745 p->p_acct[LMS_SLEEP] += p->p_cacct[LMS_SLEEP];
746 p->p_acct[LMS_WAIT_CPU] += p->p_cacct[LMS_WAIT_CPU];
747 p->p_acct[LMS_STOPPED] += p->p_cacct[LMS_STOPPED];
748
749 p->p_ru.minflt += p->p_cru.minflt;
750 p->p_ru.majflt += p->p_cru.majflt;
751 p->p_ru.nswap += p->p_cru.nswap;
752 p->p_ru.inblock += p->p_cru.inblock;
753 p->p_ru.oublock += p->p_cru.oublock;
754 p->p_ru.msgsnd += p->p_cru.msgsnd;
755 p->p_ru.msgrcv += p->p_cru.msgrcv;
756 p->p_ru.nsignals += p->p_cru.nsignals;
757 p->p_ru.nvcsw += p->p_cru.nvcsw;
758 p->p_ru.nivcsw += p->p_cru.nivcsw;
759 p->p_ru.sysc += p->p_cru.sysc;
760 p->p_ru.ioch += p->p_cru.ioch;
761
762 p->p_stat = SZOMB;
763 p->p_proc_flag &= ~P_PR_PTRACE;
764 p->p_wdata = what;
765 p->p_wcode = (char)why;
766
767 cdir = PTOU(p)->u_cdir;
768 rdir = PTOU(p)->u_rdir;
769 cwd = PTOU(p)->u_cwd;
770
771 ASSERT(cdir != NULL || p->p_parent == &p0);
772
773 /*
774 * Release resource controls, as they are no longer enforceable.
775 */
776 rctl_set_free(p->p_rctls);
777
778 /*
779 * Decrement tk_nlwps counter for our task.max-lwps resource control.
780 * An extended accounting record, if that facility is active, is
781 * scheduled to be written. We cannot give up task and project
782 * membership at this point because that would allow zombies to escape
783 * from the max-processes resource controls. Zombies stay in their
784 * current task and project until the process table slot is released
785 * in freeproc().
786 */
787 tk = p->p_task;
788
789 mutex_enter(&p->p_zone->zone_nlwps_lock);
790 tk->tk_nlwps--;
791 tk->tk_proj->kpj_nlwps--;
792 p->p_zone->zone_nlwps--;
793 mutex_exit(&p->p_zone->zone_nlwps_lock);
794
795 /*
796 * Clear the lwp directory and the lwpid hash table
797 * now that /proc can't bother us any more.
798 * We free the memory below, after dropping p->p_lock.
799 */
800 lwpdir = p->p_lwpdir;
801 lwpdir_sz = p->p_lwpdir_sz;
802 tidhash = p->p_tidhash;
803 tidhash_sz = p->p_tidhash_sz;
804 ret_tidhash = p->p_ret_tidhash;
805 p->p_lwpdir = NULL;
806 p->p_lwpfree = NULL;
807 p->p_lwpdir_sz = 0;
808 p->p_tidhash = NULL;
809 p->p_tidhash_sz = 0;
810 p->p_ret_tidhash = NULL;
811
812 /*
813 * If the process has context ops installed, call the exit routine
814 * on behalf of this last remaining thread. Normally exitpctx() is
815 * called during thread_exit() or lwp_exit(), but because this is the
816 * last thread in the process, we must call it here. By the time
817 * thread_exit() is called (below), the association with the relevant
818 * process has been lost.
819 *
820 * We also free the context here.
821 */
822 if (p->p_pctx) {
823 kpreempt_disable();
824 exitpctx(p);
825 kpreempt_enable();
826
827 freepctx(p, 0);
828 }
829
830 /*
831 * curthread's proc pointer is changed to point to the 'sched'
832 * process for the corresponding zone, except in the case when
833 * the exiting process is in fact a zsched instance, in which
834 * case the proc pointer is set to p0. We do so, so that the
835 * process still points at the right zone when we call the VN_RELE()
836 * below.
837 *
838 * This is because curthread's original proc pointer can be freed as
839 * soon as the child sends a SIGCLD to its parent. We use zsched so
840 * that for user processes, even in the final moments of death, the
841 * process is still associated with its zone.
842 */
843 if (p != t->t_procp->p_zone->zone_zsched)
844 t->t_procp = t->t_procp->p_zone->zone_zsched;
845 else
846 t->t_procp = &p0;
847
848 mutex_exit(&p->p_lock);
849 if (!evaporate) {
850 p->p_pidflag &= ~CLDPEND;
851 sigcld(p, sqp);
852 } else {
853 /*
854 * Do what sigcld() would do if the disposition
855 * of the SIGCHLD signal were set to be ignored.
856 */
857 cv_broadcast(&p->p_srwchan_cv);
858 freeproc(p);
859 }
860 mutex_exit(&pidlock);
861
862 /*
863 * We don't release u_cdir and u_rdir until SZOMB is set.
864 * This protects us against dofusers().
865 */
866 if (cdir)
867 VN_RELE(cdir);
868 if (rdir)
869 VN_RELE(rdir);
870 if (cwd)
871 refstr_rele(cwd);
872
873 /*
874 * task_rele() may ultimately cause the zone to go away (or
875 * may cause the last user process in a zone to go away, which
876 * signals zsched to go away). So prior to this call, we must
877 * no longer point at zsched.
878 */
879 t->t_procp = &p0;
880
881 kmem_free(lwpdir, lwpdir_sz * sizeof (lwpdir_t));
882 kmem_free(tidhash, tidhash_sz * sizeof (tidhash_t));
883 while (ret_tidhash != NULL) {
884 ret_tidhash_t *next = ret_tidhash->rth_next;
885 kmem_free(ret_tidhash->rth_tidhash,
886 ret_tidhash->rth_tidhash_sz * sizeof (tidhash_t));
887 kmem_free(ret_tidhash, sizeof (*ret_tidhash));
888 ret_tidhash = next;
889 }
890
891 thread_exit();
892 /* NOTREACHED */
893 }
894
895 /*
896 * Format siginfo structure for wait system calls.
897 */
898 void
899 winfo(proc_t *pp, k_siginfo_t *ip, int waitflag)
900 {
901 ASSERT(MUTEX_HELD(&pidlock));
902
903 bzero(ip, sizeof (k_siginfo_t));
904 ip->si_signo = SIGCLD;
905 ip->si_code = pp->p_wcode;
906 ip->si_pid = pp->p_pid;
907 ip->si_ctid = PRCTID(pp);
908 ip->si_zoneid = pp->p_zone->zone_id;
909 ip->si_status = pp->p_wdata;
910 ip->si_stime = pp->p_stime;
911 ip->si_utime = pp->p_utime;
912
913 if (waitflag) {
914 pp->p_wcode = 0;
915 pp->p_wdata = 0;
916 pp->p_pidflag &= ~CLDPEND;
917 }
918 }
919
920 /*
921 * Wait system call.
922 * Search for a terminated (zombie) child,
923 * finally lay it to rest, and collect its status.
924 * Look also for stopped children,
925 * and pass back status from them.
926 */
927 int
928 waitid(idtype_t idtype, id_t id, k_siginfo_t *ip, int options)
929 {
930 int found;
931 proc_t *cp, *pp;
932 int proc_gone;
933 int waitflag = !(options & WNOWAIT);
934
935 /*
936 * Obsolete flag, defined here only for binary compatibility
937 * with old statically linked executables. Delete this when
938 * we no longer care about these old and broken applications.
939 */
940 #define _WNOCHLD 0400
941 options &= ~_WNOCHLD;
942
943 if (options == 0 || (options & ~WOPTMASK))
944 return (EINVAL);
945
946 switch (idtype) {
947 case P_PID:
948 case P_PGID:
949 if (id < 0 || id >= maxpid)
950 return (EINVAL);
951 /* FALLTHROUGH */
952 case P_ALL:
953 break;
954 default:
955 return (EINVAL);
956 }
957
958 pp = ttoproc(curthread);
959
960 /*
961 * lock parent mutex so that sibling chain can be searched.
962 */
963 mutex_enter(&pidlock);
964
965 /*
966 * if we are only looking for exited processes and child_ns list
967 * is empty no reason to look at all children.
968 */
969 if (idtype == P_ALL &&
970 (options & ~WNOWAIT) == (WNOHANG | WEXITED) &&
971 pp->p_child_ns == NULL) {
972 if (pp->p_child) {
973 mutex_exit(&pidlock);
974 bzero(ip, sizeof (k_siginfo_t));
975 return (0);
976 }
977 mutex_exit(&pidlock);
978 return (ECHILD);
979 }
980
981 while (pp->p_child != NULL) {
982
983 proc_gone = 0;
984
985 for (cp = pp->p_child_ns; cp != NULL; cp = cp->p_sibling_ns) {
986 if (idtype != P_PID && (cp->p_pidflag & CLDWAITPID))
987 continue;
988 if (idtype == P_PID && id != cp->p_pid)
989 continue;
990 if (idtype == P_PGID && id != cp->p_pgrp)
991 continue;
992
993 switch (cp->p_wcode) {
994
995 case CLD_TRAPPED:
996 case CLD_STOPPED:
997 case CLD_CONTINUED:
998 cmn_err(CE_PANIC,
999 "waitid: wrong state %d on the p_newstate"
1000 " list", cp->p_wcode);
1001 break;
1002
1003 case CLD_EXITED:
1004 case CLD_DUMPED:
1005 case CLD_KILLED:
1006 if (!(options & WEXITED)) {
1007 /*
1008 * Count how many are already gone
1009 * for good.
1010 */
1011 proc_gone++;
1012 break;
1013 }
1014 if (!waitflag) {
1015 winfo(cp, ip, 0);
1016 } else {
1017 winfo(cp, ip, 1);
1018 freeproc(cp);
1019 }
1020 mutex_exit(&pidlock);
1021 if (waitflag) { /* accept SIGCLD */
1022 sigcld_delete(ip);
1023 sigcld_repost();
1024 }
1025 return (0);
1026 }
1027
1028 if (idtype == P_PID)
1029 break;
1030 }
1031
1032 /*
1033 * Wow! None of the threads on the p_sibling_ns list were
1034 * interesting threads. Check all the kids!
1035 */
1036 found = 0;
1037 for (cp = pp->p_child; cp != NULL; cp = cp->p_sibling) {
1038 if (idtype == P_PID && id != cp->p_pid)
1039 continue;
1040 if (idtype == P_PGID && id != cp->p_pgrp)
1041 continue;
1042
1043 switch (cp->p_wcode) {
1044 case CLD_TRAPPED:
1045 if (!(options & WTRAPPED))
1046 break;
1047 winfo(cp, ip, waitflag);
1048 mutex_exit(&pidlock);
1049 if (waitflag) { /* accept SIGCLD */
1050 sigcld_delete(ip);
1051 sigcld_repost();
1052 }
1053 return (0);
1054
1055 case CLD_STOPPED:
1056 if (!(options & WSTOPPED))
1057 break;
1058 /* Is it still stopped? */
1059 mutex_enter(&cp->p_lock);
1060 if (!jobstopped(cp)) {
1061 mutex_exit(&cp->p_lock);
1062 break;
1063 }
1064 mutex_exit(&cp->p_lock);
1065 winfo(cp, ip, waitflag);
1066 mutex_exit(&pidlock);
1067 if (waitflag) { /* accept SIGCLD */
1068 sigcld_delete(ip);
1069 sigcld_repost();
1070 }
1071 return (0);
1072
1073 case CLD_CONTINUED:
1074 if (!(options & WCONTINUED))
1075 break;
1076 winfo(cp, ip, waitflag);
1077 mutex_exit(&pidlock);
1078 if (waitflag) { /* accept SIGCLD */
1079 sigcld_delete(ip);
1080 sigcld_repost();
1081 }
1082 return (0);
1083
1084 case CLD_EXITED:
1085 case CLD_DUMPED:
1086 case CLD_KILLED:
1087 if (idtype != P_PID &&
1088 (cp->p_pidflag & CLDWAITPID))
1089 continue;
1090 /*
1091 * Don't complain if a process was found in
1092 * the first loop but we broke out of the loop
1093 * because of the arguments passed to us.
1094 */
1095 if (proc_gone == 0) {
1096 cmn_err(CE_PANIC,
1097 "waitid: wrong state on the"
1098 " p_child list");
1099 } else {
1100 break;
1101 }
1102 }
1103
1104 found++;
1105
1106 if (idtype == P_PID)
1107 break;
1108 }
1109
1110 /*
1111 * If we found no interesting processes at all,
1112 * break out and return ECHILD.
1113 */
1114 if (found + proc_gone == 0)
1115 break;
1116
1117 if (options & WNOHANG) {
1118 mutex_exit(&pidlock);
1119 bzero(ip, sizeof (k_siginfo_t));
1120 /*
1121 * We should set ip->si_signo = SIGCLD,
1122 * but there is an SVVS test that expects
1123 * ip->si_signo to be zero in this case.
1124 */
1125 return (0);
1126 }
1127
1128 /*
1129 * If we found no processes of interest that could
1130 * change state while we wait, we don't wait at all.
1131 * Get out with ECHILD according to SVID.
1132 */
1133 if (found == proc_gone)
1134 break;
1135
1136 if (!cv_wait_sig_swap(&pp->p_cv, &pidlock)) {
1137 mutex_exit(&pidlock);
1138 return (EINTR);
1139 }
1140 }
1141 mutex_exit(&pidlock);
1142 return (ECHILD);
1143 }
1144
1145 int
1146 waitsys(idtype_t idtype, id_t id, siginfo_t *infop, int options)
1147 {
1148 int error;
1149 k_siginfo_t info;
1150
1151 if (error = waitid(idtype, id, &info, options))
1152 return (set_errno(error));
1153 if (copyout(&info, infop, sizeof (k_siginfo_t)))
1154 return (set_errno(EFAULT));
1155 return (0);
1156 }
1157
1158 #ifdef _SYSCALL32_IMPL
1159
1160 int
1161 waitsys32(idtype_t idtype, id_t id, siginfo_t *infop, int options)
1162 {
1163 int error;
1164 k_siginfo_t info;
1165 siginfo32_t info32;
1166
1167 if (error = waitid(idtype, id, &info, options))
1168 return (set_errno(error));
1169 siginfo_kto32(&info, &info32);
1170 if (copyout(&info32, infop, sizeof (info32)))
1171 return (set_errno(EFAULT));
1172 return (0);
1173 }
1174
1175 #endif /* _SYSCALL32_IMPL */
1176
1177 void
1178 proc_detach(proc_t *p)
1179 {
1180 proc_t *q;
1181
1182 ASSERT(MUTEX_HELD(&pidlock));
1183
1184 q = p->p_parent;
1185 ASSERT(q != NULL);
1186
1187 /*
1188 * Take it off the newstate list of its parent
1189 */
1190 delete_ns(q, p);
1191
1192 if (q->p_child == p) {
1193 q->p_child = p->p_sibling;
1194 /*
1195 * If the parent has no children, it better not
1196 * have any with new states either!
1197 */
1198 ASSERT(q->p_child ? 1 : q->p_child_ns == NULL);
1199 }
1200
1201 if (p->p_sibling) {
1202 p->p_sibling->p_psibling = p->p_psibling;
1203 }
1204
1205 if (p->p_psibling) {
1206 p->p_psibling->p_sibling = p->p_sibling;
1207 }
1208 }
1209
1210 /*
1211 * Remove zombie children from the process table.
1212 */
1213 void
1214 freeproc(proc_t *p)
1215 {
1216 proc_t *q;
1217 task_t *tk;
1218
1219 ASSERT(p->p_stat == SZOMB);
1220 ASSERT(p->p_tlist == NULL);
1221 ASSERT(MUTEX_HELD(&pidlock));
1222
1223 sigdelq(p, NULL, 0);
1224 if (p->p_killsqp) {
1225 siginfofree(p->p_killsqp);
1226 p->p_killsqp = NULL;
1227 }
1228
1229 prfree(p); /* inform /proc */
1230
1231 /*
1232 * Don't free the init processes.
1233 * Other dying processes will access it.
1234 */
1235 if (p == proc_init)
1236 return;
1237
1238
1239 /*
1240 * We wait until now to free the cred structure because a
1241 * zombie process's credentials may be examined by /proc.
1242 * No cred locking needed because there are no threads at this point.
1243 */
1244 upcount_dec(crgetruid(p->p_cred), crgetzoneid(p->p_cred));
1245 crfree(p->p_cred);
1246 if (p->p_corefile != NULL) {
1247 corectl_path_rele(p->p_corefile);
1248 p->p_corefile = NULL;
1249 }
1250 if (p->p_content != NULL) {
1251 corectl_content_rele(p->p_content);
1252 p->p_content = NULL;
1253 }
1254
1255 if (p->p_nextofkin && !((p->p_nextofkin->p_flag & SNOWAIT) ||
1256 (PTOU(p->p_nextofkin)->u_signal[SIGCLD - 1] == SIG_IGN))) {
1257 /*
1258 * This should still do the right thing since p_utime/stime
1259 * get set to the correct value on process exit, so it
1260 * should get properly updated
1261 */
1262 p->p_nextofkin->p_cutime += p->p_utime;
1263 p->p_nextofkin->p_cstime += p->p_stime;
1264
1265 p->p_nextofkin->p_cacct[LMS_USER] += p->p_acct[LMS_USER];
1266 p->p_nextofkin->p_cacct[LMS_SYSTEM] += p->p_acct[LMS_SYSTEM];
1267 p->p_nextofkin->p_cacct[LMS_TRAP] += p->p_acct[LMS_TRAP];
1268 p->p_nextofkin->p_cacct[LMS_TFAULT] += p->p_acct[LMS_TFAULT];
1269 p->p_nextofkin->p_cacct[LMS_DFAULT] += p->p_acct[LMS_DFAULT];
1270 p->p_nextofkin->p_cacct[LMS_KFAULT] += p->p_acct[LMS_KFAULT];
1271 p->p_nextofkin->p_cacct[LMS_USER_LOCK]
1272 += p->p_acct[LMS_USER_LOCK];
1273 p->p_nextofkin->p_cacct[LMS_SLEEP] += p->p_acct[LMS_SLEEP];
1274 p->p_nextofkin->p_cacct[LMS_WAIT_CPU]
1275 += p->p_acct[LMS_WAIT_CPU];
1276 p->p_nextofkin->p_cacct[LMS_STOPPED] += p->p_acct[LMS_STOPPED];
1277
1278 p->p_nextofkin->p_cru.minflt += p->p_ru.minflt;
1279 p->p_nextofkin->p_cru.majflt += p->p_ru.majflt;
1280 p->p_nextofkin->p_cru.nswap += p->p_ru.nswap;
1281 p->p_nextofkin->p_cru.inblock += p->p_ru.inblock;
1282 p->p_nextofkin->p_cru.oublock += p->p_ru.oublock;
1283 p->p_nextofkin->p_cru.msgsnd += p->p_ru.msgsnd;
1284 p->p_nextofkin->p_cru.msgrcv += p->p_ru.msgrcv;
1285 p->p_nextofkin->p_cru.nsignals += p->p_ru.nsignals;
1286 p->p_nextofkin->p_cru.nvcsw += p->p_ru.nvcsw;
1287 p->p_nextofkin->p_cru.nivcsw += p->p_ru.nivcsw;
1288 p->p_nextofkin->p_cru.sysc += p->p_ru.sysc;
1289 p->p_nextofkin->p_cru.ioch += p->p_ru.ioch;
1290
1291 }
1292
1293 q = p->p_nextofkin;
1294 if (q && q->p_orphan == p)
1295 q->p_orphan = p->p_nextorph;
1296 else if (q) {
1297 for (q = q->p_orphan; q; q = q->p_nextorph)
1298 if (q->p_nextorph == p)
1299 break;
1300 ASSERT(q && q->p_nextorph == p);
1301 q->p_nextorph = p->p_nextorph;
1302 }
1303
1304 /*
1305 * The process table slot is being freed, so it is now safe to give up
1306 * task and project membership.
1307 */
1308 mutex_enter(&p->p_lock);
1309 tk = p->p_task;
1310 task_detach(p);
1311 mutex_exit(&p->p_lock);
1312
1313 proc_detach(p);
1314 pid_exit(p, tk); /* frees pid and proc structure */
1315
1316 task_rele(tk);
1317 }
1318
1319 /*
1320 * Delete process "child" from the newstate list of process "parent"
1321 */
1322 void
1323 delete_ns(proc_t *parent, proc_t *child)
1324 {
1325 proc_t **ns;
1326
1327 ASSERT(MUTEX_HELD(&pidlock));
1328 ASSERT(child->p_parent == parent);
1329 for (ns = &parent->p_child_ns; *ns != NULL; ns = &(*ns)->p_sibling_ns) {
1330 if (*ns == child) {
1331
1332 ASSERT((*ns)->p_parent == parent);
1333
1334 *ns = child->p_sibling_ns;
1335 child->p_sibling_ns = NULL;
1336 return;
1337 }
1338 }
1339 }
1340
1341 /*
1342 * Add process "child" to the new state list of process "parent"
1343 */
1344 void
1345 add_ns(proc_t *parent, proc_t *child)
1346 {
1347 ASSERT(child->p_sibling_ns == NULL);
1348 child->p_sibling_ns = parent->p_child_ns;
1349 parent->p_child_ns = child;
1350 }