Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  linux/arch/alpha/kernel/signal.c
0004  *
0005  *  Copyright (C) 1995  Linus Torvalds
0006  *
0007  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
0008  */
0009 
0010 #include <linux/sched/signal.h>
0011 #include <linux/sched/task_stack.h>
0012 #include <linux/kernel.h>
0013 #include <linux/signal.h>
0014 #include <linux/errno.h>
0015 #include <linux/wait.h>
0016 #include <linux/ptrace.h>
0017 #include <linux/unistd.h>
0018 #include <linux/mm.h>
0019 #include <linux/smp.h>
0020 #include <linux/stddef.h>
0021 #include <linux/tty.h>
0022 #include <linux/binfmts.h>
0023 #include <linux/bitops.h>
0024 #include <linux/syscalls.h>
0025 #include <linux/resume_user_mode.h>
0026 
0027 #include <linux/uaccess.h>
0028 #include <asm/sigcontext.h>
0029 #include <asm/ucontext.h>
0030 
0031 #include "proto.h"
0032 
0033 
0034 #define DEBUG_SIG 0
0035 
0036 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
0037 
0038 asmlinkage void ret_from_sys_call(void);
0039 
0040 /*
0041  * The OSF/1 sigprocmask calling sequence is different from the
0042  * C sigprocmask() sequence..
0043  */
0044 SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask)
0045 {
0046     sigset_t oldmask;
0047     sigset_t mask;
0048     unsigned long res;
0049 
0050     siginitset(&mask, newmask & _BLOCKABLE);
0051     res = sigprocmask(how, &mask, &oldmask);
0052     if (!res) {
0053         force_successful_syscall_return();
0054         res = oldmask.sig[0];
0055     }
0056     return res;
0057 }
0058 
0059 SYSCALL_DEFINE3(osf_sigaction, int, sig,
0060         const struct osf_sigaction __user *, act,
0061         struct osf_sigaction __user *, oact)
0062 {
0063     struct k_sigaction new_ka, old_ka;
0064     int ret;
0065 
0066     if (act) {
0067         old_sigset_t mask;
0068         if (!access_ok(act, sizeof(*act)) ||
0069             __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
0070             __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
0071             __get_user(mask, &act->sa_mask))
0072             return -EFAULT;
0073         siginitset(&new_ka.sa.sa_mask, mask);
0074         new_ka.ka_restorer = NULL;
0075     }
0076 
0077     ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
0078 
0079     if (!ret && oact) {
0080         if (!access_ok(oact, sizeof(*oact)) ||
0081             __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
0082             __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
0083             __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
0084             return -EFAULT;
0085     }
0086 
0087     return ret;
0088 }
0089 
0090 SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
0091         struct sigaction __user *, oact,
0092         size_t, sigsetsize, void __user *, restorer)
0093 {
0094     struct k_sigaction new_ka, old_ka;
0095     int ret;
0096 
0097     /* XXX: Don't preclude handling different sized sigset_t's.  */
0098     if (sigsetsize != sizeof(sigset_t))
0099         return -EINVAL;
0100 
0101     if (act) {
0102         new_ka.ka_restorer = restorer;
0103         if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
0104             return -EFAULT;
0105     }
0106 
0107     ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
0108 
0109     if (!ret && oact) {
0110         if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
0111             return -EFAULT;
0112     }
0113 
0114     return ret;
0115 }
0116 
0117 /*
0118  * Do a signal return; undo the signal stack.
0119  */
0120 
0121 #if _NSIG_WORDS > 1
0122 # error "Non SA_SIGINFO frame needs rearranging"
0123 #endif
0124 
0125 struct sigframe
0126 {
0127     struct sigcontext sc;
0128     unsigned int retcode[3];
0129 };
0130 
0131 struct rt_sigframe
0132 {
0133     struct siginfo info;
0134     struct ucontext uc;
0135     unsigned int retcode[3];
0136 };
0137 
0138 /* If this changes, userland unwinders that Know Things about our signal
0139    frame will break.  Do not undertake lightly.  It also implies an ABI
0140    change wrt the size of siginfo_t, which may cause some pain.  */
0141 extern char compile_time_assert
0142         [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
0143 
0144 #define INSN_MOV_R30_R16    0x47fe0410
0145 #define INSN_LDI_R0     0x201f0000
0146 #define INSN_CALLSYS        0x00000083
0147 
0148 static long
0149 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
0150 {
0151     unsigned long usp;
0152     struct switch_stack *sw = (struct switch_stack *)regs - 1;
0153     long i, err = __get_user(regs->pc, &sc->sc_pc);
0154 
0155     current->restart_block.fn = do_no_restart_syscall;
0156 
0157     sw->r26 = (unsigned long) ret_from_sys_call;
0158 
0159     err |= __get_user(regs->r0, sc->sc_regs+0);
0160     err |= __get_user(regs->r1, sc->sc_regs+1);
0161     err |= __get_user(regs->r2, sc->sc_regs+2);
0162     err |= __get_user(regs->r3, sc->sc_regs+3);
0163     err |= __get_user(regs->r4, sc->sc_regs+4);
0164     err |= __get_user(regs->r5, sc->sc_regs+5);
0165     err |= __get_user(regs->r6, sc->sc_regs+6);
0166     err |= __get_user(regs->r7, sc->sc_regs+7);
0167     err |= __get_user(regs->r8, sc->sc_regs+8);
0168     err |= __get_user(sw->r9, sc->sc_regs+9);
0169     err |= __get_user(sw->r10, sc->sc_regs+10);
0170     err |= __get_user(sw->r11, sc->sc_regs+11);
0171     err |= __get_user(sw->r12, sc->sc_regs+12);
0172     err |= __get_user(sw->r13, sc->sc_regs+13);
0173     err |= __get_user(sw->r14, sc->sc_regs+14);
0174     err |= __get_user(sw->r15, sc->sc_regs+15);
0175     err |= __get_user(regs->r16, sc->sc_regs+16);
0176     err |= __get_user(regs->r17, sc->sc_regs+17);
0177     err |= __get_user(regs->r18, sc->sc_regs+18);
0178     err |= __get_user(regs->r19, sc->sc_regs+19);
0179     err |= __get_user(regs->r20, sc->sc_regs+20);
0180     err |= __get_user(regs->r21, sc->sc_regs+21);
0181     err |= __get_user(regs->r22, sc->sc_regs+22);
0182     err |= __get_user(regs->r23, sc->sc_regs+23);
0183     err |= __get_user(regs->r24, sc->sc_regs+24);
0184     err |= __get_user(regs->r25, sc->sc_regs+25);
0185     err |= __get_user(regs->r26, sc->sc_regs+26);
0186     err |= __get_user(regs->r27, sc->sc_regs+27);
0187     err |= __get_user(regs->r28, sc->sc_regs+28);
0188     err |= __get_user(regs->gp, sc->sc_regs+29);
0189     err |= __get_user(usp, sc->sc_regs+30);
0190     wrusp(usp);
0191 
0192     for (i = 0; i < 31; i++)
0193         err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
0194     err |= __get_user(sw->fp[31], &sc->sc_fpcr);
0195 
0196     return err;
0197 }
0198 
0199 /* Note that this syscall is also used by setcontext(3) to install
0200    a given sigcontext.  This because it's impossible to set *all*
0201    registers and transfer control from userland.  */
0202 
0203 asmlinkage void
0204 do_sigreturn(struct sigcontext __user *sc)
0205 {
0206     struct pt_regs *regs = current_pt_regs();
0207     sigset_t set;
0208 
0209     /* Verify that it's a good sigcontext before using it */
0210     if (!access_ok(sc, sizeof(*sc)))
0211         goto give_sigsegv;
0212     if (__get_user(set.sig[0], &sc->sc_mask))
0213         goto give_sigsegv;
0214 
0215     set_current_blocked(&set);
0216 
0217     if (restore_sigcontext(sc, regs))
0218         goto give_sigsegv;
0219 
0220     /* Send SIGTRAP if we're single-stepping: */
0221     if (ptrace_cancel_bpt (current)) {
0222         send_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *) regs->pc,
0223                    current);
0224     }
0225     return;
0226 
0227 give_sigsegv:
0228     force_sig(SIGSEGV);
0229 }
0230 
0231 asmlinkage void
0232 do_rt_sigreturn(struct rt_sigframe __user *frame)
0233 {
0234     struct pt_regs *regs = current_pt_regs();
0235     sigset_t set;
0236 
0237     /* Verify that it's a good ucontext_t before using it */
0238     if (!access_ok(&frame->uc, sizeof(frame->uc)))
0239         goto give_sigsegv;
0240     if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
0241         goto give_sigsegv;
0242 
0243     set_current_blocked(&set);
0244 
0245     if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
0246         goto give_sigsegv;
0247 
0248     /* Send SIGTRAP if we're single-stepping: */
0249     if (ptrace_cancel_bpt (current)) {
0250         send_sig_fault(SIGTRAP, TRAP_BRKPT, (void __user *) regs->pc,
0251                    current);
0252     }
0253     return;
0254 
0255 give_sigsegv:
0256     force_sig(SIGSEGV);
0257 }
0258 
0259 
0260 /*
0261  * Set up a signal frame.
0262  */
0263 
0264 static inline void __user *
0265 get_sigframe(struct ksignal *ksig, unsigned long sp, size_t frame_size)
0266 {
0267     return (void __user *)((sigsp(sp, ksig) - frame_size) & -32ul);
0268 }
0269 
0270 static long
0271 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 
0272          unsigned long mask, unsigned long sp)
0273 {
0274     struct switch_stack *sw = (struct switch_stack *)regs - 1;
0275     long i, err = 0;
0276 
0277     err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
0278     err |= __put_user(mask, &sc->sc_mask);
0279     err |= __put_user(regs->pc, &sc->sc_pc);
0280     err |= __put_user(8, &sc->sc_ps);
0281 
0282     err |= __put_user(regs->r0 , sc->sc_regs+0);
0283     err |= __put_user(regs->r1 , sc->sc_regs+1);
0284     err |= __put_user(regs->r2 , sc->sc_regs+2);
0285     err |= __put_user(regs->r3 , sc->sc_regs+3);
0286     err |= __put_user(regs->r4 , sc->sc_regs+4);
0287     err |= __put_user(regs->r5 , sc->sc_regs+5);
0288     err |= __put_user(regs->r6 , sc->sc_regs+6);
0289     err |= __put_user(regs->r7 , sc->sc_regs+7);
0290     err |= __put_user(regs->r8 , sc->sc_regs+8);
0291     err |= __put_user(sw->r9   , sc->sc_regs+9);
0292     err |= __put_user(sw->r10  , sc->sc_regs+10);
0293     err |= __put_user(sw->r11  , sc->sc_regs+11);
0294     err |= __put_user(sw->r12  , sc->sc_regs+12);
0295     err |= __put_user(sw->r13  , sc->sc_regs+13);
0296     err |= __put_user(sw->r14  , sc->sc_regs+14);
0297     err |= __put_user(sw->r15  , sc->sc_regs+15);
0298     err |= __put_user(regs->r16, sc->sc_regs+16);
0299     err |= __put_user(regs->r17, sc->sc_regs+17);
0300     err |= __put_user(regs->r18, sc->sc_regs+18);
0301     err |= __put_user(regs->r19, sc->sc_regs+19);
0302     err |= __put_user(regs->r20, sc->sc_regs+20);
0303     err |= __put_user(regs->r21, sc->sc_regs+21);
0304     err |= __put_user(regs->r22, sc->sc_regs+22);
0305     err |= __put_user(regs->r23, sc->sc_regs+23);
0306     err |= __put_user(regs->r24, sc->sc_regs+24);
0307     err |= __put_user(regs->r25, sc->sc_regs+25);
0308     err |= __put_user(regs->r26, sc->sc_regs+26);
0309     err |= __put_user(regs->r27, sc->sc_regs+27);
0310     err |= __put_user(regs->r28, sc->sc_regs+28);
0311     err |= __put_user(regs->gp , sc->sc_regs+29);
0312     err |= __put_user(sp, sc->sc_regs+30);
0313     err |= __put_user(0, sc->sc_regs+31);
0314 
0315     for (i = 0; i < 31; i++)
0316         err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
0317     err |= __put_user(0, sc->sc_fpregs+31);
0318     err |= __put_user(sw->fp[31], &sc->sc_fpcr);
0319 
0320     err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
0321     err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
0322     err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
0323 
0324     return err;
0325 }
0326 
0327 static int
0328 setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
0329 {
0330     unsigned long oldsp, r26, err = 0;
0331     struct sigframe __user *frame;
0332 
0333     oldsp = rdusp();
0334     frame = get_sigframe(ksig, oldsp, sizeof(*frame));
0335     if (!access_ok(frame, sizeof(*frame)))
0336         return -EFAULT;
0337 
0338     err |= setup_sigcontext(&frame->sc, regs, set->sig[0], oldsp);
0339     if (err)
0340         return -EFAULT;
0341 
0342     /* Set up to return from userspace.  If provided, use a stub
0343        already in userspace.  */
0344     r26 = (unsigned long) ksig->ka.ka_restorer;
0345     if (!r26) {
0346         err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
0347         err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
0348         err |= __put_user(INSN_CALLSYS, frame->retcode+2);
0349         imb();
0350         r26 = (unsigned long) frame->retcode;
0351     }
0352 
0353     /* Check that everything was written properly.  */
0354     if (err)
0355         return err;
0356 
0357     /* "Return" to the handler */
0358     regs->r26 = r26;
0359     regs->r27 = regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
0360     regs->r16 = ksig->sig;          /* a0: signal number */
0361     regs->r17 = 0;              /* a1: exception code */
0362     regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
0363     wrusp((unsigned long) frame);
0364     
0365 #if DEBUG_SIG
0366     printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
0367         current->comm, current->pid, frame, regs->pc, regs->r26);
0368 #endif
0369     return 0;
0370 }
0371 
0372 static int
0373 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
0374 {
0375     unsigned long oldsp, r26, err = 0;
0376     struct rt_sigframe __user *frame;
0377 
0378     oldsp = rdusp();
0379     frame = get_sigframe(ksig, oldsp, sizeof(*frame));
0380     if (!access_ok(frame, sizeof(*frame)))
0381         return -EFAULT;
0382 
0383     err |= copy_siginfo_to_user(&frame->info, &ksig->info);
0384 
0385     /* Create the ucontext.  */
0386     err |= __put_user(0, &frame->uc.uc_flags);
0387     err |= __put_user(0, &frame->uc.uc_link);
0388     err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
0389     err |= __save_altstack(&frame->uc.uc_stack, oldsp);
0390     err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, 
0391                 set->sig[0], oldsp);
0392     err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
0393     if (err)
0394         return -EFAULT;
0395 
0396     /* Set up to return from userspace.  If provided, use a stub
0397        already in userspace.  */
0398     r26 = (unsigned long) ksig->ka.ka_restorer;
0399     if (!r26) {
0400         err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
0401         err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
0402                   frame->retcode+1);
0403         err |= __put_user(INSN_CALLSYS, frame->retcode+2);
0404         imb();
0405         r26 = (unsigned long) frame->retcode;
0406     }
0407 
0408     if (err)
0409         return -EFAULT;
0410 
0411     /* "Return" to the handler */
0412     regs->r26 = r26;
0413     regs->r27 = regs->pc = (unsigned long) ksig->ka.sa.sa_handler;
0414     regs->r16 = ksig->sig;            /* a0: signal number */
0415     regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
0416     regs->r18 = (unsigned long) &frame->uc;   /* a2: ucontext pointer */
0417     wrusp((unsigned long) frame);
0418 
0419 #if DEBUG_SIG
0420     printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
0421         current->comm, current->pid, frame, regs->pc, regs->r26);
0422 #endif
0423 
0424     return 0;
0425 }
0426 
0427 
0428 /*
0429  * OK, we're invoking a handler.
0430  */
0431 static inline void
0432 handle_signal(struct ksignal *ksig, struct pt_regs *regs)
0433 {
0434     sigset_t *oldset = sigmask_to_save();
0435     int ret;
0436 
0437     if (ksig->ka.sa.sa_flags & SA_SIGINFO)
0438         ret = setup_rt_frame(ksig, oldset, regs);
0439     else
0440         ret = setup_frame(ksig, oldset, regs);
0441 
0442     signal_setup_done(ret, ksig, 0);
0443 }
0444 
0445 static inline void
0446 syscall_restart(unsigned long r0, unsigned long r19,
0447         struct pt_regs *regs, struct k_sigaction *ka)
0448 {
0449     switch (regs->r0) {
0450     case ERESTARTSYS:
0451         if (!(ka->sa.sa_flags & SA_RESTART)) {
0452         case ERESTARTNOHAND:
0453             regs->r0 = EINTR;
0454             break;
0455         }
0456         fallthrough;
0457     case ERESTARTNOINTR:
0458         regs->r0 = r0;  /* reset v0 and a3 and replay syscall */
0459         regs->r19 = r19;
0460         regs->pc -= 4;
0461         break;
0462     case ERESTART_RESTARTBLOCK:
0463         regs->r0 = EINTR;
0464         break;
0465     }
0466 }
0467 
0468 
0469 /*
0470  * Note that 'init' is a special process: it doesn't get signals it doesn't
0471  * want to handle. Thus you cannot kill init even with a SIGKILL even by
0472  * mistake.
0473  *
0474  * Note that we go through the signals twice: once to check the signals that
0475  * the kernel can handle, and then we build all the user-level signal handling
0476  * stack-frames in one go after that.
0477  *
0478  * "r0" and "r19" are the registers we need to restore for system call
0479  * restart. "r0" is also used as an indicator whether we can restart at
0480  * all (if we get here from anything but a syscall return, it will be 0)
0481  */
0482 static void
0483 do_signal(struct pt_regs *regs, unsigned long r0, unsigned long r19)
0484 {
0485     unsigned long single_stepping = ptrace_cancel_bpt(current);
0486     struct ksignal ksig;
0487 
0488     /* This lets the debugger run, ... */
0489     if (get_signal(&ksig)) {
0490         /* ... so re-check the single stepping. */
0491         single_stepping |= ptrace_cancel_bpt(current);
0492         /* Whee!  Actually deliver the signal.  */
0493         if (r0)
0494             syscall_restart(r0, r19, regs, &ksig.ka);
0495         handle_signal(&ksig, regs);
0496     } else {
0497         single_stepping |= ptrace_cancel_bpt(current);
0498         if (r0) {
0499             switch (regs->r0) {
0500             case ERESTARTNOHAND:
0501             case ERESTARTSYS:
0502             case ERESTARTNOINTR:
0503                 /* Reset v0 and a3 and replay syscall.  */
0504                 regs->r0 = r0;
0505                 regs->r19 = r19;
0506                 regs->pc -= 4;
0507                 break;
0508             case ERESTART_RESTARTBLOCK:
0509                 /* Set v0 to the restart_syscall and replay */
0510                 regs->r0 = __NR_restart_syscall;
0511                 regs->pc -= 4;
0512                 break;
0513             }
0514         }
0515         restore_saved_sigmask();
0516     }
0517     if (single_stepping)
0518         ptrace_set_bpt(current);    /* re-set breakpoint */
0519 }
0520 
0521 void
0522 do_work_pending(struct pt_regs *regs, unsigned long thread_flags,
0523          unsigned long r0, unsigned long r19)
0524 {
0525     do {
0526         if (thread_flags & _TIF_NEED_RESCHED) {
0527             schedule();
0528         } else {
0529             local_irq_enable();
0530             if (thread_flags & (_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL)) {
0531                 do_signal(regs, r0, r19);
0532                 r0 = 0;
0533             } else {
0534                 resume_user_mode_work(regs);
0535             }
0536         }
0537         local_irq_disable();
0538         thread_flags = read_thread_flags();
0539     } while (thread_flags & _TIF_WORK_MASK);
0540 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!