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