1 /* 2 * linux/arch/arm/kernel/signal.c 3 * 4 * Copyright (C) 1995-2009 Russell King 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 #include <linux/errno.h> 11 #include <linux/random.h> 12 #include <linux/signal.h> 13 #include <linux/personality.h> 14 #include <linux/uaccess.h> 15 #include <linux/tracehook.h> 16 #include <linux/uprobes.h> 17 #include <linux/syscalls.h> 18 19 #include <asm/elf.h> 20 #include <asm/cacheflush.h> 21 #include <asm/traps.h> 22 #include <asm/unistd.h> 23 #include <asm/vfp.h> 24 25 #include "signal.h" 26 27 extern const unsigned long sigreturn_codes[17]; 28 29 static unsigned long signal_return_offset; 30 31 #ifdef CONFIG_CRUNCH 32 static int preserve_crunch_context(struct crunch_sigframe __user *frame) 33 { 34 char kbuf[sizeof(*frame) + 8]; 35 struct crunch_sigframe *kframe; 36 37 /* the crunch context must be 64 bit aligned */ 38 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7); 39 kframe->magic = CRUNCH_MAGIC; 40 kframe->size = CRUNCH_STORAGE_SIZE; 41 crunch_task_copy(current_thread_info(), &kframe->storage); 42 return __copy_to_user(frame, kframe, sizeof(*frame)); 43 } 44 45 static int restore_crunch_context(char __user **auxp) 46 { 47 struct crunch_sigframe __user *frame = 48 (struct crunch_sigframe __user *)*auxp; 49 char kbuf[sizeof(*frame) + 8]; 50 struct crunch_sigframe *kframe; 51 52 /* the crunch context must be 64 bit aligned */ 53 kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7); 54 if (__copy_from_user(kframe, frame, sizeof(*frame))) 55 return -1; 56 if (kframe->magic != CRUNCH_MAGIC || 57 kframe->size != CRUNCH_STORAGE_SIZE) 58 return -1; 59 *auxp += CRUNCH_STORAGE_SIZE; 60 crunch_task_restore(current_thread_info(), &kframe->storage); 61 return 0; 62 } 63 #endif 64 65 #ifdef CONFIG_IWMMXT 66 67 static int preserve_iwmmxt_context(struct iwmmxt_sigframe __user *frame) 68 { 69 char kbuf[sizeof(*frame) + 8]; 70 struct iwmmxt_sigframe *kframe; 71 int err = 0; 72 73 /* the iWMMXt context must be 64 bit aligned */ 74 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7); 75 76 if (test_thread_flag(TIF_USING_IWMMXT)) { 77 kframe->magic = IWMMXT_MAGIC; 78 kframe->size = IWMMXT_STORAGE_SIZE; 79 iwmmxt_task_copy(current_thread_info(), &kframe->storage); 80 81 err = __copy_to_user(frame, kframe, sizeof(*frame)); 82 } else { 83 /* 84 * For bug-compatibility with older kernels, some space 85 * has to be reserved for iWMMXt even if it's not used. 86 * Set the magic and size appropriately so that properly 87 * written userspace can skip it reliably: 88 */ 89 __put_user_error(DUMMY_MAGIC, &frame->magic, err); 90 __put_user_error(IWMMXT_STORAGE_SIZE, &frame->size, err); 91 } 92 93 return err; 94 } 95 96 static int restore_iwmmxt_context(char __user **auxp) 97 { 98 struct iwmmxt_sigframe __user *frame = 99 (struct iwmmxt_sigframe __user *)*auxp; 100 char kbuf[sizeof(*frame) + 8]; 101 struct iwmmxt_sigframe *kframe; 102 103 /* the iWMMXt context must be 64 bit aligned */ 104 kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7); 105 if (__copy_from_user(kframe, frame, sizeof(*frame))) 106 return -1; 107 108 /* 109 * For non-iWMMXt threads: a single iwmmxt_sigframe-sized dummy 110 * block is discarded for compatibility with setup_sigframe() if 111 * present, but we don't mandate its presence. If some other 112 * magic is here, it's not for us: 113 */ 114 if (!test_thread_flag(TIF_USING_IWMMXT) && 115 kframe->magic != DUMMY_MAGIC) 116 return 0; 117 118 if (kframe->size != IWMMXT_STORAGE_SIZE) 119 return -1; 120 121 if (test_thread_flag(TIF_USING_IWMMXT)) { 122 if (kframe->magic != IWMMXT_MAGIC) 123 return -1; 124 125 iwmmxt_task_restore(current_thread_info(), &kframe->storage); 126 } 127 128 *auxp += IWMMXT_STORAGE_SIZE; 129 return 0; 130 } 131 132 #endif 133 134 #ifdef CONFIG_VFP 135 136 static int preserve_vfp_context(struct vfp_sigframe __user *frame) 137 { 138 const unsigned long magic = VFP_MAGIC; 139 const unsigned long size = VFP_STORAGE_SIZE; 140 int err = 0; 141 142 __put_user_error(magic, &frame->magic, err); 143 __put_user_error(size, &frame->size, err); 144 145 if (err) 146 return -EFAULT; 147 148 return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc); 149 } 150 151 static int restore_vfp_context(char __user **auxp) 152 { 153 struct vfp_sigframe __user *frame = 154 (struct vfp_sigframe __user *)*auxp; 155 unsigned long magic; 156 unsigned long size; 157 int err = 0; 158 159 __get_user_error(magic, &frame->magic, err); 160 __get_user_error(size, &frame->size, err); 161 162 if (err) 163 return -EFAULT; 164 if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE) 165 return -EINVAL; 166 167 *auxp += size; 168 return vfp_restore_user_hwstate(&frame->ufp, &frame->ufp_exc); 169 } 170 171 #endif 172 173 /* 174 * Do a signal return; undo the signal stack. These are aligned to 64-bit. 175 */ 176 177 static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf) 178 { 179 char __user *aux; 180 sigset_t set; 181 int err; 182 183 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set)); 184 if (err == 0) 185 set_current_blocked(&set); 186 187 __get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err); 188 __get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err); 189 __get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err); 190 __get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err); 191 __get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err); 192 __get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err); 193 __get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err); 194 __get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err); 195 __get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err); 196 __get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err); 197 __get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err); 198 __get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err); 199 __get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err); 200 __get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err); 201 __get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err); 202 __get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err); 203 __get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err); 204 205 err |= !valid_user_regs(regs); 206 207 aux = (char __user *) sf->uc.uc_regspace; 208 #ifdef CONFIG_CRUNCH 209 if (err == 0) 210 err |= restore_crunch_context(&aux); 211 #endif 212 #ifdef CONFIG_IWMMXT 213 if (err == 0) 214 err |= restore_iwmmxt_context(&aux); 215 #endif 216 #ifdef CONFIG_VFP 217 if (err == 0) 218 err |= restore_vfp_context(&aux); 219 #endif 220 221 return err; 222 } 223 224 asmlinkage int sys_sigreturn(struct pt_regs *regs) 225 { 226 struct sigframe __user *frame; 227 228 /* Always make any pending restarted system calls return -EINTR */ 229 current->restart_block.fn = do_no_restart_syscall; 230 231 /* 232 * Since we stacked the signal on a 64-bit boundary, 233 * then 'sp' should be word aligned here. If it's 234 * not, then the user is trying to mess with us. 235 */ 236 if (regs->ARM_sp & 7) 237 goto badframe; 238 239 frame = (struct sigframe __user *)regs->ARM_sp; 240 241 if (!access_ok(VERIFY_READ, frame, sizeof (*frame))) 242 goto badframe; 243 244 if (restore_sigframe(regs, frame)) 245 goto badframe; 246 247 return regs->ARM_r0; 248 249 badframe: 250 force_sig(SIGSEGV, current); 251 return 0; 252 } 253 254 asmlinkage int sys_rt_sigreturn(struct pt_regs *regs) 255 { 256 struct rt_sigframe __user *frame; 257 258 /* Always make any pending restarted system calls return -EINTR */ 259 current->restart_block.fn = do_no_restart_syscall; 260 261 /* 262 * Since we stacked the signal on a 64-bit boundary, 263 * then 'sp' should be word aligned here. If it's 264 * not, then the user is trying to mess with us. 265 */ 266 if (regs->ARM_sp & 7) 267 goto badframe; 268 269 frame = (struct rt_sigframe __user *)regs->ARM_sp; 270 271 if (!access_ok(VERIFY_READ, frame, sizeof (*frame))) 272 goto badframe; 273 274 if (restore_sigframe(regs, &frame->sig)) 275 goto badframe; 276 277 if (restore_altstack(&frame->sig.uc.uc_stack)) 278 goto badframe; 279 280 return regs->ARM_r0; 281 282 badframe: 283 force_sig(SIGSEGV, current); 284 return 0; 285 } 286 287 static int 288 setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set) 289 { 290 struct aux_sigframe __user *aux; 291 int err = 0; 292 293 __put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err); 294 __put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err); 295 __put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err); 296 __put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err); 297 __put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err); 298 __put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err); 299 __put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err); 300 __put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err); 301 __put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err); 302 __put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err); 303 __put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err); 304 __put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err); 305 __put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err); 306 __put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err); 307 __put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err); 308 __put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err); 309 __put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err); 310 311 __put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err); 312 __put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err); 313 __put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err); 314 __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err); 315 316 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set)); 317 318 aux = (struct aux_sigframe __user *) sf->uc.uc_regspace; 319 #ifdef CONFIG_CRUNCH 320 if (err == 0) 321 err |= preserve_crunch_context(&aux->crunch); 322 #endif 323 #ifdef CONFIG_IWMMXT 324 if (err == 0) 325 err |= preserve_iwmmxt_context(&aux->iwmmxt); 326 #endif 327 #ifdef CONFIG_VFP 328 if (err == 0) 329 err |= preserve_vfp_context(&aux->vfp); 330 #endif 331 __put_user_error(0, &aux->end_magic, err); 332 333 return err; 334 } 335 336 static inline void __user * 337 get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize) 338 { 339 unsigned long sp = sigsp(regs->ARM_sp, ksig); 340 void __user *frame; 341 342 /* 343 * ATPCS B01 mandates 8-byte alignment 344 */ 345 frame = (void __user *)((sp - framesize) & ~7); 346 347 /* 348 * Check that we can actually write to the signal frame. 349 */ 350 if (!access_ok(VERIFY_WRITE, frame, framesize)) 351 frame = NULL; 352 353 return frame; 354 } 355 356 static int 357 setup_return(struct pt_regs *regs, struct ksignal *ksig, 358 unsigned long __user *rc, void __user *frame) 359 { 360 unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler; 361 unsigned long handler_fdpic_GOT = 0; 362 unsigned long retcode; 363 unsigned int idx, thumb = 0; 364 unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT); 365 bool fdpic = IS_ENABLED(CONFIG_BINFMT_ELF_FDPIC) && 366 (current->personality & FDPIC_FUNCPTRS); 367 368 if (fdpic) { 369 unsigned long __user *fdpic_func_desc = 370 (unsigned long __user *)handler; 371 if (__get_user(handler, &fdpic_func_desc[0]) || 372 __get_user(handler_fdpic_GOT, &fdpic_func_desc[1])) 373 return 1; 374 } 375 376 cpsr |= PSR_ENDSTATE; 377 378 /* 379 * Maybe we need to deliver a 32-bit signal to a 26-bit task. 380 */ 381 if (ksig->ka.sa.sa_flags & SA_THIRTYTWO) 382 cpsr = (cpsr & ~MODE_MASK) | USR_MODE; 383 384 #ifdef CONFIG_ARM_THUMB 385 if (elf_hwcap & HWCAP_THUMB) { 386 /* 387 * The LSB of the handler determines if we're going to 388 * be using THUMB or ARM mode for this signal handler. 389 */ 390 thumb = handler & 1; 391 392 /* 393 * Clear the If-Then Thumb-2 execution state. ARM spec 394 * requires this to be all 000s in ARM mode. Snapdragon 395 * S4/Krait misbehaves on a Thumb=>ARM signal transition 396 * without this. 397 * 398 * We must do this whenever we are running on a Thumb-2 399 * capable CPU, which includes ARMv6T2. However, we elect 400 * to always do this to simplify the code; this field is 401 * marked UNK/SBZP for older architectures. 402 */ 403 cpsr &= ~PSR_IT_MASK; 404 405 if (thumb) { 406 cpsr |= PSR_T_BIT; 407 } else 408 cpsr &= ~PSR_T_BIT; 409 } 410 #endif 411 412 if (ksig->ka.sa.sa_flags & SA_RESTORER) { 413 retcode = (unsigned long)ksig->ka.sa.sa_restorer; 414 if (fdpic) { 415 /* 416 * We need code to load the function descriptor. 417 * That code follows the standard sigreturn code 418 * (6 words), and is made of 3 + 2 words for each 419 * variant. The 4th copied word is the actual FD 420 * address that the assembly code expects. 421 */ 422 idx = 6 + thumb * 3; 423 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 424 idx += 5; 425 if (__put_user(sigreturn_codes[idx], rc ) || 426 __put_user(sigreturn_codes[idx+1], rc+1) || 427 __put_user(sigreturn_codes[idx+2], rc+2) || 428 __put_user(retcode, rc+3)) 429 return 1; 430 goto rc_finish; 431 } 432 } else { 433 idx = thumb << 1; 434 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 435 idx += 3; 436 437 /* 438 * Put the sigreturn code on the stack no matter which return 439 * mechanism we use in order to remain ABI compliant 440 */ 441 if (__put_user(sigreturn_codes[idx], rc) || 442 __put_user(sigreturn_codes[idx+1], rc+1)) 443 return 1; 444 445 rc_finish: 446 #ifdef CONFIG_MMU 447 if (cpsr & MODE32_BIT) { 448 struct mm_struct *mm = current->mm; 449 450 /* 451 * 32-bit code can use the signal return page 452 * except when the MPU has protected the vectors 453 * page from PL0 454 */ 455 retcode = mm->context.sigpage + signal_return_offset + 456 (idx << 2) + thumb; 457 } else 458 #endif 459 { 460 /* 461 * Ensure that the instruction cache sees 462 * the return code written onto the stack. 463 */ 464 flush_icache_range((unsigned long)rc, 465 (unsigned long)(rc + 3)); 466 467 retcode = ((unsigned long)rc) + thumb; 468 } 469 } 470 471 regs->ARM_r0 = ksig->sig; 472 regs->ARM_sp = (unsigned long)frame; 473 regs->ARM_lr = retcode; 474 regs->ARM_pc = handler; 475 if (fdpic) 476 regs->ARM_r9 = handler_fdpic_GOT; 477 regs->ARM_cpsr = cpsr; 478 479 return 0; 480 } 481 482 static int 483 setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs) 484 { 485 struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame)); 486 int err = 0; 487 488 if (!frame) 489 return 1; 490 491 /* 492 * Set uc.uc_flags to a value which sc.trap_no would never have. 493 */ 494 __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err); 495 496 err |= setup_sigframe(frame, regs, set); 497 if (err == 0) 498 err = setup_return(regs, ksig, frame->retcode, frame); 499 500 return err; 501 } 502 503 static int 504 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs) 505 { 506 struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame)); 507 int err = 0; 508 509 if (!frame) 510 return 1; 511 512 err |= copy_siginfo_to_user(&frame->info, &ksig->info); 513 514 __put_user_error(0, &frame->sig.uc.uc_flags, err); 515 __put_user_error(NULL, &frame->sig.uc.uc_link, err); 516 517 err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp); 518 err |= setup_sigframe(&frame->sig, regs, set); 519 if (err == 0) 520 err = setup_return(regs, ksig, frame->sig.retcode, frame); 521 522 if (err == 0) { 523 /* 524 * For realtime signals we must also set the second and third 525 * arguments for the signal handler. 526 * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06 527 */ 528 regs->ARM_r1 = (unsigned long)&frame->info; 529 regs->ARM_r2 = (unsigned long)&frame->sig.uc; 530 } 531 532 return err; 533 } 534 535 /* 536 * OK, we're invoking a handler 537 */ 538 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs) 539 { 540 sigset_t *oldset = sigmask_to_save(); 541 int ret; 542 543 /* 544 * Set up the stack frame 545 */ 546 if (ksig->ka.sa.sa_flags & SA_SIGINFO) 547 ret = setup_rt_frame(ksig, oldset, regs); 548 else 549 ret = setup_frame(ksig, oldset, regs); 550 551 /* 552 * Check that the resulting registers are actually sane. 553 */ 554 ret |= !valid_user_regs(regs); 555 556 signal_setup_done(ret, ksig, 0); 557 } 558 559 /* 560 * Note that 'init' is a special process: it doesn't get signals it doesn't 561 * want to handle. Thus you cannot kill init even with a SIGKILL even by 562 * mistake. 563 * 564 * Note that we go through the signals twice: once to check the signals that 565 * the kernel can handle, and then we build all the user-level signal handling 566 * stack-frames in one go after that. 567 */ 568 static int do_signal(struct pt_regs *regs, int syscall) 569 { 570 unsigned int retval = 0, continue_addr = 0, restart_addr = 0; 571 struct ksignal ksig; 572 int restart = 0; 573 574 /* 575 * If we were from a system call, check for system call restarting... 576 */ 577 if (syscall) { 578 continue_addr = regs->ARM_pc; 579 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4); 580 retval = regs->ARM_r0; 581 582 /* 583 * Prepare for system call restart. We do this here so that a 584 * debugger will see the already changed PSW. 585 */ 586 switch (retval) { 587 case -ERESTART_RESTARTBLOCK: 588 restart -= 2; 589 case -ERESTARTNOHAND: 590 case -ERESTARTSYS: 591 case -ERESTARTNOINTR: 592 restart++; 593 regs->ARM_r0 = regs->ARM_ORIG_r0; 594 regs->ARM_pc = restart_addr; 595 break; 596 } 597 } 598 599 /* 600 * Get the signal to deliver. When running under ptrace, at this 601 * point the debugger may change all our registers ... 602 */ 603 /* 604 * Depending on the signal settings we may need to revert the 605 * decision to restart the system call. But skip this if a 606 * debugger has chosen to restart at a different PC. 607 */ 608 if (get_signal(&ksig)) { 609 /* handler */ 610 if (unlikely(restart) && regs->ARM_pc == restart_addr) { 611 if (retval == -ERESTARTNOHAND || 612 retval == -ERESTART_RESTARTBLOCK 613 || (retval == -ERESTARTSYS 614 && !(ksig.ka.sa.sa_flags & SA_RESTART))) { 615 regs->ARM_r0 = -EINTR; 616 regs->ARM_pc = continue_addr; 617 } 618 } 619 handle_signal(&ksig, regs); 620 } else { 621 /* no handler */ 622 restore_saved_sigmask(); 623 if (unlikely(restart) && regs->ARM_pc == restart_addr) { 624 regs->ARM_pc = continue_addr; 625 return restart; 626 } 627 } 628 return 0; 629 } 630 631 asmlinkage int 632 do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall) 633 { 634 /* 635 * The assembly code enters us with IRQs off, but it hasn't 636 * informed the tracing code of that for efficiency reasons. 637 * Update the trace code with the current status. 638 */ 639 trace_hardirqs_off(); 640 do { 641 if (likely(thread_flags & _TIF_NEED_RESCHED)) { 642 schedule(); 643 } else { 644 if (unlikely(!user_mode(regs))) 645 return 0; 646 local_irq_enable(); 647 if (thread_flags & _TIF_SIGPENDING) { 648 int restart = do_signal(regs, syscall); 649 if (unlikely(restart)) { 650 /* 651 * Restart without handlers. 652 * Deal with it without leaving 653 * the kernel space. 654 */ 655 return restart; 656 } 657 syscall = 0; 658 } else if (thread_flags & _TIF_UPROBE) { 659 uprobe_notify_resume(regs); 660 } else { 661 clear_thread_flag(TIF_NOTIFY_RESUME); 662 tracehook_notify_resume(regs); 663 } 664 } 665 local_irq_disable(); 666 thread_flags = current_thread_info()->flags; 667 } while (thread_flags & _TIF_WORK_MASK); 668 return 0; 669 } 670 671 struct page *get_signal_page(void) 672 { 673 unsigned long ptr; 674 unsigned offset; 675 struct page *page; 676 void *addr; 677 678 page = alloc_pages(GFP_KERNEL, 0); 679 680 if (!page) 681 return NULL; 682 683 addr = page_address(page); 684 685 /* Give the signal return code some randomness */ 686 offset = 0x200 + (get_random_int() & 0x7fc); 687 signal_return_offset = offset; 688 689 /* 690 * Copy signal return handlers into the vector page, and 691 * set sigreturn to be a pointer to these. 692 */ 693 memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes)); 694 695 ptr = (unsigned long)addr + offset; 696 flush_icache_range(ptr, ptr + sizeof(sigreturn_codes)); 697 698 return page; 699 } 700 701 /* Defer to generic check */ 702 asmlinkage void addr_limit_check_failed(void) 703 { 704 addr_limit_user_check(); 705 } 706