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