Subversion Repositories or1k

/*

 *  linux/arch/mips/kernel/signal.c

 *

 *  Copyright (C) 1991, 1992  Linus Torvalds

 */

#include <linux/sched.h>

#include <linux/mm.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 <asm/bitops.h>

#include <asm/segment.h>

#include <asm/cachectl.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.

 */

asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, unsigned long set)

{

        unsigned long mask;

        struct pt_regs * regs = (struct pt_regs *) &restart;

        mask = current->blocked;

        current->blocked = set & _BLOCKABLE;

        regs->reg2 = -EINTR;

        while (1) {

                current->state = TASK_INTERRUPTIBLE;

                schedule();

                if (do_signal(mask,regs))

                        return -EINTR;

        }

}

/*

 * This sets regs->reg29 even though we don't actually use sigstacks yet..

 */

asmlinkage int sys_sigreturn(struct pt_regs *regs)

{

        struct sigcontext_struct *context;

        /*

         * We don't support fixing ADEL/ADES exceptions for signal stack frames.

         * No big loss - who doesn't care about the alignment of this stack

         * really deserves to loose.

         */

        context = (struct sigcontext_struct *) regs->reg29;

        if (verify_area(VERIFY_READ, context, sizeof(struct sigcontext_struct)) ||

            (regs->reg29 & 3))

                goto badframe;

        current->blocked = context->sc_oldmask & _BLOCKABLE;

        regs->reg1  = context->sc_at;

        regs->reg2  = context->sc_v0;

        regs->reg3  = context->sc_v1;

        regs->reg4  = context->sc_a0;

        regs->reg5  = context->sc_a1;

        regs->reg6  = context->sc_a2;

        regs->reg7  = context->sc_a3;

        regs->reg8  = context->sc_t0;

        regs->reg9  = context->sc_t1;

        regs->reg10 = context->sc_t2;

        regs->reg11 = context->sc_t3;

        regs->reg12 = context->sc_t4;

        regs->reg13 = context->sc_t5;

        regs->reg14 = context->sc_t6;

        regs->reg15 = context->sc_t7;

        regs->reg16 = context->sc_s0;

        regs->reg17 = context->sc_s1;

        regs->reg18 = context->sc_s2;

        regs->reg19 = context->sc_s3;

        regs->reg20 = context->sc_s4;

        regs->reg21 = context->sc_s5;

        regs->reg22 = context->sc_s6;

        regs->reg23 = context->sc_s7;

        regs->reg24 = context->sc_t8;

        regs->reg25 = context->sc_t9;

        /*

         * Skip k0/k1

         */

        regs->reg28 = context->sc_gp;

        regs->reg29 = context->sc_sp;

        regs->reg30 = context->sc_fp;

        regs->reg31 = context->sc_ra;

        regs->cp0_epc = context->sc_epc;

        regs->cp0_cause = context->sc_cause;

        /*

         * disable syscall checks

         */

        regs->orig_reg2 = -1;

        return context->sc_v0;

badframe:

        do_exit(SIGSEGV);

}

/*

 * Set up a signal frame...

 *

 * This routine is somewhat complicated by the fact that if the kernel may be

 * entered by an exception other than a system call; e.g. a bus error or other

 * "bad" exception.  If this is the case, then *all* the context on the kernel

 * stack frame must be saved.

 *

 * For a large number of exceptions, the stack frame format is the same

 * as that which will be created when the process traps back to the kernel

 * when finished executing the signal handler.  In this case, nothing

 * must be done. This information is saved on the user stack and restored

 * when the signal handler is returned.

 *

 * The signal handler will be called with ra pointing to code1 (see below) and

 * one parameters in a0 (signum).

 *

 *     usp ->  [unused]                         ; first free word on stack

 *             arg save space                   ; 16 bytes argument save space

 *             code1   (addiu sp,#1-offset)     ; syscall number

 *             code2   (li v0,__NR_sigreturn)   ; syscall number

 *             code3   (syscall)                ; do sigreturn(2)

 *     #1|     at, v0, v1, a0, a1, a2, a3       ; All integer registers

 *       |     t0, t1, t2, t3, t4, t5, t6, t7   ; except zero, k0 and k1

 *       |     s0, s1, s2, s3, s4, s5, s6, s7

 *       |     t8, t9, gp, sp, fp, ra;

 *       |     epc                              ; old program counter

 *       |     cause                            ; CP0 cause register

 *       |     oldmask

 */

struct sc {

        unsigned long   ass[4];

        unsigned int    code[4];

        struct sigcontext_struct scc;

};

#define scc_offset ((size_t)&((struct sc *)0)->scc)

static void setup_frame(struct sigaction * sa, struct sc **fp,

                        unsigned long pc, struct pt_regs *regs,

                        int signr, unsigned long oldmask)

{

        struct sc *frame;

        frame = *fp;

        frame--;

        /*

         * We don't support fixing ADEL/ADES exceptions for signal stack frames.

         * No big loss - who doesn't care about the alignment of this stack

         * really deserves to loose.

         */

        if (verify_area(VERIFY_WRITE, frame, sizeof (struct sc)) ||

            ((unsigned long)frame & 3))

                do_exit(SIGSEGV);

        /*

         * Set up the return code ...

         *

         *         .set    noreorder

         *         addiu   sp,24

         *         li      v0,__NR_sigreturn

         *         syscall

         *         .set    reorder

         */

        frame->code[0] = 0x27bd0000 + scc_offset;

        frame->code[1] = 0x24020000 + __NR_sigreturn;

        frame->code[2] = 0x0000000c;

        /*

         * Flush caches so that the instructions will be correctly executed.

         */

        sys_cacheflush (frame->code, sizeof (frame->code), ICACHE);

        /*

         * Set up the "normal" sigcontext_struct

         */

        frame->scc.sc_at = regs->reg1;          /* Assembler temporary */

        frame->scc.sc_v0 = regs->reg2;          /* Result registers */

        frame->scc.sc_v1 = regs->reg3;

        frame->scc.sc_a0 = regs->reg4;          /* Argument registers */

        frame->scc.sc_a1 = regs->reg5;

        frame->scc.sc_a2 = regs->reg6;

        frame->scc.sc_a3 = regs->reg7;

        frame->scc.sc_t0 = regs->reg8;          /* Caller saved */

        frame->scc.sc_t1 = regs->reg9;

        frame->scc.sc_t2 = regs->reg10;

        frame->scc.sc_t3 = regs->reg11;

        frame->scc.sc_t4 = regs->reg12;

        frame->scc.sc_t5 = regs->reg13;

        frame->scc.sc_t6 = regs->reg14;

        frame->scc.sc_t7 = regs->reg15;

        frame->scc.sc_s0 = regs->reg16;         /* Callee saved */

        frame->scc.sc_s1 = regs->reg17;

        frame->scc.sc_s2 = regs->reg18;

        frame->scc.sc_s3 = regs->reg19;

        frame->scc.sc_s4 = regs->reg20;

        frame->scc.sc_s5 = regs->reg21;

        frame->scc.sc_s6 = regs->reg22;

        frame->scc.sc_s7 = regs->reg23;

        frame->scc.sc_t8 = regs->reg24;         /* Caller saved */

        frame->scc.sc_t9 = regs->reg25;

        /*

         * Don't copy k0/k1

         */

        frame->scc.sc_gp = regs->reg28;         /* global pointer / s8 */

        frame->scc.sc_sp = regs->reg29;         /* old stack pointer */

        frame->scc.sc_fp = regs->reg30;         /* old frame pointer */

        frame->scc.sc_ra = regs->reg31;         /* old return address */

        frame->scc.sc_epc = regs->cp0_epc;      /* Program counter */

        frame->scc.sc_cause = regs->cp0_cause;  /* c0_epc register */

        frame->scc.sc_oldmask = oldmask;

        *fp = frame;

        regs->reg4 = signr;             /* argument for handler */

}

/*

 * 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 sc *frame = NULL;

        unsigned long pc = 0;

        unsigned long signr;

        struct sigaction * sa;

        while ((signr = current->signal & mask)) {

                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;

                        /* check for SIGCHLD: it's special */

                        while (sys_waitpid(-1,NULL,WNOHANG) > 0)

                                /* nothing */;

                        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:

                                if (current->flags & PF_PTRACED)

                                        continue;

                                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 SIGIOT: case SIGFPE: case SIGSEGV: case SIGBUS:

                                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->orig_reg2 >= 0) {

                        if (regs->reg2 == -ERESTARTNOHAND ||

                           (regs->reg2 == -ERESTARTSYS &&

                            !(sa->sa_flags & SA_RESTART)))

                                regs->reg2 = -EINTR;

                }

                handler_signal |= 1 << (signr-1);

                mask &= ~sa->sa_mask;

        }

        /*

         * Who's code doesn't conform to the restartable syscall convention

         * dies here!!!  The li instruction, a single machine instruction,

         * must directly be followed by the syscall instruction.

         */

        if (regs->orig_reg2 >= 0 &&

            (regs->reg2 == -ERESTARTNOHAND ||

             regs->reg2 == -ERESTARTSYS ||

             regs->reg2 == -ERESTARTNOINTR))

        {

                regs->reg2 = regs->orig_reg2;

                regs->cp0_epc -= 8;

        }

        if (!handler_signal)            /* no handler will be called - return 0 */

                return 0;

        pc = regs->cp0_epc;

        frame = (struct sc *) regs->reg29;

        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, regs, signr, oldmask);

                pc = (unsigned long) sa->sa_handler;

                if (sa->sa_flags & SA_ONESHOT)

                        sa->sa_handler = NULL;

                current->blocked |= sa->sa_mask;

                oldmask |= sa->sa_mask;

        }

        regs->reg29 = (unsigned long) frame;            /* Stack pointer */

        regs->reg31 = (unsigned long) frame->code;      /* Return address */

        regs->cp0_epc = pc;             /* "return" to the first handler */

        return 1;

}