123374Smckusick /* 263176Sbostic * Copyright (c) 1982, 1986, 1989, 1991, 1993 363176Sbostic * The Regents of the University of California. All rights reserved. 423374Smckusick * 544440Sbostic * %sccs.include.redist.c% 637580Smckusick * 7*64594Sbostic * @(#)kern_sig.c 8.4 (Berkeley) 09/23/93 823374Smckusick */ 97421Sroot 1047540Skarels #define SIGPROP /* include signal properties table */ 1156517Sbostic #include <sys/param.h> 1256517Sbostic #include <sys/signalvar.h> 1356517Sbostic #include <sys/resourcevar.h> 1456517Sbostic #include <sys/namei.h> 1556517Sbostic #include <sys/vnode.h> 1656517Sbostic #include <sys/proc.h> 1756517Sbostic #include <sys/systm.h> 1856517Sbostic #include <sys/timeb.h> 1956517Sbostic #include <sys/times.h> 2056517Sbostic #include <sys/buf.h> 2156517Sbostic #include <sys/acct.h> 2256517Sbostic #include <sys/file.h> 2356517Sbostic #include <sys/kernel.h> 2456517Sbostic #include <sys/wait.h> 2556517Sbostic #include <sys/ktrace.h> 2657533Smckusick #include <sys/syslog.h> 2764406Sbostic #include <sys/stat.h> 287421Sroot 2956517Sbostic #include <machine/cpu.h> 3049102Skarels 3156517Sbostic #include <vm/vm.h> 3256517Sbostic #include <sys/user.h> /* for coredump */ 3337581Smckusick 3417013Smckusick /* 3564406Sbostic * Can process p, with pcred pc, send the signal signum to process q? 3617013Smckusick */ 3764406Sbostic #define CANSIGNAL(p, pc, q, signum) \ 3847540Skarels ((pc)->pc_ucred->cr_uid == 0 || \ 3947540Skarels (pc)->p_ruid == (q)->p_cred->p_ruid || \ 4047540Skarels (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \ 4147540Skarels (pc)->p_ruid == (q)->p_ucred->cr_uid || \ 4247540Skarels (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \ 4364406Sbostic ((signum) == SIGCONT && (q)->p_session == (p)->p_session)) 4439513Skarels 4554926Storek struct sigaction_args { 4664406Sbostic int signum; 4754926Storek struct sigaction *nsa; 4854926Storek struct sigaction *osa; 4954926Storek }; 5042920Skarels /* ARGSUSED */ 5142920Skarels sigaction(p, uap, retval) 5242920Skarels struct proc *p; 5354926Storek register struct sigaction_args *uap; 5442920Skarels int *retval; 5542920Skarels { 5639513Skarels struct sigaction vec; 5739513Skarels register struct sigaction *sa; 5847540Skarels register struct sigacts *ps = p->p_sigacts; 5964406Sbostic register int signum; 6039513Skarels int bit, error; 617421Sroot 6264406Sbostic signum = uap->signum; 6364406Sbostic if (signum <= 0 || signum >= NSIG || 6464406Sbostic signum == SIGKILL || signum == SIGSTOP) 6544405Skarels return (EINVAL); 6639513Skarels sa = &vec; 6739513Skarels if (uap->osa) { 6864406Sbostic sa->sa_handler = ps->ps_sigact[signum]; 6964406Sbostic sa->sa_mask = ps->ps_catchmask[signum]; 7064406Sbostic bit = sigmask(signum); 7139513Skarels sa->sa_flags = 0; 7247540Skarels if ((ps->ps_sigonstack & bit) != 0) 7339513Skarels sa->sa_flags |= SA_ONSTACK; 7447540Skarels if ((ps->ps_sigintr & bit) == 0) 7539513Skarels sa->sa_flags |= SA_RESTART; 76*64594Sbostic if (p->p_flag & P_NOCLDSTOP) 7739513Skarels sa->sa_flags |= SA_NOCLDSTOP; 7839513Skarels if (error = copyout((caddr_t)sa, (caddr_t)uap->osa, 7939513Skarels sizeof (vec))) 8044405Skarels return (error); 8112951Ssam } 8239513Skarels if (uap->nsa) { 8339513Skarels if (error = copyin((caddr_t)uap->nsa, (caddr_t)sa, 8439513Skarels sizeof (vec))) 8544405Skarels return (error); 8664406Sbostic setsigvec(p, signum, sa); 8712951Ssam } 8844405Skarels return (0); 897421Sroot } 907421Sroot 9164406Sbostic setsigvec(p, signum, sa) 9242920Skarels register struct proc *p; 9364406Sbostic int signum; 9439513Skarels register struct sigaction *sa; 9512882Ssam { 9647540Skarels register struct sigacts *ps = p->p_sigacts; 9712951Ssam register int bit; 9812882Ssam 9964406Sbostic bit = sigmask(signum); 10012882Ssam /* 10112882Ssam * Change setting atomically. 10212882Ssam */ 10317153Sbloom (void) splhigh(); 10464406Sbostic ps->ps_sigact[signum] = sa->sa_handler; 10564406Sbostic ps->ps_catchmask[signum] = sa->sa_mask &~ sigcantmask; 10639513Skarels if ((sa->sa_flags & SA_RESTART) == 0) 10747540Skarels ps->ps_sigintr |= bit; 10818308Smckusick else 10947540Skarels ps->ps_sigintr &= ~bit; 11039513Skarels if (sa->sa_flags & SA_ONSTACK) 11147540Skarels ps->ps_sigonstack |= bit; 11212951Ssam else 11347540Skarels ps->ps_sigonstack &= ~bit; 11452400Storek #ifdef COMPAT_SUNOS 11552400Storek if (sa->sa_flags & SA_USERTRAMP) 11652400Storek ps->ps_usertramp |= bit; 11752400Storek else 11852400Storek ps->ps_usertramp &= ~bit; 11952400Storek #endif 12064406Sbostic if (signum == SIGCHLD) { 12139513Skarels if (sa->sa_flags & SA_NOCLDSTOP) 122*64594Sbostic p->p_flag |= P_NOCLDSTOP; 12339513Skarels else 124*64594Sbostic p->p_flag &= ~P_NOCLDSTOP; 12539513Skarels } 12639513Skarels /* 12739513Skarels * Set bit in p_sigignore for signals that are set to SIG_IGN, 12839513Skarels * and for signals set to SIG_DFL where the default is to ignore. 12939513Skarels * However, don't put SIGCONT in p_sigignore, 13039513Skarels * as we have to restart the process. 13139513Skarels */ 13239513Skarels if (sa->sa_handler == SIG_IGN || 13364406Sbostic (sigprop[signum] & SA_IGNORE && sa->sa_handler == SIG_DFL)) { 134*64594Sbostic p->p_siglist &= ~bit; /* never to be seen again */ 13564406Sbostic if (signum != SIGCONT) 13639513Skarels p->p_sigignore |= bit; /* easier in psignal */ 13712951Ssam p->p_sigcatch &= ~bit; 13812882Ssam } else { 13912951Ssam p->p_sigignore &= ~bit; 14039513Skarels if (sa->sa_handler == SIG_DFL) 14112951Ssam p->p_sigcatch &= ~bit; 14212882Ssam else 14312951Ssam p->p_sigcatch |= bit; 14412882Ssam } 14512882Ssam (void) spl0(); 14612882Ssam } 14712882Ssam 14839513Skarels /* 14939513Skarels * Initialize signal state for process 0; 15039513Skarels * set to ignore signals that are ignored by default. 15139513Skarels */ 15247540Skarels void 15339513Skarels siginit(p) 15439513Skarels struct proc *p; 1557421Sroot { 15647540Skarels register int i; 15739513Skarels 15847540Skarels for (i = 0; i < NSIG; i++) 15947540Skarels if (sigprop[i] & SA_IGNORE && i != SIGCONT) 16047540Skarels p->p_sigignore |= sigmask(i); 16139513Skarels } 16239513Skarels 16339513Skarels /* 16439513Skarels * Reset signals for an exec of the specified process. 16539513Skarels */ 16647540Skarels void 16739513Skarels execsigs(p) 16839513Skarels register struct proc *p; 16939513Skarels { 17047540Skarels register struct sigacts *ps = p->p_sigacts; 17139513Skarels register int nc, mask; 17239513Skarels 17339513Skarels /* 17439513Skarels * Reset caught signals. Held signals remain held 17539513Skarels * through p_sigmask (unless they were caught, 17639513Skarels * and are now ignored by default). 17739513Skarels */ 17839513Skarels while (p->p_sigcatch) { 17939513Skarels nc = ffs((long)p->p_sigcatch); 18039513Skarels mask = sigmask(nc); 18139513Skarels p->p_sigcatch &= ~mask; 18247540Skarels if (sigprop[nc] & SA_IGNORE) { 18339513Skarels if (nc != SIGCONT) 18439513Skarels p->p_sigignore |= mask; 185*64594Sbostic p->p_siglist &= ~mask; 18639513Skarels } 18747540Skarels ps->ps_sigact[nc] = SIG_DFL; 18839513Skarels } 18939513Skarels /* 19039513Skarels * Reset stack state to the user stack. 19139513Skarels * Clear set of signals caught on the signal stack. 19239513Skarels */ 19353218Smckusick ps->ps_sigstk.ss_flags = SA_DISABLE; 19453218Smckusick ps->ps_sigstk.ss_size = 0; 19553218Smckusick ps->ps_sigstk.ss_base = 0; 19653218Smckusick ps->ps_flags = 0; 19739513Skarels } 19839513Skarels 19939513Skarels /* 20039513Skarels * Manipulate signal mask. 20139513Skarels * Note that we receive new mask, not pointer, 20239513Skarels * and return old mask as return value; 20339513Skarels * the library stub does the rest. 20439513Skarels */ 20554926Storek struct sigprocmask_args { 20654926Storek int how; 20754926Storek sigset_t mask; 20854926Storek }; 20942920Skarels sigprocmask(p, uap, retval) 21042920Skarels register struct proc *p; 21154926Storek struct sigprocmask_args *uap; 21242920Skarels int *retval; 21342920Skarels { 21439513Skarels int error = 0; 21539513Skarels 21642920Skarels *retval = p->p_sigmask; 21739513Skarels (void) splhigh(); 21839513Skarels 21939513Skarels switch (uap->how) { 22039513Skarels case SIG_BLOCK: 22139513Skarels p->p_sigmask |= uap->mask &~ sigcantmask; 22239513Skarels break; 22339513Skarels 22439513Skarels case SIG_UNBLOCK: 22539513Skarels p->p_sigmask &= ~uap->mask; 22639513Skarels break; 22739513Skarels 22839513Skarels case SIG_SETMASK: 22939513Skarels p->p_sigmask = uap->mask &~ sigcantmask; 23039513Skarels break; 23139513Skarels 23239513Skarels default: 23339513Skarels error = EINVAL; 23439513Skarels break; 23539513Skarels } 23639513Skarels (void) spl0(); 23744405Skarels return (error); 23839513Skarels } 23939513Skarels 24054926Storek struct sigpending_args { 24154926Storek int dummy; 24254926Storek }; 24342920Skarels /* ARGSUSED */ 24442920Skarels sigpending(p, uap, retval) 24542920Skarels struct proc *p; 24654926Storek struct sigpending_args *uap; 24742920Skarels int *retval; 24839513Skarels { 24939513Skarels 250*64594Sbostic *retval = p->p_siglist; 25144405Skarels return (0); 25239513Skarels } 25339513Skarels 25452400Storek #if defined(COMPAT_43) || defined(COMPAT_SUNOS) 25539513Skarels /* 25639513Skarels * Generalized interface signal handler, 4.3-compatible. 25739513Skarels */ 25854926Storek struct osigvec_args { 25964406Sbostic int signum; 26054926Storek struct sigvec *nsv; 26154926Storek struct sigvec *osv; 26254926Storek }; 26342920Skarels /* ARGSUSED */ 26442920Skarels osigvec(p, uap, retval) 26542920Skarels struct proc *p; 26654926Storek register struct osigvec_args *uap; 26742920Skarels int *retval; 26842920Skarels { 26939513Skarels struct sigvec vec; 27047540Skarels register struct sigacts *ps = p->p_sigacts; 27139513Skarels register struct sigvec *sv; 27264406Sbostic register int signum; 27339513Skarels int bit, error; 27439513Skarels 27564406Sbostic signum = uap->signum; 27664406Sbostic if (signum <= 0 || signum >= NSIG || 27764406Sbostic signum == SIGKILL || signum == SIGSTOP) 27844405Skarels return (EINVAL); 27939513Skarels sv = &vec; 28039513Skarels if (uap->osv) { 28164406Sbostic *(sig_t *)&sv->sv_handler = ps->ps_sigact[signum]; 28264406Sbostic sv->sv_mask = ps->ps_catchmask[signum]; 28364406Sbostic bit = sigmask(signum); 28439513Skarels sv->sv_flags = 0; 28547540Skarels if ((ps->ps_sigonstack & bit) != 0) 28639513Skarels sv->sv_flags |= SV_ONSTACK; 28747540Skarels if ((ps->ps_sigintr & bit) != 0) 28839513Skarels sv->sv_flags |= SV_INTERRUPT; 28952400Storek #ifndef COMPAT_SUNOS 290*64594Sbostic if (p->p_flag & P_NOCLDSTOP) 29139513Skarels sv->sv_flags |= SA_NOCLDSTOP; 29252400Storek #endif 29339513Skarels if (error = copyout((caddr_t)sv, (caddr_t)uap->osv, 29439513Skarels sizeof (vec))) 29544405Skarels return (error); 29639513Skarels } 29739513Skarels if (uap->nsv) { 29839513Skarels if (error = copyin((caddr_t)uap->nsv, (caddr_t)sv, 29939513Skarels sizeof (vec))) 30044405Skarels return (error); 30152400Storek #ifdef COMPAT_SUNOS 30252400Storek /* 30354344Smckusick * SunOS uses this bit (4, aka SA_DISABLE) as SV_RESETHAND, 30454344Smckusick * `reset to SIG_DFL on delivery'. We have no such option 30554344Smckusick * now or ever! 30652400Storek */ 30754344Smckusick if (sv->sv_flags & SA_DISABLE) 30852400Storek return (EINVAL); 30952400Storek sv->sv_flags |= SA_USERTRAMP; 31052400Storek #endif 31139513Skarels sv->sv_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */ 31264406Sbostic setsigvec(p, signum, (struct sigaction *)sv); 31339513Skarels } 31444405Skarels return (0); 31539513Skarels } 31639513Skarels 31754926Storek struct osigblock_args { 31854926Storek int mask; 31954926Storek }; 32042920Skarels osigblock(p, uap, retval) 32142920Skarels register struct proc *p; 32254926Storek struct osigblock_args *uap; 32342920Skarels int *retval; 32439513Skarels { 3257499Sroot 32617153Sbloom (void) splhigh(); 32742920Skarels *retval = p->p_sigmask; 32839513Skarels p->p_sigmask |= uap->mask &~ sigcantmask; 32912882Ssam (void) spl0(); 33044405Skarels return (0); 3317499Sroot } 3327499Sroot 33354926Storek struct osigsetmask_args { 33454926Storek int mask; 33554926Storek }; 33642920Skarels osigsetmask(p, uap, retval) 33742920Skarels struct proc *p; 33854926Storek struct osigsetmask_args *uap; 33942920Skarels int *retval; 3407499Sroot { 3417499Sroot 34217153Sbloom (void) splhigh(); 34342920Skarels *retval = p->p_sigmask; 34439513Skarels p->p_sigmask = uap->mask &~ sigcantmask; 34512882Ssam (void) spl0(); 34644405Skarels return (0); 3477499Sroot } 34854344Smckusick #endif /* COMPAT_43 || COMPAT_SUNOS */ 3497499Sroot 35039513Skarels /* 35139513Skarels * Suspend process until signal, providing mask to be set 35239513Skarels * in the meantime. Note nonstandard calling convention: 35339513Skarels * libc stub passes mask, not pointer, to save a copyin. 35439513Skarels */ 35554926Storek struct sigsuspend_args { 35654926Storek sigset_t mask; 35754926Storek }; 35842920Skarels /* ARGSUSED */ 35942920Skarels sigsuspend(p, uap, retval) 36042920Skarels register struct proc *p; 36154926Storek struct sigsuspend_args *uap; 36242920Skarels int *retval; 3637499Sroot { 36447540Skarels register struct sigacts *ps = p->p_sigacts; 3657499Sroot 36612882Ssam /* 36712882Ssam * When returning from sigpause, we want 36812882Ssam * the old mask to be restored after the 36912882Ssam * signal handler has finished. Thus, we 37052115Skarels * save it here and mark the sigacts structure 37152115Skarels * to indicate this. 37212882Ssam */ 37347540Skarels ps->ps_oldmask = p->p_sigmask; 37453218Smckusick ps->ps_flags |= SAS_OLDMASK; 37539513Skarels p->p_sigmask = uap->mask &~ sigcantmask; 37658230Smckusick while (tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0) == 0) 37758230Smckusick /* void */; 37840807Smarc /* always return EINTR rather than ERESTART... */ 37944405Skarels return (EINTR); 3807499Sroot } 3817499Sroot 38254344Smckusick #if defined(COMPAT_43) || defined(COMPAT_SUNOS) 38354926Storek struct osigstack_args { 38454926Storek struct sigstack *nss; 38554926Storek struct sigstack *oss; 38654926Storek }; 38742920Skarels /* ARGSUSED */ 38853218Smckusick osigstack(p, uap, retval) 38942920Skarels struct proc *p; 39054926Storek register struct osigstack_args *uap; 39142920Skarels int *retval; 39242920Skarels { 39312951Ssam struct sigstack ss; 39453218Smckusick struct sigacts *psp; 39539513Skarels int error = 0; 3967499Sroot 39753218Smckusick psp = p->p_sigacts; 39853218Smckusick ss.ss_sp = psp->ps_sigstk.ss_base; 39953218Smckusick ss.ss_onstack = psp->ps_sigstk.ss_flags & SA_ONSTACK; 40053218Smckusick if (uap->oss && (error = copyout((caddr_t)&ss, (caddr_t)uap->oss, 40153218Smckusick sizeof (struct sigstack)))) 40244405Skarels return (error); 40339513Skarels if (uap->nss && (error = copyin((caddr_t)uap->nss, (caddr_t)&ss, 40453218Smckusick sizeof (ss))) == 0) { 40553218Smckusick psp->ps_sigstk.ss_base = ss.ss_sp; 40653218Smckusick psp->ps_sigstk.ss_size = 0; 40753218Smckusick psp->ps_sigstk.ss_flags |= ss.ss_onstack & SA_ONSTACK; 40853218Smckusick psp->ps_flags |= SAS_ALTSTACK; 40953218Smckusick } 41044405Skarels return (error); 4117499Sroot } 41254344Smckusick #endif /* COMPAT_43 || COMPAT_SUNOS */ 4137499Sroot 41454926Storek struct sigaltstack_args { 41554926Storek struct sigaltstack *nss; 41654926Storek struct sigaltstack *oss; 41754926Storek }; 41842920Skarels /* ARGSUSED */ 41953218Smckusick sigaltstack(p, uap, retval) 42053218Smckusick struct proc *p; 42154926Storek register struct sigaltstack_args *uap; 42253218Smckusick int *retval; 42353218Smckusick { 42453218Smckusick struct sigacts *psp; 42553218Smckusick struct sigaltstack ss; 42653218Smckusick int error; 42753218Smckusick 42853218Smckusick psp = p->p_sigacts; 42953218Smckusick if ((psp->ps_flags & SAS_ALTSTACK) == 0) 43053218Smckusick psp->ps_sigstk.ss_flags |= SA_DISABLE; 43153218Smckusick if (uap->oss && (error = copyout((caddr_t)&psp->ps_sigstk, 43253218Smckusick (caddr_t)uap->oss, sizeof (struct sigaltstack)))) 43353218Smckusick return (error); 43454464Smckusick if (uap->nss == 0) 43554464Smckusick return (0); 43654464Smckusick if (error = copyin((caddr_t)uap->nss, (caddr_t)&ss, sizeof (ss))) 43753218Smckusick return (error); 43853218Smckusick if (ss.ss_flags & SA_DISABLE) { 43953218Smckusick if (psp->ps_sigstk.ss_flags & SA_ONSTACK) 44053218Smckusick return (EINVAL); 44153218Smckusick psp->ps_flags &= ~SAS_ALTSTACK; 44253218Smckusick psp->ps_sigstk.ss_flags = ss.ss_flags; 44353218Smckusick return (0); 44453218Smckusick } 44553218Smckusick if (ss.ss_size < MINSIGSTKSZ) 44653218Smckusick return (ENOMEM); 44753218Smckusick psp->ps_flags |= SAS_ALTSTACK; 44853218Smckusick psp->ps_sigstk= ss; 44953218Smckusick return (0); 45053218Smckusick } 45153218Smckusick 45254926Storek struct kill_args { 45354926Storek int pid; 45464406Sbostic int signum; 45554926Storek }; 45653218Smckusick /* ARGSUSED */ 45742920Skarels kill(cp, uap, retval) 45842920Skarels register struct proc *cp; 45954926Storek register struct kill_args *uap; 46042920Skarels int *retval; 46142920Skarels { 46218336Smckusick register struct proc *p; 46347540Skarels register struct pcred *pc = cp->p_cred; 4648032Sroot 46564406Sbostic if ((u_int)uap->signum >= NSIG) 46644405Skarels return (EINVAL); 46718336Smckusick if (uap->pid > 0) { 46818336Smckusick /* kill single process */ 46964406Sbostic if ((p = pfind(uap->pid)) == NULL) 47044405Skarels return (ESRCH); 47164406Sbostic if (!CANSIGNAL(cp, pc, p, uap->signum)) 47244405Skarels return (EPERM); 47364406Sbostic if (uap->signum) 47464406Sbostic psignal(p, uap->signum); 47544405Skarels return (0); 47618336Smckusick } 47718336Smckusick switch (uap->pid) { 47818336Smckusick case -1: /* broadcast signal */ 47964406Sbostic return (killpg1(cp, uap->signum, 0, 1)); 48018336Smckusick case 0: /* signal own process group */ 48164406Sbostic return (killpg1(cp, uap->signum, 0, 0)); 48218336Smckusick default: /* negative explicit process group */ 48364406Sbostic return (killpg1(cp, uap->signum, -uap->pid, 0)); 48418336Smckusick } 48539513Skarels /* NOTREACHED */ 4868032Sroot } 4878032Sroot 48852400Storek #if defined(COMPAT_43) || defined(COMPAT_SUNOS) 48954926Storek struct okillpg_args { 49054926Storek int pgid; 49164406Sbostic int signum; 49254926Storek }; 49342920Skarels /* ARGSUSED */ 49442920Skarels okillpg(p, uap, retval) 49542920Skarels struct proc *p; 49654926Storek register struct okillpg_args *uap; 49742920Skarels int *retval; 49842920Skarels { 4998032Sroot 50064406Sbostic if ((u_int)uap->signum >= NSIG) 50144405Skarels return (EINVAL); 50264406Sbostic return (killpg1(p, uap->signum, uap->pgid, 0)); 5038032Sroot } 50454344Smckusick #endif /* COMPAT_43 || COMPAT_SUNOS */ 5058032Sroot 50642920Skarels /* 50742920Skarels * Common code for kill process group/broadcast kill. 50842920Skarels * cp is calling process. 50942920Skarels */ 51064406Sbostic killpg1(cp, signum, pgid, all) 51142920Skarels register struct proc *cp; 51264406Sbostic int signum, pgid, all; 5139989Ssam { 5149989Ssam register struct proc *p; 51547540Skarels register struct pcred *pc = cp->p_cred; 51637581Smckusick struct pgrp *pgrp; 51747540Skarels int nfound = 0; 51837581Smckusick 51937581Smckusick if (all) 52037581Smckusick /* 52137581Smckusick * broadcast 5227421Sroot */ 523*64594Sbostic for (p = (struct proc *)allproc; p != NULL; p = p->p_next) { 524*64594Sbostic if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || 52564406Sbostic p == cp || !CANSIGNAL(cp, pc, p, signum)) 52637581Smckusick continue; 52747540Skarels nfound++; 52864406Sbostic if (signum) 52964406Sbostic psignal(p, signum); 53037581Smckusick } 53137581Smckusick else { 53237581Smckusick if (pgid == 0) 53337581Smckusick /* 53437581Smckusick * zero pgid means send to my process group. 53537581Smckusick */ 53647540Skarels pgrp = cp->p_pgrp; 53737581Smckusick else { 53837581Smckusick pgrp = pgfind(pgid); 53937581Smckusick if (pgrp == NULL) 54039513Skarels return (ESRCH); 54137581Smckusick } 54237581Smckusick for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt) { 543*64594Sbostic if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || 54464406Sbostic p->p_stat == SZOMB || 54564406Sbostic !CANSIGNAL(cp, pc, p, signum)) 54637581Smckusick continue; 54747540Skarels nfound++; 54864406Sbostic if (signum) 54964406Sbostic psignal(p, signum); 55018336Smckusick } 5517421Sroot } 55247540Skarels return (nfound ? 0 : ESRCH); 5537421Sroot } 5547421Sroot 55542920Skarels /* 55664406Sbostic * Send a signal to a process group. 5577421Sroot */ 55847540Skarels void 55964406Sbostic gsignal(pgid, signum) 56064406Sbostic int pgid, signum; 5617421Sroot { 56239513Skarels struct pgrp *pgrp; 5637421Sroot 56439513Skarels if (pgid && (pgrp = pgfind(pgid))) 56564406Sbostic pgsignal(pgrp, signum, 0); 5667421Sroot } 56742920Skarels 56840807Smarc /* 56964406Sbostic * Send a signal to a process group. If checktty is 1, 57064406Sbostic * limit to members which have a controlling terminal. 57140807Smarc */ 57247540Skarels void 57364406Sbostic pgsignal(pgrp, signum, checkctty) 57439513Skarels struct pgrp *pgrp; 57564406Sbostic int signum, checkctty; 57637581Smckusick { 57737581Smckusick register struct proc *p; 57837581Smckusick 57940807Smarc if (pgrp) 58040807Smarc for (p = pgrp->pg_mem; p != NULL; p = p->p_pgrpnxt) 581*64594Sbostic if (checkctty == 0 || p->p_flag & P_CONTROLT) 58264406Sbostic psignal(p, signum); 58337581Smckusick } 58437581Smckusick 5857421Sroot /* 58639513Skarels * Send a signal caused by a trap to the current process. 58739513Skarels * If it will be caught immediately, deliver it with correct code. 58839513Skarels * Otherwise, post it normally. 58939513Skarels */ 59047540Skarels void 59164406Sbostic trapsignal(p, signum, code) 59247540Skarels struct proc *p; 59364406Sbostic register int signum; 59464406Sbostic u_int code; 59539513Skarels { 59647540Skarels register struct sigacts *ps = p->p_sigacts; 59739513Skarels int mask; 59839513Skarels 59964406Sbostic mask = sigmask(signum); 600*64594Sbostic if ((p->p_flag & P_TRACED) == 0 && (p->p_sigcatch & mask) != 0 && 60139513Skarels (p->p_sigmask & mask) == 0) { 60247540Skarels p->p_stats->p_ru.ru_nsignals++; 60340807Smarc #ifdef KTRACE 60440807Smarc if (KTRPOINT(p, KTR_PSIG)) 60564406Sbostic ktrpsig(p->p_tracep, signum, ps->ps_sigact[signum], 60640807Smarc p->p_sigmask, code); 60740807Smarc #endif 60864406Sbostic sendsig(ps->ps_sigact[signum], signum, p->p_sigmask, code); 60964406Sbostic p->p_sigmask |= ps->ps_catchmask[signum] | mask; 61039513Skarels } else { 61147540Skarels ps->ps_code = code; /* XXX for core dump/debugger */ 61264406Sbostic psignal(p, signum); 61339513Skarels } 61439513Skarels } 61539513Skarels 61639513Skarels /* 61764406Sbostic * Send the signal to the process. If the signal has an action, the action 61864406Sbostic * is usually performed by the target process rather than the caller; we add 61947540Skarels * the signal to the set of pending signals for the process. 62064406Sbostic * 62140807Smarc * Exceptions: 62264406Sbostic * o When a stop signal is sent to a sleeping process that takes the 62364406Sbostic * default action, the process is stopped without awakening it. 62440807Smarc * o SIGCONT restarts stopped processes (or puts them back to sleep) 62540807Smarc * regardless of the signal action (eg, blocked or ignored). 62664406Sbostic * 62740807Smarc * Other ignored signals are discarded immediately. 6287421Sroot */ 62947540Skarels void 63064406Sbostic psignal(p, signum) 6317421Sroot register struct proc *p; 63264406Sbostic register int signum; 6337421Sroot { 63447540Skarels register int s, prop; 63539513Skarels register sig_t action; 63617153Sbloom int mask; 6377421Sroot 63864406Sbostic if ((u_int)signum >= NSIG || signum == 0) 63964406Sbostic panic("psignal signal number"); 64064406Sbostic mask = sigmask(signum); 64164406Sbostic prop = sigprop[signum]; 6427421Sroot 6437421Sroot /* 6447421Sroot * If proc is traced, always give parent a chance. 6457421Sroot */ 646*64594Sbostic if (p->p_flag & P_TRACED) 6477421Sroot action = SIG_DFL; 6487421Sroot else { 6497421Sroot /* 65012882Ssam * If the signal is being ignored, 65112882Ssam * then we forget about it immediately. 65239513Skarels * (Note: we don't set SIGCONT in p_sigignore, 65339513Skarels * and if it is set to SIG_IGN, 65439513Skarels * action will be SIG_DFL here.) 6557421Sroot */ 65617153Sbloom if (p->p_sigignore & mask) 6577421Sroot return; 65817153Sbloom if (p->p_sigmask & mask) 65912882Ssam action = SIG_HOLD; 66017153Sbloom else if (p->p_sigcatch & mask) 66112882Ssam action = SIG_CATCH; 66242437Skarels else 66312882Ssam action = SIG_DFL; 6647421Sroot } 6657421Sroot 66658371Smckusick if (p->p_nice > NZERO && action == SIG_DFL && (prop & SA_KILL) && 667*64594Sbostic (p->p_flag & P_TRACED) == 0) 66847540Skarels p->p_nice = NZERO; 6697421Sroot 67047540Skarels if (prop & SA_CONT) 671*64594Sbostic p->p_siglist &= ~stopsigmask; 67239513Skarels 67347540Skarels if (prop & SA_STOP) { 67445672Skarels /* 67545672Skarels * If sending a tty stop signal to a member of an orphaned 67645672Skarels * process group, discard the signal here if the action 67745672Skarels * is default; don't stop the process below if sleeping, 67845672Skarels * and don't clear any pending SIGCONT. 67945672Skarels */ 68047540Skarels if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0 && 68147540Skarels action == SIG_DFL) 68245741Smckusick return; 683*64594Sbostic p->p_siglist &= ~contsigmask; 6847421Sroot } 685*64594Sbostic p->p_siglist |= mask; 68639513Skarels 6877421Sroot /* 68839513Skarels * Defer further processing for signals which are held, 68939513Skarels * except that stopped processes must be continued by SIGCONT. 6907421Sroot */ 69147540Skarels if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP)) 6927421Sroot return; 69317153Sbloom s = splhigh(); 6947421Sroot switch (p->p_stat) { 6957421Sroot 6967421Sroot case SSLEEP: 6977421Sroot /* 69840807Smarc * If process is sleeping uninterruptibly 6997421Sroot * we can't interrupt the sleep... the signal will 7007421Sroot * be noticed when the process returns through 7017421Sroot * trap() or syscall(). 7027421Sroot */ 703*64594Sbostic if ((p->p_flag & P_SINTR) == 0) 7047421Sroot goto out; 7057421Sroot /* 7067421Sroot * Process is sleeping and traced... make it runnable 707*64594Sbostic * so it can discover the signal in issignal() and stop 7087421Sroot * for the parent. 7097421Sroot */ 710*64594Sbostic if (p->p_flag & P_TRACED) 7117421Sroot goto run; 71239513Skarels /* 71358371Smckusick * If SIGCONT is default (or ignored) and process is 71458371Smckusick * asleep, we are finished; the process should not 71558371Smckusick * be awakened. 71658371Smckusick */ 71758371Smckusick if ((prop & SA_CONT) && action == SIG_DFL) { 718*64594Sbostic p->p_siglist &= ~mask; 71958371Smckusick goto out; 72058371Smckusick } 72158371Smckusick /* 72239513Skarels * When a sleeping process receives a stop 72339513Skarels * signal, process immediately if possible. 72439513Skarels * All other (caught or default) signals 72539513Skarels * cause the process to run. 72639513Skarels */ 72747540Skarels if (prop & SA_STOP) { 7287421Sroot if (action != SIG_DFL) 72939513Skarels goto runfast; 7307421Sroot /* 73147540Skarels * If a child holding parent blocked, 73247540Skarels * stopping could cause deadlock. 7337421Sroot */ 734*64594Sbostic if (p->p_flag & P_PPWAIT) 7357421Sroot goto out; 736*64594Sbostic p->p_siglist &= ~mask; 73764406Sbostic p->p_xstat = signum; 738*64594Sbostic if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0) 73939513Skarels psignal(p->p_pptr, SIGCHLD); 7407421Sroot stop(p); 7417421Sroot goto out; 74239513Skarels } else 74339513Skarels goto runfast; 7447421Sroot /*NOTREACHED*/ 7457421Sroot 7467421Sroot case SSTOP: 7477421Sroot /* 7487421Sroot * If traced process is already stopped, 7497421Sroot * then no further action is necessary. 7507421Sroot */ 751*64594Sbostic if (p->p_flag & P_TRACED) 7527421Sroot goto out; 7537421Sroot 75447540Skarels /* 75547540Skarels * Kill signal always sets processes running. 75647540Skarels */ 75764406Sbostic if (signum == SIGKILL) 75839513Skarels goto runfast; 7597421Sroot 76047540Skarels if (prop & SA_CONT) { 7617421Sroot /* 762*64594Sbostic * If SIGCONT is default (or ignored), we continue the 763*64594Sbostic * process but don't leave the signal in p_siglist, as 764*64594Sbostic * it has no further action. If SIGCONT is held, we 765*64594Sbostic * continue the process and leave the signal in 766*64594Sbostic * p_siglist. If the process catches SIGCONT, let it 767*64594Sbostic * handle the signal itself. If it isn't waiting on 7687421Sroot * an event, then it goes back to run state. 7697421Sroot * Otherwise, process goes back to sleep state. 7707421Sroot */ 77139513Skarels if (action == SIG_DFL) 772*64594Sbostic p->p_siglist &= ~mask; 77339513Skarels if (action == SIG_CATCH) 77439513Skarels goto runfast; 77539513Skarels if (p->p_wchan == 0) 7767421Sroot goto run; 7777421Sroot p->p_stat = SSLEEP; 7787421Sroot goto out; 77947540Skarels } 7807421Sroot 78147540Skarels if (prop & SA_STOP) { 7827421Sroot /* 7837421Sroot * Already stopped, don't need to stop again. 7847421Sroot * (If we did the shell could get confused.) 7857421Sroot */ 786*64594Sbostic p->p_siglist &= ~mask; /* take it away */ 7877421Sroot goto out; 7887421Sroot } 7897421Sroot 79047540Skarels /* 79164531Sbostic * If process is sleeping interruptibly, then simulate a 79264531Sbostic * wakeup so that when it is continued, it will be made 79364531Sbostic * runnable and can look at the signal. But don't make 79464531Sbostic * the process runnable, leave it stopped. 79547540Skarels */ 796*64594Sbostic if (p->p_wchan && p->p_flag & P_SINTR) 79747540Skarels unsleep(p); 79847540Skarels goto out; 79947540Skarels 8007421Sroot default: 8017421Sroot /* 8027421Sroot * SRUN, SIDL, SZOMB do nothing with the signal, 8037421Sroot * other than kicking ourselves if we are running. 8047421Sroot * It will either never be noticed, or noticed very soon. 8057421Sroot */ 80647650Skarels if (p == curproc) 80749102Skarels signotify(p); 8087421Sroot goto out; 8097421Sroot } 8107421Sroot /*NOTREACHED*/ 81139513Skarels 81239513Skarels runfast: 8137421Sroot /* 8147421Sroot * Raise priority to at least PUSER. 8157421Sroot */ 816*64594Sbostic if (p->p_priority > PUSER) 817*64594Sbostic p->p_priority = PUSER; 81839513Skarels run: 81964531Sbostic setrunnable(p); 8207421Sroot out: 8217421Sroot splx(s); 8227421Sroot } 8237421Sroot 8247421Sroot /* 82564406Sbostic * If the current process has received a signal (should be caught or cause 82664406Sbostic * termination, should interrupt current syscall), return the signal number. 82764406Sbostic * Stop signals with default action are processed immediately, then cleared; 82864406Sbostic * they aren't returned. This is checked after each entry to the system for 829*64594Sbostic * a syscall or trap (though this can usually be done without calling issignal 83064406Sbostic * by checking the pending signal masks in the CURSIG macro.) The normal call 83164406Sbostic * sequence is 83247540Skarels * 83364406Sbostic * while (signum = CURSIG(curproc)) 834*64594Sbostic * postsig(signum); 8357421Sroot */ 836*64594Sbostic issignal(p) 83747540Skarels register struct proc *p; 8387421Sroot { 83964406Sbostic register int signum, mask, prop; 8407421Sroot 8417421Sroot for (;;) { 842*64594Sbostic mask = p->p_siglist & ~p->p_sigmask; 843*64594Sbostic if (p->p_flag & P_PPWAIT) 84439513Skarels mask &= ~stopsigmask; 84540807Smarc if (mask == 0) /* no signal to send */ 84640807Smarc return (0); 84764406Sbostic signum = ffs((long)mask); 84864406Sbostic mask = sigmask(signum); 84964406Sbostic prop = sigprop[signum]; 85040807Smarc /* 85140807Smarc * We should see pending but ignored signals 852*64594Sbostic * only if P_TRACED was on when they were posted. 85340807Smarc */ 854*64594Sbostic if (mask & p->p_sigignore && (p->p_flag & P_TRACED) == 0) { 855*64594Sbostic p->p_siglist &= ~mask; 85640807Smarc continue; 85740807Smarc } 858*64594Sbostic if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) { 8597421Sroot /* 8607421Sroot * If traced, always stop, and stay 8617421Sroot * stopped until released by the parent. 8627421Sroot */ 86364406Sbostic p->p_xstat = signum; 86418331Skarels psignal(p->p_pptr, SIGCHLD); 8657421Sroot do { 8667421Sroot stop(p); 867*64594Sbostic mi_switch(); 868*64594Sbostic } while (!trace_req(p) && p->p_flag & P_TRACED); 8697421Sroot 8707421Sroot /* 871*64594Sbostic * If the traced bit got turned off, go back up 872*64594Sbostic * to the top to rescan signals. This ensures 873*64594Sbostic * that p_sig* and ps_sigact are consistent. 8747421Sroot */ 875*64594Sbostic if ((p->p_flag & P_TRACED) == 0) 8767421Sroot continue; 8777421Sroot 8787421Sroot /* 8797421Sroot * If parent wants us to take the signal, 88043895Skarels * then it will leave it in p->p_xstat; 8817421Sroot * otherwise we just look for signals again. 8827421Sroot */ 883*64594Sbostic p->p_siglist &= ~mask; /* clear the old signal */ 88464406Sbostic signum = p->p_xstat; 88564406Sbostic if (signum == 0) 8867421Sroot continue; 88714782Ssam 88814782Ssam /* 889*64594Sbostic * Put the new signal into p_siglist. If the 890*64594Sbostic * signal is being masked, look for other signals. 89114782Ssam */ 89264406Sbostic mask = sigmask(signum); 893*64594Sbostic p->p_siglist |= mask; 89440807Smarc if (p->p_sigmask & mask) 89514782Ssam continue; 8967421Sroot } 89740807Smarc 89840807Smarc /* 89940807Smarc * Decide whether the signal should be returned. 90040807Smarc * Return the signal's number, or fall through 90140807Smarc * to clear it from the pending mask. 90240807Smarc */ 90364406Sbostic switch ((int)p->p_sigacts->ps_sigact[signum]) { 9047421Sroot 9057421Sroot case SIG_DFL: 9067421Sroot /* 9077421Sroot * Don't take default actions on system processes. 9087421Sroot */ 90951019Sralph if (p->p_pid <= 1) { 91051019Sralph #ifdef DIAGNOSTIC 91151019Sralph /* 91251019Sralph * Are you sure you want to ignore SIGSEGV 91351019Sralph * in init? XXX 91451019Sralph */ 91551019Sralph printf("Process (pid %d) got signal %d\n", 91664406Sbostic p->p_pid, signum); 91751019Sralph #endif 91840807Smarc break; /* == ignore */ 91951019Sralph } 92040807Smarc /* 92140807Smarc * If there is a pending stop signal to process 92240807Smarc * with default action, stop here, 92342437Skarels * then clear the signal. However, 92442437Skarels * if process is member of an orphaned 92542437Skarels * process group, ignore tty stop signals. 92640807Smarc */ 92747540Skarels if (prop & SA_STOP) { 928*64594Sbostic if (p->p_flag & P_TRACED || 92942437Skarels (p->p_pgrp->pg_jobc == 0 && 93047540Skarels prop & SA_TTYSTOP)) 93140807Smarc break; /* == ignore */ 93264406Sbostic p->p_xstat = signum; 9337421Sroot stop(p); 934*64594Sbostic if ((p->p_pptr->p_flag & P_NOCLDSTOP) == 0) 93539513Skarels psignal(p->p_pptr, SIGCHLD); 936*64594Sbostic mi_switch(); 93740807Smarc break; 93847540Skarels } else if (prop & SA_IGNORE) { 9397421Sroot /* 94039513Skarels * Except for SIGCONT, shouldn't get here. 94139513Skarels * Default action is to ignore; drop it. 9427421Sroot */ 94340807Smarc break; /* == ignore */ 94439513Skarels } else 94564406Sbostic return (signum); 9467421Sroot /*NOTREACHED*/ 9477421Sroot 9487421Sroot case SIG_IGN: 9497421Sroot /* 95039513Skarels * Masking above should prevent us ever trying 95139513Skarels * to take action on an ignored signal other 95239513Skarels * than SIGCONT, unless process is traced. 9537421Sroot */ 954*64594Sbostic if ((prop & SA_CONT) == 0 && 955*64594Sbostic (p->p_flag & P_TRACED) == 0) 956*64594Sbostic printf("issignal\n"); 95740807Smarc break; /* == ignore */ 9587421Sroot 9597421Sroot default: 9607421Sroot /* 9617421Sroot * This signal has an action, let 962*64594Sbostic * postsig() process it. 9637421Sroot */ 96464406Sbostic return (signum); 9657421Sroot } 966*64594Sbostic p->p_siglist &= ~mask; /* take the signal! */ 9677421Sroot } 96840807Smarc /* NOTREACHED */ 9697421Sroot } 9707421Sroot 9717421Sroot /* 97264406Sbostic * Put the argument process into the stopped state and notify the parent 97364406Sbostic * via wakeup. Signals are handled elsewhere. The process must not be 97464406Sbostic * on the run queue. 9757421Sroot */ 9767421Sroot stop(p) 9777421Sroot register struct proc *p; 9787421Sroot { 9797421Sroot 9807421Sroot p->p_stat = SSTOP; 981*64594Sbostic p->p_flag &= ~P_WAITED; 9827421Sroot wakeup((caddr_t)p->p_pptr); 9837421Sroot } 9847421Sroot 9857421Sroot /* 98647540Skarels * Take the action for the specified signal 98747540Skarels * from the current set of pending signals. 9887421Sroot */ 98947540Skarels void 990*64594Sbostic postsig(signum) 99164406Sbostic register int signum; 9927421Sroot { 99347540Skarels register struct proc *p = curproc; 99447540Skarels register struct sigacts *ps = p->p_sigacts; 99547540Skarels register sig_t action; 99639513Skarels int mask, returnmask; 9977421Sroot 99840807Smarc #ifdef DIAGNOSTIC 99964406Sbostic if (signum == 0) 1000*64594Sbostic panic("postsig"); 100140807Smarc #endif 100264406Sbostic mask = sigmask(signum); 1003*64594Sbostic p->p_siglist &= ~mask; 100464406Sbostic action = ps->ps_sigact[signum]; 100540807Smarc #ifdef KTRACE 100647540Skarels if (KTRPOINT(p, KTR_PSIG)) 100764406Sbostic ktrpsig(p->p_tracep, 100864406Sbostic signum, action, ps->ps_flags & SAS_OLDMASK ? 100947540Skarels ps->ps_oldmask : p->p_sigmask, 0); 101040807Smarc #endif 101147540Skarels if (action == SIG_DFL) { 101247540Skarels /* 101347540Skarels * Default action, where the default is to kill 101447540Skarels * the process. (Other cases were ignored above.) 101547540Skarels */ 101664406Sbostic sigexit(p, signum); 101747540Skarels /* NOTREACHED */ 101847540Skarels } else { 101947540Skarels /* 102047540Skarels * If we get here, the signal must be caught. 102147540Skarels */ 102239513Skarels #ifdef DIAGNOSTIC 102347540Skarels if (action == SIG_IGN || (p->p_sigmask & mask)) 1024*64594Sbostic panic("postsig action"); 102539513Skarels #endif 102647540Skarels /* 102747540Skarels * Set the new mask value and also defer further 102847540Skarels * occurences of this signal. 102947540Skarels * 103047540Skarels * Special case: user has done a sigpause. Here the 103147540Skarels * current mask is not of interest, but rather the 103247540Skarels * mask from before the sigpause is what we want 103347540Skarels * restored after the signal processing is completed. 103447540Skarels */ 103547540Skarels (void) splhigh(); 103653218Smckusick if (ps->ps_flags & SAS_OLDMASK) { 103747540Skarels returnmask = ps->ps_oldmask; 103853218Smckusick ps->ps_flags &= ~SAS_OLDMASK; 103947540Skarels } else 104047540Skarels returnmask = p->p_sigmask; 104164406Sbostic p->p_sigmask |= ps->ps_catchmask[signum] | mask; 104247540Skarels (void) spl0(); 104347540Skarels p->p_stats->p_ru.ru_nsignals++; 104464406Sbostic sendsig(action, signum, returnmask, 0); 104547540Skarels } 10467421Sroot } 10477421Sroot 10487421Sroot /* 104957533Smckusick * Kill the current process for stated reason. 105057533Smckusick */ 105157533Smckusick killproc(p, why) 105257533Smckusick struct proc *p; 105357533Smckusick char *why; 105457533Smckusick { 105557533Smckusick 105657533Smckusick log(LOG_ERR, "pid %d was killed: %s\n", p->p_pid, why); 105757533Smckusick uprintf("sorry, pid %d was killed: %s\n", p->p_pid, why); 105857533Smckusick psignal(p, SIGKILL); 105957533Smckusick } 106057533Smckusick 106157533Smckusick /* 106264406Sbostic * Force the current process to exit with the specified signal, dumping core 106364406Sbostic * if appropriate. We bypass the normal tests for masked and caught signals, 106464406Sbostic * allowing unrecoverable failures to terminate the process without changing 106564406Sbostic * signal state. Mark the accounting record with the signal termination. 106664406Sbostic * If dumping core, save the signal number for the debugger. Calls exit and 106764406Sbostic * does not return. 106847650Skarels */ 106964406Sbostic sigexit(p, signum) 107047650Skarels register struct proc *p; 107164406Sbostic int signum; 107247650Skarels { 107347650Skarels 107447650Skarels p->p_acflag |= AXSIG; 107564406Sbostic if (sigprop[signum] & SA_CORE) { 107664406Sbostic p->p_sigacts->ps_sig = signum; 107747650Skarels if (coredump(p) == 0) 107864406Sbostic signum |= WCOREFLAG; 107947650Skarels } 108064406Sbostic exit1(p, W_EXITCODE(0, signum)); 108147650Skarels /* NOTREACHED */ 108247650Skarels } 108347650Skarels 108447650Skarels /* 108564406Sbostic * Dump core, into a file named "core.progname". 108664406Sbostic * Do not drop core if the process was setuid/setgid. 10877421Sroot */ 108847540Skarels coredump(p) 108947540Skarels register struct proc *p; 10907421Sroot { 109137728Smckusick register struct vnode *vp; 109247540Skarels register struct pcred *pcred = p->p_cred; 109347540Skarels register struct ucred *cred = pcred->pc_ucred; 109447540Skarels register struct vmspace *vm = p->p_vmspace; 109537580Smckusick struct vattr vattr; 109650105Smckusick int error, error1; 109747540Skarels struct nameidata nd; 109864406Sbostic char name[MAXCOMLEN+6]; /* progname.core */ 10997421Sroot 110064406Sbostic if (pcred->p_svuid != pcred->p_ruid || pcred->p_svgid != pcred->p_rgid) 110137580Smckusick return (EFAULT); 110247540Skarels if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >= 110347540Skarels p->p_rlimit[RLIMIT_CORE].rlim_cur) 110437580Smckusick return (EFAULT); 110564406Sbostic sprintf(name, "%s.core", p->p_comm); 110652304Sheideman NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, name, p); 110764406Sbostic if (error = vn_open(&nd, 110864406Sbostic O_CREAT | FWRITE, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) 110937580Smckusick return (error); 111047540Skarels vp = nd.ni_vp; 111164406Sbostic 111264406Sbostic /* Don't dump to non-regular files or files with links. */ 111364406Sbostic if (vp->v_type != VREG || 111464406Sbostic VOP_GETATTR(vp, &vattr, cred, p) || vattr.va_nlink != 1) { 111550105Smckusick error = EFAULT; 111650105Smckusick goto out; 11177818Sroot } 111841362Smckusick VATTR_NULL(&vattr); 111937580Smckusick vattr.va_size = 0; 112052183Smckusick LEASE_CHECK(vp, p, cred, LEASE_WRITE); 112148020Smckusick VOP_SETATTR(vp, &vattr, cred, p); 112247540Skarels p->p_acflag |= ACORE; 112349102Skarels bcopy(p, &p->p_addr->u_kproc.kp_proc, sizeof(struct proc)); 112449102Skarels fill_eproc(p, &p->p_addr->u_kproc.kp_eproc); 112552925Smckusick error = cpu_coredump(p, vp, cred); 112637580Smckusick if (error == 0) 112747540Skarels error = vn_rdwr(UIO_WRITE, vp, vm->vm_daddr, 112847540Skarels (int)ctob(vm->vm_dsize), (off_t)ctob(UPAGES), UIO_USERSPACE, 112949102Skarels IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p); 113037580Smckusick if (error == 0) 113137580Smckusick error = vn_rdwr(UIO_WRITE, vp, 113249102Skarels (caddr_t) trunc_page(USRSTACK - ctob(vm->vm_ssize)), 113347540Skarels round_page(ctob(vm->vm_ssize)), 113447540Skarels (off_t)ctob(UPAGES) + ctob(vm->vm_dsize), UIO_USERSPACE, 113549102Skarels IO_NODELOCKED|IO_UNIT, cred, (int *) NULL, p); 113650105Smckusick out: 113750105Smckusick VOP_UNLOCK(vp); 113850105Smckusick error1 = vn_close(vp, FWRITE, cred, p); 113950244Skarels if (error == 0) 114050105Smckusick error = error1; 114137580Smckusick return (error); 11427421Sroot } 114339513Skarels 114439513Skarels /* 114539513Skarels * Nonexistent system call-- signal process (may want to handle it). 114639513Skarels * Flag error in case process won't see signal immediately (blocked or ignored). 114739513Skarels */ 114854926Storek struct nosys_args { 114954926Storek int dummy; 115054926Storek }; 115143364Smckusick /* ARGSUSED */ 115243364Smckusick nosys(p, args, retval) 115343364Smckusick struct proc *p; 115454926Storek struct nosys_args *args; 115543364Smckusick int *retval; 115639513Skarels { 115739513Skarels 115843364Smckusick psignal(p, SIGSYS); 115944405Skarels return (EINVAL); 116039513Skarels } 1161