3 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
5 * Derived from "arch/i386/kernel/signal.c"
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
15 #include <linux/sched.h>
17 #include <linux/smp.h>
18 #include <linux/kernel.h>
19 #include <linux/signal.h>
20 #include <linux/errno.h>
21 #include <linux/wait.h>
22 #include <linux/unistd.h>
23 #include <linux/stddef.h>
24 #include <linux/elf.h>
25 #include <linux/ptrace.h>
26 #include <linux/ratelimit.h>
28 #include <asm/sigcontext.h>
29 #include <asm/ucontext.h>
30 #include <asm/uaccess.h>
31 #include <asm/pgtable.h>
32 #include <asm/unistd.h>
33 #include <asm/cacheflush.h>
34 #include <asm/syscalls.h>
36 #include <asm/switch_to.h>
43 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
44 #define FP_REGS_SIZE sizeof(elf_fpregset_t)
46 #define TRAMP_TRACEBACK 3
50 * When we have signals to deliver, we set up on the user stack,
51 * going down from the original stack pointer:
52 * 1) a rt_sigframe struct which contains the ucontext
53 * 2) a gap of __SIGNAL_FRAMESIZE bytes which acts as a dummy caller
54 * frame for the signal handler.
58 /* sys_rt_sigreturn requires the ucontext be the first field */
60 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
61 struct ucontext uc_transact;
63 unsigned long _unused[2];
64 unsigned int tramp[TRAMP_SIZE];
65 struct siginfo __user *pinfo;
68 /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
70 } __attribute__ ((aligned (16)));
72 static const char fmt32[] = KERN_INFO \
73 "%s[%d]: bad frame in %s: %08lx nip %08lx lr %08lx\n";
74 static const char fmt64[] = KERN_INFO \
75 "%s[%d]: bad frame in %s: %016lx nip %016lx lr %016lx\n";
78 * Set up the sigcontext for the signal frame.
81 static long setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
82 int signr, sigset_t *set, unsigned long handler,
83 int ctx_has_vsx_region)
85 /* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the
86 * process never used altivec yet (MSR_VEC is zero in pt_regs of
87 * the context). This is very important because we must ensure we
88 * don't lose the VRSAVE content that may have been set prior to
89 * the process doing its first vector operation
90 * Userland shall check AT_HWCAP to know whether it can rely on the
91 * v_regs pointer or not
94 elf_vrreg_t __user *v_regs = (elf_vrreg_t __user *)(((unsigned long)sc->vmx_reserve + 15) & ~0xful);
96 unsigned long msr = regs->msr;
99 flush_fp_to_thread(current);
101 #ifdef CONFIG_ALTIVEC
102 err |= __put_user(v_regs, &sc->v_regs);
104 /* save altivec registers */
105 if (current->thread.used_vr) {
106 flush_altivec_to_thread(current);
107 /* Copy 33 vec registers (vr0..31 and vscr) to the stack */
108 err |= __copy_to_user(v_regs, current->thread.vr, 33 * sizeof(vector128));
109 /* set MSR_VEC in the MSR value in the frame to indicate that sc->v_reg)
110 * contains valid data.
114 /* We always copy to/from vrsave, it's 0 if we don't have or don't
117 err |= __put_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
118 #else /* CONFIG_ALTIVEC */
119 err |= __put_user(0, &sc->v_regs);
120 #endif /* CONFIG_ALTIVEC */
121 flush_fp_to_thread(current);
122 /* copy fpr regs and fpscr */
123 err |= copy_fpr_to_user(&sc->fp_regs, current);
126 * Copy VSX low doubleword to local buffer for formatting,
127 * then out to userspace. Update v_regs to point after the
130 if (current->thread.used_vsr && ctx_has_vsx_region) {
131 __giveup_vsx(current);
132 v_regs += ELF_NVRREG;
133 err |= copy_vsx_to_user(v_regs, current);
134 /* set MSR_VSX in the MSR value in the frame to
135 * indicate that sc->vs_reg) contains valid data.
139 #endif /* CONFIG_VSX */
140 err |= __put_user(&sc->gp_regs, &sc->regs);
141 WARN_ON(!FULL_REGS(regs));
142 err |= __copy_to_user(&sc->gp_regs, regs, GP_REGS_SIZE);
143 err |= __put_user(msr, &sc->gp_regs[PT_MSR]);
144 err |= __put_user(signr, &sc->signal);
145 err |= __put_user(handler, &sc->handler);
147 err |= __put_user(set->sig[0], &sc->oldmask);
152 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
154 * As above, but Transactional Memory is in use, so deliver sigcontexts
155 * containing checkpointed and transactional register states.
157 * To do this, we treclaim (done before entering here) to gather both sets of
158 * registers and set up the 'normal' sigcontext registers with rolled-back
159 * register values such that a simple signal handler sees a correct
160 * checkpointed register state. If interested, a TM-aware sighandler can
161 * examine the transactional registers in the 2nd sigcontext to determine the
162 * real origin of the signal.
164 static long setup_tm_sigcontexts(struct sigcontext __user *sc,
165 struct sigcontext __user *tm_sc,
166 struct pt_regs *regs,
167 int signr, sigset_t *set, unsigned long handler)
169 /* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the
170 * process never used altivec yet (MSR_VEC is zero in pt_regs of
171 * the context). This is very important because we must ensure we
172 * don't lose the VRSAVE content that may have been set prior to
173 * the process doing its first vector operation
174 * Userland shall check AT_HWCAP to know wether it can rely on the
175 * v_regs pointer or not.
177 #ifdef CONFIG_ALTIVEC
178 elf_vrreg_t __user *v_regs = (elf_vrreg_t __user *)
179 (((unsigned long)sc->vmx_reserve + 15) & ~0xful);
180 elf_vrreg_t __user *tm_v_regs = (elf_vrreg_t __user *)
181 (((unsigned long)tm_sc->vmx_reserve + 15) & ~0xful);
183 unsigned long msr = regs->msr;
186 BUG_ON(!MSR_TM_ACTIVE(regs->msr));
188 flush_fp_to_thread(current);
190 #ifdef CONFIG_ALTIVEC
191 err |= __put_user(v_regs, &sc->v_regs);
192 err |= __put_user(tm_v_regs, &tm_sc->v_regs);
194 /* save altivec registers */
195 if (current->thread.used_vr) {
196 flush_altivec_to_thread(current);
197 /* Copy 33 vec registers (vr0..31 and vscr) to the stack */
198 err |= __copy_to_user(v_regs, current->thread.vr,
199 33 * sizeof(vector128));
200 /* If VEC was enabled there are transactional VRs valid too,
201 * else they're a copy of the checkpointed VRs.
204 err |= __copy_to_user(tm_v_regs,
205 current->thread.transact_vr,
206 33 * sizeof(vector128));
208 err |= __copy_to_user(tm_v_regs,
210 33 * sizeof(vector128));
212 /* set MSR_VEC in the MSR value in the frame to indicate
213 * that sc->v_reg contains valid data.
217 /* We always copy to/from vrsave, it's 0 if we don't have or don't
220 err |= __put_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
222 err |= __put_user(current->thread.transact_vrsave,
223 (u32 __user *)&tm_v_regs[33]);
225 err |= __put_user(current->thread.vrsave,
226 (u32 __user *)&tm_v_regs[33]);
228 #else /* CONFIG_ALTIVEC */
229 err |= __put_user(0, &sc->v_regs);
230 err |= __put_user(0, &tm_sc->v_regs);
231 #endif /* CONFIG_ALTIVEC */
233 /* copy fpr regs and fpscr */
234 err |= copy_fpr_to_user(&sc->fp_regs, current);
236 err |= copy_transact_fpr_to_user(&tm_sc->fp_regs, current);
238 err |= copy_fpr_to_user(&tm_sc->fp_regs, current);
242 * Copy VSX low doubleword to local buffer for formatting,
243 * then out to userspace. Update v_regs to point after the
246 if (current->thread.used_vsr) {
247 __giveup_vsx(current);
248 v_regs += ELF_NVRREG;
249 tm_v_regs += ELF_NVRREG;
251 err |= copy_vsx_to_user(v_regs, current);
254 err |= copy_transact_vsx_to_user(tm_v_regs, current);
256 err |= copy_vsx_to_user(tm_v_regs, current);
258 /* set MSR_VSX in the MSR value in the frame to
259 * indicate that sc->vs_reg) contains valid data.
263 #endif /* CONFIG_VSX */
265 err |= __put_user(&sc->gp_regs, &sc->regs);
266 err |= __put_user(&tm_sc->gp_regs, &tm_sc->regs);
267 WARN_ON(!FULL_REGS(regs));
268 err |= __copy_to_user(&tm_sc->gp_regs, regs, GP_REGS_SIZE);
269 err |= __copy_to_user(&sc->gp_regs,
270 ¤t->thread.ckpt_regs, GP_REGS_SIZE);
271 err |= __put_user(msr, &tm_sc->gp_regs[PT_MSR]);
272 err |= __put_user(msr, &sc->gp_regs[PT_MSR]);
273 err |= __put_user(signr, &sc->signal);
274 err |= __put_user(handler, &sc->handler);
276 err |= __put_user(set->sig[0], &sc->oldmask);
283 * Restore the sigcontext from the signal frame.
286 static long restore_sigcontext(struct pt_regs *regs, sigset_t *set, int sig,
287 struct sigcontext __user *sc)
289 #ifdef CONFIG_ALTIVEC
290 elf_vrreg_t __user *v_regs;
292 unsigned long err = 0;
293 unsigned long save_r13 = 0;
299 /* If this is not a signal return, we preserve the TLS in r13 */
301 save_r13 = regs->gpr[13];
304 err |= __copy_from_user(regs->gpr, sc->gp_regs, sizeof(regs->gpr));
305 err |= __get_user(regs->nip, &sc->gp_regs[PT_NIP]);
306 /* get MSR separately, transfer the LE bit if doing signal return */
307 err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
309 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
310 err |= __get_user(regs->orig_gpr3, &sc->gp_regs[PT_ORIG_R3]);
311 err |= __get_user(regs->ctr, &sc->gp_regs[PT_CTR]);
312 err |= __get_user(regs->link, &sc->gp_regs[PT_LNK]);
313 err |= __get_user(regs->xer, &sc->gp_regs[PT_XER]);
314 err |= __get_user(regs->ccr, &sc->gp_regs[PT_CCR]);
317 err |= __get_user(regs->dar, &sc->gp_regs[PT_DAR]);
318 err |= __get_user(regs->dsisr, &sc->gp_regs[PT_DSISR]);
319 err |= __get_user(regs->result, &sc->gp_regs[PT_RESULT]);
322 regs->gpr[13] = save_r13;
324 err |= __get_user(set->sig[0], &sc->oldmask);
327 * Do this before updating the thread state in
328 * current->thread.fpr/vr. That way, if we get preempted
329 * and another task grabs the FPU/Altivec, it won't be
330 * tempted to save the current CPU state into the thread_struct
331 * and corrupt what we are writing there.
333 discard_lazy_cpu_state();
336 * Force reload of FP/VEC.
337 * This has to be done before copying stuff into current->thread.fpr/vr
338 * for the reasons explained in the previous comment.
340 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC | MSR_VSX);
342 #ifdef CONFIG_ALTIVEC
343 err |= __get_user(v_regs, &sc->v_regs);
346 if (v_regs && !access_ok(VERIFY_READ, v_regs, 34 * sizeof(vector128)))
348 /* Copy 33 vec registers (vr0..31 and vscr) from the stack */
349 if (v_regs != 0 && (msr & MSR_VEC) != 0)
350 err |= __copy_from_user(current->thread.vr, v_regs,
351 33 * sizeof(vector128));
352 else if (current->thread.used_vr)
353 memset(current->thread.vr, 0, 33 * sizeof(vector128));
354 /* Always get VRSAVE back */
356 err |= __get_user(current->thread.vrsave, (u32 __user *)&v_regs[33]);
358 current->thread.vrsave = 0;
359 #endif /* CONFIG_ALTIVEC */
360 /* restore floating point */
361 err |= copy_fpr_from_user(current, &sc->fp_regs);
364 * Get additional VSX data. Update v_regs to point after the
365 * VMX data. Copy VSX low doubleword from userspace to local
366 * buffer for formatting, then into the taskstruct.
368 v_regs += ELF_NVRREG;
369 if ((msr & MSR_VSX) != 0)
370 err |= copy_vsx_from_user(current, v_regs);
372 for (i = 0; i < 32 ; i++)
373 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
378 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
380 * Restore the two sigcontexts from the frame of a transactional processes.
383 static long restore_tm_sigcontexts(struct pt_regs *regs,
384 struct sigcontext __user *sc,
385 struct sigcontext __user *tm_sc)
387 #ifdef CONFIG_ALTIVEC
388 elf_vrreg_t __user *v_regs, *tm_v_regs;
390 unsigned long err = 0;
396 err |= __copy_from_user(regs->gpr, tm_sc->gp_regs, sizeof(regs->gpr));
397 err |= __copy_from_user(¤t->thread.ckpt_regs, sc->gp_regs,
401 * TFHAR is restored from the checkpointed 'wound-back' ucontext's NIP.
402 * TEXASR was set by the signal delivery reclaim, as was TFIAR.
403 * Users doing anything abhorrent like thread-switching w/ signals for
404 * TM-Suspended code will have to back TEXASR/TFIAR up themselves.
405 * For the case of getting a signal and simply returning from it,
406 * we don't need to re-copy them here.
408 err |= __get_user(regs->nip, &tm_sc->gp_regs[PT_NIP]);
409 err |= __get_user(current->thread.tm_tfhar, &sc->gp_regs[PT_NIP]);
411 /* get MSR separately, transfer the LE bit if doing signal return */
412 err |= __get_user(msr, &sc->gp_regs[PT_MSR]);
413 /* pull in MSR TM from user context */
414 regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr & MSR_TS_MASK);
416 /* pull in MSR LE from user context */
417 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
419 /* The following non-GPR non-FPR non-VR state is also checkpointed: */
420 err |= __get_user(regs->ctr, &tm_sc->gp_regs[PT_CTR]);
421 err |= __get_user(regs->link, &tm_sc->gp_regs[PT_LNK]);
422 err |= __get_user(regs->xer, &tm_sc->gp_regs[PT_XER]);
423 err |= __get_user(regs->ccr, &tm_sc->gp_regs[PT_CCR]);
424 err |= __get_user(current->thread.ckpt_regs.ctr,
425 &sc->gp_regs[PT_CTR]);
426 err |= __get_user(current->thread.ckpt_regs.link,
427 &sc->gp_regs[PT_LNK]);
428 err |= __get_user(current->thread.ckpt_regs.xer,
429 &sc->gp_regs[PT_XER]);
430 err |= __get_user(current->thread.ckpt_regs.ccr,
431 &sc->gp_regs[PT_CCR]);
433 /* These regs are not checkpointed; they can go in 'regs'. */
434 err |= __get_user(regs->trap, &sc->gp_regs[PT_TRAP]);
435 err |= __get_user(regs->dar, &sc->gp_regs[PT_DAR]);
436 err |= __get_user(regs->dsisr, &sc->gp_regs[PT_DSISR]);
437 err |= __get_user(regs->result, &sc->gp_regs[PT_RESULT]);
440 * Do this before updating the thread state in
441 * current->thread.fpr/vr. That way, if we get preempted
442 * and another task grabs the FPU/Altivec, it won't be
443 * tempted to save the current CPU state into the thread_struct
444 * and corrupt what we are writing there.
446 discard_lazy_cpu_state();
449 * Force reload of FP/VEC.
450 * This has to be done before copying stuff into current->thread.fpr/vr
451 * for the reasons explained in the previous comment.
453 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1 | MSR_VEC | MSR_VSX);
455 #ifdef CONFIG_ALTIVEC
456 err |= __get_user(v_regs, &sc->v_regs);
457 err |= __get_user(tm_v_regs, &tm_sc->v_regs);
460 if (v_regs && !access_ok(VERIFY_READ, v_regs, 34 * sizeof(vector128)))
462 if (tm_v_regs && !access_ok(VERIFY_READ,
463 tm_v_regs, 34 * sizeof(vector128)))
465 /* Copy 33 vec registers (vr0..31 and vscr) from the stack */
466 if (v_regs != 0 && tm_v_regs != 0 && (msr & MSR_VEC) != 0) {
467 err |= __copy_from_user(current->thread.vr, v_regs,
468 33 * sizeof(vector128));
469 err |= __copy_from_user(current->thread.transact_vr, tm_v_regs,
470 33 * sizeof(vector128));
472 else if (current->thread.used_vr) {
473 memset(current->thread.vr, 0, 33 * sizeof(vector128));
474 memset(current->thread.transact_vr, 0, 33 * sizeof(vector128));
476 /* Always get VRSAVE back */
477 if (v_regs != 0 && tm_v_regs != 0) {
478 err |= __get_user(current->thread.vrsave,
479 (u32 __user *)&v_regs[33]);
480 err |= __get_user(current->thread.transact_vrsave,
481 (u32 __user *)&tm_v_regs[33]);
484 current->thread.vrsave = 0;
485 current->thread.transact_vrsave = 0;
487 #endif /* CONFIG_ALTIVEC */
488 /* restore floating point */
489 err |= copy_fpr_from_user(current, &sc->fp_regs);
490 err |= copy_transact_fpr_from_user(current, &tm_sc->fp_regs);
493 * Get additional VSX data. Update v_regs to point after the
494 * VMX data. Copy VSX low doubleword from userspace to local
495 * buffer for formatting, then into the taskstruct.
497 if (v_regs && ((msr & MSR_VSX) != 0)) {
498 v_regs += ELF_NVRREG;
499 tm_v_regs += ELF_NVRREG;
500 err |= copy_vsx_from_user(current, v_regs);
501 err |= copy_transact_vsx_from_user(current, tm_v_regs);
503 for (i = 0; i < 32 ; i++) {
504 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
505 current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
510 /* This loads the checkpointed FP/VEC state, if used */
511 tm_recheckpoint(¤t->thread, msr);
513 /* This loads the speculative FP/VEC state, if used */
515 do_load_up_transact_fpu(¤t->thread);
516 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
518 #ifdef CONFIG_ALTIVEC
520 do_load_up_transact_altivec(¤t->thread);
521 regs->msr |= MSR_VEC;
530 * Setup the trampoline code on the stack
532 static long setup_trampoline(unsigned int syscall, unsigned int __user *tramp)
537 /* addi r1, r1, __SIGNAL_FRAMESIZE # Pop the dummy stackframe */
538 err |= __put_user(0x38210000UL | (__SIGNAL_FRAMESIZE & 0xffff), &tramp[0]);
539 /* li r0, __NR_[rt_]sigreturn| */
540 err |= __put_user(0x38000000UL | (syscall & 0xffff), &tramp[1]);
542 err |= __put_user(0x44000002UL, &tramp[2]);
544 /* Minimal traceback info */
545 for (i=TRAMP_TRACEBACK; i < TRAMP_SIZE ;i++)
546 err |= __put_user(0, &tramp[i]);
549 flush_icache_range((unsigned long) &tramp[0],
550 (unsigned long) &tramp[TRAMP_SIZE]);
556 * Userspace code may pass a ucontext which doesn't include VSX added
557 * at the end. We need to check for this case.
559 #define UCONTEXTSIZEWITHOUTVSX \
560 (sizeof(struct ucontext) - 32*sizeof(long))
563 * Handle {get,set,swap}_context operations
565 int sys_swapcontext(struct ucontext __user *old_ctx,
566 struct ucontext __user *new_ctx,
567 long ctx_size, long r6, long r7, long r8, struct pt_regs *regs)
571 unsigned long new_msr = 0;
572 int ctx_has_vsx_region = 0;
575 get_user(new_msr, &new_ctx->uc_mcontext.gp_regs[PT_MSR]))
578 * Check that the context is not smaller than the original
579 * size (with VMX but without VSX)
581 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
584 * If the new context state sets the MSR VSX bits but
585 * it doesn't provide VSX state.
587 if ((ctx_size < sizeof(struct ucontext)) &&
590 /* Does the context have enough room to store VSX data? */
591 if (ctx_size >= sizeof(struct ucontext))
592 ctx_has_vsx_region = 1;
594 if (old_ctx != NULL) {
595 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
596 || setup_sigcontext(&old_ctx->uc_mcontext, regs, 0, NULL, 0,
598 || __copy_to_user(&old_ctx->uc_sigmask,
599 ¤t->blocked, sizeof(sigset_t)))
604 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
605 || __get_user(tmp, (u8 __user *) new_ctx)
606 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
610 * If we get a fault copying the context into the kernel's
611 * image of the user's registers, we can't just return -EFAULT
612 * because the user's registers will be corrupted. For instance
613 * the NIP value may have been updated but not some of the
614 * other registers. Given that we have done the access_ok
615 * and successfully read the first and last bytes of the region
616 * above, this should only happen in an out-of-memory situation
617 * or if another thread unmaps the region containing the context.
618 * We kill the task with a SIGSEGV in this situation.
621 if (__copy_from_user(&set, &new_ctx->uc_sigmask, sizeof(set)))
623 set_current_blocked(&set);
624 if (restore_sigcontext(regs, NULL, 0, &new_ctx->uc_mcontext))
627 /* This returns like rt_sigreturn */
628 set_thread_flag(TIF_RESTOREALL);
634 * Do a signal return; undo the signal stack.
637 int sys_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
638 unsigned long r6, unsigned long r7, unsigned long r8,
639 struct pt_regs *regs)
641 struct ucontext __user *uc = (struct ucontext __user *)regs->gpr[1];
643 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
647 /* Always make any pending restarted system calls return -EINTR */
648 current_thread_info()->restart_block.fn = do_no_restart_syscall;
650 if (!access_ok(VERIFY_READ, uc, sizeof(*uc)))
653 if (__copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
655 set_current_blocked(&set);
656 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
657 if (__get_user(msr, &uc->uc_mcontext.gp_regs[PT_MSR]))
659 if (MSR_TM_ACTIVE(msr)) {
660 /* We recheckpoint on return. */
661 struct ucontext __user *uc_transact;
662 if (__get_user(uc_transact, &uc->uc_link))
664 if (restore_tm_sigcontexts(regs, &uc->uc_mcontext,
665 &uc_transact->uc_mcontext))
669 /* Fall through, for non-TM restore */
671 if (restore_sigcontext(regs, NULL, 1, &uc->uc_mcontext))
674 if (restore_altstack(&uc->uc_stack))
677 set_thread_flag(TIF_RESTOREALL);
682 printk("badframe in sys_rt_sigreturn, regs=%p uc=%p &uc->uc_mcontext=%p\n",
683 regs, uc, &uc->uc_mcontext);
685 if (show_unhandled_signals)
686 printk_ratelimited(regs->msr & MSR_64BIT ? fmt64 : fmt32,
687 current->comm, current->pid, "rt_sigreturn",
688 (long)uc, regs->nip, regs->link);
690 force_sig(SIGSEGV, current);
694 int handle_rt_signal64(int signr, struct k_sigaction *ka, siginfo_t *info,
695 sigset_t *set, struct pt_regs *regs)
697 /* Handler is *really* a pointer to the function descriptor for
698 * the signal routine. The first entry in the function
699 * descriptor is the entry address of signal and the second
700 * entry is the TOC value we need to use.
702 func_descr_t __user *funct_desc_ptr;
703 struct rt_sigframe __user *frame;
704 unsigned long newsp = 0;
707 frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 0);
708 if (unlikely(frame == NULL))
711 err |= __put_user(&frame->info, &frame->pinfo);
712 err |= __put_user(&frame->uc, &frame->puc);
713 err |= copy_siginfo_to_user(&frame->info, info);
717 /* Create the ucontext. */
718 err |= __put_user(0, &frame->uc.uc_flags);
719 err |= __save_altstack(&frame->uc.uc_stack, regs->gpr[1]);
720 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
721 if (MSR_TM_ACTIVE(regs->msr)) {
722 /* The ucontext_t passed to userland points to the second
723 * ucontext_t (for transactional state) with its uc_link ptr.
725 err |= __put_user(&frame->uc_transact, &frame->uc.uc_link);
726 err |= setup_tm_sigcontexts(&frame->uc.uc_mcontext,
727 &frame->uc_transact.uc_mcontext,
730 (unsigned long)ka->sa.sa_handler);
734 err |= __put_user(0, &frame->uc.uc_link);
735 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, signr,
736 NULL, (unsigned long)ka->sa.sa_handler,
739 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
743 /* Make sure signal handler doesn't get spurious FP exceptions */
744 current->thread.fpscr.val = 0;
745 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
746 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
747 * just indicates to userland that we were doing a transaction, but we
748 * don't want to return in transactional state:
750 regs->msr &= ~MSR_TS_MASK;
753 /* Set up to return from userspace. */
754 if (vdso64_rt_sigtramp && current->mm->context.vdso_base) {
755 regs->link = current->mm->context.vdso_base + vdso64_rt_sigtramp;
757 err |= setup_trampoline(__NR_rt_sigreturn, &frame->tramp[0]);
760 regs->link = (unsigned long) &frame->tramp[0];
762 funct_desc_ptr = (func_descr_t __user *) ka->sa.sa_handler;
764 /* Allocate a dummy caller frame for the signal handler. */
765 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
766 err |= put_user(regs->gpr[1], (unsigned long __user *)newsp);
768 /* Set up "regs" so we "return" to the signal handler. */
769 err |= get_user(regs->nip, &funct_desc_ptr->entry);
770 /* enter the signal handler in big-endian mode */
771 regs->msr &= ~MSR_LE;
772 regs->gpr[1] = newsp;
773 err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
774 regs->gpr[3] = signr;
776 if (ka->sa.sa_flags & SA_SIGINFO) {
777 err |= get_user(regs->gpr[4], (unsigned long __user *)&frame->pinfo);
778 err |= get_user(regs->gpr[5], (unsigned long __user *)&frame->puc);
779 regs->gpr[6] = (unsigned long) frame;
781 regs->gpr[4] = (unsigned long)&frame->uc.uc_mcontext;
790 printk("badframe in setup_rt_frame, regs=%p frame=%p newsp=%lx\n",
793 if (show_unhandled_signals)
794 printk_ratelimited(regs->msr & MSR_64BIT ? fmt64 : fmt32,
795 current->comm, current->pid, "setup_rt_frame",
796 (long)frame, regs->nip, regs->link);
798 force_sigsegv(signr, current);