123374Smckusick /* 247540Skarels * Copyright (c) 1982, 1986, 1989, 1991 Regents of the University of California. 337580Smckusick * All rights reserved. 423374Smckusick * 544440Sbostic * %sccs.include.redist.c% 637580Smckusick * 7*52115Skarels * @(#)kern_sig.c 7.38 (Berkeley) 01/07/92 823374Smckusick */ 97421Sroot 1047540Skarels #define SIGPROP /* include signal properties table */ 1117092Sbloom #include "param.h" 1247650Skarels #include "signalvar.h" 1347650Skarels #include "resourcevar.h" 1448020Smckusick #include "namei.h" 1537580Smckusick #include "vnode.h" 1617092Sbloom #include "proc.h" 1747540Skarels #include "systm.h" 1817092Sbloom #include "timeb.h" 1917092Sbloom #include "times.h" 2017092Sbloom #include "buf.h" 2117092Sbloom #include "acct.h" 2237580Smckusick #include "file.h" 2317092Sbloom #include "kernel.h" 2439513Skarels #include "wait.h" 2540807Smarc #include "ktrace.h" 267421Sroot 2749102Skarels #include "machine/cpu.h" 2849102Skarels 2947650Skarels #include "vm/vm.h" 3047650Skarels #include "kinfo_proc.h" 3147650Skarels #include "user.h" /* for coredump */ 3237581Smckusick 3317013Smckusick /* 3447540Skarels * Can process p, with pcred pc, send the signal signo to process q? 3517013Smckusick */ 3647540Skarels #define CANSIGNAL(p, pc, q, signo) \ 3747540Skarels ((pc)->pc_ucred->cr_uid == 0 || \ 3847540Skarels (pc)->p_ruid == (q)->p_cred->p_ruid || \ 3947540Skarels (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \ 4047540Skarels (pc)->p_ruid == (q)->p_ucred->cr_uid || \ 4147540Skarels (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \ 4242920Skarels ((signo) == SIGCONT && (q)->p_session == (p)->p_session)) 4339513Skarels 4442920Skarels /* ARGSUSED */ 4542920Skarels sigaction(p, uap, retval) 4642920Skarels struct proc *p; 4742920Skarels register struct args { 4812882Ssam int signo; 4939513Skarels struct sigaction *nsa; 5039513Skarels struct sigaction *osa; 5142920Skarels } *uap; 5242920Skarels int *retval; 5342920Skarels { 5439513Skarels struct sigaction vec; 5539513Skarels register struct sigaction *sa; 5647540Skarels register struct sigacts *ps = p->p_sigacts; 5712882Ssam register int sig; 5839513Skarels int bit, error; 597421Sroot 6012882Ssam sig = uap->signo; 6139513Skarels if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP) 6244405Skarels return (EINVAL); 6339513Skarels sa = &vec; 6439513Skarels if (uap->osa) { 6547540Skarels sa->sa_handler = ps->ps_sigact[sig]; 6647540Skarels sa->sa_mask = ps->ps_catchmask[sig]; 6718308Smckusick bit = sigmask(sig); 6839513Skarels sa->sa_flags = 0; 6947540Skarels if ((ps->ps_sigonstack & bit) != 0) 7039513Skarels sa->sa_flags |= SA_ONSTACK; 7147540Skarels if ((ps->ps_sigintr & bit) == 0) 7239513Skarels sa->sa_flags |= SA_RESTART; 7342920Skarels if (p->p_flag & SNOCLDSTOP) 7439513Skarels sa->sa_flags |= SA_NOCLDSTOP; 7539513Skarels if (error = copyout((caddr_t)sa, (caddr_t)uap->osa, 7639513Skarels sizeof (vec))) 7744405Skarels return (error); 7812951Ssam } 7939513Skarels if (uap->nsa) { 8039513Skarels if (error = copyin((caddr_t)uap->nsa, (caddr_t)sa, 8139513Skarels sizeof (vec))) 8244405Skarels return (error); 8342920Skarels setsigvec(p, sig, sa); 8412951Ssam } 8544405Skarels return (0); 867421Sroot } 877421Sroot 8842920Skarels setsigvec(p, sig, sa) 8942920Skarels register struct proc *p; 9012951Ssam int sig; 9139513Skarels register struct sigaction *sa; 9212882Ssam { 9347540Skarels register struct sigacts *ps = p->p_sigacts; 9412951Ssam register int bit; 9512882Ssam 9617153Sbloom bit = sigmask(sig); 9712882Ssam /* 9812882Ssam * Change setting atomically. 9912882Ssam */ 10017153Sbloom (void) splhigh(); 10147540Skarels ps->ps_sigact[sig] = sa->sa_handler; 10247540Skarels ps->ps_catchmask[sig] = sa->sa_mask &~ sigcantmask; 10339513Skarels if ((sa->sa_flags & SA_RESTART) == 0) 10447540Skarels ps->ps_sigintr |= bit; 10518308Smckusick else 10647540Skarels ps->ps_sigintr &= ~bit; 10739513Skarels if (sa->sa_flags & SA_ONSTACK) 10847540Skarels ps->ps_sigonstack |= bit; 10912951Ssam else 11047540Skarels ps->ps_sigonstack &= ~bit; 11139513Skarels if (sig == SIGCHLD) { 11239513Skarels if (sa->sa_flags & SA_NOCLDSTOP) 11339513Skarels p->p_flag |= SNOCLDSTOP; 11439513Skarels else 11539513Skarels p->p_flag &= ~SNOCLDSTOP; 11639513Skarels } 11739513Skarels /* 11839513Skarels * Set bit in p_sigignore for signals that are set to SIG_IGN, 11939513Skarels * and for signals set to SIG_DFL where the default is to ignore. 12039513Skarels * However, don't put SIGCONT in p_sigignore, 12139513Skarels * as we have to restart the process. 12239513Skarels */ 12339513Skarels if (sa->sa_handler == SIG_IGN || 12447540Skarels (sigprop[sig] & SA_IGNORE && sa->sa_handler == SIG_DFL)) { 12512951Ssam p->p_sig &= ~bit; /* never to be seen again */ 12639513Skarels if (sig != SIGCONT) 12739513Skarels p->p_sigignore |= bit; /* easier in psignal */ 12812951Ssam p->p_sigcatch &= ~bit; 12912882Ssam } else { 13012951Ssam p->p_sigignore &= ~bit; 13139513Skarels if (sa->sa_handler == SIG_DFL) 13212951Ssam p->p_sigcatch &= ~bit; 13312882Ssam else 13412951Ssam p->p_sigcatch |= bit; 13512882Ssam } 13612882Ssam (void) spl0(); 13712882Ssam } 13812882Ssam 13939513Skarels /* 14039513Skarels * Initialize signal state for process 0; 14139513Skarels * set to ignore signals that are ignored by default. 14239513Skarels */ 14347540Skarels void 14439513Skarels siginit(p) 14539513Skarels struct proc *p; 1467421Sroot { 14747540Skarels register int i; 14839513Skarels 14947540Skarels for (i = 0; i < NSIG; i++) 15047540Skarels if (sigprop[i] & SA_IGNORE && i != SIGCONT) 15147540Skarels p->p_sigignore |= sigmask(i); 15239513Skarels } 15339513Skarels 15439513Skarels /* 15539513Skarels * Reset signals for an exec of the specified process. 15639513Skarels */ 15747540Skarels void 15839513Skarels execsigs(p) 15939513Skarels register struct proc *p; 16039513Skarels { 16147540Skarels register struct sigacts *ps = p->p_sigacts; 16239513Skarels register int nc, mask; 16339513Skarels 16439513Skarels /* 16539513Skarels * Reset caught signals. Held signals remain held 16639513Skarels * through p_sigmask (unless they were caught, 16739513Skarels * and are now ignored by default). 16839513Skarels */ 16939513Skarels while (p->p_sigcatch) { 17039513Skarels nc = ffs((long)p->p_sigcatch); 17139513Skarels mask = sigmask(nc); 17239513Skarels p->p_sigcatch &= ~mask; 17347540Skarels if (sigprop[nc] & SA_IGNORE) { 17439513Skarels if (nc != SIGCONT) 17539513Skarels p->p_sigignore |= mask; 17639513Skarels p->p_sig &= ~mask; 17739513Skarels } 17847540Skarels ps->ps_sigact[nc] = SIG_DFL; 17939513Skarels } 18039513Skarels /* 18139513Skarels * Reset stack state to the user stack. 18239513Skarels * Clear set of signals caught on the signal stack. 18339513Skarels */ 18447540Skarels ps->ps_onstack = 0; 18547540Skarels ps->ps_sigsp = 0; 18647540Skarels ps->ps_sigonstack = 0; 18739513Skarels } 18839513Skarels 18939513Skarels /* 19039513Skarels * Manipulate signal mask. 19139513Skarels * Note that we receive new mask, not pointer, 19239513Skarels * and return old mask as return value; 19339513Skarels * the library stub does the rest. 19439513Skarels */ 19542920Skarels sigprocmask(p, uap, retval) 19642920Skarels register struct proc *p; 19742920Skarels struct args { 19839513Skarels int how; 19939513Skarels sigset_t mask; 20042920Skarels } *uap; 20142920Skarels int *retval; 20242920Skarels { 20339513Skarels int error = 0; 20439513Skarels 20542920Skarels *retval = p->p_sigmask; 20639513Skarels (void) splhigh(); 20739513Skarels 20839513Skarels switch (uap->how) { 20939513Skarels case SIG_BLOCK: 21039513Skarels p->p_sigmask |= uap->mask &~ sigcantmask; 21139513Skarels break; 21239513Skarels 21339513Skarels case SIG_UNBLOCK: 21439513Skarels p->p_sigmask &= ~uap->mask; 21539513Skarels break; 21639513Skarels 21739513Skarels case SIG_SETMASK: 21839513Skarels p->p_sigmask = uap->mask &~ sigcantmask; 21939513Skarels break; 22039513Skarels 22139513Skarels default: 22239513Skarels error = EINVAL; 22339513Skarels break; 22439513Skarels } 22539513Skarels (void) spl0(); 22644405Skarels return (error); 22739513Skarels } 22839513Skarels 22942920Skarels /* ARGSUSED */ 23042920Skarels sigpending(p, uap, retval) 23142920Skarels struct proc *p; 23242920Skarels void *uap; 23342920Skarels int *retval; 23439513Skarels { 23539513Skarels 23642920Skarels *retval = p->p_sig; 23744405Skarels return (0); 23839513Skarels } 23939513Skarels 24039513Skarels #ifdef COMPAT_43 24139513Skarels /* 24239513Skarels * Generalized interface signal handler, 4.3-compatible. 24339513Skarels */ 24442920Skarels /* ARGSUSED */ 24542920Skarels osigvec(p, uap, retval) 24642920Skarels struct proc *p; 24742920Skarels register struct args { 24839513Skarels int signo; 24939513Skarels struct sigvec *nsv; 25039513Skarels struct sigvec *osv; 25142920Skarels } *uap; 25242920Skarels int *retval; 25342920Skarels { 25439513Skarels struct sigvec vec; 25547540Skarels register struct sigacts *ps = p->p_sigacts; 25639513Skarels register struct sigvec *sv; 25739513Skarels register int sig; 25839513Skarels int bit, error; 25939513Skarels 26039513Skarels sig = uap->signo; 26139513Skarels if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP) 26244405Skarels return (EINVAL); 26339513Skarels sv = &vec; 26439513Skarels if (uap->osv) { 26547540Skarels *(sig_t *)&sv->sv_handler = ps->ps_sigact[sig]; 26647540Skarels sv->sv_mask = ps->ps_catchmask[sig]; 26739513Skarels bit = sigmask(sig); 26839513Skarels sv->sv_flags = 0; 26947540Skarels if ((ps->ps_sigonstack & bit) != 0) 27039513Skarels sv->sv_flags |= SV_ONSTACK; 27147540Skarels if ((ps->ps_sigintr & bit) != 0) 27239513Skarels sv->sv_flags |= SV_INTERRUPT; 27342920Skarels if (p->p_flag & SNOCLDSTOP) 27439513Skarels sv->sv_flags |= SA_NOCLDSTOP; 27539513Skarels if (error = copyout((caddr_t)sv, (caddr_t)uap->osv, 27639513Skarels sizeof (vec))) 27744405Skarels return (error); 27839513Skarels } 27939513Skarels if (uap->nsv) { 28039513Skarels if (error = copyin((caddr_t)uap->nsv, (caddr_t)sv, 28139513Skarels sizeof (vec))) 28244405Skarels return (error); 28339513Skarels sv->sv_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */ 28442920Skarels setsigvec(p, sig, (struct sigaction *)sv); 28539513Skarels } 28644405Skarels return (0); 28739513Skarels } 28839513Skarels 28942920Skarels osigblock(p, uap, retval) 29042920Skarels register struct proc *p; 29142920Skarels struct args { 29242920Skarels int mask; 29342920Skarels } *uap; 29442920Skarels int *retval; 29539513Skarels { 2967499Sroot 29717153Sbloom (void) splhigh(); 29842920Skarels *retval = p->p_sigmask; 29939513Skarels p->p_sigmask |= uap->mask &~ sigcantmask; 30012882Ssam (void) spl0(); 30144405Skarels return (0); 3027499Sroot } 3037499Sroot 30442920Skarels osigsetmask(p, uap, retval) 30542920Skarels struct proc *p; 30642920Skarels struct args { 30742920Skarels int mask; 30842920Skarels } *uap; 30942920Skarels int *retval; 3107499Sroot { 3117499Sroot 31217153Sbloom (void) splhigh(); 31342920Skarels *retval = p->p_sigmask; 31439513Skarels p->p_sigmask = uap->mask &~ sigcantmask; 31512882Ssam (void) spl0(); 31644405Skarels return (0); 3177499Sroot } 31839513Skarels #endif 3197499Sroot 32039513Skarels /* 32139513Skarels * Suspend process until signal, providing mask to be set 32239513Skarels * in the meantime. Note nonstandard calling convention: 32339513Skarels * libc stub passes mask, not pointer, to save a copyin. 32439513Skarels */ 32542920Skarels /* ARGSUSED */ 32642920Skarels sigsuspend(p, uap, retval) 32742920Skarels register struct proc *p; 32842920Skarels struct args { 32942920Skarels sigset_t mask; 33042920Skarels } *uap; 33142920Skarels int *retval; 3327499Sroot { 33347540Skarels register struct sigacts *ps = p->p_sigacts; 3347499Sroot 33512882Ssam /* 33612882Ssam * When returning from sigpause, we want 33712882Ssam * the old mask to be restored after the 33812882Ssam * signal handler has finished. Thus, we 339*52115Skarels * save it here and mark the sigacts structure 340*52115Skarels * to indicate this. 34112882Ssam */ 34247540Skarels ps->ps_oldmask = p->p_sigmask; 34347540Skarels ps->ps_flags |= SA_OLDMASK; 34439513Skarels p->p_sigmask = uap->mask &~ sigcantmask; 34547540Skarels (void) tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0); 34640807Smarc /* always return EINTR rather than ERESTART... */ 34744405Skarels return (EINTR); 3487499Sroot } 3497499Sroot 35042920Skarels /* ARGSUSED */ 35142920Skarels sigstack(p, uap, retval) 35242920Skarels struct proc *p; 35342920Skarels register struct args { 35412951Ssam struct sigstack *nss; 35512951Ssam struct sigstack *oss; 35642920Skarels } *uap; 35742920Skarels int *retval; 35842920Skarels { 35912951Ssam struct sigstack ss; 36039513Skarels int error = 0; 3617499Sroot 36247540Skarels if (uap->oss && (error = copyout((caddr_t)&p->p_sigacts->ps_sigstack, 36339513Skarels (caddr_t)uap->oss, sizeof (struct sigstack)))) 36444405Skarels return (error); 36539513Skarels if (uap->nss && (error = copyin((caddr_t)uap->nss, (caddr_t)&ss, 36639513Skarels sizeof (ss))) == 0) 36747540Skarels p->p_sigacts->ps_sigstack = ss; 36844405Skarels return (error); 3697499Sroot } 3707499Sroot 37142920Skarels /* ARGSUSED */ 37242920Skarels kill(cp, uap, retval) 37342920Skarels register struct proc *cp; 37442920Skarels register struct args { 37512882Ssam int pid; 37612882Ssam int signo; 37742920Skarels } *uap; 37842920Skarels int *retval; 37942920Skarels { 38018336Smckusick register struct proc *p; 38147540Skarels register struct pcred *pc = cp->p_cred; 3828032Sroot 38339513Skarels if ((unsigned) uap->signo >= NSIG) 38444405Skarels return (EINVAL); 38518336Smckusick if (uap->pid > 0) { 38618336Smckusick /* kill single process */ 38718336Smckusick p = pfind(uap->pid); 38839513Skarels if (p == 0) 38944405Skarels return (ESRCH); 39047540Skarels if (!CANSIGNAL(cp, pc, p, uap->signo)) 39144405Skarels return (EPERM); 39239513Skarels if (uap->signo) 39318336Smckusick psignal(p, uap->signo); 39444405Skarels return (0); 39518336Smckusick } 39618336Smckusick switch (uap->pid) { 39718336Smckusick case -1: /* broadcast signal */ 39844405Skarels return (killpg1(cp, uap->signo, 0, 1)); 39918336Smckusick case 0: /* signal own process group */ 40044405Skarels return (killpg1(cp, uap->signo, 0, 0)); 40118336Smckusick default: /* negative explicit process group */ 40244405Skarels return (killpg1(cp, uap->signo, -uap->pid, 0)); 40318336Smckusick } 40439513Skarels /* NOTREACHED */ 4058032Sroot } 4068032Sroot 40739513Skarels #ifdef COMPAT_43 40842920Skarels /* ARGSUSED */ 40942920Skarels okillpg(p, uap, retval) 41042920Skarels struct proc *p; 41142920Skarels register struct args { 41237581Smckusick int pgid; 4139989Ssam int signo; 41442920Skarels } *uap; 41542920Skarels int *retval; 41642920Skarels { 4178032Sroot 41839513Skarels if ((unsigned) uap->signo >= NSIG) 41944405Skarels return (EINVAL); 42044405Skarels return (killpg1(p, uap->signo, uap->pgid, 0)); 4218032Sroot } 42239513Skarels #endif 4238032Sroot 42442920Skarels /* 42542920Skarels * Common code for kill process group/broadcast kill. 42642920Skarels * cp is calling process. 42742920Skarels */ 42842920Skarels killpg1(cp, signo, pgid, all) 42942920Skarels register struct proc *cp; 43037581Smckusick int signo, pgid, all; 4319989Ssam { 4329989Ssam register struct proc *p; 43347540Skarels register struct pcred *pc = cp->p_cred; 43437581Smckusick struct pgrp *pgrp; 43547540Skarels int nfound = 0; 43637581Smckusick 43737581Smckusick if (all) 43837581Smckusick /* 43937581Smckusick * broadcast 4407421Sroot */ 44137581Smckusick for (p = allproc; p != NULL; p = p->p_nxt) { 44247540Skarels if (p->p_pid <= 1 || p->p_flag&SSYS || 44347540Skarels p == cp || !CANSIGNAL(cp, pc, p, signo)) 44437581Smckusick continue; 44547540Skarels nfound++; 44637581Smckusick if (signo) 44737581Smckusick psignal(p, signo); 44837581Smckusick } 44937581Smckusick else { 45037581Smckusick if (pgid == 0) 45137581Smckusick /* 45237581Smckusick * zero pgid means send to my process group. 45337581Smckusick */ 45447540Skarels pgrp = cp->p_pgrp; 45537581Smckusick else { 45637581Smckusick pgrp = pgfind(pgid); 45737581Smckusick if (pgrp == NULL) 45839513Skarels return (ESRCH); 45937581Smckusick } 46037581Smckusick for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt) { 46147540Skarels if (p->p_pid <= 1 || p->p_flag&SSYS || 46250128Skarels p->p_stat == SZOMB || !CANSIGNAL(cp, pc, p, signo)) 46337581Smckusick continue; 46447540Skarels nfound++; 46537581Smckusick if (signo) 46637581Smckusick psignal(p, signo); 46718336Smckusick } 4687421Sroot } 46947540Skarels return (nfound ? 0 : ESRCH); 4707421Sroot } 4717421Sroot 47242920Skarels /* 4737421Sroot * Send the specified signal to 47437581Smckusick * all processes with 'pgid' as 4757421Sroot * process group. 4767421Sroot */ 47747540Skarels void 47837581Smckusick gsignal(pgid, sig) 47947540Skarels int pgid, sig; 4807421Sroot { 48139513Skarels struct pgrp *pgrp; 4827421Sroot 48339513Skarels if (pgid && (pgrp = pgfind(pgid))) 48442207Smarc pgsignal(pgrp, sig, 0); 4857421Sroot } 48642920Skarels 48740807Smarc /* 48842207Smarc * Send sig to every member of a process group. 48942207Smarc * If checktty is 1, limit to members which have a controlling 49042207Smarc * terminal. 49140807Smarc */ 49247540Skarels void 49342207Smarc pgsignal(pgrp, sig, checkctty) 49439513Skarels struct pgrp *pgrp; 49547540Skarels int sig, checkctty; 49637581Smckusick { 49737581Smckusick register struct proc *p; 49837581Smckusick 49940807Smarc if (pgrp) 50040807Smarc for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt) 50142207Smarc if (checkctty == 0 || p->p_flag&SCTTY) 50242207Smarc psignal(p, sig); 50337581Smckusick } 50437581Smckusick 5057421Sroot /* 50639513Skarels * Send a signal caused by a trap to the current process. 50739513Skarels * If it will be caught immediately, deliver it with correct code. 50839513Skarels * Otherwise, post it normally. 50939513Skarels */ 51047540Skarels void 51147540Skarels trapsignal(p, sig, code) 51247540Skarels struct proc *p; 51339513Skarels register int sig; 51439513Skarels unsigned code; 51539513Skarels { 51647540Skarels register struct sigacts *ps = p->p_sigacts; 51739513Skarels int mask; 51839513Skarels 51939513Skarels mask = sigmask(sig); 52039513Skarels if ((p->p_flag & STRC) == 0 && (p->p_sigcatch & mask) != 0 && 52139513Skarels (p->p_sigmask & mask) == 0) { 52247540Skarels p->p_stats->p_ru.ru_nsignals++; 52340807Smarc #ifdef KTRACE 52440807Smarc if (KTRPOINT(p, KTR_PSIG)) 52547540Skarels ktrpsig(p->p_tracep, sig, ps->ps_sigact[sig], 52640807Smarc p->p_sigmask, code); 52740807Smarc #endif 52847540Skarels sendsig(ps->ps_sigact[sig], sig, p->p_sigmask, code); 52947540Skarels p->p_sigmask |= ps->ps_catchmask[sig] | mask; 53039513Skarels } else { 53147540Skarels ps->ps_code = code; /* XXX for core dump/debugger */ 53239513Skarels psignal(p, sig); 53339513Skarels } 53439513Skarels } 53539513Skarels 53639513Skarels /* 53740807Smarc * Send the specified signal to the specified process. 53847540Skarels * If the signal has an action, the action is usually performed 53947540Skarels * by the target process rather than the caller; we simply add 54047540Skarels * the signal to the set of pending signals for the process. 54140807Smarc * Exceptions: 54240807Smarc * o When a stop signal is sent to a sleeping process that takes the default 54340807Smarc * action, the process is stopped without awakening it. 54440807Smarc * o SIGCONT restarts stopped processes (or puts them back to sleep) 54540807Smarc * regardless of the signal action (eg, blocked or ignored). 54640807Smarc * Other ignored signals are discarded immediately. 5477421Sroot */ 54847540Skarels void 5497421Sroot psignal(p, sig) 5507421Sroot register struct proc *p; 5517421Sroot register int sig; 5527421Sroot { 55347540Skarels register int s, prop; 55439513Skarels register sig_t action; 55517153Sbloom int mask; 5567421Sroot 55739513Skarels if ((unsigned)sig >= NSIG || sig == 0) 55839513Skarels panic("psignal sig"); 55917153Sbloom mask = sigmask(sig); 56047540Skarels prop = sigprop[sig]; 5617421Sroot 5627421Sroot /* 5637421Sroot * If proc is traced, always give parent a chance. 5647421Sroot */ 5657421Sroot if (p->p_flag & STRC) 5667421Sroot action = SIG_DFL; 5677421Sroot else { 5687421Sroot /* 56912882Ssam * If the signal is being ignored, 57012882Ssam * then we forget about it immediately. 57139513Skarels * (Note: we don't set SIGCONT in p_sigignore, 57239513Skarels * and if it is set to SIG_IGN, 57339513Skarels * action will be SIG_DFL here.) 5747421Sroot */ 57517153Sbloom if (p->p_sigignore & mask) 5767421Sroot return; 57717153Sbloom if (p->p_sigmask & mask) 57812882Ssam action = SIG_HOLD; 57917153Sbloom else if (p->p_sigcatch & mask) 58012882Ssam action = SIG_CATCH; 58142437Skarels else 58212882Ssam action = SIG_DFL; 5837421Sroot } 5847421Sroot 58547540Skarels if (p->p_nice > NZERO && (sig == SIGKILL || 58647540Skarels sig == SIGTERM && (p->p_flag&STRC || action != SIG_DFL))) 58747540Skarels p->p_nice = NZERO; 5887421Sroot 58947540Skarels if (prop & SA_CONT) 59039513Skarels p->p_sig &= ~stopsigmask; 59139513Skarels 59247540Skarels if (prop & SA_STOP) { 59345672Skarels /* 59445672Skarels * If sending a tty stop signal to a member of an orphaned 59545672Skarels * process group, discard the signal here if the action 59645672Skarels * is default; don't stop the process below if sleeping, 59745672Skarels * and don't clear any pending SIGCONT. 59845672Skarels */ 59947540Skarels if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0 && 60047540Skarels action == SIG_DFL) 60145741Smckusick return; 60247540Skarels p->p_sig &= ~contsigmask; 6037421Sroot } 60439513Skarels p->p_sig |= mask; 60539513Skarels 6067421Sroot /* 60739513Skarels * Defer further processing for signals which are held, 60839513Skarels * except that stopped processes must be continued by SIGCONT. 6097421Sroot */ 61047540Skarels if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP)) 6117421Sroot return; 61217153Sbloom s = splhigh(); 6137421Sroot switch (p->p_stat) { 6147421Sroot 6157421Sroot case SSLEEP: 6167421Sroot /* 61740807Smarc * If process is sleeping uninterruptibly 6187421Sroot * we can't interrupt the sleep... the signal will 6197421Sroot * be noticed when the process returns through 6207421Sroot * trap() or syscall(). 6217421Sroot */ 62240807Smarc if ((p->p_flag & SSINTR) == 0) 6237421Sroot goto out; 6247421Sroot /* 6257421Sroot * Process is sleeping and traced... make it runnable 6267421Sroot * so it can discover the signal in issig() and stop 6277421Sroot * for the parent. 6287421Sroot */ 6297421Sroot if (p->p_flag&STRC) 6307421Sroot goto run; 63139513Skarels /* 63239513Skarels * When a sleeping process receives a stop 63339513Skarels * signal, process immediately if possible. 63439513Skarels * All other (caught or default) signals 63539513Skarels * cause the process to run. 63639513Skarels */ 63747540Skarels if (prop & SA_STOP) { 6387421Sroot if (action != SIG_DFL) 63939513Skarels goto runfast; 6407421Sroot /* 64147540Skarels * If a child holding parent blocked, 64247540Skarels * stopping could cause deadlock. 6437421Sroot */ 64447540Skarels if (p->p_flag&SPPWAIT) 6457421Sroot goto out; 64617153Sbloom p->p_sig &= ~mask; 64743895Skarels p->p_xstat = sig; 64839513Skarels if ((p->p_pptr->p_flag & SNOCLDSTOP) == 0) 64939513Skarels psignal(p->p_pptr, SIGCHLD); 6507421Sroot stop(p); 6517421Sroot goto out; 65239513Skarels } else 65339513Skarels goto runfast; 6547421Sroot /*NOTREACHED*/ 6557421Sroot 6567421Sroot case SSTOP: 6577421Sroot /* 6587421Sroot * If traced process is already stopped, 6597421Sroot * then no further action is necessary. 6607421Sroot */ 6617421Sroot if (p->p_flag&STRC) 6627421Sroot goto out; 6637421Sroot 66447540Skarels /* 66547540Skarels * Kill signal always sets processes running. 66647540Skarels */ 66747540Skarels if (sig == SIGKILL) 66839513Skarels goto runfast; 6697421Sroot 67047540Skarels if (prop & SA_CONT) { 6717421Sroot /* 67239513Skarels * If SIGCONT is default (or ignored), we continue 67339513Skarels * the process but don't leave the signal in p_sig, 67439513Skarels * as it has no further action. If SIGCONT is held, 67539513Skarels * continue the process and leave the signal in p_sig. 6767421Sroot * If the process catches SIGCONT, let it handle 6777421Sroot * the signal itself. If it isn't waiting on 6787421Sroot * an event, then it goes back to run state. 6797421Sroot * Otherwise, process goes back to sleep state. 6807421Sroot */ 68139513Skarels if (action == SIG_DFL) 68239513Skarels p->p_sig &= ~mask; 68339513Skarels if (action == SIG_CATCH) 68439513Skarels goto runfast; 68539513Skarels if (p->p_wchan == 0) 6867421Sroot goto run; 6877421Sroot p->p_stat = SSLEEP; 6887421Sroot goto out; 68947540Skarels } 6907421Sroot 69147540Skarels if (prop & SA_STOP) { 6927421Sroot /* 6937421Sroot * Already stopped, don't need to stop again. 6947421Sroot * (If we did the shell could get confused.) 6957421Sroot */ 69617153Sbloom p->p_sig &= ~mask; /* take it away */ 6977421Sroot goto out; 6987421Sroot } 6997421Sroot 70047540Skarels /* 70147540Skarels * If process is sleeping interruptibly, then 70247540Skarels * simulate a wakeup so that when it is continued, 70347540Skarels * it will be made runnable and can look at the signal. 70447540Skarels * But don't setrun the process, leave it stopped. 70547540Skarels */ 70647540Skarels if (p->p_wchan && p->p_flag & SSINTR) 70747540Skarels unsleep(p); 70847540Skarels goto out; 70947540Skarels 7107421Sroot default: 7117421Sroot /* 7127421Sroot * SRUN, SIDL, SZOMB do nothing with the signal, 7137421Sroot * other than kicking ourselves if we are running. 7147421Sroot * It will either never be noticed, or noticed very soon. 7157421Sroot */ 71647650Skarels if (p == curproc) 71749102Skarels signotify(p); 7187421Sroot goto out; 7197421Sroot } 7207421Sroot /*NOTREACHED*/ 72139513Skarels 72239513Skarels runfast: 7237421Sroot /* 7247421Sroot * Raise priority to at least PUSER. 7257421Sroot */ 7267421Sroot if (p->p_pri > PUSER) 72717399Skarels p->p_pri = PUSER; 72839513Skarels run: 7297421Sroot setrun(p); 7307421Sroot out: 7317421Sroot splx(s); 7327421Sroot } 7337421Sroot 7347421Sroot /* 73540807Smarc * If the current process has a signal to process (should be caught 73640807Smarc * or cause termination, should interrupt current syscall), 73740807Smarc * return the signal number. Stop signals with default action 73840807Smarc * are processed immediately, then cleared; they aren't returned. 73947540Skarels * This is checked after each entry to the system for a syscall 74047540Skarels * or trap (though this can usually be done without actually calling 74147540Skarels * issig by checking the pending signal masks in the CURSIG macro.) 74247540Skarels * The normal call sequence is 74347540Skarels * 74447540Skarels * while (sig = CURSIG(curproc)) 74547540Skarels * psig(sig); 7467421Sroot */ 74747540Skarels issig(p) 74847540Skarels register struct proc *p; 7497421Sroot { 75047540Skarels register int sig, mask, prop; 7517421Sroot 7527421Sroot for (;;) { 75339513Skarels mask = p->p_sig &~ p->p_sigmask; 75447540Skarels if (p->p_flag&SPPWAIT) 75539513Skarels mask &= ~stopsigmask; 75640807Smarc if (mask == 0) /* no signal to send */ 75740807Smarc return (0); 75839513Skarels sig = ffs((long)mask); 75917153Sbloom mask = sigmask(sig); 76047540Skarels prop = sigprop[sig]; 76140807Smarc /* 76240807Smarc * We should see pending but ignored signals 76340807Smarc * only if STRC was on when they were posted. 76440807Smarc */ 76540807Smarc if (mask & p->p_sigignore && (p->p_flag&STRC) == 0) { 76640807Smarc p->p_sig &= ~mask; 76740807Smarc continue; 76840807Smarc } 76947540Skarels if (p->p_flag&STRC && (p->p_flag&SPPWAIT) == 0) { 7707421Sroot /* 7717421Sroot * If traced, always stop, and stay 7727421Sroot * stopped until released by the parent. 7737421Sroot */ 77443895Skarels p->p_xstat = sig; 77518331Skarels psignal(p->p_pptr, SIGCHLD); 7767421Sroot do { 7777421Sroot stop(p); 7787421Sroot swtch(); 77942926Smckusick } while (!procxmt(p) && p->p_flag&STRC); 7807421Sroot 7817421Sroot /* 78214782Ssam * If the traced bit got turned off, 78340807Smarc * go back up to the top to rescan signals. 78447650Skarels * This ensures that p_sig* and ps_sigact 78547650Skarels * are consistent. 7867421Sroot */ 78740807Smarc if ((p->p_flag&STRC) == 0) 7887421Sroot continue; 7897421Sroot 7907421Sroot /* 7917421Sroot * If parent wants us to take the signal, 79243895Skarels * then it will leave it in p->p_xstat; 7937421Sroot * otherwise we just look for signals again. 7947421Sroot */ 79540807Smarc p->p_sig &= ~mask; /* clear the old signal */ 79643895Skarels sig = p->p_xstat; 7977421Sroot if (sig == 0) 7987421Sroot continue; 79914782Ssam 80014782Ssam /* 80140807Smarc * Put the new signal into p_sig. 80240807Smarc * If signal is being masked, 80340807Smarc * look for other signals. 80414782Ssam */ 80517153Sbloom mask = sigmask(sig); 80640807Smarc p->p_sig |= mask; 80740807Smarc if (p->p_sigmask & mask) 80814782Ssam continue; 8097421Sroot } 81040807Smarc 81140807Smarc /* 81240807Smarc * Decide whether the signal should be returned. 81340807Smarc * Return the signal's number, or fall through 81440807Smarc * to clear it from the pending mask. 81540807Smarc */ 81647540Skarels switch ((int)p->p_sigacts->ps_sigact[sig]) { 8177421Sroot 8187421Sroot case SIG_DFL: 8197421Sroot /* 8207421Sroot * Don't take default actions on system processes. 8217421Sroot */ 82251019Sralph if (p->p_pid <= 1) { 82351019Sralph #ifdef DIAGNOSTIC 82451019Sralph /* 82551019Sralph * Are you sure you want to ignore SIGSEGV 82651019Sralph * in init? XXX 82751019Sralph */ 82851019Sralph printf("Process (pid %d) got signal %d\n", 82951019Sralph p->p_pid, sig); 83051019Sralph #endif 83140807Smarc break; /* == ignore */ 83251019Sralph } 83340807Smarc /* 83440807Smarc * If there is a pending stop signal to process 83540807Smarc * with default action, stop here, 83642437Skarels * then clear the signal. However, 83742437Skarels * if process is member of an orphaned 83842437Skarels * process group, ignore tty stop signals. 83940807Smarc */ 84047540Skarels if (prop & SA_STOP) { 84142437Skarels if (p->p_flag&STRC || 84242437Skarels (p->p_pgrp->pg_jobc == 0 && 84347540Skarels prop & SA_TTYSTOP)) 84440807Smarc break; /* == ignore */ 84543895Skarels p->p_xstat = sig; 8467421Sroot stop(p); 84739513Skarels if ((p->p_pptr->p_flag & SNOCLDSTOP) == 0) 84839513Skarels psignal(p->p_pptr, SIGCHLD); 8497421Sroot swtch(); 85040807Smarc break; 85147540Skarels } else if (prop & SA_IGNORE) { 8527421Sroot /* 85339513Skarels * Except for SIGCONT, shouldn't get here. 85439513Skarels * Default action is to ignore; drop it. 8557421Sroot */ 85640807Smarc break; /* == ignore */ 85739513Skarels } else 85840807Smarc return (sig); 8597421Sroot /*NOTREACHED*/ 8607421Sroot 8617421Sroot case SIG_IGN: 8627421Sroot /* 86339513Skarels * Masking above should prevent us ever trying 86439513Skarels * to take action on an ignored signal other 86539513Skarels * than SIGCONT, unless process is traced. 8667421Sroot */ 86747540Skarels if ((prop & SA_CONT) == 0 && (p->p_flag&STRC) == 0) 8687421Sroot printf("issig\n"); 86940807Smarc break; /* == ignore */ 8707421Sroot 8717421Sroot default: 8727421Sroot /* 8737421Sroot * This signal has an action, let 8747421Sroot * psig process it. 8757421Sroot */ 87640807Smarc return (sig); 8777421Sroot } 87840807Smarc p->p_sig &= ~mask; /* take the signal! */ 8797421Sroot } 88040807Smarc /* NOTREACHED */ 8817421Sroot } 8827421Sroot 8837421Sroot /* 8847421Sroot * Put the argument process into the stopped 88518331Skarels * state and notify the parent via wakeup. 88618331Skarels * Signals are handled elsewhere. 88740807Smarc * The process must not be on the run queue. 8887421Sroot */ 8897421Sroot stop(p) 8907421Sroot register struct proc *p; 8917421Sroot { 8927421Sroot 8937421Sroot p->p_stat = SSTOP; 8947421Sroot p->p_flag &= ~SWTED; 8957421Sroot wakeup((caddr_t)p->p_pptr); 8967421Sroot } 8977421Sroot 8987421Sroot /* 89947540Skarels * Take the action for the specified signal 90047540Skarels * from the current set of pending signals. 9017421Sroot */ 90247540Skarels void 90340807Smarc psig(sig) 90440807Smarc register int sig; 9057421Sroot { 90647540Skarels register struct proc *p = curproc; 90747540Skarels register struct sigacts *ps = p->p_sigacts; 90847540Skarels register sig_t action; 90939513Skarels int mask, returnmask; 9107421Sroot 91140807Smarc #ifdef DIAGNOSTIC 91247540Skarels if (sig == 0) 91347540Skarels panic("psig"); 91440807Smarc #endif 91547540Skarels mask = sigmask(sig); 91647540Skarels p->p_sig &= ~mask; 91747540Skarels action = ps->ps_sigact[sig]; 91840807Smarc #ifdef KTRACE 91947540Skarels if (KTRPOINT(p, KTR_PSIG)) 92047540Skarels ktrpsig(p->p_tracep, sig, action, ps->ps_flags & SA_OLDMASK ? 92147540Skarels ps->ps_oldmask : p->p_sigmask, 0); 92240807Smarc #endif 92347540Skarels if (action == SIG_DFL) { 92447540Skarels /* 92547540Skarels * Default action, where the default is to kill 92647540Skarels * the process. (Other cases were ignored above.) 92747540Skarels */ 92847650Skarels sigexit(p, sig); 92947540Skarels /* NOTREACHED */ 93047540Skarels } else { 93147540Skarels /* 93247540Skarels * If we get here, the signal must be caught. 93347540Skarels */ 93439513Skarels #ifdef DIAGNOSTIC 93547540Skarels if (action == SIG_IGN || (p->p_sigmask & mask)) 93647540Skarels panic("psig action"); 93739513Skarels #endif 93847540Skarels /* 93947540Skarels * Set the new mask value and also defer further 94047540Skarels * occurences of this signal. 94147540Skarels * 94247540Skarels * Special case: user has done a sigpause. Here the 94347540Skarels * current mask is not of interest, but rather the 94447540Skarels * mask from before the sigpause is what we want 94547540Skarels * restored after the signal processing is completed. 94647540Skarels */ 94747540Skarels (void) splhigh(); 94847540Skarels if (ps->ps_flags & SA_OLDMASK) { 94947540Skarels returnmask = ps->ps_oldmask; 95047540Skarels ps->ps_flags &= ~SA_OLDMASK; 95147540Skarels } else 95247540Skarels returnmask = p->p_sigmask; 95347540Skarels p->p_sigmask |= ps->ps_catchmask[sig] | mask; 95447540Skarels (void) spl0(); 95547540Skarels p->p_stats->p_ru.ru_nsignals++; 95647540Skarels sendsig(action, sig, returnmask, 0); 95747540Skarels } 9587421Sroot } 9597421Sroot 9607421Sroot /* 96147650Skarels * Force the current process to exit with the specified 96247650Skarels * signal, dumping core if appropriate. We bypass the normal 96347650Skarels * tests for masked and caught signals, allowing unrecoverable 96447650Skarels * failures to terminate the process without changing signal state. 96547650Skarels * Mark the accounting record with the signal termination. 96647650Skarels * If dumping core, save the signal number for the debugger. 96747650Skarels * Calls exit and does not return. 96847650Skarels */ 96947650Skarels sigexit(p, sig) 97047650Skarels register struct proc *p; 97147650Skarels int sig; 97247650Skarels { 97347650Skarels 97447650Skarels p->p_acflag |= AXSIG; 97547650Skarels if (sigprop[sig] & SA_CORE) { 97647650Skarels p->p_sigacts->ps_sig = sig; 97747650Skarels if (coredump(p) == 0) 97847650Skarels sig |= WCOREFLAG; 97947650Skarels } 98047650Skarels exit(p, W_EXITCODE(0, sig)); 98147650Skarels /* NOTREACHED */ 98247650Skarels } 98347650Skarels 98447650Skarels /* 98547540Skarels * Create a core dump. 98650244Skarels * The file name is "core.progname". 98750099Smckusick * Core dumps are not created if the process is setuid. 9887421Sroot */ 98947540Skarels coredump(p) 99047540Skarels register struct proc *p; 9917421Sroot { 99237728Smckusick register struct vnode *vp; 99347540Skarels register struct pcred *pcred = p->p_cred; 99447540Skarels register struct ucred *cred = pcred->pc_ucred; 99547540Skarels register struct vmspace *vm = p->p_vmspace; 99637580Smckusick struct vattr vattr; 99750105Smckusick int error, error1; 99847540Skarels struct nameidata nd; 99950244Skarels char name[MAXCOMLEN+6]; /* core.progname */ 10007421Sroot 100147540Skarels if (pcred->p_svuid != pcred->p_ruid || 100247540Skarels pcred->p_svgid != pcred->p_rgid) 100337580Smckusick return (EFAULT); 100447540Skarels if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >= 100547540Skarels p->p_rlimit[RLIMIT_CORE].rlim_cur) 100637580Smckusick return (EFAULT); 100750244Skarels sprintf(name, "core.%s", p->p_comm); 100850099Smckusick nd.ni_dirp = name; 100947540Skarels nd.ni_segflg = UIO_SYSSPACE; 101049913Smckusick if (error = vn_open(&nd, p, O_CREAT|FWRITE, 0644)) 101137580Smckusick return (error); 101247540Skarels vp = nd.ni_vp; 101348020Smckusick if (vp->v_type != VREG || VOP_GETATTR(vp, &vattr, cred, p) || 101437580Smckusick vattr.va_nlink != 1) { 101550105Smckusick error = EFAULT; 101650105Smckusick goto out; 10177818Sroot } 101841362Smckusick VATTR_NULL(&vattr); 101937580Smckusick vattr.va_size = 0; 102048020Smckusick VOP_SETATTR(vp, &vattr, cred, p); 102147540Skarels p->p_acflag |= ACORE; 102249102Skarels bcopy(p, &p->p_addr->u_kproc.kp_proc, sizeof(struct proc)); 102349102Skarels fill_eproc(p, &p->p_addr->u_kproc.kp_eproc); 102442004Smckusick #ifdef HPUXCOMPAT 102542004Smckusick /* 102642004Smckusick * BLETCH! If we loaded from an HPUX format binary file 102742004Smckusick * we have to dump an HPUX style user struct so that the 102842004Smckusick * HPUX debuggers can grok it. 102942004Smckusick */ 103049102Skarels if (p->p_addr->u_pcb.pcb_flags & PCB_HPUXBIN) 103147540Skarels error = hpuxdumpu(vp, cred); 103242004Smckusick else 103342004Smckusick #endif 103449102Skarels error = vn_rdwr(UIO_WRITE, vp, (caddr_t) p->p_addr, ctob(UPAGES), 103549102Skarels (off_t)0, UIO_SYSSPACE, IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, 103649102Skarels p); 103737580Smckusick if (error == 0) 103847540Skarels error = vn_rdwr(UIO_WRITE, vp, vm->vm_daddr, 103947540Skarels (int)ctob(vm->vm_dsize), (off_t)ctob(UPAGES), UIO_USERSPACE, 104049102Skarels IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p); 104137580Smckusick if (error == 0) 104237580Smckusick error = vn_rdwr(UIO_WRITE, vp, 104349102Skarels (caddr_t) trunc_page(USRSTACK - ctob(vm->vm_ssize)), 104447540Skarels round_page(ctob(vm->vm_ssize)), 104547540Skarels (off_t)ctob(UPAGES) + ctob(vm->vm_dsize), UIO_USERSPACE, 104649102Skarels IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p); 104750105Smckusick out: 104850105Smckusick VOP_UNLOCK(vp); 104950105Smckusick error1 = vn_close(vp, FWRITE, cred, p); 105050244Skarels if (error == 0) 105150105Smckusick error = error1; 105237580Smckusick return (error); 10537421Sroot } 105439513Skarels 105539513Skarels /* 105639513Skarels * Nonexistent system call-- signal process (may want to handle it). 105739513Skarels * Flag error in case process won't see signal immediately (blocked or ignored). 105839513Skarels */ 105943364Smckusick /* ARGSUSED */ 106043364Smckusick nosys(p, args, retval) 106143364Smckusick struct proc *p; 106243364Smckusick void *args; 106343364Smckusick int *retval; 106439513Skarels { 106539513Skarels 106643364Smckusick psignal(p, SIGSYS); 106744405Skarels return (EINVAL); 106839513Skarels } 1069