arch/arm/kernel/signal.c

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