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