arch/parisc/kernel/signal.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/arch/parisc/kernel/signal.c: Architecture-specific signal
   4  *  handling support.
   5  *
   6  *  Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
   7  *  Copyright (C) 2000 Linuxcare, Inc.
   8  *
   9  *  Based on the ia64, i386, and alpha versions.
  10  *
  11  *  Like the IA-64, we are a recent enough port (we are *starting*
  12  *  with glibc2.2) that we do not need to support the old non-realtime
  13  *  Linux signals.  Therefore we don't.
  14  */
  15
  16 #include <linux/sched.h>
  17 #include <linux/sched/debug.h>
  18 #include <linux/mm.h>
  19 #include <linux/smp.h>
  20 #include <linux/kernel.h>
  21 #include <linux/signal.h>
  22 #include <linux/errno.h>
  23 #include <linux/wait.h>
  24 #include <linux/ptrace.h>
  25 #include <linux/tracehook.h>
  26 #include <linux/unistd.h>
  27 #include <linux/stddef.h>
  28 #include <linux/compat.h>
  29 #include <linux/elf.h>
  30 #include <asm/ucontext.h>
  31 #include <asm/rt_sigframe.h>
  32 #include <linux/uaccess.h>
  33 #include <asm/pgalloc.h>
  34 #include <asm/cacheflush.h>
  35 #include <asm/asm-offsets.h>
  36
  37 #ifdef CONFIG_COMPAT
  38 #include "signal32.h"
  39 #endif
  40
  41 #define DEBUG_SIG 0
  42 #define DEBUG_SIG_LEVEL 2
  43
  44 #if DEBUG_SIG
  45 #define DBG(LEVEL, ...) \
  46         ((DEBUG_SIG_LEVEL >= LEVEL) \
  47         ? printk(__VA_ARGS__) : (void) 0)
  48 #else
  49 #define DBG(LEVEL, ...)
  50 #endif
  51
  52 /* gcc will complain if a pointer is cast to an integer of different
  53  * size.  If you really need to do this (and we do for an ELF32 user
  54  * application in an ELF64 kernel) then you have to do a cast to an
  55  * integer of the same size first.  The A() macro accomplishes
  56  * this. */
  57 #define A(__x)  ((unsigned long)(__x))
  58
  59 /*
  60  * Do a signal return - restore sigcontext.
  61  */
  62
  63 /* Trampoline for calling rt_sigreturn() */
  64 #define INSN_LDI_R25_0   0x34190000 /* ldi  0,%r25 (in_syscall=0) */
  65 #define INSN_LDI_R25_1   0x34190002 /* ldi  1,%r25 (in_syscall=1) */
  66 #define INSN_LDI_R20     0x3414015a /* ldi  __NR_rt_sigreturn,%r20 */
  67 #define INSN_BLE_SR2_R0  0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
  68 #define INSN_NOP         0x08000240 /* nop */
  69 /* For debugging */
  70 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
  71
  72 static long
  73 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
  74 {
  75         long err = 0;
  76
  77         err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
  78         err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
  79         err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
  80         err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
  81         err |= __get_user(regs->sar, &sc->sc_sar);
  82         DBG(2,"restore_sigcontext: iaoq is %#lx / %#lx\n",
  83                         regs->iaoq[0],regs->iaoq[1]);
  84         DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
  85         return err;
  86 }
  87
  88 void
  89 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
  90 {
  91         struct rt_sigframe __user *frame;
  92         sigset_t set;
  93         unsigned long usp = (regs->gr[30] & ~(0x01UL));
  94         unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
  95 #ifdef CONFIG_64BIT
  96         compat_sigset_t compat_set;
  97         struct compat_rt_sigframe __user * compat_frame;
  98
  99         if (is_compat_task())
 100                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 101 #endif
 102
 103         current->restart_block.fn = do_no_restart_syscall;
 104
 105         /* Unwind the user stack to get the rt_sigframe structure. */
 106         frame = (struct rt_sigframe __user *)
 107                 (usp - sigframe_size);
 108         DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
 109
 110         regs->orig_r28 = 1; /* no restarts for sigreturn */
 111
 112 #ifdef CONFIG_64BIT
 113         compat_frame = (struct compat_rt_sigframe __user *)frame;
 114
 115         if (is_compat_task()) {
 116                 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
 117                 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
 118                         goto give_sigsegv;
 119                 sigset_32to64(&set,&compat_set);
 120         } else
 121 #endif
 122         {
 123                 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 124                         goto give_sigsegv;
 125         }
 126
 127         set_current_blocked(&set);
 128
 129         /* Good thing we saved the old gr[30], eh? */
 130 #ifdef CONFIG_64BIT
 131         if (is_compat_task()) {
 132                 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
 133                                 &compat_frame->uc.uc_mcontext);
 134 // FIXME: Load upper half from register file
 135                 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
 136                                         &compat_frame->regs, regs))
 137                         goto give_sigsegv;
 138                 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
 139                                 usp, &compat_frame->uc.uc_stack);
 140                 if (compat_restore_altstack(&compat_frame->uc.uc_stack))
 141                         goto give_sigsegv;
 142         } else
 143 #endif
 144         {
 145                 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
 146                                 &frame->uc.uc_mcontext);
 147                 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
 148                         goto give_sigsegv;
 149                 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
 150                                 usp, &frame->uc.uc_stack);
 151                 if (restore_altstack(&frame->uc.uc_stack))
 152                         goto give_sigsegv;
 153         }
 154
 155
 156
 157         /* If we are on the syscall path IAOQ will not be restored, and
 158          * if we are on the interrupt path we must not corrupt gr31.
 159          */
 160         if (in_syscall)
 161                 regs->gr[31] = regs->iaoq[0];
 162 #if DEBUG_SIG
 163         DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
 164         show_regs(regs);
 165 #endif
 166         return;
 167
 168 give_sigsegv:
 169         DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
 170         force_sig(SIGSEGV, current);
 171         return;
 172 }
 173
 174 /*
 175  * Set up a signal frame.
 176  */
 177
 178 static inline void __user *
 179 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 180 {
 181         /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
 182           don't use the parameter it doesn't matter */
 183
 184         DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
 185                         (unsigned long)ka, sp, frame_size);
 186
 187         /* Align alternate stack and reserve 64 bytes for the signal
 188            handler's frame marker.  */
 189         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 190                 sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */
 191
 192         DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
 193         return (void __user *) sp; /* Stacks grow up.  Fun. */
 194 }
 195
 196 static long
 197 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
 198
 199 {
 200         unsigned long flags = 0;
 201         long err = 0;
 202
 203         if (on_sig_stack((unsigned long) sc))
 204                 flags |= PARISC_SC_FLAG_ONSTACK;
 205         if (in_syscall) {
 206                 flags |= PARISC_SC_FLAG_IN_SYSCALL;
 207                 /* regs->iaoq is undefined in the syscall return path */
 208                 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
 209                 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
 210                 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
 211                 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
 212                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
 213                         regs->gr[31], regs->gr[31]+4);
 214         } else {
 215                 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
 216                 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
 217                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
 218                         regs->iaoq[0], regs->iaoq[1]);
 219         }
 220
 221         err |= __put_user(flags, &sc->sc_flags);
 222         err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
 223         err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
 224         err |= __put_user(regs->sar, &sc->sc_sar);
 225         DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
 226
 227         return err;
 228 }
 229
 230 static long
 231 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs,
 232                int in_syscall)
 233 {
 234         struct rt_sigframe __user *frame;
 235         unsigned long rp, usp;
 236         unsigned long haddr, sigframe_size;
 237         unsigned long start, end;
 238         int err = 0;
 239 #ifdef CONFIG_64BIT
 240         struct compat_rt_sigframe __user * compat_frame;
 241         compat_sigset_t compat_set;
 242 #endif
 243
 244         usp = (regs->gr[30] & ~(0x01UL));
 245 #ifdef CONFIG_64BIT
 246         if (is_compat_task()) {
 247                 /* The gcc alloca implementation leaves garbage in the upper 32 bits of sp */
 248                 usp = (compat_uint_t)usp;
 249         }
 250 #endif
 251         /*FIXME: frame_size parameter is unused, remove it. */
 252         frame = get_sigframe(&ksig->ka, usp, sizeof(*frame));
 253
 254         DBG(1,"SETUP_RT_FRAME: START\n");
 255         DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->info);
 256
 257
 258 #ifdef CONFIG_64BIT
 259
 260         compat_frame = (struct compat_rt_sigframe __user *)frame;
 261
 262         if (is_compat_task()) {
 263                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
 264                 err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
 265                 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
 266                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
 267                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
 268                 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
 269                                         &compat_frame->regs, regs, in_syscall);
 270                 sigset_64to32(&compat_set,set);
 271                 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
 272         } else
 273 #endif
 274         {
 275                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
 276                 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 277                 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
 278                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
 279                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
 280                 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
 281                 /* FIXME: Should probably be converted as well for the compat case */
 282                 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 283         }
 284
 285         if (err)
 286                 return -EFAULT;
 287
 288         /* Set up to return from userspace.  If provided, use a stub
 289            already in userspace. The first words of tramp are used to
 290            save the previous sigrestartblock trampoline that might be
 291            on the stack. We start the sigreturn trampoline at
 292            SIGRESTARTBLOCK_TRAMP+X. */
 293         err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
 294                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
 295         err |= __put_user(INSN_LDI_R20,
 296                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
 297         err |= __put_user(INSN_BLE_SR2_R0,
 298                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
 299         err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
 300
 301 #if DEBUG_SIG
 302         /* Assert that we're flushing in the correct space... */
 303         {
 304                 unsigned long sid;
 305                 asm ("mfsp %%sr3,%0" : "=r" (sid));
 306                 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
 307                        sid, frame->tramp);
 308         }
 309 #endif
 310
 311         start = (unsigned long) &frame->tramp[0];
 312         end = (unsigned long) &frame->tramp[TRAMP_SIZE];
 313         flush_user_dcache_range_asm(start, end);
 314         flush_user_icache_range_asm(start, end);
 315
 316         /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
 317          * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
 318          * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
 319          */
 320         rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
 321
 322         if (err)
 323                 return -EFAULT;
 324
 325         haddr = A(ksig->ka.sa.sa_handler);
 326         /* The sa_handler may be a pointer to a function descriptor */
 327 #ifdef CONFIG_64BIT
 328         if (is_compat_task()) {
 329 #endif
 330                 if (haddr & PA_PLABEL_FDESC) {
 331                         Elf32_Fdesc fdesc;
 332                         Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
 333
 334                         err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
 335
 336                         if (err)
 337                                 return -EFAULT;
 338
 339                         haddr = fdesc.addr;
 340                         regs->gr[19] = fdesc.gp;
 341                 }
 342 #ifdef CONFIG_64BIT
 343         } else {
 344                 Elf64_Fdesc fdesc;
 345                 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
 346
 347                 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
 348
 349                 if (err)
 350                         return -EFAULT;
 351
 352                 haddr = fdesc.addr;
 353                 regs->gr[19] = fdesc.gp;
 354                 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
 355                      haddr, regs->gr[19], in_syscall);
 356         }
 357 #endif
 358
 359         /* The syscall return path will create IAOQ values from r31.
 360          */
 361         sigframe_size = PARISC_RT_SIGFRAME_SIZE;
 362 #ifdef CONFIG_64BIT
 363         if (is_compat_task())
 364                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 365 #endif
 366         if (in_syscall) {
 367                 regs->gr[31] = haddr;
 368 #ifdef CONFIG_64BIT
 369                 if (!test_thread_flag(TIF_32BIT))
 370                         sigframe_size |= 1;
 371 #endif
 372         } else {
 373                 unsigned long psw = USER_PSW;
 374 #ifdef CONFIG_64BIT
 375                 if (!test_thread_flag(TIF_32BIT))
 376                         psw |= PSW_W;
 377 #endif
 378
 379                 /* If we are singlestepping, arrange a trap to be delivered
 380                    when we return to userspace. Note the semantics -- we
 381                    should trap before the first insn in the handler is
 382                    executed. Ref:
 383                         http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
 384                  */
 385                 if (pa_psw(current)->r) {
 386                         pa_psw(current)->r = 0;
 387                         psw |= PSW_R;
 388                         mtctl(-1, 0);
 389                 }
 390
 391                 regs->gr[0] = psw;
 392                 regs->iaoq[0] = haddr | 3;
 393                 regs->iaoq[1] = regs->iaoq[0] + 4;
 394         }
 395
 396         regs->gr[2]  = rp;                /* userland return pointer */
 397         regs->gr[26] = ksig->sig;               /* signal number */
 398
 399 #ifdef CONFIG_64BIT
 400         if (is_compat_task()) {
 401                 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
 402                 regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
 403         } else
 404 #endif
 405         {
 406                 regs->gr[25] = A(&frame->info); /* siginfo pointer */
 407                 regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
 408         }
 409
 410         DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
 411                regs->gr[30], sigframe_size,
 412                regs->gr[30] + sigframe_size);
 413         /* Raise the user stack pointer to make a proper call frame. */
 414         regs->gr[30] = (A(frame) + sigframe_size);
 415
 416
 417         DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
 418                current->comm, current->pid, frame, regs->gr[30],
 419                regs->iaoq[0], regs->iaoq[1], rp);
 420
 421         return 0;
 422 }
 423
 424 /*
 425  * OK, we're invoking a handler.
 426  */
 427
 428 static void
 429 handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
 430 {
 431         int ret;
 432         sigset_t *oldset = sigmask_to_save();
 433
 434         DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
 435                ksig->sig, ksig->ka, ksig->info, oldset, regs);
 436
 437         /* Set up the stack frame */
 438         ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
 439
 440         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
 441                           test_thread_flag(TIF_BLOCKSTEP));
 442
 443         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
 444                 regs->gr[28]);
 445 }
 446
 447 /*
 448  * Check how the syscall number gets loaded into %r20 within
 449  * the delay branch in userspace and adjust as needed.
 450  */
 451
 452 static void check_syscallno_in_delay_branch(struct pt_regs *regs)
 453 {
 454         u32 opcode, source_reg;
 455         u32 __user *uaddr;
 456         int err;
 457
 458         /* Usually we don't have to restore %r20 (the system call number)
 459          * because it gets loaded in the delay slot of the branch external
 460          * instruction via the ldi instruction.
 461          * In some cases a register-to-register copy instruction might have
 462          * been used instead, in which case we need to copy the syscall
 463          * number into the source register before returning to userspace.
 464          */
 465
 466         /* A syscall is just a branch, so all we have to do is fiddle the
 467          * return pointer so that the ble instruction gets executed again.
 468          */
 469         regs->gr[31] -= 8; /* delayed branching */
 470
 471         /* Get assembler opcode of code in delay branch */
 472         uaddr = (unsigned int *) ((regs->gr[31] & ~3) + 4);
 473         err = get_user(opcode, uaddr);
 474         if (err)
 475                 return;
 476
 477         /* Check if delay branch uses "ldi int,%r20" */
 478         if ((opcode & 0xffff0000) == 0x34140000)
 479                 return; /* everything ok, just return */
 480
 481         /* Check if delay branch uses "nop" */
 482         if (opcode == INSN_NOP)
 483                 return;
 484
 485         /* Check if delay branch uses "copy %rX,%r20" */
 486         if ((opcode & 0xffe0ffff) == 0x08000254) {
 487                 source_reg = (opcode >> 16) & 31;
 488                 regs->gr[source_reg] = regs->gr[20];
 489                 return;
 490         }
 491
 492         pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
 493                 current->comm, task_pid_nr(current), opcode);
 494 }
 495
 496 static inline void
 497 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 498 {
 499         if (regs->orig_r28)
 500                 return;
 501         regs->orig_r28 = 1; /* no more restarts */
 502         /* Check the return code */
 503         switch (regs->gr[28]) {
 504         case -ERESTART_RESTARTBLOCK:
 505         case -ERESTARTNOHAND:
 506                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
 507                 regs->gr[28] = -EINTR;
 508                 break;
 509
 510         case -ERESTARTSYS:
 511                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 512                         DBG(1,"ERESTARTSYS: putting -EINTR\n");
 513                         regs->gr[28] = -EINTR;
 514                         break;
 515                 }
 516                 /* fallthrough */
 517         case -ERESTARTNOINTR:
 518                 check_syscallno_in_delay_branch(regs);
 519                 break;
 520         }
 521 }
 522
 523 static inline void
 524 insert_restart_trampoline(struct pt_regs *regs)
 525 {
 526         if (regs->orig_r28)
 527                 return;
 528         regs->orig_r28 = 1; /* no more restarts */
 529         switch(regs->gr[28]) {
 530         case -ERESTART_RESTARTBLOCK: {
 531                 /* Restart the system call - no handlers present */
 532                 unsigned int *usp = (unsigned int *)regs->gr[30];
 533                 unsigned long start = (unsigned long) &usp[2];
 534                 unsigned long end  = (unsigned long) &usp[5];
 535                 long err = 0;
 536
 537                 /* Setup a trampoline to restart the syscall
 538                  * with __NR_restart_syscall
 539                  *
 540                  *  0: <return address (orig r31)>
 541                  *  4: <2nd half for 64-bit>
 542                  *  8: ldw 0(%sp), %r31
 543                  * 12: be 0x100(%sr2, %r0)
 544                  * 16: ldi __NR_restart_syscall, %r20
 545                  */
 546 #ifdef CONFIG_64BIT
 547                 err |= put_user(regs->gr[31] >> 32, &usp[0]);
 548                 err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
 549                 err |= put_user(0x0fc010df, &usp[2]);
 550 #else
 551                 err |= put_user(regs->gr[31], &usp[0]);
 552                 err |= put_user(0x0fc0109f, &usp[2]);
 553 #endif
 554                 err |= put_user(0xe0008200, &usp[3]);
 555                 err |= put_user(0x34140000, &usp[4]);
 556
 557                 WARN_ON(err);
 558
 559                 /* flush data/instruction cache for new insns */
 560                 flush_user_dcache_range_asm(start, end);
 561                 flush_user_icache_range_asm(start, end);
 562
 563                 regs->gr[31] = regs->gr[30] + 8;
 564                 return;
 565         }
 566         case -ERESTARTNOHAND:
 567         case -ERESTARTSYS:
 568         case -ERESTARTNOINTR:
 569                 check_syscallno_in_delay_branch(regs);
 570                 return;
 571         default:
 572                 break;
 573         }
 574 }
 575
 576 /*
 577  * Note that 'init' is a special process: it doesn't get signals it doesn't
 578  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 579  * mistake.
 580  *
 581  * We need to be able to restore the syscall arguments (r21-r26) to
 582  * restart syscalls.  Thus, the syscall path should save them in the
 583  * pt_regs structure (it's okay to do so since they are caller-save
 584  * registers).  As noted below, the syscall number gets restored for
 585  * us due to the magic of delayed branching.
 586  */
 587 asmlinkage void
 588 do_signal(struct pt_regs *regs, long in_syscall)
 589 {
 590         struct ksignal ksig;
 591
 592         DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
 593                regs, regs->sr[7], in_syscall);
 594
 595         if (get_signal(&ksig)) {
 596                 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
 597                 /* Restart a system call if necessary. */
 598                 if (in_syscall)
 599                         syscall_restart(regs, &ksig.ka);
 600
 601                 handle_signal(&ksig, regs, in_syscall);
 602                 return;
 603         }
 604
 605         /* Did we come from a system call? */
 606         if (in_syscall)
 607                 insert_restart_trampoline(regs);
 608
 609         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
 610                 regs->gr[28]);
 611
 612         restore_saved_sigmask();
 613 }
 614
 615 void do_notify_resume(struct pt_regs *regs, long in_syscall)
 616 {
 617         if (test_thread_flag(TIF_SIGPENDING))
 618                 do_signal(regs, in_syscall);
 619
 620         if (test_thread_flag(TIF_NOTIFY_RESUME)) {
 621                 clear_thread_flag(TIF_NOTIFY_RESUME);
 622                 tracehook_notify_resume(regs);
 623         }
 624 }