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