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