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                 do_new_sigreturn32(regs);
 350                 return;
 351         }
 352
 353         scptr = (struct sigcontext32 __user *)
 354                 (regs->u_regs[UREG_I0] & 0x00000000ffffffffUL);
 355         /* Check sanity of the user arg. */
 356         if (verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext32)) ||
 357             (((unsigned long) scptr) & 3))
 358                 goto segv;
 359
 360         err = __get_user(pc, &scptr->sigc_pc);
 361         err |= __get_user(npc, &scptr->sigc_npc);
 362
 363         if ((pc | npc) & 3)
 364                 goto segv; /* Nice try. */
 365
 366         err |= __get_user(seta[0], &scptr->sigc_mask);
 367         /* Note that scptr + 1 points to extramask */
 368         err |= copy_from_user(seta+1, scptr + 1,
 369                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 370         if (err)
 371                 goto segv;
 372         switch (_NSIG_WORDS) {
 373                 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
 374                 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
 375                 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
 376                 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
 377         }
 378         sigdelsetmask(&set, ~_BLOCKABLE);
 379         spin_lock_irq(&current->sighand->siglock);
 380         current->blocked = set;
 381         recalc_sigpending();
 382         spin_unlock_irq(&current->sighand->siglock);
 383
 384         if (test_thread_flag(TIF_32BIT)) {
 385                 pc &= 0xffffffff;
 386                 npc &= 0xffffffff;
 387         }
 388         regs->tpc = pc;
 389         regs->tnpc = npc;
 390         err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
 391         err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
 392         err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
 393
 394         /* User can only change condition codes in %tstate. */
 395         err |= __get_user(psr, &scptr->sigc_psr);
 396         if (err)
 397                 goto segv;
 398         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 399         regs->tstate |= psr_to_tstate_icc(psr);
 400         return;
 401
 402 segv:
 403         do_exit(SIGSEGV);
 404 }
 405
 406 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
 407 {
 408         struct rt_signal_frame32 __user *sf;
 409         unsigned int psr, pc, npc, fpu_save, u_ss_sp;
 410         mm_segment_t old_fs;
 411         sigset_t set;
 412         compat_sigset_t seta;
 413         stack_t st;
 414         int err, i;
 415
 416         /* Always make any pending restarted system calls return -EINTR */
 417         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 418
 419         synchronize_user_stack();
 420         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 421         sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
 422
 423         /* 1. Make sure we are not getting garbage from the user */
 424         if (verify_area(VERIFY_READ, sf, sizeof(*sf))   ||
 425             (((unsigned long) sf) & 3))
 426                 goto segv;
 427
 428         get_user(pc, &sf->regs.pc);
 429         __get_user(npc, &sf->regs.npc);
 430
 431         if ((pc | npc) & 3)
 432                 goto segv;
 433
 434         if (test_thread_flag(TIF_32BIT)) {
 435                 pc &= 0xffffffff;
 436                 npc &= 0xffffffff;
 437         }
 438         regs->tpc = pc;
 439         regs->tnpc = npc;
 440
 441         /* 2. Restore the state */
 442         err = __get_user(regs->y, &sf->regs.y);
 443         err |= __get_user(psr, &sf->regs.psr);
 444
 445         for (i = UREG_G1; i <= UREG_I7; i++)
 446                 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 447         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 448                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
 449                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 450                         for (i = UREG_G1; i <= UREG_I7; i++)
 451                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 452                 }
 453         }
 454
 455         /* User can only change condition codes in %tstate. */
 456         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 457         regs->tstate |= psr_to_tstate_icc(psr);
 458
 459         err |= __get_user(fpu_save, &sf->fpu_save);
 460         if (fpu_save)
 461                 err |= restore_fpu_state32(regs, &sf->fpu_state);
 462         err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
 463         err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
 464         st.ss_sp = (void *) (long) u_ss_sp;
 465         err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
 466         err |= __get_user(st.ss_size, &sf->stack.ss_size);
 467         if (err)
 468                 goto segv;
 469
 470         /* It is more difficult to avoid calling this function than to
 471            call it and ignore errors.  */
 472         old_fs = get_fs();
 473         set_fs(KERNEL_DS);
 474         do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
 475         set_fs(old_fs);
 476
 477         switch (_NSIG_WORDS) {
 478                 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
 479                 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
 480                 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
 481                 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
 482         }
 483         sigdelsetmask(&set, ~_BLOCKABLE);
 484         spin_lock_irq(&current->sighand->siglock);
 485         current->blocked = set;
 486         recalc_sigpending();
 487         spin_unlock_irq(&current->sighand->siglock);
 488         return;
 489 segv:
 490         do_exit(SIGSEGV);
 491 }
 492
 493 /* Checks if the fp is valid */
 494 static int invalid_frame_pointer(void __user *fp, int fplen)
 495 {
 496         if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
 497                 return 1;
 498         return 0;
 499 }
 500
 501 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
 502 {
 503         unsigned long sp;
 504
 505         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 506         sp = regs->u_regs[UREG_FP];
 507
 508         /* This is the X/Open sanctioned signal stack switching.  */
 509         if (sa->sa_flags & SA_ONSTACK) {
 510                 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
 511                         sp = current->sas_ss_sp + current->sas_ss_size;
 512         }
 513         return (void __user *)(sp - framesize);
 514 }
 515
 516 static void
 517 setup_frame32(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
 518 {
 519         struct signal_sframe32 __user *sframep;
 520         struct sigcontext32 __user *sc;
 521         unsigned int seta[_COMPAT_NSIG_WORDS];
 522         int err = 0;
 523         void *sig_address;
 524         int sig_code;
 525         unsigned long pc = regs->tpc;
 526         unsigned long npc = regs->tnpc;
 527         unsigned int psr;
 528
 529         if (test_thread_flag(TIF_32BIT)) {
 530                 pc &= 0xffffffff;
 531                 npc &= 0xffffffff;
 532         }
 533
 534         synchronize_user_stack();
 535         save_and_clear_fpu();
 536
 537         sframep = (struct signal_sframe32 __user *)
 538                 get_sigframe(sa, regs, SF_ALIGNEDSZ);
 539         if (invalid_frame_pointer(sframep, sizeof(*sframep))){
 540                 /* Don't change signal code and address, so that
 541                  * post mortem debuggers can have a look.
 542                  */
 543                 do_exit(SIGILL);
 544         }
 545
 546         sc = &sframep->sig_context;
 547
 548         /* We've already made sure frame pointer isn't in kernel space... */
 549         err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
 550                          &sc->sigc_onstack);
 551
 552         switch (_NSIG_WORDS) {
 553         case 4: seta[7] = (oldset->sig[3] >> 32);
 554                 seta[6] = oldset->sig[3];
 555         case 3: seta[5] = (oldset->sig[2] >> 32);
 556                 seta[4] = oldset->sig[2];
 557         case 2: seta[3] = (oldset->sig[1] >> 32);
 558                 seta[2] = oldset->sig[1];
 559         case 1: seta[1] = (oldset->sig[0] >> 32);
 560                 seta[0] = oldset->sig[0];
 561         }
 562         err |= __put_user(seta[0], &sc->sigc_mask);
 563         err |= __copy_to_user(sframep->extramask, seta + 1,
 564                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 565         err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
 566         err |= __put_user(pc, &sc->sigc_pc);
 567         err |= __put_user(npc, &sc->sigc_npc);
 568         psr = tstate_to_psr(regs->tstate);
 569         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 570                 psr |= PSR_EF;
 571         err |= __put_user(psr, &sc->sigc_psr);
 572         err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
 573         err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
 574         err |= __put_user(get_thread_wsaved(), &sc->sigc_oswins);
 575
 576         err |= copy_in_user((u32 __user *)sframep,
 577                             (u32 __user *)(regs->u_regs[UREG_FP]),
 578                             sizeof(struct reg_window32));
 579
 580         set_thread_wsaved(0); /* So process is allowed to execute. */
 581         err |= __put_user(signr, &sframep->sig_num);
 582         sig_address = NULL;
 583         sig_code = 0;
 584         if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
 585                 sig_address = info->si_addr;
 586                 switch (signr) {
 587                 case SIGSEGV:
 588                         switch (info->si_code) {
 589                         case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
 590                         default: sig_code = SUBSIG_PROTECTION; break;
 591                         }
 592                         break;
 593                 case SIGILL:
 594                         switch (info->si_code) {
 595                         case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
 596                         case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
 597                         case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP(info->si_trapno); break;
 598                         default: sig_code = SUBSIG_STACK; break;
 599                         }
 600                         break;
 601                 case SIGFPE:
 602                         switch (info->si_code) {
 603                         case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
 604                         case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
 605                         case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
 606                         case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
 607                         case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
 608                         case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
 609                         case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
 610                         default: sig_code = SUBSIG_FPERROR; break;
 611                         }
 612                         break;
 613                 case SIGBUS:
 614                         switch (info->si_code) {
 615                         case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
 616                         case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
 617                         default: sig_code = SUBSIG_BUSTIMEOUT; break;
 618                         }
 619                         break;
 620                 case SIGEMT:
 621                         switch (info->si_code) {
 622                         case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
 623                         }
 624                         break;
 625                 case SIGSYS:
 626                         if (info->si_code == (__SI_FAULT|0x100)) {
 627                                 /* See sys_sunos32.c */
 628                                 sig_code = info->si_trapno;
 629                                 break;
 630                         }
 631                 default:
 632                         sig_address = NULL;
 633                 }
 634         }
 635         err |= __put_user((long)sig_address, &sframep->sig_address);
 636         err |= __put_user(sig_code, &sframep->sig_code);
 637         err |= __put_user((u64)sc, &sframep->sig_scptr);
 638         if (err)
 639                 goto sigsegv;
 640
 641         regs->u_regs[UREG_FP] = (unsigned long) sframep;
 642         regs->tpc = (unsigned long) sa->sa_handler;
 643         regs->tnpc = (regs->tpc + 4);
 644         if (test_thread_flag(TIF_32BIT)) {
 645                 regs->tpc &= 0xffffffff;
 646                 regs->tnpc &= 0xffffffff;
 647         }
 648         return;
 649
 650 sigsegv:
 651         do_exit(SIGSEGV);
 652 }
 653
 654
 655 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 656 {
 657         unsigned long *fpregs = current_thread_info()->fpregs;
 658         unsigned long fprs;
 659         int err = 0;
 660
 661         fprs = current_thread_info()->fpsaved[0];
 662         if (fprs & FPRS_DL)
 663                 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
 664                                     (sizeof(unsigned int) * 32));
 665         if (fprs & FPRS_DU)
 666                 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
 667                                     (sizeof(unsigned int) * 32));
 668         err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
 669         err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
 670         err |= __put_user(fprs, &fpu->si_fprs);
 671
 672         return err;
 673 }
 674
 675 static void new_setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
 676                               int signo, sigset_t *oldset)
 677 {
 678         struct new_signal_frame32 __user *sf;
 679         int sigframe_size;
 680         u32 psr;
 681         int i, err;
 682         unsigned int seta[_COMPAT_NSIG_WORDS];
 683
 684         /* 1. Make sure everything is clean */
 685         synchronize_user_stack();
 686         save_and_clear_fpu();
 687
 688         sigframe_size = NF_ALIGNEDSZ;
 689         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
 690                 sigframe_size -= sizeof(__siginfo_fpu_t);
 691
 692         sf = (struct new_signal_frame32 __user *)
 693                 get_sigframe(&ka->sa, regs, sigframe_size);
 694
 695         if (invalid_frame_pointer(sf, sigframe_size))
 696                 goto sigill;
 697
 698         if (get_thread_wsaved() != 0)
 699                 goto sigill;
 700
 701         /* 2. Save the current process state */
 702         if (test_thread_flag(TIF_32BIT)) {
 703                 regs->tpc &= 0xffffffff;
 704                 regs->tnpc &= 0xffffffff;
 705         }
 706         err  = put_user(regs->tpc, &sf->info.si_regs.pc);
 707         err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
 708         err |= __put_user(regs->y, &sf->info.si_regs.y);
 709         psr = tstate_to_psr(regs->tstate);
 710         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 711                 psr |= PSR_EF;
 712         err |= __put_user(psr, &sf->info.si_regs.psr);
 713         for (i = 0; i < 16; i++)
 714                 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 715         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 716         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 717         for (i = 1; i < 16; i++)
 718                 err |= __put_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 719
 720         if (psr & PSR_EF) {
 721                 err |= save_fpu_state32(regs, &sf->fpu_state);
 722                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
 723         } else {
 724                 err |= __put_user(0, &sf->fpu_save);
 725         }
 726
 727         switch (_NSIG_WORDS) {
 728         case 4: seta[7] = (oldset->sig[3] >> 32);
 729                 seta[6] = oldset->sig[3];
 730         case 3: seta[5] = (oldset->sig[2] >> 32);
 731                 seta[4] = oldset->sig[2];
 732         case 2: seta[3] = (oldset->sig[1] >> 32);
 733                 seta[2] = oldset->sig[1];
 734         case 1: seta[1] = (oldset->sig[0] >> 32);
 735                 seta[0] = oldset->sig[0];
 736         }
 737         err |= __put_user(seta[0], &sf->info.si_mask);
 738         err |= __copy_to_user(sf->extramask, seta + 1,
 739                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 740
 741         err |= copy_in_user((u32 __user *)sf,
 742                             (u32 __user *)(regs->u_regs[UREG_FP]),
 743                             sizeof(struct reg_window32));
 744
 745         if (err)
 746                 goto sigsegv;
 747
 748         /* 3. signal handler back-trampoline and parameters */
 749         regs->u_regs[UREG_FP] = (unsigned long) sf;
 750         regs->u_regs[UREG_I0] = signo;
 751         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 752
 753         /* 4. signal handler */
 754         regs->tpc = (unsigned long) ka->sa.sa_handler;
 755         regs->tnpc = (regs->tpc + 4);
 756         if (test_thread_flag(TIF_32BIT)) {
 757                 regs->tpc &= 0xffffffff;
 758                 regs->tnpc &= 0xffffffff;
 759         }
 760
 761         /* 5. return to kernel instructions */
 762         if (ka->ka_restorer) {
 763                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
 764         } else {
 765                 /* Flush instruction space. */
 766                 unsigned long address = ((unsigned long)&(sf->insns[0]));
 767                 pgd_t *pgdp = pgd_offset(current->mm, address);
 768                 pmd_t *pmdp = pmd_offset(pgdp, address);
 769                 pte_t *ptep;
 770
 771                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 772
 773                 err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
 774                 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
 775                 if (err)
 776                         goto sigsegv;
 777
 778                 preempt_disable();
 779                 ptep = pte_offset_map(pmdp, address);
 780                 if (pte_present(*ptep)) {
 781                         unsigned long page = (unsigned long)
 782                                 page_address(pte_page(*ptep));
 783
 784                         __asm__ __volatile__(
 785                         "       membar  #StoreStore\n"
 786                         "       flush   %0 + %1"
 787                         : : "r" (page), "r" (address & (PAGE_SIZE - 1))
 788                         : "memory");
 789                 }
 790                 pte_unmap(ptep);
 791                 preempt_enable();
 792         }
 793         return;
 794
 795 sigill:
 796         do_exit(SIGILL);
 797 sigsegv:
 798         do_exit(SIGSEGV);
 799 }
 800
 801 /* Setup a Solaris stack frame */
 802 static void
 803 setup_svr4_frame32(struct sigaction *sa, unsigned long pc, unsigned long npc,
 804                    struct pt_regs *regs, int signr, sigset_t *oldset)
 805 {
 806         svr4_signal_frame_t __user *sfp;
 807         svr4_gregset_t  __user *gr;
 808         svr4_siginfo_t  __user *si;
 809         svr4_mcontext_t __user *mc;
 810         svr4_gwindows_t __user *gw;
 811         svr4_ucontext_t __user *uc;
 812         svr4_sigset_t setv;
 813         unsigned int psr;
 814         int i, err;
 815
 816         synchronize_user_stack();
 817         save_and_clear_fpu();
 818
 819         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 820         sfp = (svr4_signal_frame_t __user *)
 821                 get_sigframe(sa, regs,
 822                              sizeof(struct reg_window32) + SVR4_SF_ALIGNED);
 823
 824         if (invalid_frame_pointer(sfp, sizeof(*sfp)))
 825                 do_exit(SIGILL);
 826
 827         /* Start with a clean frame pointer and fill it */
 828         err = clear_user(sfp, sizeof(*sfp));
 829
 830         /* Setup convenience variables */
 831         si = &sfp->si;
 832         uc = &sfp->uc;
 833         gw = &sfp->gw;
 834         mc = &uc->mcontext;
 835         gr = &mc->greg;
 836
 837         /* FIXME: where am I supposed to put this?
 838          * sc->sigc_onstack = old_status;
 839          * anyways, it does not look like it is used for anything at all.
 840          */
 841         setv.sigbits[0] = oldset->sig[0];
 842         setv.sigbits[1] = (oldset->sig[0] >> 32);
 843         if (_NSIG_WORDS >= 2) {
 844                 setv.sigbits[2] = oldset->sig[1];
 845                 setv.sigbits[3] = (oldset->sig[1] >> 32);
 846                 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
 847         } else
 848                 err |= __copy_to_user(&uc->sigmask, &setv,
 849                                       2 * sizeof(unsigned int));
 850
 851         /* Store registers */
 852         if (test_thread_flag(TIF_32BIT)) {
 853                 regs->tpc &= 0xffffffff;
 854                 regs->tnpc &= 0xffffffff;
 855         }
 856         err |= __put_user(regs->tpc, &((*gr)[SVR4_PC]));
 857         err |= __put_user(regs->tnpc, &((*gr)[SVR4_NPC]));
 858         psr = tstate_to_psr(regs->tstate);
 859         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 860                 psr |= PSR_EF;
 861         err |= __put_user(psr, &((*gr)[SVR4_PSR]));
 862         err |= __put_user(regs->y, &((*gr)[SVR4_Y]));
 863
 864         /* Copy g[1..7] and o[0..7] registers */
 865         for (i = 0; i < 7; i++)
 866                 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
 867         for (i = 0; i < 8; i++)
 868                 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
 869
 870         /* Setup sigaltstack */
 871         err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
 872         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
 873         err |= __put_user(current->sas_ss_size, &uc->stack.size);
 874
 875         /* Save the currently window file: */
 876
 877         /* 1. Link sfp->uc->gwins to our windows */
 878         err |= __put_user((u32)(long)gw, &mc->gwin);
 879
 880         /* 2. Number of windows to restore at setcontext (): */
 881         err |= __put_user(get_thread_wsaved(), &gw->count);
 882
 883         /* 3. We just pay attention to the gw->count field on setcontext */
 884         set_thread_wsaved(0); /* So process is allowed to execute. */
 885
 886         /* Setup the signal information.  Solaris expects a bunch of
 887          * information to be passed to the signal handler, we don't provide
 888          * that much currently, should use siginfo.
 889          */
 890         err |= __put_user(signr, &si->siginfo.signo);
 891         err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
 892         if (err)
 893                 goto sigsegv;
 894
 895         regs->u_regs[UREG_FP] = (unsigned long) sfp;
 896         regs->tpc = (unsigned long) sa->sa_handler;
 897         regs->tnpc = (regs->tpc + 4);
 898         if (test_thread_flag(TIF_32BIT)) {
 899                 regs->tpc &= 0xffffffff;
 900                 regs->tnpc &= 0xffffffff;
 901         }
 902
 903         /* Arguments passed to signal handler */
 904         if (regs->u_regs[14]){
 905                 struct reg_window32 __user *rw = (struct reg_window32 __user *)
 906                         (regs->u_regs[14] & 0x00000000ffffffffUL);
 907
 908                 err |= __put_user(signr, &rw->ins[0]);
 909                 err |= __put_user((u64)si, &rw->ins[1]);
 910                 err |= __put_user((u64)uc, &rw->ins[2]);
 911                 err |= __put_user((u64)sfp, &rw->ins[6]);       /* frame pointer */
 912                 if (err)
 913                         goto sigsegv;
 914
 915                 regs->u_regs[UREG_I0] = signr;
 916                 regs->u_regs[UREG_I1] = (u32)(u64) si;
 917                 regs->u_regs[UREG_I2] = (u32)(u64) uc;
 918         }
 919         return;
 920
 921 sigsegv:
 922         do_exit(SIGSEGV);
 923 }
 924
 925 asmlinkage int
 926 svr4_getcontext(svr4_ucontext_t __user *uc, struct pt_regs *regs)
 927 {
 928         svr4_gregset_t  __user *gr;
 929         svr4_mcontext_t __user *mc;
 930         svr4_sigset_t setv;
 931         int i, err;
 932         u32 psr;
 933
 934         synchronize_user_stack();
 935         save_and_clear_fpu();
 936
 937         if (get_thread_wsaved())
 938                 do_exit(SIGSEGV);
 939
 940         err = clear_user(uc, sizeof(*uc));
 941
 942         /* Setup convenience variables */
 943         mc = &uc->mcontext;
 944         gr = &mc->greg;
 945
 946         setv.sigbits[0] = current->blocked.sig[0];
 947         setv.sigbits[1] = (current->blocked.sig[0] >> 32);
 948         if (_NSIG_WORDS >= 2) {
 949                 setv.sigbits[2] = current->blocked.sig[1];
 950                 setv.sigbits[3] = (current->blocked.sig[1] >> 32);
 951                 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
 952         } else
 953                 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned));
 954
 955         /* Store registers */
 956         if (test_thread_flag(TIF_32BIT)) {
 957                 regs->tpc &= 0xffffffff;
 958                 regs->tnpc &= 0xffffffff;
 959         }
 960         err |= __put_user(regs->tpc, &uc->mcontext.greg[SVR4_PC]);
 961         err |= __put_user(regs->tnpc, &uc->mcontext.greg[SVR4_NPC]);
 962
 963         psr = tstate_to_psr(regs->tstate) & ~PSR_EF;
 964         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 965                 psr |= PSR_EF;
 966         err |= __put_user(psr, &uc->mcontext.greg[SVR4_PSR]);
 967
 968         err |= __put_user(regs->y, &uc->mcontext.greg[SVR4_Y]);
 969
 970         /* Copy g[1..7] and o[0..7] registers */
 971         for (i = 0; i < 7; i++)
 972                 err |= __put_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
 973         for (i = 0; i < 8; i++)
 974                 err |= __put_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
 975
 976         /* Setup sigaltstack */
 977         err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
 978         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
 979         err |= __put_user(current->sas_ss_size, &uc->stack.size);
 980
 981         /* The register file is not saved
 982          * we have already stuffed all of it with sync_user_stack
 983          */
 984         return (err ? -EFAULT : 0);
 985 }
 986
 987
 988 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
 989 asmlinkage int svr4_setcontext(svr4_ucontext_t __user *c, struct pt_regs *regs)
 990 {
 991         svr4_gregset_t  __user *gr;
 992         mm_segment_t old_fs;
 993         u32 pc, npc, psr, u_ss_sp;
 994         sigset_t set;
 995         svr4_sigset_t setv;
 996         int i, err;
 997         stack_t st;
 998
 999         /* Fixme: restore windows, or is this already taken care of in
1000          * svr4_setup_frame when sync_user_windows is done?
1001          */
1002         flush_user_windows();
1003
1004         if (get_thread_wsaved())
1005                 goto sigsegv;
1006
1007         if (((unsigned long) c) & 3){
1008                 printk("Unaligned structure passed\n");
1009                 goto sigsegv;
1010         }
1011
1012         if (!__access_ok((unsigned long)c, sizeof(*c))) {
1013                 /* Miguel, add nice debugging msg _here_. ;-) */
1014                 goto sigsegv;
1015         }
1016
1017         /* Check for valid PC and nPC */
1018         gr = &c->mcontext.greg;
1019         err = __get_user(pc, &((*gr)[SVR4_PC]));
1020         err |= __get_user(npc, &((*gr)[SVR4_NPC]));
1021         if ((pc | npc) & 3)
1022                 goto sigsegv;
1023
1024         /* Retrieve information from passed ucontext */
1025         /* note that nPC is ored a 1, this is used to inform entry.S */
1026         /* that we don't want it to mess with our PC and nPC */
1027
1028         err |= copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1029         set.sig[0] = setv.sigbits[0] | (((long)setv.sigbits[1]) << 32);
1030         if (_NSIG_WORDS >= 2)
1031                 set.sig[1] = setv.sigbits[2] | (((long)setv.sigbits[3]) << 32);
1032
1033         err |= __get_user(u_ss_sp, &c->stack.sp);
1034         st.ss_sp = (void *) (long) u_ss_sp;
1035         err |= __get_user(st.ss_flags, &c->stack.flags);
1036         err |= __get_user(st.ss_size, &c->stack.size);
1037         if (err)
1038                 goto sigsegv;
1039
1040         /* It is more difficult to avoid calling this function than to
1041            call it and ignore errors.  */
1042         old_fs = get_fs();
1043         set_fs(KERNEL_DS);
1044         do_sigaltstack((stack_t __user *) &st, NULL, regs->u_regs[UREG_I6]);
1045         set_fs(old_fs);
1046
1047         sigdelsetmask(&set, ~_BLOCKABLE);
1048         spin_lock_irq(&current->sighand->siglock);
1049         current->blocked = set;
1050         recalc_sigpending();
1051         spin_unlock_irq(&current->sighand->siglock);
1052         regs->tpc = pc;
1053         regs->tnpc = npc | 1;
1054         if (test_thread_flag(TIF_32BIT)) {
1055                 regs->tpc &= 0xffffffff;
1056                 regs->tnpc &= 0xffffffff;
1057         }
1058         err |= __get_user(regs->y, &((*gr)[SVR4_Y]));
1059         err |= __get_user(psr, &((*gr)[SVR4_PSR]));
1060         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
1061         regs->tstate |= psr_to_tstate_icc(psr);
1062
1063         /* Restore g[1..7] and o[0..7] registers */
1064         for (i = 0; i < 7; i++)
1065                 err |= __get_user(regs->u_regs[UREG_G1+i], (&(*gr)[SVR4_G1])+i);
1066         for (i = 0; i < 8; i++)
1067                 err |= __get_user(regs->u_regs[UREG_I0+i], (&(*gr)[SVR4_O0])+i);
1068         if (err)
1069                 goto sigsegv;
1070
1071         return -EINTR;
1072 sigsegv:
1073         do_exit(SIGSEGV);
1074 }
1075
1076 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
1077                              unsigned long signr, sigset_t *oldset,
1078                              siginfo_t *info)
1079 {
1080         struct rt_signal_frame32 __user *sf;
1081         int sigframe_size;
1082         u32 psr;
1083         int i, err;
1084         compat_sigset_t seta;
1085
1086         /* 1. Make sure everything is clean */
1087         synchronize_user_stack();
1088         save_and_clear_fpu();
1089
1090         sigframe_size = RT_ALIGNEDSZ;
1091         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
1092                 sigframe_size -= sizeof(__siginfo_fpu_t);
1093
1094         sf = (struct rt_signal_frame32 __user *)
1095                 get_sigframe(&ka->sa, regs, sigframe_size);
1096
1097         if (invalid_frame_pointer(sf, sigframe_size))
1098                 goto sigill;
1099
1100         if (get_thread_wsaved() != 0)
1101                 goto sigill;
1102
1103         /* 2. Save the current process state */
1104         if (test_thread_flag(TIF_32BIT)) {
1105                 regs->tpc &= 0xffffffff;
1106                 regs->tnpc &= 0xffffffff;
1107         }
1108         err  = put_user(regs->tpc, &sf->regs.pc);
1109         err |= __put_user(regs->tnpc, &sf->regs.npc);
1110         err |= __put_user(regs->y, &sf->regs.y);
1111         psr = tstate_to_psr(regs->tstate);
1112         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
1113                 psr |= PSR_EF;
1114         err |= __put_user(psr, &sf->regs.psr);
1115         for (i = 0; i < 16; i++)
1116                 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
1117         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
1118         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
1119         for (i = 1; i < 16; i++)
1120                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
1121                                   &sf->v8plus.g_upper[i]);
1122
1123         if (psr & PSR_EF) {
1124                 err |= save_fpu_state32(regs, &sf->fpu_state);
1125                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
1126         } else {
1127                 err |= __put_user(0, &sf->fpu_save);
1128         }
1129
1130         /* Update the siginfo structure.  */
1131         err |= copy_siginfo_to_user32(&sf->info, info);
1132
1133         /* Setup sigaltstack */
1134         err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
1135         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
1136         err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
1137
1138         switch (_NSIG_WORDS) {
1139         case 4: seta.sig[7] = (oldset->sig[3] >> 32);
1140                 seta.sig[6] = oldset->sig[3];
1141         case 3: seta.sig[5] = (oldset->sig[2] >> 32);
1142                 seta.sig[4] = oldset->sig[2];
1143         case 2: seta.sig[3] = (oldset->sig[1] >> 32);
1144                 seta.sig[2] = oldset->sig[1];
1145         case 1: seta.sig[1] = (oldset->sig[0] >> 32);
1146                 seta.sig[0] = oldset->sig[0];
1147         }
1148         err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
1149
1150         err |= copy_in_user((u32 __user *)sf,
1151                             (u32 __user *)(regs->u_regs[UREG_FP]),
1152                             sizeof(struct reg_window32));
1153         if (err)
1154                 goto sigsegv;
1155
1156         /* 3. signal handler back-trampoline and parameters */
1157         regs->u_regs[UREG_FP] = (unsigned long) sf;
1158         regs->u_regs[UREG_I0] = signr;
1159         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
1160
1161         /* 4. signal handler */
1162         regs->tpc = (unsigned long) ka->sa.sa_handler;
1163         regs->tnpc = (regs->tpc + 4);
1164         if (test_thread_flag(TIF_32BIT)) {
1165                 regs->tpc &= 0xffffffff;
1166                 regs->tnpc &= 0xffffffff;
1167         }
1168
1169         /* 5. return to kernel instructions */
1170         if (ka->ka_restorer)
1171                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
1172         else {
1173                 /* Flush instruction space. */
1174                 unsigned long address = ((unsigned long)&(sf->insns[0]));
1175                 pgd_t *pgdp = pgd_offset(current->mm, address);
1176                 pmd_t *pmdp = pmd_offset(pgdp, address);
1177                 pte_t *ptep;
1178
1179                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
1180
1181                 /* mov __NR_rt_sigreturn, %g1 */
1182                 err |= __put_user(0x82102065, &sf->insns[0]);
1183
1184                 /* t 0x10 */
1185                 err |= __put_user(0x91d02010, &sf->insns[1]);
1186                 if (err)
1187                         goto sigsegv;
1188
1189                 preempt_disable();
1190                 ptep = pte_offset_map(pmdp, address);
1191                 if (pte_present(*ptep)) {
1192                         unsigned long page = (unsigned long)
1193                                 page_address(pte_page(*ptep));
1194
1195                         __asm__ __volatile__(
1196                         "       membar  #StoreStore\n"
1197                         "       flush   %0 + %1"
1198                         : : "r" (page), "r" (address & (PAGE_SIZE - 1))
1199                         : "memory");
1200                 }
1201                 pte_unmap(ptep);
1202                 preempt_enable();
1203         }
1204         return;
1205
1206 sigill:
1207         do_exit(SIGILL);
1208 sigsegv:
1209         do_exit(SIGSEGV);
1210 }
1211
1212 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
1213                                    siginfo_t *info,
1214                                    sigset_t *oldset, struct pt_regs *regs,
1215                                    int svr4_signal)
1216 {
1217         if (svr4_signal)
1218                 setup_svr4_frame32(&ka->sa, regs->tpc, regs->tnpc,
1219                                    regs, signr, oldset);
1220         else {
1221                 if (ka->sa.sa_flags & SA_SIGINFO)
1222                         setup_rt_frame32(ka, regs, signr, oldset, info);
1223                 else if (test_thread_flag(TIF_NEWSIGNALS))
1224                         new_setup_frame32(ka, regs, signr, oldset);
1225                 else
1226                         setup_frame32(&ka->sa, regs, signr, oldset, info);
1227         }
1228         if (ka->sa.sa_flags & SA_ONESHOT)
1229                 ka->sa.sa_handler = SIG_DFL;
1230         if (!(ka->sa.sa_flags & SA_NOMASK)) {
1231                 spin_lock_irq(&current->sighand->siglock);
1232                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
1233                 sigaddset(&current->blocked,signr);
1234                 recalc_sigpending();
1235                 spin_unlock_irq(&current->sighand->siglock);
1236         }
1237 }
1238
1239 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
1240                                      struct sigaction *sa)
1241 {
1242         switch (regs->u_regs[UREG_I0]) {
1243         case ERESTART_RESTARTBLOCK:
1244         case ERESTARTNOHAND:
1245         no_system_call_restart:
1246                 regs->u_regs[UREG_I0] = EINTR;
1247                 regs->tstate |= TSTATE_ICARRY;
1248                 break;
1249         case ERESTARTSYS:
1250                 if (!(sa->sa_flags & SA_RESTART))
1251                         goto no_system_call_restart;
1252                 /* fallthrough */
1253         case ERESTARTNOINTR:
1254                 regs->u_regs[UREG_I0] = orig_i0;
1255                 regs->tpc -= 4;
1256                 regs->tnpc -= 4;
1257         }
1258 }
1259
1260 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1261  * want to handle. Thus you cannot kill init even with a SIGKILL even by
1262  * mistake.
1263  */
1264 int do_signal32(sigset_t *oldset, struct pt_regs * regs,
1265                 unsigned long orig_i0, int restart_syscall)
1266 {
1267         siginfo_t info;
1268         struct signal_deliver_cookie cookie;
1269         int signr;
1270         int svr4_signal = current->personality == PER_SVR4;
1271
1272         cookie.restart_syscall = restart_syscall;
1273         cookie.orig_i0 = orig_i0;
1274
1275         signr = get_signal_to_deliver(&info, regs, &cookie);
1276         if (signr > 0) {
1277                 struct k_sigaction *ka;
1278
1279                 ka = &current->sighand->action[signr-1];
1280
1281                 if (cookie.restart_syscall)
1282                         syscall_restart32(orig_i0, regs, &ka->sa);
1283                 handle_signal32(signr, ka, &info, oldset, regs, svr4_signal);
1284                 return 1;
1285         }
1286         if (cookie.restart_syscall &&
1287             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1288              regs->u_regs[UREG_I0] == ERESTARTSYS ||
1289              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1290                 /* replay the system call when we are done */
1291                 regs->u_regs[UREG_I0] = cookie.orig_i0;
1292                 regs->tpc -= 4;
1293                 regs->tnpc -= 4;
1294         }
1295         if (cookie.restart_syscall &&
1296             regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
1297                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
1298                 regs->tpc -= 4;
1299                 regs->tnpc -= 4;
1300         }
1301         return 0;
1302 }
1303
1304 struct sigstack32 {
1305         u32 the_stack;
1306         int cur_status;
1307 };
1308
1309 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
1310 {
1311         struct sigstack32 __user *ssptr =
1312                 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
1313         struct sigstack32 __user *ossptr =
1314                 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
1315         int ret = -EFAULT;
1316
1317         /* First see if old state is wanted. */
1318         if (ossptr) {
1319                 if (put_user(current->sas_ss_sp + current->sas_ss_size,
1320                              &ossptr->the_stack) ||
1321                     __put_user(on_sig_stack(sp), &ossptr->cur_status))
1322                         goto out;
1323         }
1324
1325         /* Now see if we want to update the new state. */
1326         if (ssptr) {
1327                 u32 ss_sp;
1328
1329                 if (get_user(ss_sp, &ssptr->the_stack))
1330                         goto out;
1331
1332                 /* If the current stack was set with sigaltstack, don't
1333                  * swap stacks while we are on it.
1334                  */
1335                 ret = -EPERM;
1336                 if (current->sas_ss_sp && on_sig_stack(sp))
1337                         goto out;
1338
1339                 /* Since we don't know the extent of the stack, and we don't
1340                  * track onstack-ness, but rather calculate it, we must
1341                  * presume a size.  Ho hum this interface is lossy.
1342                  */
1343                 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1344                 current->sas_ss_size = SIGSTKSZ;
1345         }
1346
1347         ret = 0;
1348 out:
1349         return ret;
1350 }
1351
1352 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
1353 {
1354         stack_t uss, uoss;
1355         u32 u_ss_sp = 0;
1356         int ret;
1357         mm_segment_t old_fs;
1358
1359         if (ussa && (get_user(u_ss_sp, &((stack_t32 __user *)(long)ussa)->ss_sp) ||
1360                     __get_user(uss.ss_flags, &((stack_t32 __user *)(long)ussa)->ss_flags) ||
1361                     __get_user(uss.ss_size, &((stack_t32 __user *)(long)ussa)->ss_size)))
1362                 return -EFAULT;
1363         uss.ss_sp = (void *) (long) u_ss_sp;
1364         old_fs = get_fs();
1365         set_fs(KERNEL_DS);
1366         ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
1367                              uossa ? (stack_t __user *) &uoss : NULL, sp);
1368         set_fs(old_fs);
1369         if (!ret && uossa && (put_user((long)uoss.ss_sp, &((stack_t32 __user *)(long)uossa)->ss_sp) ||
1370                     __put_user(uoss.ss_flags, &((stack_t32 __user *)(long)uossa)->ss_flags) ||
1371                     __put_user(uoss.ss_size, &((stack_t32 __user *)(long)uossa)->ss_size)))
1372                 return -EFAULT;
1373         return ret;
1374 }