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