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