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