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