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