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