arch/sparc/kernel/signal32.c

   1 /*  arch/sparc64/kernel/signal32.c
   2  *
   3  *  Copyright (C) 1991, 1992  Linus Torvalds
   4  *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   5  *  Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
   6  *  Copyright (C) 1997 Eddie C. Dost   (ecd@skynet.be)
   7  *  Copyright (C) 1997,1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/kernel.h>
  12 #include <linux/signal.h>
  13 #include <linux/errno.h>
  14 #include <linux/wait.h>
  15 #include <linux/ptrace.h>
  16 #include <linux/unistd.h>
  17 #include <linux/mm.h>
  18 #include <linux/tty.h>
  19 #include <linux/binfmts.h>
  20 #include <linux/compat.h>
  21 #include <linux/bitops.h>
  22 #include <linux/tracehook.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 /* This magic should be in g_upper[0] for all upper parts
  35  * to be valid.
  36  */
  37 #define SIGINFO_EXTRA_V8PLUS_MAGIC      0x130e269
  38 typedef struct {
  39         unsigned int g_upper[8];
  40         unsigned int o_upper[8];
  41         unsigned int asi;
  42 } siginfo_extra_v8plus_t;
  43
  44 struct signal_frame32 {
  45         struct sparc_stackf32   ss;
  46         __siginfo32_t           info;
  47         /* __siginfo_fpu32_t * */ u32 fpu_save;
  48         unsigned int            insns[2];
  49         unsigned int            extramask[_COMPAT_NSIG_WORDS - 1];
  50         unsigned int            extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  51         /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  52         siginfo_extra_v8plus_t  v8plus;
  53         __siginfo_fpu_t         fpu_state;
  54 };
  55
  56 typedef struct compat_siginfo{
  57         int si_signo;
  58         int si_errno;
  59         int si_code;
  60
  61         union {
  62                 int _pad[SI_PAD_SIZE32];
  63
  64                 /* kill() */
  65                 struct {
  66                         compat_pid_t _pid;              /* sender's pid */
  67                         unsigned int _uid;              /* sender's uid */
  68                 } _kill;
  69
  70                 /* POSIX.1b timers */
  71                 struct {
  72                         compat_timer_t _tid;                    /* timer id */
  73                         int _overrun;                   /* overrun count */
  74                         compat_sigval_t _sigval;                /* same as below */
  75                         int _sys_private;               /* not to be passed to user */
  76                 } _timer;
  77
  78                 /* POSIX.1b signals */
  79                 struct {
  80                         compat_pid_t _pid;              /* sender's pid */
  81                         unsigned int _uid;              /* sender's uid */
  82                         compat_sigval_t _sigval;
  83                 } _rt;
  84
  85                 /* SIGCHLD */
  86                 struct {
  87                         compat_pid_t _pid;              /* which child */
  88                         unsigned int _uid;              /* sender's uid */
  89                         int _status;                    /* exit code */
  90                         compat_clock_t _utime;
  91                         compat_clock_t _stime;
  92                 } _sigchld;
  93
  94                 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS, SIGEMT */
  95                 struct {
  96                         u32 _addr; /* faulting insn/memory ref. */
  97                         int _trapno;
  98                 } _sigfault;
  99
 100                 /* SIGPOLL */
 101                 struct {
 102                         int _band;      /* POLL_IN, POLL_OUT, POLL_MSG */
 103                         int _fd;
 104                 } _sigpoll;
 105         } _sifields;
 106 }compat_siginfo_t;
 107
 108 struct rt_signal_frame32 {
 109         struct sparc_stackf32   ss;
 110         compat_siginfo_t        info;
 111         struct pt_regs32        regs;
 112         compat_sigset_t         mask;
 113         /* __siginfo_fpu32_t * */ u32 fpu_save;
 114         unsigned int            insns[2];
 115         stack_t32               stack;
 116         unsigned int            extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
 117         /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
 118         siginfo_extra_v8plus_t  v8plus;
 119         __siginfo_fpu_t         fpu_state;
 120 };
 121
 122 /* Align macros */
 123 #define SF_ALIGNEDSZ  (((sizeof(struct signal_frame32) + 15) & (~15)))
 124 #define RT_ALIGNEDSZ  (((sizeof(struct rt_signal_frame32) + 15) & (~15)))
 125
 126 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
 127 {
 128         int err;
 129
 130         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 131                 return -EFAULT;
 132
 133         /* If you change siginfo_t structure, please be sure
 134            this code is fixed accordingly.
 135            It should never copy any pad contained in the structure
 136            to avoid security leaks, but must copy the generic
 137            3 ints plus the relevant union member.
 138            This routine must convert siginfo from 64bit to 32bit as well
 139            at the same time.  */
 140         err = __put_user(from->si_signo, &to->si_signo);
 141         err |= __put_user(from->si_errno, &to->si_errno);
 142         err |= __put_user((short)from->si_code, &to->si_code);
 143         if (from->si_code < 0)
 144                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 145         else {
 146                 switch (from->si_code >> 16) {
 147                 case __SI_TIMER >> 16:
 148                         err |= __put_user(from->si_tid, &to->si_tid);
 149                         err |= __put_user(from->si_overrun, &to->si_overrun);
 150                         err |= __put_user(from->si_int, &to->si_int);
 151                         break;
 152                 case __SI_CHLD >> 16:
 153                         err |= __put_user(from->si_utime, &to->si_utime);
 154                         err |= __put_user(from->si_stime, &to->si_stime);
 155                         err |= __put_user(from->si_status, &to->si_status);
 156                 default:
 157                         err |= __put_user(from->si_pid, &to->si_pid);
 158                         err |= __put_user(from->si_uid, &to->si_uid);
 159                         break;
 160                 case __SI_FAULT >> 16:
 161                         err |= __put_user(from->si_trapno, &to->si_trapno);
 162                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 163                         break;
 164                 case __SI_POLL >> 16:
 165                         err |= __put_user(from->si_band, &to->si_band);
 166                         err |= __put_user(from->si_fd, &to->si_fd);
 167                         break;
 168                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 169                 case __SI_MESGQ >> 16:
 170                         err |= __put_user(from->si_pid, &to->si_pid);
 171                         err |= __put_user(from->si_uid, &to->si_uid);
 172                         err |= __put_user(from->si_int, &to->si_int);
 173                         break;
 174                 }
 175         }
 176         return err;
 177 }
 178
 179 /* CAUTION: This is just a very minimalist implementation for the
 180  *          sake of compat_sys_rt_sigqueueinfo()
 181  */
 182 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 183 {
 184         if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
 185                 return -EFAULT;
 186
 187         if (copy_from_user(to, from, 3*sizeof(int)) ||
 188             copy_from_user(to->_sifields._pad, from->_sifields._pad,
 189                            SI_PAD_SIZE))
 190                 return -EFAULT;
 191
 192         return 0;
 193 }
 194
 195 static int restore_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 196 {
 197         unsigned long *fpregs = current_thread_info()->fpregs;
 198         unsigned long fprs;
 199         int err;
 200
 201         err = __get_user(fprs, &fpu->si_fprs);
 202         fprs_write(0);
 203         regs->tstate &= ~TSTATE_PEF;
 204         if (fprs & FPRS_DL)
 205                 err |= copy_from_user(fpregs, &fpu->si_float_regs[0], (sizeof(unsigned int) * 32));
 206         if (fprs & FPRS_DU)
 207                 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32], (sizeof(unsigned int) * 32));
 208         err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
 209         err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
 210         current_thread_info()->fpsaved[0] |= fprs;
 211         return err;
 212 }
 213
 214 void do_sigreturn32(struct pt_regs *regs)
 215 {
 216         struct signal_frame32 __user *sf;
 217         unsigned int psr;
 218         unsigned pc, npc, fpu_save;
 219         sigset_t set;
 220         unsigned seta[_COMPAT_NSIG_WORDS];
 221         int err, i;
 222
 223         /* Always make any pending restarted system calls return -EINTR */
 224         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 225
 226         synchronize_user_stack();
 227
 228         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 229         sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
 230
 231         /* 1. Make sure we are not getting garbage from the user */
 232         if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
 233             (((unsigned long) sf) & 3))
 234                 goto segv;
 235
 236         get_user(pc, &sf->info.si_regs.pc);
 237         __get_user(npc, &sf->info.si_regs.npc);
 238
 239         if ((pc | npc) & 3)
 240                 goto segv;
 241
 242         if (test_thread_flag(TIF_32BIT)) {
 243                 pc &= 0xffffffff;
 244                 npc &= 0xffffffff;
 245         }
 246         regs->tpc = pc;
 247         regs->tnpc = npc;
 248
 249         /* 2. Restore the state */
 250         err = __get_user(regs->y, &sf->info.si_regs.y);
 251         err |= __get_user(psr, &sf->info.si_regs.psr);
 252
 253         for (i = UREG_G1; i <= UREG_I7; i++)
 254                 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 255         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 256                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
 257                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 258                         unsigned long asi;
 259
 260                         for (i = UREG_G1; i <= UREG_I7; i++)
 261                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 262                         err |= __get_user(asi, &sf->v8plus.asi);
 263                         regs->tstate &= ~TSTATE_ASI;
 264                         regs->tstate |= ((asi & 0xffUL) << 24UL);
 265                 }
 266         }
 267
 268         /* User can only change condition codes in %tstate. */
 269         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 270         regs->tstate |= psr_to_tstate_icc(psr);
 271
 272         /* Prevent syscall restart.  */
 273         pt_regs_clear_syscall(regs);
 274
 275         err |= __get_user(fpu_save, &sf->fpu_save);
 276         if (fpu_save)
 277                 err |= restore_fpu_state32(regs, &sf->fpu_state);
 278         err |= __get_user(seta[0], &sf->info.si_mask);
 279         err |= copy_from_user(seta+1, &sf->extramask,
 280                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 281         if (err)
 282                 goto segv;
 283         switch (_NSIG_WORDS) {
 284                 case 4: set.sig[3] = seta[6] + (((long)seta[7]) << 32);
 285                 case 3: set.sig[2] = seta[4] + (((long)seta[5]) << 32);
 286                 case 2: set.sig[1] = seta[2] + (((long)seta[3]) << 32);
 287                 case 1: set.sig[0] = seta[0] + (((long)seta[1]) << 32);
 288         }
 289         sigdelsetmask(&set, ~_BLOCKABLE);
 290         spin_lock_irq(&current->sighand->siglock);
 291         current->blocked = set;
 292         recalc_sigpending();
 293         spin_unlock_irq(&current->sighand->siglock);
 294         return;
 295
 296 segv:
 297         force_sig(SIGSEGV, current);
 298 }
 299
 300 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
 301 {
 302         struct rt_signal_frame32 __user *sf;
 303         unsigned int psr, pc, npc, fpu_save, u_ss_sp;
 304         mm_segment_t old_fs;
 305         sigset_t set;
 306         compat_sigset_t seta;
 307         stack_t st;
 308         int err, i;
 309
 310         /* Always make any pending restarted system calls return -EINTR */
 311         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 312
 313         synchronize_user_stack();
 314         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 315         sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
 316
 317         /* 1. Make sure we are not getting garbage from the user */
 318         if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
 319             (((unsigned long) sf) & 3))
 320                 goto segv;
 321
 322         get_user(pc, &sf->regs.pc);
 323         __get_user(npc, &sf->regs.npc);
 324
 325         if ((pc | npc) & 3)
 326                 goto segv;
 327
 328         if (test_thread_flag(TIF_32BIT)) {
 329                 pc &= 0xffffffff;
 330                 npc &= 0xffffffff;
 331         }
 332         regs->tpc = pc;
 333         regs->tnpc = npc;
 334
 335         /* 2. Restore the state */
 336         err = __get_user(regs->y, &sf->regs.y);
 337         err |= __get_user(psr, &sf->regs.psr);
 338
 339         for (i = UREG_G1; i <= UREG_I7; i++)
 340                 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 341         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 342                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
 343                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 344                         unsigned long asi;
 345
 346                         for (i = UREG_G1; i <= UREG_I7; i++)
 347                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 348                         err |= __get_user(asi, &sf->v8plus.asi);
 349                         regs->tstate &= ~TSTATE_ASI;
 350                         regs->tstate |= ((asi & 0xffUL) << 24UL);
 351                 }
 352         }
 353
 354         /* User can only change condition codes in %tstate. */
 355         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 356         regs->tstate |= psr_to_tstate_icc(psr);
 357
 358         /* Prevent syscall restart.  */
 359         pt_regs_clear_syscall(regs);
 360
 361         err |= __get_user(fpu_save, &sf->fpu_save);
 362         if (fpu_save)
 363                 err |= restore_fpu_state32(regs, &sf->fpu_state);
 364         err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
 365         err |= __get_user(u_ss_sp, &sf->stack.ss_sp);
 366         st.ss_sp = compat_ptr(u_ss_sp);
 367         err |= __get_user(st.ss_flags, &sf->stack.ss_flags);
 368         err |= __get_user(st.ss_size, &sf->stack.ss_size);
 369         if (err)
 370                 goto segv;
 371
 372         /* It is more difficult to avoid calling this function than to
 373            call it and ignore errors.  */
 374         old_fs = get_fs();
 375         set_fs(KERNEL_DS);
 376         do_sigaltstack((stack_t __user *) &st, NULL, (unsigned long)sf);
 377         set_fs(old_fs);
 378
 379         switch (_NSIG_WORDS) {
 380                 case 4: set.sig[3] = seta.sig[6] + (((long)seta.sig[7]) << 32);
 381                 case 3: set.sig[2] = seta.sig[4] + (((long)seta.sig[5]) << 32);
 382                 case 2: set.sig[1] = seta.sig[2] + (((long)seta.sig[3]) << 32);
 383                 case 1: set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
 384         }
 385         sigdelsetmask(&set, ~_BLOCKABLE);
 386         spin_lock_irq(&current->sighand->siglock);
 387         current->blocked = set;
 388         recalc_sigpending();
 389         spin_unlock_irq(&current->sighand->siglock);
 390         return;
 391 segv:
 392         force_sig(SIGSEGV, current);
 393 }
 394
 395 /* Checks if the fp is valid */
 396 static int invalid_frame_pointer(void __user *fp, int fplen)
 397 {
 398         if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
 399                 return 1;
 400         return 0;
 401 }
 402
 403 static void __user *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
 404 {
 405         unsigned long sp;
 406
 407         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 408         sp = regs->u_regs[UREG_FP];
 409
 410         /*
 411          * If we are on the alternate signal stack and would overflow it, don't.
 412          * Return an always-bogus address instead so we will die with SIGSEGV.
 413          */
 414         if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
 415                 return (void __user *) -1L;
 416
 417         /* This is the X/Open sanctioned signal stack switching.  */
 418         if (sa->sa_flags & SA_ONSTACK) {
 419                 if (sas_ss_flags(sp) == 0)
 420                         sp = current->sas_ss_sp + current->sas_ss_size;
 421         }
 422
 423         sp -= framesize;
 424
 425         /* Always align the stack frame.  This handles two cases.  First,
 426          * sigaltstack need not be mindful of platform specific stack
 427          * alignment.  Second, if we took this signal because the stack
 428          * is not aligned properly, we'd like to take the signal cleanly
 429          * and report that.
 430          */
 431         sp &= ~15UL;
 432
 433         return (void __user *) sp;
 434 }
 435
 436 static int save_fpu_state32(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
 437 {
 438         unsigned long *fpregs = current_thread_info()->fpregs;
 439         unsigned long fprs;
 440         int err = 0;
 441
 442         fprs = current_thread_info()->fpsaved[0];
 443         if (fprs & FPRS_DL)
 444                 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
 445                                     (sizeof(unsigned int) * 32));
 446         if (fprs & FPRS_DU)
 447                 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
 448                                     (sizeof(unsigned int) * 32));
 449         err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
 450         err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
 451         err |= __put_user(fprs, &fpu->si_fprs);
 452
 453         return err;
 454 }
 455
 456 static void setup_frame32(struct k_sigaction *ka, struct pt_regs *regs,
 457                           int signo, sigset_t *oldset)
 458 {
 459         struct signal_frame32 __user *sf;
 460         int sigframe_size;
 461         u32 psr;
 462         int i, err;
 463         unsigned int seta[_COMPAT_NSIG_WORDS];
 464
 465         /* 1. Make sure everything is clean */
 466         synchronize_user_stack();
 467         save_and_clear_fpu();
 468
 469         sigframe_size = SF_ALIGNEDSZ;
 470         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
 471                 sigframe_size -= sizeof(__siginfo_fpu_t);
 472
 473         sf = (struct signal_frame32 __user *)
 474                 get_sigframe(&ka->sa, regs, sigframe_size);
 475
 476         if (invalid_frame_pointer(sf, sigframe_size))
 477                 goto sigill;
 478
 479         if (get_thread_wsaved() != 0)
 480                 goto sigill;
 481
 482         /* 2. Save the current process state */
 483         if (test_thread_flag(TIF_32BIT)) {
 484                 regs->tpc &= 0xffffffff;
 485                 regs->tnpc &= 0xffffffff;
 486         }
 487         err  = put_user(regs->tpc, &sf->info.si_regs.pc);
 488         err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
 489         err |= __put_user(regs->y, &sf->info.si_regs.y);
 490         psr = tstate_to_psr(regs->tstate);
 491         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 492                 psr |= PSR_EF;
 493         err |= __put_user(psr, &sf->info.si_regs.psr);
 494         for (i = 0; i < 16; i++)
 495                 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 496         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 497         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 498         for (i = 1; i < 16; i++)
 499                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
 500                                   &sf->v8plus.g_upper[i]);
 501         err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
 502                           &sf->v8plus.asi);
 503
 504         if (psr & PSR_EF) {
 505                 err |= save_fpu_state32(regs, &sf->fpu_state);
 506                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
 507         } else {
 508                 err |= __put_user(0, &sf->fpu_save);
 509         }
 510
 511         switch (_NSIG_WORDS) {
 512         case 4: seta[7] = (oldset->sig[3] >> 32);
 513                 seta[6] = oldset->sig[3];
 514         case 3: seta[5] = (oldset->sig[2] >> 32);
 515                 seta[4] = oldset->sig[2];
 516         case 2: seta[3] = (oldset->sig[1] >> 32);
 517                 seta[2] = oldset->sig[1];
 518         case 1: seta[1] = (oldset->sig[0] >> 32);
 519                 seta[0] = oldset->sig[0];
 520         }
 521         err |= __put_user(seta[0], &sf->info.si_mask);
 522         err |= __copy_to_user(sf->extramask, seta + 1,
 523                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 524
 525         err |= copy_in_user((u32 __user *)sf,
 526                             (u32 __user *)(regs->u_regs[UREG_FP]),
 527                             sizeof(struct reg_window32));
 528
 529         if (err)
 530                 goto sigsegv;
 531
 532         /* 3. signal handler back-trampoline and parameters */
 533         regs->u_regs[UREG_FP] = (unsigned long) sf;
 534         regs->u_regs[UREG_I0] = signo;
 535         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 536         regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
 537
 538         /* 4. signal handler */
 539         regs->tpc = (unsigned long) ka->sa.sa_handler;
 540         regs->tnpc = (regs->tpc + 4);
 541         if (test_thread_flag(TIF_32BIT)) {
 542                 regs->tpc &= 0xffffffff;
 543                 regs->tnpc &= 0xffffffff;
 544         }
 545
 546         /* 5. return to kernel instructions */
 547         if (ka->ka_restorer) {
 548                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
 549         } else {
 550                 /* Flush instruction space. */
 551                 unsigned long address = ((unsigned long)&(sf->insns[0]));
 552                 pgd_t *pgdp = pgd_offset(current->mm, address);
 553                 pud_t *pudp = pud_offset(pgdp, address);
 554                 pmd_t *pmdp = pmd_offset(pudp, address);
 555                 pte_t *ptep;
 556                 pte_t pte;
 557
 558                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 559
 560                 err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
 561                 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
 562                 if (err)
 563                         goto sigsegv;
 564
 565                 preempt_disable();
 566                 ptep = pte_offset_map(pmdp, address);
 567                 pte = *ptep;
 568                 if (pte_present(pte)) {
 569                         unsigned long page = (unsigned long)
 570                                 page_address(pte_page(pte));
 571
 572                         wmb();
 573                         __asm__ __volatile__("flush     %0 + %1"
 574                                              : /* no outputs */
 575                                              : "r" (page),
 576                                                "r" (address & (PAGE_SIZE - 1))
 577                                              : "memory");
 578                 }
 579                 pte_unmap(ptep);
 580                 preempt_enable();
 581         }
 582         return;
 583
 584 sigill:
 585         do_exit(SIGILL);
 586 sigsegv:
 587         force_sigsegv(signo, current);
 588 }
 589
 590 static void setup_rt_frame32(struct k_sigaction *ka, struct pt_regs *regs,
 591                              unsigned long signr, sigset_t *oldset,
 592                              siginfo_t *info)
 593 {
 594         struct rt_signal_frame32 __user *sf;
 595         int sigframe_size;
 596         u32 psr;
 597         int i, err;
 598         compat_sigset_t seta;
 599
 600         /* 1. Make sure everything is clean */
 601         synchronize_user_stack();
 602         save_and_clear_fpu();
 603
 604         sigframe_size = RT_ALIGNEDSZ;
 605         if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
 606                 sigframe_size -= sizeof(__siginfo_fpu_t);
 607
 608         sf = (struct rt_signal_frame32 __user *)
 609                 get_sigframe(&ka->sa, regs, sigframe_size);
 610
 611         if (invalid_frame_pointer(sf, sigframe_size))
 612                 goto sigill;
 613
 614         if (get_thread_wsaved() != 0)
 615                 goto sigill;
 616
 617         /* 2. Save the current process state */
 618         if (test_thread_flag(TIF_32BIT)) {
 619                 regs->tpc &= 0xffffffff;
 620                 regs->tnpc &= 0xffffffff;
 621         }
 622         err  = put_user(regs->tpc, &sf->regs.pc);
 623         err |= __put_user(regs->tnpc, &sf->regs.npc);
 624         err |= __put_user(regs->y, &sf->regs.y);
 625         psr = tstate_to_psr(regs->tstate);
 626         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 627                 psr |= PSR_EF;
 628         err |= __put_user(psr, &sf->regs.psr);
 629         for (i = 0; i < 16; i++)
 630                 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 631         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 632         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 633         for (i = 1; i < 16; i++)
 634                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
 635                                   &sf->v8plus.g_upper[i]);
 636         err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
 637                           &sf->v8plus.asi);
 638
 639         if (psr & PSR_EF) {
 640                 err |= save_fpu_state32(regs, &sf->fpu_state);
 641                 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
 642         } else {
 643                 err |= __put_user(0, &sf->fpu_save);
 644         }
 645
 646         /* Update the siginfo structure.  */
 647         err |= copy_siginfo_to_user32(&sf->info, info);
 648
 649         /* Setup sigaltstack */
 650         err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
 651         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
 652         err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
 653
 654         switch (_NSIG_WORDS) {
 655         case 4: seta.sig[7] = (oldset->sig[3] >> 32);
 656                 seta.sig[6] = oldset->sig[3];
 657         case 3: seta.sig[5] = (oldset->sig[2] >> 32);
 658                 seta.sig[4] = oldset->sig[2];
 659         case 2: seta.sig[3] = (oldset->sig[1] >> 32);
 660                 seta.sig[2] = oldset->sig[1];
 661         case 1: seta.sig[1] = (oldset->sig[0] >> 32);
 662                 seta.sig[0] = oldset->sig[0];
 663         }
 664         err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
 665
 666         err |= copy_in_user((u32 __user *)sf,
 667                             (u32 __user *)(regs->u_regs[UREG_FP]),
 668                             sizeof(struct reg_window32));
 669         if (err)
 670                 goto sigsegv;
 671
 672         /* 3. signal handler back-trampoline and parameters */
 673         regs->u_regs[UREG_FP] = (unsigned long) sf;
 674         regs->u_regs[UREG_I0] = signr;
 675         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 676         regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
 677
 678         /* 4. signal handler */
 679         regs->tpc = (unsigned long) ka->sa.sa_handler;
 680         regs->tnpc = (regs->tpc + 4);
 681         if (test_thread_flag(TIF_32BIT)) {
 682                 regs->tpc &= 0xffffffff;
 683                 regs->tnpc &= 0xffffffff;
 684         }
 685
 686         /* 5. return to kernel instructions */
 687         if (ka->ka_restorer)
 688                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
 689         else {
 690                 /* Flush instruction space. */
 691                 unsigned long address = ((unsigned long)&(sf->insns[0]));
 692                 pgd_t *pgdp = pgd_offset(current->mm, address);
 693                 pud_t *pudp = pud_offset(pgdp, address);
 694                 pmd_t *pmdp = pmd_offset(pudp, address);
 695                 pte_t *ptep;
 696
 697                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 698
 699                 /* mov __NR_rt_sigreturn, %g1 */
 700                 err |= __put_user(0x82102065, &sf->insns[0]);
 701
 702                 /* t 0x10 */
 703                 err |= __put_user(0x91d02010, &sf->insns[1]);
 704                 if (err)
 705                         goto sigsegv;
 706
 707                 preempt_disable();
 708                 ptep = pte_offset_map(pmdp, address);
 709                 if (pte_present(*ptep)) {
 710                         unsigned long page = (unsigned long)
 711                                 page_address(pte_page(*ptep));
 712
 713                         wmb();
 714                         __asm__ __volatile__("flush     %0 + %1"
 715                                              : /* no outputs */
 716                                              : "r" (page),
 717                                                "r" (address & (PAGE_SIZE - 1))
 718                                              : "memory");
 719                 }
 720                 pte_unmap(ptep);
 721                 preempt_enable();
 722         }
 723         return;
 724
 725 sigill:
 726         do_exit(SIGILL);
 727 sigsegv:
 728         force_sigsegv(signr, current);
 729 }
 730
 731 static inline void handle_signal32(unsigned long signr, struct k_sigaction *ka,
 732                                    siginfo_t *info,
 733                                    sigset_t *oldset, struct pt_regs *regs)
 734 {
 735         if (ka->sa.sa_flags & SA_SIGINFO)
 736                 setup_rt_frame32(ka, regs, signr, oldset, info);
 737         else
 738                 setup_frame32(ka, regs, signr, oldset);
 739
 740         spin_lock_irq(&current->sighand->siglock);
 741         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 742         if (!(ka->sa.sa_flags & SA_NOMASK))
 743                 sigaddset(&current->blocked,signr);
 744         recalc_sigpending();
 745         spin_unlock_irq(&current->sighand->siglock);
 746 }
 747
 748 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
 749                                      struct sigaction *sa)
 750 {
 751         switch (regs->u_regs[UREG_I0]) {
 752         case ERESTART_RESTARTBLOCK:
 753         case ERESTARTNOHAND:
 754         no_system_call_restart:
 755                 regs->u_regs[UREG_I0] = EINTR;
 756                 regs->tstate |= TSTATE_ICARRY;
 757                 break;
 758         case ERESTARTSYS:
 759                 if (!(sa->sa_flags & SA_RESTART))
 760                         goto no_system_call_restart;
 761                 /* fallthrough */
 762         case ERESTARTNOINTR:
 763                 regs->u_regs[UREG_I0] = orig_i0;
 764                 regs->tpc -= 4;
 765                 regs->tnpc -= 4;
 766         }
 767 }
 768
 769 /* Note that 'init' is a special process: it doesn't get signals it doesn't
 770  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 771  * mistake.
 772  */
 773 void do_signal32(sigset_t *oldset, struct pt_regs * regs,
 774                  int restart_syscall, unsigned long orig_i0)
 775 {
 776         struct k_sigaction ka;
 777         siginfo_t info;
 778         int signr;
 779
 780         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 781
 782         /* If the debugger messes with the program counter, it clears
 783          * the "in syscall" bit, directing us to not perform a syscall
 784          * restart.
 785          */
 786         if (restart_syscall && !pt_regs_is_syscall(regs))
 787                 restart_syscall = 0;
 788
 789         if (signr > 0) {
 790                 if (restart_syscall)
 791                         syscall_restart32(orig_i0, regs, &ka.sa);
 792                 handle_signal32(signr, &ka, &info, oldset, regs);
 793
 794                 /* A signal was successfully delivered; the saved
 795                  * sigmask will have been stored in the signal frame,
 796                  * and will be restored by sigreturn, so we can simply
 797                  * clear the TS_RESTORE_SIGMASK flag.
 798                  */
 799                 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
 800
 801                 tracehook_signal_handler(signr, &info, &ka, regs, 0);
 802                 return;
 803         }
 804         if (restart_syscall &&
 805             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
 806              regs->u_regs[UREG_I0] == ERESTARTSYS ||
 807              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
 808                 /* replay the system call when we are done */
 809                 regs->u_regs[UREG_I0] = orig_i0;
 810                 regs->tpc -= 4;
 811                 regs->tnpc -= 4;
 812         }
 813         if (restart_syscall &&
 814             regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
 815                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
 816                 regs->tpc -= 4;
 817                 regs->tnpc -= 4;
 818         }
 819
 820         /* If there's no signal to deliver, we just put the saved sigmask
 821          * back
 822          */
 823         if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
 824                 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
 825                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 826         }
 827 }
 828
 829 struct sigstack32 {
 830         u32 the_stack;
 831         int cur_status;
 832 };
 833
 834 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
 835 {
 836         struct sigstack32 __user *ssptr =
 837                 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
 838         struct sigstack32 __user *ossptr =
 839                 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
 840         int ret = -EFAULT;
 841
 842         /* First see if old state is wanted. */
 843         if (ossptr) {
 844                 if (put_user(current->sas_ss_sp + current->sas_ss_size,
 845                              &ossptr->the_stack) ||
 846                     __put_user(on_sig_stack(sp), &ossptr->cur_status))
 847                         goto out;
 848         }
 849
 850         /* Now see if we want to update the new state. */
 851         if (ssptr) {
 852                 u32 ss_sp;
 853
 854                 if (get_user(ss_sp, &ssptr->the_stack))
 855                         goto out;
 856
 857                 /* If the current stack was set with sigaltstack, don't
 858                  * swap stacks while we are on it.
 859                  */
 860                 ret = -EPERM;
 861                 if (current->sas_ss_sp && on_sig_stack(sp))
 862                         goto out;
 863
 864                 /* Since we don't know the extent of the stack, and we don't
 865                  * track onstack-ness, but rather calculate it, we must
 866                  * presume a size.  Ho hum this interface is lossy.
 867                  */
 868                 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
 869                 current->sas_ss_size = SIGSTKSZ;
 870         }
 871
 872         ret = 0;
 873 out:
 874         return ret;
 875 }
 876
 877 asmlinkage long do_sys32_sigaltstack(u32 ussa, u32 uossa, unsigned long sp)
 878 {
 879         stack_t uss, uoss;
 880         u32 u_ss_sp = 0;
 881         int ret;
 882         mm_segment_t old_fs;
 883         stack_t32 __user *uss32 = compat_ptr(ussa);
 884         stack_t32 __user *uoss32 = compat_ptr(uossa);
 885
 886         if (ussa && (get_user(u_ss_sp, &uss32->ss_sp) ||
 887                     __get_user(uss.ss_flags, &uss32->ss_flags) ||
 888                     __get_user(uss.ss_size, &uss32->ss_size)))
 889                 return -EFAULT;
 890         uss.ss_sp = compat_ptr(u_ss_sp);
 891         old_fs = get_fs();
 892         set_fs(KERNEL_DS);
 893         ret = do_sigaltstack(ussa ? (stack_t __user *) &uss : NULL,
 894                              uossa ? (stack_t __user *) &uoss : NULL, sp);
 895         set_fs(old_fs);
 896         if (!ret && uossa && (put_user(ptr_to_compat(uoss.ss_sp), &uoss32->ss_sp) ||
 897                     __put_user(uoss.ss_flags, &uoss32->ss_flags) ||
 898                     __put_user(uoss.ss_size, &uoss32->ss_size)))
 899                 return -EFAULT;
 900         return ret;
 901 }