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