git.oblomov.eu Git - linux-2.6/blob - 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 = task_pid_vnr(current);
 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, Length 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_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
 538                 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
 539
 540                 regs->gr[31] = regs->gr[30] + 8;
 541                 /* Preserve original r28. */
 542                 regs->gr[28] = regs->orig_r28;
 543
 544                 return;
 545         }
 546         case -ERESTARTNOHAND:
 547         case -ERESTARTSYS:
 548         case -ERESTARTNOINTR: {
 549                 /* Hooray for delayed branching.  We don't
 550                  * have to restore %r20 (the system call
 551                  * number) because it gets loaded in the delay
 552                  * slot of the branch external instruction.
 553                  */
 554                 regs->gr[31] -= 8;
 555                 /* Preserve original r28. */
 556                 regs->gr[28] = regs->orig_r28;
 557
 558                 return;
 559         }
 560         default:
 561                 break;
 562         }
 563 }
 564
 565 /*
 566  * Note that 'init' is a special process: it doesn't get signals it doesn't
 567  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 568  * mistake.
 569  *
 570  * We need to be able to restore the syscall arguments (r21-r26) to
 571  * restart syscalls.  Thus, the syscall path should save them in the
 572  * pt_regs structure (it's okay to do so since they are caller-save
 573  * registers).  As noted below, the syscall number gets restored for
 574  * us due to the magic of delayed branching.
 575  */
 576 asmlinkage void
 577 do_signal(struct pt_regs *regs, long in_syscall)
 578 {
 579         siginfo_t info;
 580         struct k_sigaction ka;
 581         int signr;
 582         sigset_t *oldset;
 583
 584         DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
 585                oldset, regs, regs->sr[7], in_syscall);
 586
 587         /* Everyone else checks to see if they are in kernel mode at
 588            this point and exits if that's the case.  I'm not sure why
 589            we would be called in that case, but for some reason we
 590            are. */
 591
 592         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 593                 oldset = &current->saved_sigmask;
 594         else
 595                 oldset = &current->blocked;
 596
 597         DBG(1,"do_signal: oldset %08lx / %08lx\n",
 598                 oldset->sig[0], oldset->sig[1]);
 599
 600
 601         /* May need to force signal if handle_signal failed to deliver */
 602         while (1) {
 603
 604                 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 605                 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
 606
 607                 if (signr <= 0)
 608                   break;
 609
 610                 /* Restart a system call if necessary. */
 611                 if (in_syscall)
 612                         syscall_restart(regs, &ka);
 613
 614                 /* Whee!  Actually deliver the signal.  If the
 615                    delivery failed, we need to continue to iterate in
 616                    this loop so we can deliver the SIGSEGV... */
 617                 if (handle_signal(signr, &info, &ka, oldset,
 618                                   regs, in_syscall)) {
 619                         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
 620                                 regs->gr[28]);
 621                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 622                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 623                         return;
 624                 }
 625         }
 626         /* end of while(1) looping forever if we can't force a signal */
 627
 628         /* Did we come from a system call? */
 629         if (in_syscall)
 630                 insert_restart_trampoline(regs);
 631
 632         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
 633                 regs->gr[28]);
 634
 635         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
 636                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 637                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 638         }
 639
 640         return;
 641 }
 642
 643 void do_notify_resume(struct pt_regs *regs, long in_syscall)
 644 {
 645         if (test_thread_flag(TIF_SIGPENDING) ||
 646             test_thread_flag(TIF_RESTORE_SIGMASK))
 647                 do_signal(regs, in_syscall);
 648 }