arch/parisc/kernel/signal.c

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