"final" sigvec interface?

SCCS-vsn: sys/sys/signal.h 4.2
SCCS-vsn: sys/sys/user.h 4.28
SCCS-vsn: sys/kern/kern_sig.c 5.20
SCCS-vsn: sys/kern/kern_xxx.c 4.4
SCCS-vsn: sys/vax/vax/machdep.c 4.80

diff --git a/usr/src/sys/kern/kern_sig.c b/usr/src/sys/kern/kern_sig.c
index 527252d..c5ac39f 100644 (file)
--- a/usr/src/sys/kern/kern_sig.c
+++ b/usr/src/sys/kern/kern_sig.c
@@ -1,4 +1,4 @@
-/*     kern_sig.c      5.19    83/06/02        */
+/*     kern_sig.c      5.20    83/06/09        */

 
 #include "../machine/reg.h"
 #include "../machine/pte.h"
 
 #include "../machine/reg.h"
 #include "../machine/pte.h"


@@ -23,49 +23,77 @@
 #include "../h/kernel.h"
 #include "../h/nami.h"
 
 #include "../h/kernel.h"
 #include "../h/nami.h"
 

+#define        mask(s) (1 << ((s)-1))
+#define        cantmask        (mask(SIGKILL)|mask(SIGCONT)|mask(SIGSTOP))
+

 sigvec()
 {
 sigvec()
 {

-       struct a {
+       register struct a {

                int     signo;
                int     signo;

-               int     (*sighandler)();
-               int     sigmask;
+               struct  sigvec *nsv;
+               struct  sigvec *osv;

        } *uap = (struct a  *)u.u_ap;
        } *uap = (struct a  *)u.u_ap;

+       struct sigvec vec;
+       register struct sigvec *sv;

        register int sig;
 
        sig = uap->signo;
        register int sig;
 
        sig = uap->signo;

-       if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP ||
-           (sig == SIGCONT && uap->sighandler == SIG_IGN)) {
+       if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP) {

                u.u_error = EINVAL;
                return;
        }
                u.u_error = EINVAL;
                return;
        }

-       setsignal(sig, uap->sighandler, uap->sigmask);
+       sv = &vec;
+       if (uap->osv) {
+               sv->sv_handler = u.u_signal[sig];
+               sv->sv_mask = u.u_sigmask[sig];
+               sv->sv_onstack = (u.u_sigonstack & mask(sig)) != 0;
+               u.u_error =
+                   copyout((caddr_t)sv, (caddr_t)uap->osv, sizeof (vec));
+               if (u.u_error)
+                       return;
+       }
+       if (uap->nsv) {
+               u.u_error =
+                   copyin((caddr_t)uap->nsv, (caddr_t)sv, sizeof (vec));
+               if (u.u_error)
+                       return;
+               if (sig == SIGCONT && sv->sv_handler == SIG_IGN) {
+                       u.u_error = EINVAL;
+                       return;
+               }
+               setsigvec(sig, sv);
+       }

 }
 
 }
 

-setsignal(sig, action, sigmask)
-       int sig, (*action)(), sigmask;
+setsigvec(sig, sv)
+       int sig;
+       register struct sigvec *sv;

 {
        register struct proc *p;
 {
        register struct proc *p;

-       register int mask;
+       register int bit;

 
 

-       u.u_r.r_val1 = (int)u.u_signal[sig];
-       mask = 1 << (sig - 1);
+       bit = mask(sig);

        p = u.u_procp;
        /*
         * Change setting atomically.
         */
        (void) spl6();
        p = u.u_procp;
        /*
         * Change setting atomically.
         */
        (void) spl6();

-       u.u_signal[sig] = action;
-       u.u_sigmask[sig] = sigmask;
-       if (action == SIG_IGN) {
-               p->p_sig &= ~mask;              /* never to be seen again */
-               p->p_sigignore |= mask;
-               p->p_sigcatch &= ~mask;
+       u.u_signal[sig] = sv->sv_handler;
+       u.u_sigmask[sig] = sv->sv_mask &~ cantmask;
+       if (sv->sv_onstack)
+               u.u_sigonstack |= bit;
+       else
+               u.u_sigonstack &= ~bit;
+       if (sv->sv_handler == SIG_IGN) {
+               p->p_sig &= ~bit;               /* never to be seen again */
+               p->p_sigignore |= bit;
+               p->p_sigcatch &= ~bit;

        } else {
        } else {

-               p->p_sigignore &= ~mask;
-               if (action == SIG_DFL)
-                       p->p_sigcatch &= ~mask;
+               p->p_sigignore &= ~bit;
+               if (sv->sv_handler == SIG_DFL)
+                       p->p_sigcatch &= ~bit;

                else
                else

-                       p->p_sigcatch |= mask;
+                       p->p_sigcatch |= bit;

        }
        (void) spl0();
 }
        }
        (void) spl0();
 }


@@ -73,33 +101,33 @@ setsignal(sig, action, sigmask)
 sigblock()
 {
        struct a {
 sigblock()
 {
        struct a {

-               int     mask;
+               int     sigmask;

        } *uap = (struct a *)u.u_ap;
        } *uap = (struct a *)u.u_ap;

-       struct proc *p = u.u_procp;
+       register struct proc *p = u.u_procp;

 
        (void) spl6();
        u.u_r.r_val1 = p->p_sigmask;
 
        (void) spl6();
        u.u_r.r_val1 = p->p_sigmask;

-       p->p_sigmask |= uap->mask;
+       p->p_sigmask |= uap->sigmask &~ cantmask;

        (void) spl0();
 }
 
 sigsetmask()
 {
        struct a {
        (void) spl0();
 }
 
 sigsetmask()
 {
        struct a {

-               int     mask;
+               int     sigmask;

        } *uap = (struct a *)u.u_ap;
        register struct proc *p = u.u_procp;
 
        (void) spl6();
        u.u_r.r_val1 = p->p_sigmask;
        } *uap = (struct a *)u.u_ap;
        register struct proc *p = u.u_procp;
 
        (void) spl6();
        u.u_r.r_val1 = p->p_sigmask;

-       p->p_sigmask = uap->mask;
+       p->p_sigmask = uap->sigmask &~ cantmask;

        (void) spl0();
 }
 
 sigpause()
 {
        struct a {
        (void) spl0();
 }
 
 sigpause()
 {
        struct a {

-               int     mask;
+               int     sigmask;

        } *uap = (struct a *)u.u_ap;
        register struct proc *p = u.u_procp;
 
        } *uap = (struct a *)u.u_ap;
        register struct proc *p = u.u_procp;
 


@@ -112,21 +140,35 @@ sigpause()
         */
        u.u_oldmask = p->p_sigmask;
        p->p_flag |= SOMASK;
         */
        u.u_oldmask = p->p_sigmask;
        p->p_flag |= SOMASK;

-       p->p_sigmask = uap->mask;
+       p->p_sigmask = uap->sigmask &~ cantmask;

        for (;;)
                sleep((caddr_t)&u, PSLEP);
        /*NOTREACHED*/
 }
        for (;;)
                sleep((caddr_t)&u, PSLEP);
        /*NOTREACHED*/
 }

+#undef cantmask
+#undef mask

 
 sigstack()
 {
 
 sigstack()
 {

-       struct a {
+       register struct a {

                caddr_t asp;
                caddr_t asp;

-               int     onsigstack;
+               struct  sigstack *nss;
+               struct  sigstack *oss;

        } *uap = (struct a *)u.u_ap;
        } *uap = (struct a *)u.u_ap;

+       struct sigstack ss;

 
 

-       u.u_sigstack = uap->asp;
-       u.u_onsigstack = uap->onsigstack;
+       if (uap->oss) {
+               u.u_error = copyout((caddr_t)&u.u_sigstack, (caddr_t)uap->oss, 
+                   sizeof (struct sigstack));
+               if (u.u_error)
+                       return;
+       }
+       if (uap->nss) {
+               u.u_error =
+                   copyin((caddr_t)uap->nss, (caddr_t)&ss, sizeof (ss));
+               if (u.u_error == 0)
+                       u.u_sigstack = ss;
+       }

 }
 
 kill()
 }
 
 kill()


@@ -533,6 +575,7 @@ issig()
                        case SIGCONT:
                        case SIGCHLD:
                        case SIGURG:
                        case SIGCONT:
                        case SIGCHLD:
                        case SIGURG:

+                       case SIGIO:

                                /*
                                 * These signals are normally not
                                 * sent if the action is the default.
                                /*
                                 * These signals are normally not
                                 * sent if the action is the default.


@@ -642,7 +685,7 @@ psig()
                        p->p_flag &= ~SOMASK;
                } else
                        returnmask = p->p_sigmask;
                        p->p_flag &= ~SOMASK;
                } else
                        returnmask = p->p_sigmask;

-               p->p_sigmask = u.u_sigmask[sig] | sigmask;
+               p->p_sigmask |= u.u_sigmask[sig] | sigmask;

                (void) spl0();
                u.u_ru.ru_nsignals++;
                sendsig(action, sig, returnmask);
                (void) spl0();
                u.u_ru.ru_nsignals++;
                sendsig(action, sig, returnmask);

diff --git a/usr/src/sys/kern/kern_xxx.c b/usr/src/sys/kern/kern_xxx.c
index 6466d0c..16efbab 100644 (file)
--- a/usr/src/sys/kern/kern_xxx.c
+++ b/usr/src/sys/kern/kern_xxx.c
@@ -1,4 +1,4 @@
-/*     kern_xxx.c      4.3     83/06/02        */
+/*     kern_xxx.c      4.4     83/06/09        */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -329,26 +329,32 @@ ossig()
                int     signo;
                int     (*fun)();
        } *uap = (struct a *)u.u_ap;
                int     signo;
                int     (*fun)();
        } *uap = (struct a *)u.u_ap;

-       register int a, (*f)();
+       register int a;
+       struct sigvec vec;
+       register struct sigvec *sv = &vec;

        struct proc *p = u.u_procp;
 
        struct proc *p = u.u_procp;
 

-       f = uap->fun;

        a = uap->signo;
        a = uap->signo;

+       sv->sv_handler = uap->fun;

        /*
         * Kill processes trying to use job control facilities
         * (this'll help us find any vestiges of the old stuff).
         */
        if ((a &~ 0377) ||
        /*
         * Kill processes trying to use job control facilities
         * (this'll help us find any vestiges of the old stuff).
         */
        if ((a &~ 0377) ||

-           (f != SIG_DFL && f != SIG_IGN && ((int)f) & 1)) {
+           (sv->sv_handler != SIG_DFL && sv->sv_handler != SIG_IGN &&
+            ((int)sv->sv_handler) & 1)) {

                psignal(p, SIGSYS);
                return;
        }
        if (a <= 0 || a >= NSIG || a == SIGKILL || a == SIGSTOP ||
                psignal(p, SIGSYS);
                return;
        }
        if (a <= 0 || a >= NSIG || a == SIGKILL || a == SIGSTOP ||

-           a == SIGCONT && (f == SIG_IGN || f == SIG_HOLD)) {
+           a == SIGCONT && sv->sv_handler == SIG_IGN) {

                u.u_error = EINVAL;
                return;
        }
                u.u_error = EINVAL;
                return;
        }

-       setsignal(a, f, 0);
+       sv->sv_mask = 0;
+       sv->sv_onstack = 0;
+       u.u_r.r_val1 = (int)u.u_signal[a];
+       setsigvec(a, sv);

        p->p_flag |= SOUSIG;            /* mark as simulating old stuff */
 }
 #endif
        p->p_flag |= SOUSIG;            /* mark as simulating old stuff */
 }
 #endif

diff --git a/usr/src/sys/sys/signal.h b/usr/src/sys/sys/signal.h
index 1c40635..7aed7b5 100644 (file)
--- a/usr/src/sys/sys/signal.h
+++ b/usr/src/sys/sys/signal.h
@@ -1,4 +1,4 @@
-/*     signal.h        4.1     83/06/02        */
+/*     signal.h        4.2     83/06/09        */

 
 #ifndef        NSIG
 #define NSIG   32
 
 #ifndef        NSIG
 #define NSIG   32


@@ -47,8 +47,26 @@
 
 #ifndef KERNEL
 int    (*signal())();
 
 #ifndef KERNEL
 int    (*signal())();

+int    (*sigvec())();

 #endif
 
 #endif
 

+/*
+ * Signal vector "template" used in sigvec call.
+ */
+struct sigvec {
+       int     (*sv_handler)();        /* signal handler */
+       int     sv_mask;                /* signal mask to apply */
+       int     sv_onstack;             /* if non-zero, take on signal stack */
+};
+
+/*
+ * Structure used in sigstack call.
+ */
+struct sigstack {
+       char    *ss_sp;                 /* signal stack pointer */
+       int     ss_onstack;             /* current status */
+};
+

 /*
  * Information pushed on stack when a signal is delivered.
  * This is used by the kernel to restore state following
 /*
  * Information pushed on stack when a signal is delivered.
  * This is used by the kernel to restore state following

diff --git a/usr/src/sys/sys/user.h b/usr/src/sys/sys/user.h
index 9c58a19..3835077 100644 (file)
--- a/usr/src/sys/sys/user.h
+++ b/usr/src/sys/sys/user.h
@@ -1,14 +1,17 @@
-/*     user.h  4.27    83/06/02        */
+/*     user.h  4.28    83/06/09        */

 
 #ifdef KERNEL
 #include "../machine/pcb.h"
 #include "../h/dmap.h"
 
 #ifdef KERNEL
 #include "../machine/pcb.h"
 #include "../h/dmap.h"

+#include "../h/time.h"
+#include "../h/resource.h"

 #else
 #include <machine/pcb.h>
 #include <sys/dmap.h>
 #else
 #include <machine/pcb.h>
 #include <sys/dmap.h>

-#endif

 #include <time.h>
 #include <resource.h>
 #include <time.h>
 #include <resource.h>

+#endif
+

 /*
  * Per process structure containing data that
  * isn't needed in core when the process is swapped out.
 /*
  * Per process structure containing data that
  * isn't needed in core when the process is swapped out.


@@ -62,10 +65,12 @@ struct      user {
 /* 1.3 - signal management */
        int     (*u_signal[NSIG])();    /* disposition of signals */
        int     u_sigmask[NSIG];        /* signals to be blocked */
 /* 1.3 - signal management */
        int     (*u_signal[NSIG])();    /* disposition of signals */
        int     u_sigmask[NSIG];        /* signals to be blocked */

+       int     u_sigonstack;           /* signals to take on sigstack */

        int     u_oldmask;              /* saved mask from before sigpause */
        int     u_code;                 /* ``code'' to trap */
        int     u_oldmask;              /* saved mask from before sigpause */
        int     u_code;                 /* ``code'' to trap */

-       caddr_t u_sigstack;             /* 0 means no sigstack */
-       int     u_onsigstack;
+       struct  sigstack u_sigstack;    /* sp & on stack state variable */
+#define        u_onstack       u_sigstack.ss_onstack
+#define        u_sigsp         u_sigstack.ss_sp

 
 /* 1.4 - descriptor management */
        struct  file *u_ofile[NOFILE];  /* file structures for open files */
 
 /* 1.4 - descriptor management */
        struct  file *u_ofile[NOFILE];  /* file structures for open files */

diff --git a/usr/src/sys/vax/vax/machdep.c b/usr/src/sys/vax/vax/machdep.c
index 675eedd..ff7b9af 100644 (file)
--- a/usr/src/sys/vax/vax/machdep.c
+++ b/usr/src/sys/vax/vax/machdep.c
@@ -1,4 +1,4 @@
-/*     machdep.c       4.79    83/06/02        */
+/*     machdep.c       4.80    83/06/09        */

 
 #include "../machine/reg.h"
 #include "../machine/pte.h"
 
 #include "../machine/reg.h"
 #include "../machine/pte.h"


@@ -253,21 +253,22 @@ vmtime(otime, olbolt, oicr)
  * onsigstack, it returns to user who then
  * unwinds with the rei at the bottom of sigcode.
  */
  * onsigstack, it returns to user who then
  * unwinds with the rei at the bottom of sigcode.
  */

-sendsig(p, sig, mask)
-       int (*p)(), sig, mask;
+sendsig(p, sig, sigmask)
+       int (*p)(), sig, sigmask;

 {
        register int *usp, *regs;
 {
        register int *usp, *regs;

-       int oonsigstack;
+       int oonstack;

 
        regs = u.u_ar0;
 
        regs = u.u_ar0;

-       oonsigstack = u.u_onsigstack;
-       if (!u.u_onsigstack && u.u_sigstack) {
-               usp = (int *)u.u_sigstack;
-               u.u_onsigstack = 1;
+       oonstack = u.u_onstack;
+#define        mask(s) (1<<((s)-1))
+       if (!u.u_onstack && (u.u_sigonstack & mask(sig))) {
+               usp = (int *)u.u_sigsp;
+               u.u_onstack = 1;

        } else
                usp = (int *)regs[SP];
        usp -= 8;
        } else
                usp = (int *)regs[SP];
        usp -= 8;

-       if ((int)usp <= USRSTACK - ctob(u.u_ssize))
+       if (!u.u_onstack && (int)usp <= USRSTACK - ctob(u.u_ssize))

                (void) grow((unsigned)usp);
        ;                       /* Avoid asm() label botch */
 #ifndef lint
                (void) grow((unsigned)usp);
        ;                       /* Avoid asm() label botch */
 #ifndef lint


@@ -286,8 +287,8 @@ sendsig(p, sig, mask)
        *usp++ = (int)(usp + 2);
        *usp++ = (int)p;
        /* struct sigcontext used for the inward return */
        *usp++ = (int)(usp + 2);
        *usp++ = (int)p;
        /* struct sigcontext used for the inward return */

-       *usp++ = oonsigstack;
-       *usp++ = mask;
+       *usp++ = oonstack;
+       *usp++ = sigmask;

        *usp++ = regs[PC];
        *usp++ = regs[PS];
        regs[SP] = (int)(usp - 8);
        *usp++ = regs[PC];
        *usp++ = regs[PS];
        regs[SP] = (int)(usp - 8);


@@ -302,7 +303,7 @@ bad:
         * instruction to halt it in its tracks.
         */
        u.u_signal[SIGILL] = SIG_DFL;
         * instruction to halt it in its tracks.
         */
        u.u_signal[SIGILL] = SIG_DFL;

-       sig = 1 << (SIGILL - 1);
+       sig = mask(SIGILL);

        u.u_procp->p_sigignore &= ~sig;
        u.u_procp->p_sigcatch &= ~sig;
        u.u_procp->p_sigmask &= ~sig;
        u.u_procp->p_sigignore &= ~sig;
        u.u_procp->p_sigcatch &= ~sig;
        u.u_procp->p_sigmask &= ~sig;


@@ -328,10 +329,12 @@ sigcleanup()
        if (useracc((caddr_t)usp, 8, 0))
                return;
 #endif
        if (useracc((caddr_t)usp, 8, 0))
                return;
 #endif

-       u.u_onsigstack = *usp++ & 01;
-       u.u_procp->p_sigmask = *usp++;
+       u.u_onstack = *usp++ & 01;
+       u.u_procp->p_sigmask =
+           *usp++ &~ (mask(SIGKILL)|mask(SIGCONT)|mask(SIGSTOP));

        u.u_ar0[SP] = (int)usp;
 }
        u.u_ar0[SP] = (int)usp;
 }

+#undef mask

 
 #ifdef notdef
 dorti()
 
 #ifdef notdef
 dorti()