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 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 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); 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 z->zone_restart_init == B_TRUE && 394 restart_init(what, why) == 0) 395 return (0); 396 /* 397 * Since we didn't or couldn't restart init, we clear 398 * the zone's init state and proceed with exit 399 * processing. 400 */ 401 z->zone_proc_initpid = -1; 402 } 403 404 /* 405 * Allocate a sigqueue now, before we grab locks. 406 * It will be given to sigcld(), below. 407 * Special case: If we will be making the process disappear 408 * without a trace (for the benefit of posix_spawn() in libc) 409 * don't bother to allocate a useless sigqueue. 410 */ 411 evaporate = ((p->p_flag & SVFORK) && 412 why == CLD_EXITED && what == _EVAPORATE); 413 if (!evaporate) 414 sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP); 415 416 /* 417 * revoke any doors created by the process. 418 */ 419 if (p->p_door_list) 420 door_exit(); 421 422 /* 423 * Release schedctl data structures. 424 */ 425 if (p->p_pagep) 426 schedctl_proc_cleanup(); 427 428 /* 429 * make sure all pending kaio has completed. 430 */ 431 if (p->p_aio) 432 aio_cleanup_exit(); 433 434 /* 435 * discard the lwpchan cache. 436 */ 437 if (p->p_lcp != NULL) 438 lwpchan_destroy_cache(0); 439 440 /* 441 * Clean up any DTrace helper actions or probes for the process. 442 */ 443 if (p->p_dtrace_helpers != NULL) { 444 ASSERT(dtrace_helpers_cleanup != NULL); 445 (*dtrace_helpers_cleanup)(); 446 } 447 448 /* untimeout the realtime timers */ 449 if (p->p_itimer != NULL) 450 timer_exit(); 451 452 if ((tmp_id = p->p_alarmid) != 0) { 453 p->p_alarmid = 0; 454 (void) untimeout(tmp_id); 455 } 456 457 /* 458 * Remove any fpollinfo_t's for this (last) thread from our file 459 * descriptors so closeall() can ASSERT() that they're all gone. 460 */ 461 pollcleanup(); 462 463 if (p->p_rprof_cyclic != CYCLIC_NONE) { 464 mutex_enter(&cpu_lock); 465 cyclic_remove(p->p_rprof_cyclic); 466 mutex_exit(&cpu_lock); 467 } 468 469 mutex_enter(&p->p_lock); 470 471 /* 472 * Clean up any DTrace probes associated with this process. 473 */ 474 if (p->p_dtrace_probes) { 475 ASSERT(dtrace_fasttrap_exit_ptr != NULL); 476 dtrace_fasttrap_exit_ptr(p); 477 } 478 479 while ((tmp_id = p->p_itimerid) != 0) { 480 p->p_itimerid = 0; 481 mutex_exit(&p->p_lock); 482 (void) untimeout(tmp_id); 483 mutex_enter(&p->p_lock); 484 } 485 486 lwp_cleanup(); 487 488 /* 489 * We are about to exit; prevent our resource associations from 490 * being changed. 491 */ 492 pool_barrier_enter(); 493 494 /* 495 * Block the process against /proc now that we have really 496 * acquired p->p_lock (to manipulate p_tlist at least). 497 */ 498 prbarrier(p); 499 500 #ifdef SUN_SRC_COMPAT 501 if (code == CLD_KILLED) 502 u.u_acflag |= AXSIG; 503 #endif 504 sigfillset(&p->p_ignore); 505 sigemptyset(&p->p_siginfo); 506 sigemptyset(&p->p_sig); 507 sigemptyset(&p->p_extsig); 508 sigemptyset(&t->t_sig); 509 sigemptyset(&t->t_extsig); 510 sigemptyset(&p->p_sigmask); 511 sigdelq(p, t, 0); 512 lwp->lwp_cursig = 0; 513 lwp->lwp_extsig = 0; 514 p->p_flag &= ~(SKILLED | SEXTKILLED); 515 if (lwp->lwp_curinfo) { 516 siginfofree(lwp->lwp_curinfo); 517 lwp->lwp_curinfo = NULL; 518 } 519 520 t->t_proc_flag |= TP_LWPEXIT; 521 ASSERT(p->p_lwpcnt == 1 && p->p_zombcnt == 0); 522 prlwpexit(t); /* notify /proc */ 523 lwp_hash_out(p, t->t_tid); 524 prexit(p); 525 526 p->p_lwpcnt = 0; 527 p->p_tlist = NULL; 528 sigqfree(p); 529 term_mstate(t); 530 p->p_mterm = gethrtime(); 531 532 exec_vp = p->p_exec; 533 execdir_vp = p->p_execdir; 534 p->p_exec = NULLVP; 535 p->p_execdir = NULLVP; 536 mutex_exit(&p->p_lock); 537 if (exec_vp) 538 VN_RELE(exec_vp); 539 if (execdir_vp) 540 VN_RELE(execdir_vp); 541 542 pr_free_watched_pages(p); 543 544 closeall(P_FINFO(p)); 545 546 /* Free the controlling tty. (freectty() always assumes curproc.) */ 547 ASSERT(p == curproc); 548 (void) freectty(B_TRUE); 549 550 #if defined(__sparc) 551 if (p->p_utraps != NULL) 552 utrap_free(p); 553 #endif 554 if (p->p_semacct) /* IPC semaphore exit */ 555 semexit(p); 556 rv = wstat(why, what); 557 558 acct(rv & 0xff); 559 exacct_commit_proc(p, rv); 560 561 /* 562 * Release any resources associated with C2 auditing 563 */ 564 if (audit_active) { 565 /* 566 * audit exit system call 567 */ 568 audit_exit(why, what); 569 } 570 571 /* 572 * Free address space. 573 */ 574 relvm(); 575 576 /* 577 * Release held contracts. 578 */ 579 contract_exit(p); 580 581 /* 582 * Depart our encapsulating process contract. 583 */ 584 if ((p->p_flag & SSYS) == 0) { 585 ASSERT(p->p_ct_process); 586 contract_process_exit(p->p_ct_process, p, rv); 587 } 588 589 /* 590 * Remove pool association, and block if requested by pool_do_bind. 591 */ 592 mutex_enter(&p->p_lock); 593 ASSERT(p->p_pool->pool_ref > 0); 594 atomic_add_32(&p->p_pool->pool_ref, -1); 595 p->p_pool = pool_default; 596 /* 597 * Now that our address space has been freed and all other threads 598 * in this process have exited, set the PEXITED pool flag. This 599 * tells the pools subsystems to ignore this process if it was 600 * requested to rebind this process to a new pool. 601 */ 602 p->p_poolflag |= PEXITED; 603 pool_barrier_exit(); 604 mutex_exit(&p->p_lock); 605 606 mutex_enter(&pidlock); 607 608 /* 609 * Delete this process from the newstate list of its parent. We 610 * will put it in the right place in the sigcld in the end. 611 */ 612 delete_ns(p->p_parent, p); 613 614 /* 615 * Reassign the orphans to the next of kin. 616 * Don't rearrange init's orphanage. 617 */ 618 if ((q = p->p_orphan) != NULL && p != proc_init) { 619 620 proc_t *nokp = p->p_nextofkin; 621 622 for (;;) { 623 q->p_nextofkin = nokp; 624 if (q->p_nextorph == NULL) 625 break; 626 q = q->p_nextorph; 627 } 628 q->p_nextorph = nokp->p_orphan; 629 nokp->p_orphan = p->p_orphan; 630 p->p_orphan = NULL; 631 } 632 633 /* 634 * Reassign the children to init. 635 * Don't try to assign init's children to init. 636 */ 637 if ((q = p->p_child) != NULL && p != proc_init) { 638 struct proc *np; 639 struct proc *initp = proc_init; 640 boolean_t setzonetop = B_FALSE; 641 642 if (!INGLOBALZONE(curproc)) 643 setzonetop = B_TRUE; 644 645 pgdetach(p); 646 647 do { 648 np = q->p_sibling; 649 /* 650 * Delete it from its current parent new state 651 * list and add it to init new state list 652 */ 653 delete_ns(q->p_parent, q); 654 655 q->p_ppid = 1; 656 q->p_pidflag &= ~(CLDNOSIGCHLD | CLDWAITPID); 657 if (setzonetop) { 658 mutex_enter(&q->p_lock); 659 q->p_flag |= SZONETOP; 660 mutex_exit(&q->p_lock); 661 } 662 q->p_parent = initp; 663 664 /* 665 * Since q will be the first child, 666 * it will not have a previous sibling. 667 */ 668 q->p_psibling = NULL; 669 if (initp->p_child) { 670 initp->p_child->p_psibling = q; 671 } 672 q->p_sibling = initp->p_child; 673 initp->p_child = q; 674 if (q->p_proc_flag & P_PR_PTRACE) { 675 mutex_enter(&q->p_lock); 676 sigtoproc(q, NULL, SIGKILL); 677 mutex_exit(&q->p_lock); 678 } 679 /* 680 * sigcld() will add the child to parents 681 * newstate list. 682 */ 683 if (q->p_stat == SZOMB) 684 sigcld(q, NULL); 685 } while ((q = np) != NULL); 686 687 p->p_child = NULL; 688 ASSERT(p->p_child_ns == NULL); 689 } 690 691 TRACE_1(TR_FAC_PROC, TR_PROC_EXIT, "proc_exit: %p", p); 692 693 mutex_enter(&p->p_lock); 694 CL_EXIT(curthread); /* tell the scheduler that curthread is exiting */ 695 696 /* 697 * Have our task accummulate our resource usage data before they 698 * become contaminated by p_cacct etc., and before we renounce 699 * membership of the task. 700 * 701 * We do this regardless of whether or not task accounting is active. 702 * This is to avoid having nonsense data reported for this task if 703 * task accounting is subsequently enabled. The overhead is minimal; 704 * by this point, this process has accounted for the usage of all its 705 * LWPs. We nonetheless do the work here, and under the protection of 706 * pidlock, so that the movement of the process's usage to the task 707 * happens at the same time as the removal of the process from the 708 * task, from the point of view of exacct_snapshot_task_usage(). 709 */ 710 exacct_update_task_mstate(p); 711 712 hrutime = mstate_aggr_state(p, LMS_USER); 713 hrstime = mstate_aggr_state(p, LMS_SYSTEM); 714 p->p_utime = (clock_t)NSEC_TO_TICK(hrutime) + p->p_cutime; 715 p->p_stime = (clock_t)NSEC_TO_TICK(hrstime) + p->p_cstime; 716 717 p->p_acct[LMS_USER] += p->p_cacct[LMS_USER]; 718 p->p_acct[LMS_SYSTEM] += p->p_cacct[LMS_SYSTEM]; 719 p->p_acct[LMS_TRAP] += p->p_cacct[LMS_TRAP]; 720 p->p_acct[LMS_TFAULT] += p->p_cacct[LMS_TFAULT]; 721 p->p_acct[LMS_DFAULT] += p->p_cacct[LMS_DFAULT]; 722 p->p_acct[LMS_KFAULT] += p->p_cacct[LMS_KFAULT]; 723 p->p_acct[LMS_USER_LOCK] += p->p_cacct[LMS_USER_LOCK]; 724 p->p_acct[LMS_SLEEP] += p->p_cacct[LMS_SLEEP]; 725 p->p_acct[LMS_WAIT_CPU] += p->p_cacct[LMS_WAIT_CPU]; 726 p->p_acct[LMS_STOPPED] += p->p_cacct[LMS_STOPPED]; 727 728 p->p_ru.minflt += p->p_cru.minflt; 729 p->p_ru.majflt += p->p_cru.majflt; 730 p->p_ru.nswap += p->p_cru.nswap; 731 p->p_ru.inblock += p->p_cru.inblock; 732 p->p_ru.oublock += p->p_cru.oublock; 733 p->p_ru.msgsnd += p->p_cru.msgsnd; 734 p->p_ru.msgrcv += p->p_cru.msgrcv; 735 p->p_ru.nsignals += p->p_cru.nsignals; 736 p->p_ru.nvcsw += p->p_cru.nvcsw; 737 p->p_ru.nivcsw += p->p_cru.nivcsw; 738 p->p_ru.sysc += p->p_cru.sysc; 739 p->p_ru.ioch += p->p_cru.ioch; 740 741 p->p_stat = SZOMB; 742 p->p_proc_flag &= ~P_PR_PTRACE; 743 p->p_wdata = what; 744 p->p_wcode = (char)why; 745 746 cdir = PTOU(p)->u_cdir; 747 rdir = PTOU(p)->u_rdir; 748 cwd = PTOU(p)->u_cwd; 749 750 /* 751 * Release resource controls, as they are no longer enforceable. 752 */ 753 rctl_set_free(p->p_rctls); 754 755 /* 756 * Give up task and project memberships. Decrement tk_nlwps counter 757 * for our task.max-lwps resource control. An extended accounting 758 * record, if that facility is active, is scheduled to be written. 759 * Zombie processes are false members of task0 for the remainder of 760 * their lifetime; no accounting information is recorded for them. 761 */ 762 tk = p->p_task; 763 764 mutex_enter(&p->p_zone->zone_nlwps_lock); 765 tk->tk_nlwps--; 766 tk->tk_proj->kpj_nlwps--; 767 p->p_zone->zone_nlwps--; 768 mutex_exit(&p->p_zone->zone_nlwps_lock); 769 task_detach(p); 770 p->p_task = task0p; 771 772 /* 773 * Clear the lwp directory and the lwpid hash table 774 * now that /proc can't bother us any more. 775 * We free the memory below, after dropping p->p_lock. 776 */ 777 lwpdir = p->p_lwpdir; 778 lwpdir_sz = p->p_lwpdir_sz; 779 tidhash = p->p_tidhash; 780 tidhash_sz = p->p_tidhash_sz; 781 ret_tidhash = p->p_ret_tidhash; 782 p->p_lwpdir = NULL; 783 p->p_lwpfree = NULL; 784 p->p_lwpdir_sz = 0; 785 p->p_tidhash = NULL; 786 p->p_tidhash_sz = 0; 787 p->p_ret_tidhash = NULL; 788 789 /* 790 * If the process has context ops installed, call the exit routine 791 * on behalf of this last remaining thread. Normally exitpctx() is 792 * called during thread_exit() or lwp_exit(), but because this is the 793 * last thread in the process, we must call it here. By the time 794 * thread_exit() is called (below), the association with the relevant 795 * process has been lost. 796 * 797 * We also free the context here. 798 */ 799 if (p->p_pctx) { 800 kpreempt_disable(); 801 exitpctx(p); 802 kpreempt_enable(); 803 804 freepctx(p, 0); 805 } 806 807 /* 808 * curthread's proc pointer is changed to point to the 'sched' 809 * process for the corresponding zone, except in the case when 810 * the exiting process is in fact a zsched instance, in which 811 * case the proc pointer is set to p0. We do so, so that the 812 * process still points at the right zone when we call the VN_RELE() 813 * below. 814 * 815 * This is because curthread's original proc pointer can be freed as 816 * soon as the child sends a SIGCLD to its parent. We use zsched so 817 * that for user processes, even in the final moments of death, the 818 * process is still associated with its zone. 819 */ 820 if (p != t->t_procp->p_zone->zone_zsched) 821 t->t_procp = t->t_procp->p_zone->zone_zsched; 822 else 823 t->t_procp = &p0; 824 825 mutex_exit(&p->p_lock); 826 if (!evaporate) { 827 p->p_pidflag &= ~CLDPEND; 828 sigcld(p, sqp); 829 } else { 830 /* 831 * Do what sigcld() would do if the disposition 832 * of the SIGCHLD signal were set to be ignored. 833 */ 834 cv_broadcast(&p->p_srwchan_cv); 835 freeproc(p); 836 } 837 mutex_exit(&pidlock); 838 839 /* 840 * We don't release u_cdir and u_rdir until SZOMB is set. 841 * This protects us against dofusers(). 842 */ 843 VN_RELE(cdir); 844 if (rdir) 845 VN_RELE(rdir); 846 if (cwd) 847 refstr_rele(cwd); 848 849 /* 850 * task_rele() may ultimately cause the zone to go away (or 851 * may cause the last user process in a zone to go away, which 852 * signals zsched to go away). So prior to this call, we must 853 * no longer point at zsched. 854 */ 855 t->t_procp = &p0; 856 task_rele(tk); 857 858 kmem_free(lwpdir, lwpdir_sz * sizeof (lwpdir_t)); 859 kmem_free(tidhash, tidhash_sz * sizeof (tidhash_t)); 860 while (ret_tidhash != NULL) { 861 ret_tidhash_t *next = ret_tidhash->rth_next; 862 kmem_free(ret_tidhash->rth_tidhash, 863 ret_tidhash->rth_tidhash_sz * sizeof (tidhash_t)); 864 kmem_free(ret_tidhash, sizeof (*ret_tidhash)); 865 ret_tidhash = next; 866 } 867 868 lwp_pcb_exit(); 869 870 thread_exit(); 871 /* NOTREACHED */ 872 } 873 874 /* 875 * Format siginfo structure for wait system calls. 876 */ 877 void 878 winfo(proc_t *pp, k_siginfo_t *ip, int waitflag) 879 { 880 ASSERT(MUTEX_HELD(&pidlock)); 881 882 bzero(ip, sizeof (k_siginfo_t)); 883 ip->si_signo = SIGCLD; 884 ip->si_code = pp->p_wcode; 885 ip->si_pid = pp->p_pid; 886 ip->si_ctid = PRCTID(pp); 887 ip->si_zoneid = pp->p_zone->zone_id; 888 ip->si_status = pp->p_wdata; 889 ip->si_stime = pp->p_stime; 890 ip->si_utime = pp->p_utime; 891 892 if (waitflag) { 893 pp->p_wcode = 0; 894 pp->p_wdata = 0; 895 pp->p_pidflag &= ~CLDPEND; 896 } 897 } 898 899 /* 900 * Wait system call. 901 * Search for a terminated (zombie) child, 902 * finally lay it to rest, and collect its status. 903 * Look also for stopped children, 904 * and pass back status from them. 905 */ 906 int 907 waitid(idtype_t idtype, id_t id, k_siginfo_t *ip, int options) 908 { 909 int found; 910 proc_t *cp, *pp; 911 int proc_gone; 912 int waitflag = !(options & WNOWAIT); 913 914 /* 915 * Obsolete flag, defined here only for binary compatibility 916 * with old statically linked executables. Delete this when 917 * we no longer care about these old and broken applications. 918 */ 919 #define _WNOCHLD 0400 920 options &= ~_WNOCHLD; 921 922 if (options == 0 || (options & ~WOPTMASK)) 923 return (EINVAL); 924 925 switch (idtype) { 926 case P_PID: 927 case P_PGID: 928 if (id < 0 || id >= maxpid) 929 return (EINVAL); 930 /* FALLTHROUGH */ 931 case P_ALL: 932 break; 933 default: 934 return (EINVAL); 935 } 936 937 pp = ttoproc(curthread); 938 939 /* 940 * lock parent mutex so that sibling chain can be searched. 941 */ 942 mutex_enter(&pidlock); 943 944 /* 945 * if we are only looking for exited processes and child_ns list 946 * is empty no reason to look at all children. 947 */ 948 if (idtype == P_ALL && 949 (options & ~WNOWAIT) == (WNOHANG | WEXITED) && 950 pp->p_child_ns == NULL) { 951 if (pp->p_child) { 952 mutex_exit(&pidlock); 953 bzero(ip, sizeof (k_siginfo_t)); 954 return (0); 955 } 956 mutex_exit(&pidlock); 957 return (ECHILD); 958 } 959 960 while (pp->p_child != NULL) { 961 962 proc_gone = 0; 963 964 for (cp = pp->p_child_ns; cp != NULL; cp = cp->p_sibling_ns) { 965 if (idtype != P_PID && (cp->p_pidflag & CLDWAITPID)) 966 continue; 967 if (idtype == P_PID && id != cp->p_pid) 968 continue; 969 if (idtype == P_PGID && id != cp->p_pgrp) 970 continue; 971 972 switch (cp->p_wcode) { 973 974 case CLD_TRAPPED: 975 case CLD_STOPPED: 976 case CLD_CONTINUED: 977 cmn_err(CE_PANIC, 978 "waitid: wrong state %d on the p_newstate" 979 " list", cp->p_wcode); 980 break; 981 982 case CLD_EXITED: 983 case CLD_DUMPED: 984 case CLD_KILLED: 985 if (!(options & WEXITED)) { 986 /* 987 * Count how many are already gone 988 * for good. 989 */ 990 proc_gone++; 991 break; 992 } 993 if (!waitflag) { 994 winfo(cp, ip, 0); 995 } else { 996 winfo(cp, ip, 1); 997 freeproc(cp); 998 } 999 mutex_exit(&pidlock); 1000 if (waitflag) { /* accept SIGCLD */ 1001 sigcld_delete(ip); 1002 sigcld_repost(); 1003 } 1004 return (0); 1005 } 1006 1007 if (idtype == P_PID) 1008 break; 1009 } 1010 1011 /* 1012 * Wow! None of the threads on the p_sibling_ns list were 1013 * interesting threads. Check all the kids! 1014 */ 1015 found = 0; 1016 for (cp = pp->p_child; cp != NULL; cp = cp->p_sibling) { 1017 if (idtype == P_PID && id != cp->p_pid) 1018 continue; 1019 if (idtype == P_PGID && id != cp->p_pgrp) 1020 continue; 1021 1022 switch (cp->p_wcode) { 1023 case CLD_TRAPPED: 1024 if (!(options & WTRAPPED)) 1025 break; 1026 winfo(cp, ip, waitflag); 1027 mutex_exit(&pidlock); 1028 if (waitflag) { /* accept SIGCLD */ 1029 sigcld_delete(ip); 1030 sigcld_repost(); 1031 } 1032 return (0); 1033 1034 case CLD_STOPPED: 1035 if (!(options & WSTOPPED)) 1036 break; 1037 /* Is it still stopped? */ 1038 mutex_enter(&cp->p_lock); 1039 if (!jobstopped(cp)) { 1040 mutex_exit(&cp->p_lock); 1041 break; 1042 } 1043 mutex_exit(&cp->p_lock); 1044 winfo(cp, ip, waitflag); 1045 mutex_exit(&pidlock); 1046 if (waitflag) { /* accept SIGCLD */ 1047 sigcld_delete(ip); 1048 sigcld_repost(); 1049 } 1050 return (0); 1051 1052 case CLD_CONTINUED: 1053 if (!(options & WCONTINUED)) 1054 break; 1055 winfo(cp, ip, waitflag); 1056 mutex_exit(&pidlock); 1057 if (waitflag) { /* accept SIGCLD */ 1058 sigcld_delete(ip); 1059 sigcld_repost(); 1060 } 1061 return (0); 1062 1063 case CLD_EXITED: 1064 case CLD_DUMPED: 1065 case CLD_KILLED: 1066 if (idtype != P_PID && 1067 (cp->p_pidflag & CLDWAITPID)) 1068 continue; 1069 /* 1070 * Don't complain if a process was found in 1071 * the first loop but we broke out of the loop 1072 * because of the arguments passed to us. 1073 */ 1074 if (proc_gone == 0) { 1075 cmn_err(CE_PANIC, 1076 "waitid: wrong state on the" 1077 " p_child list"); 1078 } else { 1079 break; 1080 } 1081 } 1082 1083 found++; 1084 1085 if (idtype == P_PID) 1086 break; 1087 } 1088 1089 /* 1090 * If we found no interesting processes at all, 1091 * break out and return ECHILD. 1092 */ 1093 if (found + proc_gone == 0) 1094 break; 1095 1096 if (options & WNOHANG) { 1097 mutex_exit(&pidlock); 1098 bzero(ip, sizeof (k_siginfo_t)); 1099 /* 1100 * We should set ip->si_signo = SIGCLD, 1101 * but there is an SVVS test that expects 1102 * ip->si_signo to be zero in this case. 1103 */ 1104 return (0); 1105 } 1106 1107 /* 1108 * If we found no processes of interest that could 1109 * change state while we wait, we don't wait at all. 1110 * Get out with ECHILD according to SVID. 1111 */ 1112 if (found == proc_gone) 1113 break; 1114 1115 if (!cv_wait_sig_swap(&pp->p_cv, &pidlock)) { 1116 mutex_exit(&pidlock); 1117 return (EINTR); 1118 } 1119 } 1120 mutex_exit(&pidlock); 1121 return (ECHILD); 1122 } 1123 1124 /* 1125 * The wait() system call trap is no longer invoked by libc. 1126 * It is retained only for the benefit of statically linked applications. 1127 * Delete this when we no longer care about these old and broken applications. 1128 */ 1129 int64_t 1130 wait(void) 1131 { 1132 int error; 1133 k_siginfo_t info; 1134 rval_t r; 1135 1136 if (error = waitid(P_ALL, (id_t)0, &info, WEXITED|WTRAPPED)) 1137 return (set_errno(error)); 1138 r.r_val1 = info.si_pid; 1139 r.r_val2 = wstat(info.si_code, info.si_status); 1140 return (r.r_vals); 1141 } 1142 1143 int 1144 waitsys(idtype_t idtype, id_t id, siginfo_t *infop, int options) 1145 { 1146 int error; 1147 k_siginfo_t info; 1148 1149 if (error = waitid(idtype, id, &info, options)) 1150 return (set_errno(error)); 1151 if (copyout(&info, infop, sizeof (k_siginfo_t))) 1152 return (set_errno(EFAULT)); 1153 return (0); 1154 } 1155 1156 #ifdef _SYSCALL32_IMPL 1157 1158 int 1159 waitsys32(idtype_t idtype, id_t id, siginfo_t *infop, int options) 1160 { 1161 int error; 1162 k_siginfo_t info; 1163 siginfo32_t info32; 1164 1165 if (error = waitid(idtype, id, &info, options)) 1166 return (set_errno(error)); 1167 siginfo_kto32(&info, &info32); 1168 if (copyout(&info32, infop, sizeof (info32))) 1169 return (set_errno(EFAULT)); 1170 return (0); 1171 } 1172 1173 #endif /* _SYSCALL32_IMPL */ 1174 1175 void 1176 proc_detach(proc_t *p) 1177 { 1178 proc_t *q; 1179 1180 ASSERT(MUTEX_HELD(&pidlock)); 1181 1182 q = p->p_parent; 1183 ASSERT(q != NULL); 1184 1185 /* 1186 * Take it off the newstate list of its parent 1187 */ 1188 delete_ns(q, p); 1189 1190 if (q->p_child == p) { 1191 q->p_child = p->p_sibling; 1192 /* 1193 * If the parent has no children, it better not 1194 * have any with new states either! 1195 */ 1196 ASSERT(q->p_child ? 1 : q->p_child_ns == NULL); 1197 } 1198 1199 if (p->p_sibling) { 1200 p->p_sibling->p_psibling = p->p_psibling; 1201 } 1202 1203 if (p->p_psibling) { 1204 p->p_psibling->p_sibling = p->p_sibling; 1205 } 1206 } 1207 1208 /* 1209 * Remove zombie children from the process table. 1210 */ 1211 void 1212 freeproc(proc_t *p) 1213 { 1214 proc_t *q; 1215 1216 ASSERT(p->p_stat == SZOMB); 1217 ASSERT(p->p_tlist == NULL); 1218 ASSERT(MUTEX_HELD(&pidlock)); 1219 1220 sigdelq(p, NULL, 0); 1221 if (p->p_killsqp) { 1222 siginfofree(p->p_killsqp); 1223 p->p_killsqp = NULL; 1224 } 1225 1226 prfree(p); /* inform /proc */ 1227 1228 /* 1229 * Don't free the init processes. 1230 * Other dying processes will access it. 1231 */ 1232 if (p == proc_init) 1233 return; 1234 1235 1236 /* 1237 * We wait until now to free the cred structure because a 1238 * zombie process's credentials may be examined by /proc. 1239 * No cred locking needed because there are no threads at this point. 1240 */ 1241 upcount_dec(crgetruid(p->p_cred), crgetzoneid(p->p_cred)); 1242 crfree(p->p_cred); 1243 if (p->p_corefile != NULL) { 1244 corectl_path_rele(p->p_corefile); 1245 p->p_corefile = NULL; 1246 } 1247 if (p->p_content != NULL) { 1248 corectl_content_rele(p->p_content); 1249 p->p_content = NULL; 1250 } 1251 1252 if (p->p_nextofkin && !((p->p_nextofkin->p_flag & SNOWAIT) || 1253 (PTOU(p->p_nextofkin)->u_signal[SIGCLD - 1] == SIG_IGN))) { 1254 /* 1255 * This should still do the right thing since p_utime/stime 1256 * get set to the correct value on process exit, so it 1257 * should get properly updated 1258 */ 1259 p->p_nextofkin->p_cutime += p->p_utime; 1260 p->p_nextofkin->p_cstime += p->p_stime; 1261 1262 p->p_nextofkin->p_cacct[LMS_USER] += p->p_acct[LMS_USER]; 1263 p->p_nextofkin->p_cacct[LMS_SYSTEM] += p->p_acct[LMS_SYSTEM]; 1264 p->p_nextofkin->p_cacct[LMS_TRAP] += p->p_acct[LMS_TRAP]; 1265 p->p_nextofkin->p_cacct[LMS_TFAULT] += p->p_acct[LMS_TFAULT]; 1266 p->p_nextofkin->p_cacct[LMS_DFAULT] += p->p_acct[LMS_DFAULT]; 1267 p->p_nextofkin->p_cacct[LMS_KFAULT] += p->p_acct[LMS_KFAULT]; 1268 p->p_nextofkin->p_cacct[LMS_USER_LOCK] 1269 += p->p_acct[LMS_USER_LOCK]; 1270 p->p_nextofkin->p_cacct[LMS_SLEEP] += p->p_acct[LMS_SLEEP]; 1271 p->p_nextofkin->p_cacct[LMS_WAIT_CPU] 1272 += p->p_acct[LMS_WAIT_CPU]; 1273 p->p_nextofkin->p_cacct[LMS_STOPPED] += p->p_acct[LMS_STOPPED]; 1274 1275 p->p_nextofkin->p_cru.minflt += p->p_ru.minflt; 1276 p->p_nextofkin->p_cru.majflt += p->p_ru.majflt; 1277 p->p_nextofkin->p_cru.nswap += p->p_ru.nswap; 1278 p->p_nextofkin->p_cru.inblock += p->p_ru.inblock; 1279 p->p_nextofkin->p_cru.oublock += p->p_ru.oublock; 1280 p->p_nextofkin->p_cru.msgsnd += p->p_ru.msgsnd; 1281 p->p_nextofkin->p_cru.msgrcv += p->p_ru.msgrcv; 1282 p->p_nextofkin->p_cru.nsignals += p->p_ru.nsignals; 1283 p->p_nextofkin->p_cru.nvcsw += p->p_ru.nvcsw; 1284 p->p_nextofkin->p_cru.nivcsw += p->p_ru.nivcsw; 1285 p->p_nextofkin->p_cru.sysc += p->p_ru.sysc; 1286 p->p_nextofkin->p_cru.ioch += p->p_ru.ioch; 1287 1288 } 1289 1290 q = p->p_nextofkin; 1291 if (q && q->p_orphan == p) 1292 q->p_orphan = p->p_nextorph; 1293 else if (q) { 1294 for (q = q->p_orphan; q; q = q->p_nextorph) 1295 if (q->p_nextorph == p) 1296 break; 1297 ASSERT(q && q->p_nextorph == p); 1298 q->p_nextorph = p->p_nextorph; 1299 } 1300 1301 proc_detach(p); 1302 pid_exit(p); /* frees pid and proc structure */ 1303 } 1304 1305 /* 1306 * Delete process "child" from the newstate list of process "parent" 1307 */ 1308 void 1309 delete_ns(proc_t *parent, proc_t *child) 1310 { 1311 proc_t **ns; 1312 1313 ASSERT(MUTEX_HELD(&pidlock)); 1314 ASSERT(child->p_parent == parent); 1315 for (ns = &parent->p_child_ns; *ns != NULL; ns = &(*ns)->p_sibling_ns) { 1316 if (*ns == child) { 1317 1318 ASSERT((*ns)->p_parent == parent); 1319 1320 *ns = child->p_sibling_ns; 1321 child->p_sibling_ns = NULL; 1322 return; 1323 } 1324 } 1325 } 1326 1327 /* 1328 * Add process "child" to the new state list of process "parent" 1329 */ 1330 void 1331 add_ns(proc_t *parent, proc_t *child) 1332 { 1333 ASSERT(child->p_sibling_ns == NULL); 1334 child->p_sibling_ns = parent->p_child_ns; 1335 parent->p_child_ns = child; 1336 } 1337