kernel/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 #include <asm/switch_to.h>
  32
  33 #include "sigutil.h"
  34 #include "kernel.h"
  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 struct rt_signal_frame32 {
  59         struct sparc_stackf32   ss;
  60         compat_siginfo_t        info;
  61         struct pt_regs32        regs;
  62         compat_sigset_t         mask;
  63         /* __siginfo_fpu_t * */ u32 fpu_save;
  64         unsigned int            insns[2];
  65         compat_stack_t          stack;
  66         unsigned int            extra_size; /* Should be sizeof(siginfo_extra_v8plus_t) */
  67         /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
  68         siginfo_extra_v8plus_t  v8plus;
  69         /* __siginfo_rwin_t * */u32 rwin_save;
  70 } __attribute__((aligned(8)));
  71
  72 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
  73 {
  74         int err;
  75
  76         if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  77                 return -EFAULT;
  78
  79         /* If you change siginfo_t structure, please be sure
  80            this code is fixed accordingly.
  81            It should never copy any pad contained in the structure
  82            to avoid security leaks, but must copy the generic
  83            3 ints plus the relevant union member.
  84            This routine must convert siginfo from 64bit to 32bit as well
  85            at the same time.  */
  86         err = __put_user(from->si_signo, &to->si_signo);
  87         err |= __put_user(from->si_errno, &to->si_errno);
  88         err |= __put_user((short)from->si_code, &to->si_code);
  89         if (from->si_code < 0)
  90                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  91         else {
  92                 switch (from->si_code >> 16) {
  93                 case __SI_TIMER >> 16:
  94                         err |= __put_user(from->si_tid, &to->si_tid);
  95                         err |= __put_user(from->si_overrun, &to->si_overrun);
  96                         err |= __put_user(from->si_int, &to->si_int);
  97                         break;
  98                 case __SI_CHLD >> 16:
  99                         err |= __put_user(from->si_utime, &to->si_utime);
 100                         err |= __put_user(from->si_stime, &to->si_stime);
 101                         err |= __put_user(from->si_status, &to->si_status);
 102                 default:
 103                         err |= __put_user(from->si_pid, &to->si_pid);
 104                         err |= __put_user(from->si_uid, &to->si_uid);
 105                         break;
 106                 case __SI_FAULT >> 16:
 107                         err |= __put_user(from->si_trapno, &to->si_trapno);
 108                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 109                         break;
 110                 case __SI_POLL >> 16:
 111                         err |= __put_user(from->si_band, &to->si_band);
 112                         err |= __put_user(from->si_fd, &to->si_fd);
 113                         break;
 114                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 115                 case __SI_MESGQ >> 16:
 116                         err |= __put_user(from->si_pid, &to->si_pid);
 117                         err |= __put_user(from->si_uid, &to->si_uid);
 118                         err |= __put_user(from->si_int, &to->si_int);
 119                         break;
 120                 }
 121         }
 122         return err;
 123 }
 124
 125 /* CAUTION: This is just a very minimalist implementation for the
 126  *          sake of compat_sys_rt_sigqueueinfo()
 127  */
 128 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 129 {
 130         if (!access_ok(VERIFY_WRITE, from, sizeof(compat_siginfo_t)))
 131                 return -EFAULT;
 132
 133         if (copy_from_user(to, from, 3*sizeof(int)) ||
 134             copy_from_user(to->_sifields._pad, from->_sifields._pad,
 135                            SI_PAD_SIZE))
 136                 return -EFAULT;
 137
 138         return 0;
 139 }
 140
 141 void do_sigreturn32(struct pt_regs *regs)
 142 {
 143         struct signal_frame32 __user *sf;
 144         compat_uptr_t fpu_save;
 145         compat_uptr_t rwin_save;
 146         unsigned int psr;
 147         unsigned pc, npc;
 148         sigset_t set;
 149         compat_sigset_t seta;
 150         int err, i;
 151
 152         /* Always make any pending restarted system calls return -EINTR */
 153         current->restart_block.fn = do_no_restart_syscall;
 154
 155         synchronize_user_stack();
 156
 157         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 158         sf = (struct signal_frame32 __user *) regs->u_regs[UREG_FP];
 159
 160         /* 1. Make sure we are not getting garbage from the user */
 161         if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
 162             (((unsigned long) sf) & 3))
 163                 goto segv;
 164
 165         if (get_user(pc, &sf->info.si_regs.pc) ||
 166             __get_user(npc, &sf->info.si_regs.npc))
 167                 goto segv;
 168
 169         if ((pc | npc) & 3)
 170                 goto segv;
 171
 172         if (test_thread_flag(TIF_32BIT)) {
 173                 pc &= 0xffffffff;
 174                 npc &= 0xffffffff;
 175         }
 176         regs->tpc = pc;
 177         regs->tnpc = npc;
 178
 179         /* 2. Restore the state */
 180         err = __get_user(regs->y, &sf->info.si_regs.y);
 181         err |= __get_user(psr, &sf->info.si_regs.psr);
 182
 183         for (i = UREG_G1; i <= UREG_I7; i++)
 184                 err |= __get_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 185         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 186                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
 187                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 188                         unsigned long asi;
 189
 190                         for (i = UREG_G1; i <= UREG_I7; i++)
 191                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 192                         err |= __get_user(asi, &sf->v8plus.asi);
 193                         regs->tstate &= ~TSTATE_ASI;
 194                         regs->tstate |= ((asi & 0xffUL) << 24UL);
 195                 }
 196         }
 197
 198         /* User can only change condition codes in %tstate. */
 199         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 200         regs->tstate |= psr_to_tstate_icc(psr);
 201
 202         /* Prevent syscall restart.  */
 203         pt_regs_clear_syscall(regs);
 204
 205         err |= __get_user(fpu_save, &sf->fpu_save);
 206         if (!err && fpu_save)
 207                 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
 208         err |= __get_user(rwin_save, &sf->rwin_save);
 209         if (!err && rwin_save) {
 210                 if (restore_rwin_state(compat_ptr(rwin_save)))
 211                         goto segv;
 212         }
 213         err |= __get_user(seta.sig[0], &sf->info.si_mask);
 214         err |= copy_from_user(&seta.sig[1], &sf->extramask,
 215                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 216         if (err)
 217                 goto segv;
 218
 219         set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
 220         set_current_blocked(&set);
 221         return;
 222
 223 segv:
 224         force_sig(SIGSEGV, current);
 225 }
 226
 227 asmlinkage void do_rt_sigreturn32(struct pt_regs *regs)
 228 {
 229         struct rt_signal_frame32 __user *sf;
 230         unsigned int psr, pc, npc;
 231         compat_uptr_t fpu_save;
 232         compat_uptr_t rwin_save;
 233         sigset_t set;
 234         compat_sigset_t seta;
 235         int err, i;
 236
 237         /* Always make any pending restarted system calls return -EINTR */
 238         current->restart_block.fn = do_no_restart_syscall;
 239
 240         synchronize_user_stack();
 241         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 242         sf = (struct rt_signal_frame32 __user *) regs->u_regs[UREG_FP];
 243
 244         /* 1. Make sure we are not getting garbage from the user */
 245         if (!access_ok(VERIFY_READ, sf, sizeof(*sf)) ||
 246             (((unsigned long) sf) & 3))
 247                 goto segv;
 248
 249         if (get_user(pc, &sf->regs.pc) ||
 250             __get_user(npc, &sf->regs.npc))
 251                 goto segv;
 252
 253         if ((pc | npc) & 3)
 254                 goto segv;
 255
 256         if (test_thread_flag(TIF_32BIT)) {
 257                 pc &= 0xffffffff;
 258                 npc &= 0xffffffff;
 259         }
 260         regs->tpc = pc;
 261         regs->tnpc = npc;
 262
 263         /* 2. Restore the state */
 264         err = __get_user(regs->y, &sf->regs.y);
 265         err |= __get_user(psr, &sf->regs.psr);
 266
 267         for (i = UREG_G1; i <= UREG_I7; i++)
 268                 err |= __get_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 269         if ((psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS) {
 270                 err |= __get_user(i, &sf->v8plus.g_upper[0]);
 271                 if (i == SIGINFO_EXTRA_V8PLUS_MAGIC) {
 272                         unsigned long asi;
 273
 274                         for (i = UREG_G1; i <= UREG_I7; i++)
 275                                 err |= __get_user(((u32 *)regs->u_regs)[2*i], &sf->v8plus.g_upper[i]);
 276                         err |= __get_user(asi, &sf->v8plus.asi);
 277                         regs->tstate &= ~TSTATE_ASI;
 278                         regs->tstate |= ((asi & 0xffUL) << 24UL);
 279                 }
 280         }
 281
 282         /* User can only change condition codes in %tstate. */
 283         regs->tstate &= ~(TSTATE_ICC|TSTATE_XCC);
 284         regs->tstate |= psr_to_tstate_icc(psr);
 285
 286         /* Prevent syscall restart.  */
 287         pt_regs_clear_syscall(regs);
 288
 289         err |= __get_user(fpu_save, &sf->fpu_save);
 290         if (!err && fpu_save)
 291                 err |= restore_fpu_state(regs, compat_ptr(fpu_save));
 292         err |= copy_from_user(&seta, &sf->mask, sizeof(compat_sigset_t));
 293         err |= compat_restore_altstack(&sf->stack);
 294         if (err)
 295                 goto segv;
 296
 297         err |= __get_user(rwin_save, &sf->rwin_save);
 298         if (!err && rwin_save) {
 299                 if (restore_rwin_state(compat_ptr(rwin_save)))
 300                         goto segv;
 301         }
 302
 303         set.sig[0] = seta.sig[0] + (((long)seta.sig[1]) << 32);
 304         set_current_blocked(&set);
 305         return;
 306 segv:
 307         force_sig(SIGSEGV, current);
 308 }
 309
 310 /* Checks if the fp is valid */
 311 static int invalid_frame_pointer(void __user *fp, int fplen)
 312 {
 313         if ((((unsigned long) fp) & 7) || ((unsigned long)fp) > 0x100000000ULL - fplen)
 314                 return 1;
 315         return 0;
 316 }
 317
 318 static void __user *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, unsigned long framesize)
 319 {
 320         unsigned long sp;
 321
 322         regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
 323         sp = regs->u_regs[UREG_FP];
 324
 325         /*
 326          * If we are on the alternate signal stack and would overflow it, don't.
 327          * Return an always-bogus address instead so we will die with SIGSEGV.
 328          */
 329         if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
 330                 return (void __user *) -1L;
 331
 332         /* This is the X/Open sanctioned signal stack switching.  */
 333         sp = sigsp(sp, ksig) - framesize;
 334
 335         /* Always align the stack frame.  This handles two cases.  First,
 336          * sigaltstack need not be mindful of platform specific stack
 337          * alignment.  Second, if we took this signal because the stack
 338          * is not aligned properly, we'd like to take the signal cleanly
 339          * and report that.
 340          */
 341         sp &= ~15UL;
 342
 343         return (void __user *) sp;
 344 }
 345
 346 /* The I-cache flush instruction only works in the primary ASI, which
 347  * right now is the nucleus, aka. kernel space.
 348  *
 349  * Therefore we have to kick the instructions out using the kernel
 350  * side linear mapping of the physical address backing the user
 351  * instructions.
 352  */
 353 static void flush_signal_insns(unsigned long address)
 354 {
 355         unsigned long pstate, paddr;
 356         pte_t *ptep, pte;
 357         pgd_t *pgdp;
 358         pud_t *pudp;
 359         pmd_t *pmdp;
 360
 361         /* Commit all stores of the instructions we are about to flush.  */
 362         wmb();
 363
 364         /* Disable cross-call reception.  In this way even a very wide
 365          * munmap() on another cpu can't tear down the page table
 366          * hierarchy from underneath us, since that can't complete
 367          * until the IPI tlb flush returns.
 368          */
 369
 370         __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
 371         __asm__ __volatile__("wrpr %0, %1, %%pstate"
 372                                 : : "r" (pstate), "i" (PSTATE_IE));
 373
 374         pgdp = pgd_offset(current->mm, address);
 375         if (pgd_none(*pgdp))
 376                 goto out_irqs_on;
 377         pudp = pud_offset(pgdp, address);
 378         if (pud_none(*pudp))
 379                 goto out_irqs_on;
 380         pmdp = pmd_offset(pudp, address);
 381         if (pmd_none(*pmdp))
 382                 goto out_irqs_on;
 383
 384         ptep = pte_offset_map(pmdp, address);
 385         pte = *ptep;
 386         if (!pte_present(pte))
 387                 goto out_unmap;
 388
 389         paddr = (unsigned long) page_address(pte_page(pte));
 390
 391         __asm__ __volatile__("flush     %0 + %1"
 392                              : /* no outputs */
 393                              : "r" (paddr),
 394                                "r" (address & (PAGE_SIZE - 1))
 395                              : "memory");
 396
 397 out_unmap:
 398         pte_unmap(ptep);
 399 out_irqs_on:
 400         __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
 401
 402 }
 403
 404 static int setup_frame32(struct ksignal *ksig, struct pt_regs *regs,
 405                          sigset_t *oldset)
 406 {
 407         struct signal_frame32 __user *sf;
 408         int i, err, wsaved;
 409         void __user *tail;
 410         int sigframe_size;
 411         u32 psr;
 412         compat_sigset_t seta;
 413
 414         /* 1. Make sure everything is clean */
 415         synchronize_user_stack();
 416         save_and_clear_fpu();
 417
 418         wsaved = get_thread_wsaved();
 419
 420         sigframe_size = sizeof(*sf);
 421         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 422                 sigframe_size += sizeof(__siginfo_fpu_t);
 423         if (wsaved)
 424                 sigframe_size += sizeof(__siginfo_rwin_t);
 425
 426         sf = (struct signal_frame32 __user *)
 427                 get_sigframe(ksig, regs, sigframe_size);
 428
 429         if (invalid_frame_pointer(sf, sigframe_size)) {
 430                 do_exit(SIGILL);
 431                 return -EINVAL;
 432         }
 433
 434         tail = (sf + 1);
 435
 436         /* 2. Save the current process state */
 437         if (test_thread_flag(TIF_32BIT)) {
 438                 regs->tpc &= 0xffffffff;
 439                 regs->tnpc &= 0xffffffff;
 440         }
 441         err  = put_user(regs->tpc, &sf->info.si_regs.pc);
 442         err |= __put_user(regs->tnpc, &sf->info.si_regs.npc);
 443         err |= __put_user(regs->y, &sf->info.si_regs.y);
 444         psr = tstate_to_psr(regs->tstate);
 445         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 446                 psr |= PSR_EF;
 447         err |= __put_user(psr, &sf->info.si_regs.psr);
 448         for (i = 0; i < 16; i++)
 449                 err |= __put_user(regs->u_regs[i], &sf->info.si_regs.u_regs[i]);
 450         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 451         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 452         for (i = 1; i < 16; i++)
 453                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
 454                                   &sf->v8plus.g_upper[i]);
 455         err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
 456                           &sf->v8plus.asi);
 457
 458         if (psr & PSR_EF) {
 459                 __siginfo_fpu_t __user *fp = tail;
 460                 tail += sizeof(*fp);
 461                 err |= save_fpu_state(regs, fp);
 462                 err |= __put_user((u64)fp, &sf->fpu_save);
 463         } else {
 464                 err |= __put_user(0, &sf->fpu_save);
 465         }
 466         if (wsaved) {
 467                 __siginfo_rwin_t __user *rwp = tail;
 468                 tail += sizeof(*rwp);
 469                 err |= save_rwin_state(wsaved, rwp);
 470                 err |= __put_user((u64)rwp, &sf->rwin_save);
 471                 set_thread_wsaved(0);
 472         } else {
 473                 err |= __put_user(0, &sf->rwin_save);
 474         }
 475
 476         /* If these change we need to know - assignments to seta relies on these sizes */
 477         BUILD_BUG_ON(_NSIG_WORDS != 1);
 478         BUILD_BUG_ON(_COMPAT_NSIG_WORDS != 2);
 479         seta.sig[1] = (oldset->sig[0] >> 32);
 480         seta.sig[0] = oldset->sig[0];
 481
 482         err |= __put_user(seta.sig[0], &sf->info.si_mask);
 483         err |= __copy_to_user(sf->extramask, &seta.sig[1],
 484                               (_COMPAT_NSIG_WORDS - 1) * sizeof(unsigned int));
 485
 486         if (!wsaved) {
 487                 err |= copy_in_user((u32 __user *)sf,
 488                                     (u32 __user *)(regs->u_regs[UREG_FP]),
 489                                     sizeof(struct reg_window32));
 490         } else {
 491                 struct reg_window *rp;
 492
 493                 rp = &current_thread_info()->reg_window[wsaved - 1];
 494                 for (i = 0; i < 8; i++)
 495                         err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
 496                 for (i = 0; i < 6; i++)
 497                         err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
 498                 err |= __put_user(rp->ins[6], &sf->ss.fp);
 499                 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
 500         }
 501         if (err)
 502                 return err;
 503
 504         /* 3. signal handler back-trampoline and parameters */
 505         regs->u_regs[UREG_FP] = (unsigned long) sf;
 506         regs->u_regs[UREG_I0] = ksig->sig;
 507         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 508         regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
 509
 510         /* 4. signal handler */
 511         regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
 512         regs->tnpc = (regs->tpc + 4);
 513         if (test_thread_flag(TIF_32BIT)) {
 514                 regs->tpc &= 0xffffffff;
 515                 regs->tnpc &= 0xffffffff;
 516         }
 517
 518         /* 5. return to kernel instructions */
 519         if (ksig->ka.ka_restorer) {
 520                 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
 521         } else {
 522                 unsigned long address = ((unsigned long)&(sf->insns[0]));
 523
 524                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 525
 526                 err  = __put_user(0x821020d8, &sf->insns[0]); /*mov __NR_sigreturn, %g1*/
 527                 err |= __put_user(0x91d02010, &sf->insns[1]); /*t 0x10*/
 528                 if (err)
 529                         return err;
 530                 flush_signal_insns(address);
 531         }
 532         return 0;
 533 }
 534
 535 static int setup_rt_frame32(struct ksignal *ksig, struct pt_regs *regs,
 536                             sigset_t *oldset)
 537 {
 538         struct rt_signal_frame32 __user *sf;
 539         int i, err, wsaved;
 540         void __user *tail;
 541         int sigframe_size;
 542         u32 psr;
 543         compat_sigset_t seta;
 544
 545         /* 1. Make sure everything is clean */
 546         synchronize_user_stack();
 547         save_and_clear_fpu();
 548
 549         wsaved = get_thread_wsaved();
 550
 551         sigframe_size = sizeof(*sf);
 552         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 553                 sigframe_size += sizeof(__siginfo_fpu_t);
 554         if (wsaved)
 555                 sigframe_size += sizeof(__siginfo_rwin_t);
 556
 557         sf = (struct rt_signal_frame32 __user *)
 558                 get_sigframe(ksig, regs, sigframe_size);
 559
 560         if (invalid_frame_pointer(sf, sigframe_size)) {
 561                 do_exit(SIGILL);
 562                 return -EINVAL;
 563         }
 564
 565         tail = (sf + 1);
 566
 567         /* 2. Save the current process state */
 568         if (test_thread_flag(TIF_32BIT)) {
 569                 regs->tpc &= 0xffffffff;
 570                 regs->tnpc &= 0xffffffff;
 571         }
 572         err  = put_user(regs->tpc, &sf->regs.pc);
 573         err |= __put_user(regs->tnpc, &sf->regs.npc);
 574         err |= __put_user(regs->y, &sf->regs.y);
 575         psr = tstate_to_psr(regs->tstate);
 576         if (current_thread_info()->fpsaved[0] & FPRS_FEF)
 577                 psr |= PSR_EF;
 578         err |= __put_user(psr, &sf->regs.psr);
 579         for (i = 0; i < 16; i++)
 580                 err |= __put_user(regs->u_regs[i], &sf->regs.u_regs[i]);
 581         err |= __put_user(sizeof(siginfo_extra_v8plus_t), &sf->extra_size);
 582         err |= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC, &sf->v8plus.g_upper[0]);
 583         for (i = 1; i < 16; i++)
 584                 err |= __put_user(((u32 *)regs->u_regs)[2*i],
 585                                   &sf->v8plus.g_upper[i]);
 586         err |= __put_user((regs->tstate & TSTATE_ASI) >> 24UL,
 587                           &sf->v8plus.asi);
 588
 589         if (psr & PSR_EF) {
 590                 __siginfo_fpu_t __user *fp = tail;
 591                 tail += sizeof(*fp);
 592                 err |= save_fpu_state(regs, fp);
 593                 err |= __put_user((u64)fp, &sf->fpu_save);
 594         } else {
 595                 err |= __put_user(0, &sf->fpu_save);
 596         }
 597         if (wsaved) {
 598                 __siginfo_rwin_t __user *rwp = tail;
 599                 tail += sizeof(*rwp);
 600                 err |= save_rwin_state(wsaved, rwp);
 601                 err |= __put_user((u64)rwp, &sf->rwin_save);
 602                 set_thread_wsaved(0);
 603         } else {
 604                 err |= __put_user(0, &sf->rwin_save);
 605         }
 606
 607         /* Update the siginfo structure.  */
 608         err |= copy_siginfo_to_user32(&sf->info, &ksig->info);
 609
 610         /* Setup sigaltstack */
 611         err |= __compat_save_altstack(&sf->stack, regs->u_regs[UREG_FP]);
 612
 613         seta.sig[1] = (oldset->sig[0] >> 32);
 614         seta.sig[0] = oldset->sig[0];
 615         err |= __copy_to_user(&sf->mask, &seta, sizeof(compat_sigset_t));
 616
 617         if (!wsaved) {
 618                 err |= copy_in_user((u32 __user *)sf,
 619                                     (u32 __user *)(regs->u_regs[UREG_FP]),
 620                                     sizeof(struct reg_window32));
 621         } else {
 622                 struct reg_window *rp;
 623
 624                 rp = &current_thread_info()->reg_window[wsaved - 1];
 625                 for (i = 0; i < 8; i++)
 626                         err |= __put_user(rp->locals[i], &sf->ss.locals[i]);
 627                 for (i = 0; i < 6; i++)
 628                         err |= __put_user(rp->ins[i], &sf->ss.ins[i]);
 629                 err |= __put_user(rp->ins[6], &sf->ss.fp);
 630                 err |= __put_user(rp->ins[7], &sf->ss.callers_pc);
 631         }
 632         if (err)
 633                 return err;
 634
 635         /* 3. signal handler back-trampoline and parameters */
 636         regs->u_regs[UREG_FP] = (unsigned long) sf;
 637         regs->u_regs[UREG_I0] = ksig->sig;
 638         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
 639         regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
 640
 641         /* 4. signal handler */
 642         regs->tpc = (unsigned long) ksig->ka.sa.sa_handler;
 643         regs->tnpc = (regs->tpc + 4);
 644         if (test_thread_flag(TIF_32BIT)) {
 645                 regs->tpc &= 0xffffffff;
 646                 regs->tnpc &= 0xffffffff;
 647         }
 648
 649         /* 5. return to kernel instructions */
 650         if (ksig->ka.ka_restorer)
 651                 regs->u_regs[UREG_I7] = (unsigned long)ksig->ka.ka_restorer;
 652         else {
 653                 unsigned long address = ((unsigned long)&(sf->insns[0]));
 654
 655                 regs->u_regs[UREG_I7] = (unsigned long) (&(sf->insns[0]) - 2);
 656
 657                 /* mov __NR_rt_sigreturn, %g1 */
 658                 err |= __put_user(0x82102065, &sf->insns[0]);
 659
 660                 /* t 0x10 */
 661                 err |= __put_user(0x91d02010, &sf->insns[1]);
 662                 if (err)
 663                         return err;
 664
 665                 flush_signal_insns(address);
 666         }
 667         return 0;
 668 }
 669
 670 static inline void handle_signal32(struct ksignal *ksig,
 671                                   struct pt_regs *regs)
 672 {
 673         sigset_t *oldset = sigmask_to_save();
 674         int err;
 675
 676         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 677                 err = setup_rt_frame32(ksig, regs, oldset);
 678         else
 679                 err = setup_frame32(ksig, regs, oldset);
 680
 681         signal_setup_done(err, ksig, 0);
 682 }
 683
 684 static inline void syscall_restart32(unsigned long orig_i0, struct pt_regs *regs,
 685                                      struct sigaction *sa)
 686 {
 687         switch (regs->u_regs[UREG_I0]) {
 688         case ERESTART_RESTARTBLOCK:
 689         case ERESTARTNOHAND:
 690         no_system_call_restart:
 691                 regs->u_regs[UREG_I0] = EINTR;
 692                 regs->tstate |= TSTATE_ICARRY;
 693                 break;
 694         case ERESTARTSYS:
 695                 if (!(sa->sa_flags & SA_RESTART))
 696                         goto no_system_call_restart;
 697                 /* fallthrough */
 698         case ERESTARTNOINTR:
 699                 regs->u_regs[UREG_I0] = orig_i0;
 700                 regs->tpc -= 4;
 701                 regs->tnpc -= 4;
 702         }
 703 }
 704
 705 /* Note that 'init' is a special process: it doesn't get signals it doesn't
 706  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 707  * mistake.
 708  */
 709 void do_signal32(struct pt_regs * regs)
 710 {
 711         struct ksignal ksig;
 712         unsigned long orig_i0 = 0;
 713         int restart_syscall = 0;
 714         bool has_handler = get_signal(&ksig);
 715
 716         if (pt_regs_is_syscall(regs) &&
 717             (regs->tstate & (TSTATE_XCARRY | TSTATE_ICARRY))) {
 718                 restart_syscall = 1;
 719                 orig_i0 = regs->u_regs[UREG_G6];
 720         }
 721
 722         if (has_handler) {
 723                 if (restart_syscall)
 724                         syscall_restart32(orig_i0, regs, &ksig.ka.sa);
 725                 handle_signal32(&ksig, regs);
 726         } else {
 727                 if (restart_syscall) {
 728                         switch (regs->u_regs[UREG_I0]) {
 729                         case ERESTARTNOHAND:
 730                         case ERESTARTSYS:
 731                         case ERESTARTNOINTR:
 732                                 /* replay the system call when we are done */
 733                                 regs->u_regs[UREG_I0] = orig_i0;
 734                                 regs->tpc -= 4;
 735                                 regs->tnpc -= 4;
 736                                 pt_regs_clear_syscall(regs);
 737                         case ERESTART_RESTARTBLOCK:
 738                                 regs->u_regs[UREG_G1] = __NR_restart_syscall;
 739                                 regs->tpc -= 4;
 740                                 regs->tnpc -= 4;
 741                                 pt_regs_clear_syscall(regs);
 742                         }
 743                 }
 744                 restore_saved_sigmask();
 745         }
 746 }
 747
 748 struct sigstack32 {
 749         u32 the_stack;
 750         int cur_status;
 751 };
 752
 753 asmlinkage int do_sys32_sigstack(u32 u_ssptr, u32 u_ossptr, unsigned long sp)
 754 {
 755         struct sigstack32 __user *ssptr =
 756                 (struct sigstack32 __user *)((unsigned long)(u_ssptr));
 757         struct sigstack32 __user *ossptr =
 758                 (struct sigstack32 __user *)((unsigned long)(u_ossptr));
 759         int ret = -EFAULT;
 760
 761         /* First see if old state is wanted. */
 762         if (ossptr) {
 763                 if (put_user(current->sas_ss_sp + current->sas_ss_size,
 764                              &ossptr->the_stack) ||
 765                     __put_user(on_sig_stack(sp), &ossptr->cur_status))
 766                         goto out;
 767         }
 768
 769         /* Now see if we want to update the new state. */
 770         if (ssptr) {
 771                 u32 ss_sp;
 772
 773                 if (get_user(ss_sp, &ssptr->the_stack))
 774                         goto out;
 775
 776                 /* If the current stack was set with sigaltstack, don't
 777                  * swap stacks while we are on it.
 778                  */
 779                 ret = -EPERM;
 780                 if (current->sas_ss_sp && on_sig_stack(sp))
 781                         goto out;
 782
 783                 /* Since we don't know the extent of the stack, and we don't
 784                  * track onstack-ness, but rather calculate it, we must
 785                  * presume a size.  Ho hum this interface is lossy.
 786                  */
 787                 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
 788                 current->sas_ss_size = SIGSTKSZ;
 789         }
 790
 791         ret = 0;
 792 out:
 793         return ret;
 794 }