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