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