1 /* 2 * Based on arch/arm/kernel/signal.c 3 * 4 * Copyright (C) 1995-2009 Russell King 5 * Copyright (C) 2012 ARM Ltd. 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program. If not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include <linux/compat.h> 21 #include <linux/errno.h> 22 #include <linux/signal.h> 23 #include <linux/personality.h> 24 #include <linux/freezer.h> 25 #include <linux/uaccess.h> 26 #include <linux/tracehook.h> 27 #include <linux/ratelimit.h> 28 29 #include <asm/debug-monitors.h> 30 #include <asm/elf.h> 31 #include <asm/cacheflush.h> 32 #include <asm/ucontext.h> 33 #include <asm/unistd.h> 34 #include <asm/fpsimd.h> 35 #include <asm/signal32.h> 36 #include <asm/vdso.h> 37 38 /* 39 * Do a signal return; undo the signal stack. These are aligned to 128-bit. 40 */ 41 struct rt_sigframe { 42 struct siginfo info; 43 struct ucontext uc; 44 u64 fp; 45 u64 lr; 46 }; 47 48 static int preserve_fpsimd_context(struct fpsimd_context __user *ctx) 49 { 50 struct fpsimd_state *fpsimd = ¤t->thread.fpsimd_state; 51 int err; 52 53 /* dump the hardware registers to the fpsimd_state structure */ 54 fpsimd_preserve_current_state(); 55 56 /* copy the FP and status/control registers */ 57 err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs)); 58 __put_user_error(fpsimd->fpsr, &ctx->fpsr, err); 59 __put_user_error(fpsimd->fpcr, &ctx->fpcr, err); 60 61 /* copy the magic/size information */ 62 __put_user_error(FPSIMD_MAGIC, &ctx->head.magic, err); 63 __put_user_error(sizeof(struct fpsimd_context), &ctx->head.size, err); 64 65 return err ? -EFAULT : 0; 66 } 67 68 static int restore_fpsimd_context(struct fpsimd_context __user *ctx) 69 { 70 struct fpsimd_state fpsimd; 71 __u32 magic, size; 72 int err = 0; 73 74 /* check the magic/size information */ 75 __get_user_error(magic, &ctx->head.magic, err); 76 __get_user_error(size, &ctx->head.size, err); 77 if (err) 78 return -EFAULT; 79 if (magic != FPSIMD_MAGIC || size != sizeof(struct fpsimd_context)) 80 return -EINVAL; 81 82 /* copy the FP and status/control registers */ 83 err = __copy_from_user(fpsimd.vregs, ctx->vregs, 84 sizeof(fpsimd.vregs)); 85 __get_user_error(fpsimd.fpsr, &ctx->fpsr, err); 86 __get_user_error(fpsimd.fpcr, &ctx->fpcr, err); 87 88 /* load the hardware registers from the fpsimd_state structure */ 89 if (!err) 90 fpsimd_update_current_state(&fpsimd); 91 92 return err ? -EFAULT : 0; 93 } 94 95 static int restore_sigframe(struct pt_regs *regs, 96 struct rt_sigframe __user *sf) 97 { 98 sigset_t set; 99 int i, err; 100 void *aux = sf->uc.uc_mcontext.__reserved; 101 102 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set)); 103 if (err == 0) 104 set_current_blocked(&set); 105 106 for (i = 0; i < 31; i++) 107 __get_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i], 108 err); 109 __get_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err); 110 __get_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err); 111 __get_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err); 112 113 /* 114 * Avoid sys_rt_sigreturn() restarting. 115 */ 116 regs->syscallno = ~0UL; 117 118 err |= !valid_user_regs(®s->user_regs, current); 119 120 if (err == 0) { 121 struct fpsimd_context *fpsimd_ctx = 122 container_of(aux, struct fpsimd_context, head); 123 err |= restore_fpsimd_context(fpsimd_ctx); 124 } 125 126 return err; 127 } 128 129 asmlinkage long sys_rt_sigreturn(struct pt_regs *regs) 130 { 131 struct rt_sigframe __user *frame; 132 133 /* Always make any pending restarted system calls return -EINTR */ 134 current->restart_block.fn = do_no_restart_syscall; 135 136 /* 137 * Since we stacked the signal on a 128-bit boundary, then 'sp' should 138 * be word aligned here. 139 */ 140 if (regs->sp & 15) 141 goto badframe; 142 143 frame = (struct rt_sigframe __user *)regs->sp; 144 145 if (!access_ok(VERIFY_READ, frame, sizeof (*frame))) 146 goto badframe; 147 148 if (restore_sigframe(regs, frame)) 149 goto badframe; 150 151 if (restore_altstack(&frame->uc.uc_stack)) 152 goto badframe; 153 154 return regs->regs[0]; 155 156 badframe: 157 if (show_unhandled_signals) 158 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n", 159 current->comm, task_pid_nr(current), __func__, 160 regs->pc, regs->sp); 161 force_sig(SIGSEGV, current); 162 return 0; 163 } 164 165 static int setup_sigframe(struct rt_sigframe __user *sf, 166 struct pt_regs *regs, sigset_t *set) 167 { 168 int i, err = 0; 169 void *aux = sf->uc.uc_mcontext.__reserved; 170 struct _aarch64_ctx *end; 171 172 /* set up the stack frame for unwinding */ 173 __put_user_error(regs->regs[29], &sf->fp, err); 174 __put_user_error(regs->regs[30], &sf->lr, err); 175 176 for (i = 0; i < 31; i++) 177 __put_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i], 178 err); 179 __put_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err); 180 __put_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err); 181 __put_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err); 182 183 __put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err); 184 185 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set)); 186 187 if (err == 0) { 188 struct fpsimd_context *fpsimd_ctx = 189 container_of(aux, struct fpsimd_context, head); 190 err |= preserve_fpsimd_context(fpsimd_ctx); 191 aux += sizeof(*fpsimd_ctx); 192 } 193 194 /* fault information, if valid */ 195 if (current->thread.fault_code) { 196 struct esr_context *esr_ctx = 197 container_of(aux, struct esr_context, head); 198 __put_user_error(ESR_MAGIC, &esr_ctx->head.magic, err); 199 __put_user_error(sizeof(*esr_ctx), &esr_ctx->head.size, err); 200 __put_user_error(current->thread.fault_code, &esr_ctx->esr, err); 201 aux += sizeof(*esr_ctx); 202 } 203 204 /* set the "end" magic */ 205 end = aux; 206 __put_user_error(0, &end->magic, err); 207 __put_user_error(0, &end->size, err); 208 209 return err; 210 } 211 212 static struct rt_sigframe __user *get_sigframe(struct ksignal *ksig, 213 struct pt_regs *regs) 214 { 215 unsigned long sp, sp_top; 216 struct rt_sigframe __user *frame; 217 218 sp = sp_top = sigsp(regs->sp, ksig); 219 220 sp = (sp - sizeof(struct rt_sigframe)) & ~15; 221 frame = (struct rt_sigframe __user *)sp; 222 223 /* 224 * Check that we can actually write to the signal frame. 225 */ 226 if (!access_ok(VERIFY_WRITE, frame, sp_top - sp)) 227 frame = NULL; 228 229 return frame; 230 } 231 232 static void setup_return(struct pt_regs *regs, struct k_sigaction *ka, 233 void __user *frame, int usig) 234 { 235 __sigrestore_t sigtramp; 236 237 regs->regs[0] = usig; 238 regs->sp = (unsigned long)frame; 239 regs->regs[29] = regs->sp + offsetof(struct rt_sigframe, fp); 240 regs->pc = (unsigned long)ka->sa.sa_handler; 241 242 if (ka->sa.sa_flags & SA_RESTORER) 243 sigtramp = ka->sa.sa_restorer; 244 else 245 sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp); 246 247 regs->regs[30] = (unsigned long)sigtramp; 248 } 249 250 static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set, 251 struct pt_regs *regs) 252 { 253 struct rt_sigframe __user *frame; 254 int err = 0; 255 256 frame = get_sigframe(ksig, regs); 257 if (!frame) 258 return 1; 259 260 __put_user_error(0, &frame->uc.uc_flags, err); 261 __put_user_error(NULL, &frame->uc.uc_link, err); 262 263 err |= __save_altstack(&frame->uc.uc_stack, regs->sp); 264 err |= setup_sigframe(frame, regs, set); 265 if (err == 0) { 266 setup_return(regs, &ksig->ka, frame, usig); 267 if (ksig->ka.sa.sa_flags & SA_SIGINFO) { 268 err |= copy_siginfo_to_user(&frame->info, &ksig->info); 269 regs->regs[1] = (unsigned long)&frame->info; 270 regs->regs[2] = (unsigned long)&frame->uc; 271 } 272 } 273 274 return err; 275 } 276 277 static void setup_restart_syscall(struct pt_regs *regs) 278 { 279 if (is_compat_task()) 280 compat_setup_restart_syscall(regs); 281 else 282 regs->regs[8] = __NR_restart_syscall; 283 } 284 285 /* 286 * OK, we're invoking a handler 287 */ 288 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs) 289 { 290 struct task_struct *tsk = current; 291 sigset_t *oldset = sigmask_to_save(); 292 int usig = ksig->sig; 293 int ret; 294 295 /* 296 * Set up the stack frame 297 */ 298 if (is_compat_task()) { 299 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 300 ret = compat_setup_rt_frame(usig, ksig, oldset, regs); 301 else 302 ret = compat_setup_frame(usig, ksig, oldset, regs); 303 } else { 304 ret = setup_rt_frame(usig, ksig, oldset, regs); 305 } 306 307 /* 308 * Check that the resulting registers are actually sane. 309 */ 310 ret |= !valid_user_regs(®s->user_regs, current); 311 312 /* 313 * Fast forward the stepping logic so we step into the signal 314 * handler. 315 */ 316 if (!ret) 317 user_fastforward_single_step(tsk); 318 319 signal_setup_done(ret, ksig, 0); 320 } 321 322 /* 323 * Note that 'init' is a special process: it doesn't get signals it doesn't 324 * want to handle. Thus you cannot kill init even with a SIGKILL even by 325 * mistake. 326 * 327 * Note that we go through the signals twice: once to check the signals that 328 * the kernel can handle, and then we build all the user-level signal handling 329 * stack-frames in one go after that. 330 */ 331 static void do_signal(struct pt_regs *regs) 332 { 333 unsigned long continue_addr = 0, restart_addr = 0; 334 int retval = 0; 335 int syscall = (int)regs->syscallno; 336 struct ksignal ksig; 337 338 /* 339 * If we were from a system call, check for system call restarting... 340 */ 341 if (syscall >= 0) { 342 continue_addr = regs->pc; 343 restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4); 344 retval = regs->regs[0]; 345 346 /* 347 * Avoid additional syscall restarting via ret_to_user. 348 */ 349 regs->syscallno = ~0UL; 350 351 /* 352 * Prepare for system call restart. We do this here so that a 353 * debugger will see the already changed PC. 354 */ 355 switch (retval) { 356 case -ERESTARTNOHAND: 357 case -ERESTARTSYS: 358 case -ERESTARTNOINTR: 359 case -ERESTART_RESTARTBLOCK: 360 regs->regs[0] = regs->orig_x0; 361 regs->pc = restart_addr; 362 break; 363 } 364 } 365 366 /* 367 * Get the signal to deliver. When running under ptrace, at this point 368 * the debugger may change all of our registers. 369 */ 370 if (get_signal(&ksig)) { 371 /* 372 * Depending on the signal settings, we may need to revert the 373 * decision to restart the system call, but skip this if a 374 * debugger has chosen to restart at a different PC. 375 */ 376 if (regs->pc == restart_addr && 377 (retval == -ERESTARTNOHAND || 378 retval == -ERESTART_RESTARTBLOCK || 379 (retval == -ERESTARTSYS && 380 !(ksig.ka.sa.sa_flags & SA_RESTART)))) { 381 regs->regs[0] = -EINTR; 382 regs->pc = continue_addr; 383 } 384 385 handle_signal(&ksig, regs); 386 return; 387 } 388 389 /* 390 * Handle restarting a different system call. As above, if a debugger 391 * has chosen to restart at a different PC, ignore the restart. 392 */ 393 if (syscall >= 0 && regs->pc == restart_addr) { 394 if (retval == -ERESTART_RESTARTBLOCK) 395 setup_restart_syscall(regs); 396 user_rewind_single_step(current); 397 } 398 399 restore_saved_sigmask(); 400 } 401 402 asmlinkage void do_notify_resume(struct pt_regs *regs, 403 unsigned int thread_flags) 404 { 405 if (thread_flags & _TIF_SIGPENDING) 406 do_signal(regs); 407 408 if (thread_flags & _TIF_NOTIFY_RESUME) { 409 clear_thread_flag(TIF_NOTIFY_RESUME); 410 tracehook_notify_resume(regs); 411 } 412 413 if (thread_flags & _TIF_FOREIGN_FPSTATE) 414 fpsimd_restore_current_state(); 415 416 } 417