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