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