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 <linux/tracehook.h>
  30 #include <asm/ucontext.h>
  31 #include <asm/rt_sigframe.h>
  32 #include <asm/uaccess.h>
  33 #include <asm/pgalloc.h>
  34 #include <asm/cacheflush.h>
  35 #include <asm/asm-offsets.h>
  36
  37 #ifdef CONFIG_COMPAT
  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 CONFIG_64BIT
  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 CONFIG_64BIT
 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 CONFIG_64BIT
 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 CONFIG_64BIT
 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 = task_pid_vnr(current);
 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 CONFIG_64BIT
 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 CONFIG_64BIT
 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, Length 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 CONFIG_64BIT
 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 CONFIG_64BIT
 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 CONFIG_64BIT
 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 CONFIG_64BIT
 390                 if (!test_thread_flag(TIF_32BIT))
 391                         sigframe_size |= 1;
 392 #endif
 393         } else {
 394                 unsigned long psw = USER_PSW;
 395 #ifdef CONFIG_64BIT
 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 CONFIG_64BIT
 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
 472         tracehook_signal_handler(sig, info, ka, regs, 0);
 473
 474         return 1;
 475 }
 476
 477 static inline void
 478 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 479 {
 480         /* Check the return code */
 481         switch (regs->gr[28]) {
 482         case -ERESTART_RESTARTBLOCK:
 483                 current_thread_info()->restart_block.fn =
 484                         do_no_restart_syscall;
 485         case -ERESTARTNOHAND:
 486                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
 487                 regs->gr[28] = -EINTR;
 488                 break;
 489
 490         case -ERESTARTSYS:
 491                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 492                         DBG(1,"ERESTARTSYS: putting -EINTR\n");
 493                         regs->gr[28] = -EINTR;
 494                         break;
 495                 }
 496                 /* fallthrough */
 497         case -ERESTARTNOINTR:
 498                 /* A syscall is just a branch, so all
 499                  * we have to do is fiddle the return pointer.
 500                  */
 501                 regs->gr[31] -= 8; /* delayed branching */
 502                 /* Preserve original r28. */
 503                 regs->gr[28] = regs->orig_r28;
 504                 break;
 505         }
 506 }
 507
 508 static inline void
 509 insert_restart_trampoline(struct pt_regs *regs)
 510 {
 511         switch(regs->gr[28]) {
 512         case -ERESTART_RESTARTBLOCK: {
 513                 /* Restart the system call - no handlers present */
 514                 unsigned int *usp = (unsigned int *)regs->gr[30];
 515
 516                 /* Setup a trampoline to restart the syscall
 517                  * with __NR_restart_syscall
 518                  *
 519                  *  0: <return address (orig r31)>
 520                  *  4: <2nd half for 64-bit>
 521                  *  8: ldw 0(%sp), %r31
 522                  * 12: be 0x100(%sr2, %r0)
 523                  * 16: ldi __NR_restart_syscall, %r20
 524                  */
 525 #ifdef CONFIG_64BIT
 526                 put_user(regs->gr[31] >> 32, &usp[0]);
 527                 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
 528                 put_user(0x0fc010df, &usp[2]);
 529 #else
 530                 put_user(regs->gr[31], &usp[0]);
 531                 put_user(0x0fc0109f, &usp[2]);
 532 #endif
 533                 put_user(0xe0008200, &usp[3]);
 534                 put_user(0x34140000, &usp[4]);
 535
 536                 /* Stack is 64-byte aligned, and we only need
 537                  * to flush 1 cache line.
 538                  * Flushing one cacheline is cheap.
 539                  * "sync" on bigger (> 4 way) boxes is not.
 540                  */
 541                 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
 542                 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
 543
 544                 regs->gr[31] = regs->gr[30] + 8;
 545                 /* Preserve original r28. */
 546                 regs->gr[28] = regs->orig_r28;
 547
 548                 return;
 549         }
 550         case -ERESTARTNOHAND:
 551         case -ERESTARTSYS:
 552         case -ERESTARTNOINTR: {
 553                 /* Hooray for delayed branching.  We don't
 554                  * have to restore %r20 (the system call
 555                  * number) because it gets loaded in the delay
 556                  * slot of the branch external instruction.
 557                  */
 558                 regs->gr[31] -= 8;
 559                 /* Preserve original r28. */
 560                 regs->gr[28] = regs->orig_r28;
 561
 562                 return;
 563         }
 564         default:
 565                 break;
 566         }
 567 }
 568
 569 /*
 570  * Note that 'init' is a special process: it doesn't get signals it doesn't
 571  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 572  * mistake.
 573  *
 574  * We need to be able to restore the syscall arguments (r21-r26) to
 575  * restart syscalls.  Thus, the syscall path should save them in the
 576  * pt_regs structure (it's okay to do so since they are caller-save
 577  * registers).  As noted below, the syscall number gets restored for
 578  * us due to the magic of delayed branching.
 579  */
 580 asmlinkage void
 581 do_signal(struct pt_regs *regs, long in_syscall)
 582 {
 583         siginfo_t info;
 584         struct k_sigaction ka;
 585         int signr;
 586         sigset_t *oldset;
 587
 588         DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
 589                oldset, regs, regs->sr[7], in_syscall);
 590
 591         /* Everyone else checks to see if they are in kernel mode at
 592            this point and exits if that's the case.  I'm not sure why
 593            we would be called in that case, but for some reason we
 594            are. */
 595
 596         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 597                 oldset = &current->saved_sigmask;
 598         else
 599                 oldset = &current->blocked;
 600
 601         DBG(1,"do_signal: oldset %08lx / %08lx\n",
 602                 oldset->sig[0], oldset->sig[1]);
 603
 604
 605         /* May need to force signal if handle_signal failed to deliver */
 606         while (1) {
 607
 608                 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 609                 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
 610
 611                 if (signr <= 0)
 612                   break;
 613
 614                 /* Restart a system call if necessary. */
 615                 if (in_syscall)
 616                         syscall_restart(regs, &ka);
 617
 618                 /* Whee!  Actually deliver the signal.  If the
 619                    delivery failed, we need to continue to iterate in
 620                    this loop so we can deliver the SIGSEGV... */
 621                 if (handle_signal(signr, &info, &ka, oldset,
 622                                   regs, in_syscall)) {
 623                         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
 624                                 regs->gr[28]);
 625                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 626                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 627                         return;
 628                 }
 629         }
 630         /* end of while(1) looping forever if we can't force a signal */
 631
 632         /* Did we come from a system call? */
 633         if (in_syscall)
 634                 insert_restart_trampoline(regs);
 635
 636         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
 637                 regs->gr[28]);
 638
 639         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
 640                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 641                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 642         }
 643
 644         return;
 645 }
 646
 647 void do_notify_resume(struct pt_regs *regs, long in_syscall)
 648 {
 649         if (test_thread_flag(TIF_SIGPENDING) ||
 650             test_thread_flag(TIF_RESTORE_SIGMASK))
 651                 do_signal(regs, in_syscall);
 652
 653         if (test_thread_flag(TIF_NOTIFY_RESUME)) {
 654                 clear_thread_flag(TIF_NOTIFY_RESUME);
 655                 tracehook_notify_resume(regs);
 656                 if (current->replacement_session_keyring)
 657                         key_replace_session_keyring();
 658         }
 659 }