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