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