![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_exit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to kern_exit.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */ ! 23: /* ! 24: * Copyright (c) 1982, 1986, 1989, 1991, 1993 ! 25: * The Regents of the University of California. All rights reserved. ! 26: * (c) UNIX System Laboratories, Inc. ! 27: * All or some portions of this file are derived from material licensed ! 28: * to the University of California by American Telephone and Telegraph ! 29: * Co. or Unix System Laboratories, Inc. and are reproduced herein with ! 30: * the permission of UNIX System Laboratories, Inc. ! 31: * ! 32: * Redistribution and use in source and binary forms, with or without ! 33: * modification, are permitted provided that the following conditions ! 34: * are met: ! 35: * 1. Redistributions of source code must retain the above copyright ! 36: * notice, this list of conditions and the following disclaimer. ! 37: * 2. Redistributions in binary form must reproduce the above copyright ! 38: * notice, this list of conditions and the following disclaimer in the ! 39: * documentation and/or other materials provided with the distribution. ! 40: * 3. All advertising materials mentioning features or use of this software ! 41: * must display the following acknowledgement: ! 42: * This product includes software developed by the University of ! 43: * California, Berkeley and its contributors. ! 44: * 4. Neither the name of the University nor the names of its contributors ! 45: * may be used to endorse or promote products derived from this software ! 46: * without specific prior written permission. ! 47: * ! 48: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 49: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 50: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 51: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 52: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 53: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 54: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 55: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 56: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 57: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 58: * SUCH DAMAGE. ! 59: * ! 60: * @(#)kern_exit.c 8.7 (Berkeley) 2/12/94 ! 61: */ ! 62: ! 63: #include <machine/reg.h> ! 64: #include <machine/psl.h> ! 65: ! 66: #include "compat_43.h" ! 67: ! 68: #include <sys/param.h> ! 69: #include <sys/systm.h> ! 70: #include <sys/ioctl.h> ! 71: #include <sys/proc.h> ! 72: #include <sys/tty.h> ! 73: #include <sys/time.h> ! 74: #include <sys/resource.h> ! 75: #include <sys/kernel.h> ! 76: #include <sys/buf.h> ! 77: #include <sys/wait.h> ! 78: #include <sys/file.h> ! 79: #include <sys/vnode.h> ! 80: #include <sys/syslog.h> ! 81: #include <sys/malloc.h> ! 82: #include <sys/resourcevar.h> ! 83: #include <sys/ptrace.h> ! 84: #include <sys/user.h> ! 85: ! 86: #include <mach/mach_types.h> ! 87: #include <kern/thread.h> ! 88: #include <kern/thread_act.h> ! 89: #include <kern/assert.h> ! 90: ! 91: void exit1 __P((struct proc *, int)); ! 92: ! 93: /* ! 94: * exit -- ! 95: * Death of process. ! 96: */ ! 97: struct exit_args { ! 98: int rval; ! 99: }; ! 100: void ! 101: exit(p, uap, retval) ! 102: struct proc *p; ! 103: struct exit_args *uap; ! 104: int *retval; ! 105: { ! 106: exit1(p, W_EXITCODE(uap->rval, 0)); ! 107: ! 108: thread_exception_return(); ! 109: /* NOTREACHED */ ! 110: while (TRUE) ! 111: thread_block(0); ! 112: /* NOTREACHED */ ! 113: } ! 114: ! 115: /* ! 116: * Exit: deallocate address space and other resources, change proc state ! 117: * to zombie, and unlink proc from allproc and parent's lists. Save exit ! 118: * status and rusage for wait(). Check for child processes and orphan them. ! 119: */ ! 120: void ! 121: exit1(p, rv) ! 122: register struct proc *p; ! 123: int rv; ! 124: { ! 125: register struct proc *q, *nq; ! 126: thread_t self = current_thread(); ! 127: thread_act_t th_act_self = current_act(); ! 128: struct task *task = p->task; ! 129: register int i,s; ! 130: struct uthread *ut; ! 131: ! 132: /* ! 133: * If a thread in this task has already ! 134: * called exit(), then halt any others ! 135: * right here. ! 136: */ ! 137: while (p->exit_thread != self) { ! 138: if (sig_try_lock(p) <= 0) { ! 139: if (get_threadtask(th_act_self) != task) ! 140: return; ! 141: while (TRUE) { ! 142: thread_terminate_self(); ! 143: /* NOTREACHED */ ! 144: } ! 145: } ! 146: sig_lock_to_exit(p); ! 147: } ! 148: if (p->p_pid == 1) { ! 149: printf("pid 1 exited (signal %d, exit %d)", ! 150: WTERMSIG(rv), WEXITSTATUS(rv)); ! 151: panic("init died"); ! 152: } ! 153: ! 154: s = splsched(); ! 155: p->p_flag |= P_WEXIT; ! 156: splx(s); ! 157: proc_prepareexit(p); ! 158: p->p_xstat = rv; ! 159: ! 160: /* task terminate will call proc_terminate and that cleans it up */ ! 161: task_terminate_internal(task); ! 162: ! 163: /* ! 164: * we come back and returns to AST which ! 165: * should cleanup the rest ! 166: */ ! 167: #if 0 ! 168: if (task == current_task()) { ! 169: thread_exception_return(); ! 170: /*NOTREACHED*/ ! 171: } ! 172: ! 173: while (task == current_task()) { ! 174: thread_terminate_self(); ! 175: /*NOTREACHED*/ ! 176: } ! 177: #endif ! 178: } ! 179: ! 180: void ! 181: proc_prepareexit(struct proc *p) ! 182: { ! 183: int s; ! 184: struct uthread *ut; ! 185: thread_t self = current_thread(); ! 186: thread_act_t th_act_self = current_act(); ! 187: ! 188: ! 189: /* ! 190: * Remove proc from allproc queue and from pidhash chain. ! 191: * Need to do this before we do anything that can block. ! 192: * Not doing causes things like mount() find this on allproc ! 193: * in partially cleaned state. ! 194: */ ! 195: LIST_REMOVE(p, p_list); ! 196: LIST_REMOVE(p, p_hash); ! 197: ! 198: #ifdef PGINPROF ! 199: vmsizmon(); ! 200: #endif ! 201: /* ! 202: * If parent is waiting for us to exit or exec, ! 203: * P_PPWAIT is set; we will wakeup the parent below. ! 204: */ ! 205: p->p_flag &= ~(P_TRACED | P_PPWAIT); ! 206: p->p_sigignore = ~0; ! 207: p->p_siglist = 0; ! 208: ut = get_bsdthread_info(th_act_self); ! 209: ut->uu_sig = 0; ! 210: untimeout(realitexpire, (caddr_t)p); ! 211: ! 212: } ! 213: ! 214: void ! 215: proc_exit(struct proc *p) ! 216: { ! 217: register struct proc *q, *nq; ! 218: thread_t self = current_thread(); ! 219: thread_act_t th_act_self = current_act(); ! 220: struct task *task = p->task; ! 221: register int i,s; ! 222: struct uthread *ut; ! 223: boolean_t funnel_state; ! 224: ! 225: /* This can happen if thread_terminate of the single thread ! 226: * process ! 227: */ ! 228: ! 229: funnel_state = thread_set_funneled(TRUE); ! 230: if( !(p->p_flag & P_WEXIT)) { ! 231: s = splsched(); ! 232: p->p_flag |= P_WEXIT; ! 233: splx(s); ! 234: proc_prepareexit(p); ! 235: } ! 236: ! 237: MALLOC_ZONE(p->p_ru, struct rusage *, ! 238: sizeof (*p->p_ru), M_ZOMBIE, M_WAITOK); ! 239: ! 240: /* ! 241: * Close open files and release open-file table. ! 242: * This may block! ! 243: */ ! 244: fdfree(p); ! 245: ! 246: /* Close ref SYSV Shared memory*/ ! 247: if (p->vm_shm) ! 248: shmexit(p); ! 249: ! 250: if (SESS_LEADER(p)) { ! 251: register struct session *sp = p->p_session; ! 252: ! 253: if (sp->s_ttyvp) { ! 254: /* ! 255: * Controlling process. ! 256: * Signal foreground pgrp, ! 257: * drain controlling terminal ! 258: * and revoke access to controlling terminal. ! 259: */ ! 260: if (sp->s_ttyp->t_session == sp) { ! 261: if (sp->s_ttyp->t_pgrp) ! 262: pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1); ! 263: (void) ttywait(sp->s_ttyp); ! 264: /* ! 265: * The tty could have been revoked ! 266: * if we blocked. ! 267: */ ! 268: if (sp->s_ttyvp) ! 269: VOP_REVOKE(sp->s_ttyvp, REVOKEALL); ! 270: } ! 271: if (sp->s_ttyvp) ! 272: vrele(sp->s_ttyvp); ! 273: sp->s_ttyvp = NULL; ! 274: /* ! 275: * s_ttyp is not zero'd; we use this to indicate ! 276: * that the session once had a controlling terminal. ! 277: * (for logging and informational purposes) ! 278: */ ! 279: } ! 280: sp->s_leader = NULL; ! 281: } ! 282: ! 283: fixjobc(p, p->p_pgrp, 0); ! 284: p->p_rlimit[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY; ! 285: #if KTRACE ! 286: /* ! 287: * release trace file ! 288: */ ! 289: p->p_traceflag = 0; /* don't trace the vrele() */ ! 290: if (p->p_tracep) ! 291: vrele(p->p_tracep); ! 292: #endif ! 293: ! 294: ! 295: q = p->p_children.lh_first; ! 296: if (q) /* only need this if any child is S_ZOMB */ ! 297: wakeup((caddr_t) initproc); ! 298: for (; q != 0; q = nq) { ! 299: nq = q->p_sibling.le_next; ! 300: proc_reparent(q, initproc); ! 301: /* ! 302: * Traced processes are killed ! 303: * since their existence means someone is messing up. ! 304: */ ! 305: if (q->p_flag & P_TRACED) { ! 306: q->p_flag &= ~P_TRACED; ! 307: if (q->sigwait_thread) { ! 308: thread_t sig_shuttle = getshuttle_thread(q->sigwait_thread); ! 309: /* ! 310: * The sigwait_thread could be stopped at a ! 311: * breakpoint. Wake it up to kill. ! 312: * Need to do this as it could be a thread which is not ! 313: * the first thread in the task. So any attempts to kill ! 314: * the process would result into a deadlock on q->sigwait. ! 315: */ ! 316: thread_resume((struct thread *)q->sigwait_thread); ! 317: clear_wait(sig_shuttle, THREAD_INTERRUPTED, FALSE); ! 318: threadsignal(q->sigwait_thread, SIGKILL, 0); ! 319: } ! 320: psignal(q, SIGKILL); ! 321: } ! 322: } ! 323: ! 324: ! 325: /* ! 326: * Save exit status and final rusage info, adding in child rusage ! 327: * info and self times. ! 328: */ ! 329: *p->p_ru = p->p_stats->p_ru; ! 330: ! 331: timerclear(&p->p_ru->ru_utime); ! 332: timerclear(&p->p_ru->ru_stime); ! 333: ! 334: if (task) { ! 335: task_basic_info_data_t tinfo; ! 336: int task_info_stuff = TASK_BASIC_INFO_COUNT; ! 337: ! 338: task_info(task, TASK_BASIC_INFO,&tinfo, &task_info_stuff); ! 339: p->p_ru->ru_utime.tv_sec = tinfo.user_time.seconds; ! 340: p->p_ru->ru_utime.tv_usec = tinfo.user_time.microseconds; ! 341: p->p_ru->ru_stime.tv_sec = tinfo.system_time.seconds; ! 342: p->p_ru->ru_stime.tv_usec = tinfo.system_time.microseconds; ! 343: } ! 344: ! 345: ! 346: ruadd(p->p_ru, &p->p_stats->p_cru); ! 347: ! 348: /* ! 349: * Free up profiling buffers. ! 350: */ ! 351: { ! 352: struct uprof *p0 = &p->p_stats->p_prof, *p1, *pn; ! 353: ! 354: p1 = p0->pr_next; ! 355: p0->pr_next = NULL; ! 356: p0->pr_scale = 0; ! 357: ! 358: for (; p1 != NULL; p1 = pn) { ! 359: pn = p1->pr_next; ! 360: kfree((vm_offset_t)p1, sizeof *p1); ! 361: } ! 362: } ! 363: ! 364: ! 365: /* Place onto zombproc. */ ! 366: LIST_INSERT_HEAD(&zombproc, p, p_list); ! 367: p->p_stat = SZOMB; ! 368: ! 369: /* ! 370: * Notify parent that we're gone. ! 371: */ ! 372: psignal(p->p_pptr, SIGCHLD); ! 373: wakeup((caddr_t)p->p_pptr); ! 374: ! 375: /* ! 376: * Notify procfs debugger ! 377: */ ! 378: if (p->p_flag & P_FSTRACE) ! 379: wakeup((caddr_t)p); ! 380: ! 381: /* ! 382: * Other substructures are freed from wait(). ! 383: */ ! 384: FREE_ZONE(p->p_stats, sizeof *p->p_stats, M_SUBPROC); ! 385: p->p_stats = NULL; ! 386: ! 387: FREE_ZONE(p->p_sigacts, sizeof *p->p_sigacts, M_SUBPROC); ! 388: p->p_sigacts = NULL; ! 389: ! 390: if (--p->p_limit->p_refcnt == 0) ! 391: FREE_ZONE(p->p_limit, sizeof *p->p_limit, M_SUBPROC); ! 392: p->p_limit = NULL; ! 393: ! 394: /* ! 395: * Finish up by terminating the task ! 396: * and halt this thread (only if a ! 397: * member of the task exiting). ! 398: */ ! 399: p->task = TASK_NULL; ! 400: //task->proc = NULL; ! 401: set_bsdtask_info(task, NULL); ! 402: ! 403: (void) thread_set_funneled(funnel_state); ! 404: } ! 405: ! 406: ! 407: struct wait4_args { ! 408: int pid; ! 409: int *status; ! 410: int options; ! 411: struct rusage *rusage; ! 412: }; ! 413: ! 414: #if COMPAT_43 ! 415: int ! 416: owait(p, uap, retval) ! 417: struct proc *p; ! 418: void *uap; ! 419: int *retval; ! 420: { ! 421: struct wait4_args *a; ! 422: ! 423: a = (struct wait4_args *)get_bsduthreadarg(current_act()); ! 424: ! 425: a->options = 0; ! 426: a->rusage = NULL; ! 427: a->pid = WAIT_ANY; ! 428: a->status = NULL; ! 429: return (wait1(p, a, retval, 1)); ! 430: } ! 431: ! 432: int ! 433: wait4(p, uap, retval) ! 434: struct proc *p; ! 435: struct wait4_args *uap; ! 436: int *retval; ! 437: { ! 438: ! 439: return (wait1(p, uap, retval, 0)); ! 440: } ! 441: ! 442: struct owait3_args { ! 443: int *status; ! 444: int options; ! 445: struct rusage *rusage; ! 446: }; ! 447: ! 448: int ! 449: owait3(p, uap, retval) ! 450: struct proc *p; ! 451: struct owait3_args *uap; ! 452: int *retval; ! 453: { ! 454: struct wait4_args *a; ! 455: ! 456: a = (struct wait4_args *)get_bsduthreadarg(current_act); ! 457: ! 458: a->rusage = uap->rusage; ! 459: a->options = uap->options; ! 460: a->status = uap->status; ! 461: a->pid = WAIT_ANY; ! 462: ! 463: return (wait1(p, a, retval, 1)); ! 464: } ! 465: ! 466: #else ! 467: #define wait1 wait4 ! 468: #endif ! 469: ! 470: int ! 471: wait1continue(result) ! 472: { ! 473: void * p, *vt; ! 474: thread_act_t thread; ! 475: struct uthread *ut; ! 476: int *retval; ! 477: ! 478: if (result != 0) { ! 479: return(result); ! 480: } ! 481: ! 482: thread = current_act(); ! 483: p = get_bsdtask_info(current_task()); ! 484: ut = get_bsdthread_info(thread); ! 485: vt = get_bsduthreadarg(thread); ! 486: retval = get_bsduthreadrval(thread); ! 487: wait1((struct proc *)p, (struct wait4_args *)vt, retval, 0); ! 488: } ! 489: ! 490: int ! 491: wait1(q, uap, retval, compat) ! 492: register struct proc *q; ! 493: register struct wait4_args *uap; ! 494: register_t *retval; ! 495: #if COMPAT_43 ! 496: int compat; ! 497: #endif ! 498: { ! 499: register int nfound; ! 500: register struct proc *p, *t; ! 501: int status, error; ! 502: ! 503: if (uap->pid == 0) ! 504: uap->pid = -q->p_pgid; ! 505: ! 506: loop: ! 507: nfound = 0; ! 508: for (p = q->p_children.lh_first; p != 0; p = p->p_sibling.le_next) { ! 509: if (uap->pid != WAIT_ANY && ! 510: p->p_pid != uap->pid && ! 511: p->p_pgid != -(uap->pid)) ! 512: continue; ! 513: nfound++; ! 514: if (p->p_stat == SZOMB) { ! 515: retval[0] = p->p_pid; ! 516: #if COMPAT_43 ! 517: if (compat) ! 518: retval[1] = p->p_xstat; ! 519: else ! 520: #endif ! 521: if (uap->status) { ! 522: status = p->p_xstat; /* convert to int */ ! 523: if (error = copyout((caddr_t)&status, ! 524: (caddr_t)uap->status, ! 525: sizeof(status))) ! 526: return (error); ! 527: } ! 528: if (uap->rusage && ! 529: (error = copyout((caddr_t)p->p_ru, ! 530: (caddr_t)uap->rusage, ! 531: sizeof (struct rusage)))) ! 532: return (error); ! 533: /* ! 534: * If we got the child via a ptrace 'attach', ! 535: * we need to give it back to the old parent. ! 536: */ ! 537: if (p->p_oppid && (t = pfind(p->p_oppid))) { ! 538: p->p_oppid = 0; ! 539: proc_reparent(p, t); ! 540: psignal(t, SIGCHLD); ! 541: wakeup((caddr_t)t); ! 542: return (0); ! 543: } ! 544: p->p_xstat = 0; ! 545: if (p->p_ru) { ! 546: ruadd(&q->p_stats->p_cru, p->p_ru); ! 547: FREE_ZONE(p->p_ru, sizeof *p->p_ru, M_ZOMBIE); ! 548: p->p_ru = NULL; ! 549: } else { ! 550: printf("Warning : lost p_ru for %s\n", p->p_comm); ! 551: } ! 552: ! 553: /* ! 554: * Decrement the count of procs running with this uid. ! 555: */ ! 556: (void)chgproccnt(p->p_cred->p_ruid, -1); ! 557: ! 558: /* ! 559: * Free up credentials. ! 560: */ ! 561: if (--p->p_cred->p_refcnt == 0) { ! 562: struct ucred *ucr = p->p_ucred; ! 563: struct pcred *pcr; ! 564: ! 565: if (ucr != NOCRED) { ! 566: p->p_ucred = NOCRED; ! 567: crfree(ucr); ! 568: } ! 569: pcr = p->p_cred; ! 570: p->p_cred = NULL; ! 571: FREE_ZONE(pcr, sizeof *pcr, M_SUBPROC); ! 572: } ! 573: ! 574: /* ! 575: * Release reference to text vnode ! 576: */ ! 577: if (p->p_textvp) ! 578: vrele(p->p_textvp); ! 579: ! 580: /* ! 581: * Finally finished with old proc entry. ! 582: * Unlink it from its process group and free it. ! 583: */ ! 584: leavepgrp(p); ! 585: LIST_REMOVE(p, p_list); /* off zombproc */ ! 586: LIST_REMOVE(p, p_sibling); ! 587: FREE_ZONE(p, sizeof *p, M_PROC); ! 588: nprocs--; ! 589: return (0); ! 590: } ! 591: if (p->p_stat == SSTOP && (p->p_flag & P_WAITED) == 0 && ! 592: (p->p_flag & P_TRACED || uap->options & WUNTRACED)) { ! 593: p->p_flag |= P_WAITED; ! 594: retval[0] = p->p_pid; ! 595: #if COMPAT_43 ! 596: if (compat) { ! 597: retval[1] = W_STOPCODE(p->p_xstat); ! 598: error = 0; ! 599: } else ! 600: #endif ! 601: if (uap->status) { ! 602: status = W_STOPCODE(p->p_xstat); ! 603: error = copyout((caddr_t)&status, ! 604: (caddr_t)uap->status, ! 605: sizeof(status)); ! 606: } else ! 607: error = 0; ! 608: return (error); ! 609: } ! 610: } ! 611: if (nfound == 0) ! 612: return (ECHILD); ! 613: if (uap->options & WNOHANG) { ! 614: retval[0] = 0; ! 615: return (0); ! 616: } ! 617: ! 618: if (error = tsleep0((caddr_t)q, PWAIT | PCATCH, "wait", 0, wait1continue)) { ! 619: return (error); ! 620: } ! 621: goto loop; ! 622: } ! 623: ! 624: /* ! 625: * make process 'parent' the new parent of process 'child'. ! 626: */ ! 627: void ! 628: proc_reparent(child, parent) ! 629: register struct proc *child; ! 630: register struct proc *parent; ! 631: { ! 632: ! 633: if (child->p_pptr == parent) ! 634: return; ! 635: ! 636: LIST_REMOVE(child, p_sibling); ! 637: LIST_INSERT_HEAD(&parent->p_children, child, p_sibling); ! 638: child->p_pptr = parent; ! 639: } ! 640: ! 641: kern_return_t ! 642: init_process(void) ! 643: /* ! 644: * Make the current process an "init" process, meaning ! 645: * that it doesn't have a parent, and that it won't be ! 646: * gunned down by kill(-1, 0). ! 647: */ ! 648: { ! 649: register struct proc *p = current_proc(); ! 650: ! 651: if (suser(p->p_ucred, &p->p_acflag)) ! 652: return(KERN_NO_ACCESS); ! 653: ! 654: if (p->p_pid != 1 && p->p_pgid != p->p_pid) ! 655: enterpgrp(p, p->p_pid, 0); ! 656: p->p_flag |= P_SYSTEM; ! 657: ! 658: /* ! 659: * Take us out of the sibling chain, and ! 660: * out of our parent's child chain. ! 661: */ ! 662: LIST_REMOVE(p, p_sibling); ! 663: p->p_sibling.le_prev = NULL; ! 664: p->p_sibling.le_next = NULL; ! 665: p->p_pptr = kernproc; ! 666: ! 667: return(KERN_SUCCESS); ! 668: } ! 669: ! 670: void ! 671: process_terminate_self(void) ! 672: { ! 673: struct proc *p = current_proc(); ! 674: ! 675: if (p != NULL) { ! 676: exit1(p, W_EXITCODE(0, SIGKILL)); ! 677: /*NOTREACHED*/ ! 678: } ! 679: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.