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 < NUM_FPU_REGS; 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 < NUM_FPU_REGS; 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                 if (is_fpu_owner()) {
 122                         err = save_fp_context32(sc);
 123                         unlock_fpu_owner();
 124                 } else {
 125                         unlock_fpu_owner();
 126                         err = copy_fp_to_sigcontext32(sc);
 127                 }
 128                 if (likely(!err))
 129                         break;
 130                 /* touch the sigcontext and try again */
 131                 err = __put_user(0, &sc->sc_fpregs[0]) |
 132                         __put_user(0, &sc->sc_fpregs[31]) |
 133                         __put_user(0, &sc->sc_fpc_csr);
 134                 if (err)
 135                         break;  /* really bad sigcontext */
 136         }
 137         return err;
 138 }
 139
 140 static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
 141 {
 142         int err, tmp __maybe_unused;
 143         while (1) {
 144                 lock_fpu_owner();
 145                 if (is_fpu_owner()) {
 146                         err = restore_fp_context32(sc);
 147                         unlock_fpu_owner();
 148                 } else {
 149                         unlock_fpu_owner();
 150                         err = copy_fp_from_sigcontext32(sc);
 151                 }
 152                 if (likely(!err))
 153                         break;
 154                 /* touch the sigcontext and try again */
 155                 err = __get_user(tmp, &sc->sc_fpregs[0]) |
 156                         __get_user(tmp, &sc->sc_fpregs[31]) |
 157                         __get_user(tmp, &sc->sc_fpc_csr);
 158                 if (err)
 159                         break;  /* really bad sigcontext */
 160         }
 161         return err;
 162 }
 163
 164 static int setup_sigcontext32(struct pt_regs *regs,
 165                               struct sigcontext32 __user *sc)
 166 {
 167         int err = 0;
 168         int i;
 169         u32 used_math;
 170
 171         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
 172
 173         err |= __put_user(0, &sc->sc_regs[0]);
 174         for (i = 1; i < 32; i++)
 175                 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
 176
 177         err |= __put_user(regs->hi, &sc->sc_mdhi);
 178         err |= __put_user(regs->lo, &sc->sc_mdlo);
 179         if (cpu_has_dsp) {
 180                 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
 181                 err |= __put_user(mfhi1(), &sc->sc_hi1);
 182                 err |= __put_user(mflo1(), &sc->sc_lo1);
 183                 err |= __put_user(mfhi2(), &sc->sc_hi2);
 184                 err |= __put_user(mflo2(), &sc->sc_lo2);
 185                 err |= __put_user(mfhi3(), &sc->sc_hi3);
 186                 err |= __put_user(mflo3(), &sc->sc_lo3);
 187         }
 188
 189         used_math = !!used_math();
 190         err |= __put_user(used_math, &sc->sc_used_math);
 191
 192         if (used_math) {
 193                 /*
 194                  * Save FPU state to signal context.  Signal handler
 195                  * will "inherit" current FPU state.
 196                  */
 197                 err |= protected_save_fp_context32(sc);
 198         }
 199         return err;
 200 }
 201
 202 static int
 203 check_and_restore_fp_context32(struct sigcontext32 __user *sc)
 204 {
 205         int err, sig;
 206
 207         err = sig = fpcsr_pending(&sc->sc_fpc_csr);
 208         if (err > 0)
 209                 err = 0;
 210         err |= protected_restore_fp_context32(sc);
 211         return err ?: sig;
 212 }
 213
 214 static int restore_sigcontext32(struct pt_regs *regs,
 215                                 struct sigcontext32 __user *sc)
 216 {
 217         u32 used_math;
 218         int err = 0;
 219         s32 treg;
 220         int i;
 221
 222         /* Always make any pending restarted system calls return -EINTR */
 223         current->restart_block.fn = do_no_restart_syscall;
 224
 225         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 226         err |= __get_user(regs->hi, &sc->sc_mdhi);
 227         err |= __get_user(regs->lo, &sc->sc_mdlo);
 228         if (cpu_has_dsp) {
 229                 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
 230                 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
 231                 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
 232                 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
 233                 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
 234                 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
 235                 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
 236         }
 237
 238         for (i = 1; i < 32; i++)
 239                 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
 240
 241         err |= __get_user(used_math, &sc->sc_used_math);
 242         conditional_used_math(used_math);
 243
 244         if (used_math) {
 245                 /* restore fpu context if we have used it before */
 246                 if (!err)
 247                         err = check_and_restore_fp_context32(sc);
 248         } else {
 249                 /* signal handler may have used FPU.  Give it up. */
 250                 lose_fpu(0);
 251         }
 252
 253         return err;
 254 }
 255
 256 /*
 257  *
 258  */
 259 extern void __put_sigset_unknown_nsig(void);
 260 extern void __get_sigset_unknown_nsig(void);
 261
 262 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
 263 {
 264         int err = 0;
 265
 266         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
 267                 return -EFAULT;
 268
 269         switch (_NSIG_WORDS) {
 270         default:
 271                 __put_sigset_unknown_nsig();
 272         case 2:
 273                 err |= __put_user(kbuf->sig[1] >> 32, &ubuf->sig[3]);
 274                 err |= __put_user(kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
 275         case 1:
 276                 err |= __put_user(kbuf->sig[0] >> 32, &ubuf->sig[1]);
 277                 err |= __put_user(kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
 278         }
 279
 280         return err;
 281 }
 282
 283 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
 284 {
 285         int err = 0;
 286         unsigned long sig[4];
 287
 288         if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
 289                 return -EFAULT;
 290
 291         switch (_NSIG_WORDS) {
 292         default:
 293                 __get_sigset_unknown_nsig();
 294         case 2:
 295                 err |= __get_user(sig[3], &ubuf->sig[3]);
 296                 err |= __get_user(sig[2], &ubuf->sig[2]);
 297                 kbuf->sig[1] = sig[2] | (sig[3] << 32);
 298         case 1:
 299                 err |= __get_user(sig[1], &ubuf->sig[1]);
 300                 err |= __get_user(sig[0], &ubuf->sig[0]);
 301                 kbuf->sig[0] = sig[0] | (sig[1] << 32);
 302         }
 303
 304         return err;
 305 }
 306
 307 /*
 308  * Atomically swap in the new signal mask, and wait for a signal.
 309  */
 310
 311 asmlinkage int sys32_sigsuspend(compat_sigset_t __user *uset)
 312 {
 313         return compat_sys_rt_sigsuspend(uset, sizeof(compat_sigset_t));
 314 }
 315
 316 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct compat_sigaction __user *, act,
 317         struct compat_sigaction __user *, oact)
 318 {
 319         struct k_sigaction new_ka, old_ka;
 320         int ret;
 321         int err = 0;
 322
 323         if (act) {
 324                 old_sigset_t mask;
 325                 s32 handler;
 326
 327                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 328                         return -EFAULT;
 329                 err |= __get_user(handler, &act->sa_handler);
 330                 new_ka.sa.sa_handler = (void __user *)(s64)handler;
 331                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 332                 err |= __get_user(mask, &act->sa_mask.sig[0]);
 333                 if (err)
 334                         return -EFAULT;
 335
 336                 siginitset(&new_ka.sa.sa_mask, mask);
 337         }
 338
 339         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 340
 341         if (!ret && oact) {
 342                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 343                         return -EFAULT;
 344                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 345                 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
 346                                   &oact->sa_handler);
 347                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
 348                 err |= __put_user(0, &oact->sa_mask.sig[1]);
 349                 err |= __put_user(0, &oact->sa_mask.sig[2]);
 350                 err |= __put_user(0, &oact->sa_mask.sig[3]);
 351                 if (err)
 352                         return -EFAULT;
 353         }
 354
 355         return ret;
 356 }
 357
 358 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
 359 {
 360         int err;
 361
 362         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
 363                 return -EFAULT;
 364
 365         /* If you change siginfo_t structure, please be sure
 366            this code is fixed accordingly.
 367            It should never copy any pad contained in the structure
 368            to avoid security leaks, but must copy the generic
 369            3 ints plus the relevant union member.
 370            This routine must convert siginfo from 64bit to 32bit as well
 371            at the same time.  */
 372         err = __put_user(from->si_signo, &to->si_signo);
 373         err |= __put_user(from->si_errno, &to->si_errno);
 374         err |= __put_user((short)from->si_code, &to->si_code);
 375         if (from->si_code < 0)
 376                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 377         else {
 378                 switch (from->si_code >> 16) {
 379                 case __SI_TIMER >> 16:
 380                         err |= __put_user(from->si_tid, &to->si_tid);
 381                         err |= __put_user(from->si_overrun, &to->si_overrun);
 382                         err |= __put_user(from->si_int, &to->si_int);
 383                         break;
 384                 case __SI_CHLD >> 16:
 385                         err |= __put_user(from->si_utime, &to->si_utime);
 386                         err |= __put_user(from->si_stime, &to->si_stime);
 387                         err |= __put_user(from->si_status, &to->si_status);
 388                 default:
 389                         err |= __put_user(from->si_pid, &to->si_pid);
 390                         err |= __put_user(from->si_uid, &to->si_uid);
 391                         break;
 392                 case __SI_FAULT >> 16:
 393                         err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
 394                         break;
 395                 case __SI_POLL >> 16:
 396                         err |= __put_user(from->si_band, &to->si_band);
 397                         err |= __put_user(from->si_fd, &to->si_fd);
 398                         break;
 399                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 400                 case __SI_MESGQ >> 16:
 401                         err |= __put_user(from->si_pid, &to->si_pid);
 402                         err |= __put_user(from->si_uid, &to->si_uid);
 403                         err |= __put_user(from->si_int, &to->si_int);
 404                         break;
 405                 }
 406         }
 407         return err;
 408 }
 409
 410 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 411 {
 412         memset(to, 0, sizeof *to);
 413
 414         if (copy_from_user(to, from, 3*sizeof(int)) ||
 415             copy_from_user(to->_sifields._pad,
 416                            from->_sifields._pad, SI_PAD_SIZE32))
 417                 return -EFAULT;
 418
 419         return 0;
 420 }
 421
 422 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 423 {
 424         struct sigframe32 __user *frame;
 425         sigset_t blocked;
 426         int sig;
 427
 428         frame = (struct sigframe32 __user *) regs.regs[29];
 429         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 430                 goto badframe;
 431         if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
 432                 goto badframe;
 433
 434         set_current_blocked(&blocked);
 435
 436         sig = restore_sigcontext32(&regs, &frame->sf_sc);
 437         if (sig < 0)
 438                 goto badframe;
 439         else if (sig)
 440                 force_sig(sig, current);
 441
 442         /*
 443          * Don't let your children do this ...
 444          */
 445         __asm__ __volatile__(
 446                 "move\t$29, %0\n\t"
 447                 "j\tsyscall_exit"
 448                 :/* no outputs */
 449                 :"r" (&regs));
 450         /* Unreached */
 451
 452 badframe:
 453         force_sig(SIGSEGV, current);
 454 }
 455
 456 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 457 {
 458         struct rt_sigframe32 __user *frame;
 459         sigset_t set;
 460         int sig;
 461
 462         frame = (struct rt_sigframe32 __user *) regs.regs[29];
 463         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 464                 goto badframe;
 465         if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
 466                 goto badframe;
 467
 468         set_current_blocked(&set);
 469
 470         sig = restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext);
 471         if (sig < 0)
 472                 goto badframe;
 473         else if (sig)
 474                 force_sig(sig, current);
 475
 476         if (compat_restore_altstack(&frame->rs_uc.uc_stack))
 477                 goto badframe;
 478
 479         /*
 480          * Don't let your children do this ...
 481          */
 482         __asm__ __volatile__(
 483                 "move\t$29, %0\n\t"
 484                 "j\tsyscall_exit"
 485                 :/* no outputs */
 486                 :"r" (&regs));
 487         /* Unreached */
 488
 489 badframe:
 490         force_sig(SIGSEGV, current);
 491 }
 492
 493 static int setup_frame_32(void *sig_return, struct ksignal *ksig,
 494                           struct pt_regs *regs, sigset_t *set)
 495 {
 496         struct sigframe32 __user *frame;
 497         int err = 0;
 498
 499         frame = get_sigframe(ksig, regs, sizeof(*frame));
 500         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 501                 return -EFAULT;
 502
 503         err |= setup_sigcontext32(regs, &frame->sf_sc);
 504         err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
 505
 506         if (err)
 507                 return -EFAULT;
 508
 509         /*
 510          * Arguments to signal handler:
 511          *
 512          *   a0 = signal number
 513          *   a1 = 0 (should be cause)
 514          *   a2 = pointer to struct sigcontext
 515          *
 516          * $25 and c0_epc point to the signal handler, $29 points to the
 517          * struct sigframe.
 518          */
 519         regs->regs[ 4] = ksig->sig;
 520         regs->regs[ 5] = 0;
 521         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 522         regs->regs[29] = (unsigned long) frame;
 523         regs->regs[31] = (unsigned long) sig_return;
 524         regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
 525
 526         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 527                current->comm, current->pid,
 528                frame, regs->cp0_epc, regs->regs[31]);
 529
 530         return 0;
 531 }
 532
 533 static int setup_rt_frame_32(void *sig_return, struct ksignal *ksig,
 534                              struct pt_regs *regs, sigset_t *set)
 535 {
 536         struct rt_sigframe32 __user *frame;
 537         int err = 0;
 538
 539         frame = get_sigframe(ksig, regs, sizeof(*frame));
 540         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 541                 return -EFAULT;
 542
 543         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
 544         err |= copy_siginfo_to_user32(&frame->rs_info, &ksig->info);
 545
 546         /* Create the ucontext.  */
 547         err |= __put_user(0, &frame->rs_uc.uc_flags);
 548         err |= __put_user(0, &frame->rs_uc.uc_link);
 549         err |= __compat_save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
 550         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 551         err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
 552
 553         if (err)
 554                 return -EFAULT;
 555
 556         /*
 557          * Arguments to signal handler:
 558          *
 559          *   a0 = signal number
 560          *   a1 = 0 (should be cause)
 561          *   a2 = pointer to ucontext
 562          *
 563          * $25 and c0_epc point to the signal handler, $29 points to
 564          * the struct rt_sigframe32.
 565          */
 566         regs->regs[ 4] = ksig->sig;
 567         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 568         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 569         regs->regs[29] = (unsigned long) frame;
 570         regs->regs[31] = (unsigned long) sig_return;
 571         regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
 572
 573         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 574                current->comm, current->pid,
 575                frame, regs->cp0_epc, regs->regs[31]);
 576
 577         return 0;
 578 }
 579
 580 /*
 581  * o32 compatibility on 64-bit kernels, without DSP ASE
 582  */
 583 struct mips_abi mips_abi_32 = {
 584         .setup_frame    = setup_frame_32,
 585         .signal_return_offset =
 586                 offsetof(struct mips_vdso, o32_signal_trampoline),
 587         .setup_rt_frame = setup_rt_frame_32,
 588         .rt_signal_return_offset =
 589                 offsetof(struct mips_vdso, o32_rt_signal_trampoline),
 590         .restart        = __NR_O32_restart_syscall
 591 };
 592
 593 static int signal32_init(void)
 594 {
 595         if (cpu_has_fpu) {
 596                 save_fp_context32 = _save_fp_context32;
 597                 restore_fp_context32 = _restore_fp_context32;
 598         } else {
 599                 save_fp_context32 = copy_fp_to_sigcontext32;
 600                 restore_fp_context32 = copy_fp_from_sigcontext32;
 601         }
 602
 603         return 0;
 604 }
 605
 606 arch_initcall(signal32_init);