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 (thumb) {
 357                         cpsr |= PSR_T_BIT;
 358 #if __LINUX_ARM_ARCH__ >= 7
 359                         /* clear the If-Then Thumb-2 execution state */
 360                         cpsr &= ~PSR_IT_MASK;
 361 #endif
 362                 } else
 363                         cpsr &= ~PSR_T_BIT;
 364         }
 365 #endif
 366
 367         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 368                 retcode = (unsigned long)ksig->ka.sa.sa_restorer;
 369         } else {
 370                 unsigned int idx = thumb << 1;
 371
 372                 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 373                         idx += 3;
 374
 375                 if (__put_user(sigreturn_codes[idx],   rc) ||
 376                     __put_user(sigreturn_codes[idx+1], rc+1))
 377                         return 1;
 378
 379 #ifdef CONFIG_MMU
 380                 if (cpsr & MODE32_BIT) {
 381                         struct mm_struct *mm = current->mm;
 382                         /*
 383                          * 32-bit code can use the signal return page
 384                          * except when the MPU has protected the vectors
 385                          * page from PL0
 386                          */
 387                         retcode = mm->context.sigpage + signal_return_offset +
 388                                   (idx << 2) + thumb;
 389                 } else
 390 #endif
 391                 {
 392                         /*
 393                          * Ensure that the instruction cache sees
 394                          * the return code written onto the stack.
 395                          */
 396                         flush_icache_range((unsigned long)rc,
 397                                            (unsigned long)(rc + 2));
 398
 399                         retcode = ((unsigned long)rc) + thumb;
 400                 }
 401         }
 402
 403         regs->ARM_r0 = map_sig(ksig->sig);
 404         regs->ARM_sp = (unsigned long)frame;
 405         regs->ARM_lr = retcode;
 406         regs->ARM_pc = handler;
 407         regs->ARM_cpsr = cpsr;
 408
 409         return 0;
 410 }
 411
 412 static int
 413 setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 414 {
 415         struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
 416         int err = 0;
 417
 418         if (!frame)
 419                 return 1;
 420
 421         /*
 422          * Set uc.uc_flags to a value which sc.trap_no would never have.
 423          */
 424         __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
 425
 426         err |= setup_sigframe(frame, regs, set);
 427         if (err == 0)
 428                 err = setup_return(regs, ksig, frame->retcode, frame);
 429
 430         return err;
 431 }
 432
 433 static int
 434 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
 435 {
 436         struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
 437         int err = 0;
 438
 439         if (!frame)
 440                 return 1;
 441
 442         err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 443
 444         __put_user_error(0, &frame->sig.uc.uc_flags, err);
 445         __put_user_error(NULL, &frame->sig.uc.uc_link, err);
 446
 447         err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
 448         err |= setup_sigframe(&frame->sig, regs, set);
 449         if (err == 0)
 450                 err = setup_return(regs, ksig, frame->sig.retcode, frame);
 451
 452         if (err == 0) {
 453                 /*
 454                  * For realtime signals we must also set the second and third
 455                  * arguments for the signal handler.
 456                  *   -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
 457                  */
 458                 regs->ARM_r1 = (unsigned long)&frame->info;
 459                 regs->ARM_r2 = (unsigned long)&frame->sig.uc;
 460         }
 461
 462         return err;
 463 }
 464
 465 /*
 466  * OK, we're invoking a handler
 467  */
 468 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
 469 {
 470         sigset_t *oldset = sigmask_to_save();
 471         int ret;
 472
 473         /*
 474          * Set up the stack frame
 475          */
 476         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 477                 ret = setup_rt_frame(ksig, oldset, regs);
 478         else
 479                 ret = setup_frame(ksig, oldset, regs);
 480
 481         /*
 482          * Check that the resulting registers are actually sane.
 483          */
 484         ret |= !valid_user_regs(regs);
 485
 486         signal_setup_done(ret, ksig, 0);
 487 }
 488
 489 /*
 490  * Note that 'init' is a special process: it doesn't get signals it doesn't
 491  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 492  * mistake.
 493  *
 494  * Note that we go through the signals twice: once to check the signals that
 495  * the kernel can handle, and then we build all the user-level signal handling
 496  * stack-frames in one go after that.
 497  */
 498 static int do_signal(struct pt_regs *regs, int syscall)
 499 {
 500         unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
 501         struct ksignal ksig;
 502         int restart = 0;
 503
 504         /*
 505          * If we were from a system call, check for system call restarting...
 506          */
 507         if (syscall) {
 508                 continue_addr = regs->ARM_pc;
 509                 restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
 510                 retval = regs->ARM_r0;
 511
 512                 /*
 513                  * Prepare for system call restart.  We do this here so that a
 514                  * debugger will see the already changed PSW.
 515                  */
 516                 switch (retval) {
 517                 case -ERESTART_RESTARTBLOCK:
 518                         restart -= 2;
 519                 case -ERESTARTNOHAND:
 520                 case -ERESTARTSYS:
 521                 case -ERESTARTNOINTR:
 522                         restart++;
 523                         regs->ARM_r0 = regs->ARM_ORIG_r0;
 524                         regs->ARM_pc = restart_addr;
 525                         break;
 526                 }
 527         }
 528
 529         /*
 530          * Get the signal to deliver.  When running under ptrace, at this
 531          * point the debugger may change all our registers ...
 532          */
 533         /*
 534          * Depending on the signal settings we may need to revert the
 535          * decision to restart the system call.  But skip this if a
 536          * debugger has chosen to restart at a different PC.
 537          */
 538         if (get_signal(&ksig)) {
 539                 /* handler */
 540                 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
 541                         if (retval == -ERESTARTNOHAND ||
 542                             retval == -ERESTART_RESTARTBLOCK
 543                             || (retval == -ERESTARTSYS
 544                                 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
 545                                 regs->ARM_r0 = -EINTR;
 546                                 regs->ARM_pc = continue_addr;
 547                         }
 548                 }
 549                 handle_signal(&ksig, regs);
 550         } else {
 551                 /* no handler */
 552                 restore_saved_sigmask();
 553                 if (unlikely(restart) && regs->ARM_pc == restart_addr) {
 554                         regs->ARM_pc = continue_addr;
 555                         return restart;
 556                 }
 557         }
 558         return 0;
 559 }
 560
 561 asmlinkage int
 562 do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
 563 {
 564         do {
 565                 if (likely(thread_flags & _TIF_NEED_RESCHED)) {
 566                         schedule();
 567                 } else {
 568                         if (unlikely(!user_mode(regs)))
 569                                 return 0;
 570                         local_irq_enable();
 571                         if (thread_flags & _TIF_SIGPENDING) {
 572                                 int restart = do_signal(regs, syscall);
 573                                 if (unlikely(restart)) {
 574                                         /*
 575                                          * Restart without handlers.
 576                                          * Deal with it without leaving
 577                                          * the kernel space.
 578                                          */
 579                                         return restart;
 580                                 }
 581                                 syscall = 0;
 582                         } else {
 583                                 clear_thread_flag(TIF_NOTIFY_RESUME);
 584                                 tracehook_notify_resume(regs);
 585                         }
 586                 }
 587                 local_irq_disable();
 588                 thread_flags = current_thread_info()->flags;
 589         } while (thread_flags & _TIF_WORK_MASK);
 590         return 0;
 591 }
 592
 593 struct page *get_signal_page(void)
 594 {
 595         unsigned long ptr;
 596         unsigned offset;
 597         struct page *page;
 598         void *addr;
 599
 600         page = alloc_pages(GFP_KERNEL, 0);
 601
 602         if (!page)
 603                 return NULL;
 604
 605         addr = page_address(page);
 606
 607         /* Give the signal return code some randomness */
 608         offset = 0x200 + (get_random_int() & 0x7fc);
 609         signal_return_offset = offset;
 610
 611         /*
 612          * Copy signal return handlers into the vector page, and
 613          * set sigreturn to be a pointer to these.
 614          */
 615         memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
 616
 617         ptr = (unsigned long)addr + offset;
 618         flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
 619
 620         return page;
 621 }