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