1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC 4 * 5 * PowerPC version 6 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 7 * Copyright (C) 2001 IBM 8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 9 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) 10 * 11 * Derived from "arch/i386/kernel/signal.c" 12 * Copyright (C) 1991, 1992 Linus Torvalds 13 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson 14 */ 15 16#include <linux/sched.h> 17#include <linux/mm.h> 18#include <linux/smp.h> 19#include <linux/kernel.h> 20#include <linux/signal.h> 21#include <linux/errno.h> 22#include <linux/elf.h> 23#include <linux/ptrace.h> 24#include <linux/pagemap.h> 25#include <linux/ratelimit.h> 26#include <linux/syscalls.h> 27#ifdef CONFIG_PPC64 28#include <linux/compat.h> 29#else 30#include <linux/wait.h> 31#include <linux/unistd.h> 32#include <linux/stddef.h> 33#include <linux/tty.h> 34#include <linux/binfmts.h> 35#endif 36 37#include <linux/uaccess.h> 38#include <asm/cacheflush.h> 39#include <asm/syscalls.h> 40#include <asm/sigcontext.h> 41#include <asm/vdso.h> 42#include <asm/switch_to.h> 43#include <asm/tm.h> 44#include <asm/asm-prototypes.h> 45#ifdef CONFIG_PPC64 46#include <asm/syscalls_32.h> 47#include <asm/unistd.h> 48#else 49#include <asm/ucontext.h> 50#endif 51 52#include "signal.h" 53 54 55#ifdef CONFIG_PPC64 56#define old_sigaction old_sigaction32 57#define sigcontext sigcontext32 58#define mcontext mcontext32 59#define ucontext ucontext32 60 61/* 62 * Userspace code may pass a ucontext which doesn't include VSX added 63 * at the end. We need to check for this case. 64 */ 65#define UCONTEXTSIZEWITHOUTVSX \ 66 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32)) 67 68/* 69 * Returning 0 means we return to userspace via 70 * ret_from_except and thus restore all user 71 * registers from *regs. This is what we need 72 * to do when a signal has been delivered. 73 */ 74 75#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32)) 76#undef __SIGNAL_FRAMESIZE 77#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32 78#undef ELF_NVRREG 79#define ELF_NVRREG ELF_NVRREG32 80 81/* 82 * Functions for flipping sigsets (thanks to brain dead generic 83 * implementation that makes things simple for little endian only) 84 */ 85#define unsafe_put_sigset_t unsafe_put_compat_sigset 86#define unsafe_get_sigset_t unsafe_get_compat_sigset 87 88#define to_user_ptr(p) ptr_to_compat(p) 89#define from_user_ptr(p) compat_ptr(p) 90 91static __always_inline int 92__unsafe_save_general_regs(struct pt_regs *regs, struct mcontext __user *frame) 93{ 94 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 95 int val, i; 96 97 for (i = 0; i <= PT_RESULT; i ++) { 98 /* Force usr to alway see softe as 1 (interrupts enabled) */ 99 if (i == PT_SOFTE) 100 val = 1; 101 else 102 val = gregs[i]; 103 104 unsafe_put_user(val, &frame->mc_gregs[i], failed); 105 } 106 return 0; 107 108failed: 109 return 1; 110} 111 112static __always_inline int 113__unsafe_restore_general_regs(struct pt_regs *regs, struct mcontext __user *sr) 114{ 115 elf_greg_t64 *gregs = (elf_greg_t64 *)regs; 116 int i; 117 118 for (i = 0; i <= PT_RESULT; i++) { 119 if ((i == PT_MSR) || (i == PT_SOFTE)) 120 continue; 121 unsafe_get_user(gregs[i], &sr->mc_gregs[i], failed); 122 } 123 return 0; 124 125failed: 126 return 1; 127} 128 129#else /* CONFIG_PPC64 */ 130 131#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs)) 132 133#define unsafe_put_sigset_t(uset, set, label) do { \ 134 sigset_t __user *__us = uset ; \ 135 const sigset_t *__s = set; \ 136 \ 137 unsafe_copy_to_user(__us, __s, sizeof(*__us), label); \ 138} while (0) 139 140#define unsafe_get_sigset_t unsafe_get_user_sigset 141 142#define to_user_ptr(p) ((unsigned long)(p)) 143#define from_user_ptr(p) ((void __user *)(p)) 144 145static __always_inline int 146__unsafe_save_general_regs(struct pt_regs *regs, struct mcontext __user *frame) 147{ 148 unsafe_copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE, failed); 149 return 0; 150 151failed: 152 return 1; 153} 154 155static __always_inline 156int __unsafe_restore_general_regs(struct pt_regs *regs, struct mcontext __user *sr) 157{ 158 /* copy up to but not including MSR */ 159 unsafe_copy_from_user(regs, &sr->mc_gregs, PT_MSR * sizeof(elf_greg_t), failed); 160 161 /* copy from orig_r3 (the word after the MSR) up to the end */ 162 unsafe_copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3], 163 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t), failed); 164 165 return 0; 166 167failed: 168 return 1; 169} 170#endif 171 172#define unsafe_save_general_regs(regs, frame, label) do { \ 173 if (__unsafe_save_general_regs(regs, frame)) \ 174 goto label; \ 175} while (0) 176 177#define unsafe_restore_general_regs(regs, frame, label) do { \ 178 if (__unsafe_restore_general_regs(regs, frame)) \ 179 goto label; \ 180} while (0) 181 182/* 183 * When we have signals to deliver, we set up on the 184 * user stack, going down from the original stack pointer: 185 * an ABI gap of 56 words 186 * an mcontext struct 187 * a sigcontext struct 188 * a gap of __SIGNAL_FRAMESIZE bytes 189 * 190 * Each of these things must be a multiple of 16 bytes in size. The following 191 * structure represent all of this except the __SIGNAL_FRAMESIZE gap 192 * 193 */ 194struct sigframe { 195 struct sigcontext sctx; /* the sigcontext */ 196 struct mcontext mctx; /* all the register values */ 197#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 198 struct sigcontext sctx_transact; 199 struct mcontext mctx_transact; 200#endif 201 /* 202 * Programs using the rs6000/xcoff abi can save up to 19 gp 203 * regs and 18 fp regs below sp before decrementing it. 204 */ 205 int abigap[56]; 206}; 207 208/* 209 * When we have rt signals to deliver, we set up on the 210 * user stack, going down from the original stack pointer: 211 * one rt_sigframe struct (siginfo + ucontext + ABI gap) 212 * a gap of __SIGNAL_FRAMESIZE+16 bytes 213 * (the +16 is to get the siginfo and ucontext in the same 214 * positions as in older kernels). 215 * 216 * Each of these things must be a multiple of 16 bytes in size. 217 * 218 */ 219struct rt_sigframe { 220#ifdef CONFIG_PPC64 221 compat_siginfo_t info; 222#else 223 struct siginfo info; 224#endif 225 struct ucontext uc; 226#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 227 struct ucontext uc_transact; 228#endif 229 /* 230 * Programs using the rs6000/xcoff abi can save up to 19 gp 231 * regs and 18 fp regs below sp before decrementing it. 232 */ 233 int abigap[56]; 234}; 235 236unsigned long get_min_sigframe_size_32(void) 237{ 238 return max(sizeof(struct rt_sigframe) + __SIGNAL_FRAMESIZE + 16, 239 sizeof(struct sigframe) + __SIGNAL_FRAMESIZE); 240} 241 242/* 243 * Save the current user registers on the user stack. 244 * We only save the altivec/spe registers if the process has used 245 * altivec/spe instructions at some point. 246 */ 247static void prepare_save_user_regs(int ctx_has_vsx_region) 248{ 249 /* Make sure floating point registers are stored in regs */ 250 flush_fp_to_thread(current); 251#ifdef CONFIG_ALTIVEC 252 if (current->thread.used_vr) 253 flush_altivec_to_thread(current); 254 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 255 current->thread.vrsave = mfspr(SPRN_VRSAVE); 256#endif 257#ifdef CONFIG_VSX 258 if (current->thread.used_vsr && ctx_has_vsx_region) 259 flush_vsx_to_thread(current); 260#endif 261#ifdef CONFIG_SPE 262 if (current->thread.used_spe) 263 flush_spe_to_thread(current); 264#endif 265} 266 267static __always_inline int 268__unsafe_save_user_regs(struct pt_regs *regs, struct mcontext __user *frame, 269 struct mcontext __user *tm_frame, int ctx_has_vsx_region) 270{ 271 unsigned long msr = regs->msr; 272 273 /* save general registers */ 274 unsafe_save_general_regs(regs, frame, failed); 275 276#ifdef CONFIG_ALTIVEC 277 /* save altivec registers */ 278 if (current->thread.used_vr) { 279 unsafe_copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state, 280 ELF_NVRREG * sizeof(vector128), failed); 281 /* set MSR_VEC in the saved MSR value to indicate that 282 frame->mc_vregs contains valid data */ 283 msr |= MSR_VEC; 284 } 285 /* else assert((regs->msr & MSR_VEC) == 0) */ 286 287 /* We always copy to/from vrsave, it's 0 if we don't have or don't 288 * use altivec. Since VSCR only contains 32 bits saved in the least 289 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 290 * most significant bits of that same vector. --BenH 291 * Note that the current VRSAVE value is in the SPR at this point. 292 */ 293 unsafe_put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32], 294 failed); 295#endif /* CONFIG_ALTIVEC */ 296 unsafe_copy_fpr_to_user(&frame->mc_fregs, current, failed); 297 298 /* 299 * Clear the MSR VSX bit to indicate there is no valid state attached 300 * to this context, except in the specific case below where we set it. 301 */ 302 msr &= ~MSR_VSX; 303#ifdef CONFIG_VSX 304 /* 305 * Copy VSR 0-31 upper half from thread_struct to local 306 * buffer, then write that to userspace. Also set MSR_VSX in 307 * the saved MSR value to indicate that frame->mc_vregs 308 * contains valid data 309 */ 310 if (current->thread.used_vsr && ctx_has_vsx_region) { 311 unsafe_copy_vsx_to_user(&frame->mc_vsregs, current, failed); 312 msr |= MSR_VSX; 313 } 314#endif /* CONFIG_VSX */ 315#ifdef CONFIG_SPE 316 /* save spe registers */ 317 if (current->thread.used_spe) { 318 unsafe_copy_to_user(&frame->mc_vregs, current->thread.evr, 319 ELF_NEVRREG * sizeof(u32), failed); 320 /* set MSR_SPE in the saved MSR value to indicate that 321 frame->mc_vregs contains valid data */ 322 msr |= MSR_SPE; 323 } 324 /* else assert((regs->msr & MSR_SPE) == 0) */ 325 326 /* We always copy to/from spefscr */ 327 unsafe_put_user(current->thread.spefscr, 328 (u32 __user *)&frame->mc_vregs + ELF_NEVRREG, failed); 329#endif /* CONFIG_SPE */ 330 331 unsafe_put_user(msr, &frame->mc_gregs[PT_MSR], failed); 332 333 /* We need to write 0 the MSR top 32 bits in the tm frame so that we 334 * can check it on the restore to see if TM is active 335 */ 336 if (tm_frame) 337 unsafe_put_user(0, &tm_frame->mc_gregs[PT_MSR], failed); 338 339 return 0; 340 341failed: 342 return 1; 343} 344 345#define unsafe_save_user_regs(regs, frame, tm_frame, has_vsx, label) do { \ 346 if (__unsafe_save_user_regs(regs, frame, tm_frame, has_vsx)) \ 347 goto label; \ 348} while (0) 349 350#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 351/* 352 * Save the current user registers on the user stack. 353 * We only save the altivec/spe registers if the process has used 354 * altivec/spe instructions at some point. 355 * We also save the transactional registers to a second ucontext in the 356 * frame. 357 * 358 * See __unsafe_save_user_regs() and signal_64.c:setup_tm_sigcontexts(). 359 */ 360static void prepare_save_tm_user_regs(void) 361{ 362 WARN_ON(tm_suspend_disabled); 363 364 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 365 current->thread.ckvrsave = mfspr(SPRN_VRSAVE); 366} 367 368static __always_inline int 369save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame, 370 struct mcontext __user *tm_frame, unsigned long msr) 371{ 372 /* Save both sets of general registers */ 373 unsafe_save_general_regs(¤t->thread.ckpt_regs, frame, failed); 374 unsafe_save_general_regs(regs, tm_frame, failed); 375 376 /* Stash the top half of the 64bit MSR into the 32bit MSR word 377 * of the transactional mcontext. This way we have a backward-compatible 378 * MSR in the 'normal' (checkpointed) mcontext and additionally one can 379 * also look at what type of transaction (T or S) was active at the 380 * time of the signal. 381 */ 382 unsafe_put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR], failed); 383 384 /* save altivec registers */ 385 if (current->thread.used_vr) { 386 unsafe_copy_to_user(&frame->mc_vregs, ¤t->thread.ckvr_state, 387 ELF_NVRREG * sizeof(vector128), failed); 388 if (msr & MSR_VEC) 389 unsafe_copy_to_user(&tm_frame->mc_vregs, 390 ¤t->thread.vr_state, 391 ELF_NVRREG * sizeof(vector128), failed); 392 else 393 unsafe_copy_to_user(&tm_frame->mc_vregs, 394 ¤t->thread.ckvr_state, 395 ELF_NVRREG * sizeof(vector128), failed); 396 397 /* set MSR_VEC in the saved MSR value to indicate that 398 * frame->mc_vregs contains valid data 399 */ 400 msr |= MSR_VEC; 401 } 402 403 /* We always copy to/from vrsave, it's 0 if we don't have or don't 404 * use altivec. Since VSCR only contains 32 bits saved in the least 405 * significant bits of a vector, we "cheat" and stuff VRSAVE in the 406 * most significant bits of that same vector. --BenH 407 */ 408 unsafe_put_user(current->thread.ckvrsave, 409 (u32 __user *)&frame->mc_vregs[32], failed); 410 if (msr & MSR_VEC) 411 unsafe_put_user(current->thread.vrsave, 412 (u32 __user *)&tm_frame->mc_vregs[32], failed); 413 else 414 unsafe_put_user(current->thread.ckvrsave, 415 (u32 __user *)&tm_frame->mc_vregs[32], failed); 416 417 unsafe_copy_ckfpr_to_user(&frame->mc_fregs, current, failed); 418 if (msr & MSR_FP) 419 unsafe_copy_fpr_to_user(&tm_frame->mc_fregs, current, failed); 420 else 421 unsafe_copy_ckfpr_to_user(&tm_frame->mc_fregs, current, failed); 422 423 /* 424 * Copy VSR 0-31 upper half from thread_struct to local 425 * buffer, then write that to userspace. Also set MSR_VSX in 426 * the saved MSR value to indicate that frame->mc_vregs 427 * contains valid data 428 */ 429 if (current->thread.used_vsr) { 430 unsafe_copy_ckvsx_to_user(&frame->mc_vsregs, current, failed); 431 if (msr & MSR_VSX) 432 unsafe_copy_vsx_to_user(&tm_frame->mc_vsregs, current, failed); 433 else 434 unsafe_copy_ckvsx_to_user(&tm_frame->mc_vsregs, current, failed); 435 436 msr |= MSR_VSX; 437 } 438 439 unsafe_put_user(msr, &frame->mc_gregs[PT_MSR], failed); 440 441 return 0; 442 443failed: 444 return 1; 445} 446#else 447static void prepare_save_tm_user_regs(void) { } 448 449static __always_inline int 450save_tm_user_regs_unsafe(struct pt_regs *regs, struct mcontext __user *frame, 451 struct mcontext __user *tm_frame, unsigned long msr) 452{ 453 return 0; 454} 455#endif 456 457#define unsafe_save_tm_user_regs(regs, frame, tm_frame, msr, label) do { \ 458 if (save_tm_user_regs_unsafe(regs, frame, tm_frame, msr)) \ 459 goto label; \ 460} while (0) 461 462/* 463 * Restore the current user register values from the user stack, 464 * (except for MSR). 465 */ 466static long restore_user_regs(struct pt_regs *regs, 467 struct mcontext __user *sr, int sig) 468{ 469 unsigned int save_r2 = 0; 470 unsigned long msr; 471#ifdef CONFIG_VSX 472 int i; 473#endif 474 475 if (!user_read_access_begin(sr, sizeof(*sr))) 476 return 1; 477 /* 478 * restore general registers but not including MSR or SOFTE. Also 479 * take care of keeping r2 (TLS) intact if not a signal 480 */ 481 if (!sig) 482 save_r2 = (unsigned int)regs->gpr[2]; 483 unsafe_restore_general_regs(regs, sr, failed); 484 set_trap_norestart(regs); 485 unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed); 486 if (!sig) 487 regs->gpr[2] = (unsigned long) save_r2; 488 489 /* if doing signal return, restore the previous little-endian mode */ 490 if (sig) 491 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (msr & MSR_LE)); 492 493#ifdef CONFIG_ALTIVEC 494 /* 495 * Force the process to reload the altivec registers from 496 * current->thread when it next does altivec instructions 497 */ 498 regs_set_return_msr(regs, regs->msr & ~MSR_VEC); 499 if (msr & MSR_VEC) { 500 /* restore altivec registers from the stack */ 501 unsafe_copy_from_user(¤t->thread.vr_state, &sr->mc_vregs, 502 sizeof(sr->mc_vregs), failed); 503 current->thread.used_vr = true; 504 } else if (current->thread.used_vr) 505 memset(¤t->thread.vr_state, 0, 506 ELF_NVRREG * sizeof(vector128)); 507 508 /* Always get VRSAVE back */ 509 unsafe_get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32], failed); 510 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 511 mtspr(SPRN_VRSAVE, current->thread.vrsave); 512#endif /* CONFIG_ALTIVEC */ 513 unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed); 514 515#ifdef CONFIG_VSX 516 /* 517 * Force the process to reload the VSX registers from 518 * current->thread when it next does VSX instruction. 519 */ 520 regs_set_return_msr(regs, regs->msr & ~MSR_VSX); 521 if (msr & MSR_VSX) { 522 /* 523 * Restore altivec registers from the stack to a local 524 * buffer, then write this out to the thread_struct 525 */ 526 unsafe_copy_vsx_from_user(current, &sr->mc_vsregs, failed); 527 current->thread.used_vsr = true; 528 } else if (current->thread.used_vsr) 529 for (i = 0; i < 32 ; i++) 530 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0; 531#endif /* CONFIG_VSX */ 532 /* 533 * force the process to reload the FP registers from 534 * current->thread when it next does FP instructions 535 */ 536 regs_set_return_msr(regs, regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1)); 537 538#ifdef CONFIG_SPE 539 /* 540 * Force the process to reload the spe registers from 541 * current->thread when it next does spe instructions. 542 * Since this is user ABI, we must enforce the sizing. 543 */ 544 BUILD_BUG_ON(sizeof(current->thread.spe) != ELF_NEVRREG * sizeof(u32)); 545 regs_set_return_msr(regs, regs->msr & ~MSR_SPE); 546 if (msr & MSR_SPE) { 547 /* restore spe registers from the stack */ 548 unsafe_copy_from_user(¤t->thread.spe, &sr->mc_vregs, 549 sizeof(current->thread.spe), failed); 550 current->thread.used_spe = true; 551 } else if (current->thread.used_spe) 552 memset(¤t->thread.spe, 0, sizeof(current->thread.spe)); 553 554 /* Always get SPEFSCR back */ 555 unsafe_get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG, failed); 556#endif /* CONFIG_SPE */ 557 558 user_read_access_end(); 559 return 0; 560 561failed: 562 user_read_access_end(); 563 return 1; 564} 565 566#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 567/* 568 * Restore the current user register values from the user stack, except for 569 * MSR, and recheckpoint the original checkpointed register state for processes 570 * in transactions. 571 */ 572static long restore_tm_user_regs(struct pt_regs *regs, 573 struct mcontext __user *sr, 574 struct mcontext __user *tm_sr) 575{ 576 unsigned long msr, msr_hi; 577 int i; 578 579 if (tm_suspend_disabled) 580 return 1; 581 /* 582 * restore general registers but not including MSR or SOFTE. Also 583 * take care of keeping r2 (TLS) intact if not a signal. 584 * See comment in signal_64.c:restore_tm_sigcontexts(); 585 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR 586 * were set by the signal delivery. 587 */ 588 if (!user_read_access_begin(sr, sizeof(*sr))) 589 return 1; 590 591 unsafe_restore_general_regs(¤t->thread.ckpt_regs, sr, failed); 592 unsafe_get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP], failed); 593 unsafe_get_user(msr, &sr->mc_gregs[PT_MSR], failed); 594 595 /* Restore the previous little-endian mode */ 596 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (msr & MSR_LE)); 597 598 regs_set_return_msr(regs, regs->msr & ~MSR_VEC); 599 if (msr & MSR_VEC) { 600 /* restore altivec registers from the stack */ 601 unsafe_copy_from_user(¤t->thread.ckvr_state, &sr->mc_vregs, 602 sizeof(sr->mc_vregs), failed); 603 current->thread.used_vr = true; 604 } else if (current->thread.used_vr) { 605 memset(¤t->thread.vr_state, 0, 606 ELF_NVRREG * sizeof(vector128)); 607 memset(¤t->thread.ckvr_state, 0, 608 ELF_NVRREG * sizeof(vector128)); 609 } 610 611 /* Always get VRSAVE back */ 612 unsafe_get_user(current->thread.ckvrsave, 613 (u32 __user *)&sr->mc_vregs[32], failed); 614 if (cpu_has_feature(CPU_FTR_ALTIVEC)) 615 mtspr(SPRN_VRSAVE, current->thread.ckvrsave); 616 617 regs_set_return_msr(regs, regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1)); 618 619 unsafe_copy_fpr_from_user(current, &sr->mc_fregs, failed); 620 621 regs_set_return_msr(regs, regs->msr & ~MSR_VSX); 622 if (msr & MSR_VSX) { 623 /* 624 * Restore altivec registers from the stack to a local 625 * buffer, then write this out to the thread_struct 626 */ 627 unsafe_copy_ckvsx_from_user(current, &sr->mc_vsregs, failed); 628 current->thread.used_vsr = true; 629 } else if (current->thread.used_vsr) 630 for (i = 0; i < 32 ; i++) { 631 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0; 632 current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0; 633 } 634 635 user_read_access_end(); 636 637 if (!user_read_access_begin(tm_sr, sizeof(*tm_sr))) 638 return 1; 639 640 unsafe_restore_general_regs(regs, tm_sr, failed); 641 642 /* restore altivec registers from the stack */ 643 if (msr & MSR_VEC) 644 unsafe_copy_from_user(¤t->thread.vr_state, &tm_sr->mc_vregs, 645 sizeof(sr->mc_vregs), failed); 646 647 /* Always get VRSAVE back */ 648 unsafe_get_user(current->thread.vrsave, 649 (u32 __user *)&tm_sr->mc_vregs[32], failed); 650 651 unsafe_copy_ckfpr_from_user(current, &tm_sr->mc_fregs, failed); 652 653 if (msr & MSR_VSX) { 654 /* 655 * Restore altivec registers from the stack to a local 656 * buffer, then write this out to the thread_struct 657 */ 658 unsafe_copy_vsx_from_user(current, &tm_sr->mc_vsregs, failed); 659 current->thread.used_vsr = true; 660 } 661 662 /* Get the top half of the MSR from the user context */ 663 unsafe_get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR], failed); 664 msr_hi <<= 32; 665 666 user_read_access_end(); 667 668 /* If TM bits are set to the reserved value, it's an invalid context */ 669 if (MSR_TM_RESV(msr_hi)) 670 return 1; 671 672 /* 673 * Disabling preemption, since it is unsafe to be preempted 674 * with MSR[TS] set without recheckpointing. 675 */ 676 preempt_disable(); 677 678 /* 679 * CAUTION: 680 * After regs->MSR[TS] being updated, make sure that get_user(), 681 * put_user() or similar functions are *not* called. These 682 * functions can generate page faults which will cause the process 683 * to be de-scheduled with MSR[TS] set but without calling 684 * tm_recheckpoint(). This can cause a bug. 685 * 686 * Pull in the MSR TM bits from the user context 687 */ 688 regs_set_return_msr(regs, (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK)); 689 /* Now, recheckpoint. This loads up all of the checkpointed (older) 690 * registers, including FP and V[S]Rs. After recheckpointing, the 691 * transactional versions should be loaded. 692 */ 693 tm_enable(); 694 /* Make sure the transaction is marked as failed */ 695 current->thread.tm_texasr |= TEXASR_FS; 696 /* This loads the checkpointed FP/VEC state, if used */ 697 tm_recheckpoint(¤t->thread); 698 699 /* This loads the speculative FP/VEC state, if used */ 700 msr_check_and_set(msr & (MSR_FP | MSR_VEC)); 701 if (msr & MSR_FP) { 702 load_fp_state(¤t->thread.fp_state); 703 regs_set_return_msr(regs, regs->msr | (MSR_FP | current->thread.fpexc_mode)); 704 } 705 if (msr & MSR_VEC) { 706 load_vr_state(¤t->thread.vr_state); 707 regs_set_return_msr(regs, regs->msr | MSR_VEC); 708 } 709 710 preempt_enable(); 711 712 return 0; 713 714failed: 715 user_read_access_end(); 716 return 1; 717} 718#else 719static long restore_tm_user_regs(struct pt_regs *regs, struct mcontext __user *sr, 720 struct mcontext __user *tm_sr) 721{ 722 return 0; 723} 724#endif 725 726#ifdef CONFIG_PPC64 727 728#define copy_siginfo_to_user copy_siginfo_to_user32 729 730#endif /* CONFIG_PPC64 */ 731 732/* 733 * Set up a signal frame for a "real-time" signal handler 734 * (one which gets siginfo). 735 */ 736int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset, 737 struct task_struct *tsk) 738{ 739 struct rt_sigframe __user *frame; 740 struct mcontext __user *mctx; 741 struct mcontext __user *tm_mctx = NULL; 742 unsigned long newsp = 0; 743 unsigned long tramp; 744 struct pt_regs *regs = tsk->thread.regs; 745 /* Save the thread's msr before get_tm_stackpointer() changes it */ 746 unsigned long msr = regs->msr; 747 748 /* Set up Signal Frame */ 749 frame = get_sigframe(ksig, tsk, sizeof(*frame), 1); 750 mctx = &frame->uc.uc_mcontext; 751#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 752 tm_mctx = &frame->uc_transact.uc_mcontext; 753#endif 754 if (MSR_TM_ACTIVE(msr)) 755 prepare_save_tm_user_regs(); 756 else 757 prepare_save_user_regs(1); 758 759 if (!user_access_begin(frame, sizeof(*frame))) 760 goto badframe; 761 762 /* Put the siginfo & fill in most of the ucontext */ 763 unsafe_put_user(0, &frame->uc.uc_flags, failed); 764#ifdef CONFIG_PPC64 765 unsafe_compat_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed); 766#else 767 unsafe_save_altstack(&frame->uc.uc_stack, regs->gpr[1], failed); 768#endif 769 unsafe_put_user(to_user_ptr(&frame->uc.uc_mcontext), &frame->uc.uc_regs, failed); 770 771 if (MSR_TM_ACTIVE(msr)) { 772#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 773 unsafe_put_user((unsigned long)&frame->uc_transact, 774 &frame->uc.uc_link, failed); 775 unsafe_put_user((unsigned long)tm_mctx, 776 &frame->uc_transact.uc_regs, failed); 777#endif 778 unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed); 779 } else { 780 unsafe_put_user(0, &frame->uc.uc_link, failed); 781 unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed); 782 } 783 784 /* Save user registers on the stack */ 785 if (tsk->mm->context.vdso) { 786 tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp_rt32); 787 } else { 788 tramp = (unsigned long)mctx->mc_pad; 789 unsafe_put_user(PPC_RAW_LI(_R0, __NR_rt_sigreturn), &mctx->mc_pad[0], failed); 790 unsafe_put_user(PPC_RAW_SC(), &mctx->mc_pad[1], failed); 791 asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0])); 792 } 793 unsafe_put_sigset_t(&frame->uc.uc_sigmask, oldset, failed); 794 795 user_access_end(); 796 797 if (copy_siginfo_to_user(&frame->info, &ksig->info)) 798 goto badframe; 799 800 regs->link = tramp; 801 802#ifdef CONFIG_PPC_FPU_REGS 803 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */ 804#endif 805 806 /* create a stack frame for the caller of the handler */ 807 newsp = ((unsigned long)frame) - (__SIGNAL_FRAMESIZE + 16); 808 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 809 goto badframe; 810 811 /* Fill registers for signal handler */ 812 regs->gpr[1] = newsp; 813 regs->gpr[3] = ksig->sig; 814 regs->gpr[4] = (unsigned long)&frame->info; 815 regs->gpr[5] = (unsigned long)&frame->uc; 816 regs->gpr[6] = (unsigned long)frame; 817 regs_set_return_ip(regs, (unsigned long) ksig->ka.sa.sa_handler); 818 /* enter the signal handler in native-endian mode */ 819 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (MSR_KERNEL & MSR_LE)); 820 821 return 0; 822 823failed: 824 user_access_end(); 825 826badframe: 827 signal_fault(tsk, regs, "handle_rt_signal32", frame); 828 829 return 1; 830} 831 832/* 833 * OK, we're invoking a handler 834 */ 835int handle_signal32(struct ksignal *ksig, sigset_t *oldset, 836 struct task_struct *tsk) 837{ 838 struct sigcontext __user *sc; 839 struct sigframe __user *frame; 840 struct mcontext __user *mctx; 841 struct mcontext __user *tm_mctx = NULL; 842 unsigned long newsp = 0; 843 unsigned long tramp; 844 struct pt_regs *regs = tsk->thread.regs; 845 /* Save the thread's msr before get_tm_stackpointer() changes it */ 846 unsigned long msr = regs->msr; 847 848 /* Set up Signal Frame */ 849 frame = get_sigframe(ksig, tsk, sizeof(*frame), 1); 850 mctx = &frame->mctx; 851#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 852 tm_mctx = &frame->mctx_transact; 853#endif 854 if (MSR_TM_ACTIVE(msr)) 855 prepare_save_tm_user_regs(); 856 else 857 prepare_save_user_regs(1); 858 859 if (!user_access_begin(frame, sizeof(*frame))) 860 goto badframe; 861 sc = (struct sigcontext __user *) &frame->sctx; 862 863#if _NSIG != 64 864#error "Please adjust handle_signal()" 865#endif 866 unsafe_put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler, failed); 867 unsafe_put_user(oldset->sig[0], &sc->oldmask, failed); 868#ifdef CONFIG_PPC64 869 unsafe_put_user((oldset->sig[0] >> 32), &sc->_unused[3], failed); 870#else 871 unsafe_put_user(oldset->sig[1], &sc->_unused[3], failed); 872#endif 873 unsafe_put_user(to_user_ptr(mctx), &sc->regs, failed); 874 unsafe_put_user(ksig->sig, &sc->signal, failed); 875 876 if (MSR_TM_ACTIVE(msr)) 877 unsafe_save_tm_user_regs(regs, mctx, tm_mctx, msr, failed); 878 else 879 unsafe_save_user_regs(regs, mctx, tm_mctx, 1, failed); 880 881 if (tsk->mm->context.vdso) { 882 tramp = VDSO32_SYMBOL(tsk->mm->context.vdso, sigtramp32); 883 } else { 884 tramp = (unsigned long)mctx->mc_pad; 885 unsafe_put_user(PPC_RAW_LI(_R0, __NR_sigreturn), &mctx->mc_pad[0], failed); 886 unsafe_put_user(PPC_RAW_SC(), &mctx->mc_pad[1], failed); 887 asm("dcbst %y0; sync; icbi %y0; sync" :: "Z" (mctx->mc_pad[0])); 888 } 889 user_access_end(); 890 891 regs->link = tramp; 892 893#ifdef CONFIG_PPC_FPU_REGS 894 tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */ 895#endif 896 897 /* create a stack frame for the caller of the handler */ 898 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE; 899 if (put_user(regs->gpr[1], (u32 __user *)newsp)) 900 goto badframe; 901 902 regs->gpr[1] = newsp; 903 regs->gpr[3] = ksig->sig; 904 regs->gpr[4] = (unsigned long) sc; 905 regs_set_return_ip(regs, (unsigned long) ksig->ka.sa.sa_handler); 906 /* enter the signal handler in native-endian mode */ 907 regs_set_return_msr(regs, (regs->msr & ~MSR_LE) | (MSR_KERNEL & MSR_LE)); 908 909 return 0; 910 911failed: 912 user_access_end(); 913 914badframe: 915 signal_fault(tsk, regs, "handle_signal32", frame); 916 917 return 1; 918} 919 920static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig) 921{ 922 sigset_t set; 923 struct mcontext __user *mcp; 924 925 if (!user_read_access_begin(ucp, sizeof(*ucp))) 926 return -EFAULT; 927 928 unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed); 929#ifdef CONFIG_PPC64 930 { 931 u32 cmcp; 932 933 unsafe_get_user(cmcp, &ucp->uc_regs, failed); 934 mcp = (struct mcontext __user *)(u64)cmcp; 935 } 936#else 937 unsafe_get_user(mcp, &ucp->uc_regs, failed); 938#endif 939 user_read_access_end(); 940 941 set_current_blocked(&set); 942 if (restore_user_regs(regs, mcp, sig)) 943 return -EFAULT; 944 945 return 0; 946 947failed: 948 user_read_access_end(); 949 return -EFAULT; 950} 951 952#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 953static int do_setcontext_tm(struct ucontext __user *ucp, 954 struct ucontext __user *tm_ucp, 955 struct pt_regs *regs) 956{ 957 sigset_t set; 958 struct mcontext __user *mcp; 959 struct mcontext __user *tm_mcp; 960 u32 cmcp; 961 u32 tm_cmcp; 962 963 if (!user_read_access_begin(ucp, sizeof(*ucp))) 964 return -EFAULT; 965 966 unsafe_get_sigset_t(&set, &ucp->uc_sigmask, failed); 967 unsafe_get_user(cmcp, &ucp->uc_regs, failed); 968 969 user_read_access_end(); 970 971 if (__get_user(tm_cmcp, &tm_ucp->uc_regs)) 972 return -EFAULT; 973 mcp = (struct mcontext __user *)(u64)cmcp; 974 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp; 975 /* no need to check access_ok(mcp), since mcp < 4GB */ 976 977 set_current_blocked(&set); 978 if (restore_tm_user_regs(regs, mcp, tm_mcp)) 979 return -EFAULT; 980 981 return 0; 982 983failed: 984 user_read_access_end(); 985 return -EFAULT; 986} 987#endif 988 989#ifdef CONFIG_PPC64 990COMPAT_SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx, 991 struct ucontext __user *, new_ctx, int, ctx_size) 992#else 993SYSCALL_DEFINE3(swapcontext, struct ucontext __user *, old_ctx, 994 struct ucontext __user *, new_ctx, long, ctx_size) 995#endif 996{ 997 struct pt_regs *regs = current_pt_regs(); 998 int ctx_has_vsx_region = 0; 999 1000#ifdef CONFIG_PPC64 1001 unsigned long new_msr = 0; 1002 1003 if (new_ctx) { 1004 struct mcontext __user *mcp; 1005 u32 cmcp; 1006 1007 /* 1008 * Get pointer to the real mcontext. No need for 1009 * access_ok since we are dealing with compat 1010 * pointers. 1011 */ 1012 if (__get_user(cmcp, &new_ctx->uc_regs)) 1013 return -EFAULT; 1014 mcp = (struct mcontext __user *)(u64)cmcp; 1015 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR])) 1016 return -EFAULT; 1017 } 1018 /* 1019 * Check that the context is not smaller than the original 1020 * size (with VMX but without VSX) 1021 */ 1022 if (ctx_size < UCONTEXTSIZEWITHOUTVSX) 1023 return -EINVAL; 1024 /* 1025 * If the new context state sets the MSR VSX bits but 1026 * it doesn't provide VSX state. 1027 */ 1028 if ((ctx_size < sizeof(struct ucontext)) && 1029 (new_msr & MSR_VSX)) 1030 return -EINVAL; 1031 /* Does the context have enough room to store VSX data? */ 1032 if (ctx_size >= sizeof(struct ucontext)) 1033 ctx_has_vsx_region = 1; 1034#else 1035 /* Context size is for future use. Right now, we only make sure 1036 * we are passed something we understand 1037 */ 1038 if (ctx_size < sizeof(struct ucontext)) 1039 return -EINVAL; 1040#endif 1041 if (old_ctx != NULL) { 1042 struct mcontext __user *mctx; 1043 1044 /* 1045 * old_ctx might not be 16-byte aligned, in which 1046 * case old_ctx->uc_mcontext won't be either. 1047 * Because we have the old_ctx->uc_pad2 field 1048 * before old_ctx->uc_mcontext, we need to round down 1049 * from &old_ctx->uc_mcontext to a 16-byte boundary. 1050 */ 1051 mctx = (struct mcontext __user *) 1052 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL); 1053 prepare_save_user_regs(ctx_has_vsx_region); 1054 if (!user_write_access_begin(old_ctx, ctx_size)) 1055 return -EFAULT; 1056 unsafe_save_user_regs(regs, mctx, NULL, ctx_has_vsx_region, failed); 1057 unsafe_put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked, failed); 1058 unsafe_put_user(to_user_ptr(mctx), &old_ctx->uc_regs, failed); 1059 user_write_access_end(); 1060 } 1061 if (new_ctx == NULL) 1062 return 0; 1063 if (!access_ok(new_ctx, ctx_size) || 1064 fault_in_readable((char __user *)new_ctx, ctx_size)) 1065 return -EFAULT; 1066 1067 /* 1068 * If we get a fault copying the context into the kernel's 1069 * image of the user's registers, we can't just return -EFAULT 1070 * because the user's registers will be corrupted. For instance 1071 * the NIP value may have been updated but not some of the 1072 * other registers. Given that we have done the access_ok 1073 * and successfully read the first and last bytes of the region 1074 * above, this should only happen in an out-of-memory situation 1075 * or if another thread unmaps the region containing the context. 1076 * We kill the task with a SIGSEGV in this situation. 1077 */ 1078 if (do_setcontext(new_ctx, regs, 0)) { 1079 force_exit_sig(SIGSEGV); 1080 return -EFAULT; 1081 } 1082 1083 set_thread_flag(TIF_RESTOREALL); 1084 return 0; 1085 1086failed: 1087 user_write_access_end(); 1088 return -EFAULT; 1089} 1090 1091#ifdef CONFIG_PPC64 1092COMPAT_SYSCALL_DEFINE0(rt_sigreturn) 1093#else 1094SYSCALL_DEFINE0(rt_sigreturn) 1095#endif 1096{ 1097 struct rt_sigframe __user *rt_sf; 1098 struct pt_regs *regs = current_pt_regs(); 1099 int tm_restore = 0; 1100#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1101 struct ucontext __user *uc_transact; 1102 unsigned long msr_hi; 1103 unsigned long tmp; 1104#endif 1105 /* Always make any pending restarted system calls return -EINTR */ 1106 current->restart_block.fn = do_no_restart_syscall; 1107 1108 rt_sf = (struct rt_sigframe __user *) 1109 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16); 1110 if (!access_ok(rt_sf, sizeof(*rt_sf))) 1111 goto bad; 1112 1113#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1114 /* 1115 * If there is a transactional state then throw it away. 1116 * The purpose of a sigreturn is to destroy all traces of the 1117 * signal frame, this includes any transactional state created 1118 * within in. We only check for suspended as we can never be 1119 * active in the kernel, we are active, there is nothing better to 1120 * do than go ahead and Bad Thing later. 1121 * The cause is not important as there will never be a 1122 * recheckpoint so it's not user visible. 1123 */ 1124 if (MSR_TM_SUSPENDED(mfmsr())) 1125 tm_reclaim_current(0); 1126 1127 if (__get_user(tmp, &rt_sf->uc.uc_link)) 1128 goto bad; 1129 uc_transact = (struct ucontext __user *)(uintptr_t)tmp; 1130 if (uc_transact) { 1131 u32 cmcp; 1132 struct mcontext __user *mcp; 1133 1134 if (__get_user(cmcp, &uc_transact->uc_regs)) 1135 return -EFAULT; 1136 mcp = (struct mcontext __user *)(u64)cmcp; 1137 /* The top 32 bits of the MSR are stashed in the transactional 1138 * ucontext. */ 1139 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR])) 1140 goto bad; 1141 1142 if (MSR_TM_ACTIVE(msr_hi<<32)) { 1143 /* Trying to start TM on non TM system */ 1144 if (!cpu_has_feature(CPU_FTR_TM)) 1145 goto bad; 1146 /* We only recheckpoint on return if we're 1147 * transaction. 1148 */ 1149 tm_restore = 1; 1150 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs)) 1151 goto bad; 1152 } 1153 } 1154 if (!tm_restore) { 1155 /* 1156 * Unset regs->msr because ucontext MSR TS is not 1157 * set, and recheckpoint was not called. This avoid 1158 * hitting a TM Bad thing at RFID 1159 */ 1160 regs_set_return_msr(regs, regs->msr & ~MSR_TS_MASK); 1161 } 1162 /* Fall through, for non-TM restore */ 1163#endif 1164 if (!tm_restore) 1165 if (do_setcontext(&rt_sf->uc, regs, 1)) 1166 goto bad; 1167 1168 /* 1169 * It's not clear whether or why it is desirable to save the 1170 * sigaltstack setting on signal delivery and restore it on 1171 * signal return. But other architectures do this and we have 1172 * always done it up until now so it is probably better not to 1173 * change it. -- paulus 1174 */ 1175#ifdef CONFIG_PPC64 1176 if (compat_restore_altstack(&rt_sf->uc.uc_stack)) 1177 goto bad; 1178#else 1179 if (restore_altstack(&rt_sf->uc.uc_stack)) 1180 goto bad; 1181#endif 1182 set_thread_flag(TIF_RESTOREALL); 1183 return 0; 1184 1185 bad: 1186 signal_fault(current, regs, "sys_rt_sigreturn", rt_sf); 1187 1188 force_sig(SIGSEGV); 1189 return 0; 1190} 1191 1192#ifdef CONFIG_PPC32 1193SYSCALL_DEFINE3(debug_setcontext, struct ucontext __user *, ctx, 1194 int, ndbg, struct sig_dbg_op __user *, dbg) 1195{ 1196 struct pt_regs *regs = current_pt_regs(); 1197 struct sig_dbg_op op; 1198 int i; 1199 unsigned long new_msr = regs->msr; 1200#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1201 unsigned long new_dbcr0 = current->thread.debug.dbcr0; 1202#endif 1203 1204 for (i=0; i<ndbg; i++) { 1205 if (copy_from_user(&op, dbg + i, sizeof(op))) 1206 return -EFAULT; 1207 switch (op.dbg_type) { 1208 case SIG_DBG_SINGLE_STEPPING: 1209#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1210 if (op.dbg_value) { 1211 new_msr |= MSR_DE; 1212 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC); 1213 } else { 1214 new_dbcr0 &= ~DBCR0_IC; 1215 if (!DBCR_ACTIVE_EVENTS(new_dbcr0, 1216 current->thread.debug.dbcr1)) { 1217 new_msr &= ~MSR_DE; 1218 new_dbcr0 &= ~DBCR0_IDM; 1219 } 1220 } 1221#else 1222 if (op.dbg_value) 1223 new_msr |= MSR_SE; 1224 else 1225 new_msr &= ~MSR_SE; 1226#endif 1227 break; 1228 case SIG_DBG_BRANCH_TRACING: 1229#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1230 return -EINVAL; 1231#else 1232 if (op.dbg_value) 1233 new_msr |= MSR_BE; 1234 else 1235 new_msr &= ~MSR_BE; 1236#endif 1237 break; 1238 1239 default: 1240 return -EINVAL; 1241 } 1242 } 1243 1244 /* We wait until here to actually install the values in the 1245 registers so if we fail in the above loop, it will not 1246 affect the contents of these registers. After this point, 1247 failure is a problem, anyway, and it's very unlikely unless 1248 the user is really doing something wrong. */ 1249 regs_set_return_msr(regs, new_msr); 1250#ifdef CONFIG_PPC_ADV_DEBUG_REGS 1251 current->thread.debug.dbcr0 = new_dbcr0; 1252#endif 1253 1254 if (!access_ok(ctx, sizeof(*ctx)) || 1255 fault_in_readable((char __user *)ctx, sizeof(*ctx))) 1256 return -EFAULT; 1257 1258 /* 1259 * If we get a fault copying the context into the kernel's 1260 * image of the user's registers, we can't just return -EFAULT 1261 * because the user's registers will be corrupted. For instance 1262 * the NIP value may have been updated but not some of the 1263 * other registers. Given that we have done the access_ok 1264 * and successfully read the first and last bytes of the region 1265 * above, this should only happen in an out-of-memory situation 1266 * or if another thread unmaps the region containing the context. 1267 * We kill the task with a SIGSEGV in this situation. 1268 */ 1269 if (do_setcontext(ctx, regs, 1)) { 1270 signal_fault(current, regs, "sys_debug_setcontext", ctx); 1271 1272 force_sig(SIGSEGV); 1273 goto out; 1274 } 1275 1276 /* 1277 * It's not clear whether or why it is desirable to save the 1278 * sigaltstack setting on signal delivery and restore it on 1279 * signal return. But other architectures do this and we have 1280 * always done it up until now so it is probably better not to 1281 * change it. -- paulus 1282 */ 1283 restore_altstack(&ctx->uc_stack); 1284 1285 set_thread_flag(TIF_RESTOREALL); 1286 out: 1287 return 0; 1288} 1289#endif 1290 1291/* 1292 * Do a signal return; undo the signal stack. 1293 */ 1294#ifdef CONFIG_PPC64 1295COMPAT_SYSCALL_DEFINE0(sigreturn) 1296#else 1297SYSCALL_DEFINE0(sigreturn) 1298#endif 1299{ 1300 struct pt_regs *regs = current_pt_regs(); 1301 struct sigframe __user *sf; 1302 struct sigcontext __user *sc; 1303 struct sigcontext sigctx; 1304 struct mcontext __user *sr; 1305 sigset_t set; 1306 struct mcontext __user *mcp; 1307 struct mcontext __user *tm_mcp = NULL; 1308 unsigned long long msr_hi = 0; 1309 1310 /* Always make any pending restarted system calls return -EINTR */ 1311 current->restart_block.fn = do_no_restart_syscall; 1312 1313 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE); 1314 sc = &sf->sctx; 1315 if (copy_from_user(&sigctx, sc, sizeof(sigctx))) 1316 goto badframe; 1317 1318#ifdef CONFIG_PPC64 1319 /* 1320 * Note that PPC32 puts the upper 32 bits of the sigmask in the 1321 * unused part of the signal stackframe 1322 */ 1323 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32); 1324#else 1325 set.sig[0] = sigctx.oldmask; 1326 set.sig[1] = sigctx._unused[3]; 1327#endif 1328 set_current_blocked(&set); 1329 1330 mcp = (struct mcontext __user *)&sf->mctx; 1331#ifdef CONFIG_PPC_TRANSACTIONAL_MEM 1332 tm_mcp = (struct mcontext __user *)&sf->mctx_transact; 1333 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR])) 1334 goto badframe; 1335#endif 1336 if (MSR_TM_ACTIVE(msr_hi<<32)) { 1337 if (!cpu_has_feature(CPU_FTR_TM)) 1338 goto badframe; 1339 if (restore_tm_user_regs(regs, mcp, tm_mcp)) 1340 goto badframe; 1341 } else { 1342 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs); 1343 if (restore_user_regs(regs, sr, 1)) { 1344 signal_fault(current, regs, "sys_sigreturn", sr); 1345 1346 force_sig(SIGSEGV); 1347 return 0; 1348 } 1349 } 1350 1351 set_thread_flag(TIF_RESTOREALL); 1352 return 0; 1353 1354badframe: 1355 signal_fault(current, regs, "sys_sigreturn", sc); 1356 1357 force_sig(SIGSEGV); 1358 return 0; 1359} 1360