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         if (copy_from_user(to, from, 3*sizeof(int)) ||
 413             copy_from_user(to->_sifields._pad,
 414                            from->_sifields._pad, SI_PAD_SIZE32))
 415                 return -EFAULT;
 416
 417         return 0;
 418 }
 419
 420 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
 421 {
 422         struct sigframe32 __user *frame;
 423         sigset_t blocked;
 424         int sig;
 425
 426         frame = (struct sigframe32 __user *) regs.regs[29];
 427         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 428                 goto badframe;
 429         if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
 430                 goto badframe;
 431
 432         set_current_blocked(&blocked);
 433
 434         sig = restore_sigcontext32(&regs, &frame->sf_sc);
 435         if (sig < 0)
 436                 goto badframe;
 437         else if (sig)
 438                 force_sig(sig, current);
 439
 440         /*
 441          * Don't let your children do this ...
 442          */
 443         __asm__ __volatile__(
 444                 "move\t$29, %0\n\t"
 445                 "j\tsyscall_exit"
 446                 :/* no outputs */
 447                 :"r" (&regs));
 448         /* Unreached */
 449
 450 badframe:
 451         force_sig(SIGSEGV, current);
 452 }
 453
 454 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
 455 {
 456         struct rt_sigframe32 __user *frame;
 457         sigset_t set;
 458         int sig;
 459
 460         frame = (struct rt_sigframe32 __user *) regs.regs[29];
 461         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 462                 goto badframe;
 463         if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
 464                 goto badframe;
 465
 466         set_current_blocked(&set);
 467
 468         sig = restore_sigcontext32(&regs, &frame->rs_uc.uc_mcontext);
 469         if (sig < 0)
 470                 goto badframe;
 471         else if (sig)
 472                 force_sig(sig, current);
 473
 474         if (compat_restore_altstack(&frame->rs_uc.uc_stack))
 475                 goto badframe;
 476
 477         /*
 478          * Don't let your children do this ...
 479          */
 480         __asm__ __volatile__(
 481                 "move\t$29, %0\n\t"
 482                 "j\tsyscall_exit"
 483                 :/* no outputs */
 484                 :"r" (&regs));
 485         /* Unreached */
 486
 487 badframe:
 488         force_sig(SIGSEGV, current);
 489 }
 490
 491 static int setup_frame_32(void *sig_return, struct ksignal *ksig,
 492                           struct pt_regs *regs, sigset_t *set)
 493 {
 494         struct sigframe32 __user *frame;
 495         int err = 0;
 496
 497         frame = get_sigframe(ksig, regs, sizeof(*frame));
 498         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 499                 return -EFAULT;
 500
 501         err |= setup_sigcontext32(regs, &frame->sf_sc);
 502         err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
 503
 504         if (err)
 505                 return -EFAULT;
 506
 507         /*
 508          * Arguments to signal handler:
 509          *
 510          *   a0 = signal number
 511          *   a1 = 0 (should be cause)
 512          *   a2 = pointer to struct sigcontext
 513          *
 514          * $25 and c0_epc point to the signal handler, $29 points to the
 515          * struct sigframe.
 516          */
 517         regs->regs[ 4] = ksig->sig;
 518         regs->regs[ 5] = 0;
 519         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 520         regs->regs[29] = (unsigned long) frame;
 521         regs->regs[31] = (unsigned long) sig_return;
 522         regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
 523
 524         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 525                current->comm, current->pid,
 526                frame, regs->cp0_epc, regs->regs[31]);
 527
 528         return 0;
 529 }
 530
 531 static int setup_rt_frame_32(void *sig_return, struct ksignal *ksig,
 532                              struct pt_regs *regs, sigset_t *set)
 533 {
 534         struct rt_sigframe32 __user *frame;
 535         int err = 0;
 536
 537         frame = get_sigframe(ksig, regs, sizeof(*frame));
 538         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 539                 return -EFAULT;
 540
 541         /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
 542         err |= copy_siginfo_to_user32(&frame->rs_info, &ksig->info);
 543
 544         /* Create the ucontext.  */
 545         err |= __put_user(0, &frame->rs_uc.uc_flags);
 546         err |= __put_user(0, &frame->rs_uc.uc_link);
 547         err |= __compat_save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]);
 548         err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
 549         err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
 550
 551         if (err)
 552                 return -EFAULT;
 553
 554         /*
 555          * Arguments to signal handler:
 556          *
 557          *   a0 = signal number
 558          *   a1 = 0 (should be cause)
 559          *   a2 = pointer to ucontext
 560          *
 561          * $25 and c0_epc point to the signal handler, $29 points to
 562          * the struct rt_sigframe32.
 563          */
 564         regs->regs[ 4] = ksig->sig;
 565         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 566         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 567         regs->regs[29] = (unsigned long) frame;
 568         regs->regs[31] = (unsigned long) sig_return;
 569         regs->cp0_epc = regs->regs[25] = (unsigned long) ksig->ka.sa.sa_handler;
 570
 571         DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
 572                current->comm, current->pid,
 573                frame, regs->cp0_epc, regs->regs[31]);
 574
 575         return 0;
 576 }
 577
 578 /*
 579  * o32 compatibility on 64-bit kernels, without DSP ASE
 580  */
 581 struct mips_abi mips_abi_32 = {
 582         .setup_frame    = setup_frame_32,
 583         .signal_return_offset =
 584                 offsetof(struct mips_vdso, o32_signal_trampoline),
 585         .setup_rt_frame = setup_rt_frame_32,
 586         .rt_signal_return_offset =
 587                 offsetof(struct mips_vdso, o32_rt_signal_trampoline),
 588         .restart        = __NR_O32_restart_syscall
 589 };
 590
 591 static int signal32_init(void)
 592 {
 593         if (cpu_has_fpu) {
 594                 save_fp_context32 = _save_fp_context32;
 595                 restore_fp_context32 = _restore_fp_context32;
 596         } else {
 597                 save_fp_context32 = copy_fp_to_sigcontext32;
 598                 restore_fp_context32 = copy_fp_from_sigcontext32;
 599         }
 600
 601         return 0;
 602 }
 603
 604 arch_initcall(signal32_init);