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