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/compat.h> 22 #include <linux/suspend.h> 23 #include <linux/compiler.h> 24 #include <linux/uaccess.h> 25 26 #include <asm/abi.h> 27 #include <asm/asm.h> 28 #include <asm/compat-signal.h> 29 #include <linux/bitops.h> 30 #include <asm/cacheflush.h> 31 #include <asm/sim.h> 32 #include <asm/ucontext.h> 33 #include <asm/system.h> 34 #include <asm/fpu.h> 35 #include <asm/war.h> 36 37 #include "signal-common.h" 38 39 /* 40 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ... 41 */ 42 #define __NR_O32_sigreturn 4119 43 #define __NR_O32_rt_sigreturn 4193 44 #define __NR_O32_restart_syscall 4253 45 46 /* 32-bit compatibility types */ 47 48 typedef unsigned int __sighandler32_t; 49 typedef void (*vfptr_t)(void); 50 51 struct sigaction32 { 52 unsigned int sa_flags; 53 __sighandler32_t sa_handler; 54 compat_sigset_t sa_mask; 55 }; 56 57 /* IRIX compatible stack_t */ 58 typedef struct sigaltstack32 { 59 s32 ss_sp; 60 compat_size_t ss_size; 61 int ss_flags; 62 } stack32_t; 63 64 struct ucontext32 { 65 u32 uc_flags; 66 s32 uc_link; 67 stack32_t uc_stack; 68 struct sigcontext32 uc_mcontext; 69 compat_sigset_t uc_sigmask; /* mask last for extensibility */ 70 }; 71 72 /* 73 * Horribly complicated - with the bloody RM9000 workarounds enabled 74 * the signal trampolines is moving to the end of the structure so we can 75 * increase the alignment without breaking software compatibility. 76 */ 77 #if ICACHE_REFILLS_WORKAROUND_WAR == 0 78 79 struct sigframe32 { 80 u32 sf_ass[4]; /* argument save space for o32 */ 81 u32 sf_code[2]; /* signal trampoline */ 82 struct sigcontext32 sf_sc; 83 compat_sigset_t sf_mask; 84 }; 85 86 struct rt_sigframe32 { 87 u32 rs_ass[4]; /* argument save space for o32 */ 88 u32 rs_code[2]; /* signal trampoline */ 89 compat_siginfo_t rs_info; 90 struct ucontext32 rs_uc; 91 }; 92 93 #else /* ICACHE_REFILLS_WORKAROUND_WAR */ 94 95 struct sigframe32 { 96 u32 sf_ass[4]; /* argument save space for o32 */ 97 u32 sf_pad[2]; 98 struct sigcontext32 sf_sc; /* hw context */ 99 compat_sigset_t sf_mask; 100 u32 sf_code[8] ____cacheline_aligned; /* signal trampoline */ 101 }; 102 103 struct rt_sigframe32 { 104 u32 rs_ass[4]; /* argument save space for o32 */ 105 u32 rs_pad[2]; 106 compat_siginfo_t rs_info; 107 struct ucontext32 rs_uc; 108 u32 rs_code[8] __attribute__((aligned(32))); /* signal trampoline */ 109 }; 110 111 #endif /* !ICACHE_REFILLS_WORKAROUND_WAR */ 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 own_fpu_inatomic(1); 122 err = save_fp_context32(sc); /* this might fail */ 123 unlock_fpu_owner(); 124 if (likely(!err)) 125 break; 126 /* touch the sigcontext and try again */ 127 err = __put_user(0, &sc->sc_fpregs[0]) | 128 __put_user(0, &sc->sc_fpregs[31]) | 129 __put_user(0, &sc->sc_fpc_csr); 130 if (err) 131 break; /* really bad sigcontext */ 132 } 133 return err; 134 } 135 136 static int protected_restore_fp_context32(struct sigcontext32 __user *sc) 137 { 138 int err, tmp; 139 while (1) { 140 lock_fpu_owner(); 141 own_fpu_inatomic(0); 142 err = restore_fp_context32(sc); /* this might fail */ 143 unlock_fpu_owner(); 144 if (likely(!err)) 145 break; 146 /* touch the sigcontext and try again */ 147 err = __get_user(tmp, &sc->sc_fpregs[0]) | 148 __get_user(tmp, &sc->sc_fpregs[31]) | 149 __get_user(tmp, &sc->sc_fpc_csr); 150 if (err) 151 break; /* really bad sigcontext */ 152 } 153 return err; 154 } 155 156 static int setup_sigcontext32(struct pt_regs *regs, 157 struct sigcontext32 __user *sc) 158 { 159 int err = 0; 160 int i; 161 u32 used_math; 162 163 err |= __put_user(regs->cp0_epc, &sc->sc_pc); 164 165 err |= __put_user(0, &sc->sc_regs[0]); 166 for (i = 1; i < 32; i++) 167 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); 168 169 err |= __put_user(regs->hi, &sc->sc_mdhi); 170 err |= __put_user(regs->lo, &sc->sc_mdlo); 171 if (cpu_has_dsp) { 172 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 173 err |= __put_user(mfhi1(), &sc->sc_hi1); 174 err |= __put_user(mflo1(), &sc->sc_lo1); 175 err |= __put_user(mfhi2(), &sc->sc_hi2); 176 err |= __put_user(mflo2(), &sc->sc_lo2); 177 err |= __put_user(mfhi3(), &sc->sc_hi3); 178 err |= __put_user(mflo3(), &sc->sc_lo3); 179 } 180 181 used_math = !!used_math(); 182 err |= __put_user(used_math, &sc->sc_used_math); 183 184 if (used_math) { 185 /* 186 * Save FPU state to signal context. Signal handler 187 * will "inherit" current FPU state. 188 */ 189 err |= protected_save_fp_context32(sc); 190 } 191 return err; 192 } 193 194 static int 195 check_and_restore_fp_context32(struct sigcontext32 __user *sc) 196 { 197 int err, sig; 198 199 err = sig = fpcsr_pending(&sc->sc_fpc_csr); 200 if (err > 0) 201 err = 0; 202 err |= protected_restore_fp_context32(sc); 203 return err ?: sig; 204 } 205 206 static int restore_sigcontext32(struct pt_regs *regs, 207 struct sigcontext32 __user *sc) 208 { 209 u32 used_math; 210 int err = 0; 211 s32 treg; 212 int i; 213 214 /* Always make any pending restarted system calls return -EINTR */ 215 current_thread_info()->restart_block.fn = do_no_restart_syscall; 216 217 err |= __get_user(regs->cp0_epc, &sc->sc_pc); 218 err |= __get_user(regs->hi, &sc->sc_mdhi); 219 err |= __get_user(regs->lo, &sc->sc_mdlo); 220 if (cpu_has_dsp) { 221 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 222 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 223 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 224 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 225 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 226 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 227 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 228 } 229 230 for (i = 1; i < 32; i++) 231 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); 232 233 err |= __get_user(used_math, &sc->sc_used_math); 234 conditional_used_math(used_math); 235 236 if (used_math) { 237 /* restore fpu context if we have used it before */ 238 if (!err) 239 err = check_and_restore_fp_context32(sc); 240 } else { 241 /* signal handler may have used FPU. Give it up. */ 242 lose_fpu(0); 243 } 244 245 return err; 246 } 247 248 /* 249 * 250 */ 251 extern void __put_sigset_unknown_nsig(void); 252 extern void __get_sigset_unknown_nsig(void); 253 254 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf) 255 { 256 int err = 0; 257 258 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf))) 259 return -EFAULT; 260 261 switch (_NSIG_WORDS) { 262 default: 263 __put_sigset_unknown_nsig(); 264 case 2: 265 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]); 266 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]); 267 case 1: 268 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]); 269 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]); 270 } 271 272 return err; 273 } 274 275 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf) 276 { 277 int err = 0; 278 unsigned long sig[4]; 279 280 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf))) 281 return -EFAULT; 282 283 switch (_NSIG_WORDS) { 284 default: 285 __get_sigset_unknown_nsig(); 286 case 2: 287 err |= __get_user (sig[3], &ubuf->sig[3]); 288 err |= __get_user (sig[2], &ubuf->sig[2]); 289 kbuf->sig[1] = sig[2] | (sig[3] << 32); 290 case 1: 291 err |= __get_user (sig[1], &ubuf->sig[1]); 292 err |= __get_user (sig[0], &ubuf->sig[0]); 293 kbuf->sig[0] = sig[0] | (sig[1] << 32); 294 } 295 296 return err; 297 } 298 299 /* 300 * Atomically swap in the new signal mask, and wait for a signal. 301 */ 302 303 asmlinkage int sys32_sigsuspend(nabi_no_regargs struct pt_regs regs) 304 { 305 compat_sigset_t __user *uset; 306 sigset_t newset; 307 308 uset = (compat_sigset_t __user *) regs.regs[4]; 309 if (get_sigset(&newset, uset)) 310 return -EFAULT; 311 sigdelsetmask(&newset, ~_BLOCKABLE); 312 313 spin_lock_irq(¤t->sighand->siglock); 314 current->saved_sigmask = current->blocked; 315 current->blocked = newset; 316 recalc_sigpending(); 317 spin_unlock_irq(¤t->sighand->siglock); 318 319 current->state = TASK_INTERRUPTIBLE; 320 schedule(); 321 set_thread_flag(TIF_RESTORE_SIGMASK); 322 return -ERESTARTNOHAND; 323 } 324 325 asmlinkage int sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs) 326 { 327 compat_sigset_t __user *uset; 328 sigset_t newset; 329 size_t sigsetsize; 330 331 /* XXX Don't preclude handling different sized sigset_t's. */ 332 sigsetsize = regs.regs[5]; 333 if (sigsetsize != sizeof(compat_sigset_t)) 334 return -EINVAL; 335 336 uset = (compat_sigset_t __user *) regs.regs[4]; 337 if (get_sigset(&newset, uset)) 338 return -EFAULT; 339 sigdelsetmask(&newset, ~_BLOCKABLE); 340 341 spin_lock_irq(¤t->sighand->siglock); 342 current->saved_sigmask = current->blocked; 343 current->blocked = newset; 344 recalc_sigpending(); 345 spin_unlock_irq(¤t->sighand->siglock); 346 347 current->state = TASK_INTERRUPTIBLE; 348 schedule(); 349 set_thread_flag(TIF_RESTORE_SIGMASK); 350 return -ERESTARTNOHAND; 351 } 352 353 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 __user *act, 354 struct sigaction32 __user *oact) 355 { 356 struct k_sigaction new_ka, old_ka; 357 int ret; 358 int err = 0; 359 360 if (act) { 361 old_sigset_t mask; 362 s32 handler; 363 364 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 365 return -EFAULT; 366 err |= __get_user(handler, &act->sa_handler); 367 new_ka.sa.sa_handler = (void __user *)(s64)handler; 368 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 369 err |= __get_user(mask, &act->sa_mask.sig[0]); 370 if (err) 371 return -EFAULT; 372 373 siginitset(&new_ka.sa.sa_mask, mask); 374 } 375 376 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 377 378 if (!ret && oact) { 379 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 380 return -EFAULT; 381 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 382 err |= __put_user((u32)(u64)old_ka.sa.sa_handler, 383 &oact->sa_handler); 384 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig); 385 err |= __put_user(0, &oact->sa_mask.sig[1]); 386 err |= __put_user(0, &oact->sa_mask.sig[2]); 387 err |= __put_user(0, &oact->sa_mask.sig[3]); 388 if (err) 389 return -EFAULT; 390 } 391 392 return ret; 393 } 394 395 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs) 396 { 397 const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4]; 398 stack32_t __user *uoss = (stack32_t __user *) regs.regs[5]; 399 unsigned long usp = regs.regs[29]; 400 stack_t kss, koss; 401 int ret, err = 0; 402 mm_segment_t old_fs = get_fs(); 403 s32 sp; 404 405 if (uss) { 406 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))) 407 return -EFAULT; 408 err |= __get_user(sp, &uss->ss_sp); 409 kss.ss_sp = (void __user *) (long) sp; 410 err |= __get_user(kss.ss_size, &uss->ss_size); 411 err |= __get_user(kss.ss_flags, &uss->ss_flags); 412 if (err) 413 return -EFAULT; 414 } 415 416 set_fs (KERNEL_DS); 417 ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL, 418 uoss ? (stack_t __user *)&koss : NULL, usp); 419 set_fs (old_fs); 420 421 if (!ret && uoss) { 422 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss))) 423 return -EFAULT; 424 sp = (int) (unsigned long) koss.ss_sp; 425 err |= __put_user(sp, &uoss->ss_sp); 426 err |= __put_user(koss.ss_size, &uoss->ss_size); 427 err |= __put_user(koss.ss_flags, &uoss->ss_flags); 428 if (err) 429 return -EFAULT; 430 } 431 return ret; 432 } 433 434 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) 435 { 436 int err; 437 438 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 439 return -EFAULT; 440 441 /* If you change siginfo_t structure, please be sure 442 this code is fixed accordingly. 443 It should never copy any pad contained in the structure 444 to avoid security leaks, but must copy the generic 445 3 ints plus the relevant union member. 446 This routine must convert siginfo from 64bit to 32bit as well 447 at the same time. */ 448 err = __put_user(from->si_signo, &to->si_signo); 449 err |= __put_user(from->si_errno, &to->si_errno); 450 err |= __put_user((short)from->si_code, &to->si_code); 451 if (from->si_code < 0) 452 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 453 else { 454 switch (from->si_code >> 16) { 455 case __SI_TIMER >> 16: 456 err |= __put_user(from->si_tid, &to->si_tid); 457 err |= __put_user(from->si_overrun, &to->si_overrun); 458 err |= __put_user(from->si_int, &to->si_int); 459 break; 460 case __SI_CHLD >> 16: 461 err |= __put_user(from->si_utime, &to->si_utime); 462 err |= __put_user(from->si_stime, &to->si_stime); 463 err |= __put_user(from->si_status, &to->si_status); 464 default: 465 err |= __put_user(from->si_pid, &to->si_pid); 466 err |= __put_user(from->si_uid, &to->si_uid); 467 break; 468 case __SI_FAULT >> 16: 469 err |= __put_user((unsigned long)from->si_addr, &to->si_addr); 470 break; 471 case __SI_POLL >> 16: 472 err |= __put_user(from->si_band, &to->si_band); 473 err |= __put_user(from->si_fd, &to->si_fd); 474 break; 475 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 476 case __SI_MESGQ >> 16: 477 err |= __put_user(from->si_pid, &to->si_pid); 478 err |= __put_user(from->si_uid, &to->si_uid); 479 err |= __put_user(from->si_int, &to->si_int); 480 break; 481 } 482 } 483 return err; 484 } 485 486 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs) 487 { 488 struct sigframe32 __user *frame; 489 sigset_t blocked; 490 int sig; 491 492 frame = (struct sigframe32 __user *) regs.regs[29]; 493 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 494 goto badframe; 495 if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask)) 496 goto badframe; 497 498 sigdelsetmask(&blocked, ~_BLOCKABLE); 499 spin_lock_irq(¤t->sighand->siglock); 500 current->blocked = blocked; 501 recalc_sigpending(); 502 spin_unlock_irq(¤t->sighand->siglock); 503 504 sig = restore_sigcontext32(®s, &frame->sf_sc); 505 if (sig < 0) 506 goto badframe; 507 else if (sig) 508 force_sig(sig, current); 509 510 /* 511 * Don't let your children do this ... 512 */ 513 __asm__ __volatile__( 514 "move\t$29, %0\n\t" 515 "j\tsyscall_exit" 516 :/* no outputs */ 517 :"r" (®s)); 518 /* Unreached */ 519 520 badframe: 521 force_sig(SIGSEGV, current); 522 } 523 524 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs) 525 { 526 struct rt_sigframe32 __user *frame; 527 mm_segment_t old_fs; 528 sigset_t set; 529 stack_t st; 530 s32 sp; 531 int sig; 532 533 frame = (struct rt_sigframe32 __user *) regs.regs[29]; 534 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 535 goto badframe; 536 if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask)) 537 goto badframe; 538 539 sigdelsetmask(&set, ~_BLOCKABLE); 540 spin_lock_irq(¤t->sighand->siglock); 541 current->blocked = set; 542 recalc_sigpending(); 543 spin_unlock_irq(¤t->sighand->siglock); 544 545 sig = restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext); 546 if (sig < 0) 547 goto badframe; 548 else if (sig) 549 force_sig(sig, current); 550 551 /* The ucontext contains a stack32_t, so we must convert! */ 552 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp)) 553 goto badframe; 554 st.ss_sp = (void __user *)(long) sp; 555 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size)) 556 goto badframe; 557 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags)) 558 goto badframe; 559 560 /* It is more difficult to avoid calling this function than to 561 call it and ignore errors. */ 562 old_fs = get_fs(); 563 set_fs (KERNEL_DS); 564 do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]); 565 set_fs (old_fs); 566 567 /* 568 * Don't let your children do this ... 569 */ 570 __asm__ __volatile__( 571 "move\t$29, %0\n\t" 572 "j\tsyscall_exit" 573 :/* no outputs */ 574 :"r" (®s)); 575 /* Unreached */ 576 577 badframe: 578 force_sig(SIGSEGV, current); 579 } 580 581 static int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs, 582 int signr, sigset_t *set) 583 { 584 struct sigframe32 __user *frame; 585 int err = 0; 586 587 frame = get_sigframe(ka, regs, sizeof(*frame)); 588 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 589 goto give_sigsegv; 590 591 err |= install_sigtramp(frame->sf_code, __NR_O32_sigreturn); 592 593 err |= setup_sigcontext32(regs, &frame->sf_sc); 594 err |= __copy_conv_sigset_to_user(&frame->sf_mask, set); 595 596 if (err) 597 goto give_sigsegv; 598 599 /* 600 * Arguments to signal handler: 601 * 602 * a0 = signal number 603 * a1 = 0 (should be cause) 604 * a2 = pointer to struct sigcontext 605 * 606 * $25 and c0_epc point to the signal handler, $29 points to the 607 * struct sigframe. 608 */ 609 regs->regs[ 4] = signr; 610 regs->regs[ 5] = 0; 611 regs->regs[ 6] = (unsigned long) &frame->sf_sc; 612 regs->regs[29] = (unsigned long) frame; 613 regs->regs[31] = (unsigned long) frame->sf_code; 614 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 615 616 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 617 current->comm, current->pid, 618 frame, regs->cp0_epc, regs->regs[31]); 619 620 return 0; 621 622 give_sigsegv: 623 force_sigsegv(signr, current); 624 return -EFAULT; 625 } 626 627 static int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs, 628 int signr, sigset_t *set, siginfo_t *info) 629 { 630 struct rt_sigframe32 __user *frame; 631 int err = 0; 632 s32 sp; 633 634 frame = get_sigframe(ka, regs, sizeof(*frame)); 635 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 636 goto give_sigsegv; 637 638 err |= install_sigtramp(frame->rs_code, __NR_O32_rt_sigreturn); 639 640 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */ 641 err |= copy_siginfo_to_user32(&frame->rs_info, info); 642 643 /* Create the ucontext. */ 644 err |= __put_user(0, &frame->rs_uc.uc_flags); 645 err |= __put_user(0, &frame->rs_uc.uc_link); 646 sp = (int) (long) current->sas_ss_sp; 647 err |= __put_user(sp, 648 &frame->rs_uc.uc_stack.ss_sp); 649 err |= __put_user(sas_ss_flags(regs->regs[29]), 650 &frame->rs_uc.uc_stack.ss_flags); 651 err |= __put_user(current->sas_ss_size, 652 &frame->rs_uc.uc_stack.ss_size); 653 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext); 654 err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set); 655 656 if (err) 657 goto give_sigsegv; 658 659 /* 660 * Arguments to signal handler: 661 * 662 * a0 = signal number 663 * a1 = 0 (should be cause) 664 * a2 = pointer to ucontext 665 * 666 * $25 and c0_epc point to the signal handler, $29 points to 667 * the struct rt_sigframe32. 668 */ 669 regs->regs[ 4] = signr; 670 regs->regs[ 5] = (unsigned long) &frame->rs_info; 671 regs->regs[ 6] = (unsigned long) &frame->rs_uc; 672 regs->regs[29] = (unsigned long) frame; 673 regs->regs[31] = (unsigned long) frame->rs_code; 674 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 675 676 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 677 current->comm, current->pid, 678 frame, regs->cp0_epc, regs->regs[31]); 679 680 return 0; 681 682 give_sigsegv: 683 force_sigsegv(signr, current); 684 return -EFAULT; 685 } 686 687 /* 688 * o32 compatibility on 64-bit kernels, without DSP ASE 689 */ 690 struct mips_abi mips_abi_32 = { 691 .setup_frame = setup_frame_32, 692 .setup_rt_frame = setup_rt_frame_32, 693 .restart = __NR_O32_restart_syscall 694 }; 695 696 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, 697 struct sigaction32 __user *oact, 698 unsigned int sigsetsize) 699 { 700 struct k_sigaction new_sa, old_sa; 701 int ret = -EINVAL; 702 703 /* XXX: Don't preclude handling different sized sigset_t's. */ 704 if (sigsetsize != sizeof(sigset_t)) 705 goto out; 706 707 if (act) { 708 s32 handler; 709 int err = 0; 710 711 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 712 return -EFAULT; 713 err |= __get_user(handler, &act->sa_handler); 714 new_sa.sa.sa_handler = (void __user *)(s64)handler; 715 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags); 716 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask); 717 if (err) 718 return -EFAULT; 719 } 720 721 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); 722 723 if (!ret && oact) { 724 int err = 0; 725 726 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 727 return -EFAULT; 728 729 err |= __put_user((u32)(u64)old_sa.sa.sa_handler, 730 &oact->sa_handler); 731 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags); 732 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask); 733 if (err) 734 return -EFAULT; 735 } 736 out: 737 return ret; 738 } 739 740 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, 741 compat_sigset_t __user *oset, unsigned int sigsetsize) 742 { 743 sigset_t old_set, new_set; 744 int ret; 745 mm_segment_t old_fs = get_fs(); 746 747 if (set && get_sigset(&new_set, set)) 748 return -EFAULT; 749 750 set_fs (KERNEL_DS); 751 ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL, 752 oset ? (sigset_t __user *)&old_set : NULL, 753 sigsetsize); 754 set_fs (old_fs); 755 756 if (!ret && oset && put_sigset(&old_set, oset)) 757 return -EFAULT; 758 759 return ret; 760 } 761 762 asmlinkage int sys32_rt_sigpending(compat_sigset_t __user *uset, 763 unsigned int sigsetsize) 764 { 765 int ret; 766 sigset_t set; 767 mm_segment_t old_fs = get_fs(); 768 769 set_fs (KERNEL_DS); 770 ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize); 771 set_fs (old_fs); 772 773 if (!ret && put_sigset(&set, uset)) 774 return -EFAULT; 775 776 return ret; 777 } 778 779 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo) 780 { 781 siginfo_t info; 782 int ret; 783 mm_segment_t old_fs = get_fs(); 784 785 if (copy_from_user (&info, uinfo, 3*sizeof(int)) || 786 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE)) 787 return -EFAULT; 788 set_fs (KERNEL_DS); 789 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info); 790 set_fs (old_fs); 791 return ret; 792 } 793 794 asmlinkage long 795 sys32_waitid(int which, compat_pid_t pid, 796 compat_siginfo_t __user *uinfo, int options, 797 struct compat_rusage __user *uru) 798 { 799 siginfo_t info; 800 struct rusage ru; 801 long ret; 802 mm_segment_t old_fs = get_fs(); 803 804 info.si_signo = 0; 805 set_fs (KERNEL_DS); 806 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options, 807 uru ? (struct rusage __user *) &ru : NULL); 808 set_fs (old_fs); 809 810 if (ret < 0 || info.si_signo == 0) 811 return ret; 812 813 if (uru && (ret = put_compat_rusage(&ru, uru))) 814 return ret; 815 816 BUG_ON(info.si_code & __SI_MASK); 817 info.si_code |= __SI_CHLD; 818 return copy_siginfo_to_user32(uinfo, &info); 819 } 820