diff options
34 files changed, 1263 insertions, 781 deletions
diff --git a/sys/coda/coda_psdev.c b/sys/coda/coda_psdev.c index 520702b..4cd559d 100644 --- a/sys/coda/coda_psdev.c +++ b/sys/coda/coda_psdev.c @@ -75,6 +75,10 @@ extern int coda_nc_initialized; /* Set if cache has been initialized */ #define CTL_C +#ifdef CTL_C +#include <sys/signalvar.h> +#endif + int coda_psdev_print_entry = 0; static int outstanding_upcalls = 0; @@ -485,7 +489,8 @@ coda_call(mntinfo, inSize, outSize, buffer) int error; #ifdef CTL_C struct proc *p = curproc; - unsigned int psig_omask = p->p_sigmask; + sigset_t psig_omask = p->p_sigmask; + sigset_t tempset; int i; #endif if (mntinfo == NULL) { @@ -541,36 +546,56 @@ coda_call(mntinfo, inSize, outSize, buffer) */ i = 0; do { - error = tsleep(&vmp->vm_sleep, (coda_call_sleep|coda_pcatch), "coda_call", hz*2); - if (error == 0) - break; - else if (error == EWOULDBLOCK) { + error = tsleep(&vmp->vm_sleep, + (coda_call_sleep|coda_pcatch), "coda_call", + hz*2); + if (error == 0) + break; + else if (error == EWOULDBLOCK) { #ifdef CODA_VERBOSE - printf("coda_call: tsleep TIMEOUT %d sec\n", 2+2*i); + printf("coda_call: tsleep TIMEOUT %d sec\n", 2+2*i); #endif - } else if (p->p_siglist == sigmask(SIGIO)) { - p->p_sigmask |= p->p_siglist; + } + else { + SIGEMPTYSET(tempset); + SIGADDSET(tempset, SIGIO); + if (SIGSETEQ(p->p_siglist, tempset)) { + SIGADDSET(p->p_sigmask, SIGIO); #ifdef CODA_VERBOSE - printf("coda_call: tsleep returns %d SIGIO, cnt %d\n", error, i); + printf("coda_call: tsleep returns %d SIGIO, cnt %d\n", + error, i); #endif - } else if (p->p_siglist == sigmask(SIGALRM)) { - p->p_sigmask |= p->p_siglist; + } else { + SIGDELSET(tempset, SIGIO); + SIGADDSET(tempset, SIGALRM); + if (SIGSETEQ(p->p_siglist, tempset)) { + SIGADDSET(p->p_sigmask, SIGALRM); #ifdef CODA_VERBOSE - printf("coda_call: tsleep returns %d SIGALRM, cnt %d\n", error, i); + printf("coda_call: tsleep returns %d SIGALRM, cnt %d\n", + error, i); #endif - } else { - printf("coda_call: tsleep returns %d, cnt %d\n", error, i); - printf("coda_call: siglist = %x, sigmask = %x, mask %x\n", - p->p_siglist, p->p_sigmask, - p->p_siglist & ~p->p_sigmask); - break; -#ifdef notyet - p->p_sigmask |= p->p_siglist; - printf("coda_call: new mask, siglist = %x, sigmask = %x, mask %x\n", - p->p_siglist, p->p_sigmask, - p->p_siglist & ~p->p_sigmask); + } + else { + printf("coda_call: tsleep returns %d, cnt %d\n", + error, i); + +#if notyet + tempset = p->p_siglist; + SIGSETNAND(tempset, p->p_sigmask); + printf("coda_call: siglist = %p, sigmask = %p, mask %p\n", + p->p_siglist, p->p_sigmask, + tempset); + break; + SIGSETOR(p->p_sigmask, p->p_siglist); + tempset = p->p_siglist; + SIGSETNAND(tempset, p->p_sigmask); + printf("coda_call: new mask, siglist = %p, sigmask = %p, mask %p\n", + p->p_siglist, p->p_sigmask, + tempset); #endif - } + } + } + } } while (error && i++ < 128 && VC_OPEN(vcp)); p->p_sigmask = psig_omask; #else diff --git a/sys/fs/coda/coda_psdev.c b/sys/fs/coda/coda_psdev.c index 520702b..4cd559d 100644 --- a/sys/fs/coda/coda_psdev.c +++ b/sys/fs/coda/coda_psdev.c @@ -75,6 +75,10 @@ extern int coda_nc_initialized; /* Set if cache has been initialized */ #define CTL_C +#ifdef CTL_C +#include <sys/signalvar.h> +#endif + int coda_psdev_print_entry = 0; static int outstanding_upcalls = 0; @@ -485,7 +489,8 @@ coda_call(mntinfo, inSize, outSize, buffer) int error; #ifdef CTL_C struct proc *p = curproc; - unsigned int psig_omask = p->p_sigmask; + sigset_t psig_omask = p->p_sigmask; + sigset_t tempset; int i; #endif if (mntinfo == NULL) { @@ -541,36 +546,56 @@ coda_call(mntinfo, inSize, outSize, buffer) */ i = 0; do { - error = tsleep(&vmp->vm_sleep, (coda_call_sleep|coda_pcatch), "coda_call", hz*2); - if (error == 0) - break; - else if (error == EWOULDBLOCK) { + error = tsleep(&vmp->vm_sleep, + (coda_call_sleep|coda_pcatch), "coda_call", + hz*2); + if (error == 0) + break; + else if (error == EWOULDBLOCK) { #ifdef CODA_VERBOSE - printf("coda_call: tsleep TIMEOUT %d sec\n", 2+2*i); + printf("coda_call: tsleep TIMEOUT %d sec\n", 2+2*i); #endif - } else if (p->p_siglist == sigmask(SIGIO)) { - p->p_sigmask |= p->p_siglist; + } + else { + SIGEMPTYSET(tempset); + SIGADDSET(tempset, SIGIO); + if (SIGSETEQ(p->p_siglist, tempset)) { + SIGADDSET(p->p_sigmask, SIGIO); #ifdef CODA_VERBOSE - printf("coda_call: tsleep returns %d SIGIO, cnt %d\n", error, i); + printf("coda_call: tsleep returns %d SIGIO, cnt %d\n", + error, i); #endif - } else if (p->p_siglist == sigmask(SIGALRM)) { - p->p_sigmask |= p->p_siglist; + } else { + SIGDELSET(tempset, SIGIO); + SIGADDSET(tempset, SIGALRM); + if (SIGSETEQ(p->p_siglist, tempset)) { + SIGADDSET(p->p_sigmask, SIGALRM); #ifdef CODA_VERBOSE - printf("coda_call: tsleep returns %d SIGALRM, cnt %d\n", error, i); + printf("coda_call: tsleep returns %d SIGALRM, cnt %d\n", + error, i); #endif - } else { - printf("coda_call: tsleep returns %d, cnt %d\n", error, i); - printf("coda_call: siglist = %x, sigmask = %x, mask %x\n", - p->p_siglist, p->p_sigmask, - p->p_siglist & ~p->p_sigmask); - break; -#ifdef notyet - p->p_sigmask |= p->p_siglist; - printf("coda_call: new mask, siglist = %x, sigmask = %x, mask %x\n", - p->p_siglist, p->p_sigmask, - p->p_siglist & ~p->p_sigmask); + } + else { + printf("coda_call: tsleep returns %d, cnt %d\n", + error, i); + +#if notyet + tempset = p->p_siglist; + SIGSETNAND(tempset, p->p_sigmask); + printf("coda_call: siglist = %p, sigmask = %p, mask %p\n", + p->p_siglist, p->p_sigmask, + tempset); + break; + SIGSETOR(p->p_sigmask, p->p_siglist); + tempset = p->p_siglist; + SIGSETNAND(tempset, p->p_sigmask); + printf("coda_call: new mask, siglist = %p, sigmask = %p, mask %p\n", + p->p_siglist, p->p_sigmask, + tempset); #endif - } + } + } + } } while (error && i++ < 128 && VC_OPEN(vcp)); p->p_sigmask = psig_omask; #else diff --git a/sys/fs/procfs/procfs_ctl.c b/sys/fs/procfs/procfs_ctl.c index 4f4d84b..9a74aa3 100644 --- a/sys/fs/procfs/procfs_ctl.c +++ b/sys/fs/procfs/procfs_ctl.c @@ -192,7 +192,7 @@ procfs_control(curp, p, op) p->p_flag &= ~P_TRACED; /* remove pending SIGTRAP, else the process will die */ - p->p_siglist &= ~sigmask (SIGTRAP); + SIGDELSET(p->p_siglist, SIGTRAP); /* give process back to original parent */ if (p->p_oppid != p->p_pptr->p_pid) { diff --git a/sys/kern/init_sysent.c b/sys/kern/init_sysent.c index 05f81f7..e135090 100644 --- a/sys/kern/init_sysent.c +++ b/sys/kern/init_sysent.c @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/kern/syscalls.master,v 1.64 1999/09/11 00:45:58 alfred Exp + * created from FreeBSD: src/sys/kern/syscalls.master,v 1.65 1999/09/29 15:01:21 marcel Exp */ #include "opt_compat.h" @@ -66,13 +66,13 @@ struct sysent sysent[] = { { 0, (sy_call_t *)getegid }, /* 43 = getegid */ { 4, (sy_call_t *)profil }, /* 44 = profil */ { 4, (sy_call_t *)ktrace }, /* 45 = ktrace */ - { 3, (sy_call_t *)sigaction }, /* 46 = sigaction */ + { 3, (sy_call_t *)osigaction }, /* 46 = osigaction */ { 0, (sy_call_t *)getgid }, /* 47 = getgid */ - { 2, (sy_call_t *)sigprocmask }, /* 48 = sigprocmask */ + { 2, (sy_call_t *)osigprocmask }, /* 48 = osigprocmask */ { 2, (sy_call_t *)getlogin }, /* 49 = getlogin */ { 1, (sy_call_t *)setlogin }, /* 50 = setlogin */ { 1, (sy_call_t *)acct }, /* 51 = acct */ - { 0, (sy_call_t *)sigpending }, /* 52 = sigpending */ + { 0, (sy_call_t *)osigpending }, /* 52 = osigpending */ { 2, (sy_call_t *)sigaltstack }, /* 53 = sigaltstack */ { 3, (sy_call_t *)ioctl }, /* 54 = ioctl */ { 1, (sy_call_t *)reboot }, /* 55 = reboot */ @@ -123,7 +123,7 @@ struct sysent sysent[] = { { 2, (sy_call_t *)getpriority }, /* 100 = getpriority */ { compat(4,send) }, /* 101 = old send */ { compat(4,recv) }, /* 102 = old recv */ - { 1, (sy_call_t *)sigreturn }, /* 103 = sigreturn */ + { 1, (sy_call_t *)osigreturn }, /* 103 = osigreturn */ { 3, (sy_call_t *)bind }, /* 104 = bind */ { 5, (sy_call_t *)setsockopt }, /* 105 = setsockopt */ { 2, (sy_call_t *)listen }, /* 106 = listen */ @@ -131,7 +131,7 @@ struct sysent sysent[] = { { compat(3,sigvec) }, /* 108 = old sigvec */ { compat(1,sigblock) }, /* 109 = old sigblock */ { compat(1,sigsetmask) }, /* 110 = old sigsetmask */ - { 1, (sy_call_t *)sigsuspend }, /* 111 = sigsuspend */ + { 1, (sy_call_t *)osigsuspend }, /* 111 = osigsuspend */ { compat(2,sigstack) }, /* 112 = old sigstack */ { compat(3,recvmsg) }, /* 113 = old recvmsg */ { compat(3,sendmsg) }, /* 114 = old sendmsg */ @@ -360,4 +360,11 @@ struct sysent sysent[] = { { 3, (sy_call_t *)kldsym }, /* 337 = kldsym */ { 1, (sy_call_t *)jail }, /* 338 = jail */ { 0, (sy_call_t *)nosys }, /* 339 = pioctl */ + { 3, (sy_call_t *)sigprocmask }, /* 340 = sigprocmask */ + { 1, (sy_call_t *)sigsuspend }, /* 341 = sigsuspend */ + { 3, (sy_call_t *)sigaction }, /* 342 = sigaction */ + { 1, (sy_call_t *)sigpending }, /* 343 = sigpending */ + { 1, (sy_call_t *)sigreturn }, /* 344 = sigreturn */ + { 0, (sy_call_t *)nosys }, /* 345 = sigtimedwait */ + { 0, (sy_call_t *)nosys }, /* 346 = sigwaitinfo */ }; diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c index 50e29b8..acdc299 100644 --- a/sys/kern/kern_exit.c +++ b/sys/kern/kern_exit.c @@ -173,7 +173,7 @@ exit1(p, rv) */ p->p_flag &= ~(P_TRACED | P_PPWAIT); p->p_flag |= P_WEXIT; - p->p_siglist = 0; + SIGEMPTYSET(p->p_siglist); if (timevalisset(&p->p_realtimer.it_value)) untimeout(realitexpire, (caddr_t)p, p->p_ithandle); diff --git a/sys/kern/kern_ktrace.c b/sys/kern/kern_ktrace.c index 46691a0..c2dfcac 100644 --- a/sys/kern/kern_ktrace.c +++ b/sys/kern/kern_ktrace.c @@ -194,9 +194,9 @@ done: void ktrpsig(vp, sig, action, mask, code) struct vnode *vp; - int sig; + int sig, code; sig_t action; - int mask, code; + sigset_t *mask; { struct ktr_header *kth; struct ktr_psig kp; @@ -206,7 +206,7 @@ ktrpsig(vp, sig, action, mask, code) kth = ktrgetheader(KTR_PSIG); kp.signo = (char)sig; kp.action = action; - kp.mask = mask; + kp.mask = *mask; kp.code = code; kth->ktr_buf = (caddr_t)&kp; kth->ktr_len = sizeof (struct ktr_psig); diff --git a/sys/kern/kern_sig.c b/sys/kern/kern_sig.c index b340287..3d3aaba 100644 --- a/sys/kern/kern_sig.c +++ b/sys/kern/kern_sig.c @@ -42,7 +42,6 @@ #include "opt_compat.h" #include "opt_ktrace.h" -#define SIGPROP /* include signal properties table */ #include <sys/param.h> #include <sys/kernel.h> #include <sys/sysproto.h> @@ -68,8 +67,13 @@ #include <machine/smp.h> #endif -static int killpg1 __P((struct proc *cp, int signum, int pgid, int all)); -static void setsigvec __P((struct proc *p, int signum, struct sigaction *sa)); +static int sigprop __P((int sig)); +static int sig_ffs __P((sigset_t *set)); +static int killpg1 __P((struct proc *cp, int sig, int pgid, int all)); +static int do_sigaction __P((struct proc *p, int sig, struct sigaction *act, + struct sigaction *oact)); +static int do_sigprocmask __P((struct proc *p, int how, sigset_t *set, + sigset_t *oset)); static void stop __P((struct proc *)); static char *expand_name __P((const char *, uid_t, pid_t)); static int coredump __P((struct proc *)); @@ -80,15 +84,15 @@ SYSCTL_INT(_kern, KERN_LOGSIGEXIT, logsigexit, CTLFLAG_RW, "Log processes quitting on abnormal signals to syslog(3)"); /* - * Can process p, with pcred pc, send the signal signum to process q? + * Can process p, with pcred pc, send the signal sig to process q? */ -#define CANSIGNAL(p, pc, q, signum) \ +#define CANSIGNAL(p, pc, q, sig) \ (PRISON_CHECK(p, q) && ((pc)->pc_ucred->cr_uid == 0 || \ (pc)->p_ruid == (q)->p_cred->p_ruid || \ (pc)->pc_ucred->cr_uid == (q)->p_cred->p_ruid || \ (pc)->p_ruid == (q)->p_ucred->cr_uid || \ (pc)->pc_ucred->cr_uid == (q)->p_ucred->cr_uid || \ - ((signum) == SIGCONT && (q)->p_session == (p)->p_session))) + ((sig) == SIGCONT && (q)->p_session == (p)->p_session))) /* * Policy -- Can real uid ruid with ucred uc send a signal to process q? @@ -104,11 +108,203 @@ int sugid_coredump; SYSCTL_INT(_kern, OID_AUTO, sugid_coredump, CTLFLAG_RW, &sugid_coredump, 0, "Enable coredumping set user/group ID processes"); +/* + * Signal properties and actions. + * The array below categorizes the signals and their default actions + * according to the following properties: + */ +#define SA_KILL 0x01 /* terminates process by default */ +#define SA_CORE 0x02 /* ditto and coredumps */ +#define SA_STOP 0x04 /* suspend process */ +#define SA_TTYSTOP 0x08 /* ditto, from tty */ +#define SA_IGNORE 0x10 /* ignore by default */ +#define SA_CONT 0x20 /* continue if suspended */ +#define SA_CANTMASK 0x40 /* non-maskable, catchable */ + +static int sigproptbl[NSIG] = { + SA_KILL, /* SIGHUP */ + SA_KILL, /* SIGINT */ + SA_KILL|SA_CORE, /* SIGQUIT */ + SA_KILL|SA_CORE, /* SIGILL */ + SA_KILL|SA_CORE, /* SIGTRAP */ + SA_KILL|SA_CORE, /* SIGABRT */ + SA_KILL|SA_CORE, /* SIGEMT */ + SA_KILL|SA_CORE, /* SIGFPE */ + SA_KILL, /* SIGKILL */ + SA_KILL|SA_CORE, /* SIGBUS */ + SA_KILL|SA_CORE, /* SIGSEGV */ + SA_KILL|SA_CORE, /* SIGSYS */ + SA_KILL, /* SIGPIPE */ + SA_KILL, /* SIGALRM */ + SA_KILL, /* SIGTERM */ + SA_IGNORE, /* SIGURG */ + SA_STOP, /* SIGSTOP */ + SA_STOP|SA_TTYSTOP, /* SIGTSTP */ + SA_IGNORE|SA_CONT, /* SIGCONT */ + SA_IGNORE, /* SIGCHLD */ + SA_STOP|SA_TTYSTOP, /* SIGTTIN */ + SA_STOP|SA_TTYSTOP, /* SIGTTOU */ + SA_IGNORE, /* SIGIO */ + SA_KILL, /* SIGXCPU */ + SA_KILL, /* SIGXFSZ */ + SA_KILL, /* SIGVTALRM */ + SA_KILL, /* SIGPROF */ + SA_IGNORE, /* SIGWINCH */ + SA_IGNORE, /* SIGINFO */ + SA_KILL, /* SIGUSR1 */ + SA_KILL, /* SIGUSR2 */ +}; + +extern __inline int sigprop(int sig) +{ + if (sig > 0 && sig < NSIG) + return (sigproptbl[_SIG_IDX(sig)]); + else + return (0); +} + +extern __inline int sig_ffs(sigset_t *set) +{ + int i; + + for (i = 0; i < _SIG_WORDS; i++) { + if (set->__bits[i]) + return (ffs(set->__bits[i]) + (i * 32)); + } + return (0); +} + +/* + * do_sigaction + * sigaction + * osigaction + */ +static int +do_sigaction(p, sig, act, oact) + struct proc *p; + register int sig; + struct sigaction *act, *oact; +{ + register struct sigacts *ps = p->p_sigacts; + + if (sig <= 0 || sig > _SIG_MAXSIG) + return (EINVAL); + + if (oact) { + oact->sa_handler = ps->ps_sigact[_SIG_IDX(sig)]; + oact->sa_mask = ps->ps_catchmask[_SIG_IDX(sig)]; + oact->sa_flags = 0; + if (SIGISMEMBER(ps->ps_sigonstack, sig)) + oact->sa_flags |= SA_ONSTACK; + if (!SIGISMEMBER(ps->ps_sigintr, sig)) + oact->sa_flags |= SA_RESTART; + if (SIGISMEMBER(ps->ps_sigreset, sig)) + oact->sa_flags |= SA_RESETHAND; + if (SIGISMEMBER(ps->ps_signodefer, sig)) + oact->sa_flags |= SA_NODEFER; + if (SIGISMEMBER(ps->ps_siginfo, sig)) + oact->sa_flags |= SA_SIGINFO; + if (sig == SIGCHLD && p->p_procsig->ps_flag & P_NOCLDSTOP) + oact->sa_flags |= SA_NOCLDSTOP; + if (sig == SIGCHLD && p->p_procsig->ps_flag & P_NOCLDWAIT) + oact->sa_flags |= SA_NOCLDWAIT; + } + if (act) { + if ((sig == SIGKILL || sig == SIGSTOP) && + act->sa_handler != SIG_DFL) + return (EINVAL); + + /* + * Change setting atomically. + */ + (void) splhigh(); + + ps->ps_catchmask[_SIG_IDX(sig)] = act->sa_mask; + SIG_CANTMASK(ps->ps_catchmask[_SIG_IDX(sig)]); + if (act->sa_flags & SA_SIGINFO) { + ps->ps_sigact[_SIG_IDX(sig)] = act->sa_handler; + SIGADDSET(ps->ps_siginfo, sig); + } + else { + ps->ps_sigact[_SIG_IDX(sig)] = + (__sighandler_t *)act->sa_sigaction; + SIGDELSET(ps->ps_siginfo, sig); + } + if (!(act->sa_flags & SA_RESTART)) + SIGADDSET(ps->ps_sigintr, sig); + else + SIGDELSET(ps->ps_sigintr, sig); + if (act->sa_flags & SA_ONSTACK) + SIGADDSET(ps->ps_sigonstack, sig); + else + SIGDELSET(ps->ps_sigonstack, sig); + if (act->sa_flags & SA_RESETHAND) + SIGADDSET(ps->ps_sigreset, sig); + else + SIGDELSET(ps->ps_sigreset, sig); + if (act->sa_flags & SA_NODEFER) + SIGADDSET(ps->ps_signodefer, sig); + else + SIGDELSET(ps->ps_signodefer, sig); +#ifdef COMPAT_SUNOS + if (act->sa_flags & SA_USERTRAMP) + SIGADDSET(ps->ps_usertramp, sig); + else + SIGDELSET(ps->ps_usertramp, seg); +#endif + if (sig == SIGCHLD) { + if (act->sa_flags & SA_NOCLDSTOP) + p->p_procsig->ps_flag |= P_NOCLDSTOP; + else + p->p_procsig->ps_flag &= ~P_NOCLDSTOP; + if (act->sa_flags & SA_NOCLDWAIT) { + /* + * Paranoia: since SA_NOCLDWAIT is implemented + * by reparenting the dying child to PID 1 (and + * trust it to reap the zombie), PID 1 itself + * is forbidden to set SA_NOCLDWAIT. + */ + if (p->p_pid == 1) + p->p_procsig->ps_flag &= ~P_NOCLDWAIT; + else + p->p_procsig->ps_flag |= P_NOCLDWAIT; + } else + p->p_procsig->ps_flag &= ~P_NOCLDWAIT; + } + /* + * Set bit in p_sigignore for signals that are set to SIG_IGN, + * and for signals set to SIG_DFL where the default is to + * ignore. However, don't put SIGCONT in p_sigignore, as we + * have to restart the process. + */ + if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_IGN || + (sigprop(sig) & SA_IGNORE && + ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL)) { + /* never to be seen again */ + SIGDELSET(p->p_siglist, sig); + if (sig != SIGCONT) + /* easier in psignal */ + SIGADDSET(p->p_sigignore, sig); + SIGDELSET(p->p_sigcatch, sig); + } + else { + SIGDELSET(p->p_sigignore, sig); + if (ps->ps_sigact[_SIG_IDX(sig)] == SIG_DFL) + SIGDELSET(p->p_sigcatch, sig); + else + SIGADDSET(p->p_sigcatch, sig); + } + + (void) spl0(); + } + return (0); +} + #ifndef _SYS_SYSPROTO_H_ struct sigaction_args { - int signum; - struct sigaction *nsa; - struct sigaction *osa; + int sig; + struct sigaction *act; + struct sigaction *oact; }; #endif /* ARGSUSED */ @@ -117,138 +313,64 @@ sigaction(p, uap) struct proc *p; register struct sigaction_args *uap; { - struct sigaction vec; - register struct sigaction *sa; - register struct sigacts *ps = p->p_sigacts; - register int signum; - int bit, error; + struct sigaction act, oact; + register struct sigaction *actp, *oactp; + int error; - signum = uap->signum; - if (signum <= 0 || signum >= NSIG) - return (EINVAL); - sa = &vec; - if (uap->osa) { - bit = sigmask(signum); - if ((ps->ps_siginfo & bit) != 0) - sa->sa_sigaction = - (__siginfohandler_t *)ps->ps_sigact[signum]; - else - sa->sa_handler = ps->ps_sigact[signum]; - sa->sa_mask = ps->ps_catchmask[signum]; - sa->sa_flags = 0; - if ((ps->ps_sigonstack & bit) != 0) - sa->sa_flags |= SA_ONSTACK; - if ((ps->ps_sigintr & bit) == 0) - sa->sa_flags |= SA_RESTART; - if ((ps->ps_sigreset & bit) != 0) - sa->sa_flags |= SA_RESETHAND; - if ((ps->ps_signodefer & bit) != 0) - sa->sa_flags |= SA_NODEFER; - if ((ps->ps_siginfo & bit) != 0) - sa->sa_flags |= SA_SIGINFO; - if (signum == SIGCHLD && p->p_procsig->ps_flag & P_NOCLDSTOP) - sa->sa_flags |= SA_NOCLDSTOP; - if (signum == SIGCHLD && p->p_procsig->ps_flag & P_NOCLDWAIT) - sa->sa_flags |= SA_NOCLDWAIT; - if ((error = copyout((caddr_t)sa, (caddr_t)uap->osa, - sizeof (vec)))) + p->p_flag |= P_NEWSIGSET; + + actp = (uap->act) ? &act : NULL; + oactp = (uap->oact) ? &oact : NULL; + if (actp) { + error = copyin((c_caddr_t)uap->act, (caddr_t)actp, + sizeof(act)); + if (error) return (error); } - if (uap->nsa) { - if ((error = copyin((caddr_t)uap->nsa, (caddr_t)sa, - sizeof (vec)))) - return (error); - if ((signum == SIGKILL || signum == SIGSTOP) && - sa->sa_handler != SIG_DFL) - return (EINVAL); - setsigvec(p, signum, sa); + error = do_sigaction(p, uap->sig, actp, oactp); + if (oactp && !error) { + error = copyout((caddr_t)oactp, (caddr_t)uap->oact, + sizeof(oact)); } - return (0); + return (error); } -static void -setsigvec(p, signum, sa) - register struct proc *p; - int signum; - register struct sigaction *sa; +#ifndef _SYS_SYSPROTO_H_ +struct osigaction_args { + int signum; + struct osigaction *nsa; + struct osigaction *osa; +}; +#endif +/* ARGSUSED */ +int +osigaction(p, uap) + struct proc *p; + register struct osigaction_args *uap; { - register struct sigacts *ps = p->p_sigacts; - register int bit; + struct osigaction sa; + struct sigaction nsa, osa; + register struct sigaction *nsap, *osap; + int error; - bit = sigmask(signum); - /* - * Change setting atomically. - */ - (void) splhigh(); - ps->ps_catchmask[signum] = sa->sa_mask &~ sigcantmask; - if (sa->sa_flags & SA_SIGINFO) { - ps->ps_sigact[signum] = sa->sa_handler; - ps->ps_siginfo |= bit; - } else { - ps->ps_sigact[signum] = (__sighandler_t *)sa->sa_sigaction; - ps->ps_siginfo &= ~bit; + nsap = (uap->nsa) ? &nsa : NULL; + osap = (uap->osa) ? &osa : NULL; + if (nsap) { + error = copyin((caddr_t)uap->nsa, (caddr_t)&sa, sizeof(sa)); + if (error) + return (error); + nsap->sa_handler = sa.sa_handler; + nsap->sa_flags = sa.sa_flags; + OSIG2SIG(sa.sa_mask, nsap->sa_mask); } - if ((sa->sa_flags & SA_RESTART) == 0) - ps->ps_sigintr |= bit; - else - ps->ps_sigintr &= ~bit; - if (sa->sa_flags & SA_ONSTACK) - ps->ps_sigonstack |= bit; - else - ps->ps_sigonstack &= ~bit; - if (sa->sa_flags & SA_RESETHAND) - ps->ps_sigreset |= bit; - else - ps->ps_sigreset &= ~bit; - if (sa->sa_flags & SA_NODEFER) - ps->ps_signodefer |= bit; - else - ps->ps_signodefer &= ~bit; -#ifdef COMPAT_SUNOS - if (sa->sa_flags & SA_USERTRAMP) - ps->ps_usertramp |= bit; - else - ps->ps_usertramp &= ~bit; -#endif - if (signum == SIGCHLD) { - if (sa->sa_flags & SA_NOCLDSTOP) - p->p_procsig->ps_flag |= P_NOCLDSTOP; - else - p->p_procsig->ps_flag &= ~P_NOCLDSTOP; - if (sa->sa_flags & SA_NOCLDWAIT) { - /* - * Paranoia: since SA_NOCLDWAIT is implemented by - * reparenting the dying child to PID 1 (and - * trust it to reap the zombie), PID 1 itself is - * forbidden to set SA_NOCLDWAIT. - */ - if (p->p_pid == 1) - p->p_procsig->ps_flag &= ~P_NOCLDWAIT; - else - p->p_procsig->ps_flag |= P_NOCLDWAIT; - } else - p->p_procsig->ps_flag &= ~P_NOCLDWAIT; + error = do_sigaction(p, uap->signum, nsap, osap); + if (osap && !error) { + sa.sa_handler = osap->sa_handler; + sa.sa_flags = osap->sa_flags; + SIG2OSIG(osap->sa_mask, sa.sa_mask); + error = copyout((caddr_t)&sa, (caddr_t)uap->osa, sizeof(sa)); } - /* - * Set bit in p_sigignore for signals that are set to SIG_IGN, - * and for signals set to SIG_DFL where the default is to ignore. - * However, don't put SIGCONT in p_sigignore, - * as we have to restart the process. - */ - if (ps->ps_sigact[signum] == SIG_IGN || - (sigprop[signum] & SA_IGNORE && ps->ps_sigact[signum] == SIG_DFL)) { - p->p_siglist &= ~bit; /* never to be seen again */ - if (signum != SIGCONT) - p->p_sigignore |= bit; /* easier in psignal */ - p->p_sigcatch &= ~bit; - } else { - p->p_sigignore &= ~bit; - if (ps->ps_sigact[signum] == SIG_DFL) - p->p_sigcatch &= ~bit; - else - p->p_sigcatch |= bit; - } - (void) spl0(); + return (error); } /* @@ -261,9 +383,9 @@ siginit(p) { register int i; - for (i = 0; i < NSIG; i++) - if (sigprop[i] & SA_IGNORE && i != SIGCONT) - p->p_sigignore |= sigmask(i); + for (i = 1; i <= NSIG; i++) + if (sigprop(i) & SA_IGNORE && i != SIGCONT) + SIGADDSET(p->p_sigignore, i); } /* @@ -274,23 +396,22 @@ execsigs(p) register struct proc *p; { register struct sigacts *ps = p->p_sigacts; - register int nc, mask; + register int sig; /* * Reset caught signals. Held signals remain held * through p_sigmask (unless they were caught, * and are now ignored by default). */ - while (p->p_sigcatch) { - nc = ffs((long)p->p_sigcatch); - mask = sigmask(nc); - p->p_sigcatch &= ~mask; - if (sigprop[nc] & SA_IGNORE) { - if (nc != SIGCONT) - p->p_sigignore |= mask; - p->p_siglist &= ~mask; + while (SIGNOTEMPTY(p->p_sigcatch)) { + sig = sig_ffs(&p->p_sigcatch); + SIGDELSET(p->p_sigcatch, sig); + if (sigprop(sig) & SA_IGNORE) { + if (sig != SIGCONT) + SIGADDSET(p->p_sigignore, sig); + SIGDELSET(p->p_siglist, sig); } - ps->ps_sigact[nc] = SIG_DFL; + ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL; } /* * Reset stack state to the user stack. @@ -312,10 +433,46 @@ execsigs(p) * and return old mask as return value; * the library stub does the rest. */ +static int +do_sigprocmask(p, how, set, oset) + struct proc *p; + int how; + sigset_t *set, *oset; +{ + int error; + + if (oset != NULL) + *oset = p->p_sigmask; + + error = 0; + if (set != NULL) { + (void) splhigh(); + switch (how) { + case SIG_BLOCK: + SIGSETOR(p->p_sigmask, *set); + SIG_CANTMASK(p->p_sigmask); + break; + case SIG_UNBLOCK: + SIGSETNAND(p->p_sigmask, *set); + break; + case SIG_SETMASK: + p->p_sigmask = *set; + SIG_CANTMASK(p->p_sigmask); + break; + default: + error = EINVAL; + break; + } + (void) spl0(); + } + return (error); +} + #ifndef _SYS_SYSPROTO_H_ struct sigprocmask_args { int how; - sigset_t mask; + const sigset_t *set; + sigset_t *oset; }; #endif int @@ -323,35 +480,49 @@ sigprocmask(p, uap) register struct proc *p; struct sigprocmask_args *uap; { - int error = 0; - - p->p_retval[0] = p->p_sigmask; - (void) splhigh(); - - switch (uap->how) { - case SIG_BLOCK: - p->p_sigmask |= uap->mask &~ sigcantmask; - break; + sigset_t set, oset; + sigset_t *setp, *osetp; + int error; - case SIG_UNBLOCK: - p->p_sigmask &= ~uap->mask; - break; + setp = (uap->set) ? &set : NULL; + osetp = (uap->oset) ? &oset : NULL; + if (setp) { + error = copyin((c_caddr_t)uap->set, (caddr_t)setp, + sizeof(set)); + if (error) + return (error); + } + error = do_sigprocmask(p, uap->how, setp, osetp); + if (osetp && !error) { + error = copyout((caddr_t)osetp, (caddr_t)uap->oset, + sizeof(oset)); + } + return (error); +} - case SIG_SETMASK: - p->p_sigmask = uap->mask &~ sigcantmask; - break; +#ifndef _SYS_SYSPROTO_H_ +struct osigprocmask_args { + int how; + osigset_t mask; +}; +#endif +int +osigprocmask(p, uap) + register struct proc *p; + struct osigprocmask_args *uap; +{ + sigset_t set, oset; + int error; - default: - error = EINVAL; - break; - } - (void) spl0(); + OSIG2SIG(uap->mask, set); + error = do_sigprocmask(p, uap->how, &set, &oset); + SIG2OSIG(oset, p->p_retval[0]); return (error); } #ifndef _SYS_SYSPROTO_H_ struct sigpending_args { - int dummy; + sigset_t *set; }; #endif /* ARGSUSED */ @@ -361,7 +532,23 @@ sigpending(p, uap) struct sigpending_args *uap; { - p->p_retval[0] = p->p_siglist; + return (copyout((caddr_t)&p->p_siglist, (caddr_t)uap->set, + sizeof(sigset_t))); +} + +#ifndef _SYS_SYSPROTO_H_ +struct osigpending_args { + int dummy; +}; +#endif +/* ARGSUSED */ +int +osigpending(p, uap) + struct proc *p; + struct osigpending_args *uap; +{ + + SIG2OSIG(p->p_siglist, p->p_retval[0]); return (0); } @@ -383,52 +570,37 @@ osigvec(p, uap) register struct osigvec_args *uap; { struct sigvec vec; - register struct sigacts *ps = p->p_sigacts; - register struct sigvec *sv; - register int signum; - int bit, error; + struct sigaction nsa, osa; + register struct sigaction *nsap, *osap; + int error; - signum = uap->signum; - if (signum <= 0 || signum >= NSIG) - return (EINVAL); - sv = &vec; - if (uap->osv) { - *(sig_t *)&sv->sv_handler = ps->ps_sigact[signum]; - sv->sv_mask = ps->ps_catchmask[signum]; - bit = sigmask(signum); - sv->sv_flags = 0; - if ((ps->ps_sigonstack & bit) != 0) - sv->sv_flags |= SV_ONSTACK; - if ((ps->ps_sigintr & bit) != 0) - sv->sv_flags |= SV_INTERRUPT; - if ((ps->ps_sigreset & bit) != 0) - sv->sv_flags |= SV_RESETHAND; - if ((ps->ps_signodefer & bit) != 0) - sv->sv_flags |= SV_NODEFER; - if ((ps->ps_siginfo & bit) != 0) - sv->sv_flags |= SV_SIGINFO; -#ifndef COMPAT_SUNOS - if (signum == SIGCHLD && p->p_procsig->ps_flag & P_NOCLDSTOP) - sv->sv_flags |= SV_NOCLDSTOP; -#endif - if ((error = copyout((caddr_t)sv, (caddr_t)uap->osv, - sizeof (vec)))) + nsap = (uap->nsv) ? &nsa : NULL; + osap = (uap->osv) ? &osa : NULL; + if (nsap) { + error = copyin((caddr_t)uap->nsv, (caddr_t)&vec, sizeof(vec)); + if (error) return (error); + nsap->sa_handler = vec.sv_handler; + OSIG2SIG(vec.sv_mask, nsap->sa_mask); + nsap->sa_flags = vec.sv_flags; + nsap->sa_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */ +#ifdef COMPAT_SUNOS + nsap->sa_flags |= SA_USERTRAMP; +#endif } - if (uap->nsv) { - if ((error = copyin((caddr_t)uap->nsv, (caddr_t)sv, - sizeof (vec)))) - return (error); - if ((signum == SIGKILL || signum == SIGSTOP) && - sv->sv_handler != SIG_DFL) - return (EINVAL); + error = do_sigaction(p, uap->signum, nsap, osap); + if (osap && !error) { + vec.sv_handler = osap->sa_handler; + SIG2OSIG(osap->sa_mask, vec.sv_mask); + vec.sv_flags = osap->sa_flags; + vec.sv_flags &= ~SA_NOCLDWAIT; + vec.sv_flags ^= SA_RESTART; #ifdef COMPAT_SUNOS - sv->sv_flags |= SA_USERTRAMP; + vec.sv_flags &= ~SA_NOCLDSTOP; #endif - sv->sv_flags ^= SA_RESTART; /* opposite of SV_INTERRUPT */ - setsigvec(p, signum, (struct sigaction *)sv); + error = copyout((caddr_t)&vec, (caddr_t)uap->osv, sizeof(vec)); } - return (0); + return (error); } #ifndef _SYS_SYSPROTO_H_ @@ -441,10 +613,13 @@ osigblock(p, uap) register struct proc *p; struct osigblock_args *uap; { + sigset_t set; + OSIG2SIG(uap->mask, set); + SIG_CANTMASK(set); (void) splhigh(); - p->p_retval[0] = p->p_sigmask; - p->p_sigmask |= uap->mask &~ sigcantmask; + SIG2OSIG(p->p_sigmask, p->p_retval[0]); + SIGSETOR(p->p_sigmask, set); (void) spl0(); return (0); } @@ -459,10 +634,13 @@ osigsetmask(p, uap) struct proc *p; struct osigsetmask_args *uap; { + sigset_t set; + OSIG2SIG(uap->mask, set); + SIG_CANTMASK(set); (void) splhigh(); - p->p_retval[0] = p->p_sigmask; - p->p_sigmask = uap->mask &~ sigcantmask; + SIG2OSIG(p->p_sigmask, p->p_retval[0]); + p->p_sigmask = set; (void) spl0(); return (0); } @@ -475,7 +653,7 @@ osigsetmask(p, uap) */ #ifndef _SYS_SYSPROTO_H_ struct sigsuspend_args { - sigset_t mask; + const sigset_t *sigmask; }; #endif /* ARGSUSED */ @@ -484,7 +662,13 @@ sigsuspend(p, uap) register struct proc *p; struct sigsuspend_args *uap; { + sigset_t mask; register struct sigacts *ps = p->p_sigacts; + int error; + + error = copyin((c_caddr_t)uap->sigmask, (caddr_t)&mask, sizeof(mask)); + if (error) + return (error); /* * When returning from sigpause, we want @@ -494,7 +678,32 @@ sigsuspend(p, uap) * to indicate this. */ p->p_oldsigmask = p->p_sigmask; - p->p_sigmask = uap->mask &~ sigcantmask; + p->p_sigmask = mask; + SIG_CANTMASK(p->p_sigmask); + while (tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0) == 0) + /* void */; + /* always return EINTR rather than ERESTART... */ + return (EINTR); +} + +#ifndef _SYS_SYSPROTO_H_ +struct osigsuspend_args { + osigset_t mask; +}; +#endif +/* ARGSUSED */ +int +osigsuspend(p, uap) + register struct proc *p; + struct osigsuspend_args *uap; +{ + sigset_t set; + register struct sigacts *ps = p->p_sigacts; + + OSIG2SIG(uap->mask, set); + SIG_CANTMASK(set); + p->p_oldsigmask = p->p_sigmask; + p->p_sigmask = set; while (tsleep((caddr_t) ps, PPAUSE|PCATCH, "pause", 0) == 0) /* void */; /* always return EINTR rather than ERESTART... */ @@ -537,8 +746,8 @@ osigstack(p, uap) #ifndef _SYS_SYSPROTO_H_ struct sigaltstack_args { - struct sigaltstack *nss; - struct sigaltstack *oss; + stack_t *ss; + stack_t *oss; }; #endif /* ARGSUSED */ @@ -548,18 +757,18 @@ sigaltstack(p, uap) register struct sigaltstack_args *uap; { struct sigacts *psp; - struct sigaltstack ss; + stack_t ss; int error; psp = p->p_sigacts; if ((psp->ps_flags & SAS_ALTSTACK) == 0) psp->ps_sigstk.ss_flags |= SS_DISABLE; if (uap->oss && (error = copyout((caddr_t)&psp->ps_sigstk, - (caddr_t)uap->oss, sizeof (struct sigaltstack)))) + (caddr_t)uap->oss, sizeof (stack_t)))) return (error); - if (uap->nss == 0) + if (uap->ss == 0) return (0); - if ((error = copyin((caddr_t)uap->nss, (caddr_t)&ss, sizeof (ss)))) + if ((error = copyin((caddr_t)uap->ss, (caddr_t)&ss, sizeof (ss)))) return (error); if (ss.ss_flags & SS_DISABLE) { if (psp->ps_sigstk.ss_flags & SS_ONSTACK) @@ -571,7 +780,7 @@ sigaltstack(p, uap) if (ss.ss_size < MINSIGSTKSZ) return (ENOMEM); psp->ps_flags |= SAS_ALTSTACK; - psp->ps_sigstk= ss; + psp->ps_sigstk = ss; return (0); } @@ -580,9 +789,9 @@ sigaltstack(p, uap) * cp is calling process. */ int -killpg1(cp, signum, pgid, all) +killpg1(cp, sig, pgid, all) register struct proc *cp; - int signum, pgid, all; + int sig, pgid, all; { register struct proc *p; register struct pcred *pc = cp->p_cred; @@ -595,11 +804,11 @@ killpg1(cp, signum, pgid, all) */ for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) { if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || - p == cp || !CANSIGNAL(cp, pc, p, signum)) + p == cp || !CANSIGNAL(cp, pc, p, sig)) continue; nfound++; - if (signum) - psignal(p, signum); + if (sig) + psignal(p, sig); } else { if (pgid == 0) @@ -616,11 +825,11 @@ killpg1(cp, signum, pgid, all) p = p->p_pglist.le_next) { if (p->p_pid <= 1 || p->p_flag & P_SYSTEM || p->p_stat == SZOMB || - !CANSIGNAL(cp, pc, p, signum)) + !CANSIGNAL(cp, pc, p, sig)) continue; nfound++; - if (signum) - psignal(p, signum); + if (sig) + psignal(p, sig); } } return (nfound ? 0 : ESRCH); @@ -641,7 +850,7 @@ kill(cp, uap) register struct proc *p; register struct pcred *pc = cp->p_cred; - if ((u_int)uap->signum >= NSIG) + if ((u_int)uap->signum > _SIG_MAXSIG) return (EINVAL); if (uap->pid > 0) { /* kill single process */ @@ -678,7 +887,7 @@ okillpg(p, uap) register struct okillpg_args *uap; { - if ((u_int)uap->signum >= NSIG) + if ((u_int)uap->signum > _SIG_MAXSIG) return (EINVAL); return (killpg1(p, uap->signum, uap->pgid, 0)); } @@ -688,13 +897,13 @@ okillpg(p, uap) * Send a signal to a process group. */ void -gsignal(pgid, signum) - int pgid, signum; +gsignal(pgid, sig) + int pgid, sig; { struct pgrp *pgrp; if (pgid && (pgrp = pgfind(pgid))) - pgsignal(pgrp, signum, 0); + pgsignal(pgrp, sig, 0); } /* @@ -702,9 +911,9 @@ gsignal(pgid, signum) * limit to members which have a controlling terminal. */ void -pgsignal(pgrp, signum, checkctty) +pgsignal(pgrp, sig, checkctty) struct pgrp *pgrp; - int signum, checkctty; + int sig, checkctty; { register struct proc *p; @@ -712,7 +921,7 @@ pgsignal(pgrp, signum, checkctty) for (p = pgrp->pg_members.lh_first; p != 0; p = p->p_pglist.le_next) if (checkctty == 0 || p->p_flag & P_CONTROLT) - psignal(p, signum); + psignal(p, sig); } /* @@ -721,40 +930,41 @@ pgsignal(pgrp, signum, checkctty) * Otherwise, post it normally. */ void -trapsignal(p, signum, code) +trapsignal(p, sig, code) struct proc *p; - register int signum; + register int sig; u_long code; { register struct sigacts *ps = p->p_sigacts; - int mask; - mask = sigmask(signum); - if ((p->p_flag & P_TRACED) == 0 && (p->p_sigcatch & mask) != 0 && - (p->p_sigmask & mask) == 0) { + if ((p->p_flag & P_TRACED) == 0 && SIGISMEMBER(p->p_sigcatch, sig) && + SIGISMEMBER(p->p_sigmask, sig)) { p->p_stats->p_ru.ru_nsignals++; #ifdef KTRACE if (KTRPOINT(p, KTR_PSIG)) - ktrpsig(p->p_tracep, signum, ps->ps_sigact[signum], - p->p_sigmask, code); + ktrpsig(p->p_tracep, sig, ps->ps_sigact[_SIG_IDX(sig)], + &p->p_sigmask, code); #endif - (*p->p_sysent->sv_sendsig)(ps->ps_sigact[signum], signum, - p->p_sigmask, code); - p->p_sigmask |= ps->ps_catchmask[signum] | - (mask & ~ps->ps_signodefer); - if ((ps->ps_sigreset & mask) != 0) { + (*p->p_sysent->sv_sendsig)(ps->ps_sigact[_SIG_IDX(sig)], sig, + &p->p_sigmask, code); + SIGSETOR(p->p_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]); + if (!SIGISMEMBER(ps->ps_signodefer, sig)) + SIGADDSET(p->p_sigmask, sig); + if (SIGISMEMBER(ps->ps_sigreset, sig)) { /* - * See setsigvec() for origin of this code. + * See do_sigaction() for origin of this code. */ - p->p_sigcatch &= ~mask; - if (signum != SIGCONT && sigprop[signum] & SA_IGNORE) - p->p_sigignore |= mask; - ps->ps_sigact[signum] = SIG_DFL; + SIGDELSET(p->p_sigcatch, sig); + if (sig != SIGCONT && + sigprop(sig) & SA_IGNORE) + SIGADDSET(p->p_sigignore, sig); + ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL; } - } else { + } + else { p->p_code = code; /* XXX for core dump/debugger */ - p->p_sig = signum; /* XXX to verify code */ - psignal(p, signum); + p->p_sig = sig; /* XXX to verify code */ + psignal(p, sig); } } @@ -772,20 +982,19 @@ trapsignal(p, signum, code) * Other ignored signals are discarded immediately. */ void -psignal(p, signum) +psignal(p, sig) register struct proc *p; - register int signum; + register int sig; { register int s, prop; register sig_t action; - int mask; - if ((u_int)signum >= NSIG || signum == 0) { - printf("psignal: signum %d\n", signum); + if (sig > _SIG_MAXSIG || sig <= 0) { + printf("psignal: signal %d\n", sig); panic("psignal signal number"); } - mask = sigmask(signum); - prop = sigprop[signum]; + + prop = sigprop(sig); /* * If proc is traced, always give parent a chance; @@ -802,11 +1011,11 @@ psignal(p, signum) * and if it is set to SIG_IGN, * action will be SIG_DFL here.) */ - if ((p->p_sigignore & mask) || (p->p_flag & P_WEXIT)) + if (SIGISMEMBER(p->p_sigignore, sig) || (p->p_flag & P_WEXIT)) return; - if (p->p_sigmask & mask) + if (SIGISMEMBER(p->p_sigmask, sig)) action = SIG_HOLD; - else if (p->p_sigcatch & mask) + else if (SIGISMEMBER(p->p_sigcatch, sig)) action = SIG_CATCH; else action = SIG_DFL; @@ -817,7 +1026,7 @@ psignal(p, signum) p->p_nice = NZERO; if (prop & SA_CONT) - p->p_siglist &= ~stopsigmask; + SIG_STOPSIGMASK(p->p_siglist); if (prop & SA_STOP) { /* @@ -829,15 +1038,15 @@ psignal(p, signum) if (prop & SA_TTYSTOP && p->p_pgrp->pg_jobc == 0 && action == SIG_DFL) return; - p->p_siglist &= ~contsigmask; + SIG_CONTSIGMASK(p->p_siglist); } - p->p_siglist |= mask; + SIGADDSET(p->p_siglist, sig); /* * Defer further processing for signals which are held, * except that stopped processes must be continued by SIGCONT. */ - if (action == SIG_HOLD && ((prop & SA_CONT) == 0 || p->p_stat != SSTOP)) + if (action == SIG_HOLD && (!(prop & SA_CONT) || p->p_stat != SSTOP)) return; s = splhigh(); switch (p->p_stat) { @@ -864,7 +1073,7 @@ psignal(p, signum) * be awakened. */ if ((prop & SA_CONT) && action == SIG_DFL) { - p->p_siglist &= ~mask; + SIGDELSET(p->p_siglist, sig); goto out; } /* @@ -882,8 +1091,8 @@ psignal(p, signum) */ if (p->p_flag & P_PPWAIT) goto out; - p->p_siglist &= ~mask; - p->p_xstat = signum; + SIGDELSET(p->p_siglist, sig); + p->p_xstat = sig; if ((p->p_pptr->p_procsig->ps_flag & P_NOCLDSTOP) == 0) psignal(p->p_pptr, SIGCHLD); stop(p); @@ -903,7 +1112,7 @@ psignal(p, signum) /* * Kill signal always sets processes running. */ - if (signum == SIGKILL) + if (sig == SIGKILL) goto runfast; if (prop & SA_CONT) { @@ -918,7 +1127,7 @@ psignal(p, signum) * Otherwise, process goes back to sleep state. */ if (action == SIG_DFL) - p->p_siglist &= ~mask; + SIGDELSET(p->p_siglist, sig); if (action == SIG_CATCH) goto runfast; if (p->p_wchan == 0) @@ -932,7 +1141,7 @@ psignal(p, signum) * Already stopped, don't need to stop again. * (If we did the shell could get confused.) */ - p->p_siglist &= ~mask; /* take it away */ + SIGDELSET(p->p_siglist, sig); goto out; } @@ -983,35 +1192,36 @@ out: * by checking the pending signal masks in the CURSIG macro.) The normal call * sequence is * - * while (signum = CURSIG(curproc)) - * postsig(signum); + * while (sig = CURSIG(curproc)) + * postsig(sig); */ int issignal(p) register struct proc *p; { - register int signum, mask, prop; + sigset_t mask; + register int sig, prop; for (;;) { int traced = (p->p_flag & P_TRACED) || (p->p_stops & S_SIG); - mask = p->p_siglist & ~p->p_sigmask; + mask = p->p_siglist; + SIGSETNAND(mask, p->p_sigmask); if (p->p_flag & P_PPWAIT) - mask &= ~stopsigmask; - if (mask == 0) /* no signal to send */ + SIG_STOPSIGMASK(mask); + if (!SIGNOTEMPTY(mask)) /* no signal to send */ return (0); - signum = ffs((long)mask); - mask = sigmask(signum); - prop = sigprop[signum]; + sig = sig_ffs(&mask); + prop = sigprop(sig); - STOPEVENT(p, S_SIG, signum); + STOPEVENT(p, S_SIG, sig); /* * We should see pending but ignored signals * only if P_TRACED was on when they were posted. */ - if ((mask & p->p_sigignore) && (traced == 0)) { - p->p_siglist &= ~mask; + if (SIGISMEMBER(p->p_sigignore, sig) && (traced == 0)) { + SIGDELSET(p->p_siglist, sig); continue; } if (p->p_flag & P_TRACED && (p->p_flag & P_PPWAIT) == 0) { @@ -1019,7 +1229,7 @@ issignal(p) * If traced, always stop, and stay * stopped until released by the parent. */ - p->p_xstat = signum; + p->p_xstat = sig; psignal(p->p_pptr, SIGCHLD); do { stop(p); @@ -1040,18 +1250,17 @@ issignal(p) * then it will leave it in p->p_xstat; * otherwise we just look for signals again. */ - p->p_siglist &= ~mask; /* clear the old signal */ - signum = p->p_xstat; - if (signum == 0) + SIGDELSET(p->p_siglist, sig); /* clear old signal */ + sig = p->p_xstat; + if (sig == 0) continue; /* * Put the new signal into p_siglist. If the * signal is being masked, look for other signals. */ - mask = sigmask(signum); - p->p_siglist |= mask; - if (p->p_sigmask & mask) + SIGADDSET(p->p_siglist, sig); + if (SIGISMEMBER(p->p_sigmask, sig)) continue; } @@ -1060,7 +1269,7 @@ issignal(p) * Return the signal's number, or fall through * to clear it from the pending mask. */ - switch ((int)(intptr_t)p->p_sigacts->ps_sigact[signum]) { + switch ((int)(intptr_t)p->p_sigacts->ps_sigact[_SIG_IDX(sig)]) { case (int)SIG_DFL: /* @@ -1073,7 +1282,7 @@ issignal(p) * in init? XXX */ printf("Process (pid %lu) got signal %d\n", - (u_long)p->p_pid, signum); + (u_long)p->p_pid, sig); #endif break; /* == ignore */ } @@ -1089,7 +1298,7 @@ issignal(p) (p->p_pgrp->pg_jobc == 0 && prop & SA_TTYSTOP)) break; /* == ignore */ - p->p_xstat = signum; + p->p_xstat = sig; stop(p); if ((p->p_pptr->p_procsig->ps_flag & P_NOCLDSTOP) == 0) psignal(p->p_pptr, SIGCHLD); @@ -1102,7 +1311,7 @@ issignal(p) */ break; /* == ignore */ } else - return (signum); + return (sig); /*NOTREACHED*/ case (int)SIG_IGN: @@ -1121,9 +1330,9 @@ issignal(p) * This signal has an action, let * postsig() process it. */ - return (signum); + return (sig); } - p->p_siglist &= ~mask; /* take the signal! */ + SIGDELSET(p->p_siglist, sig); /* take the signal! */ } /* NOTREACHED */ } @@ -1148,39 +1357,39 @@ stop(p) * from the current set of pending signals. */ void -postsig(signum) - register int signum; +postsig(sig) + register int sig; { register struct proc *p = curproc; - register struct sigacts *ps = p->p_sigacts; - register sig_t action; - int code, mask, returnmask; + struct sigacts *ps = p->p_sigacts; + sig_t action; + sigset_t returnmask; + int code; - KASSERT(signum != 0, ("postsig")); + KASSERT(sig != 0, ("postsig")); - mask = sigmask(signum); - p->p_siglist &= ~mask; - action = ps->ps_sigact[signum]; + SIGDELSET(p->p_siglist, sig); + action = ps->ps_sigact[_SIG_IDX(sig)]; #ifdef KTRACE if (KTRPOINT(p, KTR_PSIG)) ktrpsig(p->p_tracep, - signum, action, p->p_oldsigmask ? - p->p_oldsigmask : p->p_sigmask, 0); + sig, action, SIGNOTEMPTY(p->p_oldsigmask) ? + &p->p_oldsigmask : &p->p_sigmask, 0); #endif - STOPEVENT(p, S_SIG, signum); + STOPEVENT(p, S_SIG, sig); if (action == SIG_DFL) { /* * Default action, where the default is to kill * the process. (Other cases were ignored above.) */ - sigexit(p, signum); + sigexit(p, sig); /* NOTREACHED */ } else { /* * If we get here, the signal must be caught. */ - KASSERT(action != SIG_IGN && (p->p_sigmask & mask) == 0, + KASSERT(action != SIG_IGN && !SIGISMEMBER(p->p_sigmask, sig), ("postsig action")); /* * Set the new mask value and also defer further @@ -1192,32 +1401,36 @@ postsig(signum) * restored after the signal processing is completed. */ (void) splhigh(); - if (p->p_oldsigmask) { + if (SIGNOTEMPTY(p->p_oldsigmask)) { returnmask = p->p_oldsigmask; - p->p_oldsigmask = 0; + SIGEMPTYSET(p->p_oldsigmask); } else returnmask = p->p_sigmask; - p->p_sigmask |= ps->ps_catchmask[signum] | - (mask & ~ps->ps_signodefer); - if ((ps->ps_sigreset & mask) != 0) { + + SIGSETOR(p->p_sigmask, ps->ps_catchmask[_SIG_IDX(sig)]); + if (!SIGISMEMBER(ps->ps_signodefer, sig)) + SIGADDSET(p->p_sigmask, sig); + + if (SIGISMEMBER(ps->ps_sigreset, sig)) { /* - * See setsigvec() for origin of this code. + * See do_sigaction() for origin of this code. */ - p->p_sigcatch &= ~mask; - if (signum != SIGCONT && sigprop[signum] & SA_IGNORE) - p->p_sigignore |= mask; - ps->ps_sigact[signum] = SIG_DFL; + SIGDELSET(p->p_sigcatch, sig); + if (sig != SIGCONT && + sigprop(sig) & SA_IGNORE) + SIGADDSET(p->p_sigignore, sig); + ps->ps_sigact[_SIG_IDX(sig)] = SIG_DFL; } (void) spl0(); p->p_stats->p_ru.ru_nsignals++; - if (p->p_sig != signum) { + if (p->p_sig != sig) { code = 0; } else { code = p->p_code; p->p_code = 0; p->p_sig = 0; } - (*p->p_sysent->sv_sendsig)(action, signum, returnmask, code); + (*p->p_sysent->sv_sendsig)(action, sig, &returnmask, code); } } @@ -1243,14 +1456,14 @@ killproc(p, why) * does not return. */ void -sigexit(p, signum) +sigexit(p, sig) register struct proc *p; - int signum; + int sig; { p->p_acflag |= AXSIG; - if (sigprop[signum] & SA_CORE) { - p->p_sig = signum; + if (sigprop(sig) & SA_CORE) { + p->p_sig = sig; /* * Log signals which would cause core dumps * (Log as LOG_INFO to appease those who don't want @@ -1258,16 +1471,16 @@ sigexit(p, signum) * XXX : Todo, as well as euid, write out ruid too */ if (coredump(p) == 0) - signum |= WCOREFLAG; + sig |= WCOREFLAG; if (kern_logsigexit) log(LOG_INFO, "pid %d (%s), uid %d: exited on signal %d%s\n", p->p_pid, p->p_comm, p->p_cred && p->p_ucred ? p->p_ucred->cr_uid : -1, - signum &~ WCOREFLAG, - signum & WCOREFLAG ? " (core dumped)" : ""); + sig &~ WCOREFLAG, + sig & WCOREFLAG ? " (core dumped)" : ""); } - exit1(p, W_EXITCODE(0, signum)); + exit1(p, W_EXITCODE(0, sig)); /* NOTREACHED */ } @@ -1443,9 +1656,9 @@ nosys(p, args) * stored credentials rather than those of the current process. */ void -pgsigio(sigio, signum, checkctty) +pgsigio(sigio, sig, checkctty) struct sigio *sigio; - int signum, checkctty; + int sig, checkctty; { if (sigio == NULL) return; @@ -1453,7 +1666,7 @@ pgsigio(sigio, signum, checkctty) if (sigio->sio_pgid > 0) { if (CANSIGIO(sigio->sio_ruid, sigio->sio_ucred, sigio->sio_proc)) - psignal(sigio->sio_proc, signum); + psignal(sigio->sio_proc, sig); } else if (sigio->sio_pgid < 0) { struct proc *p; @@ -1461,6 +1674,6 @@ pgsigio(sigio, signum, checkctty) p = p->p_pglist.le_next) if (CANSIGIO(sigio->sio_ruid, sigio->sio_ucred, p) && (checkctty == 0 || (p->p_flag & P_CONTROLT))) - psignal(p, signum); + psignal(p, sig); } } diff --git a/sys/kern/kern_synch.c b/sys/kern/kern_synch.c index be058da..293a75f 100644 --- a/sys/kern/kern_synch.c +++ b/sys/kern/kern_synch.c @@ -459,7 +459,7 @@ resume: if (KTRPOINT(p, KTR_CSW)) ktrcsw(p->p_tracep, 0, 0); #endif - if (p->p_sigacts->ps_sigintr & sigmask(sig)) + if (SIGISMEMBER(p->p_sigacts->ps_sigintr, sig)) return (EINTR); return (ERESTART); } @@ -599,7 +599,7 @@ resume: if (KTRPOINT(p, KTR_CSW)) ktrcsw(p->p_tracep, 0, 0); #endif - if (p->p_sigacts->ps_sigintr & sigmask(sig)) + if (SIGISMEMBER(p->p_sigacts->ps_sigintr, sig)) return (EINTR); return (ERESTART); } diff --git a/sys/kern/syscalls.c b/sys/kern/syscalls.c index 657b0e3..43fce45 100644 --- a/sys/kern/syscalls.c +++ b/sys/kern/syscalls.c @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/kern/syscalls.master,v 1.64 1999/09/11 00:45:58 alfred Exp + * created from FreeBSD: src/sys/kern/syscalls.master,v 1.65 1999/09/29 15:01:21 marcel Exp */ char *syscallnames[] = { @@ -53,13 +53,13 @@ char *syscallnames[] = { "getegid", /* 43 = getegid */ "profil", /* 44 = profil */ "ktrace", /* 45 = ktrace */ - "sigaction", /* 46 = sigaction */ + "osigaction", /* 46 = osigaction */ "getgid", /* 47 = getgid */ - "sigprocmask", /* 48 = sigprocmask */ + "osigprocmask", /* 48 = osigprocmask */ "getlogin", /* 49 = getlogin */ "setlogin", /* 50 = setlogin */ "acct", /* 51 = acct */ - "sigpending", /* 52 = sigpending */ + "osigpending", /* 52 = osigpending */ "sigaltstack", /* 53 = sigaltstack */ "ioctl", /* 54 = ioctl */ "reboot", /* 55 = reboot */ @@ -110,7 +110,7 @@ char *syscallnames[] = { "getpriority", /* 100 = getpriority */ "old.send", /* 101 = old send */ "old.recv", /* 102 = old recv */ - "sigreturn", /* 103 = sigreturn */ + "osigreturn", /* 103 = osigreturn */ "bind", /* 104 = bind */ "setsockopt", /* 105 = setsockopt */ "listen", /* 106 = listen */ @@ -118,7 +118,7 @@ char *syscallnames[] = { "old.sigvec", /* 108 = old sigvec */ "old.sigblock", /* 109 = old sigblock */ "old.sigsetmask", /* 110 = old sigsetmask */ - "sigsuspend", /* 111 = sigsuspend */ + "osigsuspend", /* 111 = osigsuspend */ "old.sigstack", /* 112 = old sigstack */ "old.recvmsg", /* 113 = old recvmsg */ "old.sendmsg", /* 114 = old sendmsg */ @@ -347,4 +347,11 @@ char *syscallnames[] = { "kldsym", /* 337 = kldsym */ "jail", /* 338 = jail */ "#339", /* 339 = pioctl */ + "sigprocmask", /* 340 = sigprocmask */ + "sigsuspend", /* 341 = sigsuspend */ + "sigaction", /* 342 = sigaction */ + "sigpending", /* 343 = sigpending */ + "sigreturn", /* 344 = sigreturn */ + "#345", /* 345 = sigtimedwait */ + "#346", /* 346 = sigwaitinfo */ }; diff --git a/sys/kern/tty.c b/sys/kern/tty.c index f311f76..7f4cd43 100644 --- a/sys/kern/tty.c +++ b/sys/kern/tty.c @@ -739,10 +739,9 @@ ttioctl(tp, cmd, data, flag) case TIOCSETP: case TIOCSLTC: #endif - while (isbackground(p, tp) && - (p->p_flag & P_PPWAIT) == 0 && - (p->p_sigignore & sigmask(SIGTTOU)) == 0 && - (p->p_sigmask & sigmask(SIGTTOU)) == 0) { + while (isbackground(p, tp) && !(p->p_flag & P_PPWAIT) && + !SIGISMEMBER(p->p_sigignore, SIGTTOU) && + !SIGISMEMBER(p->p_sigmask, SIGTTOU)) { if (p->p_pgrp->pg_jobc == 0) return (EIO); pgsignal(p->p_pgrp, SIGTTOU, 1); @@ -1448,9 +1447,9 @@ loop: */ if (isbackground(p, tp)) { splx(s); - if ((p->p_sigignore & sigmask(SIGTTIN)) || - (p->p_sigmask & sigmask(SIGTTIN)) || - p->p_flag & P_PPWAIT || p->p_pgrp->pg_jobc == 0) + if (SIGISMEMBER(p->p_sigignore, SIGTTIN) || + SIGISMEMBER(p->p_sigmask, SIGTTIN) || + (p->p_flag & P_PPWAIT) || p->p_pgrp->pg_jobc == 0) return (EIO); pgsignal(p->p_pgrp, SIGTTIN, 1); error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ttybg2", 0); @@ -1699,17 +1698,20 @@ ttycheckoutq(tp, wait) register struct tty *tp; int wait; { - int hiwat, s, oldsig; + int hiwat, s; + sigset_t oldmask; hiwat = tp->t_ohiwat; + SIGEMPTYSET(oldmask); s = spltty(); - oldsig = wait ? curproc->p_siglist : 0; + if (wait) + oldmask = curproc->p_siglist; if (tp->t_outq.c_cc > hiwat + OBUFSIZ + 100) while (tp->t_outq.c_cc > hiwat) { ttstart(tp); if (tp->t_outq.c_cc <= hiwat) break; - if (wait == 0 || curproc->p_siglist != oldsig) { + if (!(wait && SIGSETEQ(curproc->p_siglist, oldmask))) { splx(s); return (0); } @@ -1766,9 +1768,9 @@ loop: */ p = curproc; if (isbackground(p, tp) && - ISSET(tp->t_lflag, TOSTOP) && (p->p_flag & P_PPWAIT) == 0 && - (p->p_sigignore & sigmask(SIGTTOU)) == 0 && - (p->p_sigmask & sigmask(SIGTTOU)) == 0) { + ISSET(tp->t_lflag, TOSTOP) && !(p->p_flag & P_PPWAIT) && + !SIGISMEMBER(p->p_sigignore, SIGTTOU) && + !SIGISMEMBER(p->p_sigmask, SIGTTOU)) { if (p->p_pgrp->pg_jobc == 0) { error = EIO; goto out; diff --git a/sys/kern/tty_pty.c b/sys/kern/tty_pty.c index 238fdad..539ee0b 100644 --- a/sys/kern/tty_pty.c +++ b/sys/kern/tty_pty.c @@ -243,10 +243,9 @@ ptsread(dev, uio, flag) again: if (pti->pt_flags & PF_REMOTE) { while (isbackground(p, tp)) { - if ((p->p_sigignore & sigmask(SIGTTIN)) || - (p->p_sigmask & sigmask(SIGTTIN)) || - p->p_pgrp->pg_jobc == 0 || - p->p_flag & P_PPWAIT) + if (SIGISMEMBER(p->p_sigignore, SIGTTIN) || + SIGISMEMBER(p->p_sigmask, SIGTTIN) || + p->p_pgrp->pg_jobc == 0 || p->p_flag & P_PPWAIT) return (EIO); pgsignal(p->p_pgrp, SIGTTIN, 1); error = ttysleep(tp, &lbolt, TTIPRI | PCATCH, "ptsbg", diff --git a/sys/miscfs/procfs/procfs_ctl.c b/sys/miscfs/procfs/procfs_ctl.c index 4f4d84b..9a74aa3 100644 --- a/sys/miscfs/procfs/procfs_ctl.c +++ b/sys/miscfs/procfs/procfs_ctl.c @@ -192,7 +192,7 @@ procfs_control(curp, p, op) p->p_flag &= ~P_TRACED; /* remove pending SIGTRAP, else the process will die */ - p->p_siglist &= ~sigmask (SIGTRAP); + SIGDELSET(p->p_siglist, SIGTRAP); /* give process back to original parent */ if (p->p_oppid != p->p_pptr->p_pid) { diff --git a/sys/nfs/nfs.h b/sys/nfs/nfs.h index efdb607..296e34f 100644 --- a/sys/nfs/nfs.h +++ b/sys/nfs/nfs.h @@ -326,8 +326,10 @@ struct uio; struct buf; struct vattr; struct nameidata; /* XXX */ * such as SIGALRM will not expect file I/O system calls to be interrupted * by them and break. */ -#define NFSINT_SIGMASK (sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \ - sigmask(SIGHUP)|sigmask(SIGQUIT)) +#define NFSINT_SIGMASK(set) \ + (SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) || \ + SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) || \ + SIGISMEMBER(set, SIGQUIT)) /* * Socket errors ignored for connectionless sockets?? diff --git a/sys/nfs/nfs_socket.c b/sys/nfs/nfs_socket.c index 0059c51..9434fb9 100644 --- a/sys/nfs/nfs_socket.c +++ b/sys/nfs/nfs_socket.c @@ -55,6 +55,7 @@ #include <sys/syslog.h> #include <sys/tprintf.h> #include <sys/sysctl.h> +#include <sys/signalvar.h> #include <netinet/in.h> #include <netinet/tcp.h> @@ -1501,14 +1502,16 @@ nfs_sigintr(nmp, rep, p) struct nfsreq *rep; register struct proc *p; { + sigset_t tmpset; + tmpset = p->p_siglist; + SIGSETNAND(tmpset, p->p_sigmask); + SIGSETNAND(tmpset, p->p_sigignore); if (rep && (rep->r_flags & R_SOFTTERM)) return (EINTR); if (!(nmp->nm_flag & NFSMNT_INT)) return (0); - if (p && p->p_siglist && - (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) & - NFSINT_SIGMASK)) + if (p && SIGNOTEMPTY(p->p_siglist) && NFSINT_SIGMASK(tmpset)) return (EINTR); return (0); } diff --git a/sys/nfsclient/nfs.h b/sys/nfsclient/nfs.h index efdb607..296e34f 100644 --- a/sys/nfsclient/nfs.h +++ b/sys/nfsclient/nfs.h @@ -326,8 +326,10 @@ struct uio; struct buf; struct vattr; struct nameidata; /* XXX */ * such as SIGALRM will not expect file I/O system calls to be interrupted * by them and break. */ -#define NFSINT_SIGMASK (sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \ - sigmask(SIGHUP)|sigmask(SIGQUIT)) +#define NFSINT_SIGMASK(set) \ + (SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) || \ + SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) || \ + SIGISMEMBER(set, SIGQUIT)) /* * Socket errors ignored for connectionless sockets?? diff --git a/sys/nfsclient/nfs_socket.c b/sys/nfsclient/nfs_socket.c index 0059c51..9434fb9 100644 --- a/sys/nfsclient/nfs_socket.c +++ b/sys/nfsclient/nfs_socket.c @@ -55,6 +55,7 @@ #include <sys/syslog.h> #include <sys/tprintf.h> #include <sys/sysctl.h> +#include <sys/signalvar.h> #include <netinet/in.h> #include <netinet/tcp.h> @@ -1501,14 +1502,16 @@ nfs_sigintr(nmp, rep, p) struct nfsreq *rep; register struct proc *p; { + sigset_t tmpset; + tmpset = p->p_siglist; + SIGSETNAND(tmpset, p->p_sigmask); + SIGSETNAND(tmpset, p->p_sigignore); if (rep && (rep->r_flags & R_SOFTTERM)) return (EINTR); if (!(nmp->nm_flag & NFSMNT_INT)) return (0); - if (p && p->p_siglist && - (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) & - NFSINT_SIGMASK)) + if (p && SIGNOTEMPTY(p->p_siglist) && NFSINT_SIGMASK(tmpset)) return (EINTR); return (0); } diff --git a/sys/nfsclient/nfsargs.h b/sys/nfsclient/nfsargs.h index efdb607..296e34f 100644 --- a/sys/nfsclient/nfsargs.h +++ b/sys/nfsclient/nfsargs.h @@ -326,8 +326,10 @@ struct uio; struct buf; struct vattr; struct nameidata; /* XXX */ * such as SIGALRM will not expect file I/O system calls to be interrupted * by them and break. */ -#define NFSINT_SIGMASK (sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \ - sigmask(SIGHUP)|sigmask(SIGQUIT)) +#define NFSINT_SIGMASK(set) \ + (SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) || \ + SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) || \ + SIGISMEMBER(set, SIGQUIT)) /* * Socket errors ignored for connectionless sockets?? diff --git a/sys/nfsclient/nfsstats.h b/sys/nfsclient/nfsstats.h index efdb607..296e34f 100644 --- a/sys/nfsclient/nfsstats.h +++ b/sys/nfsclient/nfsstats.h @@ -326,8 +326,10 @@ struct uio; struct buf; struct vattr; struct nameidata; /* XXX */ * such as SIGALRM will not expect file I/O system calls to be interrupted * by them and break. */ -#define NFSINT_SIGMASK (sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \ - sigmask(SIGHUP)|sigmask(SIGQUIT)) +#define NFSINT_SIGMASK(set) \ + (SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) || \ + SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) || \ + SIGISMEMBER(set, SIGQUIT)) /* * Socket errors ignored for connectionless sockets?? diff --git a/sys/nfsserver/nfs.h b/sys/nfsserver/nfs.h index efdb607..296e34f 100644 --- a/sys/nfsserver/nfs.h +++ b/sys/nfsserver/nfs.h @@ -326,8 +326,10 @@ struct uio; struct buf; struct vattr; struct nameidata; /* XXX */ * such as SIGALRM will not expect file I/O system calls to be interrupted * by them and break. */ -#define NFSINT_SIGMASK (sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \ - sigmask(SIGHUP)|sigmask(SIGQUIT)) +#define NFSINT_SIGMASK(set) \ + (SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) || \ + SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) || \ + SIGISMEMBER(set, SIGQUIT)) /* * Socket errors ignored for connectionless sockets?? diff --git a/sys/nfsserver/nfs_srvsock.c b/sys/nfsserver/nfs_srvsock.c index 0059c51..9434fb9 100644 --- a/sys/nfsserver/nfs_srvsock.c +++ b/sys/nfsserver/nfs_srvsock.c @@ -55,6 +55,7 @@ #include <sys/syslog.h> #include <sys/tprintf.h> #include <sys/sysctl.h> +#include <sys/signalvar.h> #include <netinet/in.h> #include <netinet/tcp.h> @@ -1501,14 +1502,16 @@ nfs_sigintr(nmp, rep, p) struct nfsreq *rep; register struct proc *p; { + sigset_t tmpset; + tmpset = p->p_siglist; + SIGSETNAND(tmpset, p->p_sigmask); + SIGSETNAND(tmpset, p->p_sigignore); if (rep && (rep->r_flags & R_SOFTTERM)) return (EINTR); if (!(nmp->nm_flag & NFSMNT_INT)) return (0); - if (p && p->p_siglist && - (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) & - NFSINT_SIGMASK)) + if (p && SIGNOTEMPTY(p->p_siglist) && NFSINT_SIGMASK(tmpset)) return (EINTR); return (0); } diff --git a/sys/nfsserver/nfsrvstats.h b/sys/nfsserver/nfsrvstats.h index efdb607..296e34f 100644 --- a/sys/nfsserver/nfsrvstats.h +++ b/sys/nfsserver/nfsrvstats.h @@ -326,8 +326,10 @@ struct uio; struct buf; struct vattr; struct nameidata; /* XXX */ * such as SIGALRM will not expect file I/O system calls to be interrupted * by them and break. */ -#define NFSINT_SIGMASK (sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \ - sigmask(SIGHUP)|sigmask(SIGQUIT)) +#define NFSINT_SIGMASK(set) \ + (SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) || \ + SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) || \ + SIGISMEMBER(set, SIGQUIT)) /* * Socket errors ignored for connectionless sockets?? diff --git a/sys/sys/_sigset.h b/sys/sys/_sigset.h index 4a0fee8..8d1e773 100644 --- a/sys/sys/_sigset.h +++ b/sys/sys/_sigset.h @@ -44,56 +44,65 @@ #include <sys/cdefs.h> #include <sys/_posix.h> +#include <sys/types.h> #include <machine/signal.h> /* sig_atomic_t; trap codes; sigcontext */ -#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) -#define NSIG 32 /* counting 0; could be 33 (mask is 1-32) */ -#endif +/* + * sigset_t macros + */ +#define _SIG_WORDS 4 +#define _SIG_MAXSIG 128 +#define _SIG_IDX(sig) ((sig) - 1) +#define _SIG_WORD(sig) (_SIG_IDX(sig) >> 5) +#define _SIG_BIT(sig) (1 << (_SIG_IDX(sig) & 31)) -#define SIGHUP 1 /* hangup */ -#define SIGINT 2 /* interrupt */ -#define SIGQUIT 3 /* quit */ -#define SIGILL 4 /* illegal instruction (not reset when caught) */ +/* + * system defined signals + */ +#define SIGHUP 1 /* hangup */ +#define SIGINT 2 /* interrupt */ +#define SIGQUIT 3 /* quit */ +#define SIGILL 4 /* illegal instr. (not reset when caught) */ #ifndef _POSIX_SOURCE -#define SIGTRAP 5 /* trace trap (not reset when caught) */ +#define SIGTRAP 5 /* trace trap (not reset when caught) */ #endif -#define SIGABRT 6 /* abort() */ +#define SIGABRT 6 /* abort() */ #ifndef _POSIX_SOURCE -#define SIGIOT SIGABRT /* compatibility */ -#define SIGEMT 7 /* EMT instruction */ +#define SIGIOT SIGABRT /* compatibility */ +#define SIGEMT 7 /* EMT instruction */ #endif -#define SIGFPE 8 /* floating point exception */ -#define SIGKILL 9 /* kill (cannot be caught or ignored) */ +#define SIGFPE 8 /* floating point exception */ +#define SIGKILL 9 /* kill (cannot be caught or ignored) */ #ifndef _POSIX_SOURCE -#define SIGBUS 10 /* bus error */ +#define SIGBUS 10 /* bus error */ #endif -#define SIGSEGV 11 /* segmentation violation */ +#define SIGSEGV 11 /* segmentation violation */ #ifndef _POSIX_SOURCE -#define SIGSYS 12 /* non-existent system call invoked */ +#define SIGSYS 12 /* non-existent system call invoked */ #endif -#define SIGPIPE 13 /* write on a pipe with no one to read it */ -#define SIGALRM 14 /* alarm clock */ -#define SIGTERM 15 /* software termination signal from kill */ +#define SIGPIPE 13 /* write on a pipe with no one to read it */ +#define SIGALRM 14 /* alarm clock */ +#define SIGTERM 15 /* software termination signal from kill */ #ifndef _POSIX_SOURCE -#define SIGURG 16 /* urgent condition on IO channel */ +#define SIGURG 16 /* urgent condition on IO channel */ #endif -#define SIGSTOP 17 /* sendable stop signal not from tty */ -#define SIGTSTP 18 /* stop signal from tty */ -#define SIGCONT 19 /* continue a stopped process */ -#define SIGCHLD 20 /* to parent on child stop or exit */ -#define SIGTTIN 21 /* to readers pgrp upon background tty read */ -#define SIGTTOU 22 /* like TTIN for output if (tp->t_local<OSTOP) */ +#define SIGSTOP 17 /* sendable stop signal not from tty */ +#define SIGTSTP 18 /* stop signal from tty */ +#define SIGCONT 19 /* continue a stopped process */ +#define SIGCHLD 20 /* to parent on child stop or exit */ +#define SIGTTIN 21 /* to readers pgrp upon background tty read */ +#define SIGTTOU 22 /* like TTIN if (tp->t_local<OSTOP) */ #ifndef _POSIX_SOURCE -#define SIGIO 23 /* input/output possible signal */ -#define SIGXCPU 24 /* exceeded CPU time limit */ -#define SIGXFSZ 25 /* exceeded file size limit */ -#define SIGVTALRM 26 /* virtual time alarm */ -#define SIGPROF 27 /* profiling time alarm */ -#define SIGWINCH 28 /* window size changes */ -#define SIGINFO 29 /* information request */ +#define SIGIO 23 /* input/output possible signal */ +#define SIGXCPU 24 /* exceeded CPU time limit */ +#define SIGXFSZ 25 /* exceeded file size limit */ +#define SIGVTALRM 26 /* virtual time alarm */ +#define SIGPROF 27 /* profiling time alarm */ +#define SIGWINCH 28 /* window size changes */ +#define SIGINFO 29 /* information request */ #endif -#define SIGUSR1 30 /* user defined signal 1 */ -#define SIGUSR2 31 /* user defined signal 2 */ +#define SIGUSR1 30 /* user defined signal 1 */ +#define SIGUSR2 31 /* user defined signal 2 */ /*- * Type of a signal handling function. @@ -113,56 +122,41 @@ */ typedef void __sighandler_t __P((int)); -#if defined(_P1003_1B_VISIBLE_HISTORICALLY) || \ - (!defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE)) +#define SIG_DFL ((__sighandler_t *)0) +#define SIG_IGN ((__sighandler_t *)1) +#define SIG_HOLD ((__sighandler_t *)2) +#define SIG_ERR ((__sighandler_t *)-1) + union sigval { /* Members as suggested by Annex C of POSIX 1003.1b. */ - int sigval_int; - void *sigval_ptr; + int sigval_int; + void *sigval_ptr; }; -#endif /* !_ANSI_SOURCE && _P1003_1B_VISIBLE_HISTORICALLY */ - -#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) -/* POSIX 1003.1b required values. */ -#define SI_USER 0x10001 -#define SI_QUEUE 0x10002 -#define SI_TIMER 0x10003 -#define SI_ASYNCIO 0x10004 -#define SI_MESGQ 0x10005 - -/* Additional FreeBSD values. */ -#define SI_UNDEFINED 0 - -struct __siginfo { - struct sigcontext si_sc; - int si_signo; /* signal number */ +typedef struct { + int si_signo; /* signal number */ + int si_errno; /* errno association */ /* * Cause of signal, one of the SI_ macros or signal-specific * values, i.e. one of the FPE_... values for SIGFPE. This * value is equivalent to the second argument to an old-style * FreeBSD signal handler. */ - int si_code; - - union sigval si_value; -}; -#else /* ! _ANSI_SOURCE && ! _POSIX_SOURCE */ -struct __siginfo; -#endif /* ! _ANSI_SOURCE && ! _POSIX_SOURCE */ - -typedef struct __siginfo siginfo_t; - -#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) -typedef void __siginfohandler_t __P((int, siginfo_t *, void *)); -#endif /* ! _ANSI_SOURCE && ! _POSIX_SOURCE */ - -#define SIG_DFL ((__sighandler_t *)0) -#define SIG_IGN ((__sighandler_t *)1) -#define SIG_ERR ((__sighandler_t *)-1) - -#ifndef _ANSI_SOURCE -typedef unsigned int sigset_t; + int si_code; /* signal code */ + pid_t si_pid; /* sending process */ + uid_t si_uid; /* sender's ruid */ + int si_status; /* exit value */ + void *si_addr; /* faulting instruction */ + union sigval si_value; /* signal value */ + long si_band; /* band event for SIGPOLL */ + int __spare__[7]; /* gimme some slack */ +} siginfo_t; + +typedef struct { + unsigned int __bits[_SIG_WORDS]; +} sigset_t; + +#if !defined(_ANSI_SOURCE) /* * Signal vector "template" used in sigaction call. @@ -172,16 +166,19 @@ struct sigaction { void (*__sa_handler) __P((int)); void (*__sa_sigaction) __P((int, siginfo_t *, void *)); } __sigaction_u; /* signal handler */ - sigset_t sa_mask; /* signal mask to apply */ - int sa_flags; /* see signal options below */ + int sa_flags; /* see signal options below */ + sigset_t sa_mask; /* signal mask to apply */ }; + /* if SA_SIGINFO is set, sa_sigaction is to be used instead of sa_handler. */ #define sa_handler __sigaction_u.__sa_handler -#ifndef _POSIX_SOURCE + +#define SA_NOCLDSTOP 0x0008 /* do not generate SIGCHLD on child stop */ + +#if !defined(_POSIX_SOURCE) + #define sa_sigaction __sigaction_u.__sa_sigaction -#endif -#ifndef _POSIX_SOURCE #define SA_ONSTACK 0x0001 /* take signal on signal stack */ #define SA_RESTART 0x0002 /* restart system call on signal return */ #define SA_RESETHAND 0x0004 /* reset to SIG_DFL when taking signal */ @@ -191,17 +188,21 @@ struct sigaction { #ifdef COMPAT_SUNOS #define SA_USERTRAMP 0x0100 /* do not bounce off kernel's sigtramp */ #endif -#endif /* _POSIX_SOURCE */ -#define SA_NOCLDSTOP 0x0008 /* do not generate SIGCHLD on child stop */ -/* - * Flags for sigprocmask: - */ -#define SIG_BLOCK 1 /* block specified signal set */ -#define SIG_UNBLOCK 2 /* unblock specified signal set */ -#define SIG_SETMASK 3 /* set specified signal set */ +#define NSIG 32 + +/* POSIX 1003.1b required values. */ +#define SI_USER 0x10001 +#define SI_QUEUE 0x10002 +#define SI_TIMER 0x10003 +#define SI_ASYNCIO 0x10004 +#define SI_MESGQ 0x10005 + +/* Additional FreeBSD values. */ +#define SI_UNDEFINED 0 + +typedef void __siginfohandler_t __P((int, siginfo_t *, void *)); -#ifndef _POSIX_SOURCE typedef __sighandler_t *sig_t; /* type of pointer to a signal function */ #ifdef _BSD_SIZE_T_ @@ -210,26 +211,32 @@ typedef _BSD_SIZE_T_ size_t; #endif /* - * Structure used in sigaltstack call. + * sigaltstack */ -struct sigaltstack { - char *ss_sp; /* signal stack base */ - size_t ss_size; /* signal stack length */ - int ss_flags; /* SS_DISABLE and/or SS_ONSTACK */ -}; +typedef struct sigaltstack { + char *ss_sp; /* signal stack base */ + unsigned int ss_size; /* signal stack length */ + int ss_flags; /* SS_DISABLE and/or SS_ONSTACK */ +} stack_t; + #define SS_ONSTACK 0x0001 /* take signal on alternate stack */ #define SS_DISABLE 0x0004 /* disable taking signals on alternate stack */ #define MINSIGSTKSZ 8192 /* minimum allowable stack */ #define SIGSTKSZ (MINSIGSTKSZ + 32768) /* recommended stack size */ /* + * Suck in definition of ucontext_t + */ +#include <sys/ucontext.h> + +/* * 4.3 compatibility: * Signal vector "template" used in sigvec call. */ struct sigvec { - __sighandler_t *sv_handler; /* signal handler */ - int sv_mask; /* signal mask to apply */ - int sv_flags; /* see signal options below */ + __sighandler_t *sv_handler; /* signal handler */ + int sv_mask; /* signal mask to apply */ + int sv_flags; /* see signal options below */ }; #define SV_ONSTACK SA_ONSTACK @@ -244,8 +251,8 @@ struct sigvec { * Structure used in sigstack call. */ struct sigstack { - char *ss_sp; /* signal stack pointer */ - int ss_onstack; /* current status */ + char *ss_sp; /* signal stack pointer */ + int ss_onstack; /* current status */ }; /* @@ -256,21 +263,25 @@ struct sigstack { #define BADSIG SIG_ERR -#endif /* !_POSIX_SOURCE */ -#endif /* !_ANSI_SOURCE */ +#endif /* !_POSIX_SOURCE */ -#if !defined(_ANSI_SOURCE) && defined(_P1003_1B_VISIBLE_HISTORICALLY) +/* + * Flags for sigprocmask: + */ +#define SIG_BLOCK 1 /* block specified signal set */ +#define SIG_UNBLOCK 2 /* unblock specified signal set */ +#define SIG_SETMASK 3 /* set specified signal set */ struct sigevent { - int sigev_notify; /* Notification type */ - int sigev_signo; /* Signal number */ - union sigval sigev_value; /* Signal value */ + int sigev_notify; /* Notification type */ + int sigev_signo; /* Signal number */ + union sigval sigev_value; /* Signal value */ }; #define SIGEV_NONE 0 /* No async notification */ #define SIGEV_SIGNAL 1 /* Generate a queued signal */ -#endif /* ! _ANSI_SOURCE && _P1003_1B_VISIBLE_HISTORICALLY */ +#endif /* !_ANSI_SOURCE */ /* * For historical reasons; programs expect signal's return value to be diff --git a/sys/sys/ktrace.h b/sys/sys/ktrace.h index df818da..dc3e120 100644 --- a/sys/sys/ktrace.h +++ b/sys/sys/ktrace.h @@ -120,8 +120,8 @@ struct ktr_genio { struct ktr_psig { int signo; sig_t action; - int mask; int code; + sigset_t mask; }; /* @@ -159,7 +159,7 @@ struct ktr_csw { #ifdef KERNEL void ktrnamei __P((struct vnode *,char *)); void ktrcsw __P((struct vnode *,int,int)); -void ktrpsig __P((struct vnode *, int, sig_t, int, int)); +void ktrpsig __P((struct vnode *, int, sig_t, sigset_t *, int)); void ktrgenio __P((struct vnode *,int, enum uio_rw,struct iovec *,int,int)); void ktrsyscall __P((struct vnode *, int, int narg, register_t args[])); void ktrsysret __P((struct vnode *, int, int, register_t)); diff --git a/sys/sys/param.h b/sys/sys/param.h index 3ae239c..9729433 100644 --- a/sys/sys/param.h +++ b/sys/sys/param.h @@ -46,7 +46,7 @@ #define BSD4_3 1 #define BSD4_4 1 #undef __FreeBSD_version -#define __FreeBSD_version 400010 /* Master, propagated to newvers */ +#define __FreeBSD_version 400011 /* Master, propagated to newvers */ #ifndef NULL #define NULL 0 diff --git a/sys/sys/proc.h b/sys/sys/proc.h index 7885af3..99e429f 100644 --- a/sys/sys/proc.h +++ b/sys/sys/proc.h @@ -167,7 +167,7 @@ struct proc { int p_traceflag; /* Kernel trace points. */ struct vnode *p_tracep; /* Trace to vnode. */ - int p_siglist; /* Signals arrived but not delivered. */ + sigset_t p_siglist; /* Signals arrived but not delivered. */ struct vnode *p_textvp; /* Vnode of executable. */ @@ -271,6 +271,7 @@ struct proc { #define P_DEADLKTREAT 0x800000 /* lock aquisition - deadlock treatment */ #define P_JAILED 0x1000000 /* Process is in jail */ +#define P_NEWSIGSET 0x2000000 /* Process uses new sigset_t */ /* * MOVE TO ucred.h? diff --git a/sys/sys/signal.h b/sys/sys/signal.h index 4a0fee8..8d1e773 100644 --- a/sys/sys/signal.h +++ b/sys/sys/signal.h @@ -44,56 +44,65 @@ #include <sys/cdefs.h> #include <sys/_posix.h> +#include <sys/types.h> #include <machine/signal.h> /* sig_atomic_t; trap codes; sigcontext */ -#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) -#define NSIG 32 /* counting 0; could be 33 (mask is 1-32) */ -#endif +/* + * sigset_t macros + */ +#define _SIG_WORDS 4 +#define _SIG_MAXSIG 128 +#define _SIG_IDX(sig) ((sig) - 1) +#define _SIG_WORD(sig) (_SIG_IDX(sig) >> 5) +#define _SIG_BIT(sig) (1 << (_SIG_IDX(sig) & 31)) -#define SIGHUP 1 /* hangup */ -#define SIGINT 2 /* interrupt */ -#define SIGQUIT 3 /* quit */ -#define SIGILL 4 /* illegal instruction (not reset when caught) */ +/* + * system defined signals + */ +#define SIGHUP 1 /* hangup */ +#define SIGINT 2 /* interrupt */ +#define SIGQUIT 3 /* quit */ +#define SIGILL 4 /* illegal instr. (not reset when caught) */ #ifndef _POSIX_SOURCE -#define SIGTRAP 5 /* trace trap (not reset when caught) */ +#define SIGTRAP 5 /* trace trap (not reset when caught) */ #endif -#define SIGABRT 6 /* abort() */ +#define SIGABRT 6 /* abort() */ #ifndef _POSIX_SOURCE -#define SIGIOT SIGABRT /* compatibility */ -#define SIGEMT 7 /* EMT instruction */ +#define SIGIOT SIGABRT /* compatibility */ +#define SIGEMT 7 /* EMT instruction */ #endif -#define SIGFPE 8 /* floating point exception */ -#define SIGKILL 9 /* kill (cannot be caught or ignored) */ +#define SIGFPE 8 /* floating point exception */ +#define SIGKILL 9 /* kill (cannot be caught or ignored) */ #ifndef _POSIX_SOURCE -#define SIGBUS 10 /* bus error */ +#define SIGBUS 10 /* bus error */ #endif -#define SIGSEGV 11 /* segmentation violation */ +#define SIGSEGV 11 /* segmentation violation */ #ifndef _POSIX_SOURCE -#define SIGSYS 12 /* non-existent system call invoked */ +#define SIGSYS 12 /* non-existent system call invoked */ #endif -#define SIGPIPE 13 /* write on a pipe with no one to read it */ -#define SIGALRM 14 /* alarm clock */ -#define SIGTERM 15 /* software termination signal from kill */ +#define SIGPIPE 13 /* write on a pipe with no one to read it */ +#define SIGALRM 14 /* alarm clock */ +#define SIGTERM 15 /* software termination signal from kill */ #ifndef _POSIX_SOURCE -#define SIGURG 16 /* urgent condition on IO channel */ +#define SIGURG 16 /* urgent condition on IO channel */ #endif -#define SIGSTOP 17 /* sendable stop signal not from tty */ -#define SIGTSTP 18 /* stop signal from tty */ -#define SIGCONT 19 /* continue a stopped process */ -#define SIGCHLD 20 /* to parent on child stop or exit */ -#define SIGTTIN 21 /* to readers pgrp upon background tty read */ -#define SIGTTOU 22 /* like TTIN for output if (tp->t_local<OSTOP) */ +#define SIGSTOP 17 /* sendable stop signal not from tty */ +#define SIGTSTP 18 /* stop signal from tty */ +#define SIGCONT 19 /* continue a stopped process */ +#define SIGCHLD 20 /* to parent on child stop or exit */ +#define SIGTTIN 21 /* to readers pgrp upon background tty read */ +#define SIGTTOU 22 /* like TTIN if (tp->t_local<OSTOP) */ #ifndef _POSIX_SOURCE -#define SIGIO 23 /* input/output possible signal */ -#define SIGXCPU 24 /* exceeded CPU time limit */ -#define SIGXFSZ 25 /* exceeded file size limit */ -#define SIGVTALRM 26 /* virtual time alarm */ -#define SIGPROF 27 /* profiling time alarm */ -#define SIGWINCH 28 /* window size changes */ -#define SIGINFO 29 /* information request */ +#define SIGIO 23 /* input/output possible signal */ +#define SIGXCPU 24 /* exceeded CPU time limit */ +#define SIGXFSZ 25 /* exceeded file size limit */ +#define SIGVTALRM 26 /* virtual time alarm */ +#define SIGPROF 27 /* profiling time alarm */ +#define SIGWINCH 28 /* window size changes */ +#define SIGINFO 29 /* information request */ #endif -#define SIGUSR1 30 /* user defined signal 1 */ -#define SIGUSR2 31 /* user defined signal 2 */ +#define SIGUSR1 30 /* user defined signal 1 */ +#define SIGUSR2 31 /* user defined signal 2 */ /*- * Type of a signal handling function. @@ -113,56 +122,41 @@ */ typedef void __sighandler_t __P((int)); -#if defined(_P1003_1B_VISIBLE_HISTORICALLY) || \ - (!defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE)) +#define SIG_DFL ((__sighandler_t *)0) +#define SIG_IGN ((__sighandler_t *)1) +#define SIG_HOLD ((__sighandler_t *)2) +#define SIG_ERR ((__sighandler_t *)-1) + union sigval { /* Members as suggested by Annex C of POSIX 1003.1b. */ - int sigval_int; - void *sigval_ptr; + int sigval_int; + void *sigval_ptr; }; -#endif /* !_ANSI_SOURCE && _P1003_1B_VISIBLE_HISTORICALLY */ - -#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) -/* POSIX 1003.1b required values. */ -#define SI_USER 0x10001 -#define SI_QUEUE 0x10002 -#define SI_TIMER 0x10003 -#define SI_ASYNCIO 0x10004 -#define SI_MESGQ 0x10005 - -/* Additional FreeBSD values. */ -#define SI_UNDEFINED 0 - -struct __siginfo { - struct sigcontext si_sc; - int si_signo; /* signal number */ +typedef struct { + int si_signo; /* signal number */ + int si_errno; /* errno association */ /* * Cause of signal, one of the SI_ macros or signal-specific * values, i.e. one of the FPE_... values for SIGFPE. This * value is equivalent to the second argument to an old-style * FreeBSD signal handler. */ - int si_code; - - union sigval si_value; -}; -#else /* ! _ANSI_SOURCE && ! _POSIX_SOURCE */ -struct __siginfo; -#endif /* ! _ANSI_SOURCE && ! _POSIX_SOURCE */ - -typedef struct __siginfo siginfo_t; - -#if !defined(_ANSI_SOURCE) && !defined(_POSIX_SOURCE) -typedef void __siginfohandler_t __P((int, siginfo_t *, void *)); -#endif /* ! _ANSI_SOURCE && ! _POSIX_SOURCE */ - -#define SIG_DFL ((__sighandler_t *)0) -#define SIG_IGN ((__sighandler_t *)1) -#define SIG_ERR ((__sighandler_t *)-1) - -#ifndef _ANSI_SOURCE -typedef unsigned int sigset_t; + int si_code; /* signal code */ + pid_t si_pid; /* sending process */ + uid_t si_uid; /* sender's ruid */ + int si_status; /* exit value */ + void *si_addr; /* faulting instruction */ + union sigval si_value; /* signal value */ + long si_band; /* band event for SIGPOLL */ + int __spare__[7]; /* gimme some slack */ +} siginfo_t; + +typedef struct { + unsigned int __bits[_SIG_WORDS]; +} sigset_t; + +#if !defined(_ANSI_SOURCE) /* * Signal vector "template" used in sigaction call. @@ -172,16 +166,19 @@ struct sigaction { void (*__sa_handler) __P((int)); void (*__sa_sigaction) __P((int, siginfo_t *, void *)); } __sigaction_u; /* signal handler */ - sigset_t sa_mask; /* signal mask to apply */ - int sa_flags; /* see signal options below */ + int sa_flags; /* see signal options below */ + sigset_t sa_mask; /* signal mask to apply */ }; + /* if SA_SIGINFO is set, sa_sigaction is to be used instead of sa_handler. */ #define sa_handler __sigaction_u.__sa_handler -#ifndef _POSIX_SOURCE + +#define SA_NOCLDSTOP 0x0008 /* do not generate SIGCHLD on child stop */ + +#if !defined(_POSIX_SOURCE) + #define sa_sigaction __sigaction_u.__sa_sigaction -#endif -#ifndef _POSIX_SOURCE #define SA_ONSTACK 0x0001 /* take signal on signal stack */ #define SA_RESTART 0x0002 /* restart system call on signal return */ #define SA_RESETHAND 0x0004 /* reset to SIG_DFL when taking signal */ @@ -191,17 +188,21 @@ struct sigaction { #ifdef COMPAT_SUNOS #define SA_USERTRAMP 0x0100 /* do not bounce off kernel's sigtramp */ #endif -#endif /* _POSIX_SOURCE */ -#define SA_NOCLDSTOP 0x0008 /* do not generate SIGCHLD on child stop */ -/* - * Flags for sigprocmask: - */ -#define SIG_BLOCK 1 /* block specified signal set */ -#define SIG_UNBLOCK 2 /* unblock specified signal set */ -#define SIG_SETMASK 3 /* set specified signal set */ +#define NSIG 32 + +/* POSIX 1003.1b required values. */ +#define SI_USER 0x10001 +#define SI_QUEUE 0x10002 +#define SI_TIMER 0x10003 +#define SI_ASYNCIO 0x10004 +#define SI_MESGQ 0x10005 + +/* Additional FreeBSD values. */ +#define SI_UNDEFINED 0 + +typedef void __siginfohandler_t __P((int, siginfo_t *, void *)); -#ifndef _POSIX_SOURCE typedef __sighandler_t *sig_t; /* type of pointer to a signal function */ #ifdef _BSD_SIZE_T_ @@ -210,26 +211,32 @@ typedef _BSD_SIZE_T_ size_t; #endif /* - * Structure used in sigaltstack call. + * sigaltstack */ -struct sigaltstack { - char *ss_sp; /* signal stack base */ - size_t ss_size; /* signal stack length */ - int ss_flags; /* SS_DISABLE and/or SS_ONSTACK */ -}; +typedef struct sigaltstack { + char *ss_sp; /* signal stack base */ + unsigned int ss_size; /* signal stack length */ + int ss_flags; /* SS_DISABLE and/or SS_ONSTACK */ +} stack_t; + #define SS_ONSTACK 0x0001 /* take signal on alternate stack */ #define SS_DISABLE 0x0004 /* disable taking signals on alternate stack */ #define MINSIGSTKSZ 8192 /* minimum allowable stack */ #define SIGSTKSZ (MINSIGSTKSZ + 32768) /* recommended stack size */ /* + * Suck in definition of ucontext_t + */ +#include <sys/ucontext.h> + +/* * 4.3 compatibility: * Signal vector "template" used in sigvec call. */ struct sigvec { - __sighandler_t *sv_handler; /* signal handler */ - int sv_mask; /* signal mask to apply */ - int sv_flags; /* see signal options below */ + __sighandler_t *sv_handler; /* signal handler */ + int sv_mask; /* signal mask to apply */ + int sv_flags; /* see signal options below */ }; #define SV_ONSTACK SA_ONSTACK @@ -244,8 +251,8 @@ struct sigvec { * Structure used in sigstack call. */ struct sigstack { - char *ss_sp; /* signal stack pointer */ - int ss_onstack; /* current status */ + char *ss_sp; /* signal stack pointer */ + int ss_onstack; /* current status */ }; /* @@ -256,21 +263,25 @@ struct sigstack { #define BADSIG SIG_ERR -#endif /* !_POSIX_SOURCE */ -#endif /* !_ANSI_SOURCE */ +#endif /* !_POSIX_SOURCE */ -#if !defined(_ANSI_SOURCE) && defined(_P1003_1B_VISIBLE_HISTORICALLY) +/* + * Flags for sigprocmask: + */ +#define SIG_BLOCK 1 /* block specified signal set */ +#define SIG_UNBLOCK 2 /* unblock specified signal set */ +#define SIG_SETMASK 3 /* set specified signal set */ struct sigevent { - int sigev_notify; /* Notification type */ - int sigev_signo; /* Signal number */ - union sigval sigev_value; /* Signal value */ + int sigev_notify; /* Notification type */ + int sigev_signo; /* Signal number */ + union sigval sigev_value; /* Signal value */ }; #define SIGEV_NONE 0 /* No async notification */ #define SIGEV_SIGNAL 1 /* Generate a queued signal */ -#endif /* ! _ANSI_SOURCE && _P1003_1B_VISIBLE_HISTORICALLY */ +#endif /* !_ANSI_SOURCE */ /* * For historical reasons; programs expect signal's return value to be diff --git a/sys/sys/signalvar.h b/sys/sys/signalvar.h index b3da667..99b26bd 100644 --- a/sys/sys/signalvar.h +++ b/sys/sys/signalvar.h @@ -38,26 +38,29 @@ #define _SYS_SIGNALVAR_H_ #include <sys/signal.h> +#include <sys/proc.h> /* * Kernel signal definitions and data structures, * not exported to user programs. */ +int __sigisempty __P((sigset_t *set)); +int __sigseteq __P((sigset_t *set1, sigset_t *set2)); /* * Process signal actions and state, needed only within the process * (not necessarily resident). */ struct sigacts { - sig_t ps_sigact[NSIG]; /* disposition of signals */ - sigset_t ps_catchmask[NSIG]; /* signals to be blocked */ + sig_t ps_sigact[_SIG_MAXSIG]; /* disposition of signals */ + sigset_t ps_catchmask[_SIG_MAXSIG]; /* signals to be blocked */ sigset_t ps_sigonstack; /* signals to take on sigstack */ sigset_t ps_sigintr; /* signals that interrupt syscalls */ sigset_t ps_sigreset; /* signals that reset when caught */ sigset_t ps_signodefer; /* signals not masked while handled */ sigset_t ps_siginfo; /* signals that want SA_SIGINFO args */ int ps_flags; /* signal flags, below */ - struct sigaltstack ps_sigstk; /* sp & on stack state variable */ + stack_t ps_sigstk; /* sp & on stack state variable */ sigset_t ps_usertramp; /* SunOS compat; libc sigtramp XXX */ }; @@ -65,89 +68,131 @@ struct sigacts { #define SAS_OLDMASK 0x01 /* need to restore mask before pause */ #define SAS_ALTSTACK 0x02 /* have alternate signal stack */ -/* additional signal action values, used only temporarily/internally */ -#define SIG_CATCH ((__sighandler_t *)2) -#define SIG_HOLD ((__sighandler_t *)3) - /* - * get signal action for process and signal; currently only for current process + * Compatibility */ -#define SIGACTION(p, sig) (p->p_sigacts->ps_sigact[(sig)]) +typedef struct { + struct osigcontext si_sc; + int si_signo; + int si_code; + union sigval si_value; +} osiginfo_t; + +struct osigaction { + union { + void (*__sa_handler) __P((int)); + void (*__sa_sigaction) __P((int, osiginfo_t *, void *)); + } __sigaction_u; /* signal handler */ + osigset_t sa_mask; /* signal mask to apply */ + int sa_flags; /* see signal options below */ +}; + +typedef void __osiginfohandler_t __P((int, osiginfo_t *, void *)); /* - * Determine signal that should be delivered to process p, the current - * process, 0 if none. If there is a pending stop signal with default - * action, the process stops in issignal(). + * additional signal action values, used only temporarily/internally + * NOTE: SIG_HOLD was previously internal only, but has been moved to + * sys/signal.h */ -#define CURSIG(p) \ - (((p)->p_siglist == 0 || \ - (((p)->p_flag & P_TRACED) == 0 && \ - ((p)->p_siglist & ~(p)->p_sigmask) == 0)) ? \ - 0 : issignal(p)) +#define SIG_CATCH ((__sighandler_t *)3) /* - * Clear a pending signal from a process. + * get signal action for process and signal; currently only for current process */ -#define CLRSIG(p, sig) { (p)->p_siglist &= ~sigmask(sig); } +#define SIGACTION(p, sig) (p->p_sigacts->ps_sigact[_SIG_IDX(sig)]) /* - * Signal properties and actions. - * The array below categorizes the signals and their default actions - * according to the following properties: + * sigset_t manipulation macros */ -#define SA_KILL 0x01 /* terminates process by default */ -#define SA_CORE 0x02 /* ditto and coredumps */ -#define SA_STOP 0x04 /* suspend process */ -#define SA_TTYSTOP 0x08 /* ditto, from tty */ -#define SA_IGNORE 0x10 /* ignore by default */ -#define SA_CONT 0x20 /* continue if suspended */ -#define SA_CANTMASK 0x40 /* non-maskable, catchable */ - -#ifdef SIGPROP -static int sigprop[NSIG + 1] = { - 0, /* unused */ - SA_KILL, /* SIGHUP */ - SA_KILL, /* SIGINT */ - SA_KILL|SA_CORE, /* SIGQUIT */ - SA_KILL|SA_CORE, /* SIGILL */ - SA_KILL|SA_CORE, /* SIGTRAP */ - SA_KILL|SA_CORE, /* SIGABRT */ - SA_KILL|SA_CORE, /* SIGEMT */ - SA_KILL|SA_CORE, /* SIGFPE */ - SA_KILL, /* SIGKILL */ - SA_KILL|SA_CORE, /* SIGBUS */ - SA_KILL|SA_CORE, /* SIGSEGV */ - SA_KILL|SA_CORE, /* SIGSYS */ - SA_KILL, /* SIGPIPE */ - SA_KILL, /* SIGALRM */ - SA_KILL, /* SIGTERM */ - SA_IGNORE, /* SIGURG */ - SA_STOP, /* SIGSTOP */ - SA_STOP|SA_TTYSTOP, /* SIGTSTP */ - SA_IGNORE|SA_CONT, /* SIGCONT */ - SA_IGNORE, /* SIGCHLD */ - SA_STOP|SA_TTYSTOP, /* SIGTTIN */ - SA_STOP|SA_TTYSTOP, /* SIGTTOU */ - SA_IGNORE, /* SIGIO */ - SA_KILL, /* SIGXCPU */ - SA_KILL, /* SIGXFSZ */ - SA_KILL, /* SIGVTALRM */ - SA_KILL, /* SIGPROF */ - SA_IGNORE, /* SIGWINCH */ - SA_IGNORE, /* SIGINFO */ - SA_KILL, /* SIGUSR1 */ - SA_KILL, /* SIGUSR2 */ -}; - -#define contsigmask (sigmask(SIGCONT)) -#define stopsigmask (sigmask(SIGSTOP) | sigmask(SIGTSTP) | \ - sigmask(SIGTTIN) | sigmask(SIGTTOU)) - -#endif /* SIGPROP */ - -#define sigcantmask (sigmask(SIGKILL) | sigmask(SIGSTOP)) +#define SIGADDSET(set, signo) \ + (set).__bits[_SIG_WORD(signo)] |= _SIG_BIT(signo) + +#define SIGDELSET(set, signo) \ + (set).__bits[_SIG_WORD(signo)] &= ~_SIG_BIT(signo) + +#define SIGEMPTYSET(set) \ + do { \ + int __i; \ + for (__i = 0; __i < _SIG_WORDS; __i++) \ + (set).__bits[__i] = 0; \ + } while (0) + +#define SIGFILLSET(set) \ + do { \ + int __i; \ + for (__i = 0; __i < _SIG_WORDS; __i++) \ + (set).__bits[__i] = ~(unsigned int)0; \ + } while (0) + +#define SIGISMEMBER(set, signo) \ + ((set).__bits[_SIG_WORD(signo)] & _SIG_BIT(signo)) + +#define SIGISEMPTY(set) __sigisempty(&(set)) +#define SIGNOTEMPTY(set) (!__sigisempty(&(set))) + +#define SIGSETEQ(set1, set2) __sigseteq(&(set1), &(set2)) +#define SIGSETNEQ(set1, set2) (!__sigseteq(&(set1), &(set2))) + +#define SIGSETOR(set1, set2) \ + do { \ + int __i; \ + for (__i = 0; __i < _SIG_WORDS; __i++) \ + (set1).__bits[__i] |= (set2).__bits[__i]; \ + } while (0) + +#define SIGSETAND(set1, set2) \ + do { \ + int __i; \ + for (__i = 0; __i < _SIG_WORDS; __i++) \ + (set1).__bits[__i] &= (set2).__bits[__i]; \ + } while (0) + +#define SIGSETNAND(set1, set2) \ + do { \ + int __i; \ + for (__i = 0; __i < _SIG_WORDS; __i++) \ + (set1).__bits[__i] &= ~(set2).__bits[__i]; \ + } while (0) + +#define SIG_CANTMASK(set) \ + SIGDELSET(set, SIGKILL), SIGDELSET(set, SIGSTOP) + +#define SIG_STOPSIGMASK(set) \ + SIGDELSET(set, SIGSTOP), SIGDELSET(set, SIGTSTP), \ + SIGDELSET(set, SIGTTIN), SIGDELSET(set, SIGTTOU) + +#define SIG_CONTSIGMASK(set) \ + SIGDELSET(set, SIGCONT) + +#define sigcantmask (sigmask(SIGKILL) | sigmask(SIGSTOP)) + +#define SIG2OSIG(sig, osig) osig = (sig).__bits[0] +#define OSIG2SIG(osig, sig) SIGEMPTYSET(sig); (sig).__bits[0] = osig + +extern __inline int __sigisempty(sigset_t *set) +{ + int i; + + for (i = 0; i < _SIG_WORDS; i++) { + if (set->__bits[i]) + return (0); + } + return (1); +} + +extern __inline int __sigseteq(sigset_t *set1, sigset_t *set2) +{ + int i; + + for (i = 0; i < _SIG_WORDS; i++) { + if (set1->__bits[i] != set2->__bits[i]) + return (0); + } + return (1); +} #ifdef KERNEL + struct pgrp; struct proc; struct sigio; @@ -168,10 +213,37 @@ void psignal __P((struct proc *p, int sig)); void sigexit __P((struct proc *p, int signum)); void siginit __P((struct proc *p)); void trapsignal __P((struct proc *p, int sig, u_long code)); -void check_sigacts (void); +void check_sigacts __P((void)); +int __sig_ffs __P((sigset_t *set)); +int __cursig __P((struct proc *p)); + /* * Machine-dependent functions: */ -void sendsig __P((sig_t action, int sig, int returnmask, u_long code)); +void sendsig __P((sig_t action, int sig, sigset_t *retmask, u_long code)); +int md_sigreturn __P((struct proc *p, void *sigcntxp, sigset_t *mask)); + +/* + * Inline functions: + */ +#define CURSIG(p) __cursig(p) + +/* + * Determine signal that should be delivered to process p, the current + * process, 0 if none. If there is a pending stop signal with default + * action, the process stops in issignal(). + */ +extern __inline int __cursig(struct proc *p) +{ + sigset_t tmpset; + + tmpset = p->p_siglist; + SIGSETNAND(tmpset, p->p_sigmask); + return ((SIGISEMPTY(p->p_siglist) || + (!(p->p_flag & P_TRACED) && SIGISEMPTY(tmpset))) + ? 0 : issignal(p)); +} + #endif /* KERNEL */ + #endif /* !_SYS_SIGNALVAR_H_ */ diff --git a/sys/sys/syscall-hide.h b/sys/sys/syscall-hide.h index 39a35ca..2ece27a 100644 --- a/sys/sys/syscall-hide.h +++ b/sys/sys/syscall-hide.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/kern/syscalls.master,v 1.64 1999/09/11 00:45:58 alfred Exp + * created from FreeBSD: src/sys/kern/syscalls.master,v 1.65 1999/09/29 15:01:21 marcel Exp */ HIDE_POSIX(fork) @@ -49,13 +49,13 @@ HIDE_POSIX(pipe) HIDE_POSIX(getegid) HIDE_BSD(profil) HIDE_BSD(ktrace) -HIDE_POSIX(sigaction) +HIDE_POSIX(osigaction) HIDE_POSIX(getgid) -HIDE_POSIX(sigprocmask) +HIDE_POSIX(osigprocmask) HIDE_BSD(getlogin) HIDE_BSD(setlogin) HIDE_BSD(acct) -HIDE_POSIX(sigpending) +HIDE_POSIX(osigpending) HIDE_BSD(sigaltstack) HIDE_POSIX(ioctl) HIDE_BSD(reboot) @@ -102,14 +102,14 @@ HIDE_BSD(accept) HIDE_BSD(getpriority) HIDE_BSD(send) HIDE_BSD(recv) -HIDE_BSD(sigreturn) +HIDE_BSD(osigreturn) HIDE_BSD(bind) HIDE_BSD(setsockopt) HIDE_BSD(listen) HIDE_BSD(sigvec) HIDE_BSD(sigblock) HIDE_BSD(sigsetmask) -HIDE_POSIX(sigsuspend) +HIDE_POSIX(osigsuspend) HIDE_BSD(sigstack) HIDE_BSD(recvmsg) HIDE_BSD(sendmsg) @@ -257,3 +257,8 @@ HIDE_BSD(sendfile) HIDE_BSD(kldsym) HIDE_BSD(jail) HIDE_BSD(pioctl) +HIDE_POSIX(sigprocmask) +HIDE_POSIX(sigsuspend) +HIDE_POSIX(sigaction) +HIDE_POSIX(sigpending) +HIDE_BSD(sigreturn) diff --git a/sys/sys/syscall.h b/sys/sys/syscall.h index ea52b4b9..555e5e0 100644 --- a/sys/sys/syscall.h +++ b/sys/sys/syscall.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/kern/syscalls.master,v 1.64 1999/09/11 00:45:58 alfred Exp + * created from FreeBSD: src/sys/kern/syscalls.master,v 1.65 1999/09/29 15:01:21 marcel Exp */ #define SYS_syscall 0 @@ -52,13 +52,13 @@ #define SYS_getegid 43 #define SYS_profil 44 #define SYS_ktrace 45 -#define SYS_sigaction 46 +#define SYS_osigaction 46 #define SYS_getgid 47 -#define SYS_sigprocmask 48 +#define SYS_osigprocmask 48 #define SYS_getlogin 49 #define SYS_setlogin 50 #define SYS_acct 51 -#define SYS_sigpending 52 +#define SYS_osigpending 52 #define SYS_sigaltstack 53 #define SYS_ioctl 54 #define SYS_reboot 55 @@ -107,7 +107,7 @@ #define SYS_getpriority 100 /* 101 is old send */ /* 102 is old recv */ -#define SYS_sigreturn 103 +#define SYS_osigreturn 103 #define SYS_bind 104 #define SYS_setsockopt 105 #define SYS_listen 106 @@ -115,7 +115,7 @@ /* 108 is old sigvec */ /* 109 is old sigblock */ /* 110 is old sigsetmask */ -#define SYS_sigsuspend 111 +#define SYS_osigsuspend 111 /* 112 is old sigstack */ /* 113 is old recvmsg */ /* 114 is old sendmsg */ @@ -262,4 +262,9 @@ #define SYS_sendfile 336 #define SYS_kldsym 337 #define SYS_jail 338 -#define SYS_MAXSYSCALL 340 +#define SYS_sigprocmask 340 +#define SYS_sigsuspend 341 +#define SYS_sigaction 342 +#define SYS_sigpending 343 +#define SYS_sigreturn 344 +#define SYS_MAXSYSCALL 347 diff --git a/sys/sys/syscall.mk b/sys/sys/syscall.mk index 1ec08c9..abc1835 100644 --- a/sys/sys/syscall.mk +++ b/sys/sys/syscall.mk @@ -1,7 +1,7 @@ # FreeBSD system call names. # DO NOT EDIT-- this file is automatically generated. # $FreeBSD$ -# created from FreeBSD: src/sys/kern/syscalls.master,v 1.64 1999/09/11 00:45:58 alfred Exp +# created from FreeBSD: src/sys/kern/syscalls.master,v 1.65 1999/09/29 15:01:21 marcel Exp MIASM = \ syscall.o \ exit.o \ @@ -44,13 +44,13 @@ MIASM = \ getegid.o \ profil.o \ ktrace.o \ - sigaction.o \ + osigaction.o \ getgid.o \ - sigprocmask.o \ + osigprocmask.o \ getlogin.o \ setlogin.o \ acct.o \ - sigpending.o \ + osigpending.o \ sigaltstack.o \ ioctl.o \ reboot.o \ @@ -85,11 +85,11 @@ MIASM = \ socket.o \ connect.o \ getpriority.o \ - sigreturn.o \ + osigreturn.o \ bind.o \ setsockopt.o \ listen.o \ - sigsuspend.o \ + osigsuspend.o \ gettimeofday.o \ getrusage.o \ getsockopt.o \ @@ -217,4 +217,9 @@ MIASM = \ utrace.o \ sendfile.o \ kldsym.o \ - jail.o + jail.o \ + sigprocmask.o \ + sigsuspend.o \ + sigaction.o \ + sigpending.o \ + sigreturn.o diff --git a/sys/sys/sysent.h b/sys/sys/sysent.h index 9fc634c..7ff638d 100644 --- a/sys/sys/sysent.h +++ b/sys/sys/sysent.h @@ -36,6 +36,8 @@ #ifndef _SYS_SYSENT_H_ #define _SYS_SYSENT_H_ +#include <sys/signal.h> + struct proc; typedef int sy_call_t __P((struct proc *, void *)); @@ -63,7 +65,7 @@ struct sysentvec { /* translate trap-to-signal mapping */ int (*sv_fixup) __P((long **, struct image_params *)); /* stack fixup function */ - void (*sv_sendsig) __P((void (*)(int), int, int, u_long)); + void (*sv_sendsig) __P((void (*)(int), int, sigset_t *, u_long)); /* send signal */ char *sv_sigcode; /* start of sigtramp code */ int *sv_szsigcode; /* size of sigtramp code */ diff --git a/sys/sys/sysproto.h b/sys/sys/sysproto.h index 530ba1a..d80e69c 100644 --- a/sys/sys/sysproto.h +++ b/sys/sys/sysproto.h @@ -3,7 +3,7 @@ * * DO NOT EDIT-- this file is automatically generated. * $FreeBSD$ - * created from FreeBSD: src/sys/kern/syscalls.master,v 1.64 1999/09/11 00:45:58 alfred Exp + * created from FreeBSD: src/sys/kern/syscalls.master,v 1.65 1999/09/29 15:01:21 marcel Exp */ #ifndef _SYS_SYSPROTO_H_ @@ -188,17 +188,17 @@ struct ktrace_args { int facs; char facs_[PAD_(int)]; int pid; char pid_[PAD_(int)]; }; -struct sigaction_args { +struct osigaction_args { int signum; char signum_[PAD_(int)]; - struct sigaction * nsa; char nsa_[PAD_(struct sigaction *)]; - struct sigaction * osa; char osa_[PAD_(struct sigaction *)]; + struct osigaction * nsa; char nsa_[PAD_(struct osigaction *)]; + struct osigaction * osa; char osa_[PAD_(struct osigaction *)]; }; struct getgid_args { register_t dummy; }; -struct sigprocmask_args { +struct osigprocmask_args { int how; char how_[PAD_(int)]; - sigset_t mask; char mask_[PAD_(sigset_t)]; + osigset_t mask; char mask_[PAD_(osigset_t)]; }; struct getlogin_args { char * namebuf; char namebuf_[PAD_(char *)]; @@ -210,12 +210,12 @@ struct setlogin_args { struct acct_args { char * path; char path_[PAD_(char *)]; }; -struct sigpending_args { +struct osigpending_args { register_t dummy; }; struct sigaltstack_args { - struct sigaltstack * nss; char nss_[PAD_(struct sigaltstack *)]; - struct sigaltstack * oss; char oss_[PAD_(struct sigaltstack *)]; + stack_t * ss; char ss_[PAD_(stack_t *)]; + stack_t * oss; char oss_[PAD_(stack_t *)]; }; struct ioctl_args { int fd; char fd_[PAD_(int)]; @@ -358,8 +358,8 @@ struct getpriority_args { int which; char which_[PAD_(int)]; int who; char who_[PAD_(int)]; }; -struct sigreturn_args { - struct sigcontext * sigcntxp; char sigcntxp_[PAD_(struct sigcontext *)]; +struct osigreturn_args { + struct osigcontext * sigcntxp; char sigcntxp_[PAD_(struct osigcontext *)]; }; struct bind_args { int s; char s_[PAD_(int)]; @@ -377,8 +377,8 @@ struct listen_args { int s; char s_[PAD_(int)]; int backlog; char backlog_[PAD_(int)]; }; -struct sigsuspend_args { - sigset_t mask; char mask_[PAD_(sigset_t)]; +struct osigsuspend_args { + osigset_t mask; char mask_[PAD_(osigset_t)]; }; struct gettimeofday_args { struct timeval * tp; char tp_[PAD_(struct timeval *)]; @@ -923,6 +923,25 @@ struct kldsym_args { struct jail_args { struct jail * jail; char jail_[PAD_(struct jail *)]; }; +struct sigprocmask_args { + int how; char how_[PAD_(int)]; + const sigset_t * set; char set_[PAD_(const sigset_t *)]; + sigset_t * oset; char oset_[PAD_(sigset_t *)]; +}; +struct sigsuspend_args { + const sigset_t * sigmask; char sigmask_[PAD_(const sigset_t *)]; +}; +struct sigaction_args { + int sig; char sig_[PAD_(int)]; + const struct sigaction * act; char act_[PAD_(const struct sigaction *)]; + struct sigaction * oact; char oact_[PAD_(struct sigaction *)]; +}; +struct sigpending_args { + sigset_t * set; char set_[PAD_(sigset_t *)]; +}; +struct sigreturn_args { + ucontext_t * sigcntxp; char sigcntxp_[PAD_(ucontext_t *)]; +}; int nosys __P((struct proc *, struct nosys_args *)); void exit __P((struct proc *, struct rexit_args *)) __dead2; int fork __P((struct proc *, struct fork_args *)); @@ -964,13 +983,13 @@ int pipe __P((struct proc *, struct pipe_args *)); int getegid __P((struct proc *, struct getegid_args *)); int profil __P((struct proc *, struct profil_args *)); int ktrace __P((struct proc *, struct ktrace_args *)); -int sigaction __P((struct proc *, struct sigaction_args *)); +int osigaction __P((struct proc *, struct osigaction_args *)); int getgid __P((struct proc *, struct getgid_args *)); -int sigprocmask __P((struct proc *, struct sigprocmask_args *)); +int osigprocmask __P((struct proc *, struct osigprocmask_args *)); int getlogin __P((struct proc *, struct getlogin_args *)); int setlogin __P((struct proc *, struct setlogin_args *)); int acct __P((struct proc *, struct acct_args *)); -int sigpending __P((struct proc *, struct sigpending_args *)); +int osigpending __P((struct proc *, struct osigpending_args *)); int sigaltstack __P((struct proc *, struct sigaltstack_args *)); int ioctl __P((struct proc *, struct ioctl_args *)); int reboot __P((struct proc *, struct reboot_args *)); @@ -1005,11 +1024,11 @@ int setpriority __P((struct proc *, struct setpriority_args *)); int socket __P((struct proc *, struct socket_args *)); int connect __P((struct proc *, struct connect_args *)); int getpriority __P((struct proc *, struct getpriority_args *)); -int sigreturn __P((struct proc *, struct sigreturn_args *)); +int osigreturn __P((struct proc *, struct osigreturn_args *)); int bind __P((struct proc *, struct bind_args *)); int setsockopt __P((struct proc *, struct setsockopt_args *)); int listen __P((struct proc *, struct listen_args *)); -int sigsuspend __P((struct proc *, struct sigsuspend_args *)); +int osigsuspend __P((struct proc *, struct osigsuspend_args *)); int gettimeofday __P((struct proc *, struct gettimeofday_args *)); int getrusage __P((struct proc *, struct getrusage_args *)); int getsockopt __P((struct proc *, struct getsockopt_args *)); @@ -1136,6 +1155,11 @@ int utrace __P((struct proc *, struct utrace_args *)); int sendfile __P((struct proc *, struct sendfile_args *)); int kldsym __P((struct proc *, struct kldsym_args *)); int jail __P((struct proc *, struct jail_args *)); +int sigprocmask __P((struct proc *, struct sigprocmask_args *)); +int sigsuspend __P((struct proc *, struct sigsuspend_args *)); +int sigaction __P((struct proc *, struct sigaction_args *)); +int sigpending __P((struct proc *, struct sigpending_args *)); +int sigreturn __P((struct proc *, struct sigreturn_args *)); #ifdef COMPAT_43 diff --git a/sys/sys/ucontext.h b/sys/sys/ucontext.h new file mode 100644 index 0000000..fda8bcd --- /dev/null +++ b/sys/sys/ucontext.h @@ -0,0 +1,44 @@ +/*- + * Copyright (c) 1999 Marcel Moolenaar + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _SYS_UCONTEXT_H_ +#define _SYS_UCONTEXT_H_ 1 + +#include <machine/ucontext.h> + +typedef struct __ucontext { + struct __ucontext *uc_link; + stack_t uc_stack; + sigset_t uc_sigmask; + mcontext_t uc_mcontext; + int __spare__[8]; +} ucontext_t; + +#endif /* _SYS_UCONTEXT_H_ */ diff --git a/sys/ufs/mfs/mfs_vfsops.c b/sys/ufs/mfs/mfs_vfsops.c index 9188837..0355d57 100644 --- a/sys/ufs/mfs/mfs_vfsops.c +++ b/sys/ufs/mfs/mfs_vfsops.c @@ -410,7 +410,7 @@ mfs_start(mp, flags, p) register struct vnode *vp = VFSTOUFS(mp)->um_devvp; register struct mfsnode *mfsp = VTOMFS(vp); register struct buf *bp; - register int gotsig = 0; + register int gotsig = 0, sig; /* * We must prevent the system from trying to swap @@ -449,8 +449,11 @@ mfs_start(mp, flags, p) */ if (gotsig) { gotsig = 0; - if (dounmount(mp, 0, p) != 0) - CLRSIG(p, CURSIG(p)); /* try sleep again.. */ + if (dounmount(mp, 0, p) != 0) { + sig = CURSIG(p); + if (sig) + SIGDELSET(p->p_siglist, sig); + } } else if (tsleep((caddr_t)vp, mfs_pri, "mfsidl", 0)) gotsig++; /* try to unmount in next pass */ |
