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