signal.c revision ac689eb7f9d4e270d1365853b82eece669387e2c
1ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn/* 2ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * OpenRISC signal.c 3ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * 4ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Linux architectural port borrowing liberally from similar works of 5ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * others. All original copyrights apply as per the original source 6ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * declaration. 7ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * 8ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Modifications for the OpenRISC architecture: 9ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com> 10ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se> 11ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * 12ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * This program is free software; you can redistribute it and/or 13ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * modify it under the terms of the GNU General Public License 14ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * as published by the Free Software Foundation; either version 15ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * 2 of the License, or (at your option) any later version. 16ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 17ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 18ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/sched.h> 19ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/mm.h> 20ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/smp.h> 21ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/kernel.h> 22ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/signal.h> 23ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/errno.h> 24ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/wait.h> 25ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/ptrace.h> 26ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/unistd.h> 27ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/stddef.h> 28ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <linux/tracehook.h> 29ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 30ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <asm/processor.h> 31ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <asm/ucontext.h> 32ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#include <asm/uaccess.h> 33ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 34ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#define DEBUG_SIG 0 35ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 36ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 37ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 38ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnasmlinkage long 39ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn_sys_sigaltstack(const stack_t *uss, stack_t *uoss, struct pt_regs *regs) 40ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 41ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return do_sigaltstack(uss, uoss, regs->sp); 42ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 43ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 44ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnstruct rt_sigframe { 45ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn struct siginfo *pinfo; 46ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn void *puc; 47ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn struct siginfo info; 48ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn struct ucontext uc; 49ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn unsigned char retcode[16]; /* trampoline code */ 50ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn}; 51ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 52ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnstatic int restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc) 53ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 54ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn unsigned int err = 0; 55ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn unsigned long old_usp; 56ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 57ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* Alwys make any pending restarted system call return -EINTR */ 58ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn current_thread_info()->restart_block.fn = do_no_restart_syscall; 59ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 60ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* restore the regs from &sc->regs (same as sc, since regs is first) 61ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * (sc is already checked for VERIFY_READ since the sigframe was 62ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * checked in sys_sigreturn previously) 63ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 64ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 65ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (__copy_from_user(regs, sc, sizeof(struct pt_regs))) 66ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto badframe; 67ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 68ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* make sure the SM-bit is cleared so user-mode cannot fool us */ 69ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->sr &= ~SPR_SR_SM; 70ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 71ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* restore the old USP as it was before we stacked the sc etc. 72ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * (we cannot just pop the sigcontext since we aligned the sp and 73ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * stuff after pushing it) 74ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 75ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 76ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __get_user(old_usp, &sc->usp); 77ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 78ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->sp = old_usp; 79ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 80ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* TODO: the other ports use regs->orig_XX to disable syscall checks 81ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * after this completes, but we don't use that mechanism. maybe we can 82ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * use it now ? 83ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 84ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 85ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return err; 86ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 87ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnbadframe: 88ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return 1; 89ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 90ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 91ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnasmlinkage long _sys_rt_sigreturn(struct pt_regs *regs) 92ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 93ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn struct rt_sigframe *frame = (struct rt_sigframe __user *)regs->sp; 94ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigset_t set; 95ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn stack_t st; 96ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 97ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* 98ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Since we stacked the signal on a dword boundary, 99ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * then frame should be dword aligned here. If it's 100ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * not, then the user is trying to mess with us. 101ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 102ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (((long)frame) & 3) 103ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto badframe; 104ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 105ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 106ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto badframe; 107ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 108ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto badframe; 109ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 110ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigdelsetmask(&set, ~_BLOCKABLE); 111ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn spin_lock_irq(¤t->sighand->siglock); 112ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn current->blocked = set; 113ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn recalc_sigpending(); 114ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn spin_unlock_irq(¤t->sighand->siglock); 115ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 116ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (restore_sigcontext(regs, &frame->uc.uc_mcontext)) 117ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto badframe; 118ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 119ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st))) 120ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto badframe; 121ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* It is more difficult to avoid calling this function than to 122ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn call it and ignore errors. */ 123ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn do_sigaltstack(&st, NULL, regs->sp); 124ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 125ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return regs->gpr[11]; 126ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 127ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnbadframe: 128ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn force_sig(SIGSEGV, current); 129ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return 0; 130ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 131ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 132ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn/* 133ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Set up a signal frame. 134ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 135ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 136ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnstatic int setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, 137ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn unsigned long mask) 138ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 139ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn int err = 0; 140ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn unsigned long usp = regs->sp; 141ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 142ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* copy the regs. they are first in sc so we can use sc directly */ 143ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 144ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __copy_to_user(sc, regs, sizeof(struct pt_regs)); 145ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 146ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* then some other stuff */ 147ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 148ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(mask, &sc->oldmask); 149ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 150ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(usp, &sc->usp); 151ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 152ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return err; 153ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 154ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 155ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnstatic inline unsigned long align_sigframe(unsigned long sp) 156ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 157ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return sp & ~3UL; 158ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 159ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 160ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn/* 161ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Work out where the signal frame should go. It's either on the user stack 162ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * or the alternate stack. 163ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 164ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 165ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnstatic inline void __user *get_sigframe(struct k_sigaction *ka, 166ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn struct pt_regs *regs, size_t frame_size) 167ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 168ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn unsigned long sp = regs->sp; 169ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn int onsigstack = on_sig_stack(sp); 170ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 171ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* redzone */ 172ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sp -= STACK_FRAME_OVERHEAD; 173ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 174ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* This is the X/Open sanctioned signal stack switching. */ 175ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if ((ka->sa.sa_flags & SA_ONSTACK) && !onsigstack) { 176ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (current->sas_ss_size) 177ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sp = current->sas_ss_sp + current->sas_ss_size; 178ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } 179ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 180ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sp = align_sigframe(sp - frame_size); 181ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 182ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* 183ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * If we are on the alternate signal stack and would overflow it, don't. 184ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Return an always-bogus address instead so we will die with SIGSEGV. 185ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 186ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (onsigstack && !likely(on_sig_stack(sp))) 187ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return (void __user *)-1L; 188ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 189ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return (void __user *)sp; 190ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 191ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 192ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn/* grab and setup a signal frame. 193ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * 194ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * basically we stack a lot of state info, and arrange for the 195ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * user-mode program to return to the kernel using either a 196ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * trampoline which performs the syscall sigreturn, or a provided 197ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * user-mode trampoline. 198ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 199ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnstatic void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 200ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigset_t *set, struct pt_regs *regs) 201ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 202ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn struct rt_sigframe *frame; 203ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn unsigned long return_ip; 204ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn int err = 0; 205ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 206ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn frame = get_sigframe(ka, regs, sizeof(*frame)); 207ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 208ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 209ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto give_sigsegv; 210ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 211ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(&frame->info, &frame->pinfo); 212ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(&frame->uc, &frame->puc); 213ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 214ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (ka->sa.sa_flags & SA_SIGINFO) 215ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= copy_siginfo_to_user(&frame->info, info); 216ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (err) 217ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto give_sigsegv; 218ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 219ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* Clear all the bits of the ucontext we don't use. */ 220ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext)); 221ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(0, &frame->uc.uc_flags); 222ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(NULL, &frame->uc.uc_link); 223ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user((void *)current->sas_ss_sp, 224ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn &frame->uc.uc_stack.ss_sp); 225ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(sas_ss_flags(regs->sp), &frame->uc.uc_stack.ss_flags); 226ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 227ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]); 228ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 229ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 230ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 231ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (err) 232ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto give_sigsegv; 233ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 234ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* trampoline - the desired return ip is the retcode itself */ 235ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return_ip = (unsigned long)&frame->retcode; 236ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */ 237ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(0xa960, (short *)(frame->retcode + 0)); 238ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode + 2)); 239ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(0x20000001, (unsigned long *)(frame->retcode + 4)); 240ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn err |= __put_user(0x15000000, (unsigned long *)(frame->retcode + 8)); 241ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 242ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (err) 243ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn goto give_sigsegv; 244ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 245ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* TODO what is the current->exec_domain stuff and invmap ? */ 246ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 247ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* Set up registers for signal handler */ 248ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->pc = (unsigned long)ka->sa.sa_handler; /* what we enter NOW */ 249ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */ 250ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->gpr[3] = (unsigned long)sig; /* arg 1: signo */ 251ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */ 252ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */ 253ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 254ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* actually move the usp to reflect the stacked frame */ 255ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->sp = (unsigned long)frame; 256ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 257ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return; 258ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 259ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonngive_sigsegv: 260ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (sig == SIGSEGV) 261ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn ka->sa.sa_handler = SIG_DFL; 262ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn force_sig(SIGSEGV, current); 263ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 264ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 265ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnstatic inline void 266ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnhandle_signal(unsigned long sig, 267ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn siginfo_t *info, struct k_sigaction *ka, 268ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigset_t *oldset, struct pt_regs *regs) 269ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 270ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn setup_rt_frame(sig, ka, info, oldset, regs); 271ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 272ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (ka->sa.sa_flags & SA_ONESHOT) 273ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn ka->sa.sa_handler = SIG_DFL; 274ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 275ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn spin_lock_irq(¤t->sighand->siglock); 276ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigorsets(¤t->blocked, ¤t->blocked, &ka->sa.sa_mask); 277ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (!(ka->sa.sa_flags & SA_NODEFER)) 278ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigaddset(¤t->blocked, sig); 279ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn recalc_sigpending(); 280ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 281ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn spin_unlock_irq(¤t->sighand->siglock); 282ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 283ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 284ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn/* 285ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Note that 'init' is a special process: it doesn't get signals it doesn't 286ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * want to handle. Thus you cannot kill init even with a SIGKILL even by 287ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * mistake. 288ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * 289ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * Also note that the regs structure given here as an argument, is the latest 290ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * pushed pt_regs. It may or may not be the same as the first pushed registers 291ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * when the initial usermode->kernelmode transition took place. Therefore 292ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * we can use user_mode(regs) to see if we came directly from kernel or user 293ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * mode below. 294ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 295ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 296ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnvoid do_signal(struct pt_regs *regs) 297ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 298ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn siginfo_t info; 299ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn int signr; 300ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn struct k_sigaction ka; 301ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 302ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* 303ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * We want the common case to go fast, which 304ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * is why we may in certain cases get here from 305ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * kernel mode. Just return without doing anything 306ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * if so. 307ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 308ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (!user_mode(regs)) 309ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return; 310ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 311ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn signr = get_signal_to_deliver(&info, &ka, regs, NULL); 312ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 313ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* If we are coming out of a syscall then we need 314ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * to check if the syscall was interrupted and wants to be 315ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * restarted after handling the signal. If so, the original 316ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * syscall number is put back into r11 and the PC rewound to 317ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * point at the l.sys instruction that resulted in the 318ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * original syscall. Syscall results other than the four 319ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * below mean that the syscall executed to completion and no 320ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * restart is necessary. 321ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn */ 322ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (regs->syscallno) { 323ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn int restart = 0; 324ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 325ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn switch (regs->gpr[11]) { 326ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn case -ERESTART_RESTARTBLOCK: 327ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn case -ERESTARTNOHAND: 328ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* Restart if there is no signal handler */ 329ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn restart = (signr <= 0); 330ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn break; 331ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn case -ERESTARTSYS: 332ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* Restart if there no signal handler or 333ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * SA_RESTART flag is set */ 334ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn restart = (signr <= 0 || (ka.sa.sa_flags & SA_RESTART)); 335ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn break; 336ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn case -ERESTARTNOINTR: 337ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* Always restart */ 338ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn restart = 1; 339ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn break; 340ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } 341ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 342ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (restart) { 343ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (regs->gpr[11] == -ERESTART_RESTARTBLOCK) 344ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->gpr[11] = __NR_restart_syscall; 345ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn else 346ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->gpr[11] = regs->orig_gpr11; 347ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->pc -= 4; 348ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } else { 349ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn regs->gpr[11] = -EINTR; 350ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } 351ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } 352ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 353ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (signr <= 0) { 354ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* no signal to deliver so we just put the saved sigmask 355ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * back */ 356ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 357ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn clear_thread_flag(TIF_RESTORE_SIGMASK); 358ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 359ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } 360ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 361ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } else { /* signr > 0 */ 362ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn sigset_t *oldset; 363ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 364ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (current_thread_info()->flags & _TIF_RESTORE_SIGMASK) 365ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn oldset = ¤t->saved_sigmask; 366ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn else 367ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn oldset = ¤t->blocked; 368ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 369ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* Whee! Actually deliver the signal. */ 370ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn handle_signal(signr, &info, &ka, oldset, regs); 371ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn /* a signal was successfully delivered; the saved 372ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * sigmask will have been stored in the signal frame, 373ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * and will be restored by sigreturn, so we can simply 374ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn * clear the TIF_RESTORE_SIGMASK flag */ 375ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (test_thread_flag(TIF_RESTORE_SIGMASK)) 376ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn clear_thread_flag(TIF_RESTORE_SIGMASK); 377ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 378ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn tracehook_signal_handler(signr, &info, &ka, regs, 379ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn test_thread_flag(TIF_SINGLESTEP)); 380ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } 381ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 382ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn return; 383ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 384ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 385ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonnasmlinkage void do_notify_resume(struct pt_regs *regs) 386ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn{ 387ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (current_thread_info()->flags & _TIF_SIGPENDING) 388ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn do_signal(regs); 389ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn 390ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (current_thread_info()->flags & _TIF_NOTIFY_RESUME) { 391ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn clear_thread_flag(TIF_NOTIFY_RESUME); 392ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn tracehook_notify_resume(regs); 393ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn if (current->replacement_session_keyring) 394ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn key_replace_session_keyring(); 395ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn } 396ac689eb7f9d4e270d1365853b82eece669387e2cJonas Bonn} 397