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