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 #define _NSIG_BPW32 32 112 #define _NSIG_WORDS32 (_NSIG / _NSIG_BPW32) 113 114 typedef struct { 115 unsigned int sig[_NSIG_WORDS32]; 116 } sigset_t32; 117 118 typedef unsigned int __sighandler32_t; 119 typedef void (*vfptr_t)(void); 120 121 struct sigaction32 { 122 unsigned int sa_flags; 123 __sighandler32_t sa_handler; 124 compat_sigset_t sa_mask; 125 }; 126 127 /* IRIX compatible stack_t */ 128 typedef struct sigaltstack32 { 129 s32 ss_sp; 130 compat_size_t ss_size; 131 int ss_flags; 132 } stack32_t; 133 134 struct ucontext32 { 135 u32 uc_flags; 136 s32 uc_link; 137 stack32_t uc_stack; 138 struct sigcontext32 uc_mcontext; 139 sigset_t32 uc_sigmask; /* mask last for extensibility */ 140 }; 141 142 /* 143 * Horribly complicated - with the bloody RM9000 workarounds enabled 144 * the signal trampolines is moving to the end of the structure so we can 145 * increase the alignment without breaking software compatibility. 146 */ 147 #if ICACHE_REFILLS_WORKAROUND_WAR == 0 148 149 struct sigframe32 { 150 u32 sf_ass[4]; /* argument save space for o32 */ 151 u32 sf_code[2]; /* signal trampoline */ 152 struct sigcontext32 sf_sc; 153 sigset_t sf_mask; 154 }; 155 156 struct rt_sigframe32 { 157 u32 rs_ass[4]; /* argument save space for o32 */ 158 u32 rs_code[2]; /* signal trampoline */ 159 compat_siginfo_t rs_info; 160 struct ucontext32 rs_uc; 161 }; 162 163 #else /* ICACHE_REFILLS_WORKAROUND_WAR */ 164 165 struct sigframe32 { 166 u32 sf_ass[4]; /* argument save space for o32 */ 167 u32 sf_pad[2]; 168 struct sigcontext32 sf_sc; /* hw context */ 169 sigset_t sf_mask; 170 u32 sf_code[8] ____cacheline_aligned; /* signal trampoline */ 171 }; 172 173 struct rt_sigframe32 { 174 u32 rs_ass[4]; /* argument save space for o32 */ 175 u32 rs_pad[2]; 176 compat_siginfo_t rs_info; 177 struct ucontext32 rs_uc; 178 u32 rs_code[8] __attribute__((aligned(32))); /* signal trampoline */ 179 }; 180 181 #endif /* !ICACHE_REFILLS_WORKAROUND_WAR */ 182 183 /* 184 * sigcontext handlers 185 */ 186 static int setup_sigcontext32(struct pt_regs *regs, 187 struct sigcontext32 __user *sc) 188 { 189 int err = 0; 190 int i; 191 192 err |= __put_user(regs->cp0_epc, &sc->sc_pc); 193 194 err |= __put_user(0, &sc->sc_regs[0]); 195 for (i = 1; i < 32; i++) 196 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); 197 198 err |= __put_user(regs->hi, &sc->sc_mdhi); 199 err |= __put_user(regs->lo, &sc->sc_mdlo); 200 if (cpu_has_dsp) { 201 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 202 err |= __put_user(mfhi1(), &sc->sc_hi1); 203 err |= __put_user(mflo1(), &sc->sc_lo1); 204 err |= __put_user(mfhi2(), &sc->sc_hi2); 205 err |= __put_user(mflo2(), &sc->sc_lo2); 206 err |= __put_user(mfhi3(), &sc->sc_hi3); 207 err |= __put_user(mflo3(), &sc->sc_lo3); 208 } 209 210 err |= __put_user(!!used_math(), &sc->sc_used_math); 211 212 if (used_math()) { 213 /* 214 * Save FPU state to signal context. Signal handler 215 * will "inherit" current FPU state. 216 */ 217 preempt_disable(); 218 219 if (!is_fpu_owner()) { 220 own_fpu(); 221 restore_fp(current); 222 } 223 err |= save_fp_context32(sc); 224 225 preempt_enable(); 226 } 227 return err; 228 } 229 230 static int restore_sigcontext32(struct pt_regs *regs, 231 struct sigcontext32 __user *sc) 232 { 233 u32 used_math; 234 int err = 0; 235 s32 treg; 236 int i; 237 238 /* Always make any pending restarted system calls return -EINTR */ 239 current_thread_info()->restart_block.fn = do_no_restart_syscall; 240 241 err |= __get_user(regs->cp0_epc, &sc->sc_pc); 242 err |= __get_user(regs->hi, &sc->sc_mdhi); 243 err |= __get_user(regs->lo, &sc->sc_mdlo); 244 if (cpu_has_dsp) { 245 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 246 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 247 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 248 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 249 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 250 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 251 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 252 } 253 254 for (i = 1; i < 32; i++) 255 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); 256 257 err |= __get_user(used_math, &sc->sc_used_math); 258 conditional_used_math(used_math); 259 260 preempt_disable(); 261 262 if (used_math()) { 263 /* restore fpu context if we have used it before */ 264 own_fpu(); 265 err |= restore_fp_context32(sc); 266 } else { 267 /* signal handler may have used FPU. Give it up. */ 268 lose_fpu(); 269 } 270 271 preempt_enable(); 272 273 return err; 274 } 275 276 /* 277 * 278 */ 279 extern void __put_sigset_unknown_nsig(void); 280 extern void __get_sigset_unknown_nsig(void); 281 282 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf) 283 { 284 int err = 0; 285 286 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf))) 287 return -EFAULT; 288 289 switch (_NSIG_WORDS) { 290 default: 291 __put_sigset_unknown_nsig(); 292 case 2: 293 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]); 294 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]); 295 case 1: 296 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]); 297 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]); 298 } 299 300 return err; 301 } 302 303 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf) 304 { 305 int err = 0; 306 unsigned long sig[4]; 307 308 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf))) 309 return -EFAULT; 310 311 switch (_NSIG_WORDS) { 312 default: 313 __get_sigset_unknown_nsig(); 314 case 2: 315 err |= __get_user (sig[3], &ubuf->sig[3]); 316 err |= __get_user (sig[2], &ubuf->sig[2]); 317 kbuf->sig[1] = sig[2] | (sig[3] << 32); 318 case 1: 319 err |= __get_user (sig[1], &ubuf->sig[1]); 320 err |= __get_user (sig[0], &ubuf->sig[0]); 321 kbuf->sig[0] = sig[0] | (sig[1] << 32); 322 } 323 324 return err; 325 } 326 327 /* 328 * Atomically swap in the new signal mask, and wait for a signal. 329 */ 330 331 asmlinkage int sys32_sigsuspend(nabi_no_regargs struct pt_regs regs) 332 { 333 compat_sigset_t __user *uset; 334 sigset_t newset; 335 336 uset = (compat_sigset_t __user *) regs.regs[4]; 337 if (get_sigset(&newset, uset)) 338 return -EFAULT; 339 sigdelsetmask(&newset, ~_BLOCKABLE); 340 341 spin_lock_irq(¤t->sighand->siglock); 342 current->saved_sigmask = current->blocked; 343 current->blocked = newset; 344 recalc_sigpending(); 345 spin_unlock_irq(¤t->sighand->siglock); 346 347 current->state = TASK_INTERRUPTIBLE; 348 schedule(); 349 set_thread_flag(TIF_RESTORE_SIGMASK); 350 return -ERESTARTNOHAND; 351 } 352 353 asmlinkage int sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs) 354 { 355 compat_sigset_t __user *uset; 356 sigset_t newset; 357 size_t sigsetsize; 358 359 /* XXX Don't preclude handling different sized sigset_t's. */ 360 sigsetsize = regs.regs[5]; 361 if (sigsetsize != sizeof(compat_sigset_t)) 362 return -EINVAL; 363 364 uset = (compat_sigset_t __user *) regs.regs[4]; 365 if (get_sigset(&newset, uset)) 366 return -EFAULT; 367 sigdelsetmask(&newset, ~_BLOCKABLE); 368 369 spin_lock_irq(¤t->sighand->siglock); 370 current->saved_sigmask = current->blocked; 371 current->blocked = newset; 372 recalc_sigpending(); 373 spin_unlock_irq(¤t->sighand->siglock); 374 375 current->state = TASK_INTERRUPTIBLE; 376 schedule(); 377 set_thread_flag(TIF_RESTORE_SIGMASK); 378 return -ERESTARTNOHAND; 379 } 380 381 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 __user *act, 382 struct sigaction32 __user *oact) 383 { 384 struct k_sigaction new_ka, old_ka; 385 int ret; 386 int err = 0; 387 388 if (act) { 389 old_sigset_t mask; 390 s32 handler; 391 392 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 393 return -EFAULT; 394 err |= __get_user(handler, &act->sa_handler); 395 new_ka.sa.sa_handler = (void __user *)(s64)handler; 396 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 397 err |= __get_user(mask, &act->sa_mask.sig[0]); 398 if (err) 399 return -EFAULT; 400 401 siginitset(&new_ka.sa.sa_mask, mask); 402 } 403 404 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 405 406 if (!ret && oact) { 407 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 408 return -EFAULT; 409 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 410 err |= __put_user((u32)(u64)old_ka.sa.sa_handler, 411 &oact->sa_handler); 412 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig); 413 err |= __put_user(0, &oact->sa_mask.sig[1]); 414 err |= __put_user(0, &oact->sa_mask.sig[2]); 415 err |= __put_user(0, &oact->sa_mask.sig[3]); 416 if (err) 417 return -EFAULT; 418 } 419 420 return ret; 421 } 422 423 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs) 424 { 425 const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4]; 426 stack32_t __user *uoss = (stack32_t __user *) regs.regs[5]; 427 unsigned long usp = regs.regs[29]; 428 stack_t kss, koss; 429 int ret, err = 0; 430 mm_segment_t old_fs = get_fs(); 431 s32 sp; 432 433 if (uss) { 434 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))) 435 return -EFAULT; 436 err |= __get_user(sp, &uss->ss_sp); 437 kss.ss_sp = (void __user *) (long) sp; 438 err |= __get_user(kss.ss_size, &uss->ss_size); 439 err |= __get_user(kss.ss_flags, &uss->ss_flags); 440 if (err) 441 return -EFAULT; 442 } 443 444 set_fs (KERNEL_DS); 445 ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL, 446 uoss ? (stack_t __user *)&koss : NULL, usp); 447 set_fs (old_fs); 448 449 if (!ret && uoss) { 450 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss))) 451 return -EFAULT; 452 sp = (int) (unsigned long) koss.ss_sp; 453 err |= __put_user(sp, &uoss->ss_sp); 454 err |= __put_user(koss.ss_size, &uoss->ss_size); 455 err |= __put_user(koss.ss_flags, &uoss->ss_flags); 456 if (err) 457 return -EFAULT; 458 } 459 return ret; 460 } 461 462 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from) 463 { 464 int err; 465 466 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 467 return -EFAULT; 468 469 /* If you change siginfo_t structure, please be sure 470 this code is fixed accordingly. 471 It should never copy any pad contained in the structure 472 to avoid security leaks, but must copy the generic 473 3 ints plus the relevant union member. 474 This routine must convert siginfo from 64bit to 32bit as well 475 at the same time. */ 476 err = __put_user(from->si_signo, &to->si_signo); 477 err |= __put_user(from->si_errno, &to->si_errno); 478 err |= __put_user((short)from->si_code, &to->si_code); 479 if (from->si_code < 0) 480 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 481 else { 482 switch (from->si_code >> 16) { 483 case __SI_TIMER >> 16: 484 err |= __put_user(from->si_tid, &to->si_tid); 485 err |= __put_user(from->si_overrun, &to->si_overrun); 486 err |= __put_user(from->si_int, &to->si_int); 487 break; 488 case __SI_CHLD >> 16: 489 err |= __put_user(from->si_utime, &to->si_utime); 490 err |= __put_user(from->si_stime, &to->si_stime); 491 err |= __put_user(from->si_status, &to->si_status); 492 default: 493 err |= __put_user(from->si_pid, &to->si_pid); 494 err |= __put_user(from->si_uid, &to->si_uid); 495 break; 496 case __SI_FAULT >> 16: 497 err |= __put_user((unsigned long)from->si_addr, &to->si_addr); 498 break; 499 case __SI_POLL >> 16: 500 err |= __put_user(from->si_band, &to->si_band); 501 err |= __put_user(from->si_fd, &to->si_fd); 502 break; 503 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 504 case __SI_MESGQ >> 16: 505 err |= __put_user(from->si_pid, &to->si_pid); 506 err |= __put_user(from->si_uid, &to->si_uid); 507 err |= __put_user(from->si_int, &to->si_int); 508 break; 509 } 510 } 511 return err; 512 } 513 514 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs) 515 { 516 struct sigframe32 __user *frame; 517 sigset_t blocked; 518 519 frame = (struct sigframe32 __user *) regs.regs[29]; 520 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 521 goto badframe; 522 if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask)) 523 goto badframe; 524 525 sigdelsetmask(&blocked, ~_BLOCKABLE); 526 spin_lock_irq(¤t->sighand->siglock); 527 current->blocked = blocked; 528 recalc_sigpending(); 529 spin_unlock_irq(¤t->sighand->siglock); 530 531 if (restore_sigcontext32(®s, &frame->sf_sc)) 532 goto badframe; 533 534 /* 535 * Don't let your children do this ... 536 */ 537 __asm__ __volatile__( 538 "move\t$29, %0\n\t" 539 "j\tsyscall_exit" 540 :/* no outputs */ 541 :"r" (®s)); 542 /* Unreached */ 543 544 badframe: 545 force_sig(SIGSEGV, current); 546 } 547 548 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs) 549 { 550 struct rt_sigframe32 __user *frame; 551 mm_segment_t old_fs; 552 sigset_t set; 553 stack_t st; 554 s32 sp; 555 556 frame = (struct rt_sigframe32 __user *) regs.regs[29]; 557 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 558 goto badframe; 559 if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask)) 560 goto badframe; 561 562 sigdelsetmask(&set, ~_BLOCKABLE); 563 spin_lock_irq(¤t->sighand->siglock); 564 current->blocked = set; 565 recalc_sigpending(); 566 spin_unlock_irq(¤t->sighand->siglock); 567 568 if (restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext)) 569 goto badframe; 570 571 /* The ucontext contains a stack32_t, so we must convert! */ 572 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp)) 573 goto badframe; 574 st.ss_sp = (void __user *)(long) sp; 575 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size)) 576 goto badframe; 577 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags)) 578 goto badframe; 579 580 /* It is more difficult to avoid calling this function than to 581 call it and ignore errors. */ 582 old_fs = get_fs(); 583 set_fs (KERNEL_DS); 584 do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]); 585 set_fs (old_fs); 586 587 /* 588 * Don't let your children do this ... 589 */ 590 __asm__ __volatile__( 591 "move\t$29, %0\n\t" 592 "j\tsyscall_exit" 593 :/* no outputs */ 594 :"r" (®s)); 595 /* Unreached */ 596 597 badframe: 598 force_sig(SIGSEGV, current); 599 } 600 601 int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs, 602 int signr, sigset_t *set) 603 { 604 struct sigframe32 __user *frame; 605 int err = 0; 606 607 frame = get_sigframe(ka, regs, sizeof(*frame)); 608 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 609 goto give_sigsegv; 610 611 err |= install_sigtramp(frame->sf_code, __NR_O32_sigreturn); 612 613 err |= setup_sigcontext32(regs, &frame->sf_sc); 614 err |= __copy_conv_sigset_to_user(&frame->sf_mask, set); 615 616 if (err) 617 goto give_sigsegv; 618 619 /* 620 * Arguments to signal handler: 621 * 622 * a0 = signal number 623 * a1 = 0 (should be cause) 624 * a2 = pointer to struct sigcontext 625 * 626 * $25 and c0_epc point to the signal handler, $29 points to the 627 * struct sigframe. 628 */ 629 regs->regs[ 4] = signr; 630 regs->regs[ 5] = 0; 631 regs->regs[ 6] = (unsigned long) &frame->sf_sc; 632 regs->regs[29] = (unsigned long) frame; 633 regs->regs[31] = (unsigned long) frame->sf_code; 634 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 635 636 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 637 current->comm, current->pid, 638 frame, regs->cp0_epc, regs->regs[31]); 639 640 return 0; 641 642 give_sigsegv: 643 force_sigsegv(signr, current); 644 return -EFAULT; 645 } 646 647 int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs, 648 int signr, sigset_t *set, siginfo_t *info) 649 { 650 struct rt_sigframe32 __user *frame; 651 int err = 0; 652 s32 sp; 653 654 frame = get_sigframe(ka, regs, sizeof(*frame)); 655 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 656 goto give_sigsegv; 657 658 err |= install_sigtramp(frame->rs_code, __NR_O32_rt_sigreturn); 659 660 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */ 661 err |= copy_siginfo_to_user32(&frame->rs_info, info); 662 663 /* Create the ucontext. */ 664 err |= __put_user(0, &frame->rs_uc.uc_flags); 665 err |= __put_user(0, &frame->rs_uc.uc_link); 666 sp = (int) (long) current->sas_ss_sp; 667 err |= __put_user(sp, 668 &frame->rs_uc.uc_stack.ss_sp); 669 err |= __put_user(sas_ss_flags(regs->regs[29]), 670 &frame->rs_uc.uc_stack.ss_flags); 671 err |= __put_user(current->sas_ss_size, 672 &frame->rs_uc.uc_stack.ss_size); 673 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext); 674 err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set); 675 676 if (err) 677 goto give_sigsegv; 678 679 /* 680 * Arguments to signal handler: 681 * 682 * a0 = signal number 683 * a1 = 0 (should be cause) 684 * a2 = pointer to ucontext 685 * 686 * $25 and c0_epc point to the signal handler, $29 points to 687 * the struct rt_sigframe32. 688 */ 689 regs->regs[ 4] = signr; 690 regs->regs[ 5] = (unsigned long) &frame->rs_info; 691 regs->regs[ 6] = (unsigned long) &frame->rs_uc; 692 regs->regs[29] = (unsigned long) frame; 693 regs->regs[31] = (unsigned long) frame->rs_code; 694 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 695 696 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 697 current->comm, current->pid, 698 frame, regs->cp0_epc, regs->regs[31]); 699 700 return 0; 701 702 give_sigsegv: 703 force_sigsegv(signr, current); 704 return -EFAULT; 705 } 706 707 static inline int handle_signal(unsigned long sig, siginfo_t *info, 708 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs) 709 { 710 int ret; 711 712 switch (regs->regs[0]) { 713 case ERESTART_RESTARTBLOCK: 714 case ERESTARTNOHAND: 715 regs->regs[2] = EINTR; 716 break; 717 case ERESTARTSYS: 718 if (!(ka->sa.sa_flags & SA_RESTART)) { 719 regs->regs[2] = EINTR; 720 break; 721 } 722 /* fallthrough */ 723 case ERESTARTNOINTR: /* Userland will reload $v0. */ 724 regs->regs[7] = regs->regs[26]; 725 regs->cp0_epc -= 8; 726 } 727 728 regs->regs[0] = 0; /* Don't deal with this again. */ 729 730 if (ka->sa.sa_flags & SA_SIGINFO) 731 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info); 732 else 733 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset); 734 735 spin_lock_irq(¤t->sighand->siglock); 736 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 737 if (!(ka->sa.sa_flags & SA_NODEFER)) 738 sigaddset(¤t->blocked,sig); 739 recalc_sigpending(); 740 spin_unlock_irq(¤t->sighand->siglock); 741 742 return ret; 743 } 744 745 void do_signal32(struct pt_regs *regs) 746 { 747 struct k_sigaction ka; 748 sigset_t *oldset; 749 siginfo_t info; 750 int signr; 751 752 /* 753 * We want the common case to go fast, which is why we may in certain 754 * cases get here from kernel mode. Just return without doing anything 755 * if so. 756 */ 757 if (!user_mode(regs)) 758 return; 759 760 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 761 oldset = ¤t->saved_sigmask; 762 else 763 oldset = ¤t->blocked; 764 765 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 766 if (signr > 0) { 767 /* Whee! Actually deliver the signal. */ 768 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) { 769 /* 770 * A signal was successfully delivered; the saved 771 * sigmask will have been stored in the signal frame, 772 * and will be restored by sigreturn, so we can simply 773 * clear the TIF_RESTORE_SIGMASK flag. 774 */ 775 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 776 clear_thread_flag(TIF_RESTORE_SIGMASK); 777 } 778 779 return; 780 } 781 782 /* 783 * Who's code doesn't conform to the restartable syscall convention 784 * dies here!!! The li instruction, a single machine instruction, 785 * must directly be followed by the syscall instruction. 786 */ 787 if (regs->regs[0]) { 788 if (regs->regs[2] == ERESTARTNOHAND || 789 regs->regs[2] == ERESTARTSYS || 790 regs->regs[2] == ERESTARTNOINTR) { 791 regs->regs[7] = regs->regs[26]; 792 regs->cp0_epc -= 8; 793 } 794 if (regs->regs[2] == ERESTART_RESTARTBLOCK) { 795 regs->regs[2] = __NR_O32_restart_syscall; 796 regs->regs[7] = regs->regs[26]; 797 regs->cp0_epc -= 4; 798 } 799 regs->regs[0] = 0; /* Don't deal with this again. */ 800 } 801 802 /* 803 * If there's no signal to deliver, we just put the saved sigmask 804 * back 805 */ 806 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 807 clear_thread_flag(TIF_RESTORE_SIGMASK); 808 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 809 } 810 } 811 812 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, 813 struct sigaction32 __user *oact, 814 unsigned int sigsetsize) 815 { 816 struct k_sigaction new_sa, old_sa; 817 int ret = -EINVAL; 818 819 /* XXX: Don't preclude handling different sized sigset_t's. */ 820 if (sigsetsize != sizeof(sigset_t)) 821 goto out; 822 823 if (act) { 824 s32 handler; 825 int err = 0; 826 827 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 828 return -EFAULT; 829 err |= __get_user(handler, &act->sa_handler); 830 new_sa.sa.sa_handler = (void __user *)(s64)handler; 831 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags); 832 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask); 833 if (err) 834 return -EFAULT; 835 } 836 837 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); 838 839 if (!ret && oact) { 840 int err = 0; 841 842 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 843 return -EFAULT; 844 845 err |= __put_user((u32)(u64)old_sa.sa.sa_handler, 846 &oact->sa_handler); 847 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags); 848 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask); 849 if (err) 850 return -EFAULT; 851 } 852 out: 853 return ret; 854 } 855 856 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, 857 compat_sigset_t __user *oset, unsigned int sigsetsize) 858 { 859 sigset_t old_set, new_set; 860 int ret; 861 mm_segment_t old_fs = get_fs(); 862 863 if (set && get_sigset(&new_set, set)) 864 return -EFAULT; 865 866 set_fs (KERNEL_DS); 867 ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL, 868 oset ? (sigset_t __user *)&old_set : NULL, 869 sigsetsize); 870 set_fs (old_fs); 871 872 if (!ret && oset && put_sigset(&old_set, oset)) 873 return -EFAULT; 874 875 return ret; 876 } 877 878 asmlinkage int sys32_rt_sigpending(compat_sigset_t __user *uset, 879 unsigned int sigsetsize) 880 { 881 int ret; 882 sigset_t set; 883 mm_segment_t old_fs = get_fs(); 884 885 set_fs (KERNEL_DS); 886 ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize); 887 set_fs (old_fs); 888 889 if (!ret && put_sigset(&set, uset)) 890 return -EFAULT; 891 892 return ret; 893 } 894 895 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo) 896 { 897 siginfo_t info; 898 int ret; 899 mm_segment_t old_fs = get_fs(); 900 901 if (copy_from_user (&info, uinfo, 3*sizeof(int)) || 902 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE)) 903 return -EFAULT; 904 set_fs (KERNEL_DS); 905 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info); 906 set_fs (old_fs); 907 return ret; 908 } 909 910 asmlinkage long 911 sys32_waitid(int which, compat_pid_t pid, 912 compat_siginfo_t __user *uinfo, int options, 913 struct compat_rusage __user *uru) 914 { 915 siginfo_t info; 916 struct rusage ru; 917 long ret; 918 mm_segment_t old_fs = get_fs(); 919 920 info.si_signo = 0; 921 set_fs (KERNEL_DS); 922 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options, 923 uru ? (struct rusage __user *) &ru : NULL); 924 set_fs (old_fs); 925 926 if (ret < 0 || info.si_signo == 0) 927 return ret; 928 929 if (uru && (ret = put_compat_rusage(&ru, uru))) 930 return ret; 931 932 BUG_ON(info.si_code & __SI_MASK); 933 info.si_code |= __SI_CHLD; 934 return copy_siginfo_to_user32(uinfo, &info); 935 } 936