git.oblomov.eu Git - linux-2.6/blob - arch/sparc64/kernel/signal.c

   1 /*  $Id: signal.c,v 1.60 2002/02/09 19:49:31 davem Exp $
   2  *  arch/sparc64/kernel/signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   6  *  Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
   7  *  Copyright (C) 1997 Eddie C. Dost   (ecd@skynet.be)
   8  *  Copyright (C) 1997,1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
   9  */
  10
  11 #include <linux/config.h>
  12 #ifdef CONFIG_SPARC32_COMPAT
  13 #include <linux/compat.h>       /* for compat_old_sigset_t */
  14 #endif
  15 #include <linux/sched.h>
  16 #include <linux/kernel.h>
  17 #include <linux/signal.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/ptrace.h>
  21 #include <linux/unistd.h>
  22 #include <linux/mm.h>
  23 #include <linux/tty.h>
  24 #include <linux/smp_lock.h>
  25 #include <linux/binfmts.h>
  26 #include <linux/bitops.h>
  27
  28 #include <asm/uaccess.h>
  29 #include <asm/ptrace.h>
  30 #include <asm/svr4.h>
  31 #include <asm/pgtable.h>
  32 #include <asm/fpumacro.h>
  33 #include <asm/uctx.h>
  34 #include <asm/siginfo.h>
  35 #include <asm/visasm.h>
  36
  37 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  38
  39 static int do_signal(sigset_t *oldset, struct pt_regs * regs,
  40                      unsigned long orig_o0, int ret_from_syscall);
  41
  42 /* {set, get}context() needed for 64-bit SparcLinux userland. */
  43 asmlinkage void sparc64_set_context(struct pt_regs *regs)
  44 {
  45         struct ucontext __user *ucp = (struct ucontext __user *)
  46                 regs->u_regs[UREG_I0];
  47         mc_gregset_t __user *grp;
  48         unsigned long pc, npc, tstate;
  49         unsigned long fp, i7;
  50         unsigned char fenab;
  51         int err;
  52
  53         flush_user_windows();
  54         if (get_thread_wsaved()                                 ||
  55             (((unsigned long)ucp) & (sizeof(unsigned long)-1))  ||
  56             (!__access_ok(ucp, sizeof(*ucp))))
  57                 goto do_sigsegv;
  58         grp  = &ucp->uc_mcontext.mc_gregs;
  59         err  = __get_user(pc, &((*grp)[MC_PC]));
  60         err |= __get_user(npc, &((*grp)[MC_NPC]));
  61         if (err || ((pc | npc) & 3))
  62                 goto do_sigsegv;
  63         if (regs->u_regs[UREG_I1]) {
  64                 sigset_t set;
  65
  66                 if (_NSIG_WORDS == 1) {
  67                         if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))
  68                                 goto do_sigsegv;
  69                 } else {
  70                         if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))
  71                                 goto do_sigsegv;
  72                 }
  73                 sigdelsetmask(&set, ~_BLOCKABLE);
  74                 spin_lock_irq(&current->sighand->siglock);
  75                 current->blocked = set;
  76                 recalc_sigpending();
  77                 spin_unlock_irq(&current->sighand->siglock);
  78         }
  79         if (test_thread_flag(TIF_32BIT)) {
  80                 pc &= 0xffffffff;
  81                 npc &= 0xffffffff;
  82         }
  83         regs->tpc = pc;
  84         regs->tnpc = npc;
  85         err |= __get_user(regs->y, &((*grp)[MC_Y]));
  86         err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
  87         regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);
  88         regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));
  89         err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));
  90         err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));
  91         err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));
  92         err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));
  93         err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));
  94         err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));
  95         err |= __get_user(regs->u_regs[UREG_G7], (&(*grp)[MC_G7]));
  96         err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));
  97         err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));
  98         err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));
  99         err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));
 100         err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));
 101         err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));
 102         err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));
 103         err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));
 104
 105         err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
 106         err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
 107         err |= __put_user(fp,
 108               (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
 109         err |= __put_user(i7,
 110               (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
 111
 112         err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
 113         if (fenab) {
 114                 unsigned long *fpregs = current_thread_info()->fpregs;
 115                 unsigned long fprs;
 116
 117                 fprs_write(0);
 118                 err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
 119                 if (fprs & FPRS_DL)
 120                         err |= copy_from_user(fpregs,
 121                                               &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),
 122                                               (sizeof(unsigned int) * 32));
 123                 if (fprs & FPRS_DU)
 124                         err |= copy_from_user(fpregs+16,
 125                          ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,
 126                          (sizeof(unsigned int) * 32));
 127                 err |= __get_user(current_thread_info()->xfsr[0],
 128                                   &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
 129                 err |= __get_user(current_thread_info()->gsr[0],
 130                                   &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
 131                 regs->tstate &= ~TSTATE_PEF;
 132         }
 133         if (err)
 134                 goto do_sigsegv;
 135
 136         return;
 137 do_sigsegv:
 138         force_sig(SIGSEGV, current);
 139 }
 140
 141 asmlinkage void sparc64_get_context(struct pt_regs *regs)
 142 {
 143         struct ucontext __user *ucp = (struct ucontext __user *)
 144                 regs->u_regs[UREG_I0];
 145         mc_gregset_t __user *grp;
 146         mcontext_t __user *mcp;
 147         unsigned long fp, i7;
 148         unsigned char fenab;
 149         int err;
 150
 151         synchronize_user_stack();
 152         if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp)))
 153                 goto do_sigsegv;
 154
 155 #if 1
 156         fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
 157 #else
 158         fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF);
 159 #endif
 160
 161         mcp = &ucp->uc_mcontext;
 162         grp = &mcp->mc_gregs;
 163
 164         /* Skip over the trap instruction, first. */
 165         if (test_thread_flag(TIF_32BIT)) {
 166                 regs->tpc   = (regs->tnpc & 0xffffffff);
 167                 regs->tnpc  = (regs->tnpc + 4) & 0xffffffff;
 168         } else {
 169                 regs->tpc   = regs->tnpc;
 170                 regs->tnpc += 4;
 171         }
 172         err = 0;
 173         if (_NSIG_WORDS == 1)
 174                 err |= __put_user(current->blocked.sig[0],
 175                                   (unsigned long __user *)&ucp->uc_sigmask);
 176         else
 177                 err |= __copy_to_user(&ucp->uc_sigmask, &current->blocked,
 178                                       sizeof(sigset_t));
 179
 180         err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE]));
 181         err |= __put_user(regs->tpc, &((*grp)[MC_PC]));
 182         err |= __put_user(regs->tnpc, &((*grp)[MC_NPC]));
 183         err |= __put_user(regs->y, &((*grp)[MC_Y]));
 184         err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1]));
 185         err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2]));
 186         err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3]));
 187         err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4]));
 188         err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5]));
 189         err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6]));
 190         err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7]));
 191         err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0]));
 192         err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1]));
 193         err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2]));
 194         err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3]));
 195         err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4]));
 196         err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5]));
 197         err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6]));
 198         err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7]));
 199
 200         err |= __get_user(fp,
 201                  (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
 202         err |= __get_user(i7,
 203                  (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
 204         err |= __put_user(fp, &(mcp->mc_fp));
 205         err |= __put_user(i7, &(mcp->mc_i7));
 206
 207         err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));
 208         if (fenab) {
 209                 unsigned long *fpregs = current_thread_info()->fpregs;
 210                 unsigned long fprs;
 211
 212                 fprs = current_thread_info()->fpsaved[0];
 213                 if (fprs & FPRS_DL)
 214                         err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,
 215                                             (sizeof(unsigned int) * 32));
 216                 if (fprs & FPRS_DU)
 217                         err |= copy_to_user(
 218                           ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16,
 219                           (sizeof(unsigned int) * 32));
 220                 err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr));
 221                 err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr));
 222                 err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs));
 223         }
 224         if (err)
 225                 goto do_sigsegv;
 226
 227         return;
 228 do_sigsegv:
 229         force_sig(SIGSEGV, current);
 230 }
 231
 232 struct rt_signal_frame {
 233         struct sparc_stackf     ss;
 234         siginfo_t               info;
 235         struct pt_regs          regs;
 236         __siginfo_fpu_t __user  *fpu_save;
 237         stack_t                 stack;
 238         sigset_t                mask;
 239         __siginfo_fpu_t         fpu_state;
 240 };
 241
 242 /* Align macros */
 243 #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame) + 7) & (~7)))
 244
 245 /*
 246  * atomically swap in the new signal mask, and wait for a signal.
 247  * This is really tricky on the Sparc, watch out...
 248  */
 249 asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
 250 {
 251         sigset_t saveset;
 252
 253 #ifdef CONFIG_SPARC32_COMPAT
 254         if (test_thread_flag(TIF_32BIT)) {
 255                 extern asmlinkage void _sigpause32_common(compat_old_sigset_t,
 256                                                           struct pt_regs *);
 257                 _sigpause32_common(set, regs);
 258                 return;
 259         }
 260 #endif
 261         set &= _BLOCKABLE;
 262         spin_lock_irq(&current->sighand->siglock);
 263         saveset = current->blocked;
 264         siginitset(&current->blocked, set);
 265         recalc_sigpending();
 266         spin_unlock_irq(&current->sighand->siglock);
 267
 268         if (test_thread_flag(TIF_32BIT)) {
 269                 regs->tpc = (regs->tnpc & 0xffffffff);
 270                 regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
 271         } else {
 272                 regs->tpc = regs->tnpc;
 273                 regs->tnpc += 4;
 274         }
 275
 276         /* Condition codes and return value where set here for sigpause,
 277          * and so got used by setup_frame, which again causes sigreturn()
 278          * to return -EINTR.
 279          */
 280         while (1) {
 281                 current->state = TASK_INTERRUPTIBLE;
 282                 schedule();
 283                 /*
 284                  * Return -EINTR and set condition code here,
 285                  * so the interrupted system call actually returns
 286                  * these.
 287                  */
 288                 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
 289                 regs->u_regs[UREG_I0] = EINTR;
 290                 if (do_signal(&saveset, regs, 0, 0))
 291                         return;
 292         }
 293 }
 294
 295 asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
 296 {
 297         _sigpause_common(set, regs);
 298 }
 299
 300 asmlinkage void do_sigsuspend(struct pt_regs *regs)
 301 {
 302         _sigpause_common(regs->u_regs[UREG_I0], regs);
 303 }
 304
 305 asmlinkage void do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize, struct pt_regs *regs)
 306 {
 307         sigset_t oldset, set;
 308
 309         /* XXX: Don't preclude handling different sized sigset_t's.  */
 310         if (sigsetsize != sizeof(sigset_t)) {
 311                 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
 312                 regs->u_regs[UREG_I0] = EINVAL;
 313                 return;
 314         }
 315         if (copy_from_user(&set, uset, sizeof(set))) {
 316                 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
 317                 regs->u_regs[UREG_I0] = EFAULT;
 318                 return;
 319         }
 320
 321         sigdelsetmask(&set, ~_BLOCKABLE);
 322         spin_lock_irq(&current->sighand->siglock);
 323         oldset = current->blocked;
 324         current->blocked = set;
 325         recalc_sigpending();
 326         spin_unlock_irq(&current->sighand->siglock);
 327
 328         if (test_thread_flag(TIF_32BIT)) {
 329                 regs->tpc = (regs->tnpc & 0xffffffff);
 330                 regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
 331         } else {
 332                 regs->tpc = regs->tnpc;
 333                 regs->tnpc += 4;
 334         }
 335
 336         /* Condition codes and return value where set here for sigpause,
 337          * and so got used by setup_frame, which again causes sigreturn()
 338          * to return -EINTR.
 339          */
 340         while (1) {
 341                 current->state = TASK_INTERRUPTIBLE;
 342                 schedule();
 343                 /*
 344                  * Return -EINTR and set condition code here,
 345                  * so the interrupted system call actually returns
 346                  * these.
 347                  */
 348                 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
 349                 regs->u_regs[UREG_I0] = EINTR;
 350                 if (do_signal(&oldset, regs, 0, 0))
 351                         return;
 352         }
 353 }
 354
 355 static inline int
 356 restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 357 {
 358         unsigned long *fpregs = current_thread_info()->fpregs;
 359         unsigned long fprs;
 360         int err;
 361
 362         err = __get_user(fprs, &fpu->si_fprs);
 363         fprs_write(0);
 364         regs->tstate &= ~TSTATE_PEF;
 365         if (fprs & FPRS_DL)
 366                 err |= copy_from_user(fpregs, &fpu->si_float_regs[0],
 367                                (sizeof(unsigned int) * 32));
 368         if (fprs & FPRS_DU)
 369                 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32],
 370                                (sizeof(unsigned int) * 32));
 371         err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
 372         err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
 373         current_thread_info()->fpsaved[0] |= fprs;
 374         return err;
 375 }
 376
 377 void do_rt_sigreturn(struct pt_regs *regs)
 378 {
 379         struct rt_signal_frame __user *sf;
 380         unsigned long tpc, tnpc, tstate;
 381         __siginfo_fpu_t __user *fpu_save;
 382         mm_segment_t old_fs;
 383         sigset_t set;
 384         stack_t st;
 385         int err;
 386
 387         /* Always make any pending restarted system calls return -EINTR */
 388         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 389
 390         synchronize_user_stack ();
 391         sf = (struct rt_signal_frame __user *)
 392                 (regs->u_regs [UREG_FP] + STACK_BIAS);
 393
 394         /* 1. Make sure we are not getting garbage from the user */
 395         if (((unsigned long) sf) & 3)
 396                 goto segv;
 397
 398         err = get_user(tpc, &sf->regs.tpc);
 399         err |= __get_user(tnpc, &sf->regs.tnpc);
 400         if (test_thread_flag(TIF_32BIT)) {
 401                 tpc &= 0xffffffff;
 402                 tnpc &= 0xffffffff;
 403         }
 404         err |= ((tpc | tnpc) & 3);
 405
 406         /* 2. Restore the state */
 407         err |= __get_user(regs->y, &sf->regs.y);
 408         err |= __get_user(tstate, &sf->regs.tstate);
 409         err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));
 410
 411         /* User can only change condition codes and %asi in %tstate. */
 412         regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);
 413         regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));
 414
 415         err |= __get_user(fpu_save, &sf->fpu_save);
 416         if (fpu_save)
 417                 err |= restore_fpu_state(regs, &sf->fpu_state);
 418
 419         err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
 420         err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
 421
 422         if (err)
 423                 goto segv;
 424
 425         regs->tpc = tpc;
 426         regs->tnpc = tnpc;
 427
 428         /* It is more difficult to avoid calling this function than to
 429            call it and ignore errors.  */
 430         old_fs = get_fs();
 431         set_fs(KERNEL_DS);
 432         do_sigaltstack((const stack_t __user *) &st, NULL, (unsigned long)sf);
 433         set_fs(old_fs);
 434
 435         sigdelsetmask(&set, ~_BLOCKABLE);
 436         spin_lock_irq(&current->sighand->siglock);
 437         current->blocked = set;
 438         recalc_sigpending();
 439         spin_unlock_irq(&current->sighand->siglock);
 440         return;
 441 segv:
 442         force_sig(SIGSEGV, current);
 443 }
 444
 445 /* Checks if the fp is valid */
 446 static int invalid_frame_pointer(void __user *fp, int fplen)
 447 {
 448         if (((unsigned long) fp) & 7)
 449                 return 1;
 450         return 0;
 451 }
 452
 453 static inline int
 454 save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 455 {
 456         unsigned long *fpregs = (unsigned long *)(regs+1);
 457         unsigned long fprs;
 458         int err = 0;
 459
 460         fprs = current_thread_info()->fpsaved[0];
 461         if (fprs & FPRS_DL)
 462                 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
 463                                     (sizeof(unsigned int) * 32));
 464         if (fprs & FPRS_DU)
 465                 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
 466                                     (sizeof(unsigned int) * 32));
 467         err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
 468         err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
 469         err |= __put_user(fprs, &fpu->si_fprs);
 470
 471         return err;
 472 }
 473
 474 static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize)
 475 {
 476         unsigned long sp;
 477
 478         sp = regs->u_regs[UREG_FP] + STACK_BIAS;
 479
 480         /* This is the X/Open sanctioned signal stack switching.  */
 481         if (ka->sa.sa_flags & SA_ONSTACK) {
 482                 if (!on_sig_stack(sp) &&
 483                     !((current->sas_ss_sp + current->sas_ss_size) & 7))
 484                         sp = current->sas_ss_sp + current->sas_ss_size;
 485         }
 486         return (void __user *)(sp - framesize);
 487 }
 488
 489 static inline void
 490 setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
 491                int signo, sigset_t *oldset, siginfo_t *info)
 492 {
 493         struct rt_signal_frame __user *sf;
 494         int sigframe_size, err;
 495
 496         /* 1. Make sure everything is clean */
 497         synchronize_user_stack();
 498         save_and_clear_fpu();
 499
 500         sigframe_size = RT_ALIGNEDSZ;
 501         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
 502                 sigframe_size -= sizeof(__siginfo_fpu_t);
 503
 504         sf = (struct rt_signal_frame __user *)
 505                 get_sigframe(ka, regs, sigframe_size);
 506
 507         if (invalid_frame_pointer (sf, sigframe_size))
 508                 goto sigill;
 509
 510         if (get_thread_wsaved() != 0)
 511                 goto sigill;
 512
 513         /* 2. Save the current process state */
 514         err = copy_to_user(&sf->regs, regs, sizeof (*regs));
 515
 516         if (current_thread_info()->fpsaved[0] & FPRS_FEF) {
 517                 err |= save_fpu_state(regs, &sf->fpu_state);
 518                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
 519         } else {
 520                 err |= __put_user(0, &sf->fpu_save);
 521         }
 522
 523         /* Setup sigaltstack */
 524         err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
 525         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
 526         err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
 527
 528         err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));
 529
 530         err |= copy_in_user((u64 __user *)sf,
 531                             (u64 __user *)(regs->u_regs[UREG_FP]+STACK_BIAS),
 532                             sizeof(struct reg_window));
 533
 534         if (info)
 535                 err |= copy_siginfo_to_user(&sf->info, info);
 536         else {
 537                 err |= __put_user(signo, &sf->info.si_signo);
 538                 err |= __put_user(SI_NOINFO, &sf->info.si_code);
 539         }
 540         if (err)
 541                 goto sigsegv;
 542
 543         /* 3. signal handler back-trampoline and parameters */
 544         regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;
 545         regs->u_regs[UREG_I0] = signo;
 546         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 547
 548         /* The sigcontext is passed in this way because of how it
 549          * is defined in GLIBC's /usr/include/bits/sigcontext.h
 550          * for sparc64.  It includes the 128 bytes of siginfo_t.
 551          */
 552         regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
 553
 554         /* 5. signal handler */
 555         regs->tpc = (unsigned long) ka->sa.sa_handler;
 556         regs->tnpc = (regs->tpc + 4);
 557         if (test_thread_flag(TIF_32BIT)) {
 558                 regs->tpc &= 0xffffffff;
 559                 regs->tnpc &= 0xffffffff;
 560         }
 561         /* 4. return to kernel instructions */
 562         regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
 563         return;
 564
 565 sigill:
 566         do_exit(SIGILL);
 567 sigsegv:
 568         force_sigsegv(signo, current);
 569 }
 570
 571 static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
 572                                  siginfo_t *info,
 573                                  sigset_t *oldset, struct pt_regs *regs)
 574 {
 575         setup_rt_frame(ka, regs, signr, oldset,
 576                        (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL);
 577         spin_lock_irq(&current->sighand->siglock);
 578         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 579         if (!(ka->sa.sa_flags & SA_NOMASK))
 580                 sigaddset(&current->blocked,signr);
 581         recalc_sigpending();
 582         spin_unlock_irq(&current->sighand->siglock);
 583 }
 584
 585 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
 586                                      struct sigaction *sa)
 587 {
 588         switch (regs->u_regs[UREG_I0]) {
 589         case ERESTART_RESTARTBLOCK:
 590         case ERESTARTNOHAND:
 591         no_system_call_restart:
 592                 regs->u_regs[UREG_I0] = EINTR;
 593                 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
 594                 break;
 595         case ERESTARTSYS:
 596                 if (!(sa->sa_flags & SA_RESTART))
 597                         goto no_system_call_restart;
 598                 /* fallthrough */
 599         case ERESTARTNOINTR:
 600                 regs->u_regs[UREG_I0] = orig_i0;
 601                 regs->tpc -= 4;
 602                 regs->tnpc -= 4;
 603         }
 604 }
 605
 606 /* Note that 'init' is a special process: it doesn't get signals it doesn't
 607  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 608  * mistake.
 609  */
 610 static int do_signal(sigset_t *oldset, struct pt_regs * regs,
 611                      unsigned long orig_i0, int restart_syscall)
 612 {
 613         siginfo_t info;
 614         struct signal_deliver_cookie cookie;
 615         struct k_sigaction ka;
 616         int signr;
 617
 618         cookie.restart_syscall = restart_syscall;
 619         cookie.orig_i0 = orig_i0;
 620
 621         if (!oldset)
 622                 oldset = &current->blocked;
 623
 624 #ifdef CONFIG_SPARC32_COMPAT
 625         if (test_thread_flag(TIF_32BIT)) {
 626                 extern int do_signal32(sigset_t *, struct pt_regs *,
 627                                        unsigned long, int);
 628                 return do_signal32(oldset, regs, orig_i0,
 629                                    cookie.restart_syscall);
 630         }
 631 #endif
 632
 633         signr = get_signal_to_deliver(&info, &ka, regs, &cookie);
 634         if (signr > 0) {
 635                 if (cookie.restart_syscall)
 636                         syscall_restart(orig_i0, regs, &ka.sa);
 637                 handle_signal(signr, &ka, &info, oldset, regs);
 638                 return 1;
 639         }
 640         if (cookie.restart_syscall &&
 641             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
 642              regs->u_regs[UREG_I0] == ERESTARTSYS ||
 643              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
 644                 /* replay the system call when we are done */
 645                 regs->u_regs[UREG_I0] = cookie.orig_i0;
 646                 regs->tpc -= 4;
 647                 regs->tnpc -= 4;
 648         }
 649         if (cookie.restart_syscall &&
 650             regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
 651                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
 652                 regs->tpc -= 4;
 653                 regs->tnpc -= 4;
 654         }
 655         return 0;
 656 }
 657
 658 void do_notify_resume(sigset_t *oldset, struct pt_regs *regs,
 659                       unsigned long orig_i0, int restart_syscall,
 660                       unsigned long thread_info_flags)
 661 {
 662         if (thread_info_flags & _TIF_SIGPENDING)
 663                 do_signal(oldset, regs, orig_i0, restart_syscall);
 664 }
 665
 666 void ptrace_signal_deliver(struct pt_regs *regs, void *cookie)
 667 {
 668         struct signal_deliver_cookie *cp = cookie;
 669
 670         if (cp->restart_syscall &&
 671             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
 672              regs->u_regs[UREG_I0] == ERESTARTSYS ||
 673              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
 674                 /* replay the system call when we are done */
 675                 regs->u_regs[UREG_I0] = cp->orig_i0;
 676                 regs->tpc -= 4;
 677                 regs->tnpc -= 4;
 678                 cp->restart_syscall = 0;
 679         }
 680         if (cp->restart_syscall &&
 681             regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
 682                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
 683                 regs->tpc -= 4;
 684                 regs->tnpc -= 4;
 685                 cp->restart_syscall = 0;
 686         }
 687 }