linux/arch/parisc/kernel/signal.c
<<
>>
Prefs
   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
  81static long
  82restore_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
  97void
  98sys_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
 178give_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
 188static inline void __user *
 189get_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
 204static long
 205setup_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
 238static long
 239setup_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 aswell 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
 436give_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
 446static long
 447handle_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
 471static inline void
 472syscall_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
 502static inline void
 503insert_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 */
 574asmlinkage void
 575do_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
 641void 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}
 654