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