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