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