signal_32.c revision 1c9bb1a01ac1bc92a0d98cf3e40a7922ee684dc0
1/* 2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC 3 * 4 * PowerPC version 5 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 6 * Copyright (C) 2001 IBM 7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 8 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) 9 * 10 * Derived from "arch/i386/kernel/signal.c" 11 * Copyright (C) 1991, 1992 Linus Torvalds 12 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License 16 * as published by the Free Software Foundation; either version 17 * 2 of the License, or (at your option) any later version. 18 */ 19 20#include <linux/sched.h> 21#include <linux/mm.h> 22#include <linux/smp.h> 23#include <linux/smp_lock.h> 24#include <linux/kernel.h> 25#include <linux/signal.h> 26#include <linux/errno.h> 27#include <linux/elf.h> 28#ifdef CONFIG_PPC64 29#include <linux/syscalls.h> 30#include <linux/compat.h> 31#include <linux/ptrace.h> 32#else 33#include <linux/wait.h> 34#include <linux/ptrace.h> 35#include <linux/unistd.h> 36#include <linux/stddef.h> 37#include <linux/tty.h> 38#include <linux/binfmts.h> 39#include <linux/freezer.h> 40#endif 41 42#include <asm/uaccess.h> 43#include <asm/cacheflush.h> 44#include <asm/syscalls.h> 45#include <asm/sigcontext.h> 46#include <asm/vdso.h> 47#ifdef CONFIG_PPC64 48#include "ppc32.h" 49#include <asm/unistd.h> 50#else 51#include <asm/ucontext.h> 52#include <asm/pgtable.h> 53#endif 54 55#undef DEBUG_SIG 56 57#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 58 59#ifdef CONFIG_PPC64 60#define do_signal do_signal32 61#define sys_sigsuspend compat_sys_sigsuspend 62#define sys_rt_sigsuspend compat_sys_rt_sigsuspend 63#define sys_rt_sigreturn compat_sys_rt_sigreturn 64#define sys_sigaction compat_sys_sigaction 65#define sys_swapcontext compat_sys_swapcontext 66#define sys_sigreturn compat_sys_sigreturn 67 68#define old_sigaction old_sigaction32 69#define sigcontext sigcontext32 70#define mcontext mcontext32 71#define ucontext ucontext32 72 73/* 74 * Returning 0 means we return to userspace via 75 * ret_from_except and thus restore all user 76 * registers from *regs. This is what we need 77 * to do when a signal has been delivered. 78 */ 79 80#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32)) 81#undef __SIGNAL_FRAMESIZE 82#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32 83#undef ELF_NVRREG 84#define ELF_NVRREG ELF_NVRREG32 85 86/* 87 * Functions for flipping sigsets (thanks to brain dead generic 88 * implementation that makes things simple for little endian only) 89 */ 90static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set) 91{ 92 compat_sigset_t cset; 93 94 switch (_NSIG_WORDS) { 95 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull; 96 cset.sig[7] = set->sig[3] >> 32; 97 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull; 98 cset.sig[5] = set->sig[2] >> 32; 99 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull; 100 cset.sig[3] = set->sig[1] >> 32; 101 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull; 102 cset.sig[1] = set->sig[0] >> 32; 103 } 104 return copy_to_user(uset, &cset, sizeof(*uset)); 105} 106 107static inline int get_sigset_t(sigset_t *set, 108 const compat_sigset_t __user *uset) 109{ 110 compat_sigset_t s32; 111 112 if (copy_from_user(&s32, uset, sizeof(*uset))) 113 return -EFAULT; 114 115 /* 116 * Swap the 2 words of the 64-bit sigset_t (they are stored 117 * in the "wrong" endian in 32-bit user storage). 118 */ 119 switch (_NSIG_WORDS) { 120 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32); 121 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32); 122 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32); 123 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); 124 } 125 return 0; 126} 127 128static inline int get_old_sigaction(struct k_sigaction *new_ka, 129 struct old_sigaction __user *act) 130{ 131 compat_old_sigset_t mask; 132 compat_uptr_t handler, restorer; 133 134 if (get_user(handler, &act->sa_handler) || 135 __get_user(restorer, &act->sa_restorer) || 136 __get_user(new_ka->sa.sa_flags, &act->sa_flags) || 137 __get_user(mask, &act->sa_mask)) 138 return -EFAULT; 139 new_ka->sa.sa_handler = compat_ptr(handler); 140 new_ka->sa.sa_restorer = compat_ptr(restorer); 141 siginitset(&new_ka->sa.sa_mask, mask); 142 return 0; 143} 144 145#define to_user_ptr(p) ptr_to_compat(p) 146#define from_user_ptr(p) compat_ptr(p) 147 148static inline int save_general_regs(struct pt_regs *regs, 149 struct mcontext __user *frame) 150{ 151 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 152 int i; 153 154 WARN_ON(!FULL_REGS(regs)); 155 156 for (i = 0; i <= PT_RESULT; i ++) { 157 if (i == 14 && !FULL_REGS(regs)) 158 i = 32; 159 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i])) 160 return -EFAULT; 161 } 162 return 0; 163} 164 165static inline int restore_general_regs(struct pt_regs *regs, 166 struct mcontext __user *sr) 167{ 168 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 169 int i; 170 171 for (i = 0; i <= PT_RESULT; i++) { 172 if ((i == PT_MSR) || (i == PT_SOFTE)) 173 continue; 174 if (__get_user(gregs[i], &sr->mc_gregs[i])) 175 return -EFAULT; 176 } 177 return 0; 178} 179 180#else /* CONFIG_PPC64 */ 181 182#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs)) 183 184static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set) 185{ 186 return copy_to_user(uset, set, sizeof(*uset)); 187} 188 189static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset) 190{ 191 return copy_from_user(set, uset, sizeof(*uset)); 192} 193 194static inline int get_old_sigaction(struct k_sigaction *new_ka, 195 struct old_sigaction __user *act) 196{ 197 old_sigset_t mask; 198 199 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 200 __get_user(new_ka->sa.sa_handler, &act->sa_handler) || 201 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer)) 202 return -EFAULT; 203 __get_user(new_ka->sa.sa_flags, &act->sa_flags); 204 __get_user(mask, &act->sa_mask); 205 siginitset(&new_ka->sa.sa_mask, mask); 206 return 0; 207} 208 209#define to_user_ptr(p) ((unsigned long)(p)) 210#define from_user_ptr(p) ((void __user *)(p)) 211 212static inline int save_general_regs(struct pt_regs *regs, 213 struct mcontext __user *frame) 214{ 215 WARN_ON(!FULL_REGS(regs)); 216 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE); 217} 218 219static inline int restore_general_regs(struct pt_regs *regs, 220 struct mcontext __user *sr) 221{ 222 /* copy up to but not including MSR */ 223 if (__copy_from_user(regs, &sr->mc_gregs, 224 PT_MSR * sizeof(elf_greg_t))) 225 return -EFAULT; 226 /* copy from orig_r3 (the word after the MSR) up to the end */ 227 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3], 228 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t))) 229 return -EFAULT; 230 return 0; 231} 232 233#endif /* CONFIG_PPC64 */ 234 235int do_signal(sigset_t *oldset, struct pt_regs *regs); 236 237/* 238 * Atomically swap in the new signal mask, and wait for a signal. 239 */ 240long sys_sigsuspend(old_sigset_t mask) 241{ 242 mask &= _BLOCKABLE; 243 spin_lock_irq(¤t->sighand->siglock); 244 current->saved_sigmask = current->blocked; 245 siginitset(¤t->blocked, mask); 246 recalc_sigpending(); 247 spin_unlock_irq(¤t->sighand->siglock); 248 249 current->state = TASK_INTERRUPTIBLE; 250 schedule(); 251 set_thread_flag(TIF_RESTORE_SIGMASK); 252 return -ERESTARTNOHAND; 253} 254 255#ifdef CONFIG_PPC32 256long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5, 257 int r6, int r7, int r8, struct pt_regs *regs) 258{ 259 return do_sigaltstack(uss, uoss, regs->gpr[1]); 260} 261#endif 262 263long sys_sigaction(int sig, struct old_sigaction __user *act, 264 struct old_sigaction __user *oact) 265{ 266 struct k_sigaction new_ka, old_ka; 267 int ret; 268 269#ifdef CONFIG_PPC64 270 if (sig < 0) 271 sig = -sig; 272#endif 273 274 if (act) { 275 if (get_old_sigaction(&new_ka, act)) 276 return -EFAULT; 277 } 278 279 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 280 if (!ret && oact) { 281 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 282 __put_user(to_user_ptr(old_ka.sa.sa_handler), 283 &oact->sa_handler) || 284 __put_user(to_user_ptr(old_ka.sa.sa_restorer), 285 &oact->sa_restorer) || 286 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 287 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 288 return -EFAULT; 289 } 290 291 return ret; 292} 293 294/* 295 * When we have signals to deliver, we set up on the 296 * user stack, going down from the original stack pointer: 297 * a sigregs struct 298 * a sigcontext struct 299 * a gap of __SIGNAL_FRAMESIZE bytes 300 * 301 * Each of these things must be a multiple of 16 bytes in size. 302 * 303 */ 304struct sigregs { 305 struct mcontext mctx; /* all the register values */ 306 /* 307 * Programs using the rs6000/xcoff abi can save up to 19 gp 308 * regs and 18 fp regs below sp before decrementing it. 309 */ 310 int abigap[56]; 311}; 312 313/* We use the mc_pad field for the signal return trampoline. */ 314#define tramp mc_pad 315 316/* 317 * When we have rt signals to deliver, we set up on the 318 * user stack, going down from the original stack pointer: 319 * one rt_sigframe struct (siginfo + ucontext + ABI gap) 320 * a gap of __SIGNAL_FRAMESIZE+16 bytes 321 * (the +16 is to get the siginfo and ucontext in the same 322 * positions as in older kernels). 323 * 324 * Each of these things must be a multiple of 16 bytes in size. 325 * 326 */ 327struct rt_sigframe { 328#ifdef CONFIG_PPC64 329 compat_siginfo_t info; 330#else 331 struct siginfo info; 332#endif 333 struct ucontext uc; 334 /* 335 * Programs using the rs6000/xcoff abi can save up to 19 gp 336 * regs and 18 fp regs below sp before decrementing it. 337 */ 338 int abigap[56]; 339}; 340 341/* 342 * Save the current user registers on the user stack. 343 * We only save the altivec/spe registers if the process has used 344 * altivec/spe instructions at some point. 345 */ 346static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame, 347 int sigret) 348{ 349 /* Make sure floating point registers are stored in regs */ 350 flush_fp_to_thread(current); 351 352 /* save general and floating-point registers */ 353 if (save_general_regs(regs, frame) || 354 __copy_to_user(&frame->mc_fregs, current->thread.fpr, 355 ELF_NFPREG * sizeof(double))) 356 return 1; 357 358#ifdef CONFIG_ALTIVEC 359 /* save altivec registers */ 360 if (current->thread.used_vr) { 361 flush_altivec_to_thread(current); 362 if (__copy_to_user(&frame->mc_vregs, current->thread.vr, 363 ELF_NVRREG * sizeof(vector128))) 364 return 1; 365 /* set MSR_VEC in the saved MSR value to indicate that 366 frame->mc_vregs contains valid data */ 367 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR])) 368 return 1; 369 } 370 /* else assert((regs->msr & MSR_VEC) == 0) */ 371 372 /* We always copy to/from vrsave, it's 0 if we don't have or don't 373 * use altivec. Since VSCR only contains 32 bits saved in the least 374 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 375 * most significant bits of that same vector. --BenH 376 */ 377 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32])) 378 return 1; 379#endif /* CONFIG_ALTIVEC */ 380 381#ifdef CONFIG_SPE 382 /* save spe registers */ 383 if (current->thread.used_spe) { 384 flush_spe_to_thread(current); 385 if (__copy_to_user(&frame->mc_vregs, current->thread.evr, 386 ELF_NEVRREG * sizeof(u32))) 387 return 1; 388 /* set MSR_SPE in the saved MSR value to indicate that 389 frame->mc_vregs contains valid data */ 390 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR])) 391 return 1; 392 } 393 /* else assert((regs->msr & MSR_SPE) == 0) */ 394 395 /* We always copy to/from spefscr */ 396 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG)) 397 return 1; 398#endif /* CONFIG_SPE */ 399 400 if (sigret) { 401 /* Set up the sigreturn trampoline: li r0,sigret; sc */ 402 if (__put_user(0x38000000UL + sigret, &frame->tramp[0]) 403 || __put_user(0x44000002UL, &frame->tramp[1])) 404 return 1; 405 flush_icache_range((unsigned long) &frame->tramp[0], 406 (unsigned long) &frame->tramp[2]); 407 } 408 409 return 0; 410} 411 412/* 413 * Restore the current user register values from the user stack, 414 * (except for MSR). 415 */ 416static long restore_user_regs(struct pt_regs *regs, 417 struct mcontext __user *sr, int sig) 418{ 419 long err; 420 unsigned int save_r2 = 0; 421 unsigned long msr; 422 423 /* 424 * restore general registers but not including MSR or SOFTE. Also 425 * take care of keeping r2 (TLS) intact if not a signal 426 */ 427 if (!sig) 428 save_r2 = (unsigned int)regs->gpr[2]; 429 err = restore_general_regs(regs, sr); 430 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]); 431 if (!sig) 432 regs->gpr[2] = (unsigned long) save_r2; 433 if (err) 434 return 1; 435 436 /* if doing signal return, restore the previous little-endian mode */ 437 if (sig) 438 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE); 439 440 /* 441 * Do this before updating the thread state in 442 * current->thread.fpr/vr/evr. That way, if we get preempted 443 * and another task grabs the FPU/Altivec/SPE, it won't be 444 * tempted to save the current CPU state into the thread_struct 445 * and corrupt what we are writing there. 446 */ 447 discard_lazy_cpu_state(); 448 449 /* force the process to reload the FP registers from 450 current->thread when it next does FP instructions */ 451 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 452 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs, 453 sizeof(sr->mc_fregs))) 454 return 1; 455 456#ifdef CONFIG_ALTIVEC 457 /* force the process to reload the altivec registers from 458 current->thread when it next does altivec instructions */ 459 regs->msr &= ~MSR_VEC; 460 if (msr & MSR_VEC) { 461 /* restore altivec registers from the stack */ 462 if (__copy_from_user(current->thread.vr, &sr->mc_vregs, 463 sizeof(sr->mc_vregs))) 464 return 1; 465 } else if (current->thread.used_vr) 466 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128)); 467 468 /* Always get VRSAVE back */ 469 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32])) 470 return 1; 471#endif /* CONFIG_ALTIVEC */ 472 473#ifdef CONFIG_SPE 474 /* force the process to reload the spe registers from 475 current->thread when it next does spe instructions */ 476 regs->msr &= ~MSR_SPE; 477 if (msr & MSR_SPE) { 478 /* restore spe registers from the stack */ 479 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 480 ELF_NEVRREG * sizeof(u32))) 481 return 1; 482 } else if (current->thread.used_spe) 483 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 484 485 /* Always get SPEFSCR back */ 486 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG)) 487 return 1; 488#endif /* CONFIG_SPE */ 489 490 return 0; 491} 492 493#ifdef CONFIG_PPC64 494long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act, 495 struct sigaction32 __user *oact, size_t sigsetsize) 496{ 497 struct k_sigaction new_ka, old_ka; 498 int ret; 499 500 /* XXX: Don't preclude handling different sized sigset_t's. */ 501 if (sigsetsize != sizeof(compat_sigset_t)) 502 return -EINVAL; 503 504 if (act) { 505 compat_uptr_t handler; 506 507 ret = get_user(handler, &act->sa_handler); 508 new_ka.sa.sa_handler = compat_ptr(handler); 509 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask); 510 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 511 if (ret) 512 return -EFAULT; 513 } 514 515 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 516 if (!ret && oact) { 517 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler); 518 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask); 519 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 520 } 521 return ret; 522} 523 524/* 525 * Note: it is necessary to treat how as an unsigned int, with the 526 * corresponding cast to a signed int to insure that the proper 527 * conversion (sign extension) between the register representation 528 * of a signed int (msr in 32-bit mode) and the register representation 529 * of a signed int (msr in 64-bit mode) is performed. 530 */ 531long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set, 532 compat_sigset_t __user *oset, size_t sigsetsize) 533{ 534 sigset_t s; 535 sigset_t __user *up; 536 int ret; 537 mm_segment_t old_fs = get_fs(); 538 539 if (set) { 540 if (get_sigset_t(&s, set)) 541 return -EFAULT; 542 } 543 544 set_fs(KERNEL_DS); 545 /* This is valid because of the set_fs() */ 546 up = (sigset_t __user *) &s; 547 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL, 548 sigsetsize); 549 set_fs(old_fs); 550 if (ret) 551 return ret; 552 if (oset) { 553 if (put_sigset_t(oset, &s)) 554 return -EFAULT; 555 } 556 return 0; 557} 558 559long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize) 560{ 561 sigset_t s; 562 int ret; 563 mm_segment_t old_fs = get_fs(); 564 565 set_fs(KERNEL_DS); 566 /* The __user pointer cast is valid because of the set_fs() */ 567 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize); 568 set_fs(old_fs); 569 if (!ret) { 570 if (put_sigset_t(set, &s)) 571 return -EFAULT; 572 } 573 return ret; 574} 575 576 577int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s) 578{ 579 int err; 580 581 if (!access_ok (VERIFY_WRITE, d, sizeof(*d))) 582 return -EFAULT; 583 584 /* If you change siginfo_t structure, please be sure 585 * this code is fixed accordingly. 586 * It should never copy any pad contained in the structure 587 * to avoid security leaks, but must copy the generic 588 * 3 ints plus the relevant union member. 589 * This routine must convert siginfo from 64bit to 32bit as well 590 * at the same time. 591 */ 592 err = __put_user(s->si_signo, &d->si_signo); 593 err |= __put_user(s->si_errno, &d->si_errno); 594 err |= __put_user((short)s->si_code, &d->si_code); 595 if (s->si_code < 0) 596 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad, 597 SI_PAD_SIZE32); 598 else switch(s->si_code >> 16) { 599 case __SI_CHLD >> 16: 600 err |= __put_user(s->si_pid, &d->si_pid); 601 err |= __put_user(s->si_uid, &d->si_uid); 602 err |= __put_user(s->si_utime, &d->si_utime); 603 err |= __put_user(s->si_stime, &d->si_stime); 604 err |= __put_user(s->si_status, &d->si_status); 605 break; 606 case __SI_FAULT >> 16: 607 err |= __put_user((unsigned int)(unsigned long)s->si_addr, 608 &d->si_addr); 609 break; 610 case __SI_POLL >> 16: 611 err |= __put_user(s->si_band, &d->si_band); 612 err |= __put_user(s->si_fd, &d->si_fd); 613 break; 614 case __SI_TIMER >> 16: 615 err |= __put_user(s->si_tid, &d->si_tid); 616 err |= __put_user(s->si_overrun, &d->si_overrun); 617 err |= __put_user(s->si_int, &d->si_int); 618 break; 619 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 620 case __SI_MESGQ >> 16: 621 err |= __put_user(s->si_int, &d->si_int); 622 /* fallthrough */ 623 case __SI_KILL >> 16: 624 default: 625 err |= __put_user(s->si_pid, &d->si_pid); 626 err |= __put_user(s->si_uid, &d->si_uid); 627 break; 628 } 629 return err; 630} 631 632#define copy_siginfo_to_user copy_siginfo_to_user32 633 634/* 635 * Note: it is necessary to treat pid and sig as unsigned ints, with the 636 * corresponding cast to a signed int to insure that the proper conversion 637 * (sign extension) between the register representation of a signed int 638 * (msr in 32-bit mode) and the register representation of a signed int 639 * (msr in 64-bit mode) is performed. 640 */ 641long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo) 642{ 643 siginfo_t info; 644 int ret; 645 mm_segment_t old_fs = get_fs(); 646 647 if (copy_from_user (&info, uinfo, 3*sizeof(int)) || 648 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32)) 649 return -EFAULT; 650 set_fs (KERNEL_DS); 651 /* The __user pointer cast is valid becasuse of the set_fs() */ 652 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info); 653 set_fs (old_fs); 654 return ret; 655} 656/* 657 * Start Alternate signal stack support 658 * 659 * System Calls 660 * sigaltatck compat_sys_sigaltstack 661 */ 662 663int compat_sys_sigaltstack(u32 __new, u32 __old, int r5, 664 int r6, int r7, int r8, struct pt_regs *regs) 665{ 666 stack_32_t __user * newstack = compat_ptr(__new); 667 stack_32_t __user * oldstack = compat_ptr(__old); 668 stack_t uss, uoss; 669 int ret; 670 mm_segment_t old_fs; 671 unsigned long sp; 672 compat_uptr_t ss_sp; 673 674 /* 675 * set sp to the user stack on entry to the system call 676 * the system call router sets R9 to the saved registers 677 */ 678 sp = regs->gpr[1]; 679 680 /* Put new stack info in local 64 bit stack struct */ 681 if (newstack) { 682 if (get_user(ss_sp, &newstack->ss_sp) || 683 __get_user(uss.ss_flags, &newstack->ss_flags) || 684 __get_user(uss.ss_size, &newstack->ss_size)) 685 return -EFAULT; 686 uss.ss_sp = compat_ptr(ss_sp); 687 } 688 689 old_fs = get_fs(); 690 set_fs(KERNEL_DS); 691 /* The __user pointer casts are valid because of the set_fs() */ 692 ret = do_sigaltstack( 693 newstack ? (stack_t __user *) &uss : NULL, 694 oldstack ? (stack_t __user *) &uoss : NULL, 695 sp); 696 set_fs(old_fs); 697 /* Copy the stack information to the user output buffer */ 698 if (!ret && oldstack && 699 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) || 700 __put_user(uoss.ss_flags, &oldstack->ss_flags) || 701 __put_user(uoss.ss_size, &oldstack->ss_size))) 702 return -EFAULT; 703 return ret; 704} 705#endif /* CONFIG_PPC64 */ 706 707 708/* 709 * Restore the user process's signal mask 710 */ 711#ifdef CONFIG_PPC64 712extern void restore_sigmask(sigset_t *set); 713#else /* CONFIG_PPC64 */ 714static void restore_sigmask(sigset_t *set) 715{ 716 sigdelsetmask(set, ~_BLOCKABLE); 717 spin_lock_irq(¤t->sighand->siglock); 718 current->blocked = *set; 719 recalc_sigpending(); 720 spin_unlock_irq(¤t->sighand->siglock); 721} 722#endif 723 724/* 725 * Set up a signal frame for a "real-time" signal handler 726 * (one which gets siginfo). 727 */ 728static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka, 729 siginfo_t *info, sigset_t *oldset, 730 struct pt_regs *regs, unsigned long newsp) 731{ 732 struct rt_sigframe __user *rt_sf; 733 struct mcontext __user *frame; 734 unsigned long origsp = newsp; 735 736 /* Set up Signal Frame */ 737 /* Put a Real Time Context onto stack */ 738 newsp -= sizeof(*rt_sf); 739 rt_sf = (struct rt_sigframe __user *)newsp; 740 741 /* create a stack frame for the caller of the handler */ 742 newsp -= __SIGNAL_FRAMESIZE + 16; 743 744 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp)) 745 goto badframe; 746 747 /* Put the siginfo & fill in most of the ucontext */ 748 if (copy_siginfo_to_user(&rt_sf->info, info) 749 || __put_user(0, &rt_sf->uc.uc_flags) 750 || __put_user(0, &rt_sf->uc.uc_link) 751 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp) 752 || __put_user(sas_ss_flags(regs->gpr[1]), 753 &rt_sf->uc.uc_stack.ss_flags) 754 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size) 755 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext), 756 &rt_sf->uc.uc_regs) 757 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset)) 758 goto badframe; 759 760 /* Save user registers on the stack */ 761 frame = &rt_sf->uc.uc_mcontext; 762 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) { 763 if (save_user_regs(regs, frame, 0)) 764 goto badframe; 765 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp; 766 } else { 767 if (save_user_regs(regs, frame, __NR_rt_sigreturn)) 768 goto badframe; 769 regs->link = (unsigned long) frame->tramp; 770 } 771 772 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 773 774 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 775 goto badframe; 776 regs->gpr[1] = newsp; 777 regs->gpr[3] = sig; 778 regs->gpr[4] = (unsigned long) &rt_sf->info; 779 regs->gpr[5] = (unsigned long) &rt_sf->uc; 780 regs->gpr[6] = (unsigned long) rt_sf; 781 regs->nip = (unsigned long) ka->sa.sa_handler; 782 /* enter the signal handler in big-endian mode */ 783 regs->msr &= ~MSR_LE; 784 regs->trap = 0; 785 return 1; 786 787badframe: 788#ifdef DEBUG_SIG 789 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n", 790 regs, frame, newsp); 791#endif 792 force_sigsegv(sig, current); 793 return 0; 794} 795 796static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig) 797{ 798 sigset_t set; 799 struct mcontext __user *mcp; 800 801 if (get_sigset_t(&set, &ucp->uc_sigmask)) 802 return -EFAULT; 803#ifdef CONFIG_PPC64 804 { 805 u32 cmcp; 806 807 if (__get_user(cmcp, &ucp->uc_regs)) 808 return -EFAULT; 809 mcp = (struct mcontext __user *)(u64)cmcp; 810 /* no need to check access_ok(mcp), since mcp < 4GB */ 811 } 812#else 813 if (__get_user(mcp, &ucp->uc_regs)) 814 return -EFAULT; 815 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp))) 816 return -EFAULT; 817#endif 818 restore_sigmask(&set); 819 if (restore_user_regs(regs, mcp, sig)) 820 return -EFAULT; 821 822 return 0; 823} 824 825long sys_swapcontext(struct ucontext __user *old_ctx, 826 struct ucontext __user *new_ctx, 827 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs) 828{ 829 unsigned char tmp; 830 831 /* Context size is for future use. Right now, we only make sure 832 * we are passed something we understand 833 */ 834 if (ctx_size < sizeof(struct ucontext)) 835 return -EINVAL; 836 837 if (old_ctx != NULL) { 838 struct mcontext __user *mctx; 839 840 /* 841 * old_ctx might not be 16-byte aligned, in which 842 * case old_ctx->uc_mcontext won't be either. 843 * Because we have the old_ctx->uc_pad2 field 844 * before old_ctx->uc_mcontext, we need to round down 845 * from &old_ctx->uc_mcontext to a 16-byte boundary. 846 */ 847 mctx = (struct mcontext __user *) 848 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL); 849 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx)) 850 || save_user_regs(regs, mctx, 0) 851 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) 852 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs)) 853 return -EFAULT; 854 } 855 if (new_ctx == NULL) 856 return 0; 857 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx)) 858 || __get_user(tmp, (u8 __user *) new_ctx) 859 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1)) 860 return -EFAULT; 861 862 /* 863 * If we get a fault copying the context into the kernel's 864 * image of the user's registers, we can't just return -EFAULT 865 * because the user's registers will be corrupted. For instance 866 * the NIP value may have been updated but not some of the 867 * other registers. Given that we have done the access_ok 868 * and successfully read the first and last bytes of the region 869 * above, this should only happen in an out-of-memory situation 870 * or if another thread unmaps the region containing the context. 871 * We kill the task with a SIGSEGV in this situation. 872 */ 873 if (do_setcontext(new_ctx, regs, 0)) 874 do_exit(SIGSEGV); 875 876 set_thread_flag(TIF_RESTOREALL); 877 return 0; 878} 879 880long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 881 struct pt_regs *regs) 882{ 883 struct rt_sigframe __user *rt_sf; 884 885 /* Always make any pending restarted system calls return -EINTR */ 886 current_thread_info()->restart_block.fn = do_no_restart_syscall; 887 888 rt_sf = (struct rt_sigframe __user *) 889 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 890 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf))) 891 goto bad; 892 if (do_setcontext(&rt_sf->uc, regs, 1)) 893 goto bad; 894 895 /* 896 * It's not clear whether or why it is desirable to save the 897 * sigaltstack setting on signal delivery and restore it on 898 * signal return. But other architectures do this and we have 899 * always done it up until now so it is probably better not to 900 * change it. -- paulus 901 */ 902#ifdef CONFIG_PPC64 903 /* 904 * We use the compat_sys_ version that does the 32/64 bits conversion 905 * and takes userland pointer directly. What about error checking ? 906 * nobody does any... 907 */ 908 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs); 909#else 910 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]); 911#endif 912 set_thread_flag(TIF_RESTOREALL); 913 return 0; 914 915 bad: 916 force_sig(SIGSEGV, current); 917 return 0; 918} 919 920#ifdef CONFIG_PPC32 921int sys_debug_setcontext(struct ucontext __user *ctx, 922 int ndbg, struct sig_dbg_op __user *dbg, 923 int r6, int r7, int r8, 924 struct pt_regs *regs) 925{ 926 struct sig_dbg_op op; 927 int i; 928 unsigned char tmp; 929 unsigned long new_msr = regs->msr; 930#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 931 unsigned long new_dbcr0 = current->thread.dbcr0; 932#endif 933 934 for (i=0; i<ndbg; i++) { 935 if (copy_from_user(&op, dbg + i, sizeof(op))) 936 return -EFAULT; 937 switch (op.dbg_type) { 938 case SIG_DBG_SINGLE_STEPPING: 939#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 940 if (op.dbg_value) { 941 new_msr |= MSR_DE; 942 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 943 } else { 944 new_msr &= ~MSR_DE; 945 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC); 946 } 947#else 948 if (op.dbg_value) 949 new_msr |= MSR_SE; 950 else 951 new_msr &= ~MSR_SE; 952#endif 953 break; 954 case SIG_DBG_BRANCH_TRACING: 955#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 956 return -EINVAL; 957#else 958 if (op.dbg_value) 959 new_msr |= MSR_BE; 960 else 961 new_msr &= ~MSR_BE; 962#endif 963 break; 964 965 default: 966 return -EINVAL; 967 } 968 } 969 970 /* We wait until here to actually install the values in the 971 registers so if we fail in the above loop, it will not 972 affect the contents of these registers. After this point, 973 failure is a problem, anyway, and it's very unlikely unless 974 the user is really doing something wrong. */ 975 regs->msr = new_msr; 976#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE) 977 current->thread.dbcr0 = new_dbcr0; 978#endif 979 980 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) 981 || __get_user(tmp, (u8 __user *) ctx) 982 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1)) 983 return -EFAULT; 984 985 /* 986 * If we get a fault copying the context into the kernel's 987 * image of the user's registers, we can't just return -EFAULT 988 * because the user's registers will be corrupted. For instance 989 * the NIP value may have been updated but not some of the 990 * other registers. Given that we have done the access_ok 991 * and successfully read the first and last bytes of the region 992 * above, this should only happen in an out-of-memory situation 993 * or if another thread unmaps the region containing the context. 994 * We kill the task with a SIGSEGV in this situation. 995 */ 996 if (do_setcontext(ctx, regs, 1)) { 997 force_sig(SIGSEGV, current); 998 goto out; 999 } 1000 1001 /* 1002 * It's not clear whether or why it is desirable to save the 1003 * sigaltstack setting on signal delivery and restore it on 1004 * signal return. But other architectures do this and we have 1005 * always done it up until now so it is probably better not to 1006 * change it. -- paulus 1007 */ 1008 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]); 1009 1010 set_thread_flag(TIF_RESTOREALL); 1011 out: 1012 return 0; 1013} 1014#endif 1015 1016/* 1017 * OK, we're invoking a handler 1018 */ 1019static int handle_signal(unsigned long sig, struct k_sigaction *ka, 1020 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs, 1021 unsigned long newsp) 1022{ 1023 struct sigcontext __user *sc; 1024 struct sigregs __user *frame; 1025 unsigned long origsp = newsp; 1026 1027 /* Set up Signal Frame */ 1028 newsp -= sizeof(struct sigregs); 1029 frame = (struct sigregs __user *) newsp; 1030 1031 /* Put a sigcontext on the stack */ 1032 newsp -= sizeof(*sc); 1033 sc = (struct sigcontext __user *) newsp; 1034 1035 /* create a stack frame for the caller of the handler */ 1036 newsp -= __SIGNAL_FRAMESIZE; 1037 1038 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp)) 1039 goto badframe; 1040 1041#if _NSIG != 64 1042#error "Please adjust handle_signal()" 1043#endif 1044 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler) 1045 || __put_user(oldset->sig[0], &sc->oldmask) 1046#ifdef CONFIG_PPC64 1047 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3]) 1048#else 1049 || __put_user(oldset->sig[1], &sc->_unused[3]) 1050#endif 1051 || __put_user(to_user_ptr(frame), &sc->regs) 1052 || __put_user(sig, &sc->signal)) 1053 goto badframe; 1054 1055 if (vdso32_sigtramp && current->mm->context.vdso_base) { 1056 if (save_user_regs(regs, &frame->mctx, 0)) 1057 goto badframe; 1058 regs->link = current->mm->context.vdso_base + vdso32_sigtramp; 1059 } else { 1060 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn)) 1061 goto badframe; 1062 regs->link = (unsigned long) frame->mctx.tramp; 1063 } 1064 1065 current->thread.fpscr.val = 0; /* turn off all fp exceptions */ 1066 1067 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1068 goto badframe; 1069 regs->gpr[1] = newsp; 1070 regs->gpr[3] = sig; 1071 regs->gpr[4] = (unsigned long) sc; 1072 regs->nip = (unsigned long) ka->sa.sa_handler; 1073 /* enter the signal handler in big-endian mode */ 1074 regs->msr &= ~MSR_LE; 1075 regs->trap = 0; 1076 1077 return 1; 1078 1079badframe: 1080#ifdef DEBUG_SIG 1081 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n", 1082 regs, frame, newsp); 1083#endif 1084 force_sigsegv(sig, current); 1085 return 0; 1086} 1087 1088/* 1089 * Do a signal return; undo the signal stack. 1090 */ 1091long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1092 struct pt_regs *regs) 1093{ 1094 struct sigcontext __user *sc; 1095 struct sigcontext sigctx; 1096 struct mcontext __user *sr; 1097 sigset_t set; 1098 1099 /* Always make any pending restarted system calls return -EINTR */ 1100 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1101 1102 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); 1103 if (copy_from_user(&sigctx, sc, sizeof(sigctx))) 1104 goto badframe; 1105 1106#ifdef CONFIG_PPC64 1107 /* 1108 * Note that PPC32 puts the upper 32 bits of the sigmask in the 1109 * unused part of the signal stackframe 1110 */ 1111 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32); 1112#else 1113 set.sig[0] = sigctx.oldmask; 1114 set.sig[1] = sigctx._unused[3]; 1115#endif 1116 restore_sigmask(&set); 1117 1118 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs); 1119 if (!access_ok(VERIFY_READ, sr, sizeof(*sr)) 1120 || restore_user_regs(regs, sr, 1)) 1121 goto badframe; 1122 1123 set_thread_flag(TIF_RESTOREALL); 1124 return 0; 1125 1126badframe: 1127 force_sig(SIGSEGV, current); 1128 return 0; 1129} 1130 1131/* 1132 * Note that 'init' is a special process: it doesn't get signals it doesn't 1133 * want to handle. Thus you cannot kill init even with a SIGKILL even by 1134 * mistake. 1135 */ 1136int do_signal(sigset_t *oldset, struct pt_regs *regs) 1137{ 1138 siginfo_t info; 1139 struct k_sigaction ka; 1140 unsigned int newsp; 1141 int signr, ret; 1142 1143#ifdef CONFIG_PPC32 1144 if (try_to_freeze()) { 1145 signr = 0; 1146 if (!signal_pending(current)) 1147 goto no_signal; 1148 } 1149#endif 1150 1151 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1152 oldset = ¤t->saved_sigmask; 1153 else if (!oldset) 1154 oldset = ¤t->blocked; 1155 1156 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 1157#ifdef CONFIG_PPC32 1158no_signal: 1159#endif 1160 if (TRAP(regs) == 0x0C00 /* System Call! */ 1161 && regs->ccr & 0x10000000 /* error signalled */ 1162 && ((ret = regs->gpr[3]) == ERESTARTSYS 1163 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR 1164 || ret == ERESTART_RESTARTBLOCK)) { 1165 1166 if (signr > 0 1167 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK 1168 || (ret == ERESTARTSYS 1169 && !(ka.sa.sa_flags & SA_RESTART)))) { 1170 /* make the system call return an EINTR error */ 1171 regs->result = -EINTR; 1172 regs->gpr[3] = EINTR; 1173 /* note that the cr0.SO bit is already set */ 1174 } else { 1175 regs->nip -= 4; /* Back up & retry system call */ 1176 regs->result = 0; 1177 regs->trap = 0; 1178 if (ret == ERESTART_RESTARTBLOCK) 1179 regs->gpr[0] = __NR_restart_syscall; 1180 else 1181 regs->gpr[3] = regs->orig_gpr3; 1182 } 1183 } 1184 1185 if (signr == 0) { 1186 /* No signal to deliver -- put the saved sigmask back */ 1187 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 1188 clear_thread_flag(TIF_RESTORE_SIGMASK); 1189 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 1190 } 1191 return 0; /* no signals delivered */ 1192 } 1193 1194 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size 1195 && !on_sig_stack(regs->gpr[1])) 1196 newsp = current->sas_ss_sp + current->sas_ss_size; 1197 else 1198 newsp = regs->gpr[1]; 1199 newsp &= ~0xfUL; 1200 1201#ifdef CONFIG_PPC64 1202 /* 1203 * Reenable the DABR before delivering the signal to 1204 * user space. The DABR will have been cleared if it 1205 * triggered inside the kernel. 1206 */ 1207 if (current->thread.dabr) 1208 set_dabr(current->thread.dabr); 1209#endif 1210 1211 /* Whee! Actually deliver the signal. */ 1212 if (ka.sa.sa_flags & SA_SIGINFO) 1213 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp); 1214 else 1215 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp); 1216 1217 if (ret) { 1218 spin_lock_irq(¤t->sighand->siglock); 1219 sigorsets(¤t->blocked, ¤t->blocked, 1220 &ka.sa.sa_mask); 1221 if (!(ka.sa.sa_flags & SA_NODEFER)) 1222 sigaddset(¤t->blocked, signr); 1223 recalc_sigpending(); 1224 spin_unlock_irq(¤t->sighand->siglock); 1225 /* A signal was successfully delivered; the saved sigmask is in 1226 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */ 1227 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 1228 clear_thread_flag(TIF_RESTORE_SIGMASK); 1229 } 1230 1231 return ret; 1232} 1233