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 Ralf Baechle 8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc. 9 */ 10 #include <linux/cache.h> 11 #include <linux/irqflags.h> 12 #include <linux/sched.h> 13 #include <linux/mm.h> 14 #include <linux/personality.h> 15 #include <linux/smp.h> 16 #include <linux/kernel.h> 17 #include <linux/signal.h> 18 #include <linux/errno.h> 19 #include <linux/wait.h> 20 #include <linux/ptrace.h> 21 #include <linux/unistd.h> 22 #include <linux/compiler.h> 23 #include <linux/syscalls.h> 24 #include <linux/uaccess.h> 25 #include <linux/tracehook.h> 26 27 #include <asm/abi.h> 28 #include <asm/asm.h> 29 #include <linux/bitops.h> 30 #include <asm/cacheflush.h> 31 #include <asm/fpu.h> 32 #include <asm/sim.h> 33 #include <asm/ucontext.h> 34 #include <asm/cpu-features.h> 35 #include <asm/war.h> 36 #include <asm/vdso.h> 37 #include <asm/dsp.h> 38 #include <asm/inst.h> 39 40 #include "signal-common.h" 41 42 static int (*save_fp_context)(struct sigcontext __user *sc); 43 static int (*restore_fp_context)(struct sigcontext __user *sc); 44 45 extern asmlinkage int _save_fp_context(struct sigcontext __user *sc); 46 extern asmlinkage int _restore_fp_context(struct sigcontext __user *sc); 47 48 extern asmlinkage int fpu_emulator_save_context(struct sigcontext __user *sc); 49 extern asmlinkage int fpu_emulator_restore_context(struct sigcontext __user *sc); 50 51 struct sigframe { 52 u32 sf_ass[4]; /* argument save space for o32 */ 53 u32 sf_pad[2]; /* Was: signal trampoline */ 54 struct sigcontext sf_sc; 55 sigset_t sf_mask; 56 }; 57 58 struct rt_sigframe { 59 u32 rs_ass[4]; /* argument save space for o32 */ 60 u32 rs_pad[2]; /* Was: signal trampoline */ 61 struct siginfo rs_info; 62 struct ucontext rs_uc; 63 }; 64 65 /* 66 * Helper routines 67 */ 68 static int protected_save_fp_context(struct sigcontext __user *sc) 69 { 70 int err; 71 while (1) { 72 lock_fpu_owner(); 73 own_fpu_inatomic(1); 74 err = save_fp_context(sc); /* this might fail */ 75 unlock_fpu_owner(); 76 if (likely(!err)) 77 break; 78 /* touch the sigcontext and try again */ 79 err = __put_user(0, &sc->sc_fpregs[0]) | 80 __put_user(0, &sc->sc_fpregs[31]) | 81 __put_user(0, &sc->sc_fpc_csr); 82 if (err) 83 break; /* really bad sigcontext */ 84 } 85 return err; 86 } 87 88 static int protected_restore_fp_context(struct sigcontext __user *sc) 89 { 90 int err, tmp __maybe_unused; 91 while (1) { 92 lock_fpu_owner(); 93 own_fpu_inatomic(0); 94 err = restore_fp_context(sc); /* this might fail */ 95 unlock_fpu_owner(); 96 if (likely(!err)) 97 break; 98 /* touch the sigcontext and try again */ 99 err = __get_user(tmp, &sc->sc_fpregs[0]) | 100 __get_user(tmp, &sc->sc_fpregs[31]) | 101 __get_user(tmp, &sc->sc_fpc_csr); 102 if (err) 103 break; /* really bad sigcontext */ 104 } 105 return err; 106 } 107 108 int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) 109 { 110 int err = 0; 111 int i; 112 unsigned int used_math; 113 114 err |= __put_user(regs->cp0_epc, &sc->sc_pc); 115 116 err |= __put_user(0, &sc->sc_regs[0]); 117 for (i = 1; i < 32; i++) 118 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); 119 120 #ifdef CONFIG_CPU_HAS_SMARTMIPS 121 err |= __put_user(regs->acx, &sc->sc_acx); 122 #endif 123 err |= __put_user(regs->hi, &sc->sc_mdhi); 124 err |= __put_user(regs->lo, &sc->sc_mdlo); 125 if (cpu_has_dsp) { 126 err |= __put_user(mfhi1(), &sc->sc_hi1); 127 err |= __put_user(mflo1(), &sc->sc_lo1); 128 err |= __put_user(mfhi2(), &sc->sc_hi2); 129 err |= __put_user(mflo2(), &sc->sc_lo2); 130 err |= __put_user(mfhi3(), &sc->sc_hi3); 131 err |= __put_user(mflo3(), &sc->sc_lo3); 132 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 133 } 134 135 used_math = !!used_math(); 136 err |= __put_user(used_math, &sc->sc_used_math); 137 138 if (used_math) { 139 /* 140 * Save FPU state to signal context. Signal handler 141 * will "inherit" current FPU state. 142 */ 143 err |= protected_save_fp_context(sc); 144 } 145 return err; 146 } 147 148 int fpcsr_pending(unsigned int __user *fpcsr) 149 { 150 int err, sig = 0; 151 unsigned int csr, enabled; 152 153 err = __get_user(csr, fpcsr); 154 enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5); 155 /* 156 * If the signal handler set some FPU exceptions, clear it and 157 * send SIGFPE. 158 */ 159 if (csr & enabled) { 160 csr &= ~enabled; 161 err |= __put_user(csr, fpcsr); 162 sig = SIGFPE; 163 } 164 return err ?: sig; 165 } 166 167 static int 168 check_and_restore_fp_context(struct sigcontext __user *sc) 169 { 170 int err, sig; 171 172 err = sig = fpcsr_pending(&sc->sc_fpc_csr); 173 if (err > 0) 174 err = 0; 175 err |= protected_restore_fp_context(sc); 176 return err ?: sig; 177 } 178 179 int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) 180 { 181 unsigned int used_math; 182 unsigned long treg; 183 int err = 0; 184 int i; 185 186 /* Always make any pending restarted system calls return -EINTR */ 187 current_thread_info()->restart_block.fn = do_no_restart_syscall; 188 189 err |= __get_user(regs->cp0_epc, &sc->sc_pc); 190 191 #ifdef CONFIG_CPU_HAS_SMARTMIPS 192 err |= __get_user(regs->acx, &sc->sc_acx); 193 #endif 194 err |= __get_user(regs->hi, &sc->sc_mdhi); 195 err |= __get_user(regs->lo, &sc->sc_mdlo); 196 if (cpu_has_dsp) { 197 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 198 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 199 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 200 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 201 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 202 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 203 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 204 } 205 206 for (i = 1; i < 32; i++) 207 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); 208 209 err |= __get_user(used_math, &sc->sc_used_math); 210 conditional_used_math(used_math); 211 212 if (used_math) { 213 /* restore fpu context if we have used it before */ 214 if (!err) 215 err = check_and_restore_fp_context(sc); 216 } else { 217 /* signal handler may have used FPU. Give it up. */ 218 lose_fpu(0); 219 } 220 221 return err; 222 } 223 224 void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, 225 size_t frame_size) 226 { 227 unsigned long sp; 228 229 /* Default to using normal stack */ 230 sp = regs->regs[29]; 231 232 /* 233 * FPU emulator may have it's own trampoline active just 234 * above the user stack, 16-bytes before the next lowest 235 * 16 byte boundary. Try to avoid trashing it. 236 */ 237 sp -= 32; 238 239 /* This is the X/Open sanctioned signal stack switching. */ 240 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0)) 241 sp = current->sas_ss_sp + current->sas_ss_size; 242 243 return (void __user *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? ~(cpu_icache_line_size()-1) : ALMASK)); 244 } 245 246 /* 247 * Atomically swap in the new signal mask, and wait for a signal. 248 */ 249 250 #ifdef CONFIG_TRAD_SIGNALS 251 SYSCALL_DEFINE1(sigsuspend, sigset_t __user *, uset) 252 { 253 return sys_rt_sigsuspend(uset, sizeof(sigset_t)); 254 } 255 #endif 256 257 #ifdef CONFIG_TRAD_SIGNALS 258 SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act, 259 struct sigaction __user *, oact) 260 { 261 struct k_sigaction new_ka, old_ka; 262 int ret; 263 int err = 0; 264 265 if (act) { 266 old_sigset_t mask; 267 268 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 269 return -EFAULT; 270 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler); 271 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 272 err |= __get_user(mask, &act->sa_mask.sig[0]); 273 if (err) 274 return -EFAULT; 275 276 siginitset(&new_ka.sa.sa_mask, mask); 277 } 278 279 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 280 281 if (!ret && oact) { 282 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 283 return -EFAULT; 284 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 285 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler); 286 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig); 287 err |= __put_user(0, &oact->sa_mask.sig[1]); 288 err |= __put_user(0, &oact->sa_mask.sig[2]); 289 err |= __put_user(0, &oact->sa_mask.sig[3]); 290 if (err) 291 return -EFAULT; 292 } 293 294 return ret; 295 } 296 #endif 297 298 #ifdef CONFIG_TRAD_SIGNALS 299 asmlinkage void sys_sigreturn(nabi_no_regargs struct pt_regs regs) 300 { 301 struct sigframe __user *frame; 302 sigset_t blocked; 303 int sig; 304 305 frame = (struct sigframe __user *) regs.regs[29]; 306 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 307 goto badframe; 308 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked))) 309 goto badframe; 310 311 set_current_blocked(&blocked); 312 313 sig = restore_sigcontext(®s, &frame->sf_sc); 314 if (sig < 0) 315 goto badframe; 316 else if (sig) 317 force_sig(sig, current); 318 319 /* 320 * Don't let your children do this ... 321 */ 322 __asm__ __volatile__( 323 "move\t$29, %0\n\t" 324 "j\tsyscall_exit" 325 :/* no outputs */ 326 :"r" (®s)); 327 /* Unreached */ 328 329 badframe: 330 force_sig(SIGSEGV, current); 331 } 332 #endif /* CONFIG_TRAD_SIGNALS */ 333 334 asmlinkage void sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs) 335 { 336 struct rt_sigframe __user *frame; 337 sigset_t set; 338 int sig; 339 340 frame = (struct rt_sigframe __user *) regs.regs[29]; 341 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 342 goto badframe; 343 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set))) 344 goto badframe; 345 346 set_current_blocked(&set); 347 348 sig = restore_sigcontext(®s, &frame->rs_uc.uc_mcontext); 349 if (sig < 0) 350 goto badframe; 351 else if (sig) 352 force_sig(sig, current); 353 354 if (restore_altstack(&frame->rs_uc.uc_stack)) 355 goto badframe; 356 357 /* 358 * Don't let your children do this ... 359 */ 360 __asm__ __volatile__( 361 "move\t$29, %0\n\t" 362 "j\tsyscall_exit" 363 :/* no outputs */ 364 :"r" (®s)); 365 /* Unreached */ 366 367 badframe: 368 force_sig(SIGSEGV, current); 369 } 370 371 #ifdef CONFIG_TRAD_SIGNALS 372 static int setup_frame(void *sig_return, struct k_sigaction *ka, 373 struct pt_regs *regs, int signr, sigset_t *set) 374 { 375 struct sigframe __user *frame; 376 int err = 0; 377 378 frame = get_sigframe(ka, regs, sizeof(*frame)); 379 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 380 goto give_sigsegv; 381 382 err |= setup_sigcontext(regs, &frame->sf_sc); 383 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set)); 384 if (err) 385 goto give_sigsegv; 386 387 /* 388 * Arguments to signal handler: 389 * 390 * a0 = signal number 391 * a1 = 0 (should be cause) 392 * a2 = pointer to struct sigcontext 393 * 394 * $25 and c0_epc point to the signal handler, $29 points to the 395 * struct sigframe. 396 */ 397 regs->regs[ 4] = signr; 398 regs->regs[ 5] = 0; 399 regs->regs[ 6] = (unsigned long) &frame->sf_sc; 400 regs->regs[29] = (unsigned long) frame; 401 regs->regs[31] = (unsigned long) sig_return; 402 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 403 404 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 405 current->comm, current->pid, 406 frame, regs->cp0_epc, regs->regs[31]); 407 return 0; 408 409 give_sigsegv: 410 force_sigsegv(signr, current); 411 return -EFAULT; 412 } 413 #endif 414 415 static int setup_rt_frame(void *sig_return, struct k_sigaction *ka, 416 struct pt_regs *regs, int signr, sigset_t *set, 417 siginfo_t *info) 418 { 419 struct rt_sigframe __user *frame; 420 int err = 0; 421 422 frame = get_sigframe(ka, regs, sizeof(*frame)); 423 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 424 goto give_sigsegv; 425 426 /* Create siginfo. */ 427 err |= copy_siginfo_to_user(&frame->rs_info, info); 428 429 /* Create the ucontext. */ 430 err |= __put_user(0, &frame->rs_uc.uc_flags); 431 err |= __put_user(NULL, &frame->rs_uc.uc_link); 432 err |= __save_altstack(&frame->rs_uc.uc_stack, regs->regs[29]); 433 err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext); 434 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set)); 435 436 if (err) 437 goto give_sigsegv; 438 439 /* 440 * Arguments to signal handler: 441 * 442 * a0 = signal number 443 * a1 = 0 (should be cause) 444 * a2 = pointer to ucontext 445 * 446 * $25 and c0_epc point to the signal handler, $29 points to 447 * the struct rt_sigframe. 448 */ 449 regs->regs[ 4] = signr; 450 regs->regs[ 5] = (unsigned long) &frame->rs_info; 451 regs->regs[ 6] = (unsigned long) &frame->rs_uc; 452 regs->regs[29] = (unsigned long) frame; 453 regs->regs[31] = (unsigned long) sig_return; 454 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 455 456 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 457 current->comm, current->pid, 458 frame, regs->cp0_epc, regs->regs[31]); 459 460 return 0; 461 462 give_sigsegv: 463 force_sigsegv(signr, current); 464 return -EFAULT; 465 } 466 467 struct mips_abi mips_abi = { 468 #ifdef CONFIG_TRAD_SIGNALS 469 .setup_frame = setup_frame, 470 .signal_return_offset = offsetof(struct mips_vdso, signal_trampoline), 471 #endif 472 .setup_rt_frame = setup_rt_frame, 473 .rt_signal_return_offset = 474 offsetof(struct mips_vdso, rt_signal_trampoline), 475 .restart = __NR_restart_syscall 476 }; 477 478 static void handle_signal(unsigned long sig, siginfo_t *info, 479 struct k_sigaction *ka, struct pt_regs *regs) 480 { 481 sigset_t *oldset = sigmask_to_save(); 482 int ret; 483 struct mips_abi *abi = current->thread.abi; 484 #ifdef CONFIG_CPU_MICROMIPS 485 void *vdso; 486 unsigned int tmp = (unsigned int)current->mm->context.vdso; 487 488 set_isa16_mode(tmp); 489 vdso = (void *)tmp; 490 #else 491 void *vdso = current->mm->context.vdso; 492 #endif 493 494 if (regs->regs[0]) { 495 switch(regs->regs[2]) { 496 case ERESTART_RESTARTBLOCK: 497 case ERESTARTNOHAND: 498 regs->regs[2] = EINTR; 499 break; 500 case ERESTARTSYS: 501 if (!(ka->sa.sa_flags & SA_RESTART)) { 502 regs->regs[2] = EINTR; 503 break; 504 } 505 /* fallthrough */ 506 case ERESTARTNOINTR: 507 regs->regs[7] = regs->regs[26]; 508 regs->regs[2] = regs->regs[0]; 509 regs->cp0_epc -= 4; 510 } 511 512 regs->regs[0] = 0; /* Don't deal with this again. */ 513 } 514 515 if (sig_uses_siginfo(ka)) 516 ret = abi->setup_rt_frame(vdso + abi->rt_signal_return_offset, 517 ka, regs, sig, oldset, info); 518 else 519 ret = abi->setup_frame(vdso + abi->signal_return_offset, 520 ka, regs, sig, oldset); 521 522 if (ret) 523 return; 524 525 signal_delivered(sig, info, ka, regs, 0); 526 } 527 528 static void do_signal(struct pt_regs *regs) 529 { 530 struct k_sigaction ka; 531 siginfo_t info; 532 int signr; 533 534 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 535 if (signr > 0) { 536 /* Whee! Actually deliver the signal. */ 537 handle_signal(signr, &info, &ka, regs); 538 return; 539 } 540 541 if (regs->regs[0]) { 542 switch (regs->regs[2]) { 543 case ERESTARTNOHAND: 544 case ERESTARTSYS: 545 case ERESTARTNOINTR: 546 regs->regs[2] = regs->regs[0]; 547 regs->regs[7] = regs->regs[26]; 548 regs->cp0_epc -= 4; 549 break; 550 551 case ERESTART_RESTARTBLOCK: 552 regs->regs[2] = current->thread.abi->restart; 553 regs->regs[7] = regs->regs[26]; 554 regs->cp0_epc -= 4; 555 break; 556 } 557 regs->regs[0] = 0; /* Don't deal with this again. */ 558 } 559 560 /* 561 * If there's no signal to deliver, we just put the saved sigmask 562 * back 563 */ 564 restore_saved_sigmask(); 565 } 566 567 /* 568 * notification of userspace execution resumption 569 * - triggered by the TIF_WORK_MASK flags 570 */ 571 asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused, 572 __u32 thread_info_flags) 573 { 574 local_irq_enable(); 575 576 /* deal with pending signal delivery */ 577 if (thread_info_flags & _TIF_SIGPENDING) 578 do_signal(regs); 579 580 if (thread_info_flags & _TIF_NOTIFY_RESUME) { 581 clear_thread_flag(TIF_NOTIFY_RESUME); 582 tracehook_notify_resume(regs); 583 } 584 } 585 586 #ifdef CONFIG_SMP 587 static int smp_save_fp_context(struct sigcontext __user *sc) 588 { 589 return raw_cpu_has_fpu 590 ? _save_fp_context(sc) 591 : fpu_emulator_save_context(sc); 592 } 593 594 static int smp_restore_fp_context(struct sigcontext __user *sc) 595 { 596 return raw_cpu_has_fpu 597 ? _restore_fp_context(sc) 598 : fpu_emulator_restore_context(sc); 599 } 600 #endif 601 602 static int signal_setup(void) 603 { 604 #ifdef CONFIG_SMP 605 /* For now just do the cpu_has_fpu check when the functions are invoked */ 606 save_fp_context = smp_save_fp_context; 607 restore_fp_context = smp_restore_fp_context; 608 #else 609 if (cpu_has_fpu) { 610 save_fp_context = _save_fp_context; 611 restore_fp_context = _restore_fp_context; 612 } else { 613 save_fp_context = fpu_emulator_save_context; 614 restore_fp_context = fpu_emulator_restore_context; 615 } 616 #endif 617 618 return 0; 619 } 620 621 arch_initcall(signal_setup); 622