signal_32.c revision de79f7b9f6f92ec1bd6f61fa1f20de60728a5b5e
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#ifdef CONFIG_VSX 449 /* 450 * Copy VSR 0-31 upper half from thread_struct to local 451 * buffer, then write that to userspace. Also set MSR_VSX in 452 * the saved MSR value to indicate that frame->mc_vregs 453 * contains valid data 454 */ 455 if (current->thread.used_vsr && ctx_has_vsx_region) { 456 __giveup_vsx(current); 457 if (copy_vsx_to_user(&frame->mc_vsregs, current)) 458 return 1; 459 msr |= MSR_VSX; 460 } 461#endif /* CONFIG_VSX */ 462#ifdef CONFIG_SPE 463 /* save spe registers */ 464 if (current->thread.used_spe) { 465 flush_spe_to_thread(current); 466 if (__copy_to_user(&frame->mc_vregs, current->thread.evr, 467 ELF_NEVRREG * sizeof(u32))) 468 return 1; 469 /* set MSR_SPE in the saved MSR value to indicate that 470 frame->mc_vregs contains valid data */ 471 msr |= MSR_SPE; 472 } 473 /* else assert((regs->msr & MSR_SPE) == 0) */ 474 475 /* We always copy to/from spefscr */ 476 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG)) 477 return 1; 478#endif /* CONFIG_SPE */ 479 480 if (__put_user(msr, &frame->mc_gregs[PT_MSR])) 481 return 1; 482 /* We need to write 0 the MSR top 32 bits in the tm frame so that we 483 * can check it on the restore to see if TM is active 484 */ 485 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR])) 486 return 1; 487 488 if (sigret) { 489 /* Set up the sigreturn trampoline: li r0,sigret; sc */ 490 if (__put_user(0x38000000UL + sigret, &frame->tramp[0]) 491 || __put_user(0x44000002UL, &frame->tramp[1])) 492 return 1; 493 flush_icache_range((unsigned long) &frame->tramp[0], 494 (unsigned long) &frame->tramp[2]); 495 } 496 497 return 0; 498} 499 500#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 501/* 502 * Save the current user registers on the user stack. 503 * We only save the altivec/spe registers if the process has used 504 * altivec/spe instructions at some point. 505 * We also save the transactional registers to a second ucontext in the 506 * frame. 507 * 508 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts(). 509 */ 510static int save_tm_user_regs(struct pt_regs *regs, 511 struct mcontext __user *frame, 512 struct mcontext __user *tm_frame, int sigret) 513{ 514 unsigned long msr = regs->msr; 515 516 /* Make sure floating point registers are stored in regs */ 517 flush_fp_to_thread(current); 518 519 /* Save both sets of general registers */ 520 if (save_general_regs(¤t->thread.ckpt_regs, frame) 521 || save_general_regs(regs, tm_frame)) 522 return 1; 523 524 /* Stash the top half of the 64bit MSR into the 32bit MSR word 525 * of the transactional mcontext. This way we have a backward-compatible 526 * MSR in the 'normal' (checkpointed) mcontext and additionally one can 527 * also look at what type of transaction (T or S) was active at the 528 * time of the signal. 529 */ 530 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR])) 531 return 1; 532 533#ifdef CONFIG_ALTIVEC 534 /* save altivec registers */ 535 if (current->thread.used_vr) { 536 flush_altivec_to_thread(current); 537 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state, 538 ELF_NVRREG * sizeof(vector128))) 539 return 1; 540 if (msr & MSR_VEC) { 541 if (__copy_to_user(&tm_frame->mc_vregs, 542 ¤t->thread.transact_vr, 543 ELF_NVRREG * sizeof(vector128))) 544 return 1; 545 } else { 546 if (__copy_to_user(&tm_frame->mc_vregs, 547 ¤t->thread.vr_state, 548 ELF_NVRREG * sizeof(vector128))) 549 return 1; 550 } 551 552 /* set MSR_VEC in the saved MSR value to indicate that 553 * frame->mc_vregs contains valid data 554 */ 555 msr |= MSR_VEC; 556 } 557 558 /* We always copy to/from vrsave, it's 0 if we don't have or don't 559 * use altivec. Since VSCR only contains 32 bits saved in the least 560 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 561 * most significant bits of that same vector. --BenH 562 */ 563 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 564 current->thread.vrsave = mfspr(SPRN_VRSAVE); 565 if (__put_user(current->thread.vrsave, 566 (u32 __user *)&frame->mc_vregs[32])) 567 return 1; 568 if (msr & MSR_VEC) { 569 if (__put_user(current->thread.transact_vrsave, 570 (u32 __user *)&tm_frame->mc_vregs[32])) 571 return 1; 572 } else { 573 if (__put_user(current->thread.vrsave, 574 (u32 __user *)&tm_frame->mc_vregs[32])) 575 return 1; 576 } 577#endif /* CONFIG_ALTIVEC */ 578 579 if (copy_fpr_to_user(&frame->mc_fregs, current)) 580 return 1; 581 if (msr & MSR_FP) { 582 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current)) 583 return 1; 584 } else { 585 if (copy_fpr_to_user(&tm_frame->mc_fregs, current)) 586 return 1; 587 } 588 589#ifdef CONFIG_VSX 590 /* 591 * Copy VSR 0-31 upper half from thread_struct to local 592 * buffer, then write that to userspace. Also set MSR_VSX in 593 * the saved MSR value to indicate that frame->mc_vregs 594 * contains valid data 595 */ 596 if (current->thread.used_vsr) { 597 __giveup_vsx(current); 598 if (copy_vsx_to_user(&frame->mc_vsregs, current)) 599 return 1; 600 if (msr & MSR_VSX) { 601 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs, 602 current)) 603 return 1; 604 } else { 605 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current)) 606 return 1; 607 } 608 609 msr |= MSR_VSX; 610 } 611#endif /* CONFIG_VSX */ 612#ifdef CONFIG_SPE 613 /* SPE regs are not checkpointed with TM, so this section is 614 * simply the same as in save_user_regs(). 615 */ 616 if (current->thread.used_spe) { 617 flush_spe_to_thread(current); 618 if (__copy_to_user(&frame->mc_vregs, current->thread.evr, 619 ELF_NEVRREG * sizeof(u32))) 620 return 1; 621 /* set MSR_SPE in the saved MSR value to indicate that 622 * frame->mc_vregs contains valid data */ 623 msr |= MSR_SPE; 624 } 625 626 /* We always copy to/from spefscr */ 627 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG)) 628 return 1; 629#endif /* CONFIG_SPE */ 630 631 if (__put_user(msr, &frame->mc_gregs[PT_MSR])) 632 return 1; 633 if (sigret) { 634 /* Set up the sigreturn trampoline: li r0,sigret; sc */ 635 if (__put_user(0x38000000UL + sigret, &frame->tramp[0]) 636 || __put_user(0x44000002UL, &frame->tramp[1])) 637 return 1; 638 flush_icache_range((unsigned long) &frame->tramp[0], 639 (unsigned long) &frame->tramp[2]); 640 } 641 642 return 0; 643} 644#endif 645 646/* 647 * Restore the current user register values from the user stack, 648 * (except for MSR). 649 */ 650static long restore_user_regs(struct pt_regs *regs, 651 struct mcontext __user *sr, int sig) 652{ 653 long err; 654 unsigned int save_r2 = 0; 655 unsigned long msr; 656#ifdef CONFIG_VSX 657 int i; 658#endif 659 660 /* 661 * restore general registers but not including MSR or SOFTE. Also 662 * take care of keeping r2 (TLS) intact if not a signal 663 */ 664 if (!sig) 665 save_r2 = (unsigned int)regs->gpr[2]; 666 err = restore_general_regs(regs, sr); 667 regs->trap = 0; 668 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]); 669 if (!sig) 670 regs->gpr[2] = (unsigned long) save_r2; 671 if (err) 672 return 1; 673 674 /* if doing signal return, restore the previous little-endian mode */ 675 if (sig) 676 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE); 677 678 /* 679 * Do this before updating the thread state in 680 * current->thread.fpr/vr/evr. That way, if we get preempted 681 * and another task grabs the FPU/Altivec/SPE, it won't be 682 * tempted to save the current CPU state into the thread_struct 683 * and corrupt what we are writing there. 684 */ 685 discard_lazy_cpu_state(); 686 687#ifdef CONFIG_ALTIVEC 688 /* 689 * Force the process to reload the altivec registers from 690 * current->thread when it next does altivec instructions 691 */ 692 regs->msr &= ~MSR_VEC; 693 if (msr & MSR_VEC) { 694 /* restore altivec registers from the stack */ 695 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs, 696 sizeof(sr->mc_vregs))) 697 return 1; 698 } else if (current->thread.used_vr) 699 memset(¤t->thread.vr_state, 0, 700 ELF_NVRREG * sizeof(vector128)); 701 702 /* Always get VRSAVE back */ 703 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32])) 704 return 1; 705 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 706 mtspr(SPRN_VRSAVE, current->thread.vrsave); 707#endif /* CONFIG_ALTIVEC */ 708 if (copy_fpr_from_user(current, &sr->mc_fregs)) 709 return 1; 710 711#ifdef CONFIG_VSX 712 /* 713 * Force the process to reload the VSX registers from 714 * current->thread when it next does VSX instruction. 715 */ 716 regs->msr &= ~MSR_VSX; 717 if (msr & MSR_VSX) { 718 /* 719 * Restore altivec registers from the stack to a local 720 * buffer, then write this out to the thread_struct 721 */ 722 if (copy_vsx_from_user(current, &sr->mc_vsregs)) 723 return 1; 724 } else if (current->thread.used_vsr) 725 for (i = 0; i < 32 ; i++) 726 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0; 727#endif /* CONFIG_VSX */ 728 /* 729 * force the process to reload the FP registers from 730 * current->thread when it next does FP instructions 731 */ 732 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 733 734#ifdef CONFIG_SPE 735 /* force the process to reload the spe registers from 736 current->thread when it next does spe instructions */ 737 regs->msr &= ~MSR_SPE; 738 if (msr & MSR_SPE) { 739 /* restore spe registers from the stack */ 740 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 741 ELF_NEVRREG * sizeof(u32))) 742 return 1; 743 } else if (current->thread.used_spe) 744 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 745 746 /* Always get SPEFSCR back */ 747 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG)) 748 return 1; 749#endif /* CONFIG_SPE */ 750 751 return 0; 752} 753 754#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 755/* 756 * Restore the current user register values from the user stack, except for 757 * MSR, and recheckpoint the original checkpointed register state for processes 758 * in transactions. 759 */ 760static long restore_tm_user_regs(struct pt_regs *regs, 761 struct mcontext __user *sr, 762 struct mcontext __user *tm_sr) 763{ 764 long err; 765 unsigned long msr, msr_hi; 766#ifdef CONFIG_VSX 767 int i; 768#endif 769 770 /* 771 * restore general registers but not including MSR or SOFTE. Also 772 * take care of keeping r2 (TLS) intact if not a signal. 773 * See comment in signal_64.c:restore_tm_sigcontexts(); 774 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR 775 * were set by the signal delivery. 776 */ 777 err = restore_general_regs(regs, tm_sr); 778 err |= restore_general_regs(¤t->thread.ckpt_regs, sr); 779 780 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]); 781 782 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]); 783 if (err) 784 return 1; 785 786 /* Restore the previous little-endian mode */ 787 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE); 788 789 /* 790 * Do this before updating the thread state in 791 * current->thread.fpr/vr/evr. That way, if we get preempted 792 * and another task grabs the FPU/Altivec/SPE, it won't be 793 * tempted to save the current CPU state into the thread_struct 794 * and corrupt what we are writing there. 795 */ 796 discard_lazy_cpu_state(); 797 798#ifdef CONFIG_ALTIVEC 799 regs->msr &= ~MSR_VEC; 800 if (msr & MSR_VEC) { 801 /* restore altivec registers from the stack */ 802 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs, 803 sizeof(sr->mc_vregs)) || 804 __copy_from_user(¤t->thread.transact_vr, 805 &tm_sr->mc_vregs, 806 sizeof(sr->mc_vregs))) 807 return 1; 808 } else if (current->thread.used_vr) { 809 memset(¤t->thread.vr_state, 0, 810 ELF_NVRREG * sizeof(vector128)); 811 memset(¤t->thread.transact_vr, 0, 812 ELF_NVRREG * sizeof(vector128)); 813 } 814 815 /* Always get VRSAVE back */ 816 if (__get_user(current->thread.vrsave, 817 (u32 __user *)&sr->mc_vregs[32]) || 818 __get_user(current->thread.transact_vrsave, 819 (u32 __user *)&tm_sr->mc_vregs[32])) 820 return 1; 821 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 822 mtspr(SPRN_VRSAVE, current->thread.vrsave); 823#endif /* CONFIG_ALTIVEC */ 824 825 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1); 826 827 if (copy_fpr_from_user(current, &sr->mc_fregs) || 828 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs)) 829 return 1; 830 831#ifdef CONFIG_VSX 832 regs->msr &= ~MSR_VSX; 833 if (msr & MSR_VSX) { 834 /* 835 * Restore altivec registers from the stack to a local 836 * buffer, then write this out to the thread_struct 837 */ 838 if (copy_vsx_from_user(current, &sr->mc_vsregs) || 839 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs)) 840 return 1; 841 } else if (current->thread.used_vsr) 842 for (i = 0; i < 32 ; i++) { 843 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0; 844 current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0; 845 } 846#endif /* CONFIG_VSX */ 847 848#ifdef CONFIG_SPE 849 /* SPE regs are not checkpointed with TM, so this section is 850 * simply the same as in restore_user_regs(). 851 */ 852 regs->msr &= ~MSR_SPE; 853 if (msr & MSR_SPE) { 854 if (__copy_from_user(current->thread.evr, &sr->mc_vregs, 855 ELF_NEVRREG * sizeof(u32))) 856 return 1; 857 } else if (current->thread.used_spe) 858 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32)); 859 860 /* Always get SPEFSCR back */ 861 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs 862 + ELF_NEVRREG)) 863 return 1; 864#endif /* CONFIG_SPE */ 865 866 /* Now, recheckpoint. This loads up all of the checkpointed (older) 867 * registers, including FP and V[S]Rs. After recheckpointing, the 868 * transactional versions should be loaded. 869 */ 870 tm_enable(); 871 /* This loads the checkpointed FP/VEC state, if used */ 872 tm_recheckpoint(¤t->thread, msr); 873 /* Get the top half of the MSR */ 874 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR])) 875 return 1; 876 /* Pull in MSR TM from user context */ 877 regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK); 878 879 /* This loads the speculative FP/VEC state, if used */ 880 if (msr & MSR_FP) { 881 do_load_up_transact_fpu(¤t->thread); 882 regs->msr |= (MSR_FP | current->thread.fpexc_mode); 883 } 884#ifdef CONFIG_ALTIVEC 885 if (msr & MSR_VEC) { 886 do_load_up_transact_altivec(¤t->thread); 887 regs->msr |= MSR_VEC; 888 } 889#endif 890 891 return 0; 892} 893#endif 894 895#ifdef CONFIG_PPC64 896int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s) 897{ 898 int err; 899 900 if (!access_ok (VERIFY_WRITE, d, sizeof(*d))) 901 return -EFAULT; 902 903 /* If you change siginfo_t structure, please be sure 904 * this code is fixed accordingly. 905 * It should never copy any pad contained in the structure 906 * to avoid security leaks, but must copy the generic 907 * 3 ints plus the relevant union member. 908 * This routine must convert siginfo from 64bit to 32bit as well 909 * at the same time. 910 */ 911 err = __put_user(s->si_signo, &d->si_signo); 912 err |= __put_user(s->si_errno, &d->si_errno); 913 err |= __put_user((short)s->si_code, &d->si_code); 914 if (s->si_code < 0) 915 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad, 916 SI_PAD_SIZE32); 917 else switch(s->si_code >> 16) { 918 case __SI_CHLD >> 16: 919 err |= __put_user(s->si_pid, &d->si_pid); 920 err |= __put_user(s->si_uid, &d->si_uid); 921 err |= __put_user(s->si_utime, &d->si_utime); 922 err |= __put_user(s->si_stime, &d->si_stime); 923 err |= __put_user(s->si_status, &d->si_status); 924 break; 925 case __SI_FAULT >> 16: 926 err |= __put_user((unsigned int)(unsigned long)s->si_addr, 927 &d->si_addr); 928 break; 929 case __SI_POLL >> 16: 930 err |= __put_user(s->si_band, &d->si_band); 931 err |= __put_user(s->si_fd, &d->si_fd); 932 break; 933 case __SI_TIMER >> 16: 934 err |= __put_user(s->si_tid, &d->si_tid); 935 err |= __put_user(s->si_overrun, &d->si_overrun); 936 err |= __put_user(s->si_int, &d->si_int); 937 break; 938 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 939 case __SI_MESGQ >> 16: 940 err |= __put_user(s->si_int, &d->si_int); 941 /* fallthrough */ 942 case __SI_KILL >> 16: 943 default: 944 err |= __put_user(s->si_pid, &d->si_pid); 945 err |= __put_user(s->si_uid, &d->si_uid); 946 break; 947 } 948 return err; 949} 950 951#define copy_siginfo_to_user copy_siginfo_to_user32 952 953int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from) 954{ 955 memset(to, 0, sizeof *to); 956 957 if (copy_from_user(to, from, 3*sizeof(int)) || 958 copy_from_user(to->_sifields._pad, 959 from->_sifields._pad, SI_PAD_SIZE32)) 960 return -EFAULT; 961 962 return 0; 963} 964#endif /* CONFIG_PPC64 */ 965 966/* 967 * Set up a signal frame for a "real-time" signal handler 968 * (one which gets siginfo). 969 */ 970int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka, 971 siginfo_t *info, sigset_t *oldset, 972 struct pt_regs *regs) 973{ 974 struct rt_sigframe __user *rt_sf; 975 struct mcontext __user *frame; 976 struct mcontext __user *tm_frame = NULL; 977 void __user *addr; 978 unsigned long newsp = 0; 979 int sigret; 980 unsigned long tramp; 981 982 /* Set up Signal Frame */ 983 /* Put a Real Time Context onto stack */ 984 rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1); 985 addr = rt_sf; 986 if (unlikely(rt_sf == NULL)) 987 goto badframe; 988 989 /* Put the siginfo & fill in most of the ucontext */ 990 if (copy_siginfo_to_user(&rt_sf->info, info) 991 || __put_user(0, &rt_sf->uc.uc_flags) 992 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1]) 993 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext), 994 &rt_sf->uc.uc_regs) 995 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset)) 996 goto badframe; 997 998 /* Save user registers on the stack */ 999 frame = &rt_sf->uc.uc_mcontext; 1000 addr = frame; 1001 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) { 1002 sigret = 0; 1003 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp; 1004 } else { 1005 sigret = __NR_rt_sigreturn; 1006 tramp = (unsigned long) frame->tramp; 1007 } 1008 1009#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1010 tm_frame = &rt_sf->uc_transact.uc_mcontext; 1011 if (MSR_TM_ACTIVE(regs->msr)) { 1012 if (save_tm_user_regs(regs, frame, tm_frame, sigret)) 1013 goto badframe; 1014 } 1015 else 1016#endif 1017 { 1018 if (save_user_regs(regs, frame, tm_frame, sigret, 1)) 1019 goto badframe; 1020 } 1021 regs->link = tramp; 1022 1023#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1024 if (MSR_TM_ACTIVE(regs->msr)) { 1025 if (__put_user((unsigned long)&rt_sf->uc_transact, 1026 &rt_sf->uc.uc_link) 1027 || __put_user((unsigned long)tm_frame, &rt_sf->uc_transact.uc_regs)) 1028 goto badframe; 1029 } 1030 else 1031#endif 1032 if (__put_user(0, &rt_sf->uc.uc_link)) 1033 goto badframe; 1034 1035 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */ 1036 1037 /* create a stack frame for the caller of the handler */ 1038 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16); 1039 addr = (void __user *)regs->gpr[1]; 1040 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1041 goto badframe; 1042 1043 /* Fill registers for signal handler */ 1044 regs->gpr[1] = newsp; 1045 regs->gpr[3] = sig; 1046 regs->gpr[4] = (unsigned long) &rt_sf->info; 1047 regs->gpr[5] = (unsigned long) &rt_sf->uc; 1048 regs->gpr[6] = (unsigned long) rt_sf; 1049 regs->nip = (unsigned long) ka->sa.sa_handler; 1050 /* enter the signal handler in big-endian mode */ 1051 regs->msr &= ~MSR_LE; 1052#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1053 /* Remove TM bits from thread's MSR. The MSR in the sigcontext 1054 * just indicates to userland that we were doing a transaction, but we 1055 * don't want to return in transactional state: 1056 */ 1057 regs->msr &= ~MSR_TS_MASK; 1058#endif 1059 return 1; 1060 1061badframe: 1062#ifdef DEBUG_SIG 1063 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n", 1064 regs, frame, newsp); 1065#endif 1066 if (show_unhandled_signals) 1067 printk_ratelimited(KERN_INFO 1068 "%s[%d]: bad frame in handle_rt_signal32: " 1069 "%p nip %08lx lr %08lx\n", 1070 current->comm, current->pid, 1071 addr, regs->nip, regs->link); 1072 1073 force_sigsegv(sig, current); 1074 return 0; 1075} 1076 1077static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig) 1078{ 1079 sigset_t set; 1080 struct mcontext __user *mcp; 1081 1082 if (get_sigset_t(&set, &ucp->uc_sigmask)) 1083 return -EFAULT; 1084#ifdef CONFIG_PPC64 1085 { 1086 u32 cmcp; 1087 1088 if (__get_user(cmcp, &ucp->uc_regs)) 1089 return -EFAULT; 1090 mcp = (struct mcontext __user *)(u64)cmcp; 1091 /* no need to check access_ok(mcp), since mcp < 4GB */ 1092 } 1093#else 1094 if (__get_user(mcp, &ucp->uc_regs)) 1095 return -EFAULT; 1096 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp))) 1097 return -EFAULT; 1098#endif 1099 set_current_blocked(&set); 1100 if (restore_user_regs(regs, mcp, sig)) 1101 return -EFAULT; 1102 1103 return 0; 1104} 1105 1106#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1107static int do_setcontext_tm(struct ucontext __user *ucp, 1108 struct ucontext __user *tm_ucp, 1109 struct pt_regs *regs) 1110{ 1111 sigset_t set; 1112 struct mcontext __user *mcp; 1113 struct mcontext __user *tm_mcp; 1114 u32 cmcp; 1115 u32 tm_cmcp; 1116 1117 if (get_sigset_t(&set, &ucp->uc_sigmask)) 1118 return -EFAULT; 1119 1120 if (__get_user(cmcp, &ucp->uc_regs) || 1121 __get_user(tm_cmcp, &tm_ucp->uc_regs)) 1122 return -EFAULT; 1123 mcp = (struct mcontext __user *)(u64)cmcp; 1124 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp; 1125 /* no need to check access_ok(mcp), since mcp < 4GB */ 1126 1127 set_current_blocked(&set); 1128 if (restore_tm_user_regs(regs, mcp, tm_mcp)) 1129 return -EFAULT; 1130 1131 return 0; 1132} 1133#endif 1134 1135long sys_swapcontext(struct ucontext __user *old_ctx, 1136 struct ucontext __user *new_ctx, 1137 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs) 1138{ 1139 unsigned char tmp; 1140 int ctx_has_vsx_region = 0; 1141 1142#ifdef CONFIG_PPC64 1143 unsigned long new_msr = 0; 1144 1145 if (new_ctx) { 1146 struct mcontext __user *mcp; 1147 u32 cmcp; 1148 1149 /* 1150 * Get pointer to the real mcontext. No need for 1151 * access_ok since we are dealing with compat 1152 * pointers. 1153 */ 1154 if (__get_user(cmcp, &new_ctx->uc_regs)) 1155 return -EFAULT; 1156 mcp = (struct mcontext __user *)(u64)cmcp; 1157 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR])) 1158 return -EFAULT; 1159 } 1160 /* 1161 * Check that the context is not smaller than the original 1162 * size (with VMX but without VSX) 1163 */ 1164 if (ctx_size < UCONTEXTSIZEWITHOUTVSX) 1165 return -EINVAL; 1166 /* 1167 * If the new context state sets the MSR VSX bits but 1168 * it doesn't provide VSX state. 1169 */ 1170 if ((ctx_size < sizeof(struct ucontext)) && 1171 (new_msr & MSR_VSX)) 1172 return -EINVAL; 1173 /* Does the context have enough room to store VSX data? */ 1174 if (ctx_size >= sizeof(struct ucontext)) 1175 ctx_has_vsx_region = 1; 1176#else 1177 /* Context size is for future use. Right now, we only make sure 1178 * we are passed something we understand 1179 */ 1180 if (ctx_size < sizeof(struct ucontext)) 1181 return -EINVAL; 1182#endif 1183 if (old_ctx != NULL) { 1184 struct mcontext __user *mctx; 1185 1186 /* 1187 * old_ctx might not be 16-byte aligned, in which 1188 * case old_ctx->uc_mcontext won't be either. 1189 * Because we have the old_ctx->uc_pad2 field 1190 * before old_ctx->uc_mcontext, we need to round down 1191 * from &old_ctx->uc_mcontext to a 16-byte boundary. 1192 */ 1193 mctx = (struct mcontext __user *) 1194 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL); 1195 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size) 1196 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region) 1197 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked) 1198 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs)) 1199 return -EFAULT; 1200 } 1201 if (new_ctx == NULL) 1202 return 0; 1203 if (!access_ok(VERIFY_READ, new_ctx, ctx_size) 1204 || __get_user(tmp, (u8 __user *) new_ctx) 1205 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1)) 1206 return -EFAULT; 1207 1208 /* 1209 * If we get a fault copying the context into the kernel's 1210 * image of the user's registers, we can't just return -EFAULT 1211 * because the user's registers will be corrupted. For instance 1212 * the NIP value may have been updated but not some of the 1213 * other registers. Given that we have done the access_ok 1214 * and successfully read the first and last bytes of the region 1215 * above, this should only happen in an out-of-memory situation 1216 * or if another thread unmaps the region containing the context. 1217 * We kill the task with a SIGSEGV in this situation. 1218 */ 1219 if (do_setcontext(new_ctx, regs, 0)) 1220 do_exit(SIGSEGV); 1221 1222 set_thread_flag(TIF_RESTOREALL); 1223 return 0; 1224} 1225 1226long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8, 1227 struct pt_regs *regs) 1228{ 1229 struct rt_sigframe __user *rt_sf; 1230#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1231 struct ucontext __user *uc_transact; 1232 unsigned long msr_hi; 1233 unsigned long tmp; 1234 int tm_restore = 0; 1235#endif 1236 /* Always make any pending restarted system calls return -EINTR */ 1237 current_thread_info()->restart_block.fn = do_no_restart_syscall; 1238 1239 rt_sf = (struct rt_sigframe __user *) 1240 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 1241 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf))) 1242 goto bad; 1243#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1244 if (__get_user(tmp, &rt_sf->uc.uc_link)) 1245 goto bad; 1246 uc_transact = (struct ucontext __user *)(uintptr_t)tmp; 1247 if (uc_transact) { 1248 u32 cmcp; 1249 struct mcontext __user *mcp; 1250 1251 if (__get_user(cmcp, &uc_transact->uc_regs)) 1252 return -EFAULT; 1253 mcp = (struct mcontext __user *)(u64)cmcp; 1254 /* The top 32 bits of the MSR are stashed in the transactional 1255 * ucontext. */ 1256 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR])) 1257 goto bad; 1258 1259 if (MSR_TM_ACTIVE(msr_hi<<32)) { 1260 /* We only recheckpoint on return if we're 1261 * transaction. 1262 */ 1263 tm_restore = 1; 1264 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs)) 1265 goto bad; 1266 } 1267 } 1268 if (!tm_restore) 1269 /* Fall through, for non-TM restore */ 1270#endif 1271 if (do_setcontext(&rt_sf->uc, regs, 1)) 1272 goto bad; 1273 1274 /* 1275 * It's not clear whether or why it is desirable to save the 1276 * sigaltstack setting on signal delivery and restore it on 1277 * signal return. But other architectures do this and we have 1278 * always done it up until now so it is probably better not to 1279 * change it. -- paulus 1280 */ 1281#ifdef CONFIG_PPC64 1282 if (compat_restore_altstack(&rt_sf->uc.uc_stack)) 1283 goto bad; 1284#else 1285 if (restore_altstack(&rt_sf->uc.uc_stack)) 1286 goto bad; 1287#endif 1288 set_thread_flag(TIF_RESTOREALL); 1289 return 0; 1290 1291 bad: 1292 if (show_unhandled_signals) 1293 printk_ratelimited(KERN_INFO 1294 "%s[%d]: bad frame in sys_rt_sigreturn: " 1295 "%p nip %08lx lr %08lx\n", 1296 current->comm, current->pid, 1297 rt_sf, regs->nip, regs->link); 1298 1299 force_sig(SIGSEGV, current); 1300 return 0; 1301} 1302 1303#ifdef CONFIG_PPC32 1304int sys_debug_setcontext(struct ucontext __user *ctx, 1305 int ndbg, struct sig_dbg_op __user *dbg, 1306 int r6, int r7, int r8, 1307 struct pt_regs *regs) 1308{ 1309 struct sig_dbg_op op; 1310 int i; 1311 unsigned char tmp; 1312 unsigned long new_msr = regs->msr; 1313#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1314 unsigned long new_dbcr0 = current->thread.dbcr0; 1315#endif 1316 1317 for (i=0; i<ndbg; i++) { 1318 if (copy_from_user(&op, dbg + i, sizeof(op))) 1319 return -EFAULT; 1320 switch (op.dbg_type) { 1321 case SIG_DBG_SINGLE_STEPPING: 1322#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1323 if (op.dbg_value) { 1324 new_msr |= MSR_DE; 1325 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 1326 } else { 1327 new_dbcr0 &= ~DBCR0_IC; 1328 if (!DBCR_ACTIVE_EVENTS(new_dbcr0, 1329 current->thread.dbcr1)) { 1330 new_msr &= ~MSR_DE; 1331 new_dbcr0 &= ~DBCR0_IDM; 1332 } 1333 } 1334#else 1335 if (op.dbg_value) 1336 new_msr |= MSR_SE; 1337 else 1338 new_msr &= ~MSR_SE; 1339#endif 1340 break; 1341 case SIG_DBG_BRANCH_TRACING: 1342#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1343 return -EINVAL; 1344#else 1345 if (op.dbg_value) 1346 new_msr |= MSR_BE; 1347 else 1348 new_msr &= ~MSR_BE; 1349#endif 1350 break; 1351 1352 default: 1353 return -EINVAL; 1354 } 1355 } 1356 1357 /* We wait until here to actually install the values in the 1358 registers so if we fail in the above loop, it will not 1359 affect the contents of these registers. After this point, 1360 failure is a problem, anyway, and it's very unlikely unless 1361 the user is really doing something wrong. */ 1362 regs->msr = new_msr; 1363#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1364 current->thread.dbcr0 = new_dbcr0; 1365#endif 1366 1367 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx)) 1368 || __get_user(tmp, (u8 __user *) ctx) 1369 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1)) 1370 return -EFAULT; 1371 1372 /* 1373 * If we get a fault copying the context into the kernel's 1374 * image of the user's registers, we can't just return -EFAULT 1375 * because the user's registers will be corrupted. For instance 1376 * the NIP value may have been updated but not some of the 1377 * other registers. Given that we have done the access_ok 1378 * and successfully read the first and last bytes of the region 1379 * above, this should only happen in an out-of-memory situation 1380 * or if another thread unmaps the region containing the context. 1381 * We kill the task with a SIGSEGV in this situation. 1382 */ 1383 if (do_setcontext(ctx, regs, 1)) { 1384 if (show_unhandled_signals) 1385 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in " 1386 "sys_debug_setcontext: %p nip %08lx " 1387 "lr %08lx\n", 1388 current->comm, current->pid, 1389 ctx, regs->nip, regs->link); 1390 1391 force_sig(SIGSEGV, current); 1392 goto out; 1393 } 1394 1395 /* 1396 * It's not clear whether or why it is desirable to save the 1397 * sigaltstack setting on signal delivery and restore it on 1398 * signal return. But other architectures do this and we have 1399 * always done it up until now so it is probably better not to 1400 * change it. -- paulus 1401 */ 1402 restore_altstack(&ctx->uc_stack); 1403 1404 set_thread_flag(TIF_RESTOREALL); 1405 out: 1406 return 0; 1407} 1408#endif 1409 1410/* 1411 * OK, we're invoking a handler 1412 */ 1413int handle_signal32(unsigned long sig, struct k_sigaction *ka, 1414 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs) 1415{ 1416 struct sigcontext __user *sc; 1417 struct sigframe __user *frame; 1418 struct mcontext __user *tm_mctx = NULL; 1419 unsigned long newsp = 0; 1420 int sigret; 1421 unsigned long tramp; 1422 1423 /* Set up Signal Frame */ 1424 frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1); 1425 if (unlikely(frame == NULL)) 1426 goto badframe; 1427 sc = (struct sigcontext __user *) &frame->sctx; 1428 1429#if _NSIG != 64 1430#error "Please adjust handle_signal()" 1431#endif 1432 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler) 1433 || __put_user(oldset->sig[0], &sc->oldmask) 1434#ifdef CONFIG_PPC64 1435 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3]) 1436#else 1437 || __put_user(oldset->sig[1], &sc->_unused[3]) 1438#endif 1439 || __put_user(to_user_ptr(&frame->mctx), &sc->regs) 1440 || __put_user(sig, &sc->signal)) 1441 goto badframe; 1442 1443 if (vdso32_sigtramp && current->mm->context.vdso_base) { 1444 sigret = 0; 1445 tramp = current->mm->context.vdso_base + vdso32_sigtramp; 1446 } else { 1447 sigret = __NR_sigreturn; 1448 tramp = (unsigned long) frame->mctx.tramp; 1449 } 1450 1451#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1452 tm_mctx = &frame->mctx_transact; 1453 if (MSR_TM_ACTIVE(regs->msr)) { 1454 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact, 1455 sigret)) 1456 goto badframe; 1457 } 1458 else 1459#endif 1460 { 1461 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1)) 1462 goto badframe; 1463 } 1464 1465 regs->link = tramp; 1466 1467 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */ 1468 1469 /* create a stack frame for the caller of the handler */ 1470 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE; 1471 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 1472 goto badframe; 1473 1474 regs->gpr[1] = newsp; 1475 regs->gpr[3] = sig; 1476 regs->gpr[4] = (unsigned long) sc; 1477 regs->nip = (unsigned long) ka->sa.sa_handler; 1478 /* enter the signal handler in big-endian mode */ 1479 regs->msr &= ~MSR_LE; 1480#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1481 /* Remove TM bits from thread's MSR. The MSR in the sigcontext 1482 * just indicates to userland that we were doing a transaction, but we 1483 * don't want to return in transactional state: 1484 */ 1485 regs->msr &= ~MSR_TS_MASK; 1486#endif 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