1b53e906dSLey Foon Tan /* 2b53e906dSLey Foon Tan * Copyright (C) 2013-2014 Altera Corporation 3b53e906dSLey Foon Tan * Copyright (C) 2011-2012 Tobias Klauser <tklauser@distanz.ch> 4b53e906dSLey Foon Tan * Copyright (C) 2004 Microtronix Datacom Ltd 5b53e906dSLey Foon Tan * Copyright (C) 1991, 1992 Linus Torvalds 6b53e906dSLey Foon Tan * 7b53e906dSLey Foon Tan * This file is subject to the terms and conditions of the GNU General Public 8b53e906dSLey Foon Tan * License. See the file COPYING in the main directory of this archive 9b53e906dSLey Foon Tan * for more details. 10b53e906dSLey Foon Tan */ 11b53e906dSLey Foon Tan 12b53e906dSLey Foon Tan #include <linux/signal.h> 13b53e906dSLey Foon Tan #include <linux/errno.h> 14b53e906dSLey Foon Tan #include <linux/ptrace.h> 15b53e906dSLey Foon Tan #include <linux/uaccess.h> 16b53e906dSLey Foon Tan #include <linux/unistd.h> 17b53e906dSLey Foon Tan #include <linux/personality.h> 18b53e906dSLey Foon Tan #include <linux/tracehook.h> 19b53e906dSLey Foon Tan 20b53e906dSLey Foon Tan #include <asm/ucontext.h> 21b53e906dSLey Foon Tan #include <asm/cacheflush.h> 22b53e906dSLey Foon Tan 23b53e906dSLey Foon Tan #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 24b53e906dSLey Foon Tan 25b53e906dSLey Foon Tan /* 26b53e906dSLey Foon Tan * Do a signal return; undo the signal stack. 27b53e906dSLey Foon Tan * 28b53e906dSLey Foon Tan * Keep the return code on the stack quadword aligned! 29b53e906dSLey Foon Tan * That makes the cache flush below easier. 30b53e906dSLey Foon Tan */ 31b53e906dSLey Foon Tan 32b53e906dSLey Foon Tan struct rt_sigframe { 33b53e906dSLey Foon Tan struct siginfo info; 34b53e906dSLey Foon Tan struct ucontext uc; 35b53e906dSLey Foon Tan }; 36b53e906dSLey Foon Tan 37b53e906dSLey Foon Tan static inline int rt_restore_ucontext(struct pt_regs *regs, 38b53e906dSLey Foon Tan struct switch_stack *sw, 39b53e906dSLey Foon Tan struct ucontext *uc, int *pr2) 40b53e906dSLey Foon Tan { 41b53e906dSLey Foon Tan int temp; 4292d5dd8cSChung-Ling Tang unsigned long *gregs = uc->uc_mcontext.gregs; 43b53e906dSLey Foon Tan int err; 44b53e906dSLey Foon Tan 45b53e906dSLey Foon Tan /* Always make any pending restarted system calls return -EINTR */ 467587d126SLey Foon Tan current->restart_block.fn = do_no_restart_syscall; 47b53e906dSLey Foon Tan 48b53e906dSLey Foon Tan err = __get_user(temp, &uc->uc_mcontext.version); 49b53e906dSLey Foon Tan if (temp != MCONTEXT_VERSION) 50b53e906dSLey Foon Tan goto badframe; 51b53e906dSLey Foon Tan /* restore passed registers */ 52b53e906dSLey Foon Tan err |= __get_user(regs->r1, &gregs[0]); 53b53e906dSLey Foon Tan err |= __get_user(regs->r2, &gregs[1]); 54b53e906dSLey Foon Tan err |= __get_user(regs->r3, &gregs[2]); 55b53e906dSLey Foon Tan err |= __get_user(regs->r4, &gregs[3]); 56b53e906dSLey Foon Tan err |= __get_user(regs->r5, &gregs[4]); 57b53e906dSLey Foon Tan err |= __get_user(regs->r6, &gregs[5]); 58b53e906dSLey Foon Tan err |= __get_user(regs->r7, &gregs[6]); 59b53e906dSLey Foon Tan err |= __get_user(regs->r8, &gregs[7]); 60b53e906dSLey Foon Tan err |= __get_user(regs->r9, &gregs[8]); 61b53e906dSLey Foon Tan err |= __get_user(regs->r10, &gregs[9]); 62b53e906dSLey Foon Tan err |= __get_user(regs->r11, &gregs[10]); 63b53e906dSLey Foon Tan err |= __get_user(regs->r12, &gregs[11]); 64b53e906dSLey Foon Tan err |= __get_user(regs->r13, &gregs[12]); 65b53e906dSLey Foon Tan err |= __get_user(regs->r14, &gregs[13]); 66b53e906dSLey Foon Tan err |= __get_user(regs->r15, &gregs[14]); 67b53e906dSLey Foon Tan err |= __get_user(sw->r16, &gregs[15]); 68b53e906dSLey Foon Tan err |= __get_user(sw->r17, &gregs[16]); 69b53e906dSLey Foon Tan err |= __get_user(sw->r18, &gregs[17]); 70b53e906dSLey Foon Tan err |= __get_user(sw->r19, &gregs[18]); 71b53e906dSLey Foon Tan err |= __get_user(sw->r20, &gregs[19]); 72b53e906dSLey Foon Tan err |= __get_user(sw->r21, &gregs[20]); 73b53e906dSLey Foon Tan err |= __get_user(sw->r22, &gregs[21]); 74b53e906dSLey Foon Tan err |= __get_user(sw->r23, &gregs[22]); 75b53e906dSLey Foon Tan /* gregs[23] is handled below */ 76b53e906dSLey Foon Tan err |= __get_user(sw->fp, &gregs[24]); /* Verify, should this be 77b53e906dSLey Foon Tan settable */ 78b53e906dSLey Foon Tan err |= __get_user(sw->gp, &gregs[25]); /* Verify, should this be 79b53e906dSLey Foon Tan settable */ 80b53e906dSLey Foon Tan 81b53e906dSLey Foon Tan err |= __get_user(temp, &gregs[26]); /* Not really necessary no user 82b53e906dSLey Foon Tan settable bits */ 83b53e906dSLey Foon Tan err |= __get_user(regs->ea, &gregs[27]); 84b53e906dSLey Foon Tan 85b53e906dSLey Foon Tan err |= __get_user(regs->ra, &gregs[23]); 86b53e906dSLey Foon Tan err |= __get_user(regs->sp, &gregs[28]); 87b53e906dSLey Foon Tan 88b53e906dSLey Foon Tan regs->orig_r2 = -1; /* disable syscall checks */ 89b53e906dSLey Foon Tan 90b53e906dSLey Foon Tan err |= restore_altstack(&uc->uc_stack); 91b53e906dSLey Foon Tan if (err) 92b53e906dSLey Foon Tan goto badframe; 93b53e906dSLey Foon Tan 94b53e906dSLey Foon Tan *pr2 = regs->r2; 95b53e906dSLey Foon Tan return err; 96b53e906dSLey Foon Tan 97b53e906dSLey Foon Tan badframe: 98b53e906dSLey Foon Tan return 1; 99b53e906dSLey Foon Tan } 100b53e906dSLey Foon Tan 101b53e906dSLey Foon Tan asmlinkage int do_rt_sigreturn(struct switch_stack *sw) 102b53e906dSLey Foon Tan { 103b53e906dSLey Foon Tan struct pt_regs *regs = (struct pt_regs *)(sw + 1); 104b53e906dSLey Foon Tan /* Verify, can we follow the stack back */ 105b53e906dSLey Foon Tan struct rt_sigframe *frame = (struct rt_sigframe *) regs->sp; 106b53e906dSLey Foon Tan sigset_t set; 107b53e906dSLey Foon Tan int rval; 108b53e906dSLey Foon Tan 10996d4f267SLinus Torvalds if (!access_ok(frame, sizeof(*frame))) 110b53e906dSLey Foon Tan goto badframe; 111b53e906dSLey Foon Tan 112b53e906dSLey Foon Tan if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 113b53e906dSLey Foon Tan goto badframe; 114b53e906dSLey Foon Tan 115b53e906dSLey Foon Tan set_current_blocked(&set); 116b53e906dSLey Foon Tan 117b53e906dSLey Foon Tan if (rt_restore_ucontext(regs, sw, &frame->uc, &rval)) 118b53e906dSLey Foon Tan goto badframe; 119b53e906dSLey Foon Tan 120b53e906dSLey Foon Tan return rval; 121b53e906dSLey Foon Tan 122b53e906dSLey Foon Tan badframe: 1233cf5d076SEric W. Biederman force_sig(SIGSEGV); 124b53e906dSLey Foon Tan return 0; 125b53e906dSLey Foon Tan } 126b53e906dSLey Foon Tan 127b53e906dSLey Foon Tan static inline int rt_setup_ucontext(struct ucontext *uc, struct pt_regs *regs) 128b53e906dSLey Foon Tan { 129b53e906dSLey Foon Tan struct switch_stack *sw = (struct switch_stack *)regs - 1; 13092d5dd8cSChung-Ling Tang unsigned long *gregs = uc->uc_mcontext.gregs; 131b53e906dSLey Foon Tan int err = 0; 132b53e906dSLey Foon Tan 133b53e906dSLey Foon Tan err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version); 134b53e906dSLey Foon Tan err |= __put_user(regs->r1, &gregs[0]); 135b53e906dSLey Foon Tan err |= __put_user(regs->r2, &gregs[1]); 136b53e906dSLey Foon Tan err |= __put_user(regs->r3, &gregs[2]); 137b53e906dSLey Foon Tan err |= __put_user(regs->r4, &gregs[3]); 138b53e906dSLey Foon Tan err |= __put_user(regs->r5, &gregs[4]); 139b53e906dSLey Foon Tan err |= __put_user(regs->r6, &gregs[5]); 140b53e906dSLey Foon Tan err |= __put_user(regs->r7, &gregs[6]); 141b53e906dSLey Foon Tan err |= __put_user(regs->r8, &gregs[7]); 142b53e906dSLey Foon Tan err |= __put_user(regs->r9, &gregs[8]); 143b53e906dSLey Foon Tan err |= __put_user(regs->r10, &gregs[9]); 144b53e906dSLey Foon Tan err |= __put_user(regs->r11, &gregs[10]); 145b53e906dSLey Foon Tan err |= __put_user(regs->r12, &gregs[11]); 146b53e906dSLey Foon Tan err |= __put_user(regs->r13, &gregs[12]); 147b53e906dSLey Foon Tan err |= __put_user(regs->r14, &gregs[13]); 148b53e906dSLey Foon Tan err |= __put_user(regs->r15, &gregs[14]); 149b53e906dSLey Foon Tan err |= __put_user(sw->r16, &gregs[15]); 150b53e906dSLey Foon Tan err |= __put_user(sw->r17, &gregs[16]); 151b53e906dSLey Foon Tan err |= __put_user(sw->r18, &gregs[17]); 152b53e906dSLey Foon Tan err |= __put_user(sw->r19, &gregs[18]); 153b53e906dSLey Foon Tan err |= __put_user(sw->r20, &gregs[19]); 154b53e906dSLey Foon Tan err |= __put_user(sw->r21, &gregs[20]); 155b53e906dSLey Foon Tan err |= __put_user(sw->r22, &gregs[21]); 156b53e906dSLey Foon Tan err |= __put_user(sw->r23, &gregs[22]); 157b53e906dSLey Foon Tan err |= __put_user(regs->ra, &gregs[23]); 158b53e906dSLey Foon Tan err |= __put_user(sw->fp, &gregs[24]); 159b53e906dSLey Foon Tan err |= __put_user(sw->gp, &gregs[25]); 160b53e906dSLey Foon Tan err |= __put_user(regs->ea, &gregs[27]); 161b53e906dSLey Foon Tan err |= __put_user(regs->sp, &gregs[28]); 162b53e906dSLey Foon Tan return err; 163b53e906dSLey Foon Tan } 164b53e906dSLey Foon Tan 165b53e906dSLey Foon Tan static inline void *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, 166b53e906dSLey Foon Tan size_t frame_size) 167b53e906dSLey Foon Tan { 168b53e906dSLey Foon Tan unsigned long usp; 169b53e906dSLey Foon Tan 170b53e906dSLey Foon Tan /* Default to using normal stack. */ 171b53e906dSLey Foon Tan usp = regs->sp; 172b53e906dSLey Foon Tan 173b53e906dSLey Foon Tan /* This is the X/Open sanctioned signal stack switching. */ 174b53e906dSLey Foon Tan usp = sigsp(usp, ksig); 175b53e906dSLey Foon Tan 176b53e906dSLey Foon Tan /* Verify, is it 32 or 64 bit aligned */ 177b53e906dSLey Foon Tan return (void *)((usp - frame_size) & -8UL); 178b53e906dSLey Foon Tan } 179b53e906dSLey Foon Tan 180b53e906dSLey Foon Tan static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, 181b53e906dSLey Foon Tan struct pt_regs *regs) 182b53e906dSLey Foon Tan { 183b53e906dSLey Foon Tan struct rt_sigframe *frame; 184b53e906dSLey Foon Tan int err = 0; 185b53e906dSLey Foon Tan 186b53e906dSLey Foon Tan frame = get_sigframe(ksig, regs, sizeof(*frame)); 187b53e906dSLey Foon Tan 188b53e906dSLey Foon Tan if (ksig->ka.sa.sa_flags & SA_SIGINFO) 189b53e906dSLey Foon Tan err |= copy_siginfo_to_user(&frame->info, &ksig->info); 190b53e906dSLey Foon Tan 191b53e906dSLey Foon Tan /* Create the ucontext. */ 192b53e906dSLey Foon Tan err |= __put_user(0, &frame->uc.uc_flags); 193b53e906dSLey Foon Tan err |= __put_user(0, &frame->uc.uc_link); 194b53e906dSLey Foon Tan err |= __save_altstack(&frame->uc.uc_stack, regs->sp); 195b53e906dSLey Foon Tan err |= rt_setup_ucontext(&frame->uc, regs); 196b53e906dSLey Foon Tan err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 197b53e906dSLey Foon Tan 198b53e906dSLey Foon Tan if (err) 199b53e906dSLey Foon Tan goto give_sigsegv; 200b53e906dSLey Foon Tan 201b53e906dSLey Foon Tan /* Set up to return from userspace; jump to fixed address sigreturn 202b53e906dSLey Foon Tan trampoline on kuser page. */ 203d24c8163SLey Foon Tan regs->ra = (unsigned long) (0x1044); 204b53e906dSLey Foon Tan 205b53e906dSLey Foon Tan /* Set up registers for signal handler */ 206b53e906dSLey Foon Tan regs->sp = (unsigned long) frame; 207b53e906dSLey Foon Tan regs->r4 = (unsigned long) ksig->sig; 208b53e906dSLey Foon Tan regs->r5 = (unsigned long) &frame->info; 209b53e906dSLey Foon Tan regs->r6 = (unsigned long) &frame->uc; 210b53e906dSLey Foon Tan regs->ea = (unsigned long) ksig->ka.sa.sa_handler; 211b53e906dSLey Foon Tan return 0; 212b53e906dSLey Foon Tan 213b53e906dSLey Foon Tan give_sigsegv: 214cb44c9a0SEric W. Biederman force_sigsegv(ksig->sig); 215b53e906dSLey Foon Tan return -EFAULT; 216b53e906dSLey Foon Tan } 217b53e906dSLey Foon Tan 218b53e906dSLey Foon Tan /* 219b53e906dSLey Foon Tan * OK, we're invoking a handler 220b53e906dSLey Foon Tan */ 221b53e906dSLey Foon Tan static void handle_signal(struct ksignal *ksig, struct pt_regs *regs) 222b53e906dSLey Foon Tan { 223b53e906dSLey Foon Tan int ret; 224b53e906dSLey Foon Tan sigset_t *oldset = sigmask_to_save(); 225b53e906dSLey Foon Tan 226b53e906dSLey Foon Tan /* set up the stack frame */ 227b53e906dSLey Foon Tan ret = setup_rt_frame(ksig, oldset, regs); 228b53e906dSLey Foon Tan 229b53e906dSLey Foon Tan signal_setup_done(ret, ksig, 0); 230b53e906dSLey Foon Tan } 231b53e906dSLey Foon Tan 232b53e906dSLey Foon Tan static int do_signal(struct pt_regs *regs) 233b53e906dSLey Foon Tan { 234b53e906dSLey Foon Tan unsigned int retval = 0, continue_addr = 0, restart_addr = 0; 235b53e906dSLey Foon Tan int restart = 0; 236b53e906dSLey Foon Tan struct ksignal ksig; 237b53e906dSLey Foon Tan 238b53e906dSLey Foon Tan current->thread.kregs = regs; 239b53e906dSLey Foon Tan 240b53e906dSLey Foon Tan /* 241b53e906dSLey Foon Tan * If we were from a system call, check for system call restarting... 242b53e906dSLey Foon Tan */ 243b53e906dSLey Foon Tan if (regs->orig_r2 >= 0) { 244b53e906dSLey Foon Tan continue_addr = regs->ea; 245b53e906dSLey Foon Tan restart_addr = continue_addr - 4; 246b53e906dSLey Foon Tan retval = regs->r2; 247b53e906dSLey Foon Tan 248b53e906dSLey Foon Tan /* 249b53e906dSLey Foon Tan * Prepare for system call restart. We do this here so that a 250b53e906dSLey Foon Tan * debugger will see the already changed PC. 251b53e906dSLey Foon Tan */ 252b53e906dSLey Foon Tan switch (retval) { 253b53e906dSLey Foon Tan case ERESTART_RESTARTBLOCK: 254b53e906dSLey Foon Tan restart = -2; 2556b57fa4dSLey Foon Tan fallthrough; 256b53e906dSLey Foon Tan case ERESTARTNOHAND: 257b53e906dSLey Foon Tan case ERESTARTSYS: 258b53e906dSLey Foon Tan case ERESTARTNOINTR: 259b53e906dSLey Foon Tan restart++; 260b53e906dSLey Foon Tan regs->r2 = regs->orig_r2; 261b53e906dSLey Foon Tan regs->r7 = regs->orig_r7; 262b53e906dSLey Foon Tan regs->ea = restart_addr; 263b53e906dSLey Foon Tan break; 264b53e906dSLey Foon Tan } 265b53e906dSLey Foon Tan } 266b53e906dSLey Foon Tan 267b53e906dSLey Foon Tan if (get_signal(&ksig)) { 268b53e906dSLey Foon Tan /* handler */ 269b53e906dSLey Foon Tan if (unlikely(restart && regs->ea == restart_addr)) { 270b53e906dSLey Foon Tan if (retval == ERESTARTNOHAND || 271b53e906dSLey Foon Tan retval == ERESTART_RESTARTBLOCK || 272b53e906dSLey Foon Tan (retval == ERESTARTSYS 273b53e906dSLey Foon Tan && !(ksig.ka.sa.sa_flags & SA_RESTART))) { 274b53e906dSLey Foon Tan regs->r2 = EINTR; 275b53e906dSLey Foon Tan regs->r7 = 1; 276b53e906dSLey Foon Tan regs->ea = continue_addr; 277b53e906dSLey Foon Tan } 278b53e906dSLey Foon Tan } 279b53e906dSLey Foon Tan handle_signal(&ksig, regs); 280b53e906dSLey Foon Tan return 0; 281b53e906dSLey Foon Tan } 282b53e906dSLey Foon Tan 283b53e906dSLey Foon Tan /* 284b53e906dSLey Foon Tan * No handler present 285b53e906dSLey Foon Tan */ 286b53e906dSLey Foon Tan if (unlikely(restart) && regs->ea == restart_addr) { 287b53e906dSLey Foon Tan regs->ea = continue_addr; 288b53e906dSLey Foon Tan regs->r2 = __NR_restart_syscall; 289b53e906dSLey Foon Tan } 290b53e906dSLey Foon Tan 291b53e906dSLey Foon Tan /* 292b53e906dSLey Foon Tan * If there's no signal to deliver, we just put the saved sigmask back. 293b53e906dSLey Foon Tan */ 294b53e906dSLey Foon Tan restore_saved_sigmask(); 295b53e906dSLey Foon Tan 296b53e906dSLey Foon Tan return restart; 297b53e906dSLey Foon Tan } 298b53e906dSLey Foon Tan 299b53e906dSLey Foon Tan asmlinkage int do_notify_resume(struct pt_regs *regs) 300b53e906dSLey Foon Tan { 301b53e906dSLey Foon Tan /* 302b53e906dSLey Foon Tan * We want the common case to go fast, which is why we may in certain 303b53e906dSLey Foon Tan * cases get here from kernel mode. Just return without doing anything 304b53e906dSLey Foon Tan * if so. 305b53e906dSLey Foon Tan */ 306b53e906dSLey Foon Tan if (!user_mode(regs)) 307b53e906dSLey Foon Tan return 0; 308b53e906dSLey Foon Tan 309*42020064SJens Axboe if (test_thread_flag(TIF_SIGPENDING) || 310*42020064SJens Axboe test_thread_flag(TIF_NOTIFY_SIGNAL)) { 311b53e906dSLey Foon Tan int restart = do_signal(regs); 312b53e906dSLey Foon Tan 313b53e906dSLey Foon Tan if (unlikely(restart)) { 314b53e906dSLey Foon Tan /* 315b53e906dSLey Foon Tan * Restart without handlers. 316b53e906dSLey Foon Tan * Deal with it without leaving 317b53e906dSLey Foon Tan * the kernel space. 318b53e906dSLey Foon Tan */ 319b53e906dSLey Foon Tan return restart; 320b53e906dSLey Foon Tan } 3213c532798SJens Axboe } else if (test_thread_flag(TIF_NOTIFY_RESUME)) 322b53e906dSLey Foon Tan tracehook_notify_resume(regs); 323b53e906dSLey Foon Tan 324b53e906dSLey Foon Tan return 0; 325b53e906dSLey Foon Tan } 326