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