arch/mips/kernel/signal32.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1991, 1992  Linus Torvalds
   7  * Copyright (C) 1994 - 2000, 2006  Ralf Baechle
   8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
   9  */
  10 #include <linux/cache.h>
  11 #include <linux/compat.h>
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/kernel.h>
  16 #include <linux/signal.h>
  17 #include <linux/syscalls.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/ptrace.h>
  21 #include <linux/suspend.h>
  22 #include <linux/compiler.h>
  23 #include <linux/uaccess.h>
  24
  25 #include <asm/abi.h>
  26 #include <asm/asm.h>
  27 #include <asm/compat-signal.h>
  28 #include <linux/bitops.h>
  29 #include <asm/cacheflush.h>
  30 #include <asm/sim.h>
  31 #include <asm/ucontext.h>
  32 #include <asm/fpu.h>
  33 #include <asm/war.h>
  34 #include <asm/vdso.h>
  35 #include <asm/dsp.h>
  36
  37 #include "signal-common.h"
  38
  39 static int (*save_fp_context32)(struct sigcontext32 __user *sc);
  40 static int (*restore_fp_context32)(struct sigcontext32 __user *sc);
  41
  42 extern asmlinkage int _save_fp_context32(struct sigcontext32 __user *sc);
  43 extern asmlinkage int _restore_fp_context32(struct sigcontext32 __user *sc);
  44
  45 /*
  46  * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
  47  */
  48 #define __NR_O32_restart_syscall        4253
  49
  50 /* 32-bit compatibility types */
  51
  52 typedef unsigned int __sighandler32_t;
  53 typedef void (*vfptr_t)(void);
  54
  55 struct ucontext32 {
  56         u32                 uc_flags;
  57         s32                 uc_link;
  58         compat_stack_t      uc_stack;
  59         struct sigcontext32 uc_mcontext;
  60         compat_sigset_t     uc_sigmask;   /* mask last for extensibility */
  61 };
  62
  63 struct sigframe32 {
  64         u32 sf_ass[4];          /* argument save space for o32 */
  65         u32 sf_pad[2];          /* Was: signal trampoline */
  66         struct sigcontext32 sf_sc;
  67         compat_sigset_t sf_mask;
  68 };
  69
  70 struct rt_sigframe32 {
  71         u32 rs_ass[4];                  /* argument save space for o32 */
  72         u32 rs_pad[2];                  /* Was: signal trampoline */
  73         compat_siginfo_t rs_info;
  74         struct ucontext32 rs_uc;
  75 };
  76
  77 /*
  78  * Thread saved context copy to/from a signal context presumed to be on the
  79  * user stack, and therefore accessed with appropriate macros from uaccess.h.
  80  */
  81 static int copy_fp_to_sigcontext32(struct sigcontext32 __user *sc)
  82 {
  83         int i;
  84         int err = 0;
  85         int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
  86
  87         for (i = 0; i < 32; i += inc) {
  88                 err |=
  89                     __put_user(get_fpr64(&current->thread.fpu.fpr[i], 0),
  90                                &sc->sc_fpregs[i]);
  91         }
  92         err |= __put_user(current->thread.fpu.fcr31, &sc->sc_fpc_csr);
  93
  94         return err;
  95 }
  96
  97 static int copy_fp_from_sigcontext32(struct sigcontext32 __user *sc)
  98 {
  99         int i;
 100         int err = 0;
 101         int inc = test_thread_flag(TIF_32BIT_FPREGS) ? 2 : 1;
 102         u64 fpr_val;
 103
 104         for (i = 0; i < 32; i += inc) {
 105                 err |= __get_user(fpr_val, &sc->sc_fpregs[i]);
 106                 set_fpr64(&current->thread.fpu.fpr[i], 0, fpr_val);
 107         }
 108         err |= __get_user(current->thread.fpu.fcr31, &sc->sc_fpc_csr);
 109
 110         return err;
 111 }
 112
 113 /*
 114  * sigcontext handlers
 115  */
 116 static int protected_save_fp_context32(struct sigcontext32 __user *sc)
 117 {
 118         int err;
 119         while (1) {
 120                 lock_fpu_owner();
 121                 err = own_fpu_inatomic(1);
 122                 if (!err)
 123                         err = save_fp_context32(sc); /* this might fail */
 124                 unlock_fpu_owner();
 125                 if (likely(!err))
 126                         break;
 127                 /* touch the sigcontext and try again */
 128                 err = __put_user(0, &sc->sc_fpregs[0]) |
 129                         __put_user(0, &sc->sc_fpregs[31]) |
 130                         __put_user(0, &sc->sc_fpc_csr);
 131                 if (err)
 132                         break;  /* really bad sigcontext */
 133         }
 134         return err;
 135 }
 136
 137 static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
 138 {
 139         int err, tmp __maybe_unused;
 140         while (1) {
 141                 lock_fpu_owner();
 142                 err = own_fpu_inatomic(0);
 143                 if (!err)
 144                         err = restore_fp_context32(sc); /* this might fail */
 145                 unlock_fpu_owner();
 146                 if (likely(!err))
 147                         break;
 148                 /* touch the sigcontext and try again */
 149                 err = __get_user(tmp, &sc->sc_fpregs[0]) |
 150                         __get_user(tmp, &sc->sc_fpregs[31]) |
 151                         __get_user(tmp, &sc->sc_fpc_csr);
 152                 if (err)
 153                         break;  /* really bad sigcontext */
 154         }
 155         return err;
 156 }
 157
 158 static int setup_sigcontext32(struct pt_regs *regs,
 159                               struct sigcontext32 __user *sc)
 160 {
 161         int err = 0;
 162         int i;
 163         u32 used_math;
 164
 165         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
 166
 167         err |= __put_user(0, &sc->sc_regs[0]);
 168         for (i = 1; i < 32; i++)
 169                 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
 170
 171         err |= __put_user(regs->hi, &sc->sc_mdhi);
 172         err |= __put_user(regs->lo, &sc->sc_mdlo);
 173         if (cpu_has_dsp) {
 174                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
 175                 err |= __put_user(mfhi1(), &sc->sc_hi1);
 176                 err |= __put_user(mflo1(), &sc->sc_lo1);
 177                 err |= __put_user(mfhi2(), &sc->sc_hi2);
 178                 err |= __put_user(mflo2(), &sc->sc_lo2);
 179                 err |= __put_user(mfhi3(), &sc->sc_hi3);
 180                 err |= __put_user(mflo3(), &sc->sc_lo3);
 181         }
 182
 183         used_math = !!used_math();
 184         err |= __put_user(used_math, &sc->sc_used_math);
 185
 186         if (used_math) {
 187                 /*
 188                  * Save FPU state to signal context.  Signal handler
 189                  * will "inherit" current FPU state.
 190                  */
 191                 err |= protected_save_fp_context32(sc);
 192         }
 193         return err;
 194 }
 195
 196 static int
 197 check_and_restore_fp_context32(struct sigcontext32 __user *sc)
 198 {
 199         int err, sig;
 200
 201         err = sig = fpcsr_pending(&sc->sc_fpc_csr);
 202         if (err > 0)
 203                 err = 0;
 204         err |= protected_restore_fp_context32(sc);
 205         return err ?: sig;
 206 }
 207
 208 static int restore_sigcontext32(struct pt_regs *regs,
 209                                 struct sigcontext32 __user *sc)
 210 {
 211         u32 used_math;
 212         int err = 0;
 213         s32 treg;
 214         int i;
 215
 216         /* Always make any pending restarted system calls return -EINTR */
 217         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 218
 219         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 220         err |= __get_user(regs->hi, &sc->sc_mdhi);
 221         err |= __get_user(regs->lo, &sc->sc_mdlo);
 222         if (cpu_has_dsp) {
 223                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
 224                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
 225                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
 226                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
 227                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
 228                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
 229                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
 230         }
 231
 232         for (i = 1; i < 32; i++)
 233                 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
 234
 235         err |= __get_user(used_math, &sc->sc_used_math);
 236         conditional_used_math(used_math);
 237
 238         if (used_math) {
 239                 /* restore fpu context if we have used it before */
 240                 if (!err)
 241                         err = check_and_restore_fp_context32(sc);
 242         } else {
 243                 /* signal handler may have used FPU.  Give it up. */
 244                 lose_fpu(0);
 245         }
 246
 247         return err;
 248 }
 249
 250 /*
 251  *
 252  */
 253 extern void __put_sigset_unknown_nsig(void);
 254 extern void __get_sigset_unknown_nsig(void);
 255
 256 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
 257 {
 258         int err = 0;
 259
 260         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
 261                 return -EFAULT;
 262
 263         switch (_NSIG_WORDS) {
 264         default:
 265                 __put_sigset_unknown_nsig();
 266         case 2:
 267                 err |= __put_user(kbuf->sig[1] >> 32, &ubuf->sig[3]);
 268                 err |= __put_user(kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
 269         case 1:
 270                 err |= __put_user(kbuf->sig[0] >> 32, &ubuf->sig[1]);
 271                 err |= __put_user(kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
 272         }
 273
 274         return err;
 275 }
 276
 277 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
 278 {
 279         int err = 0;
 280         unsigned long sig[4];
 281
 282         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
 283                 return -EFAULT;
 284
 285         switch (_NSIG_WORDS) {
 286         default:
 287                 __get_sigset_unknown_nsig();
 288         case 2:
 289                 err |= __get_user(sig[3], &ubuf->sig[3]);
 290                 err |= __get_user(sig[2], &ubuf->sig[2]);
 291                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
 292         case 1:
 293                 err |= __get_user(sig[1], &ubuf->sig[1]);
 294                 err |= __get_user(sig[0], &ubuf->sig[0]);
 295                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
 296         }
 297
 298         return err;
 299 }
 300
 301 /*
 302  * Atomically swap in the new signal mask, and wait for a signal.
 303  */
 304
 305 asmlinkage int sys32_sigsuspend(compat_sigset_t __user *uset)
 306 {
 307         return compat_sys_rt_sigsuspend(uset, sizeof(compat_sigset_t));
 308 }
 309
 310 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct compat_sigaction __user *, act,
 311         struct compat_sigaction __user *, oact)
 312 {
 313         struct k_sigaction new_ka, old_ka;
 314         int ret;
 315         int err = 0;
 316
 317         if (act) {
 318                 old_sigset_t mask;
 319                 s32 handler;
 320
 321                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 322                         return -EFAULT;
 323                 err |= __get_user(handler, &act->sa_handler);
 324                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
 325                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 326                 err |= __get_user(mask, &act->sa_mask.sig[0]);
 327                 if (err)
 328                         return -EFAULT;
 329
 330                 siginitset(&new_ka.sa.sa_mask, mask);
 331         }
 332
 333         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 334
 335         if (!ret && oact) {
 336                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 337                         return -EFAULT;
 338                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 339                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
 340                                   &oact->sa_handler);
 341                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
 342                 err |= __put_user(0, &oact->sa_mask.sig[1]);
 343                 err |= __put_user(0, &oact->sa_mask.sig[2]);
 344                 err |= __put_user(0, &oact->sa_mask.sig[3]);
 345                 if (err)
 346                         return -EFAULT;
 347         }
 348
 349         return ret;
 350 }
 351
 352 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
 353 {
 354         int err;
 355
 356         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 357                 return -EFAULT;
 358
 359         /* If you change siginfo_t structure, please be sure
 360            this code is fixed accordingly.
 361            It should never copy any pad contained in the structure
 362            to avoid security leaks, but must copy the generic
 363            3 ints plus the relevant union member.
 364            This routine must convert siginfo from 64bit to 32bit as well
 365            at the same time.  */
 366         err = __put_user(from->si_signo, &to->si_signo);
 367         err |= __put_user(from->si_errno, &to->si_errno);
 368         err |= __put_user((short)from->si_code, &to->si_code);
 369         if (from->si_code < 0)
 370                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 371         else {
 372                 switch (from->si_code >> 16) {
 373                 case __SI_TIMER >> 16:
 374                         err |= __put_user(from->si_tid, &to->si_tid);
 375                         err |= __put_user(from->si_overrun, &to->si_overrun);
 376                         err |= __put_user(from->si_int, &to->si_int);
 377                         break;
 378                 case __SI_CHLD >> 16:
 379                         err |= __put_user(from->si_utime, &to->si_utime);
 380                         err |= __put_user(from->si_stime, &to->si_stime);
 381                         err |= __put_user(from->si_status, &to->si_status);
 382                 default:
 383                         err |= __put_user(from->si_pid, &to->si_pid);
 384                         err |= __put_user(from->si_uid, &to->si_uid);
 385                         break;
 386                 case __SI_FAULT >> 16:
 387                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 388                         break;
 389                 case __SI_POLL >> 16:
 390                         err |= __put_user(from->si_band, &to->si_band);
 391                         err |= __put_user(from->si_fd, &to->si_fd);
 392                         break;
 393                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 394                 case __SI_MESGQ >> 16:
 395                         err |= __put_user(from->si_pid, &to->si_pid);
 396                         err |= __put_user(from->si_uid, &to->si_uid);
 397                         err |= __put_user(from->si_int, &to->si_int);
 398                         break;
 399                 }
 400         }
 401         return err;
 402 }
 403
 404 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 405 {
 406         memset(to, 0, sizeof *to);
 407
 408         if (copy_from_user(to, from, 3*sizeof(int)) ||
 409             copy_from_user(to->_sifields._pad,
 410                            from->_sifields._pad, SI_PAD_SIZE32))
 411                 return -EFAULT;
 412
 413         return 0;
 414 }
 415
 416 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 417 {
 418         struct sigframe32 __user *frame;
 419         sigset_t blocked;
 420         int sig;
 421
 422         frame = (struct sigframe32 __user *) regs.regs[29];
 423         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 424                 goto badframe;
 425         if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
 426                 goto badframe;
 427
 428         set_current_blocked(&blocked);
 429
 430         sig = restore_sigcontext32(&regs, &frame->sf_sc);
 431         if (sig < 0)
 432                 goto badframe;
 433         else if (sig)
 434                 force_sig(sig, current);
 435
 436         /*
 437          * Don't let your children do this ...
 438          */
 439         __asm__ __volatile__(
 440                 "move\t$29, %0\n\t"
 441                 "j\tsyscall_exit"
 442                 :/* no outputs */
 443                 :"r" (&regs));
 444         /* Unreached */
 445
 446 badframe:
 447         force_sig(SIGSEGV, current);
 448 }
 449
 450 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 451 {
 452         struct rt_sigframe32 __user *frame;
 453         sigset_t set;
 454         int sig;
 455
 456         frame = (struct rt_sigframe32 __user *) regs.regs[29];
 457         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 458                 goto badframe;
 459         if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
 460                 goto badframe;
 461
 462         set_current_blocked(&set);
 463
 464         sig = restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext);
 465         if (sig < 0)
 466                 goto badframe;
 467         else if (sig)
 468                 force_sig(sig, current);
 469
 470         if (compat_restore_altstack(&frame->rs_uc.uc_stack))
 471                 goto badframe;
 472
 473         /*
 474          * Don't let your children do this ...
 475          */
 476         __asm__ __volatile__(
 477                 "move\t$29, %0\n\t"
 478                 "j\tsyscall_exit"
 479                 :/* no outputs */
 480                 :"r" (&regs));
 481         /* Unreached */
 482
 483 badframe:
 484         force_sig(SIGSEGV, current);
 485 }
 486
 487 static int setup_frame_32(void *sig_return, struct k_sigaction *ka,
 488                           struct pt_regs *regs, int signr, sigset_t *set)
 489 {
 490         struct sigframe32 __user *frame;
 491         int err = 0;
 492
 493         frame = get_sigframe(ka, regs, sizeof(*frame));
 494         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 495                 goto give_sigsegv;
 496
 497         err |= setup_sigcontext32(regs, &frame->sf_sc);
 498         err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
 499
 500         if (err)
 501                 goto give_sigsegv;
 502
 503         /*
 504          * Arguments to signal handler:
 505          *
 506          *   a0 = signal number
 507          *   a1 = 0 (should be cause)
 508          *   a2 = pointer to struct sigcontext
 509          *
 510          * $25 and c0_epc point to the signal handler, $29 points to the
 511          * struct sigframe.
 512          */
 513         regs->regs[ 4] = signr;
 514         regs->regs[ 5] = 0;
 515         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 516         regs->regs[29] = (unsigned long) frame;
 517         regs->regs[31] = (unsigned long) sig_return;
 518         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 519
 520         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 521                current->comm, current->pid,
 522                frame, regs->cp0_epc, regs->regs[31]);
 523
 524         return 0;
 525
 526 give_sigsegv:
 527         force_sigsegv(signr, current);
 528         return -EFAULT;
 529 }
 530
 531 static int setup_rt_frame_32(void *sig_return, struct k_sigaction *ka,
 532                              struct pt_regs *regs, int signr, sigset_t *set,
 533                              siginfo_t *info)
 534 {
 535         struct rt_sigframe32 __user *frame;
 536         int err = 0;
 537
 538         frame = get_sigframe(ka, regs, sizeof(*frame));
 539         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 540                 goto give_sigsegv;
 541
 542         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
 543         err |= copy_siginfo_to_user32(&frame->rs_info, info);
 544
 545         /* Create the ucontext.  */
 546         err |= __put_user(0, &frame->rs_uc.uc_flags);
 547         err |= __put_user(0, &frame->rs_uc.uc_link);
 548         err |= __compat_save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
 549         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 550         err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
 551
 552         if (err)
 553                 goto give_sigsegv;
 554
 555         /*
 556          * Arguments to signal handler:
 557          *
 558          *   a0 = signal number
 559          *   a1 = 0 (should be cause)
 560          *   a2 = pointer to ucontext
 561          *
 562          * $25 and c0_epc point to the signal handler, $29 points to
 563          * the struct rt_sigframe32.
 564          */
 565         regs->regs[ 4] = signr;
 566         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 567         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 568         regs->regs[29] = (unsigned long) frame;
 569         regs->regs[31] = (unsigned long) sig_return;
 570         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 571
 572         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 573                current->comm, current->pid,
 574                frame, regs->cp0_epc, regs->regs[31]);
 575
 576         return 0;
 577
 578 give_sigsegv:
 579         force_sigsegv(signr, current);
 580         return -EFAULT;
 581 }
 582
 583 /*
 584  * o32 compatibility on 64-bit kernels, without DSP ASE
 585  */
 586 struct mips_abi mips_abi_32 = {
 587         .setup_frame    = setup_frame_32,
 588         .signal_return_offset =
 589                 offsetof(struct mips_vdso, o32_signal_trampoline),
 590         .setup_rt_frame = setup_rt_frame_32,
 591         .rt_signal_return_offset =
 592                 offsetof(struct mips_vdso, o32_rt_signal_trampoline),
 593         .restart        = __NR_O32_restart_syscall
 594 };
 595
 596 static int signal32_init(void)
 597 {
 598         if (cpu_has_fpu) {
 599                 save_fp_context32 = _save_fp_context32;
 600                 restore_fp_context32 = _restore_fp_context32;
 601         } else {
 602                 save_fp_context32 = copy_fp_to_sigcontext32;
 603                 restore_fp_context32 = copy_fp_from_sigcontext32;
 604         }
 605
 606         return 0;
 607 }
 608
 609 arch_initcall(signal32_init);