URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [arch/] [sparc/] [kernel/] [signal.c] - Blame information for rev 1775

Go to most recent revision | Details | Compare with Previous | View Log


/*  $Id: signal.c,v 1.1.1.1 2001-09-10 07:44:02 simons Exp $
 *  linux/arch/sparc/kernel/signal.c
 *
 *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
 */
 
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/wait.h>
#include <linux/ptrace.h>
#include <linux/unistd.h>
#include <linux/mm.h>
 
#include <asm/segment.h>
#include <asm/bitops.h>
#include <asm/ptrace.h>
 
#define _S(nr) (1<<((nr)-1))
 
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
 
asmlinkage int sys_waitpid(pid_t pid, unsigned long *stat_addr, int options);
asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs);
 
/*
 * atomically swap in the new signal mask, and wait for a signal.
 * This is really tricky on the Sparc, watch out...
 */
asmlinkage inline void _sigpause_common(unsigned int set, struct pt_regs *regs)
{
        unsigned long mask;
 
        mask = current->blocked;
        current->blocked = set & _BLOCKABLE;
 
        /* Advance over the syscall instruction for when
         * we return.  We want setup_frame to save the proper
         * state, including the error return number & condition
         * codes.
         */
        regs->pc = regs->npc;
        regs->npc += 4;
        regs->psr |= PSR_C;
        regs->u_regs[UREG_I0] = EINTR;
 
        while (1) {
                current->state = TASK_INTERRUPTIBLE;
                schedule();
                if (do_signal(mask, regs))
                        return;
        }
}
 
asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
{
        _sigpause_common(set, regs);
}
 
asmlinkage void do_sigsuspend (struct pt_regs *regs)
{
        unsigned long mask;
        unsigned long set;
 
        set = regs->u_regs [UREG_I0];
        mask = current->blocked;
        current->blocked = set & _BLOCKABLE;
        regs->pc = regs->npc;
        regs->npc += 4;
        while (1) {
                current->state = TASK_INTERRUPTIBLE;
                schedule();
                if (do_signal(mask,regs)){
                        regs->psr |= PSR_C;
                        regs->u_regs [UREG_I0] = EINTR;
                        return;
                }
        }
}
 
asmlinkage void do_sigreturn(struct pt_regs *regs)
{
        struct sigcontext_struct *scptr =
                (struct sigcontext_struct *) regs->u_regs[UREG_I0];
 
        synchronize_user_stack();
 
        /* Check sanity of the user arg. */
        if(verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext_struct)) ||
           ((((unsigned long) scptr)) & 0x3)) {
                printk("%s [%d]: do_sigreturn, scptr is invalid at pc<%08lx> scptr<%p>\n",
                       current->comm, current->pid, regs->pc, scptr);
                do_exit(SIGSEGV);
        }
 
        if((scptr->sigc_pc | scptr->sigc_npc) & 3)
                return; /* Nice try. */
 
        current->blocked = scptr->sigc_mask & _BLOCKABLE;
        current->tss.sstk_info.cur_status = (scptr->sigc_onstack & 1);
        regs->pc = scptr->sigc_pc;
        regs->npc = scptr->sigc_npc;
        regs->u_regs[UREG_FP] = scptr->sigc_sp;
        regs->u_regs[UREG_I0] = scptr->sigc_o0;
        regs->u_regs[UREG_G1] = scptr->sigc_g1;
 
        /* User can only change condition codes in %psr. */
        regs->psr &= (~PSR_ICC);
        regs->psr |= (scptr->sigc_psr & PSR_ICC);
}
 
/*
 * Set up a signal frame... Make the stack look the way SunOS
 * expects it to look which is basically:
 *
 * ---------------------------------- <-- %sp at signal time
 * Struct sigcontext
 * Signal address
 * Ptr to sigcontext area above
 * Signal code
 * The signal number itself
 * One register window
 * ---------------------------------- <-- New %sp
 */
struct signal_sframe {
        struct reg_window sig_window;
        int sig_num;
        int sig_code;
        struct sigcontext_struct *sig_scptr;
        int sig_address;
        struct sigcontext_struct sig_context;
};
/* To align the structure properly. */
#define SF_ALIGNEDSZ  (((sizeof(struct signal_sframe) + 7) & (~7)))
 
static inline void
setup_frame(struct sigaction *sa, struct sigcontext_struct **fp,
            unsigned long pc, unsigned long npc, struct pt_regs *regs,
            int signr, unsigned long oldmask)
{
        struct signal_sframe *sframep;
        struct sigcontext_struct *sc;
        int window = 0;
        int old_status = current->tss.sstk_info.cur_status;
 
        synchronize_user_stack();
        sframep = (struct signal_sframe *) *fp;
        sframep = (struct signal_sframe *) (((unsigned long) sframep)-SF_ALIGNEDSZ);
        sc = &sframep->sig_context;
        if(verify_area(VERIFY_WRITE, sframep, sizeof(*sframep)) ||
           (((unsigned long) sframep) & 7) ||
           (((unsigned long) sframep) >= KERNBASE) ||
           ((sparc_cpu_model == sun4 || sparc_cpu_model == sun4c) &&
            ((unsigned long) sframep < 0xe0000000 && (unsigned long) sframep >= 0x20000000))) {
#if 0 /* fills up the console logs... */
                printk("%s [%d]: User has trashed signal stack\n",
                       current->comm, current->pid);
                printk("Sigstack ptr %p handler at pc<%08lx> for sig<%d>\n",
                       sframep, pc, signr);
#endif
                /* Don't change signal code and address, so that
                 * post mortem debuggers can have a look.
                 */
                current->sig->action[SIGILL-1].sa_handler = SIG_DFL;
                current->blocked &= ~(1<<(SIGILL-1));
                send_sig(SIGILL,current,1);
                return;
        }
        *fp = (struct sigcontext_struct *) sframep;
 
        sc->sigc_onstack = old_status;
        sc->sigc_mask = oldmask;
        sc->sigc_sp = regs->u_regs[UREG_FP];
        sc->sigc_pc = pc;
        sc->sigc_npc = npc;
        sc->sigc_psr = regs->psr;
        sc->sigc_g1 = regs->u_regs[UREG_G1];
        sc->sigc_o0 = regs->u_regs[UREG_I0];
        sc->sigc_oswins = current->tss.w_saved;
        if(current->tss.w_saved)
                for(window = 0; window < current->tss.w_saved; window++) {
                        sc->sigc_spbuf[window] =
                                (char *)current->tss.rwbuf_stkptrs[window];
                        memcpy(&sc->sigc_wbuf[window],
                               &current->tss.reg_window[window],
                               sizeof(struct reg_window));
                }
        else
                memcpy(sframep, (char *)regs->u_regs[UREG_FP],
                       sizeof(struct reg_window));
 
        current->tss.w_saved = 0; /* So process is allowed to execute. */
        sframep->sig_num = signr;
        if(signr == SIGSEGV ||
           signr == SIGILL ||
           signr == SIGFPE ||
           signr == SIGBUS ||
           signr == SIGEMT) {
                sframep->sig_code = current->tss.sig_desc;
                sframep->sig_address = current->tss.sig_address;
        } else {
                sframep->sig_code = 0;
                sframep->sig_address = 0;
        }
        sframep->sig_scptr = sc;
        regs->u_regs[UREG_FP] = (unsigned long) *fp;
}
 
/*
 * Note that 'init' is a special process: it doesn't get signals it doesn't
 * want to handle. Thus you cannot kill init even with a SIGKILL even by
 * mistake.
 *
 * Note that we go through the signals twice: once to check the signals that
 * the kernel can handle, and then we build all the user-level signal handling
 * stack-frames in one go after that.
 */
 
asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs)
{
        unsigned long mask = ~current->blocked;
        unsigned long handler_signal = 0;
        struct sigcontext_struct *frame = NULL;
        unsigned long pc = 0;
        unsigned long npc = 0;
        unsigned long signr;
        struct sigaction *sa;
 
        while ((signr = current->signal & mask) != 0) {
                signr = ffz(~signr);
                clear_bit(signr, &current->signal);
                sa = current->sig->action + signr;
                signr++;
                if ((current->flags & PF_PTRACED) && signr != SIGKILL) {
                        current->exit_code = signr;
                        current->state = TASK_STOPPED;
                        notify_parent(current);
                        schedule();
                        if (!(signr = current->exit_code))
                                continue;
                        current->exit_code = 0;
                        if (signr == SIGSTOP)
                                continue;
                        if (_S(signr) & current->blocked) {
                                current->signal |= _S(signr);
                                continue;
                        }
                        sa = current->sig->action + signr - 1;
                }
                if(sa->sa_handler == SIG_IGN) {
                        if(signr != SIGCHLD)
                                continue;
                        while(sys_waitpid(-1,NULL,WNOHANG) > 0);
                        continue;
                }
                if(sa->sa_handler == SIG_DFL) {
                        if(current->pid == 1)
                                continue;
                        switch(signr) {
                        case SIGCONT: case SIGCHLD: case SIGWINCH:
                                continue;
 
                        case SIGSTOP: case SIGTSTP: case SIGTTIN: case SIGTTOU:
                                current->state = TASK_STOPPED;
                                current->exit_code = signr;
                                if(!(current->p_pptr->sig->action[SIGCHLD-1].sa_flags &
                                     SA_NOCLDSTOP))
                                        notify_parent(current);
                                schedule();
                                continue;
 
                        case SIGQUIT: case SIGILL: case SIGTRAP:
                        case SIGABRT: case SIGFPE: case SIGSEGV:
                                if(current->binfmt && current->binfmt->core_dump) {
                                        if(current->binfmt->core_dump(signr, regs))
                                                signr |= 0x80;
                                }
                                /* fall through */
                        default:
                                current->signal |= _S(signr & 0x7f);
                                current->flags |= PF_SIGNALED;
                                do_exit(signr);
                        }
                }
                /* OK, we're invoking a handler. */
                if(regs->psr & PSR_C) {
                        if(regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
                           (regs->u_regs[UREG_I0] == ERESTARTSYS && !(sa->sa_flags & SA_RESTART)))
                                regs->u_regs[UREG_I0] = EINTR;
                }
                handler_signal |= 1 << (signr - 1);
                mask &= ~sa->sa_mask;
        }
        if((regs->psr & PSR_C) &&
           (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
            regs->u_regs[UREG_I0] == ERESTARTSYS ||
            regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
                /* replay the system call when we are done */
                regs->u_regs[UREG_I0] = regs->u_regs[UREG_G0];
                regs->pc -= 4;
                regs->npc -= 4;
        }
        if(!handler_signal)
                return 0;
        pc = regs->pc;
        npc = regs->npc;
        frame = (struct sigcontext_struct *) regs->u_regs[UREG_FP];
        signr = 1;
        sa = current->sig->action;
        for(mask = 1; mask; sa++, signr++, mask += mask) {
                if(mask > handler_signal)
                        break;
                if(!(mask & handler_signal))
                        continue;
                setup_frame(sa, &frame, pc, npc, regs, signr, oldmask);
                pc = (unsigned long) sa->sa_handler;
                npc = pc + 4;
                if(sa->sa_flags & SA_ONESHOT)
                        sa->sa_handler = NULL;
                current->blocked |= sa->sa_mask;
                oldmask |= sa->sa_mask;
        }
        regs->pc = pc;
        regs->npc = npc;
        return 1;
}
 
asmlinkage int
sys_sigstack(struct sigstack *ssptr, struct sigstack *ossptr)
{
        /* First see if old state is wanted. */
        if(ossptr) {
                if(verify_area(VERIFY_WRITE, ossptr, sizeof(struct sigstack)))
                        return -EFAULT;
                memcpy(ossptr, &current->tss.sstk_info, sizeof(struct sigstack));
        }
 
        /* Now see if we want to update the new state. */
        if(ssptr) {
                if(verify_area(VERIFY_READ, ssptr, sizeof(struct sigstack)))
                        return -EFAULT;
                memcpy(&current->tss.sstk_info, ssptr, sizeof(struct sigstack));
        }
        return 0;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [arch/] [sparc/] [kernel/] [signal.c] - Blame information for rev 1775

Line No.	Rev	Author	Line
1	199	simons	`/* $Id: signal.c,v 1.1.1.1 2001-09-10 07:44:02 simons Exp $`
2			`* linux/arch/sparc/kernel/signal.c`
3			`*`
4			`* Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)`
5			`*/`
6
7			`#include <linux/sched.h>`
8			`#include <linux/kernel.h>`
9			`#include <linux/signal.h>`
10			`#include <linux/errno.h>`
11			`#include <linux/wait.h>`
12			`#include <linux/ptrace.h>`
13			`#include <linux/unistd.h>`
14			`#include <linux/mm.h>`
15
16			`#include <asm/segment.h>`
17			`#include <asm/bitops.h>`
18			`#include <asm/ptrace.h>`
19
20			`#define _S(nr) (1<<((nr)-1))`
21
22			`#define _BLOCKABLE (~(_S(SIGKILL) \| _S(SIGSTOP)))`
23
24			`asmlinkage int sys_waitpid(pid_t pid, unsigned long *stat_addr, int options);`
25			`asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs);`
26
27			`/*`
28			`* atomically swap in the new signal mask, and wait for a signal.`
29			`* This is really tricky on the Sparc, watch out...`
30			`*/`
31			`asmlinkage inline void _sigpause_common(unsigned int set, struct pt_regs *regs)`
32			`{`
33			`unsigned long mask;`
34
35			`mask = current->blocked;`
36			`current->blocked = set & _BLOCKABLE;`
37
38			`/* Advance over the syscall instruction for when`
39			`* we return. We want setup_frame to save the proper`
40			`* state, including the error return number & condition`
41			`* codes.`
42			`*/`
43			`regs->pc = regs->npc;`
44			`regs->npc += 4;`
45			`regs->psr \|= PSR_C;`
46			`regs->u_regs[UREG_I0] = EINTR;`
47
48			`while (1) {`
49			`current->state = TASK_INTERRUPTIBLE;`
50			`schedule();`
51			`if (do_signal(mask, regs))`
52			`return;`
53			`}`
54			`}`
55
56			`asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)`
57			`{`
58			`_sigpause_common(set, regs);`
59			`}`
60
61			`asmlinkage void do_sigsuspend (struct pt_regs *regs)`
62			`{`
63			`unsigned long mask;`
64			`unsigned long set;`
65
66			`set = regs->u_regs [UREG_I0];`
67			`mask = current->blocked;`
68			`current->blocked = set & _BLOCKABLE;`
69			`regs->pc = regs->npc;`
70			`regs->npc += 4;`
71			`while (1) {`
72			`current->state = TASK_INTERRUPTIBLE;`
73			`schedule();`
74			`if (do_signal(mask,regs)){`
75			`regs->psr \|= PSR_C;`
76			`regs->u_regs [UREG_I0] = EINTR;`
77			`return;`
78			`}`
79			`}`
80			`}`
81
82			`asmlinkage void do_sigreturn(struct pt_regs *regs)`
83			`{`
84			`struct sigcontext_struct *scptr =`
85			`(struct sigcontext_struct *) regs->u_regs[UREG_I0];`
86
87			`synchronize_user_stack();`
88
89			`/* Check sanity of the user arg. */`
90			`if(verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext_struct)) \|\|`
91			`((((unsigned long) scptr)) & 0x3)) {`
92			`printk("%s [%d]: do_sigreturn, scptr is invalid at pc<%08lx> scptr<%p>\n",`
93			`current->comm, current->pid, regs->pc, scptr);`
94			`do_exit(SIGSEGV);`
95			`}`
96
97			`if((scptr->sigc_pc \| scptr->sigc_npc) & 3)`
98			`return; /* Nice try. */`
99
100			`current->blocked = scptr->sigc_mask & _BLOCKABLE;`
101			`current->tss.sstk_info.cur_status = (scptr->sigc_onstack & 1);`
102			`regs->pc = scptr->sigc_pc;`
103			`regs->npc = scptr->sigc_npc;`
104			`regs->u_regs[UREG_FP] = scptr->sigc_sp;`
105			`regs->u_regs[UREG_I0] = scptr->sigc_o0;`
106			`regs->u_regs[UREG_G1] = scptr->sigc_g1;`
107
108			`/* User can only change condition codes in %psr. */`
109			`regs->psr &= (~PSR_ICC);`
110			`regs->psr \|= (scptr->sigc_psr & PSR_ICC);`
111			`}`
112
113			`/*`
114			`* Set up a signal frame... Make the stack look the way SunOS`
115			`* expects it to look which is basically:`
116			`*`
117			`* ---------------------------------- <-- %sp at signal time`
118			`* Struct sigcontext`
119			`* Signal address`
120			`* Ptr to sigcontext area above`
121			`* Signal code`
122			`* The signal number itself`
123			`* One register window`
124			`* ---------------------------------- <-- New %sp`
125			`*/`
126			`struct signal_sframe {`
127			`struct reg_window sig_window;`
128			`int sig_num;`
129			`int sig_code;`
130			`struct sigcontext_struct *sig_scptr;`
131			`int sig_address;`
132			`struct sigcontext_struct sig_context;`
133			`};`
134			`/* To align the structure properly. */`
135			`#define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))`
136
137			`static inline void`
138			`setup_frame(struct sigaction sa, struct sigcontext_struct *fp,`
139			`unsigned long pc, unsigned long npc, struct pt_regs *regs,`
140			`int signr, unsigned long oldmask)`
141			`{`
142			`struct signal_sframe *sframep;`
143			`struct sigcontext_struct *sc;`
144			`int window = 0;`
145			`int old_status = current->tss.sstk_info.cur_status;`
146
147			`synchronize_user_stack();`
148			`sframep = (struct signal_sframe ) fp;`
149			`sframep = (struct signal_sframe *) (((unsigned long) sframep)-SF_ALIGNEDSZ);`
150			`sc = &sframep->sig_context;`
151			`if(verify_area(VERIFY_WRITE, sframep, sizeof(*sframep)) \|\|`
152			`(((unsigned long) sframep) & 7) \|\|`
153			`(((unsigned long) sframep) >= KERNBASE) \|\|`
154			`((sparc_cpu_model == sun4 \|\| sparc_cpu_model == sun4c) &&`
155			`((unsigned long) sframep < 0xe0000000 && (unsigned long) sframep >= 0x20000000))) {`
156			`#if 0 /* fills up the console logs... */`
157			`printk("%s [%d]: User has trashed signal stack\n",`
158			`current->comm, current->pid);`
159			`printk("Sigstack ptr %p handler at pc<%08lx> for sig<%d>\n",`
160			`sframep, pc, signr);`
161			`#endif`
162			`/* Don't change signal code and address, so that`
163			`* post mortem debuggers can have a look.`
164			`*/`
165			`current->sig->action[SIGILL-1].sa_handler = SIG_DFL;`
166			`current->blocked &= ~(1<<(SIGILL-1));`
167			`send_sig(SIGILL,current,1);`
168			`return;`
169			`}`
170			`fp = (struct sigcontext_struct ) sframep;`
171
172			`sc->sigc_onstack = old_status;`
173			`sc->sigc_mask = oldmask;`
174			`sc->sigc_sp = regs->u_regs[UREG_FP];`
175			`sc->sigc_pc = pc;`
176			`sc->sigc_npc = npc;`
177			`sc->sigc_psr = regs->psr;`
178			`sc->sigc_g1 = regs->u_regs[UREG_G1];`
179			`sc->sigc_o0 = regs->u_regs[UREG_I0];`
180			`sc->sigc_oswins = current->tss.w_saved;`
181			`if(current->tss.w_saved)`
182			`for(window = 0; window < current->tss.w_saved; window++) {`
183			`sc->sigc_spbuf[window] =`
184			`(char *)current->tss.rwbuf_stkptrs[window];`
185			`memcpy(&sc->sigc_wbuf[window],`
186			`&current->tss.reg_window[window],`
187			`sizeof(struct reg_window));`
188			`}`
189			`else`
190			`memcpy(sframep, (char *)regs->u_regs[UREG_FP],`
191			`sizeof(struct reg_window));`
192
193			`current->tss.w_saved = 0; /* So process is allowed to execute. */`
194			`sframep->sig_num = signr;`
195			`if(signr == SIGSEGV \|\|`
196			`signr == SIGILL \|\|`
197			`signr == SIGFPE \|\|`
198			`signr == SIGBUS \|\|`
199			`signr == SIGEMT) {`
200			`sframep->sig_code = current->tss.sig_desc;`
201			`sframep->sig_address = current->tss.sig_address;`
202			`} else {`
203			`sframep->sig_code = 0;`
204			`sframep->sig_address = 0;`
205			`}`
206			`sframep->sig_scptr = sc;`
207			`regs->u_regs[UREG_FP] = (unsigned long) *fp;`
208			`}`
209
210			`/*`
211			`* Note that 'init' is a special process: it doesn't get signals it doesn't`
212			`* want to handle. Thus you cannot kill init even with a SIGKILL even by`
213			`* mistake.`
214			`*`
215			`* Note that we go through the signals twice: once to check the signals that`
216			`* the kernel can handle, and then we build all the user-level signal handling`
217			`* stack-frames in one go after that.`
218			`*/`
219
220			`asmlinkage int do_signal(unsigned long oldmask, struct pt_regs * regs)`
221			`{`
222			`unsigned long mask = ~current->blocked;`
223			`unsigned long handler_signal = 0;`
224			`struct sigcontext_struct *frame = NULL;`
225			`unsigned long pc = 0;`
226			`unsigned long npc = 0;`
227			`unsigned long signr;`
228			`struct sigaction *sa;`
229
230			`while ((signr = current->signal & mask) != 0) {`
231			`signr = ffz(~signr);`
232			`clear_bit(signr, &current->signal);`
233			`sa = current->sig->action + signr;`
234			`signr++;`
235			`if ((current->flags & PF_PTRACED) && signr != SIGKILL) {`
236			`current->exit_code = signr;`
237			`current->state = TASK_STOPPED;`
238			`notify_parent(current);`
239			`schedule();`
240			`if (!(signr = current->exit_code))`
241			`continue;`
242			`current->exit_code = 0;`
243			`if (signr == SIGSTOP)`
244			`continue;`
245			`if (_S(signr) & current->blocked) {`
246			`current->signal \|= _S(signr);`
247			`continue;`
248			`}`
249			`sa = current->sig->action + signr - 1;`
250			`}`
251			`if(sa->sa_handler == SIG_IGN) {`
252			`if(signr != SIGCHLD)`
253			`continue;`
254			`while(sys_waitpid(-1,NULL,WNOHANG) > 0);`
255			`continue;`
256			`}`
257			`if(sa->sa_handler == SIG_DFL) {`
258			`if(current->pid == 1)`
259			`continue;`
260			`switch(signr) {`
261			`case SIGCONT: case SIGCHLD: case SIGWINCH:`
262			`continue;`
263
264			`case SIGSTOP: case SIGTSTP: case SIGTTIN: case SIGTTOU:`
265			`current->state = TASK_STOPPED;`
266			`current->exit_code = signr;`
267			`if(!(current->p_pptr->sig->action[SIGCHLD-1].sa_flags &`
268			`SA_NOCLDSTOP))`
269			`notify_parent(current);`
270			`schedule();`
271			`continue;`
272
273			`case SIGQUIT: case SIGILL: case SIGTRAP:`
274			`case SIGABRT: case SIGFPE: case SIGSEGV:`
275			`if(current->binfmt && current->binfmt->core_dump) {`
276			`if(current->binfmt->core_dump(signr, regs))`
277			`signr \|= 0x80;`
278			`}`
279			`/* fall through */`
280			`default:`
281			`current->signal \|= _S(signr & 0x7f);`
282			`current->flags \|= PF_SIGNALED;`
283			`do_exit(signr);`
284			`}`
285			`}`
286			`/* OK, we're invoking a handler. */`
287			`if(regs->psr & PSR_C) {`
288			`if(regs->u_regs[UREG_I0] == ERESTARTNOHAND \|\|`
289			`(regs->u_regs[UREG_I0] == ERESTARTSYS && !(sa->sa_flags & SA_RESTART)))`
290			`regs->u_regs[UREG_I0] = EINTR;`
291			`}`
292			`handler_signal \|= 1 << (signr - 1);`
293			`mask &= ~sa->sa_mask;`
294			`}`
295			`if((regs->psr & PSR_C) &&`
296			`(regs->u_regs[UREG_I0] == ERESTARTNOHAND \|\|`
297			`regs->u_regs[UREG_I0] == ERESTARTSYS \|\|`
298			`regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {`
299			`/* replay the system call when we are done */`
300			`regs->u_regs[UREG_I0] = regs->u_regs[UREG_G0];`
301			`regs->pc -= 4;`
302			`regs->npc -= 4;`
303			`}`
304			`if(!handler_signal)`
305			`return 0;`
306			`pc = regs->pc;`
307			`npc = regs->npc;`
308			`frame = (struct sigcontext_struct *) regs->u_regs[UREG_FP];`
309			`signr = 1;`
310			`sa = current->sig->action;`
311			`for(mask = 1; mask; sa++, signr++, mask += mask) {`
312			`if(mask > handler_signal)`
313			`break;`
314			`if(!(mask & handler_signal))`
315			`continue;`
316			`setup_frame(sa, &frame, pc, npc, regs, signr, oldmask);`
317			`pc = (unsigned long) sa->sa_handler;`
318			`npc = pc + 4;`
319			`if(sa->sa_flags & SA_ONESHOT)`
320			`sa->sa_handler = NULL;`
321			`current->blocked \|= sa->sa_mask;`
322			`oldmask \|= sa->sa_mask;`
323			`}`
324			`regs->pc = pc;`
325			`regs->npc = npc;`
326			`return 1;`
327			`}`
328
329			`asmlinkage int`
330			`sys_sigstack(struct sigstack ssptr, struct sigstack ossptr)`
331			`{`
332			`/* First see if old state is wanted. */`
333			`if(ossptr) {`
334			`if(verify_area(VERIFY_WRITE, ossptr, sizeof(struct sigstack)))`
335			`return -EFAULT;`
336			`memcpy(ossptr, &current->tss.sstk_info, sizeof(struct sigstack));`
337			`}`
338
339			`/* Now see if we want to update the new state. */`
340			`if(ssptr) {`
341			`if(verify_area(VERIFY_READ, ssptr, sizeof(struct sigstack)))`
342			`return -EFAULT;`
343			`memcpy(&current->tss.sstk_info, ssptr, sizeof(struct sigstack));`
344			`}`
345			`return 0;`
346			`}`