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