arch/parisc/kernel/signal.c

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