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         /*FIXME: frame_size parameter is unused, remove it. */
 246         frame = get_sigframe(&ksig->ka, usp, sizeof(*frame));
 247
 248         DBG(1,"SETUP_RT_FRAME: START\n");
 249         DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->info);
 250
 251
 252 #ifdef CONFIG_64BIT
 253
 254         compat_frame = (struct compat_rt_sigframe __user *)frame;
 255
 256         if (is_compat_task()) {
 257                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
 258                 err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
 259                 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
 260                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
 261                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
 262                 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
 263                                         &compat_frame->regs, regs, in_syscall);
 264                 sigset_64to32(&compat_set,set);
 265                 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
 266         } else
 267 #endif
 268         {
 269                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
 270                 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
 271                 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
 272                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
 273                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
 274                 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
 275                 /* FIXME: Should probably be converted as well for the compat case */
 276                 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 277         }
 278
 279         if (err)
 280                 return -EFAULT;
 281
 282         /* Set up to return from userspace.  If provided, use a stub
 283            already in userspace. The first words of tramp are used to
 284            save the previous sigrestartblock trampoline that might be
 285            on the stack. We start the sigreturn trampoline at
 286            SIGRESTARTBLOCK_TRAMP+X. */
 287         err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
 288                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
 289         err |= __put_user(INSN_LDI_R20,
 290                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
 291         err |= __put_user(INSN_BLE_SR2_R0,
 292                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
 293         err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
 294
 295 #if DEBUG_SIG
 296         /* Assert that we're flushing in the correct space... */
 297         {
 298                 unsigned long sid;
 299                 asm ("mfsp %%sr3,%0" : "=r" (sid));
 300                 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
 301                        sid, frame->tramp);
 302         }
 303 #endif
 304
 305         start = (unsigned long) &frame->tramp[0];
 306         end = (unsigned long) &frame->tramp[TRAMP_SIZE];
 307         flush_user_dcache_range_asm(start, end);
 308         flush_user_icache_range_asm(start, end);
 309
 310         /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
 311          * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
 312          * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
 313          */
 314         rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
 315
 316         if (err)
 317                 return -EFAULT;
 318
 319         haddr = A(ksig->ka.sa.sa_handler);
 320         /* The sa_handler may be a pointer to a function descriptor */
 321 #ifdef CONFIG_64BIT
 322         if (is_compat_task()) {
 323 #endif
 324                 if (haddr & PA_PLABEL_FDESC) {
 325                         Elf32_Fdesc fdesc;
 326                         Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
 327
 328                         err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
 329
 330                         if (err)
 331                                 return -EFAULT;
 332
 333                         haddr = fdesc.addr;
 334                         regs->gr[19] = fdesc.gp;
 335                 }
 336 #ifdef CONFIG_64BIT
 337         } else {
 338                 Elf64_Fdesc fdesc;
 339                 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
 340
 341                 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
 342
 343                 if (err)
 344                         return -EFAULT;
 345
 346                 haddr = fdesc.addr;
 347                 regs->gr[19] = fdesc.gp;
 348                 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
 349                      haddr, regs->gr[19], in_syscall);
 350         }
 351 #endif
 352
 353         /* The syscall return path will create IAOQ values from r31.
 354          */
 355         sigframe_size = PARISC_RT_SIGFRAME_SIZE;
 356 #ifdef CONFIG_64BIT
 357         if (is_compat_task())
 358                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
 359 #endif
 360         if (in_syscall) {
 361                 regs->gr[31] = haddr;
 362 #ifdef CONFIG_64BIT
 363                 if (!test_thread_flag(TIF_32BIT))
 364                         sigframe_size |= 1;
 365 #endif
 366         } else {
 367                 unsigned long psw = USER_PSW;
 368 #ifdef CONFIG_64BIT
 369                 if (!test_thread_flag(TIF_32BIT))
 370                         psw |= PSW_W;
 371 #endif
 372
 373                 /* If we are singlestepping, arrange a trap to be delivered
 374                    when we return to userspace. Note the semantics -- we
 375                    should trap before the first insn in the handler is
 376                    executed. Ref:
 377                         http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
 378                  */
 379                 if (pa_psw(current)->r) {
 380                         pa_psw(current)->r = 0;
 381                         psw |= PSW_R;
 382                         mtctl(-1, 0);
 383                 }
 384
 385                 regs->gr[0] = psw;
 386                 regs->iaoq[0] = haddr | 3;
 387                 regs->iaoq[1] = regs->iaoq[0] + 4;
 388         }
 389
 390         regs->gr[2]  = rp;                /* userland return pointer */
 391         regs->gr[26] = ksig->sig;               /* signal number */
 392
 393 #ifdef CONFIG_64BIT
 394         if (is_compat_task()) {
 395                 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
 396                 regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
 397         } else
 398 #endif
 399         {
 400                 regs->gr[25] = A(&frame->info); /* siginfo pointer */
 401                 regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
 402         }
 403
 404         DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
 405                regs->gr[30], sigframe_size,
 406                regs->gr[30] + sigframe_size);
 407         /* Raise the user stack pointer to make a proper call frame. */
 408         regs->gr[30] = (A(frame) + sigframe_size);
 409
 410
 411         DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
 412                current->comm, current->pid, frame, regs->gr[30],
 413                regs->iaoq[0], regs->iaoq[1], rp);
 414
 415         return 0;
 416 }
 417
 418 /*
 419  * OK, we're invoking a handler.
 420  */
 421
 422 static void
 423 handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
 424 {
 425         int ret;
 426         sigset_t *oldset = sigmask_to_save();
 427
 428         DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
 429                ksig->sig, ksig->ka, ksig->info, oldset, regs);
 430
 431         /* Set up the stack frame */
 432         ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
 433
 434         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
 435                           test_thread_flag(TIF_BLOCKSTEP));
 436
 437         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
 438                 regs->gr[28]);
 439 }
 440
 441 /*
 442  * Check how the syscall number gets loaded into %r20 within
 443  * the delay branch in userspace and adjust as needed.
 444  */
 445
 446 static void check_syscallno_in_delay_branch(struct pt_regs *regs)
 447 {
 448         u32 opcode, source_reg;
 449         u32 __user *uaddr;
 450         int err;
 451
 452         /* Usually we don't have to restore %r20 (the system call number)
 453          * because it gets loaded in the delay slot of the branch external
 454          * instruction via the ldi instruction.
 455          * In some cases a register-to-register copy instruction might have
 456          * been used instead, in which case we need to copy the syscall
 457          * number into the source register before returning to userspace.
 458          */
 459
 460         /* A syscall is just a branch, so all we have to do is fiddle the
 461          * return pointer so that the ble instruction gets executed again.
 462          */
 463         regs->gr[31] -= 8; /* delayed branching */
 464
 465         /* Get assembler opcode of code in delay branch */
 466         uaddr = (unsigned int *) ((regs->gr[31] & ~3) + 4);
 467         err = get_user(opcode, uaddr);
 468         if (err)
 469                 return;
 470
 471         /* Check if delay branch uses "ldi int,%r20" */
 472         if ((opcode & 0xffff0000) == 0x34140000)
 473                 return; /* everything ok, just return */
 474
 475         /* Check if delay branch uses "nop" */
 476         if (opcode == INSN_NOP)
 477                 return;
 478
 479         /* Check if delay branch uses "copy %rX,%r20" */
 480         if ((opcode & 0xffe0ffff) == 0x08000254) {
 481                 source_reg = (opcode >> 16) & 31;
 482                 regs->gr[source_reg] = regs->gr[20];
 483                 return;
 484         }
 485
 486         pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
 487                 current->comm, task_pid_nr(current), opcode);
 488 }
 489
 490 static inline void
 491 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 492 {
 493         if (regs->orig_r28)
 494                 return;
 495         regs->orig_r28 = 1; /* no more restarts */
 496         /* Check the return code */
 497         switch (regs->gr[28]) {
 498         case -ERESTART_RESTARTBLOCK:
 499         case -ERESTARTNOHAND:
 500                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
 501                 regs->gr[28] = -EINTR;
 502                 break;
 503
 504         case -ERESTARTSYS:
 505                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 506                         DBG(1,"ERESTARTSYS: putting -EINTR\n");
 507                         regs->gr[28] = -EINTR;
 508                         break;
 509                 }
 510                 /* fallthrough */
 511         case -ERESTARTNOINTR:
 512                 check_syscallno_in_delay_branch(regs);
 513                 break;
 514         }
 515 }
 516
 517 static inline void
 518 insert_restart_trampoline(struct pt_regs *regs)
 519 {
 520         if (regs->orig_r28)
 521                 return;
 522         regs->orig_r28 = 1; /* no more restarts */
 523         switch(regs->gr[28]) {
 524         case -ERESTART_RESTARTBLOCK: {
 525                 /* Restart the system call - no handlers present */
 526                 unsigned int *usp = (unsigned int *)regs->gr[30];
 527                 unsigned long start = (unsigned long) &usp[2];
 528                 unsigned long end  = (unsigned long) &usp[5];
 529                 long err = 0;
 530
 531                 /* Setup a trampoline to restart the syscall
 532                  * with __NR_restart_syscall
 533                  *
 534                  *  0: <return address (orig r31)>
 535                  *  4: <2nd half for 64-bit>
 536                  *  8: ldw 0(%sp), %r31
 537                  * 12: be 0x100(%sr2, %r0)
 538                  * 16: ldi __NR_restart_syscall, %r20
 539                  */
 540 #ifdef CONFIG_64BIT
 541                 err |= put_user(regs->gr[31] >> 32, &usp[0]);
 542                 err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
 543                 err |= put_user(0x0fc010df, &usp[2]);
 544 #else
 545                 err |= put_user(regs->gr[31], &usp[0]);
 546                 err |= put_user(0x0fc0109f, &usp[2]);
 547 #endif
 548                 err |= put_user(0xe0008200, &usp[3]);
 549                 err |= put_user(0x34140000, &usp[4]);
 550
 551                 WARN_ON(err);
 552
 553                 /* flush data/instruction cache for new insns */
 554                 flush_user_dcache_range_asm(start, end);
 555                 flush_user_icache_range_asm(start, end);
 556
 557                 regs->gr[31] = regs->gr[30] + 8;
 558                 return;
 559         }
 560         case -ERESTARTNOHAND:
 561         case -ERESTARTSYS:
 562         case -ERESTARTNOINTR:
 563                 check_syscallno_in_delay_branch(regs);
 564                 return;
 565         default:
 566                 break;
 567         }
 568 }
 569
 570 /*
 571  * Note that 'init' is a special process: it doesn't get signals it doesn't
 572  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 573  * mistake.
 574  *
 575  * We need to be able to restore the syscall arguments (r21-r26) to
 576  * restart syscalls.  Thus, the syscall path should save them in the
 577  * pt_regs structure (it's okay to do so since they are caller-save
 578  * registers).  As noted below, the syscall number gets restored for
 579  * us due to the magic of delayed branching.
 580  */
 581 asmlinkage void
 582 do_signal(struct pt_regs *regs, long in_syscall)
 583 {
 584         struct ksignal ksig;
 585
 586         DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
 587                regs, regs->sr[7], in_syscall);
 588
 589         if (get_signal(&ksig)) {
 590                 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
 591                 /* Restart a system call if necessary. */
 592                 if (in_syscall)
 593                         syscall_restart(regs, &ksig.ka);
 594
 595                 handle_signal(&ksig, regs, in_syscall);
 596                 return;
 597         }
 598
 599         /* Did we come from a system call? */
 600         if (in_syscall)
 601                 insert_restart_trampoline(regs);
 602
 603         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
 604                 regs->gr[28]);
 605
 606         restore_saved_sigmask();
 607 }
 608
 609 void do_notify_resume(struct pt_regs *regs, long in_syscall)
 610 {
 611         if (test_thread_flag(TIF_SIGPENDING))
 612                 do_signal(regs, in_syscall);
 613
 614         if (test_thread_flag(TIF_NOTIFY_RESUME)) {
 615                 clear_thread_flag(TIF_NOTIFY_RESUME);
 616                 tracehook_notify_resume(regs);
 617         }
 618 }