arch/arm/kernel/signal.c

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