arch/sparc64/kernel/signal32.c

   1 /*  $Id: signal32.c,v 1.74 2002/02/09 19:49:30 davem Exp $
   2  *  arch/sparc64/kernel/signal32.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/sched.h>
  12 #include <linux/kernel.h>
  13 #include <linux/signal.h>
  14 #include <linux/errno.h>
  15 #include <linux/wait.h>
  16 #include <linux/ptrace.h>
  17 #include <linux/unistd.h>
  18 #include <linux/mm.h>
  19 #include <linux/tty.h>
  20 #include <linux/smp_lock.h>
  21 #include <linux/binfmts.h>
  22 #include <linux/compat.h>
  23
  24 #include <asm/uaccess.h>
  25 #include <asm/bitops.h>
  26 #include <asm/ptrace.h>
  27 #include <asm/svr4.h>
  28 #include <asm/pgtable.h>
  29 #include <asm/psrcompat.h>
  30 #include <asm/fpumacro.h>
  31 #include <asm/visasm.h>
  32
  33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  34
  35 int do_signal32(sigset_t *oldset, struct pt_regs *regs,
  36                 unsigned long orig_o0, int ret_from_syscall);
  37
  38 /* Signal frames: the original one (compatible with SunOS):
  39  *
  40  * Set up a signal frame... Make the stack look the way SunOS
  41  * expects it to look which is basically:
  42  *
  43  * ---------------------------------- <-- %sp at signal time
  44  * Struct sigcontext
  45  * Signal address
  46  * Ptr to sigcontext area above
  47  * Signal code
  48  * The signal number itself
  49  * One register window
  50  * ---------------------------------- <-- New %sp
  51  */
  52 struct signal_sframe32 {
  53         struct reg_window32 sig_window;
  54         int sig_num;
  55         int sig_code;
  56         /* struct sigcontext32 * */ u32 sig_scptr;
  57         int sig_address;
  58         struct sigcontext32 sig_context;
  59         unsigned int extramask[_COMPAT_NSIG_WORDS - 1];
  60 };
  61
  62 /*
  63  * And the new one, intended to be used for Linux applications only
  64  * (we have enough in there to work with clone).
  65  * All the interesting bits are in the info field.
  66  */
  67 struct new_signal_frame32 {
  68         struct sparc_stackf32   ss;
  69         __siginfo32_t           info;
  70         /* __siginfo_fpu32_t * */ u32 fpu_save;
  71         unsigned int            insns[2];
  72         unsigned int            extramask[_COMPAT_NSIG_WORDS - 1];
  73         unsigned int            extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  74         /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  75         siginfo_extra_v8plus_t  v8plus;
  76         __siginfo_fpu_t         fpu_state;
  77 };
  78
  79 struct rt_signal_frame32 {
  80         struct sparc_stackf32   ss;
  81         siginfo_t32             info;
  82         struct pt_regs32        regs;
  83         compat_sigset_t         mask;
  84         /* __siginfo_fpu32_t * */ u32 fpu_save;
  85         unsigned int            insns[2];
  86         stack_t32               stack;
  87         unsigned int            extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  88         /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  89         siginfo_extra_v8plus_t  v8plus;
  90         __siginfo_fpu_t         fpu_state;
  91 };
  92
  93 /* Align macros */
  94 #define SF_ALIGNEDSZ  (((sizeof(struct signal_sframe32) + 7) & (~7)))
  95 #define NF_ALIGNEDSZ  (((sizeof(struct new_signal_frame32) + 7) & (~7)))
  96 #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
  97
  98 int copy_siginfo_to_user32(siginfo_t32 __user *to, siginfo_t *from)
  99 {
 100         int err;
 101
 102         if (!access_ok(VERIFY_WRITE, to, sizeof(siginfo_t32)))
 103                 return -EFAULT;
 104
 105         /* If you change siginfo_t structure, please be sure
 106            this code is fixed accordingly.
 107            It should never copy any pad contained in the structure
 108            to avoid security leaks, but must copy the generic
 109            3 ints plus the relevant union member.
 110            This routine must convert siginfo from 64bit to 32bit as well
 111            at the same time.  */
 112         err = __put_user(from->si_signo, &to->si_signo);
 113         err |= __put_user(from->si_errno, &to->si_errno);
 114         err |= __put_user((short)from->si_code, &to->si_code);
 115         if (from->si_code < 0)
 116                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 117         else {
 118                 switch (from->si_code >> 16) {
 119                 case __SI_TIMER >> 16:
 120                         err |= __put_user(from->si_tid, &to->si_tid);
 121                         err |= __put_user(from->si_overrun, &to->si_overrun);
 122                         err |= __put_user((u32)(u64)from->si_ptr, &to->si_ptr);
 123                         break;
 124                 case __SI_CHLD >> 16:
 125                         err |= __put_user(from->si_utime, &to->si_utime);
 126                         err |= __put_user(from->si_stime, &to->si_stime);
 127                         err |= __put_user(from->si_status, &to->si_status);
 128                 default:
 129                         err |= __put_user(from->si_pid, &to->si_pid);
 130                         err |= __put_user(from->si_uid, &to->si_uid);
 131                         break;
 132                 case __SI_FAULT >> 16:
 133                 case __SI_POLL >> 16:
 134                         err |= __put_user(from->si_trapno, &to->si_trapno);
 135                         err |= __put_user((long)from->si_addr, &to->si_addr);
 136                         break;
 137                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 138                 case __SI_MESGQ >> 16:
 139                         err |= __put_user(from->si_pid, &to->si_pid);
 140                         err |= __put_user(from->si_uid, &to->si_uid);
 141                         err |= __put_user(from->si_int, &to->si_int);
 142                         break;
 143                 }
 144         }
 145         return err;
 146 }
 147
 148 /*
 149  * atomically swap in the new signal mask, and wait for a signal.
 150  * This is really tricky on the Sparc, watch out...
 151  */
 152 asmlinkage void _sigpause32_common(compat_old_sigset_t set, struct pt_regs *regs)
 153 {
 154         sigset_t saveset;
 155
 156         set &= _BLOCKABLE;
 157         spin_lock_irq(&current->sighand->siglock);
 158         saveset = current->blocked;
 159         siginitset(&current->blocked, set);
 160         recalc_sigpending();
 161         spin_unlock_irq(&current->sighand->siglock);
 162
 163         regs->tpc = regs->tnpc;
 164         regs->tnpc += 4;
 165         if (test_thread_flag(TIF_32BIT)) {
 166                 regs->tpc &= 0xffffffff;
 167                 regs->tnpc &= 0xffffffff;
 168         }
 169
 170         /* Condition codes and return value where set here for sigpause,
 171          * and so got used by setup_frame, which again causes sigreturn()
 172          * to return -EINTR.
 173          */
 174         while (1) {
 175                 current->state = TASK_INTERRUPTIBLE;
 176                 schedule();
 177                 /*
 178                  * Return -EINTR and set condition code here,
 179                  * so the interrupted system call actually returns
 180                  * these.
 181                  */
 182                 regs->tstate |= TSTATE_ICARRY;
 183                 regs->u_regs[UREG_I0] = EINTR;
 184                 if (do_signal32(&saveset, regs, 0, 0))
 185                         return;
 186         }
 187 }
 188
 189 asmlinkage void do_rt_sigsuspend32(u32 uset, size_t sigsetsize, struct pt_regs *regs)
 190 {
 191         sigset_t oldset, set;
 192         compat_sigset_t set32;
 193
 194         /* XXX: Don't preclude handling different sized sigset_t's.  */
 195         if (((compat_size_t)sigsetsize) != sizeof(sigset_t)) {
 196                 regs->tstate |= TSTATE_ICARRY;
 197                 regs->u_regs[UREG_I0] = EINVAL;
 198                 return;
 199         }
 200         if (copy_from_user(&set32, (void __user *)(long)uset, sizeof(set32))) {
 201                 regs->tstate |= TSTATE_ICARRY;
 202                 regs->u_regs[UREG_I0] = EFAULT;
 203                 return;
 204         }
 205         switch (_NSIG_WORDS) {
 206         case 4: set.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
 207         case 3: set.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
 208         case 2: set.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
 209         case 1: set.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
 210         }
 211         sigdelsetmask(&set, ~_BLOCKABLE);
 212         spin_lock_irq(&current->sighand->siglock);
 213         oldset = current->blocked;
 214         current->blocked = set;
 215         recalc_sigpending();
 216         spin_unlock_irq(&current->sighand->siglock);
 217
 218         regs->tpc = regs->tnpc;
 219         regs->tnpc += 4;
 220         if (test_thread_flag(TIF_32BIT)) {
 221                 regs->tpc &= 0xffffffff;
 222                 regs->tnpc &= 0xffffffff;
 223         }
 224
 225         /* Condition codes and return value where set here for sigpause,
 226          * and so got used by setup_frame, which again causes sigreturn()
 227          * to return -EINTR.
 228          */
 229         while (1) {
 230                 current->state = TASK_INTERRUPTIBLE;
 231                 schedule();
 232                 /*
 233                  * Return -EINTR and set condition code here,
 234                  * so the interrupted system call actually returns
 235                  * these.
 236                  */
 237                 regs->tstate |= TSTATE_ICARRY;
 238                 regs->u_regs[UREG_I0] = EINTR;
 239                 if (do_signal32(&oldset, regs, 0, 0))
 240                         return;
 241         }
 242 }
 243
 244 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 245 {
 246         unsigned long *fpregs = current_thread_info()->fpregs;
 247         unsigned long fprs;
 248         int err;
 249
 250         err = __get_user(fprs, &fpu->si_fprs);
 251         fprs_write(0);
 252         regs->tstate &= ~TSTATE_PEF;
 253         if (fprs & FPRS_DL)
 254                 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
 255         if (fprs & FPRS_DU)
 256                 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
 257         err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
 258         err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
 259         current_thread_info()->fpsaved[0] |= fprs;
 260         return err;
 261 }
 262
 263 void do_new_sigreturn32(struct pt_regs *regs)
 264 {
 265         struct new_signal_frame32 __user *sf;
 266         unsigned int psr;
 267         unsigned pc, npc, fpu_save;
 268         sigset_t set;
 269         unsigned seta[_COMPAT_NSIG_WORDS];
 270         int err, i;
 271
 272         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 273         sf = (struct new_signal_frame32 __user *) regs->u_regs[UREG_FP];
 274
 275         /* 1. Make sure we are not getting garbage from the user */
 276         if (verify_area(VERIFY_READ, sf, sizeof(*sf))   ||
 277             (((unsigned long) sf) & 3))
 278                 goto segv;
 279
 280         get_user(pc, &sf->info.si_regs.pc);
 281         __get_user(npc, &sf->info.si_regs.npc);
 282
 283         if ((pc | npc) & 3)
 284                 goto segv;
 285
 286         if (test_thread_flag(TIF_32BIT)) {
 287                 pc &= 0xffffffff;
 288                 npc &= 0xffffffff;
 289         }
 290         regs->tpc = pc;
 291         regs->tnpc = npc;
 292
 293         /* 2. Restore the state */
 294         err = __get_user(regs->y, &sf->info.si_regs.y);
 295         err |= __get_user(psr, &sf->info.si_regs.psr);
 296
 297         for (i = UREG_G1; i <= UREG_I7; i++)
 298                 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 299         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 300                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
 301                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 302                         for (i = UREG_G1; i <= UREG_I7; i++)
 303                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 304                 }
 305         }
 306
 307         /* User can only change condition codes in %tstate. */
 308         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 309         regs->tstate |= psr_to_tstate_icc(psr);
 310
 311         err |= __get_user(fpu_save, &sf->fpu_save);
 312         if (fpu_save)
 313                 err |= restore_fpu_state32(regs, &sf->fpu_state);
 314         err |= __get_user(seta[0], &sf->info.si_mask);
 315         err |= copy_from_user(seta+1, &sf->extramask,
 316                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 317         if (err)
 318                 goto segv;
 319         switch (_NSIG_WORDS) {
 320                 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
 321                 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
 322                 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
 323                 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
 324         }
 325         sigdelsetmask(&set, ~_BLOCKABLE);
 326         spin_lock_irq(&current->sighand->siglock);
 327         current->blocked = set;
 328         recalc_sigpending();
 329         spin_unlock_irq(&current->sighand->siglock);
 330         return;
 331
 332 segv:
 333         do_exit(SIGSEGV);
 334 }
 335
 336 asmlinkage void do_sigreturn32(struct pt_regs *regs)
 337 {
 338         struct sigcontext32 __user *scptr;
 339         unsigned int pc, npc, psr;
 340         sigset_t set;
 341         unsigned int seta[_COMPAT_NSIG_WORDS];
 342         int err;
 343
 344         /* Always make any pending restarted system calls return -EINTR */
 345         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 346
 347         synchronize_user_stack();
 348         if (test_thread_flag(TIF_NEWSIGNALS))
 349                 return do_new_sigreturn32(regs);
 350
 351         scptr = (struct sigcontext32 __user *)
 352                 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
 353         /* Check sanity of the user arg. */
 354         if (verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
 355             (((unsigned long) scptr) & 3))
 356                 goto segv;
 357
 358         err = __get_user(pc, &scptr->sigc_pc);
 359         err |= __get_user(npc, &scptr->sigc_npc);
 360
 361         if ((pc | npc) & 3)
 362                 goto segv; /* Nice try. */
 363
 364         err |= __get_user(seta[0], &scptr->sigc_mask);
 365         /* Note that scptr + 1 points to extramask */
 366         err |= copy_from_user(seta+1, scptr + 1,
 367                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 368         if (err)
 369                 goto segv;
 370         switch (_NSIG_WORDS) {
 371                 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
 372                 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
 373                 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
 374                 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
 375         }
 376         sigdelsetmask(&set, ~_BLOCKABLE);
 377         spin_lock_irq(&current->sighand->siglock);
 378         current->blocked = set;
 379         recalc_sigpending();
 380         spin_unlock_irq(&current->sighand->siglock);
 381
 382         if (test_thread_flag(TIF_32BIT)) {
 383                 pc &= 0xffffffff;
 384                 npc &= 0xffffffff;
 385         }
 386         regs->tpc = pc;
 387         regs->tnpc = npc;
 388         err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
 389         err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
 390         err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
 391
 392         /* User can only change condition codes in %tstate. */
 393         err |= __get_user(psr, &scptr->sigc_psr);
 394         if (err)
 395                 goto segv;
 396         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 397         regs->tstate |= psr_to_tstate_icc(psr);
 398         return;
 399
 400 segv:
 401         do_exit(SIGSEGV);
 402 }
 403
 404 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
 405 {
 406         struct rt_signal_frame32 __user *sf;
 407         unsigned int psr, pc, npc, fpu_save, u_ss_sp;
 408         mm_segment_t old_fs;
 409         sigset_t set;
 410         compat_sigset_t seta;
 411         stack_t st;
 412         int err, i;
 413
 414         /* Always make any pending restarted system calls return -EINTR */
 415         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 416
 417         synchronize_user_stack();
 418         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 419         sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
 420
 421         /* 1. Make sure we are not getting garbage from the user */
 422         if (verify_area(VERIFY_READ, sf, sizeof(*sf))   ||
 423             (((unsigned long) sf) & 3))
 424                 goto segv;
 425
 426         get_user(pc, &sf->regs.pc);
 427         __get_user(npc, &sf->regs.npc);
 428
 429         if ((pc | npc) & 3)
 430                 goto segv;
 431
 432         if (test_thread_flag(TIF_32BIT)) {
 433                 pc &= 0xffffffff;
 434                 npc &= 0xffffffff;
 435         }
 436         regs->tpc = pc;
 437         regs->tnpc = npc;
 438
 439         /* 2. Restore the state */
 440         err = __get_user(regs->y, &sf->regs.y);
 441         err |= __get_user(psr, &sf->regs.psr);
 442
 443         for (i = UREG_G1; i <= UREG_I7; i++)
 444                 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 445         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 446                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
 447                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 448                         for (i = UREG_G1; i <= UREG_I7; i++)
 449                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 450                 }
 451         }
 452
 453         /* User can only change condition codes in %tstate. */
 454         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 455         regs->tstate |= psr_to_tstate_icc(psr);
 456
 457         err |= __get_user(fpu_save, &sf->fpu_save);
 458         if (fpu_save)
 459                 err |= restore_fpu_state32(regs, &sf->fpu_state);
 460         err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
 461         err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
 462         st.ss_sp = (void *) (long) u_ss_sp;
 463         err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
 464         err |= __get_user(st.ss_size, &sf->stack.ss_size);
 465         if (err)
 466                 goto segv;
 467
 468         /* It is more difficult to avoid calling this function than to
 469            call it and ignore errors.  */
 470         old_fs = get_fs();
 471         set_fs(KERNEL_DS);
 472         do_sigaltstack(&st, NULL, (unsigned long)sf);
 473         set_fs(old_fs);
 474
 475         switch (_NSIG_WORDS) {
 476                 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
 477                 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
 478                 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
 479                 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
 480         }
 481         sigdelsetmask(&set, ~_BLOCKABLE);
 482         spin_lock_irq(&current->sighand->siglock);
 483         current->blocked = set;
 484         recalc_sigpending();
 485         spin_unlock_irq(&current->sighand->siglock);
 486         return;
 487 segv:
 488         do_exit(SIGSEGV);
 489 }
 490
 491 /* Checks if the fp is valid */
 492 static int invalid_frame_pointer(void __user *fp, int fplen)
 493 {
 494         if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
 495                 return 1;
 496         return 0;
 497 }
 498
 499 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
 500 {
 501         unsigned long sp;
 502
 503         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 504         sp = regs->u_regs[UREG_FP];
 505
 506         /* This is the X/Open sanctioned signal stack switching.  */
 507         if (sa->sa_flags & SA_ONSTACK) {
 508                 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
 509                         sp = current->sas_ss_sp + current->sas_ss_size;
 510         }
 511         return (void __user *)(sp - framesize);
 512 }
 513
 514 static void
 515 setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
 516 {
 517         struct signal_sframe32 __user *sframep;
 518         struct sigcontext32 __user *sc;
 519         unsigned int seta[_COMPAT_NSIG_WORDS];
 520         int err = 0;
 521         void *sig_address;
 522         int sig_code;
 523         unsigned long pc = regs->tpc;
 524         unsigned long npc = regs->tnpc;
 525         unsigned int psr;
 526
 527         if (test_thread_flag(TIF_32BIT)) {
 528                 pc &= 0xffffffff;
 529                 npc &= 0xffffffff;
 530         }
 531
 532         synchronize_user_stack();
 533         save_and_clear_fpu();
 534
 535         sframep = (struct signal_sframe32 __user *)
 536                 get_sigframe(sa, regs, SF_ALIGNEDSZ);
 537         if (invalid_frame_pointer(sframep, sizeof(*sframep))){
 538                 /* Don't change signal code and address, so that
 539                  * post mortem debuggers can have a look.
 540                  */
 541                 do_exit(SIGILL);
 542         }
 543
 544         sc = &sframep->sig_context;
 545
 546         /* We've already made sure frame pointer isn't in kernel space... */
 547         err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
 548                          &sc->sigc_onstack);
 549
 550         switch (_NSIG_WORDS) {
 551         case 4: seta[7] = (oldset->sig[3] >> 32);
 552                 seta[6] = oldset->sig[3];
 553         case 3: seta[5] = (oldset->sig[2] >> 32);
 554                 seta[4] = oldset->sig[2];
 555         case 2: seta[3] = (oldset->sig[1] >> 32);
 556                 seta[2] = oldset->sig[1];
 557         case 1: seta[1] = (oldset->sig[0] >> 32);
 558                 seta[0] = oldset->sig[0];
 559         }
 560         err |= __put_user(seta[0], &sc->sigc_mask);
 561         err |= __copy_to_user(sframep->extramask, seta + 1,
 562                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 563         err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
 564         err |= __put_user(pc, &sc->sigc_pc);
 565         err |= __put_user(npc, &sc->sigc_npc);
 566         psr = tstate_to_psr(regs->tstate);
 567         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 568                 psr |= PSR_EF;
 569         err |= __put_user(psr, &sc->sigc_psr);
 570         err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
 571         err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
 572         err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins);
 573
 574         err |= copy_in_user((u32 __user *)sframep,
 575                             (u32 __user *)(regs->u_regs[UREG_FP]),
 576                             sizeof(struct reg_window32));
 577
 578         set_thread_wsaved(0); /* So process is allowed to execute. */
 579         err |= __put_user(signr, &sframep->sig_num);
 580         sig_address = NULL;
 581         sig_code = 0;
 582         if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
 583                 sig_address = info->si_addr;
 584                 switch (signr) {
 585                 case SIGSEGV:
 586                         switch (info->si_code) {
 587                         case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
 588                         default: sig_code = SUBSIG_PROTECTION; break;
 589                         }
 590                         break;
 591                 case SIGILL:
 592                         switch (info->si_code) {
 593                         case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
 594                         case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
 595                         case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
 596                         default: sig_code = SUBSIG_STACK; break;
 597                         }
 598                         break;
 599                 case SIGFPE:
 600                         switch (info->si_code) {
 601                         case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
 602                         case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
 603                         case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
 604                         case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
 605                         case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
 606                         case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
 607                         case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
 608                         default: sig_code = SUBSIG_FPERROR; break;
 609                         }
 610                         break;
 611                 case SIGBUS:
 612                         switch (info->si_code) {
 613                         case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
 614                         case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
 615                         default: sig_code = SUBSIG_BUSTIMEOUT; break;
 616                         }
 617                         break;
 618                 case SIGEMT:
 619                         switch (info->si_code) {
 620                         case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
 621                         }
 622                         break;
 623                 case SIGSYS:
 624                         if (info->si_code == (__SI_FAULT|0x100)) {
 625                                 /* See sys_sunos32.c */
 626                                 sig_code = info->si_trapno;
 627                                 break;
 628                         }
 629                 default:
 630                         sig_address = NULL;
 631                 }
 632         }
 633         err |= __put_user((long)sig_address, &sframep->sig_address);
 634         err |= __put_user(sig_code, &sframep->sig_code);
 635         err |= __put_user((u64)sc, &sframep->sig_scptr);
 636         if (err)
 637                 goto sigsegv;
 638
 639         regs->u_regs[UREG_FP] = (unsigned long) sframep;
 640         regs->tpc = (unsigned long) sa->sa_handler;
 641         regs->tnpc = (regs->tpc + 4);
 642         if (test_thread_flag(TIF_32BIT)) {
 643                 regs->tpc &= 0xffffffff;
 644                 regs->tnpc &= 0xffffffff;
 645         }
 646         return;
 647
 648 sigsegv:
 649         do_exit(SIGSEGV);
 650 }
 651
 652
 653 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 654 {
 655         unsigned long *fpregs = current_thread_info()->fpregs;
 656         unsigned long fprs;
 657         int err = 0;
 658
 659         fprs = current_thread_info()->fpsaved[0];
 660         if (fprs & FPRS_DL)
 661                 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
 662                                     (sizeof(unsigned int) * 32));
 663         if (fprs & FPRS_DU)
 664                 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
 665                                     (sizeof(unsigned int) * 32));
 666         err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
 667         err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
 668         err |= __put_user(fprs, &fpu->si_fprs);
 669
 670         return err;
 671 }
 672
 673 static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
 674                               int signo, sigset_t *oldset)
 675 {
 676         struct new_signal_frame32 __user *sf;
 677         int sigframe_size;
 678         u32 psr;
 679         int i, err;
 680         unsigned int seta[_COMPAT_NSIG_WORDS];
 681
 682         /* 1. Make sure everything is clean */
 683         synchronize_user_stack();
 684         save_and_clear_fpu();
 685
 686         sigframe_size = NF_ALIGNEDSZ;
 687         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
 688                 sigframe_size -= sizeof(__siginfo_fpu_t);
 689
 690         sf = (struct new_signal_frame32 __user *)
 691                 get_sigframe(&ka->sa, regs, sigframe_size);
 692
 693         if (invalid_frame_pointer(sf, sigframe_size))
 694                 goto sigill;
 695
 696         if (get_thread_wsaved() != 0)
 697                 goto sigill;
 698
 699         /* 2. Save the current process state */
 700         if (test_thread_flag(TIF_32BIT)) {
 701                 regs->tpc &= 0xffffffff;
 702                 regs->tnpc &= 0xffffffff;
 703         }
 704         err  = put_user(regs->tpc, &sf->info.si_regs.pc);
 705         err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
 706         err |= __put_user(regs->y, &sf->info.si_regs.y);
 707         psr = tstate_to_psr(regs->tstate);
 708         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 709                 psr |= PSR_EF;
 710         err |= __put_user(psr, &sf->info.si_regs.psr);
 711         for (i = 0; i < 16; i++)
 712                 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 713         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 714         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 715         for (i = 1; i < 16; i++)
 716                 err |= __put_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 717
 718         if (psr & PSR_EF) {
 719                 err |= save_fpu_state32(regs, &sf->fpu_state);
 720                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
 721         } else {
 722                 err |= __put_user(0, &sf->fpu_save);
 723         }
 724
 725         switch (_NSIG_WORDS) {
 726         case 4: seta[7] = (oldset->sig[3] >> 32);
 727                 seta[6] = oldset->sig[3];
 728         case 3: seta[5] = (oldset->sig[2] >> 32);
 729                 seta[4] = oldset->sig[2];
 730         case 2: seta[3] = (oldset->sig[1] >> 32);
 731                 seta[2] = oldset->sig[1];
 732         case 1: seta[1] = (oldset->sig[0] >> 32);
 733                 seta[0] = oldset->sig[0];
 734         }
 735         err |= __put_user(seta[0], &sf->info.si_mask);
 736         err |= __copy_to_user(sf->extramask, seta + 1,
 737                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 738
 739         err |= copy_in_user((u32 __user *)sf,
 740                             (u32 __user *)(regs->u_regs[UREG_FP]),
 741                             sizeof(struct reg_window32));
 742
 743         if (err)
 744                 goto sigsegv;
 745
 746         /* 3. signal handler back-trampoline and parameters */
 747         regs->u_regs[UREG_FP] = (unsigned long) sf;
 748         regs->u_regs[UREG_I0] = signo;
 749         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 750
 751         /* 4. signal handler */
 752         regs->tpc = (unsigned long) ka->sa.sa_handler;
 753         regs->tnpc = (regs->tpc + 4);
 754         if (test_thread_flag(TIF_32BIT)) {
 755                 regs->tpc &= 0xffffffff;
 756                 regs->tnpc &= 0xffffffff;
 757         }
 758
 759         /* 5. return to kernel instructions */
 760         if (ka->ka_restorer) {
 761                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
 762         } else {
 763                 /* Flush instruction space. */
 764                 unsigned long address = ((unsigned long)&(sf->insns[0]));
 765                 pgd_t *pgdp = pgd_offset(current->mm, address);
 766                 pmd_t *pmdp = pmd_offset(pgdp, address);
 767                 pte_t *ptep;
 768
 769                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 770
 771                 err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
 772                 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
 773                 if (err)
 774                         goto sigsegv;
 775
 776                 preempt_disable();
 777                 ptep = pte_offset_map(pmdp, address);
 778                 if (pte_present(*ptep)) {
 779                         unsigned long page = (unsigned long)
 780                                 page_address(pte_page(*ptep));
 781
 782                         __asm__ __volatile__(
 783                         "       membar  #StoreStore\n"
 784                         "       flush   %0 + %1"
 785                         : : "r" (page), "r" (address & (PAGE_SIZE - 1))
 786                         : "memory");
 787                 }
 788                 pte_unmap(ptep);
 789                 preempt_enable();
 790         }
 791         return;
 792
 793 sigill:
 794         do_exit(SIGILL);
 795 sigsegv:
 796         do_exit(SIGSEGV);
 797 }
 798
 799 /* Setup a Solaris stack frame */
 800 static void
 801 setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
 802                    struct pt_regs *regs, int signr, sigset_t *oldset)
 803 {
 804         svr4_signal_frame_t __user *sfp;
 805         svr4_gregset_t  __user *gr;
 806         svr4_siginfo_t  __user *si;
 807         svr4_mcontext_t __user *mc;
 808         svr4_gwindows_t __user *gw;
 809         svr4_ucontext_t __user *uc;
 810         svr4_sigset_t setv;
 811         unsigned int psr;
 812         int i, err;
 813
 814         synchronize_user_stack();
 815         save_and_clear_fpu();
 816
 817         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 818         sfp = (svr4_signal_frame_t __user *)
 819                 get_sigframe(sa, regs,
 820                              sizeof(struct reg_window32) + SVR4_SF_ALIGNED);
 821
 822         if (invalid_frame_pointer(sfp, sizeof(*sfp)))
 823                 do_exit(SIGILL);
 824
 825         /* Start with a clean frame pointer and fill it */
 826         err = clear_user(sfp, sizeof(*sfp));
 827
 828         /* Setup convenience variables */
 829         si = &sfp->si;
 830         uc = &sfp->uc;
 831         gw = &sfp->gw;
 832         mc = &uc->mcontext;
 833         gr = &mc->greg;
 834
 835         /* FIXME: where am I supposed to put this?
 836          * sc->sigc_onstack = old_status;
 837          * anyways, it does not look like it is used for anything at all.
 838          */
 839         setv.sigbits[0] = oldset->sig[0];
 840         setv.sigbits[1] = (oldset->sig[0] >> 32);
 841         if (_NSIG_WORDS >= 2) {
 842                 setv.sigbits[2] = oldset->sig[1];
 843                 setv.sigbits[3] = (oldset->sig[1] >> 32);
 844                 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
 845         } else
 846                 err |= __copy_to_user(&uc->sigmask, &setv,
 847                                       2 * sizeof(unsigned int));
 848
 849         /* Store registers */
 850         if (test_thread_flag(TIF_32BIT)) {
 851                 regs->tpc &= 0xffffffff;
 852                 regs->tnpc &= 0xffffffff;
 853         }
 854         err |= __put_user(regs->tpc, &((*gr)[SVR4_PC]));
 855         err |= __put_user(regs->tnpc, &((*gr)[SVR4_NPC]));
 856         psr = tstate_to_psr(regs->tstate);
 857         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 858                 psr |= PSR_EF;
 859         err |= __put_user(psr, &((*gr)[SVR4_PSR]));
 860         err |= __put_user(regs->y, &((*gr)[SVR4_Y]));
 861
 862         /* Copy g[1..7] and o[0..7] registers */
 863         for (i = 0; i < 7; i++)
 864                 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
 865         for (i = 0; i < 8; i++)
 866                 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
 867
 868         /* Setup sigaltstack */
 869         err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
 870         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
 871         err |= __put_user(current->sas_ss_size, &uc->stack.size);
 872
 873         /* Save the currently window file: */
 874
 875         /* 1. Link sfp->uc->gwins to our windows */
 876         err |= __put_user((u32)(long)gw, &mc->gwin);
 877
 878         /* 2. Number of windows to restore at setcontext (): */
 879         err |= __put_user(get_thread_wsaved(), &gw->count);
 880
 881         /* 3. We just pay attention to the gw->count field on setcontext */
 882         set_thread_wsaved(0); /* So process is allowed to execute. */
 883
 884         /* Setup the signal information.  Solaris expects a bunch of
 885          * information to be passed to the signal handler, we don't provide
 886          * that much currently, should use siginfo.
 887          */
 888         err |= __put_user(signr, &si->siginfo.signo);
 889         err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
 890         if (err)
 891                 goto sigsegv;
 892
 893         regs->u_regs[UREG_FP] = (unsigned long) sfp;
 894         regs->tpc = (unsigned long) sa->sa_handler;
 895         regs->tnpc = (regs->tpc + 4);
 896         if (test_thread_flag(TIF_32BIT)) {
 897                 regs->tpc &= 0xffffffff;
 898                 regs->tnpc &= 0xffffffff;
 899         }
 900
 901         /* Arguments passed to signal handler */
 902         if (regs->u_regs[14]){
 903                 struct reg_window32 __user *rw = (struct reg_window32 __user *)
 904                         (regs->u_regs[14] & 0x00000000ffffffffUL);
 905
 906                 err |= __put_user(signr, &rw->ins[0]);
 907                 err |= __put_user((u64)si, &rw->ins[1]);
 908                 err |= __put_user((u64)uc, &rw->ins[2]);
 909                 err |= __put_user((u64)sfp, &rw->ins[6]);       /* frame pointer */
 910                 if (err)
 911                         goto sigsegv;
 912
 913                 regs->u_regs[UREG_I0] = signr;
 914                 regs->u_regs[UREG_I1] = (u32)(u64) si;
 915                 regs->u_regs[UREG_I2] = (u32)(u64) uc;
 916         }
 917         return;
 918
 919 sigsegv:
 920         do_exit(SIGSEGV);
 921 }
 922
 923 asmlinkage int
 924 svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs)
 925 {
 926         svr4_gregset_t  __user *gr;
 927         svr4_mcontext_t __user *mc;
 928         svr4_sigset_t setv;
 929         int i, err;
 930         u32 psr;
 931
 932         synchronize_user_stack();
 933         save_and_clear_fpu();
 934
 935         if (get_thread_wsaved())
 936                 do_exit(SIGSEGV);
 937
 938         err = clear_user(uc, sizeof(*uc));
 939
 940         /* Setup convenience variables */
 941         mc = &uc->mcontext;
 942         gr = &mc->greg;
 943
 944         setv.sigbits[0] = current->blocked.sig[0];
 945         setv.sigbits[1] = (current->blocked.sig[0] >> 32);
 946         if (_NSIG_WORDS >= 2) {
 947                 setv.sigbits[2] = current->blocked.sig[1];
 948                 setv.sigbits[3] = (current->blocked.sig[1] >> 32);
 949                 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
 950         } else
 951                 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
 952
 953         /* Store registers */
 954         if (test_thread_flag(TIF_32BIT)) {
 955                 regs->tpc &= 0xffffffff;
 956                 regs->tnpc &= 0xffffffff;
 957         }
 958         err |= __put_user(regs->tpc, &uc->mcontext.greg[SVR4_PC]);
 959         err |= __put_user(regs->tnpc, &uc->mcontext.greg[SVR4_NPC]);
 960
 961         psr = tstate_to_psr(regs->tstate) & ~PSR_EF;
 962         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 963                 psr |= PSR_EF;
 964         err |= __put_user(psr, &uc->mcontext.greg[SVR4_PSR]);
 965
 966         err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]);
 967
 968         /* Copy g[1..7] and o[0..7] registers */
 969         for (i = 0; i < 7; i++)
 970                 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
 971         for (i = 0; i < 8; i++)
 972                 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
 973
 974         /* Setup sigaltstack */
 975         err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
 976         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
 977         err |= __put_user(current->sas_ss_size, &uc->stack.size);
 978
 979         /* The register file is not saved
 980          * we have already stuffed all of it with sync_user_stack
 981          */
 982         return (err ? -EFAULT : 0);
 983 }
 984
 985
 986 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
 987 asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs)
 988 {
 989         svr4_gregset_t  __user *gr;
 990         mm_segment_t old_fs;
 991         u32 pc, npc, psr, u_ss_sp;
 992         sigset_t set;
 993         svr4_sigset_t setv;
 994         int i, err;
 995         stack_t st;
 996
 997         /* Fixme: restore windows, or is this already taken care of in
 998          * svr4_setup_frame when sync_user_windows is done?
 999          */
1000         flush_user_windows();
1001
1002         if (get_thread_wsaved())
1003                 goto sigsegv;
1004
1005         if (((unsigned long) c) & 3){
1006                 printk("Unaligned structure passed\n");
1007                 goto sigsegv;
1008         }
1009
1010         if (!__access_ok((unsigned long)c, sizeof(*c))) {
1011                 /* Miguel, add nice debugging msg _here_. ;-) */
1012                 goto sigsegv;
1013         }
1014
1015         /* Check for valid PC and nPC */
1016         gr = &c->mcontext.greg;
1017         err = __get_user(pc, &((*gr)[SVR4_PC]));
1018         err |= __get_user(npc, &((*gr)[SVR4_NPC]));
1019         if ((pc | npc) & 3)
1020                 goto sigsegv;
1021
1022         /* Retrieve information from passed ucontext */
1023         /* note that nPC is ored a 1, this is used to inform entry.S */
1024         /* that we don't want it to mess with our PC and nPC */
1025
1026         err |= copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1027         set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
1028         if (_NSIG_WORDS >= 2)
1029                 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
1030
1031         err |= __get_user(u_ss_sp, &c->stack.sp);
1032         st.ss_sp = (void *) (long) u_ss_sp;
1033         err |= __get_user(st.ss_flags, &c->stack.flags);
1034         err |= __get_user(st.ss_size, &c->stack.size);
1035         if (err)
1036                 goto sigsegv;
1037
1038         /* It is more difficult to avoid calling this function than to
1039            call it and ignore errors.  */
1040         old_fs = get_fs();
1041         set_fs(KERNEL_DS);
1042         do_sigaltstack(&st, NULL, regs->u_regs[UREG_I6]);
1043         set_fs(old_fs);
1044
1045         sigdelsetmask(&set, ~_BLOCKABLE);
1046         spin_lock_irq(&current->sighand->siglock);
1047         current->blocked = set;
1048         recalc_sigpending();
1049         spin_unlock_irq(&current->sighand->siglock);
1050         regs->tpc = pc;
1051         regs->tnpc = npc | 1;
1052         if (test_thread_flag(TIF_32BIT)) {
1053                 regs->tpc &= 0xffffffff;
1054                 regs->tnpc &= 0xffffffff;
1055         }
1056         err |= __get_user(regs->y, &((*gr)[SVR4_Y]));
1057         err |= __get_user(psr, &((*gr)[SVR4_PSR]));
1058         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
1059         regs->tstate |= psr_to_tstate_icc(psr);
1060
1061         /* Restore g[1..7] and o[0..7] registers */
1062         for (i = 0; i < 7; i++)
1063                 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1064         for (i = 0; i < 8; i++)
1065                 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1066         if (err)
1067                 goto sigsegv;
1068
1069         return -EINTR;
1070 sigsegv:
1071         do_exit(SIGSEGV);
1072 }
1073
1074 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
1075                              unsigned long signr, sigset_t *oldset,
1076                              siginfo_t *info)
1077 {
1078         struct rt_signal_frame32 __user *sf;
1079         int sigframe_size;
1080         u32 psr;
1081         int i, err;
1082         compat_sigset_t seta;
1083
1084         /* 1. Make sure everything is clean */
1085         synchronize_user_stack();
1086         save_and_clear_fpu();
1087
1088         sigframe_size = RT_ALIGNEDSZ;
1089         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
1090                 sigframe_size -= sizeof(__siginfo_fpu_t);
1091
1092         sf = (struct rt_signal_frame32 __user *)
1093                 get_sigframe(&ka->sa, regs, sigframe_size);
1094
1095         if (invalid_frame_pointer(sf, sigframe_size))
1096                 goto sigill;
1097
1098         if (get_thread_wsaved() != 0)
1099                 goto sigill;
1100
1101         /* 2. Save the current process state */
1102         if (test_thread_flag(TIF_32BIT)) {
1103                 regs->tpc &= 0xffffffff;
1104                 regs->tnpc &= 0xffffffff;
1105         }
1106         err  = put_user(regs->tpc, &sf->regs.pc);
1107         err |= __put_user(regs->tnpc, &sf->regs.npc);
1108         err |= __put_user(regs->y, &sf->regs.y);
1109         psr = tstate_to_psr(regs->tstate);
1110         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1111                 psr |= PSR_EF;
1112         err |= __put_user(psr, &sf->regs.psr);
1113         for (i = 0; i < 16; i++)
1114                 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
1115         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
1116         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
1117         for (i = 1; i < 16; i++)
1118                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
1119                                   &sf->v8plus.g_upper[i]);
1120
1121         if (psr & PSR_EF) {
1122                 err |= save_fpu_state32(regs, &sf->fpu_state);
1123                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
1124         } else {
1125                 err |= __put_user(0, &sf->fpu_save);
1126         }
1127
1128         /* Update the siginfo structure.  */
1129         err |= copy_siginfo_to_user32(&sf->info, info);
1130
1131         /* Setup sigaltstack */
1132         err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
1133         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
1134         err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
1135
1136         switch (_NSIG_WORDS) {
1137         case 4: seta.sig[7] = (oldset->sig[3] >> 32);
1138                 seta.sig[6] = oldset->sig[3];
1139         case 3: seta.sig[5] = (oldset->sig[2] >> 32);
1140                 seta.sig[4] = oldset->sig[2];
1141         case 2: seta.sig[3] = (oldset->sig[1] >> 32);
1142                 seta.sig[2] = oldset->sig[1];
1143         case 1: seta.sig[1] = (oldset->sig[0] >> 32);
1144                 seta.sig[0] = oldset->sig[0];
1145         }
1146         err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
1147
1148         err |= copy_in_user((u32 __user *)sf,
1149                             (u32 __user *)(regs->u_regs[UREG_FP]),
1150                             sizeof(struct reg_window32));
1151         if (err)
1152                 goto sigsegv;
1153
1154         /* 3. signal handler back-trampoline and parameters */
1155         regs->u_regs[UREG_FP] = (unsigned long) sf;
1156         regs->u_regs[UREG_I0] = signr;
1157         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
1158
1159         /* 4. signal handler */
1160         regs->tpc = (unsigned long) ka->sa.sa_handler;
1161         regs->tnpc = (regs->tpc + 4);
1162         if (test_thread_flag(TIF_32BIT)) {
1163                 regs->tpc &= 0xffffffff;
1164                 regs->tnpc &= 0xffffffff;
1165         }
1166
1167         /* 5. return to kernel instructions */
1168         if (ka->ka_restorer)
1169                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
1170         else {
1171                 /* Flush instruction space. */
1172                 unsigned long address = ((unsigned long)&(sf->insns[0]));
1173                 pgd_t *pgdp = pgd_offset(current->mm, address);
1174                 pmd_t *pmdp = pmd_offset(pgdp, address);
1175                 pte_t *ptep;
1176
1177                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
1178
1179                 /* mov __NR_rt_sigreturn, %g1 */
1180                 err |= __put_user(0x82102065, &sf->insns[0]);
1181
1182                 /* t 0x10 */
1183                 err |= __put_user(0x91d02010, &sf->insns[1]);
1184                 if (err)
1185                         goto sigsegv;
1186
1187                 preempt_disable();
1188                 ptep = pte_offset_map(pmdp, address);
1189                 if (pte_present(*ptep)) {
1190                         unsigned long page = (unsigned long)
1191                                 page_address(pte_page(*ptep));
1192
1193                         __asm__ __volatile__(
1194                         "       membar  #StoreStore\n"
1195                         "       flush   %0 + %1"
1196                         : : "r" (page), "r" (address & (PAGE_SIZE - 1))
1197                         : "memory");
1198                 }
1199                 pte_unmap(ptep);
1200                 preempt_enable();
1201         }
1202         return;
1203
1204 sigill:
1205         do_exit(SIGILL);
1206 sigsegv:
1207         do_exit(SIGSEGV);
1208 }
1209
1210 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
1211                                    siginfo_t *info,
1212                                    sigset_t *oldset, struct pt_regs *regs,
1213                                    int svr4_signal)
1214 {
1215         if (svr4_signal)
1216                 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc,
1217                                    regs, signr, oldset);
1218         else {
1219                 if (ka->sa.sa_flags & SA_SIGINFO)
1220                         setup_rt_frame32(ka, regs, signr, oldset, info);
1221                 else if (test_thread_flag(TIF_NEWSIGNALS))
1222                         new_setup_frame32(ka, regs, signr, oldset);
1223                 else
1224                         setup_frame32(&ka->sa, regs, signr, oldset, info);
1225         }
1226         if (ka->sa.sa_flags & SA_ONESHOT)
1227                 ka->sa.sa_handler = SIG_DFL;
1228         if (!(ka->sa.sa_flags & SA_NOMASK)) {
1229                 spin_lock_irq(&current->sighand->siglock);
1230                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
1231                 sigaddset(&current->blocked,signr);
1232                 recalc_sigpending();
1233                 spin_unlock_irq(&current->sighand->siglock);
1234         }
1235 }
1236
1237 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
1238                                      struct sigaction *sa)
1239 {
1240         switch (regs->u_regs[UREG_I0]) {
1241         case ERESTART_RESTARTBLOCK:
1242         case ERESTARTNOHAND:
1243         no_system_call_restart:
1244                 regs->u_regs[UREG_I0] = EINTR;
1245                 regs->tstate |= TSTATE_ICARRY;
1246                 break;
1247         case ERESTARTSYS:
1248                 if (!(sa->sa_flags & SA_RESTART))
1249                         goto no_system_call_restart;
1250                 /* fallthrough */
1251         case ERESTARTNOINTR:
1252                 regs->u_regs[UREG_I0] = orig_i0;
1253                 regs->tpc -= 4;
1254                 regs->tnpc -= 4;
1255         }
1256 }
1257
1258 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1259  * want to handle. Thus you cannot kill init even with a SIGKILL even by
1260  * mistake.
1261  */
1262 int do_signal32(sigset_t *oldset, struct pt_regs * regs,
1263                 unsigned long orig_i0, int restart_syscall)
1264 {
1265         siginfo_t info;
1266         struct signal_deliver_cookie cookie;
1267         int signr;
1268         int svr4_signal = current->personality == PER_SVR4;
1269
1270         cookie.restart_syscall = restart_syscall;
1271         cookie.orig_i0 = orig_i0;
1272
1273         signr = get_signal_to_deliver(&info, regs, &cookie);
1274         if (signr > 0) {
1275                 struct k_sigaction *ka;
1276
1277                 ka = &current->sighand->action[signr-1];
1278
1279                 if (cookie.restart_syscall)
1280                         syscall_restart32(orig_i0, regs, &ka->sa);
1281                 handle_signal32(signr, ka, &info, oldset, regs, svr4_signal);
1282                 return 1;
1283         }
1284         if (cookie.restart_syscall &&
1285             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1286              regs->u_regs[UREG_I0] == ERESTARTSYS ||
1287              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1288                 /* replay the system call when we are done */
1289                 regs->u_regs[UREG_I0] = cookie.orig_i0;
1290                 regs->tpc -= 4;
1291                 regs->tnpc -= 4;
1292         }
1293         if (cookie.restart_syscall &&
1294             regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1295                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1296                 regs->tpc -= 4;
1297                 regs->tnpc -= 4;
1298         }
1299         return 0;
1300 }
1301
1302 struct sigstack32 {
1303         u32 the_stack;
1304         int cur_status;
1305 };
1306
1307 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1308 {
1309         struct sigstack32 __user *ssptr =
1310                 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
1311         struct sigstack32 __user *ossptr =
1312                 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
1313         int ret = -EFAULT;
1314
1315         /* First see if old state is wanted. */
1316         if (ossptr) {
1317                 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1318                              &ossptr->the_stack) ||
1319                     __put_user(on_sig_stack(sp), &ossptr->cur_status))
1320                         goto out;
1321         }
1322
1323         /* Now see if we want to update the new state. */
1324         if (ssptr) {
1325                 u32 ss_sp;
1326
1327                 if (get_user(ss_sp, &ssptr->the_stack))
1328                         goto out;
1329
1330                 /* If the current stack was set with sigaltstack, don't
1331                  * swap stacks while we are on it.
1332                  */
1333                 ret = -EPERM;
1334                 if (current->sas_ss_sp && on_sig_stack(sp))
1335                         goto out;
1336
1337                 /* Since we don't know the extent of the stack, and we don't
1338                  * track onstack-ness, but rather calculate it, we must
1339                  * presume a size.  Ho hum this interface is lossy.
1340                  */
1341                 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1342                 current->sas_ss_size = SIGSTKSZ;
1343         }
1344
1345         ret = 0;
1346 out:
1347         return ret;
1348 }
1349
1350 asmlinkage int do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1351 {
1352         stack_t uss, uoss;
1353         u32 u_ss_sp = 0;
1354         int ret;
1355         mm_segment_t old_fs;
1356
1357         if (ussa && (get_user(u_ss_sp, &((stack_t32 __user *)(long)ussa)->ss_sp) ||
1358                     __get_user(uss.ss_flags, &((stack_t32 __user *)(long)ussa)->ss_flags) ||
1359                     __get_user(uss.ss_size, &((stack_t32 __user *)(long)ussa)->ss_size)))
1360                 return -EFAULT;
1361         uss.ss_sp = (void *) (long) u_ss_sp;
1362         old_fs = get_fs();
1363         set_fs(KERNEL_DS);
1364         ret = do_sigaltstack(ussa ? &uss : NULL, uossa ? &uoss : NULL, sp);
1365         set_fs(old_fs);
1366         if (!ret && uossa && (put_user((long)uoss.ss_sp, &((stack_t32 __user *)(long)uossa)->ss_sp) ||
1367                     __put_user(uoss.ss_flags, &((stack_t32 __user *)(long)uossa)->ss_flags) ||
1368                     __put_user(uoss.ss_size, &((stack_t32 __user *)(long)uossa)->ss_size)))
1369                 return -EFAULT;
1370         return ret;
1371 }