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