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