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