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); 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_thread_info()->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 k_sigaction *ka, 213 struct pt_regs *regs) 214 { 215 unsigned long sp, sp_top; 216 struct rt_sigframe __user *frame; 217 218 sp = sp_top = regs->sp; 219 220 /* 221 * This is the X/Open sanctioned signal stack switching. 222 */ 223 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) 224 sp = sp_top = current->sas_ss_sp + current->sas_ss_size; 225 226 sp = (sp - sizeof(struct rt_sigframe)) & ~15; 227 frame = (struct rt_sigframe __user *)sp; 228 229 /* 230 * Check that we can actually write to the signal frame. 231 */ 232 if (!access_ok(VERIFY_WRITE, frame, sp_top - sp)) 233 frame = NULL; 234 235 return frame; 236 } 237 238 static void setup_return(struct pt_regs *regs, struct k_sigaction *ka, 239 void __user *frame, int usig) 240 { 241 __sigrestore_t sigtramp; 242 243 regs->regs[0] = usig; 244 regs->sp = (unsigned long)frame; 245 regs->regs[29] = regs->sp + offsetof(struct rt_sigframe, fp); 246 regs->pc = (unsigned long)ka->sa.sa_handler; 247 248 if (ka->sa.sa_flags & SA_RESTORER) 249 sigtramp = ka->sa.sa_restorer; 250 else 251 sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp); 252 253 regs->regs[30] = (unsigned long)sigtramp; 254 } 255 256 static int setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info, 257 sigset_t *set, struct pt_regs *regs) 258 { 259 struct rt_sigframe __user *frame; 260 int err = 0; 261 262 frame = get_sigframe(ka, regs); 263 if (!frame) 264 return 1; 265 266 __put_user_error(0, &frame->uc.uc_flags, err); 267 __put_user_error(NULL, &frame->uc.uc_link, err); 268 269 err |= __save_altstack(&frame->uc.uc_stack, regs->sp); 270 err |= setup_sigframe(frame, regs, set); 271 if (err == 0) { 272 setup_return(regs, ka, frame, usig); 273 if (ka->sa.sa_flags & SA_SIGINFO) { 274 err |= copy_siginfo_to_user(&frame->info, info); 275 regs->regs[1] = (unsigned long)&frame->info; 276 regs->regs[2] = (unsigned long)&frame->uc; 277 } 278 } 279 280 return err; 281 } 282 283 static void setup_restart_syscall(struct pt_regs *regs) 284 { 285 if (is_compat_task()) 286 compat_setup_restart_syscall(regs); 287 else 288 regs->regs[8] = __NR_restart_syscall; 289 } 290 291 /* 292 * OK, we're invoking a handler 293 */ 294 static void handle_signal(unsigned long sig, struct k_sigaction *ka, 295 siginfo_t *info, struct pt_regs *regs) 296 { 297 struct thread_info *thread = current_thread_info(); 298 struct task_struct *tsk = current; 299 sigset_t *oldset = sigmask_to_save(); 300 int usig = sig; 301 int ret; 302 303 /* 304 * translate the signal 305 */ 306 if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap) 307 usig = thread->exec_domain->signal_invmap[usig]; 308 309 /* 310 * Set up the stack frame 311 */ 312 if (is_compat_task()) { 313 if (ka->sa.sa_flags & SA_SIGINFO) 314 ret = compat_setup_rt_frame(usig, ka, info, oldset, 315 regs); 316 else 317 ret = compat_setup_frame(usig, ka, oldset, regs); 318 } else { 319 ret = setup_rt_frame(usig, ka, info, oldset, regs); 320 } 321 322 /* 323 * Check that the resulting registers are actually sane. 324 */ 325 ret |= !valid_user_regs(®s->user_regs); 326 327 if (ret != 0) { 328 force_sigsegv(sig, tsk); 329 return; 330 } 331 332 /* 333 * Fast forward the stepping logic so we step into the signal 334 * handler. 335 */ 336 user_fastforward_single_step(tsk); 337 338 signal_delivered(sig, info, ka, regs, 0); 339 } 340 341 /* 342 * Note that 'init' is a special process: it doesn't get signals it doesn't 343 * want to handle. Thus you cannot kill init even with a SIGKILL even by 344 * mistake. 345 * 346 * Note that we go through the signals twice: once to check the signals that 347 * the kernel can handle, and then we build all the user-level signal handling 348 * stack-frames in one go after that. 349 */ 350 static void do_signal(struct pt_regs *regs) 351 { 352 unsigned long continue_addr = 0, restart_addr = 0; 353 struct k_sigaction ka; 354 siginfo_t info; 355 int signr, retval = 0; 356 int syscall = (int)regs->syscallno; 357 358 /* 359 * If we were from a system call, check for system call restarting... 360 */ 361 if (syscall >= 0) { 362 continue_addr = regs->pc; 363 restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4); 364 retval = regs->regs[0]; 365 366 /* 367 * Avoid additional syscall restarting via ret_to_user. 368 */ 369 regs->syscallno = ~0UL; 370 371 /* 372 * Prepare for system call restart. We do this here so that a 373 * debugger will see the already changed PC. 374 */ 375 switch (retval) { 376 case -ERESTARTNOHAND: 377 case -ERESTARTSYS: 378 case -ERESTARTNOINTR: 379 case -ERESTART_RESTARTBLOCK: 380 regs->regs[0] = regs->orig_x0; 381 regs->pc = restart_addr; 382 break; 383 } 384 } 385 386 /* 387 * Get the signal to deliver. When running under ptrace, at this point 388 * the debugger may change all of our registers. 389 */ 390 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 391 if (signr > 0) { 392 /* 393 * Depending on the signal settings, we may need to revert the 394 * decision to restart the system call, but skip this if a 395 * debugger has chosen to restart at a different PC. 396 */ 397 if (regs->pc == restart_addr && 398 (retval == -ERESTARTNOHAND || 399 retval == -ERESTART_RESTARTBLOCK || 400 (retval == -ERESTARTSYS && 401 !(ka.sa.sa_flags & SA_RESTART)))) { 402 regs->regs[0] = -EINTR; 403 regs->pc = continue_addr; 404 } 405 406 handle_signal(signr, &ka, &info, regs); 407 return; 408 } 409 410 /* 411 * Handle restarting a different system call. As above, if a debugger 412 * has chosen to restart at a different PC, ignore the restart. 413 */ 414 if (syscall >= 0 && regs->pc == restart_addr) { 415 if (retval == -ERESTART_RESTARTBLOCK) 416 setup_restart_syscall(regs); 417 user_rewind_single_step(current); 418 } 419 420 restore_saved_sigmask(); 421 } 422 423 asmlinkage void do_notify_resume(struct pt_regs *regs, 424 unsigned int thread_flags) 425 { 426 if (thread_flags & _TIF_SIGPENDING) 427 do_signal(regs); 428 429 if (thread_flags & _TIF_NOTIFY_RESUME) { 430 clear_thread_flag(TIF_NOTIFY_RESUME); 431 tracehook_notify_resume(regs); 432 } 433 434 if (thread_flags & _TIF_FOREIGN_FPSTATE) 435 fpsimd_restore_current_state(); 436 437 } 438