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