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(¤t->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(¤t->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_thread_info()->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(®s, &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" (®s)); 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(®s, &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" (®s)); 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); 607