signal_32.c revision d31626f70b6103f4d9153b75d07e0e8795728cc9
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#include <asm/tm.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#include "signal.h" 56 57#undef DEBUG_SIG 58 59#ifdef CONFIG_PPC64 60#define sys_rt_sigreturn compat_sys_rt_sigreturn 61#define sys_swapcontext compat_sys_swapcontext 62#define sys_sigreturn compat_sys_sigreturn 63 64#define old_sigaction old_sigaction32 65#define sigcontext sigcontext32 66#define mcontext mcontext32 67#define ucontext ucontext32 68 69#define __save_altstack __compat_save_altstack 70 71/* 72 * Userspace code may pass a ucontext which doesn't include VSX added 73 * at the end. We need to check for this case. 74 */ 75#define UCONTEXTSIZEWITHOUTVSX \ 76 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32)) 77 78/* 79 * Returning 0 means we return to userspace via 80 * ret_from_except and thus restore all user 81 * registers from *regs. This is what we need 82 * to do when a signal has been delivered. 83 */ 84 85#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32)) 86#undef __SIGNAL_FRAMESIZE 87#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32 88#undef ELF_NVRREG 89#define ELF_NVRREG ELF_NVRREG32 90 91/* 92 * Functions for flipping sigsets (thanks to brain dead generic 93 * implementation that makes things simple for little endian only) 94 */ 95static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set) 96{ 97 compat_sigset_t cset; 98 99 switch (_NSIG_WORDS) { 100 case 4: cset.sig[6] = set->sig[3] & 0xffffffffull; 101 cset.sig[7] = set->sig[3] >> 32; 102 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull; 103 cset.sig[5] = set->sig[2] >> 32; 104 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull; 105 cset.sig[3] = set->sig[1] >> 32; 106 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull; 107 cset.sig[1] = set->sig[0] >> 32; 108 } 109 return copy_to_user(uset, &cset, sizeof(*uset)); 110} 111 112static inline int get_sigset_t(sigset_t *set, 113 const compat_sigset_t __user *uset) 114{ 115 compat_sigset_t s32; 116 117 if (copy_from_user(&s32, uset, sizeof(*uset))) 118 return -EFAULT; 119 120 /* 121 * Swap the 2 words of the 64-bit sigset_t (they are stored 122 * in the "wrong" endian in 32-bit user storage). 123 */ 124 switch (_NSIG_WORDS) { 125 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32); 126 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32); 127 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32); 128 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); 129 } 130 return 0; 131} 132 133#define to_user_ptr(p) ptr_to_compat(p) 134#define from_user_ptr(p) compat_ptr(p) 135 136static inline int save_general_regs(struct pt_regs *regs, 137 struct mcontext __user *frame) 138{ 139 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 140 int i; 141 142 WARN_ON(!FULL_REGS(regs)); 143 144 for (i = 0; i <= PT_RESULT; i ++) { 145 if (i == 14 && !FULL_REGS(regs)) 146 i = 32; 147 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i])) 148 return -EFAULT; 149 } 150 return 0; 151} 152 153static inline int restore_general_regs(struct pt_regs *regs, 154 struct mcontext __user *sr) 155{ 156 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 157 int i; 158 159 for (i = 0; i <= PT_RESULT; i++) { 160 if ((i == PT_MSR) || (i == PT_SOFTE)) 161 continue; 162 if (__get_user(gregs[i], &sr->mc_gregs[i])) 163 return -EFAULT; 164 } 165 return 0; 166} 167 168#else /* CONFIG_PPC64 */ 169 170#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs)) 171 172static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set) 173{ 174 return copy_to_user(uset, set, sizeof(*uset)); 175} 176 177static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset) 178{ 179 return copy_from_user(set, uset, sizeof(*uset)); 180} 181 182#define to_user_ptr(p) ((unsigned long)(p)) 183#define from_user_ptr(p) ((void __user *)(p)) 184 185static inline int save_general_regs(struct pt_regs *regs, 186 struct mcontext __user *frame) 187{ 188 WARN_ON(!FULL_REGS(regs)); 189 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE); 190} 191 192static inline int restore_general_regs(struct pt_regs *regs, 193 struct mcontext __user *sr) 194{ 195 /* copy up to but not including MSR */ 196 if (__copy_from_user(regs, &sr->mc_gregs, 197 PT_MSR * sizeof(elf_greg_t))) 198 return -EFAULT; 199 /* copy from orig_r3 (the word after the MSR) up to the end */ 200 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3], 201 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t))) 202 return -EFAULT; 203 return 0; 204} 205#endif 206 207/* 208 * When we have signals to deliver, we set up on the 209 * user stack, going down from the original stack pointer: 210 * an ABI gap of 56 words 211 * an mcontext struct 212 * a sigcontext struct 213 * a gap of __SIGNAL_FRAMESIZE bytes 214 * 215 * Each of these things must be a multiple of 16 bytes in size. The following 216 * structure represent all of this except the __SIGNAL_FRAMESIZE gap 217 * 218 */ 219struct sigframe { 220 struct sigcontext sctx; /* the sigcontext */ 221 struct mcontext mctx; /* all the register values */ 222#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 223 struct sigcontext sctx_transact; 224 struct mcontext mctx_transact; 225#endif 226 /* 227 * Programs using the rs6000/xcoff abi can save up to 19 gp 228 * regs and 18 fp regs below sp before decrementing it. 229 */ 230 int abigap[56]; 231}; 232 233/* We use the mc_pad field for the signal return trampoline. */ 234#define tramp mc_pad 235 236/* 237 * When we have rt signals to deliver, we set up on the 238 * user stack, going down from the original stack pointer: 239 * one rt_sigframe struct (siginfo + ucontext + ABI gap) 240 * a gap of __SIGNAL_FRAMESIZE+16 bytes 241 * (the +16 is to get the siginfo and ucontext in the same 242 * positions as in older kernels). 243 * 244 * Each of these things must be a multiple of 16 bytes in size. 245 * 246 */ 247struct rt_sigframe { 248#ifdef CONFIG_PPC64 249 compat_siginfo_t info; 250#else 251 struct siginfo info; 252#endif 253 struct ucontext uc; 254#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 255 struct ucontext uc_transact; 256#endif 257 /* 258 * Programs using the rs6000/xcoff abi can save up to 19 gp 259 * regs and 18 fp regs below sp before decrementing it. 260 */ 261 int abigap[56]; 262}; 263 264#ifdef CONFIG_VSX 265unsigned long copy_fpr_to_user(void __user *to, 266 struct task_struct *task) 267{ 268 u64 buf[ELF_NFPREG]; 269 int i; 270 271 /* save FPR copy to local buffer then write to the thread_struct */ 272 for (i = 0; i < (ELF_NFPREG - 1) ; i++) 273 buf[i] = task->thread.TS_FPR(i); 274 buf[i] = task->thread.fp_state.fpscr; 275 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double)); 276} 277 278unsigned long copy_fpr_from_user(struct task_struct *task, 279 void __user *from) 280{ 281 u64 buf[ELF_NFPREG]; 282 int i; 283 284 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double))) 285 return 1; 286 for (i = 0; i < (ELF_NFPREG - 1) ; i++) 287 task->thread.TS_FPR(i) = buf[i]; 288 task->thread.fp_state.fpscr = buf[i]; 289 290 return 0; 291} 292 293unsigned long copy_vsx_to_user(void __user *to, 294 struct task_struct *task) 295{ 296 u64 buf[ELF_NVSRHALFREG]; 297 int i; 298 299 /* save FPR copy to local buffer then write to the thread_struct */ 300 for (i = 0; i < ELF_NVSRHALFREG; i++) 301 buf[i] = task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET]; 302 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double)); 303} 304 305unsigned long copy_vsx_from_user(struct task_struct *task, 306 void __user *from) 307{ 308 u64 buf[ELF_NVSRHALFREG]; 309 int i; 310 311 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double))) 312 return 1; 313 for (i = 0; i < ELF_NVSRHALFREG ; i++) 314 task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i]; 315 return 0; 316} 317 318#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 319unsigned long copy_transact_fpr_to_user(void __user *to, 320 struct task_struct *task) 321{ 322 u64 buf[ELF_NFPREG]; 323 int i; 324 325 /* save FPR copy to local buffer then write to the thread_struct */ 326 for (i = 0; i < (ELF_NFPREG - 1) ; i++) 327 buf[i] = task->thread.TS_TRANS_FPR(i); 328 buf[i] = task->thread.transact_fp.fpscr; 329 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double)); 330} 331 332unsigned long copy_transact_fpr_from_user(struct task_struct *task, 333 void __user *from) 334{ 335 u64 buf[ELF_NFPREG]; 336 int i; 337 338 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double))) 339 return 1; 340 for (i = 0; i < (ELF_NFPREG - 1) ; i++) 341 task->thread.TS_TRANS_FPR(i) = buf[i]; 342 task->thread.transact_fp.fpscr = buf[i]; 343 344 return 0; 345} 346 347unsigned long copy_transact_vsx_to_user(void __user *to, 348 struct task_struct *task) 349{ 350 u64 buf[ELF_NVSRHALFREG]; 351 int i; 352 353 /* save FPR copy to local buffer then write to the thread_struct */ 354 for (i = 0; i < ELF_NVSRHALFREG; i++) 355 buf[i] = task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET]; 356 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double)); 357} 358 359unsigned long copy_transact_vsx_from_user(struct task_struct *task, 360 void __user *from) 361{ 362 u64 buf[ELF_NVSRHALFREG]; 363 int i; 364 365 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double))) 366 return 1; 367 for (i = 0; i < ELF_NVSRHALFREG ; i++) 368 task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = buf[i]; 369 return 0; 370} 371#endif /* CONFIG_PPC_TRANSACTIONAL_MEM */ 372#else 373inline unsigned long copy_fpr_to_user(void __user *to, 374 struct task_struct *task) 375{ 376 return __copy_to_user(to, task->thread.fp_state.fpr, 377 ELF_NFPREG * sizeof(double)); 378} 379 380inline unsigned long copy_fpr_from_user(struct task_struct *task, 381 void __user *from) 382{ 383 return __copy_from_user(task->thread.fp_state.fpr, from, 384 ELF_NFPREG * sizeof(double)); 385} 386 387#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 388inline unsigned long copy_transact_fpr_to_user(void __user *to, 389 struct task_struct *task) 390{ 391 return __copy_to_user(to, task->thread.transact_fp.fpr, 392 ELF_NFPREG * sizeof(double)); 393} 394 395inline unsigned long copy_transact_fpr_from_user(struct task_struct *task, 396 void __user *from) 397{ 398 return __copy_from_user(task->thread.transact_fp.fpr, from, 399 ELF_NFPREG * sizeof(double)); 400} 401#endif /* CONFIG_PPC_TRANSACTIONAL_MEM */ 402#endif 403 404/* 405 * Save the current user registers on the user stack. 406 * We only save the altivec/spe registers if the process has used 407 * altivec/spe instructions at some point. 408 */ 409static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame, 410 struct mcontext __user *tm_frame, int sigret, 411 int ctx_has_vsx_region) 412{ 413 unsigned long msr = regs->msr; 414 415 /* Make sure floating point registers are stored in regs */ 416 flush_fp_to_thread(current); 417 418 /* save general registers */ 419 if (save_general_regs(regs, frame)) 420 return 1; 421 422#ifdef CONFIG_ALTIVEC 423 /* save altivec registers */ 424 if (current->thread.used_vr) { 425 flush_altivec_to_thread(current); 426 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state, 427 ELF_NVRREG * sizeof(vector128))) 428 return 1; 429 /* set MSR_VEC in the saved MSR value to indicate that 430 frame->mc_vregs contains valid data */ 431 msr |= MSR_VEC; 432 } 433 /* else assert((regs->msr & MSR_VEC) == 0) */ 434 435 /* We always copy to/from vrsave, it's 0 if we don't have or don't 436 * use altivec. Since VSCR only contains 32 bits saved in the least 437 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 438 * most significant bits of that same vector. --BenH 439 * Note that the current VRSAVE value is in the SPR at this point. 440 */ 441 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 442 current->thread.vrsave = mfspr(SPRN_VRSAVE); 443 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32])) 444 return 1; 445#endif /* CONFIG_ALTIVEC */ 446 if (copy_fpr_to_user(&frame->mc_fregs, current)) 447 return 1; 448 449 /* 450 * Clear the MSR VSX bit to indicate there is no valid state attached 451 * to this context, except in the specific case below where we set it. 452 */ 453 msr &= ~MSR_VSX; 454#ifdef CONFIG_VSX 455 /* 456 * Copy VSR 0-31 upper half from thread_struct to local 457 * buffer, then write that to userspace. Also set MSR_VSX in 458 * the saved MSR value to indicate that frame->mc_vregs 459 * contains valid data 460 */ 461 if (current->thread.used_vsr && ctx_has_vsx_region) { 462 __giveup_vsx(current); 463 if (copy_vsx_to_user(&frame->mc_vsregs, current)) 464 return 1; 465 msr |= MSR_VSX; 466 } 467#endif /* CONFIG_VSX */ 468#ifdef CONFIG_SPE 469 /* save spe registers */ 470 if (current->thread.used_spe) { 471 flush_spe_to_thread(current); 472 if (__copy_to_user(&frame->mc_vregs, current->thread.evr, 473 ELF_NEVRREG * sizeof(u32))) 474 return 1; 475 /* set MSR_SPE in the saved MSR value to indicate that 476 frame->mc_vregs contains valid data */ 477 msr |= MSR_SPE; 478 } 479 /* else assert((regs->msr & MSR_SPE) == 0) */ 480 481 /* We always copy to/from spefscr */ 482 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG)) 483 return 1; 484#endif /* CONFIG_SPE */ 485 486 if (__put_user(msr, &frame->mc_gregs[PT_MSR])) 487 return 1; 488 /* We need to write 0 the MSR top 32 bits in the tm frame so that we 489 * can check it on the restore to see if TM is active 490 */ 491 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR])) 492 return 1; 493 494 if (sigret) { 495 /* Set up the sigreturn trampoline: li r0,sigret; sc */ 496 if (__put_user(0x38000000UL + sigret, &frame->tramp[0]) 497 || __put_user(0x44000002UL, &frame->tramp[1])) 498 return 1; 499 flush_icache_range((unsigned long) &frame->tramp[0], 500 (unsigned long) &frame->tramp[2]); 501 } 502 503 return 0; 504} 505 506#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 507/* 508 * Save the current user registers on the user stack. 509 * We only save the altivec/spe registers if the process has used 510 * altivec/spe instructions at some point. 511 * We also save the transactional registers to a second ucontext in the 512 * frame. 513 * 514 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts(). 515 */ 516static int save_tm_user_regs(struct pt_regs *regs, 517 struct mcontext __user *frame, 518 struct mcontext __user *tm_frame, int sigret) 519{ 520 unsigned long msr = regs->msr; 521 522 /* Remove TM bits from thread's MSR. The MSR in the sigcontext 523 * just indicates to userland that we were doing a transaction, but we 524 * don't want to return in transactional state. This also ensures 525 * that flush_fp_to_thread won't set TIF_RESTORE_TM again. 526 */ 527 regs->msr &= ~MSR_TS_MASK; 528 529 /* Make sure floating point registers are stored in regs */ 530 flush_fp_to_thread(current); 531 532 /* Save both sets of general registers */ 533 if (save_general_regs(¤t->thread.ckpt_regs, frame) 534 || save_general_regs(regs, tm_frame)) 535 return 1; 536 537 /* Stash the top half of the 64bit MSR into the 32bit MSR word 538 * of the transactional mcontext. This way we have a backward-compatible 539 * MSR in the 'normal' (checkpointed) mcontext and additionally one can 540 * also look at what type of transaction (T or S) was active at the 541 * time of the signal. 542 */ 543 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR])) 544 return 1; 545 546#ifdef CONFIG_ALTIVEC 547 /* save altivec registers */ 548 if (current->thread.used_vr) { 549 flush_altivec_to_thread(current); 550 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state, 551 ELF_NVRREG * sizeof(vector128))) 552 return 1; 553 if (msr & MSR_VEC) { 554 if (__copy_to_user(&tm_frame->mc_vregs, 555 ¤t->thread.transact_vr, 556 ELF_NVRREG * sizeof(vector128))) 557 return 1; 558 } else { 559 if (__copy_to_user(&tm_frame->mc_vregs, 560 ¤t->thread.vr_state, 561 ELF_NVRREG * sizeof(vector128))) 562 return 1; 563 } 564 565 /* set MSR_VEC in the saved MSR value to indicate that 566 * frame->mc_vregs contains valid data 567 */ 568 msr |= MSR_VEC; 569 } 570 571 /* We always copy to/from vrsave, it's 0 if we don't have or don't 572 * use altivec. Since VSCR only contains 32 bits saved in the least 573 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 574 * most significant bits of that same vector. --BenH 575 */ 576 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 577 current->thread.vrsave = mfspr(SPRN_VRSAVE); 578 if (__put_user(current->thread.vrsave, 579 (u32 __user *)&frame->mc_vregs[32])) 580 return 1; 581 if (msr & MSR_VEC) { 582 if (__put_user(current->thread.transact_vrsave, 583 (u32 __user *)&tm_frame->mc_vregs[32])) 584 return 1; 585 } else { 586 if (__put_user(current->thread.vrsave, 587 (u32 __user *)&tm_frame->mc_vregs[32])) 588 return 1; 589 } 590#endif /* CONFIG_ALTIVEC */ 591 592 if (copy_fpr_to_user(&frame->mc_fregs, current)) 593 return 1; 594 if (msr & MSR_FP) { 595 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current)) 596 return 1; 597 } else { 598 if (copy_fpr_to_user(&tm_frame->mc_fregs, current)) 599 return 1; 600 } 601 602#ifdef CONFIG_VSX 603 /* 604 * Copy VSR 0-31 upper half from thread_struct to local 605 * buffer, then write that to userspace. Also set MSR_VSX in 606 * the saved MSR value to indicate that frame->mc_vregs 607 * contains valid data 608 */ 609 if (current->thread.used_vsr) { 610 __giveup_vsx(current); 611 if (copy_vsx_to_user(&frame->mc_vsregs, current)) 612 return 1; 613 if (msr & MSR_VSX) { 614 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs, 615 current)) 616 return 1; 617 } else { 618 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current)) 619 return 1; 620 } 621 622 msr |= MSR_VSX; 623 } 624#endif /* CONFIG_VSX */ 625#ifdef CONFIG_SPE 626 /* SPE regs are not checkpointed with TM, so this section is 627 * simply the same as in save_user_regs(). 628 */ 629 if (current->thread.used_spe) { 630 flush_spe_to_thread(current); 631 if (__copy_to_user(&frame->mc_vregs, current->thread.evr, 632 ELF_NEVRREG * sizeof(u32))) 633 return 1; 634 /* set MSR_SPE in the saved MSR value to indicate that 635 * frame->mc_vregs contains valid data */ 636 msr |= MSR_SPE; 637 } 638 639 /* We always copy to/from spefscr */ 640 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG)) 641 return 1; 642#endif /* CONFIG_SPE */ 643 644 if (__put_user(msr, &frame->mc_gregs[PT_MSR])) 645 return 1; 646 if (sigret) { 647 /* Set up the sigreturn trampoline: li r0,sigret; sc */ 648 if (__put_user(0x38000000UL + sigret, &frame->tramp[0]) 649 || __put_user(0x44000002UL, &frame->tramp[1])) 650 return 1; 651 flush_icache_range((unsigned long) &frame->tramp[0], 652 (unsigned long) &frame->tramp[2]); 653 } 654 655 return 0; 656} 657#endif 658 659/* 660 * Restore the current user register values from the user stack, 661 * (except for MSR). 662 */ 663static long restore_user_regs(struct pt_regs *regs, 664 struct mcontext __user *sr, int sig) 665{ 666 long err; 667 unsigned int save_r2 = 0; 668 unsigned long msr; 669#ifdef CONFIG_VSX 670 int i; 671#endif 672 673 /* 674 * restore general registers but not including MSR or SOFTE. Also 675 * take care of keeping r2 (TLS) intact if not a signal 676 */ 677 if (!sig) 678 save_r2 = (unsigned int)regs->gpr[2]; 679 err = restore_general_regs(regs, sr); 680 regs->trap = 0; 681 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]); 682 if (!sig) 683 regs->gpr[2] = (unsigned long) save_r2; 684 if (err) 685 return 1; 686 687 /* if doing signal return, restore the previous little-endian mode */ 688 if (sig) 689 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE); 690 691 /* 692 * Do this before updating the thread state in 693 * current->thread.fpr/vr/evr. That way, if we get preempted 694 * and another task grabs the FPU/Altivec/SPE, it won't be 695 * tempted to save the current CPU state into the thread_struct 696 * and corrupt what we are writing there. 697 */ 698 discard_lazy_cpu_state(); 699 700#ifdef CONFIG_ALTIVEC 701 /* 702 * Force the process to reload the altivec registers from 703 * current->thread when it next does altivec instructions 704 */ 705 regs->msr &= ~MSR_VEC; 706 if (msr & MSR_VEC) { 707 /* restore altivec registers from the stack */ 708 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs, 709 sizeof(sr->mc_vregs))) 710 return 1; 711 } else if (current->thread.used_vr) 712 memset(¤t->thread.vr_state, 0, 713 ELF_NVRREG * sizeof(vector128)); 714 715 /* Always get VRSAVE back */ 716 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32])) 717 return 1; 718 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 719 mtspr(SPRN_VRSAVE, current->thread.vrsave); 720#endif /* CONFIG_ALTIVEC */ 721 if (copy_fpr_from_user(current, &sr->mc_fregs)) 722 return 1; 723 724#ifdef CONFIG_VSX 725 /* 726 * Force the process to reload the VSX registers from 727 * current->thread when it next does VSX instruction. 728 */ 729 regs->msr &= ~MSR_VSX; 730 if (msr & MSR_VSX) { 731 /* 732 * Restore altivec registers from the stack to a local 733 * buffer, then write this out to the thread_struct 734 */ 735 if (copy_vsx_from_user(current, &sr->mc_vsregs)) 736 return 1; 737 } else if (current->thread.used_vsr) 738 for (i = 0; i < 32 ; i++) 739 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0; 740#endif /* CONFIG_VSX */ 741 /* 742 * force the process to reload the FP registers from 743 * current->thread when it next does FP instructions 744 */ 745 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 746 747#ifdef CONFIG_SPE 748 /* force the process to reload the spe registers from 749 current->thread when it next does spe instructions */ 750 regs->msr &= ~MSR_SPE; 751 if (msr & MSR_SPE) { 752 /* restore spe registers from the stack */ 753 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 754 ELF_NEVRREG * sizeof(u32))) 755 return 1; 756 } else if (current->thread.used_spe) 757 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 758 759 /* Always get SPEFSCR back */ 760 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG)) 761 return 1; 762#endif /* CONFIG_SPE */ 763 764 return 0; 765} 766 767#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 768/* 769 * Restore the current user register values from the user stack, except for 770 * MSR, and recheckpoint the original checkpointed register state for processes 771 * in transactions. 772 */ 773static long restore_tm_user_regs(struct pt_regs *regs, 774 struct mcontext __user *sr, 775 struct mcontext __user *tm_sr) 776{ 777 long err; 778 unsigned long msr, msr_hi; 779#ifdef CONFIG_VSX 780 int i; 781#endif 782 783 /* 784 * restore general registers but not including MSR or SOFTE. Also 785 * take care of keeping r2 (TLS) intact if not a signal. 786 * See comment in signal_64.c:restore_tm_sigcontexts(); 787 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR 788 * were set by the signal delivery. 789 */ 790 err = restore_general_regs(regs, tm_sr); 791 err |= restore_general_regs(¤t->thread.ckpt_regs, sr); 792 793 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]); 794 795 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]); 796 if (err) 797 return 1; 798 799 /* Restore the previous little-endian mode */ 800 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE); 801 802 /* 803 * Do this before updating the thread state in 804 * current->thread.fpr/vr/evr. That way, if we get preempted 805 * and another task grabs the FPU/Altivec/SPE, it won't be 806 * tempted to save the current CPU state into the thread_struct 807 * and corrupt what we are writing there. 808 */ 809 discard_lazy_cpu_state(); 810 811#ifdef CONFIG_ALTIVEC 812 regs->msr &= ~MSR_VEC; 813 if (msr & MSR_VEC) { 814 /* restore altivec registers from the stack */ 815 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs, 816 sizeof(sr->mc_vregs)) || 817 __copy_from_user(¤t->thread.transact_vr, 818 &tm_sr->mc_vregs, 819 sizeof(sr->mc_vregs))) 820 return 1; 821 } else if (current->thread.used_vr) { 822 memset(¤t->thread.vr_state, 0, 823 ELF_NVRREG * sizeof(vector128)); 824 memset(¤t->thread.transact_vr, 0, 825 ELF_NVRREG * sizeof(vector128)); 826 } 827 828 /* Always get VRSAVE back */ 829 if (__get_user(current->thread.vrsave, 830 (u32 __user *)&sr->mc_vregs[32]) || 831 __get_user(current->thread.transact_vrsave, 832 (u32 __user *)&tm_sr->mc_vregs[32])) 833 return 1; 834 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 835 mtspr(SPRN_VRSAVE, current->thread.vrsave); 836#endif /* CONFIG_ALTIVEC */ 837 838 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 839 840 if (copy_fpr_from_user(current, &sr->mc_fregs) || 841 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs)) 842 return 1; 843 844#ifdef CONFIG_VSX 845 regs->msr &= ~MSR_VSX; 846 if (msr & MSR_VSX) { 847 /* 848 * Restore altivec registers from the stack to a local 849 * buffer, then write this out to the thread_struct 850 */ 851 if (copy_vsx_from_user(current, &sr->mc_vsregs) || 852 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs)) 853 return 1; 854 } else if (current->thread.used_vsr) 855 for (i = 0; i < 32 ; i++) { 856 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0; 857 current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0; 858 } 859#endif /* CONFIG_VSX */ 860 861#ifdef CONFIG_SPE 862 /* SPE regs are not checkpointed with TM, so this section is 863 * simply the same as in restore_user_regs(). 864 */ 865 regs->msr &= ~MSR_SPE; 866 if (msr & MSR_SPE) { 867 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 868 ELF_NEVRREG * sizeof(u32))) 869 return 1; 870 } else if (current->thread.used_spe) 871 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 872 873 /* Always get SPEFSCR back */ 874 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs 875 + ELF_NEVRREG)) 876 return 1; 877#endif /* CONFIG_SPE */ 878 879 /* Now, recheckpoint. This loads up all of the checkpointed (older) 880 * registers, including FP and V[S]Rs. After recheckpointing, the 881 * transactional versions should be loaded. 882 */ 883 tm_enable(); 884 /* This loads the checkpointed FP/VEC state, if used */ 885 tm_recheckpoint(¤t->thread, msr); 886 /* Get the top half of the MSR */ 887 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR])) 888 return 1; 889 /* Pull in MSR TM from user context */ 890 regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK); 891 892 /* This loads the speculative FP/VEC state, if used */ 893 if (msr & MSR_FP) { 894 do_load_up_transact_fpu(¤t->thread); 895 regs->msr |= (MSR_FP | current->thread.fpexc_mode); 896 } 897#ifdef CONFIG_ALTIVEC 898 if (msr & MSR_VEC) { 899 do_load_up_transact_altivec(¤t->thread); 900 regs->msr |= MSR_VEC; 901 } 902#endif 903 904 return 0; 905} 906#endif 907 908#ifdef CONFIG_PPC64 909int copy_siginfo_to_user32(struct compat_siginfo __user *d, const siginfo_t *s) 910{ 911 int err; 912 913 if (!access_ok (VERIFY_WRITE, d, sizeof(*d))) 914 return -EFAULT; 915 916 /* If you change siginfo_t structure, please be sure 917 * this code is fixed accordingly. 918 * It should never copy any pad contained in the structure 919 * to avoid security leaks, but must copy the generic 920 * 3 ints plus the relevant union member. 921 * This routine must convert siginfo from 64bit to 32bit as well 922 * at the same time. 923 */ 924 err = __put_user(s->si_signo, &d->si_signo); 925 err |= __put_user(s->si_errno, &d->si_errno); 926 err |= __put_user((short)s->si_code, &d->si_code); 927 if (s->si_code < 0) 928 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad, 929 SI_PAD_SIZE32); 930 else switch(s->si_code >> 16) { 931 case __SI_CHLD >> 16: 932 err |= __put_user(s->si_pid, &d->si_pid); 933 err |= __put_user(s->si_uid, &d->si_uid); 934 err |= __put_user(s->si_utime, &d->si_utime); 935 err |= __put_user(s->si_stime, &d->si_stime); 936 err |= __put_user(s->si_status, &d->si_status); 937 break; 938 case __SI_FAULT >> 16: 939 err |= __put_user((unsigned int)(unsigned long)s->si_addr, 940 &d->si_addr); 941 break; 942 case __SI_POLL >> 16: 943 err |= __put_user(s->si_band, &d->si_band); 944 err |= __put_user(s->si_fd, &d->si_fd); 945 break; 946 case __SI_TIMER >> 16: 947 err |= __put_user(s->si_tid, &d->si_tid); 948 err |= __put_user(s->si_overrun, &d->si_overrun); 949 err |= __put_user(s->si_int, &d->si_int); 950 break; 951 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 952 case __SI_MESGQ >> 16: 953 err |= __put_user(s->si_int, &d->si_int); 954 /* fallthrough */ 955 case __SI_KILL >> 16: 956 default: 957 err |= __put_user(s->si_pid, &d->si_pid); 958 err |= __put_user(s->si_uid, &d->si_uid); 959 break; 960 } 961 return err; 962} 963 964#define copy_siginfo_to_user copy_siginfo_to_user32 965 966int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from) 967{ 968 memset(to, 0, sizeof *to); 969 970 if (copy_from_user(to, from, 3*sizeof(int)) || 971 copy_from_user(to->_sifields._pad, 972 from->_sifields._pad, SI_PAD_SIZE32)) 973 return -EFAULT; 974 975 return 0; 976} 977#endif /* CONFIG_PPC64 */ 978 979/* 980 * Set up a signal frame for a "real-time" signal handler 981 * (one which gets siginfo). 982 */ 983int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka, 984 siginfo_t *info, sigset_t *oldset, 985 struct pt_regs *regs) 986{ 987 struct rt_sigframe __user *rt_sf; 988 struct mcontext __user *frame; 989 struct mcontext __user *tm_frame = NULL; 990 void __user *addr; 991 unsigned long newsp = 0; 992 int sigret; 993 unsigned long tramp; 994 995 /* Set up Signal Frame */ 996 /* Put a Real Time Context onto stack */ 997 rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1); 998 addr = rt_sf; 999 if (unlikely(rt_sf == NULL)) 1000 goto badframe; 1001 1002 /* Put the siginfo & fill in most of the ucontext */ 1003 if (copy_siginfo_to_user(&rt_sf->info, info) 1004 || __put_user(0, &rt_sf->uc.uc_flags) 1005 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1]) 1006 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext), 1007 &rt_sf->uc.uc_regs) 1008 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset)) 1009 goto badframe; 1010 1011 /* Save user registers on the stack */ 1012 frame = &rt_sf->uc.uc_mcontext; 1013 addr = frame; 1014 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) { 1015 sigret = 0; 1016 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp; 1017 } else { 1018 sigret = __NR_rt_sigreturn; 1019 tramp = (unsigned long) frame->tramp; 1020 } 1021 1022#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1023 tm_frame = &rt_sf->uc_transact.uc_mcontext; 1024 if (MSR_TM_ACTIVE(regs->msr)) { 1025 if (save_tm_user_regs(regs, frame, tm_frame, sigret)) 1026 goto badframe; 1027 } 1028 else 1029#endif 1030 { 1031 if (save_user_regs(regs, frame, tm_frame, sigret, 1)) 1032 goto badframe; 1033 } 1034 regs->link = tramp; 1035 1036#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1037 if (MSR_TM_ACTIVE(regs->msr)) { 1038 if (__put_user((unsigned long)&rt_sf->uc_transact, 1039 &rt_sf->uc.uc_link) 1040 || __put_user((unsigned long)tm_frame, &rt_sf->uc_transact.uc_regs)) 1041 goto badframe; 1042 } 1043 else 1044#endif 1045 if (__put_user(0, &rt_sf->uc.uc_link)) 1046 goto badframe; 1047 1048 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */ 1049 1050 /* create a stack frame for the caller of the handler */ 1051 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16); 1052 addr = (void __user *)regs->gpr[1]; 1053 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1054 goto badframe; 1055 1056 /* Fill registers for signal handler */ 1057 regs->gpr[1] = newsp; 1058 regs->gpr[3] = sig; 1059 regs->gpr[4] = (unsigned long) &rt_sf->info; 1060 regs->gpr[5] = (unsigned long) &rt_sf->uc; 1061 regs->gpr[6] = (unsigned long) rt_sf; 1062 regs->nip = (unsigned long) ka->sa.sa_handler; 1063 /* enter the signal handler in native-endian mode */ 1064 regs->msr &= ~MSR_LE; 1065 regs->msr |= (MSR_KERNEL & MSR_LE); 1066 return 1; 1067 1068badframe: 1069#ifdef DEBUG_SIG 1070 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n", 1071 regs, frame, newsp); 1072#endif 1073 if (show_unhandled_signals) 1074 printk_ratelimited(KERN_INFO 1075 "%s[%d]: bad frame in handle_rt_signal32: " 1076 "%p nip %08lx lr %08lx\n", 1077 current->comm, current->pid, 1078 addr, regs->nip, regs->link); 1079 1080 force_sigsegv(sig, current); 1081 return 0; 1082} 1083 1084static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig) 1085{ 1086 sigset_t set; 1087 struct mcontext __user *mcp; 1088 1089 if (get_sigset_t(&set, &ucp->uc_sigmask)) 1090 return -EFAULT; 1091#ifdef CONFIG_PPC64 1092 { 1093 u32 cmcp; 1094 1095 if (__get_user(cmcp, &ucp->uc_regs)) 1096 return -EFAULT; 1097 mcp = (struct mcontext __user *)(u64)cmcp; 1098 /* no need to check access_ok(mcp), since mcp < 4GB */ 1099 } 1100#else 1101 if (__get_user(mcp, &ucp->uc_regs)) 1102 return -EFAULT; 1103 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp))) 1104 return -EFAULT; 1105#endif 1106 set_current_blocked(&set); 1107 if (restore_user_regs(regs, mcp, sig)) 1108 return -EFAULT; 1109 1110 return 0; 1111} 1112 1113#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1114static int do_setcontext_tm(struct ucontext __user *ucp, 1115 struct ucontext __user *tm_ucp, 1116 struct pt_regs *regs) 1117{ 1118 sigset_t set; 1119 struct mcontext __user *mcp; 1120 struct mcontext __user *tm_mcp; 1121 u32 cmcp; 1122 u32 tm_cmcp; 1123 1124 if (get_sigset_t(&set, &ucp->uc_sigmask)) 1125 return -EFAULT; 1126 1127 if (__get_user(cmcp, &ucp->uc_regs) || 1128 __get_user(tm_cmcp, &tm_ucp->uc_regs)) 1129 return -EFAULT; 1130 mcp = (struct mcontext __user *)(u64)cmcp; 1131 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp; 1132 /* no need to check access_ok(mcp), since mcp < 4GB */ 1133 1134 set_current_blocked(&set); 1135 if (restore_tm_user_regs(regs, mcp, tm_mcp)) 1136 return -EFAULT; 1137 1138 return 0; 1139} 1140#endif 1141 1142long sys_swapcontext(struct ucontext __user *old_ctx, 1143 struct ucontext __user *new_ctx, 1144 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs) 1145{ 1146 unsigned char tmp; 1147 int ctx_has_vsx_region = 0; 1148 1149#ifdef CONFIG_PPC64 1150 unsigned long new_msr = 0; 1151 1152 if (new_ctx) { 1153 struct mcontext __user *mcp; 1154 u32 cmcp; 1155 1156 /* 1157 * Get pointer to the real mcontext. No need for 1158 * access_ok since we are dealing with compat 1159 * pointers. 1160 */ 1161 if (__get_user(cmcp, &new_ctx->uc_regs)) 1162 return -EFAULT; 1163 mcp = (struct mcontext __user *)(u64)cmcp; 1164 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR])) 1165 return -EFAULT; 1166 } 1167 /* 1168 * Check that the context is not smaller than the original 1169 * size (with VMX but without VSX) 1170 */ 1171 if (ctx_size < UCONTEXTSIZEWITHOUTVSX) 1172 return -EINVAL; 1173 /* 1174 * If the new context state sets the MSR VSX bits but 1175 * it doesn't provide VSX state. 1176 */ 1177 if ((ctx_size < sizeof(struct ucontext)) && 1178 (new_msr & MSR_VSX)) 1179 return -EINVAL; 1180 /* Does the context have enough room to store VSX data? */ 1181 if (ctx_size >= sizeof(struct ucontext)) 1182 ctx_has_vsx_region = 1; 1183#else 1184 /* Context size is for future use. Right now, we only make sure 1185 * we are passed something we understand 1186 */ 1187 if (ctx_size < sizeof(struct ucontext)) 1188 return -EINVAL; 1189#endif 1190 if (old_ctx != NULL) { 1191 struct mcontext __user *mctx; 1192 1193 /* 1194 * old_ctx might not be 16-byte aligned, in which 1195 * case old_ctx->uc_mcontext won't be either. 1196 * Because we have the old_ctx->uc_pad2 field 1197 * before old_ctx->uc_mcontext, we need to round down 1198 * from &old_ctx->uc_mcontext to a 16-byte boundary. 1199 */ 1200 mctx = (struct mcontext __user *) 1201 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL); 1202 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size) 1203 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region) 1204 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) 1205 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs)) 1206 return -EFAULT; 1207 } 1208 if (new_ctx == NULL) 1209 return 0; 1210 if (!access_ok(VERIFY_READ, new_ctx, ctx_size) 1211 || __get_user(tmp, (u8 __user *) new_ctx) 1212 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1)) 1213 return -EFAULT; 1214 1215 /* 1216 * If we get a fault copying the context into the kernel's 1217 * image of the user's registers, we can't just return -EFAULT 1218 * because the user's registers will be corrupted. For instance 1219 * the NIP value may have been updated but not some of the 1220 * other registers. Given that we have done the access_ok 1221 * and successfully read the first and last bytes of the region 1222 * above, this should only happen in an out-of-memory situation 1223 * or if another thread unmaps the region containing the context. 1224 * We kill the task with a SIGSEGV in this situation. 1225 */ 1226 if (do_setcontext(new_ctx, regs, 0)) 1227 do_exit(SIGSEGV); 1228 1229 set_thread_flag(TIF_RESTOREALL); 1230 return 0; 1231} 1232 1233long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1234 struct pt_regs *regs) 1235{ 1236 struct rt_sigframe __user *rt_sf; 1237#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1238 struct ucontext __user *uc_transact; 1239 unsigned long msr_hi; 1240 unsigned long tmp; 1241 int tm_restore = 0; 1242#endif 1243 /* Always make any pending restarted system calls return -EINTR */ 1244 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1245 1246 rt_sf = (struct rt_sigframe __user *) 1247 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 1248 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf))) 1249 goto bad; 1250#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1251 if (__get_user(tmp, &rt_sf->uc.uc_link)) 1252 goto bad; 1253 uc_transact = (struct ucontext __user *)(uintptr_t)tmp; 1254 if (uc_transact) { 1255 u32 cmcp; 1256 struct mcontext __user *mcp; 1257 1258 if (__get_user(cmcp, &uc_transact->uc_regs)) 1259 return -EFAULT; 1260 mcp = (struct mcontext __user *)(u64)cmcp; 1261 /* The top 32 bits of the MSR are stashed in the transactional 1262 * ucontext. */ 1263 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR])) 1264 goto bad; 1265 1266 if (MSR_TM_ACTIVE(msr_hi<<32)) { 1267 /* We only recheckpoint on return if we're 1268 * transaction. 1269 */ 1270 tm_restore = 1; 1271 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs)) 1272 goto bad; 1273 } 1274 } 1275 if (!tm_restore) 1276 /* Fall through, for non-TM restore */ 1277#endif 1278 if (do_setcontext(&rt_sf->uc, regs, 1)) 1279 goto bad; 1280 1281 /* 1282 * It's not clear whether or why it is desirable to save the 1283 * sigaltstack setting on signal delivery and restore it on 1284 * signal return. But other architectures do this and we have 1285 * always done it up until now so it is probably better not to 1286 * change it. -- paulus 1287 */ 1288#ifdef CONFIG_PPC64 1289 if (compat_restore_altstack(&rt_sf->uc.uc_stack)) 1290 goto bad; 1291#else 1292 if (restore_altstack(&rt_sf->uc.uc_stack)) 1293 goto bad; 1294#endif 1295 set_thread_flag(TIF_RESTOREALL); 1296 return 0; 1297 1298 bad: 1299 if (show_unhandled_signals) 1300 printk_ratelimited(KERN_INFO 1301 "%s[%d]: bad frame in sys_rt_sigreturn: " 1302 "%p nip %08lx lr %08lx\n", 1303 current->comm, current->pid, 1304 rt_sf, regs->nip, regs->link); 1305 1306 force_sig(SIGSEGV, current); 1307 return 0; 1308} 1309 1310#ifdef CONFIG_PPC32 1311int sys_debug_setcontext(struct ucontext __user *ctx, 1312 int ndbg, struct sig_dbg_op __user *dbg, 1313 int r6, int r7, int r8, 1314 struct pt_regs *regs) 1315{ 1316 struct sig_dbg_op op; 1317 int i; 1318 unsigned char tmp; 1319 unsigned long new_msr = regs->msr; 1320#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1321 unsigned long new_dbcr0 = current->thread.debug.dbcr0; 1322#endif 1323 1324 for (i=0; i<ndbg; i++) { 1325 if (copy_from_user(&op, dbg + i, sizeof(op))) 1326 return -EFAULT; 1327 switch (op.dbg_type) { 1328 case SIG_DBG_SINGLE_STEPPING: 1329#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1330 if (op.dbg_value) { 1331 new_msr |= MSR_DE; 1332 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 1333 } else { 1334 new_dbcr0 &= ~DBCR0_IC; 1335 if (!DBCR_ACTIVE_EVENTS(new_dbcr0, 1336 current->thread.debug.dbcr1)) { 1337 new_msr &= ~MSR_DE; 1338 new_dbcr0 &= ~DBCR0_IDM; 1339 } 1340 } 1341#else 1342 if (op.dbg_value) 1343 new_msr |= MSR_SE; 1344 else 1345 new_msr &= ~MSR_SE; 1346#endif 1347 break; 1348 case SIG_DBG_BRANCH_TRACING: 1349#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1350 return -EINVAL; 1351#else 1352 if (op.dbg_value) 1353 new_msr |= MSR_BE; 1354 else 1355 new_msr &= ~MSR_BE; 1356#endif 1357 break; 1358 1359 default: 1360 return -EINVAL; 1361 } 1362 } 1363 1364 /* We wait until here to actually install the values in the 1365 registers so if we fail in the above loop, it will not 1366 affect the contents of these registers. After this point, 1367 failure is a problem, anyway, and it's very unlikely unless 1368 the user is really doing something wrong. */ 1369 regs->msr = new_msr; 1370#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1371 current->thread.debug.dbcr0 = new_dbcr0; 1372#endif 1373 1374 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) 1375 || __get_user(tmp, (u8 __user *) ctx) 1376 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1)) 1377 return -EFAULT; 1378 1379 /* 1380 * If we get a fault copying the context into the kernel's 1381 * image of the user's registers, we can't just return -EFAULT 1382 * because the user's registers will be corrupted. For instance 1383 * the NIP value may have been updated but not some of the 1384 * other registers. Given that we have done the access_ok 1385 * and successfully read the first and last bytes of the region 1386 * above, this should only happen in an out-of-memory situation 1387 * or if another thread unmaps the region containing the context. 1388 * We kill the task with a SIGSEGV in this situation. 1389 */ 1390 if (do_setcontext(ctx, regs, 1)) { 1391 if (show_unhandled_signals) 1392 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in " 1393 "sys_debug_setcontext: %p nip %08lx " 1394 "lr %08lx\n", 1395 current->comm, current->pid, 1396 ctx, regs->nip, regs->link); 1397 1398 force_sig(SIGSEGV, current); 1399 goto out; 1400 } 1401 1402 /* 1403 * It's not clear whether or why it is desirable to save the 1404 * sigaltstack setting on signal delivery and restore it on 1405 * signal return. But other architectures do this and we have 1406 * always done it up until now so it is probably better not to 1407 * change it. -- paulus 1408 */ 1409 restore_altstack(&ctx->uc_stack); 1410 1411 set_thread_flag(TIF_RESTOREALL); 1412 out: 1413 return 0; 1414} 1415#endif 1416 1417/* 1418 * OK, we're invoking a handler 1419 */ 1420int handle_signal32(unsigned long sig, struct k_sigaction *ka, 1421 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs) 1422{ 1423 struct sigcontext __user *sc; 1424 struct sigframe __user *frame; 1425 struct mcontext __user *tm_mctx = NULL; 1426 unsigned long newsp = 0; 1427 int sigret; 1428 unsigned long tramp; 1429 1430 /* Set up Signal Frame */ 1431 frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1); 1432 if (unlikely(frame == NULL)) 1433 goto badframe; 1434 sc = (struct sigcontext __user *) &frame->sctx; 1435 1436#if _NSIG != 64 1437#error "Please adjust handle_signal()" 1438#endif 1439 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler) 1440 || __put_user(oldset->sig[0], &sc->oldmask) 1441#ifdef CONFIG_PPC64 1442 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3]) 1443#else 1444 || __put_user(oldset->sig[1], &sc->_unused[3]) 1445#endif 1446 || __put_user(to_user_ptr(&frame->mctx), &sc->regs) 1447 || __put_user(sig, &sc->signal)) 1448 goto badframe; 1449 1450 if (vdso32_sigtramp && current->mm->context.vdso_base) { 1451 sigret = 0; 1452 tramp = current->mm->context.vdso_base + vdso32_sigtramp; 1453 } else { 1454 sigret = __NR_sigreturn; 1455 tramp = (unsigned long) frame->mctx.tramp; 1456 } 1457 1458#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1459 tm_mctx = &frame->mctx_transact; 1460 if (MSR_TM_ACTIVE(regs->msr)) { 1461 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact, 1462 sigret)) 1463 goto badframe; 1464 } 1465 else 1466#endif 1467 { 1468 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1)) 1469 goto badframe; 1470 } 1471 1472 regs->link = tramp; 1473 1474 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */ 1475 1476 /* create a stack frame for the caller of the handler */ 1477 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE; 1478 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1479 goto badframe; 1480 1481 regs->gpr[1] = newsp; 1482 regs->gpr[3] = sig; 1483 regs->gpr[4] = (unsigned long) sc; 1484 regs->nip = (unsigned long) ka->sa.sa_handler; 1485 /* enter the signal handler in big-endian mode */ 1486 regs->msr &= ~MSR_LE; 1487 return 1; 1488 1489badframe: 1490#ifdef DEBUG_SIG 1491 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n", 1492 regs, frame, newsp); 1493#endif 1494 if (show_unhandled_signals) 1495 printk_ratelimited(KERN_INFO 1496 "%s[%d]: bad frame in handle_signal32: " 1497 "%p nip %08lx lr %08lx\n", 1498 current->comm, current->pid, 1499 frame, regs->nip, regs->link); 1500 1501 force_sigsegv(sig, current); 1502 return 0; 1503} 1504 1505/* 1506 * Do a signal return; undo the signal stack. 1507 */ 1508long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1509 struct pt_regs *regs) 1510{ 1511 struct sigframe __user *sf; 1512 struct sigcontext __user *sc; 1513 struct sigcontext sigctx; 1514 struct mcontext __user *sr; 1515 void __user *addr; 1516 sigset_t set; 1517#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1518 struct mcontext __user *mcp, *tm_mcp; 1519 unsigned long msr_hi; 1520#endif 1521 1522 /* Always make any pending restarted system calls return -EINTR */ 1523 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1524 1525 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); 1526 sc = &sf->sctx; 1527 addr = sc; 1528 if (copy_from_user(&sigctx, sc, sizeof(sigctx))) 1529 goto badframe; 1530 1531#ifdef CONFIG_PPC64 1532 /* 1533 * Note that PPC32 puts the upper 32 bits of the sigmask in the 1534 * unused part of the signal stackframe 1535 */ 1536 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32); 1537#else 1538 set.sig[0] = sigctx.oldmask; 1539 set.sig[1] = sigctx._unused[3]; 1540#endif 1541 set_current_blocked(&set); 1542 1543#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1544 mcp = (struct mcontext __user *)&sf->mctx; 1545 tm_mcp = (struct mcontext __user *)&sf->mctx_transact; 1546 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR])) 1547 goto badframe; 1548 if (MSR_TM_ACTIVE(msr_hi<<32)) { 1549 if (!cpu_has_feature(CPU_FTR_TM)) 1550 goto badframe; 1551 if (restore_tm_user_regs(regs, mcp, tm_mcp)) 1552 goto badframe; 1553 } else 1554#endif 1555 { 1556 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs); 1557 addr = sr; 1558 if (!access_ok(VERIFY_READ, sr, sizeof(*sr)) 1559 || restore_user_regs(regs, sr, 1)) 1560 goto badframe; 1561 } 1562 1563 set_thread_flag(TIF_RESTOREALL); 1564 return 0; 1565 1566badframe: 1567 if (show_unhandled_signals) 1568 printk_ratelimited(KERN_INFO 1569 "%s[%d]: bad frame in sys_sigreturn: " 1570 "%p nip %08lx lr %08lx\n", 1571 current->comm, current->pid, 1572 addr, regs->nip, regs->link); 1573 1574 force_sig(SIGSEGV, current); 1575 return 0; 1576} 1577