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