![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_sig.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / kern|
Return to kern_sig.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1989, 1991 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)kern_sig.c 7.35 (Berkeley) 6/28/91 ! 34: */ ! 35: ! 36: #define SIGPROP /* include signal properties table */ ! 37: #include "param.h" ! 38: #include "signalvar.h" ! 39: #include "resourcevar.h" ! 40: #include "namei.h" ! 41: #include "vnode.h" ! 42: #include "proc.h" ! 43: #include "systm.h" ! 44: #include "timeb.h" ! 45: #include "times.h" ! 46: #include "buf.h" ! 47: #include "seg.h" ! 48: #include "acct.h" ! 49: #include "file.h" ! 50: #include "kernel.h" ! 51: #include "wait.h" ! 52: #include "ktrace.h" ! 53: ! 54: #include "machine/cpu.h" ! 55: ! 56: #include "vm/vm.h" ! 57: #include "kinfo_proc.h" ! 58: #include "user.h" /* for coredump */ ! 59: ! 60: /* ! 61: * Can process p, with pcred pc, send the signal signo to process q? ! 62: */ ! 63: #define CANSIGNAL(p, pc, q, signo) \ ! 64: ((pc)->pc_ucred->cr_uid == 0 || \ ! 65: (pc)->p_ruid == (q)->p_cred->p_ruid || \ ! 66: (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \ ! 67: (pc)->p_ruid == (q)->p_ucred->cr_uid || \ ! 68: (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \ ! 69: ((signo) == SIGCONT && (q)->p_session == (p)->p_session)) ! 70: ! 71: /* ARGSUSED */ ! 72: sigaction(p, uap, retval) ! 73: struct proc *p; ! 74: register struct args { ! 75: int signo; ! 76: struct sigaction *nsa; ! 77: struct sigaction *osa; ! 78: } *uap; ! 79: int *retval; ! 80: { ! 81: struct sigaction vec; ! 82: register struct sigaction *sa; ! 83: register struct sigacts *ps = p->p_sigacts; ! 84: register int sig; ! 85: int bit, error; ! 86: ! 87: sig = uap->signo; ! 88: if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP) ! 89: return (EINVAL); ! 90: sa = &vec; ! 91: if (uap->osa) { ! 92: sa->sa_handler = ps->ps_sigact[sig]; ! 93: sa->sa_mask = ps->ps_catchmask[sig]; ! 94: bit = sigmask(sig); ! 95: sa->sa_flags = 0; ! 96: if ((ps->ps_sigonstack & bit) != 0) ! 97: sa->sa_flags |= SA_ONSTACK; ! 98: if ((ps->ps_sigintr & bit) == 0) ! 99: sa->sa_flags |= SA_RESTART; ! 100: if (p->p_flag & SNOCLDSTOP) ! 101: sa->sa_flags |= SA_NOCLDSTOP; ! 102: if (error = copyout((caddr_t)sa, (caddr_t)uap->osa, ! 103: sizeof (vec))) ! 104: return (error); ! 105: } ! 106: if (uap->nsa) { ! 107: if (error = copyin((caddr_t)uap->nsa, (caddr_t)sa, ! 108: sizeof (vec))) ! 109: return (error); ! 110: setsigvec(p, sig, sa); ! 111: } ! 112: return (0); ! 113: } ! 114: ! 115: setsigvec(p, sig, sa) ! 116: register struct proc *p; ! 117: int sig; ! 118: register struct sigaction *sa; ! 119: { ! 120: register struct sigacts *ps = p->p_sigacts; ! 121: register int bit; ! 122: ! 123: bit = sigmask(sig); ! 124: /* ! 125: * Change setting atomically. ! 126: */ ! 127: (void) splhigh(); ! 128: ps->ps_sigact[sig] = sa->sa_handler; ! 129: ps->ps_catchmask[sig] = sa->sa_mask &~ sigcantmask; ! 130: if ((sa->sa_flags & SA_RESTART) == 0) ! 131: ps->ps_sigintr |= bit; ! 132: else ! 133: ps->ps_sigintr &= ~bit; ! 134: if (sa->sa_flags & SA_ONSTACK) ! 135: ps->ps_sigonstack |= bit; ! 136: else ! 137: ps->ps_sigonstack &= ~bit; ! 138: if (sig == SIGCHLD) { ! 139: if (sa->sa_flags & SA_NOCLDSTOP) ! 140: p->p_flag |= SNOCLDSTOP; ! 141: else ! 142: p->p_flag &= ~SNOCLDSTOP; ! 143: } ! 144: /* ! 145: * Set bit in p_sigignore for signals that are set to SIG_IGN, ! 146: * and for signals set to SIG_DFL where the default is to ignore. ! 147: * However, don't put SIGCONT in p_sigignore, ! 148: * as we have to restart the process. ! 149: */ ! 150: if (sa->sa_handler == SIG_IGN || ! 151: (sigprop[sig] & SA_IGNORE && sa->sa_handler == SIG_DFL)) { ! 152: p->p_sig &= ~bit; /* never to be seen again */ ! 153: if (sig != SIGCONT) ! 154: p->p_sigignore |= bit; /* easier in psignal */ ! 155: p->p_sigcatch &= ~bit; ! 156: } else { ! 157: p->p_sigignore &= ~bit; ! 158: if (sa->sa_handler == SIG_DFL) ! 159: p->p_sigcatch &= ~bit; ! 160: else ! 161: p->p_sigcatch |= bit; ! 162: } ! 163: (void) spl0(); ! 164: } ! 165: ! 166: /* ! 167: * Initialize signal state for process 0; ! 168: * set to ignore signals that are ignored by default. ! 169: */ ! 170: void ! 171: siginit(p) ! 172: struct proc *p; ! 173: { ! 174: register int i; ! 175: ! 176: for (i = 0; i < NSIG; i++) ! 177: if (sigprop[i] & SA_IGNORE && i != SIGCONT) ! 178: p->p_sigignore |= sigmask(i); ! 179: } ! 180: ! 181: /* ! 182: * Reset signals for an exec of the specified process. ! 183: */ ! 184: void ! 185: execsigs(p) ! 186: register struct proc *p; ! 187: { ! 188: register struct sigacts *ps = p->p_sigacts; ! 189: register int nc, mask; ! 190: ! 191: /* ! 192: * Reset caught signals. Held signals remain held ! 193: * through p_sigmask (unless they were caught, ! 194: * and are now ignored by default). ! 195: */ ! 196: while (p->p_sigcatch) { ! 197: nc = ffs((long)p->p_sigcatch); ! 198: mask = sigmask(nc); ! 199: p->p_sigcatch &= ~mask; ! 200: if (sigprop[nc] & SA_IGNORE) { ! 201: if (nc != SIGCONT) ! 202: p->p_sigignore |= mask; ! 203: p->p_sig &= ~mask; ! 204: } ! 205: ps->ps_sigact[nc] = SIG_DFL; ! 206: } ! 207: /* ! 208: * Reset stack state to the user stack. ! 209: * Clear set of signals caught on the signal stack. ! 210: */ ! 211: ps->ps_onstack = 0; ! 212: ps->ps_sigsp = 0; ! 213: ps->ps_sigonstack = 0; ! 214: } ! 215: ! 216: /* ! 217: * Manipulate signal mask. ! 218: * Note that we receive new mask, not pointer, ! 219: * and return old mask as return value; ! 220: * the library stub does the rest. ! 221: */ ! 222: sigprocmask(p, uap, retval) ! 223: register struct proc *p; ! 224: struct args { ! 225: int how; ! 226: sigset_t mask; ! 227: } *uap; ! 228: int *retval; ! 229: { ! 230: int error = 0; ! 231: ! 232: *retval = p->p_sigmask; ! 233: (void) splhigh(); ! 234: ! 235: switch (uap->how) { ! 236: case SIG_BLOCK: ! 237: p->p_sigmask |= uap->mask &~ sigcantmask; ! 238: break; ! 239: ! 240: case SIG_UNBLOCK: ! 241: p->p_sigmask &= ~uap->mask; ! 242: break; ! 243: ! 244: case SIG_SETMASK: ! 245: p->p_sigmask = uap->mask &~ sigcantmask; ! 246: break; ! 247: ! 248: default: ! 249: error = EINVAL; ! 250: break; ! 251: } ! 252: (void) spl0(); ! 253: return (error); ! 254: } ! 255: ! 256: /* ARGSUSED */ ! 257: sigpending(p, uap, retval) ! 258: struct proc *p; ! 259: void *uap; ! 260: int *retval; ! 261: { ! 262: ! 263: *retval = p->p_sig; ! 264: return (0); ! 265: } ! 266: ! 267: #ifdef COMPAT_43 ! 268: /* ! 269: * Generalized interface signal handler, 4.3-compatible. ! 270: */ ! 271: /* ARGSUSED */ ! 272: osigvec(p, uap, retval) ! 273: struct proc *p; ! 274: register struct args { ! 275: int signo; ! 276: struct sigvec *nsv; ! 277: struct sigvec *osv; ! 278: } *uap; ! 279: int *retval; ! 280: { ! 281: struct sigvec vec; ! 282: register struct sigacts *ps = p->p_sigacts; ! 283: register struct sigvec *sv; ! 284: register int sig; ! 285: int bit, error; ! 286: ! 287: sig = uap->signo; ! 288: if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP) ! 289: return (EINVAL); ! 290: sv = &vec; ! 291: if (uap->osv) { ! 292: *(sig_t *)&sv->sv_handler = ps->ps_sigact[sig]; ! 293: sv->sv_mask = ps->ps_catchmask[sig]; ! 294: bit = sigmask(sig); ! 295: sv->sv_flags = 0; ! 296: if ((ps->ps_sigonstack & bit) != 0) ! 297: sv->sv_flags |= SV_ONSTACK; ! 298: if ((ps->ps_sigintr & bit) != 0) ! 299: sv->sv_flags |= SV_INTERRUPT; ! 300: if (p->p_flag & SNOCLDSTOP) ! 301: sv->sv_flags |= SA_NOCLDSTOP; ! 302: if (error = copyout((caddr_t)sv, (caddr_t)uap->osv, ! 303: sizeof (vec))) ! 304: return (error); ! 305: } ! 306: if (uap->nsv) { ! 307: if (error = copyin((caddr_t)uap->nsv, (caddr_t)sv, ! 308: sizeof (vec))) ! 309: return (error); ! 310: sv->sv_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */ ! 311: setsigvec(p, sig, (struct sigaction *)sv); ! 312: } ! 313: return (0); ! 314: } ! 315: ! 316: osigblock(p, uap, retval) ! 317: register struct proc *p; ! 318: struct args { ! 319: int mask; ! 320: } *uap; ! 321: int *retval; ! 322: { ! 323: ! 324: (void) splhigh(); ! 325: *retval = p->p_sigmask; ! 326: p->p_sigmask |= uap->mask &~ sigcantmask; ! 327: (void) spl0(); ! 328: return (0); ! 329: } ! 330: ! 331: osigsetmask(p, uap, retval) ! 332: struct proc *p; ! 333: struct args { ! 334: int mask; ! 335: } *uap; ! 336: int *retval; ! 337: { ! 338: ! 339: (void) splhigh(); ! 340: *retval = p->p_sigmask; ! 341: p->p_sigmask = uap->mask &~ sigcantmask; ! 342: (void) spl0(); ! 343: return (0); ! 344: } ! 345: #endif ! 346: ! 347: /* ! 348: * Suspend process until signal, providing mask to be set ! 349: * in the meantime. Note nonstandard calling convention: ! 350: * libc stub passes mask, not pointer, to save a copyin. ! 351: */ ! 352: /* ARGSUSED */ ! 353: sigsuspend(p, uap, retval) ! 354: register struct proc *p; ! 355: struct args { ! 356: sigset_t mask; ! 357: } *uap; ! 358: int *retval; ! 359: { ! 360: register struct sigacts *ps = p->p_sigacts; ! 361: ! 362: /* ! 363: * When returning from sigpause, we want ! 364: * the old mask to be restored after the ! 365: * signal handler has finished. Thus, we ! 366: * save it here and mark the proc structure ! 367: * to indicate this (should be in sigacts). ! 368: */ ! 369: ps->ps_oldmask = p->p_sigmask; ! 370: ps->ps_flags |= SA_OLDMASK; ! 371: p->p_sigmask = uap->mask &~ sigcantmask; ! 372: (void) tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0); ! 373: /* always return EINTR rather than ERESTART... */ ! 374: return (EINTR); ! 375: } ! 376: ! 377: /* ARGSUSED */ ! 378: sigstack(p, uap, retval) ! 379: struct proc *p; ! 380: register struct args { ! 381: struct sigstack *nss; ! 382: struct sigstack *oss; ! 383: } *uap; ! 384: int *retval; ! 385: { ! 386: struct sigstack ss; ! 387: int error = 0; ! 388: ! 389: if (uap->oss && (error = copyout((caddr_t)&p->p_sigacts->ps_sigstack, ! 390: (caddr_t)uap->oss, sizeof (struct sigstack)))) ! 391: return (error); ! 392: if (uap->nss && (error = copyin((caddr_t)uap->nss, (caddr_t)&ss, ! 393: sizeof (ss))) == 0) ! 394: p->p_sigacts->ps_sigstack = ss; ! 395: return (error); ! 396: } ! 397: ! 398: /* ARGSUSED */ ! 399: kill(cp, uap, retval) ! 400: register struct proc *cp; ! 401: register struct args { ! 402: int pid; ! 403: int signo; ! 404: } *uap; ! 405: int *retval; ! 406: { ! 407: register struct proc *p; ! 408: register struct pcred *pc = cp->p_cred; ! 409: ! 410: if ((unsigned) uap->signo >= NSIG) ! 411: return (EINVAL); ! 412: if (uap->pid > 0) { ! 413: /* kill single process */ ! 414: p = pfind(uap->pid); ! 415: if (p == 0) ! 416: return (ESRCH); ! 417: if (!CANSIGNAL(cp, pc, p, uap->signo)) ! 418: return (EPERM); ! 419: if (uap->signo) ! 420: psignal(p, uap->signo); ! 421: return (0); ! 422: } ! 423: switch (uap->pid) { ! 424: case -1: /* broadcast signal */ ! 425: return (killpg1(cp, uap->signo, 0, 1)); ! 426: case 0: /* signal own process group */ ! 427: return (killpg1(cp, uap->signo, 0, 0)); ! 428: default: /* negative explicit process group */ ! 429: return (killpg1(cp, uap->signo, -uap->pid, 0)); ! 430: } ! 431: /* NOTREACHED */ ! 432: } ! 433: ! 434: #ifdef COMPAT_43 ! 435: /* ARGSUSED */ ! 436: okillpg(p, uap, retval) ! 437: struct proc *p; ! 438: register struct args { ! 439: int pgid; ! 440: int signo; ! 441: } *uap; ! 442: int *retval; ! 443: { ! 444: ! 445: if ((unsigned) uap->signo >= NSIG) ! 446: return (EINVAL); ! 447: return (killpg1(p, uap->signo, uap->pgid, 0)); ! 448: } ! 449: #endif ! 450: ! 451: /* ! 452: * Common code for kill process group/broadcast kill. ! 453: * cp is calling process. ! 454: */ ! 455: killpg1(cp, signo, pgid, all) ! 456: register struct proc *cp; ! 457: int signo, pgid, all; ! 458: { ! 459: register struct proc *p; ! 460: register struct pcred *pc = cp->p_cred; ! 461: struct pgrp *pgrp; ! 462: int nfound = 0; ! 463: ! 464: if (all) ! 465: /* ! 466: * broadcast ! 467: */ ! 468: for (p = allproc; p != NULL; p = p->p_nxt) { ! 469: if (p->p_pid <= 1 || p->p_flag&SSYS || ! 470: p == cp || !CANSIGNAL(cp, pc, p, signo)) ! 471: continue; ! 472: nfound++; ! 473: if (signo) ! 474: psignal(p, signo); ! 475: } ! 476: else { ! 477: if (pgid == 0) ! 478: /* ! 479: * zero pgid means send to my process group. ! 480: */ ! 481: pgrp = cp->p_pgrp; ! 482: else { ! 483: pgrp = pgfind(pgid); ! 484: if (pgrp == NULL) ! 485: return (ESRCH); ! 486: } ! 487: for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt) { ! 488: if (p->p_pid <= 1 || p->p_flag&SSYS || ! 489: p->p_stat == SZOMB || !CANSIGNAL(cp, pc, p, signo)) ! 490: continue; ! 491: nfound++; ! 492: if (signo) ! 493: psignal(p, signo); ! 494: } ! 495: } ! 496: return (nfound ? 0 : ESRCH); ! 497: } ! 498: ! 499: /* ! 500: * Send the specified signal to ! 501: * all processes with 'pgid' as ! 502: * process group. ! 503: */ ! 504: void ! 505: gsignal(pgid, sig) ! 506: int pgid, sig; ! 507: { ! 508: struct pgrp *pgrp; ! 509: ! 510: if (pgid && (pgrp = pgfind(pgid))) ! 511: pgsignal(pgrp, sig, 0); ! 512: } ! 513: ! 514: /* ! 515: * Send sig to every member of a process group. ! 516: * If checktty is 1, limit to members which have a controlling ! 517: * terminal. ! 518: */ ! 519: void ! 520: pgsignal(pgrp, sig, checkctty) ! 521: struct pgrp *pgrp; ! 522: int sig, checkctty; ! 523: { ! 524: register struct proc *p; ! 525: ! 526: if (pgrp) ! 527: for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt) ! 528: if (checkctty == 0 || p->p_flag&SCTTY) ! 529: psignal(p, sig); ! 530: } ! 531: ! 532: /* ! 533: * Send a signal caused by a trap to the current process. ! 534: * If it will be caught immediately, deliver it with correct code. ! 535: * Otherwise, post it normally. ! 536: */ ! 537: void ! 538: trapsignal(p, sig, code) ! 539: struct proc *p; ! 540: register int sig; ! 541: unsigned code; ! 542: { ! 543: register struct sigacts *ps = p->p_sigacts; ! 544: int mask; ! 545: ! 546: mask = sigmask(sig); ! 547: if ((p->p_flag & STRC) == 0 && (p->p_sigcatch & mask) != 0 && ! 548: (p->p_sigmask & mask) == 0) { ! 549: p->p_stats->p_ru.ru_nsignals++; ! 550: #ifdef KTRACE ! 551: if (KTRPOINT(p, KTR_PSIG)) ! 552: ktrpsig(p->p_tracep, sig, ps->ps_sigact[sig], ! 553: p->p_sigmask, code); ! 554: #endif ! 555: sendsig(ps->ps_sigact[sig], sig, p->p_sigmask, code); ! 556: p->p_sigmask |= ps->ps_catchmask[sig] | mask; ! 557: } else { ! 558: ps->ps_code = code; /* XXX for core dump/debugger */ ! 559: psignal(p, sig); ! 560: } ! 561: } ! 562: ! 563: /* ! 564: * Send the specified signal to the specified process. ! 565: * If the signal has an action, the action is usually performed ! 566: * by the target process rather than the caller; we simply add ! 567: * the signal to the set of pending signals for the process. ! 568: * Exceptions: ! 569: * o When a stop signal is sent to a sleeping process that takes the default ! 570: * action, the process is stopped without awakening it. ! 571: * o SIGCONT restarts stopped processes (or puts them back to sleep) ! 572: * regardless of the signal action (eg, blocked or ignored). ! 573: * Other ignored signals are discarded immediately. ! 574: */ ! 575: void ! 576: psignal(p, sig) ! 577: register struct proc *p; ! 578: register int sig; ! 579: { ! 580: register int s, prop; ! 581: register sig_t action; ! 582: int mask; ! 583: ! 584: if ((unsigned)sig >= NSIG || sig == 0) ! 585: panic("psignal sig"); ! 586: mask = sigmask(sig); ! 587: prop = sigprop[sig]; ! 588: ! 589: /* ! 590: * If proc is traced, always give parent a chance. ! 591: */ ! 592: if (p->p_flag & STRC) ! 593: action = SIG_DFL; ! 594: else { ! 595: /* ! 596: * If the signal is being ignored, ! 597: * then we forget about it immediately. ! 598: * (Note: we don't set SIGCONT in p_sigignore, ! 599: * and if it is set to SIG_IGN, ! 600: * action will be SIG_DFL here.) ! 601: */ ! 602: if (p->p_sigignore & mask) ! 603: return; ! 604: if (p->p_sigmask & mask) ! 605: action = SIG_HOLD; ! 606: else if (p->p_sigcatch & mask) ! 607: action = SIG_CATCH; ! 608: else ! 609: action = SIG_DFL; ! 610: } ! 611: ! 612: if (p->p_nice > NZERO && (sig == SIGKILL || ! 613: sig == SIGTERM && (p->p_flag&STRC || action != SIG_DFL))) ! 614: p->p_nice = NZERO; ! 615: ! 616: if (prop & SA_CONT) ! 617: p->p_sig &= ~stopsigmask; ! 618: ! 619: if (prop & SA_STOP) { ! 620: /* ! 621: * If sending a tty stop signal to a member of an orphaned ! 622: * process group, discard the signal here if the action ! 623: * is default; don't stop the process below if sleeping, ! 624: * and don't clear any pending SIGCONT. ! 625: */ ! 626: if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0 && ! 627: action == SIG_DFL) ! 628: return; ! 629: p->p_sig &= ~contsigmask; ! 630: } ! 631: p->p_sig |= mask; ! 632: ! 633: /* ! 634: * Defer further processing for signals which are held, ! 635: * except that stopped processes must be continued by SIGCONT. ! 636: */ ! 637: if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP)) ! 638: return; ! 639: s = splhigh(); ! 640: switch (p->p_stat) { ! 641: ! 642: case SSLEEP: ! 643: /* ! 644: * If process is sleeping uninterruptibly ! 645: * we can't interrupt the sleep... the signal will ! 646: * be noticed when the process returns through ! 647: * trap() or syscall(). ! 648: */ ! 649: if ((p->p_flag & SSINTR) == 0) ! 650: goto out; ! 651: /* ! 652: * Process is sleeping and traced... make it runnable ! 653: * so it can discover the signal in issig() and stop ! 654: * for the parent. ! 655: */ ! 656: if (p->p_flag&STRC) ! 657: goto run; ! 658: /* ! 659: * When a sleeping process receives a stop ! 660: * signal, process immediately if possible. ! 661: * All other (caught or default) signals ! 662: * cause the process to run. ! 663: */ ! 664: if (prop & SA_STOP) { ! 665: if (action != SIG_DFL) ! 666: goto runfast; ! 667: /* ! 668: * If a child holding parent blocked, ! 669: * stopping could cause deadlock. ! 670: */ ! 671: if (p->p_flag&SPPWAIT) ! 672: goto out; ! 673: p->p_sig &= ~mask; ! 674: p->p_xstat = sig; ! 675: if ((p->p_pptr->p_flag & SNOCLDSTOP) == 0) ! 676: psignal(p->p_pptr, SIGCHLD); ! 677: stop(p); ! 678: goto out; ! 679: } else ! 680: goto runfast; ! 681: /*NOTREACHED*/ ! 682: ! 683: case SSTOP: ! 684: /* ! 685: * If traced process is already stopped, ! 686: * then no further action is necessary. ! 687: */ ! 688: if (p->p_flag&STRC) ! 689: goto out; ! 690: ! 691: /* ! 692: * Kill signal always sets processes running. ! 693: */ ! 694: if (sig == SIGKILL) ! 695: goto runfast; ! 696: ! 697: if (prop & SA_CONT) { ! 698: /* ! 699: * If SIGCONT is default (or ignored), we continue ! 700: * the process but don't leave the signal in p_sig, ! 701: * as it has no further action. If SIGCONT is held, ! 702: * continue the process and leave the signal in p_sig. ! 703: * If the process catches SIGCONT, let it handle ! 704: * the signal itself. If it isn't waiting on ! 705: * an event, then it goes back to run state. ! 706: * Otherwise, process goes back to sleep state. ! 707: */ ! 708: if (action == SIG_DFL) ! 709: p->p_sig &= ~mask; ! 710: if (action == SIG_CATCH) ! 711: goto runfast; ! 712: if (p->p_wchan == 0) ! 713: goto run; ! 714: p->p_stat = SSLEEP; ! 715: goto out; ! 716: } ! 717: ! 718: if (prop & SA_STOP) { ! 719: /* ! 720: * Already stopped, don't need to stop again. ! 721: * (If we did the shell could get confused.) ! 722: */ ! 723: p->p_sig &= ~mask; /* take it away */ ! 724: goto out; ! 725: } ! 726: ! 727: /* ! 728: * If process is sleeping interruptibly, then ! 729: * simulate a wakeup so that when it is continued, ! 730: * it will be made runnable and can look at the signal. ! 731: * But don't setrun the process, leave it stopped. ! 732: */ ! 733: if (p->p_wchan && p->p_flag & SSINTR) ! 734: unsleep(p); ! 735: goto out; ! 736: ! 737: default: ! 738: /* ! 739: * SRUN, SIDL, SZOMB do nothing with the signal, ! 740: * other than kicking ourselves if we are running. ! 741: * It will either never be noticed, or noticed very soon. ! 742: */ ! 743: if (p == curproc) ! 744: signotify(p); ! 745: goto out; ! 746: } ! 747: /*NOTREACHED*/ ! 748: ! 749: runfast: ! 750: /* ! 751: * Raise priority to at least PUSER. ! 752: */ ! 753: if (p->p_pri > PUSER) ! 754: p->p_pri = PUSER; ! 755: run: ! 756: setrun(p); ! 757: out: ! 758: splx(s); ! 759: } ! 760: ! 761: /* ! 762: * If the current process has a signal to process (should be caught ! 763: * or cause termination, should interrupt current syscall), ! 764: * return the signal number. Stop signals with default action ! 765: * are processed immediately, then cleared; they aren't returned. ! 766: * This is checked after each entry to the system for a syscall ! 767: * or trap (though this can usually be done without actually calling ! 768: * issig by checking the pending signal masks in the CURSIG macro.) ! 769: * The normal call sequence is ! 770: * ! 771: * while (sig = CURSIG(curproc)) ! 772: * psig(sig); ! 773: */ ! 774: issig(p) ! 775: register struct proc *p; ! 776: { ! 777: register int sig, mask, prop; ! 778: ! 779: for (;;) { ! 780: mask = p->p_sig &~ p->p_sigmask; ! 781: if (p->p_flag&SPPWAIT) ! 782: mask &= ~stopsigmask; ! 783: if (mask == 0) /* no signal to send */ ! 784: return (0); ! 785: sig = ffs((long)mask); ! 786: mask = sigmask(sig); ! 787: prop = sigprop[sig]; ! 788: /* ! 789: * We should see pending but ignored signals ! 790: * only if STRC was on when they were posted. ! 791: */ ! 792: if (mask & p->p_sigignore && (p->p_flag&STRC) == 0) { ! 793: p->p_sig &= ~mask; ! 794: continue; ! 795: } ! 796: if (p->p_flag&STRC && (p->p_flag&SPPWAIT) == 0) { ! 797: /* ! 798: * If traced, always stop, and stay ! 799: * stopped until released by the parent. ! 800: */ ! 801: p->p_xstat = sig; ! 802: psignal(p->p_pptr, SIGCHLD); ! 803: do { ! 804: stop(p); ! 805: swtch(); ! 806: } while (!procxmt(p) && p->p_flag&STRC); ! 807: ! 808: /* ! 809: * If the traced bit got turned off, ! 810: * go back up to the top to rescan signals. ! 811: * This ensures that p_sig* and ps_sigact ! 812: * are consistent. ! 813: */ ! 814: if ((p->p_flag&STRC) == 0) ! 815: continue; ! 816: ! 817: /* ! 818: * If parent wants us to take the signal, ! 819: * then it will leave it in p->p_xstat; ! 820: * otherwise we just look for signals again. ! 821: */ ! 822: p->p_sig &= ~mask; /* clear the old signal */ ! 823: sig = p->p_xstat; ! 824: if (sig == 0) ! 825: continue; ! 826: ! 827: /* ! 828: * Put the new signal into p_sig. ! 829: * If signal is being masked, ! 830: * look for other signals. ! 831: */ ! 832: mask = sigmask(sig); ! 833: p->p_sig |= mask; ! 834: if (p->p_sigmask & mask) ! 835: continue; ! 836: } ! 837: ! 838: /* ! 839: * Decide whether the signal should be returned. ! 840: * Return the signal's number, or fall through ! 841: * to clear it from the pending mask. ! 842: */ ! 843: switch ((int)p->p_sigacts->ps_sigact[sig]) { ! 844: ! 845: case SIG_DFL: ! 846: /* ! 847: * Don't take default actions on system processes. ! 848: */ ! 849: if (p->p_pid <= 1) ! 850: break; /* == ignore */ ! 851: /* ! 852: * If there is a pending stop signal to process ! 853: * with default action, stop here, ! 854: * then clear the signal. However, ! 855: * if process is member of an orphaned ! 856: * process group, ignore tty stop signals. ! 857: */ ! 858: if (prop & SA_STOP) { ! 859: if (p->p_flag&STRC || ! 860: (p->p_pgrp->pg_jobc == 0 && ! 861: prop & SA_TTYSTOP)) ! 862: break; /* == ignore */ ! 863: p->p_xstat = sig; ! 864: stop(p); ! 865: if ((p->p_pptr->p_flag & SNOCLDSTOP) == 0) ! 866: psignal(p->p_pptr, SIGCHLD); ! 867: swtch(); ! 868: break; ! 869: } else if (prop & SA_IGNORE) { ! 870: /* ! 871: * Except for SIGCONT, shouldn't get here. ! 872: * Default action is to ignore; drop it. ! 873: */ ! 874: break; /* == ignore */ ! 875: } else ! 876: return (sig); ! 877: /*NOTREACHED*/ ! 878: ! 879: case SIG_IGN: ! 880: /* ! 881: * Masking above should prevent us ever trying ! 882: * to take action on an ignored signal other ! 883: * than SIGCONT, unless process is traced. ! 884: */ ! 885: if ((prop & SA_CONT) == 0 && (p->p_flag&STRC) == 0) ! 886: printf("issig\n"); ! 887: break; /* == ignore */ ! 888: ! 889: default: ! 890: /* ! 891: * This signal has an action, let ! 892: * psig process it. ! 893: */ ! 894: return (sig); ! 895: } ! 896: p->p_sig &= ~mask; /* take the signal! */ ! 897: } ! 898: /* NOTREACHED */ ! 899: } ! 900: ! 901: /* ! 902: * Put the argument process into the stopped ! 903: * state and notify the parent via wakeup. ! 904: * Signals are handled elsewhere. ! 905: * The process must not be on the run queue. ! 906: */ ! 907: stop(p) ! 908: register struct proc *p; ! 909: { ! 910: ! 911: p->p_stat = SSTOP; ! 912: p->p_flag &= ~SWTED; ! 913: wakeup((caddr_t)p->p_pptr); ! 914: } ! 915: ! 916: /* ! 917: * Take the action for the specified signal ! 918: * from the current set of pending signals. ! 919: */ ! 920: void ! 921: psig(sig) ! 922: register int sig; ! 923: { ! 924: register struct proc *p = curproc; ! 925: register struct sigacts *ps = p->p_sigacts; ! 926: register sig_t action; ! 927: int mask, returnmask; ! 928: ! 929: #ifdef DIAGNOSTIC ! 930: if (sig == 0) ! 931: panic("psig"); ! 932: #endif ! 933: mask = sigmask(sig); ! 934: p->p_sig &= ~mask; ! 935: action = ps->ps_sigact[sig]; ! 936: #ifdef KTRACE ! 937: if (KTRPOINT(p, KTR_PSIG)) ! 938: ktrpsig(p->p_tracep, sig, action, ps->ps_flags & SA_OLDMASK ? ! 939: ps->ps_oldmask : p->p_sigmask, 0); ! 940: #endif ! 941: if (action == SIG_DFL) { ! 942: /* ! 943: * Default action, where the default is to kill ! 944: * the process. (Other cases were ignored above.) ! 945: */ ! 946: sigexit(p, sig); ! 947: /* NOTREACHED */ ! 948: } else { ! 949: /* ! 950: * If we get here, the signal must be caught. ! 951: */ ! 952: #ifdef DIAGNOSTIC ! 953: if (action == SIG_IGN || (p->p_sigmask & mask)) ! 954: panic("psig action"); ! 955: #endif ! 956: /* ! 957: * Set the new mask value and also defer further ! 958: * occurences of this signal. ! 959: * ! 960: * Special case: user has done a sigpause. Here the ! 961: * current mask is not of interest, but rather the ! 962: * mask from before the sigpause is what we want ! 963: * restored after the signal processing is completed. ! 964: */ ! 965: (void) splhigh(); ! 966: if (ps->ps_flags & SA_OLDMASK) { ! 967: returnmask = ps->ps_oldmask; ! 968: ps->ps_flags &= ~SA_OLDMASK; ! 969: } else ! 970: returnmask = p->p_sigmask; ! 971: p->p_sigmask |= ps->ps_catchmask[sig] | mask; ! 972: (void) spl0(); ! 973: p->p_stats->p_ru.ru_nsignals++; ! 974: sendsig(action, sig, returnmask, 0); ! 975: } ! 976: } ! 977: ! 978: /* ! 979: * Force the current process to exit with the specified ! 980: * signal, dumping core if appropriate. We bypass the normal ! 981: * tests for masked and caught signals, allowing unrecoverable ! 982: * failures to terminate the process without changing signal state. ! 983: * Mark the accounting record with the signal termination. ! 984: * If dumping core, save the signal number for the debugger. ! 985: * Calls exit and does not return. ! 986: */ ! 987: sigexit(p, sig) ! 988: register struct proc *p; ! 989: int sig; ! 990: { ! 991: ! 992: p->p_acflag |= AXSIG; ! 993: if (sigprop[sig] & SA_CORE) { ! 994: p->p_sigacts->ps_sig = sig; ! 995: if (coredump(p) == 0) ! 996: sig |= WCOREFLAG; ! 997: } ! 998: exit(p, W_EXITCODE(0, sig)); ! 999: /* NOTREACHED */ ! 1000: } ! 1001: ! 1002: /* ! 1003: * Create a core dump. ! 1004: * The file name is "core.progname". ! 1005: * Core dumps are not created if the process is setuid. ! 1006: */ ! 1007: coredump(p) ! 1008: register struct proc *p; ! 1009: { ! 1010: register struct vnode *vp; ! 1011: register struct pcred *pcred = p->p_cred; ! 1012: register struct ucred *cred = pcred->pc_ucred; ! 1013: register struct vmspace *vm = p->p_vmspace; ! 1014: struct vattr vattr; ! 1015: int error, error1; ! 1016: struct nameidata nd; ! 1017: char name[MAXCOMLEN+6]; /* core.progname */ ! 1018: ! 1019: if (pcred->p_svuid != pcred->p_ruid || ! 1020: pcred->p_svgid != pcred->p_rgid) ! 1021: return (EFAULT); ! 1022: if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >= ! 1023: p->p_rlimit[RLIMIT_CORE].rlim_cur) ! 1024: return (EFAULT); ! 1025: sprintf(name, "core.%s", p->p_comm); ! 1026: nd.ni_dirp = name; ! 1027: nd.ni_segflg = UIO_SYSSPACE; ! 1028: if (error = vn_open(&nd, p, O_CREAT|FWRITE, 0644)) ! 1029: return (error); ! 1030: vp = nd.ni_vp; ! 1031: if (vp->v_type != VREG || VOP_GETATTR(vp, &vattr, cred, p) || ! 1032: vattr.va_nlink != 1) { ! 1033: error = EFAULT; ! 1034: goto out; ! 1035: } ! 1036: VATTR_NULL(&vattr); ! 1037: vattr.va_size = 0; ! 1038: VOP_SETATTR(vp, &vattr, cred, p); ! 1039: p->p_acflag |= ACORE; ! 1040: bcopy(p, &p->p_addr->u_kproc.kp_proc, sizeof(struct proc)); ! 1041: fill_eproc(p, &p->p_addr->u_kproc.kp_eproc); ! 1042: #ifdef HPUXCOMPAT ! 1043: /* ! 1044: * BLETCH! If we loaded from an HPUX format binary file ! 1045: * we have to dump an HPUX style user struct so that the ! 1046: * HPUX debuggers can grok it. ! 1047: */ ! 1048: if (p->p_addr->u_pcb.pcb_flags & PCB_HPUXBIN) ! 1049: error = hpuxdumpu(vp, cred); ! 1050: else ! 1051: #endif ! 1052: error = vn_rdwr(UIO_WRITE, vp, (caddr_t) p->p_addr, ctob(UPAGES), ! 1053: (off_t)0, UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, ! 1054: p); ! 1055: if (error == 0) ! 1056: error = vn_rdwr(UIO_WRITE, vp, vm->vm_daddr, ! 1057: (int)ctob(vm->vm_dsize), (off_t)ctob(UPAGES), UIO_USERSPACE, ! 1058: IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p); ! 1059: if (error == 0) ! 1060: error = vn_rdwr(UIO_WRITE, vp, ! 1061: (caddr_t) trunc_page(USRSTACK - ctob(vm->vm_ssize)), ! 1062: round_page(ctob(vm->vm_ssize)), ! 1063: (off_t)ctob(UPAGES) + ctob(vm->vm_dsize), UIO_USERSPACE, ! 1064: IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p); ! 1065: out: ! 1066: VOP_UNLOCK(vp); ! 1067: error1 = vn_close(vp, FWRITE, cred, p); ! 1068: if (error == 0) ! 1069: error = error1; ! 1070: return (error); ! 1071: } ! 1072: ! 1073: /* ! 1074: * Nonexistent system call-- signal process (may want to handle it). ! 1075: * Flag error in case process won't see signal immediately (blocked or ignored). ! 1076: */ ! 1077: /* ARGSUSED */ ! 1078: nosys(p, args, retval) ! 1079: struct proc *p; ! 1080: void *args; ! 1081: int *retval; ! 1082: { ! 1083: ! 1084: psignal(p, SIGSYS); ! 1085: return (EINVAL); ! 1086: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.