2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
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)
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
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.
20 #include <linux/sched.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>
30 #include <linux/syscalls.h>
31 #include <linux/compat.h>
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>
40 #include <asm/uaccess.h>
41 #include <asm/cacheflush.h>
42 #include <asm/syscalls.h>
43 #include <asm/sigcontext.h>
45 #include <asm/switch_to.h>
49 #include <asm/unistd.h>
51 #include <asm/ucontext.h>
52 #include <asm/pgtable.h>
60 #define sys_rt_sigreturn compat_sys_rt_sigreturn
61 #define sys_swapcontext compat_sys_swapcontext
62 #define sys_sigreturn compat_sys_sigreturn
64 #define old_sigaction old_sigaction32
65 #define sigcontext sigcontext32
66 #define mcontext mcontext32
67 #define ucontext ucontext32
69 #define __save_altstack __compat_save_altstack
72 * Userspace code may pass a ucontext which doesn't include VSX added
73 * at the end. We need to check for this case.
75 #define UCONTEXTSIZEWITHOUTVSX \
76 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
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.
85 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
86 #undef __SIGNAL_FRAMESIZE
87 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
89 #define ELF_NVRREG ELF_NVRREG32
92 * Functions for flipping sigsets (thanks to brain dead generic
93 * implementation that makes things simple for little endian only)
95 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
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;
109 return copy_to_user(uset, &cset, sizeof(*uset));
112 static inline int get_sigset_t(sigset_t *set,
113 const compat_sigset_t __user *uset)
117 if (copy_from_user(&s32, uset, sizeof(*uset)))
121 * Swap the 2 words of the 64-bit sigset_t (they are stored
122 * in the "wrong" endian in 32-bit user storage).
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);
133 #define to_user_ptr(p) ptr_to_compat(p)
134 #define from_user_ptr(p) compat_ptr(p)
136 static inline int save_general_regs(struct pt_regs *regs,
137 struct mcontext __user *frame)
139 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
142 WARN_ON(!FULL_REGS(regs));
144 for (i = 0; i <= PT_RESULT; i ++) {
145 if (i == 14 && !FULL_REGS(regs))
147 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
153 static inline int restore_general_regs(struct pt_regs *regs,
154 struct mcontext __user *sr)
156 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
159 for (i = 0; i <= PT_RESULT; i++) {
160 if ((i == PT_MSR) || (i == PT_SOFTE))
162 if (__get_user(gregs[i], &sr->mc_gregs[i]))
168 #else /* CONFIG_PPC64 */
170 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
172 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
174 return copy_to_user(uset, set, sizeof(*uset));
177 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
179 return copy_from_user(set, uset, sizeof(*uset));
182 #define to_user_ptr(p) ((unsigned long)(p))
183 #define from_user_ptr(p) ((void __user *)(p))
185 static inline int save_general_regs(struct pt_regs *regs,
186 struct mcontext __user *frame)
188 WARN_ON(!FULL_REGS(regs));
189 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
192 static inline int restore_general_regs(struct pt_regs *regs,
193 struct mcontext __user *sr)
195 /* copy up to but not including MSR */
196 if (__copy_from_user(regs, &sr->mc_gregs,
197 PT_MSR * sizeof(elf_greg_t)))
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)))
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
212 * a sigcontext struct
213 * a gap of __SIGNAL_FRAMESIZE bytes
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
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;
227 * Programs using the rs6000/xcoff abi can save up to 19 gp
228 * regs and 18 fp regs below sp before decrementing it.
233 /* We use the mc_pad field for the signal return trampoline. */
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).
244 * Each of these things must be a multiple of 16 bytes in size.
249 compat_siginfo_t info;
254 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
255 struct ucontext uc_transact;
258 * Programs using the rs6000/xcoff abi can save up to 19 gp
259 * regs and 18 fp regs below sp before decrementing it.
265 unsigned long copy_fpr_to_user(void __user *to,
266 struct task_struct *task)
268 double buf[ELF_NFPREG];
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));
278 unsigned long copy_fpr_from_user(struct task_struct *task,
281 double buf[ELF_NFPREG];
284 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
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));
293 unsigned long copy_vsx_to_user(void __user *to,
294 struct task_struct *task)
296 double buf[ELF_NVSRHALFREG];
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));
305 unsigned long copy_vsx_from_user(struct task_struct *task,
308 double buf[ELF_NVSRHALFREG];
311 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
313 for (i = 0; i < ELF_NVSRHALFREG ; i++)
314 task->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
318 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
319 unsigned long copy_transact_fpr_to_user(void __user *to,
320 struct task_struct *task)
322 double buf[ELF_NFPREG];
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));
332 unsigned long copy_transact_fpr_from_user(struct task_struct *task,
335 double buf[ELF_NFPREG];
338 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
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));
347 unsigned long copy_transact_vsx_to_user(void __user *to,
348 struct task_struct *task)
350 double buf[ELF_NVSRHALFREG];
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));
359 unsigned long copy_transact_vsx_from_user(struct task_struct *task,
362 double buf[ELF_NVSRHALFREG];
365 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
367 for (i = 0; i < ELF_NVSRHALFREG ; i++)
368 task->thread.transact_fpr[i][TS_VSRLOWOFFSET] = buf[i];
371 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
373 inline unsigned long copy_fpr_to_user(void __user *to,
374 struct task_struct *task)
376 return __copy_to_user(to, task->thread.fpr,
377 ELF_NFPREG * sizeof(double));
380 inline unsigned long copy_fpr_from_user(struct task_struct *task,
383 return __copy_from_user(task->thread.fpr, from,
384 ELF_NFPREG * sizeof(double));
387 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
388 inline unsigned long copy_transact_fpr_to_user(void __user *to,
389 struct task_struct *task)
391 return __copy_to_user(to, task->thread.transact_fpr,
392 ELF_NFPREG * sizeof(double));
395 inline unsigned long copy_transact_fpr_from_user(struct task_struct *task,
398 return __copy_from_user(task->thread.transact_fpr, from,
399 ELF_NFPREG * sizeof(double));
401 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
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.
409 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
410 int sigret, int ctx_has_vsx_region)
412 unsigned long msr = regs->msr;
414 /* Make sure floating point registers are stored in regs */
415 flush_fp_to_thread(current);
417 /* save general registers */
418 if (save_general_regs(regs, frame))
421 #ifdef CONFIG_ALTIVEC
422 /* save altivec registers */
423 if (current->thread.used_vr) {
424 flush_altivec_to_thread(current);
425 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
426 ELF_NVRREG * sizeof(vector128)))
428 /* set MSR_VEC in the saved MSR value to indicate that
429 frame->mc_vregs contains valid data */
432 /* else assert((regs->msr & MSR_VEC) == 0) */
434 /* We always copy to/from vrsave, it's 0 if we don't have or don't
435 * use altivec. Since VSCR only contains 32 bits saved in the least
436 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
437 * most significant bits of that same vector. --BenH
439 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
441 #endif /* CONFIG_ALTIVEC */
442 if (copy_fpr_to_user(&frame->mc_fregs, current))
446 * Copy VSR 0-31 upper half from thread_struct to local
447 * buffer, then write that to userspace. Also set MSR_VSX in
448 * the saved MSR value to indicate that frame->mc_vregs
449 * contains valid data
451 if (current->thread.used_vsr && ctx_has_vsx_region) {
452 __giveup_vsx(current);
453 if (copy_vsx_to_user(&frame->mc_vsregs, current))
457 #endif /* CONFIG_VSX */
459 /* save spe registers */
460 if (current->thread.used_spe) {
461 flush_spe_to_thread(current);
462 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
463 ELF_NEVRREG * sizeof(u32)))
465 /* set MSR_SPE in the saved MSR value to indicate that
466 frame->mc_vregs contains valid data */
469 /* else assert((regs->msr & MSR_SPE) == 0) */
471 /* We always copy to/from spefscr */
472 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
474 #endif /* CONFIG_SPE */
476 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
479 /* Set up the sigreturn trampoline: li r0,sigret; sc */
480 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
481 || __put_user(0x44000002UL, &frame->tramp[1]))
483 flush_icache_range((unsigned long) &frame->tramp[0],
484 (unsigned long) &frame->tramp[2]);
490 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
492 * Save the current user registers on the user stack.
493 * We only save the altivec/spe registers if the process has used
494 * altivec/spe instructions at some point.
495 * We also save the transactional registers to a second ucontext in the
498 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
500 static int save_tm_user_regs(struct pt_regs *regs,
501 struct mcontext __user *frame,
502 struct mcontext __user *tm_frame, int sigret)
504 unsigned long msr = regs->msr;
506 /* tm_reclaim rolls back all reg states, updating thread.ckpt_regs,
507 * thread.transact_fpr[], thread.transact_vr[], etc.
510 tm_reclaim(¤t->thread, msr, TM_CAUSE_SIGNAL);
512 /* Make sure floating point registers are stored in regs */
513 flush_fp_to_thread(current);
515 /* Save both sets of general registers */
516 if (save_general_regs(¤t->thread.ckpt_regs, frame)
517 || save_general_regs(regs, tm_frame))
520 /* Stash the top half of the 64bit MSR into the 32bit MSR word
521 * of the transactional mcontext. This way we have a backward-compatible
522 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
523 * also look at what type of transaction (T or S) was active at the
524 * time of the signal.
526 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
529 #ifdef CONFIG_ALTIVEC
530 /* save altivec registers */
531 if (current->thread.used_vr) {
532 flush_altivec_to_thread(current);
533 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
534 ELF_NVRREG * sizeof(vector128)))
537 if (__copy_to_user(&tm_frame->mc_vregs,
538 current->thread.transact_vr,
539 ELF_NVRREG * sizeof(vector128)))
542 if (__copy_to_user(&tm_frame->mc_vregs,
544 ELF_NVRREG * sizeof(vector128)))
548 /* set MSR_VEC in the saved MSR value to indicate that
549 * frame->mc_vregs contains valid data
554 /* We always copy to/from vrsave, it's 0 if we don't have or don't
555 * use altivec. Since VSCR only contains 32 bits saved in the least
556 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
557 * most significant bits of that same vector. --BenH
559 if (__put_user(current->thread.vrsave,
560 (u32 __user *)&frame->mc_vregs[32]))
563 if (__put_user(current->thread.transact_vrsave,
564 (u32 __user *)&tm_frame->mc_vregs[32]))
567 if (__put_user(current->thread.vrsave,
568 (u32 __user *)&tm_frame->mc_vregs[32]))
571 #endif /* CONFIG_ALTIVEC */
573 if (copy_fpr_to_user(&frame->mc_fregs, current))
576 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
579 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
585 * Copy VSR 0-31 upper half from thread_struct to local
586 * buffer, then write that to userspace. Also set MSR_VSX in
587 * the saved MSR value to indicate that frame->mc_vregs
588 * contains valid data
590 if (current->thread.used_vsr) {
591 __giveup_vsx(current);
592 if (copy_vsx_to_user(&frame->mc_vsregs, current))
595 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
599 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
605 #endif /* CONFIG_VSX */
607 /* SPE regs are not checkpointed with TM, so this section is
608 * simply the same as in save_user_regs().
610 if (current->thread.used_spe) {
611 flush_spe_to_thread(current);
612 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
613 ELF_NEVRREG * sizeof(u32)))
615 /* set MSR_SPE in the saved MSR value to indicate that
616 * frame->mc_vregs contains valid data */
620 /* We always copy to/from spefscr */
621 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
623 #endif /* CONFIG_SPE */
625 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
628 /* Set up the sigreturn trampoline: li r0,sigret; sc */
629 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
630 || __put_user(0x44000002UL, &frame->tramp[1]))
632 flush_icache_range((unsigned long) &frame->tramp[0],
633 (unsigned long) &frame->tramp[2]);
641 * Restore the current user register values from the user stack,
644 static long restore_user_regs(struct pt_regs *regs,
645 struct mcontext __user *sr, int sig)
648 unsigned int save_r2 = 0;
655 * restore general registers but not including MSR or SOFTE. Also
656 * take care of keeping r2 (TLS) intact if not a signal
659 save_r2 = (unsigned int)regs->gpr[2];
660 err = restore_general_regs(regs, sr);
662 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
664 regs->gpr[2] = (unsigned long) save_r2;
668 /* if doing signal return, restore the previous little-endian mode */
670 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
673 * Do this before updating the thread state in
674 * current->thread.fpr/vr/evr. That way, if we get preempted
675 * and another task grabs the FPU/Altivec/SPE, it won't be
676 * tempted to save the current CPU state into the thread_struct
677 * and corrupt what we are writing there.
679 discard_lazy_cpu_state();
681 #ifdef CONFIG_ALTIVEC
683 * Force the process to reload the altivec registers from
684 * current->thread when it next does altivec instructions
686 regs->msr &= ~MSR_VEC;
688 /* restore altivec registers from the stack */
689 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
690 sizeof(sr->mc_vregs)))
692 } else if (current->thread.used_vr)
693 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
695 /* Always get VRSAVE back */
696 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
698 #endif /* CONFIG_ALTIVEC */
699 if (copy_fpr_from_user(current, &sr->mc_fregs))
704 * Force the process to reload the VSX registers from
705 * current->thread when it next does VSX instruction.
707 regs->msr &= ~MSR_VSX;
710 * Restore altivec registers from the stack to a local
711 * buffer, then write this out to the thread_struct
713 if (copy_vsx_from_user(current, &sr->mc_vsregs))
715 } else if (current->thread.used_vsr)
716 for (i = 0; i < 32 ; i++)
717 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
718 #endif /* CONFIG_VSX */
720 * force the process to reload the FP registers from
721 * current->thread when it next does FP instructions
723 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
726 /* force the process to reload the spe registers from
727 current->thread when it next does spe instructions */
728 regs->msr &= ~MSR_SPE;
730 /* restore spe registers from the stack */
731 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
732 ELF_NEVRREG * sizeof(u32)))
734 } else if (current->thread.used_spe)
735 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
737 /* Always get SPEFSCR back */
738 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
740 #endif /* CONFIG_SPE */
745 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
747 * Restore the current user register values from the user stack, except for
748 * MSR, and recheckpoint the original checkpointed register state for processes
751 static long restore_tm_user_regs(struct pt_regs *regs,
752 struct mcontext __user *sr,
753 struct mcontext __user *tm_sr)
762 * restore general registers but not including MSR or SOFTE. Also
763 * take care of keeping r2 (TLS) intact if not a signal.
764 * See comment in signal_64.c:restore_tm_sigcontexts();
765 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
766 * were set by the signal delivery.
768 err = restore_general_regs(regs, tm_sr);
769 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
771 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
773 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
777 /* Restore the previous little-endian mode */
778 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
781 * Do this before updating the thread state in
782 * current->thread.fpr/vr/evr. That way, if we get preempted
783 * and another task grabs the FPU/Altivec/SPE, it won't be
784 * tempted to save the current CPU state into the thread_struct
785 * and corrupt what we are writing there.
787 discard_lazy_cpu_state();
789 #ifdef CONFIG_ALTIVEC
790 regs->msr &= ~MSR_VEC;
792 /* restore altivec registers from the stack */
793 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
794 sizeof(sr->mc_vregs)) ||
795 __copy_from_user(current->thread.transact_vr,
797 sizeof(sr->mc_vregs)))
799 } else if (current->thread.used_vr) {
800 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
801 memset(current->thread.transact_vr, 0,
802 ELF_NVRREG * sizeof(vector128));
805 /* Always get VRSAVE back */
806 if (__get_user(current->thread.vrsave,
807 (u32 __user *)&sr->mc_vregs[32]) ||
808 __get_user(current->thread.transact_vrsave,
809 (u32 __user *)&tm_sr->mc_vregs[32]))
811 #endif /* CONFIG_ALTIVEC */
813 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
815 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
816 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
820 regs->msr &= ~MSR_VSX;
823 * Restore altivec registers from the stack to a local
824 * buffer, then write this out to the thread_struct
826 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
827 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
829 } else if (current->thread.used_vsr)
830 for (i = 0; i < 32 ; i++) {
831 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
832 current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
834 #endif /* CONFIG_VSX */
837 /* SPE regs are not checkpointed with TM, so this section is
838 * simply the same as in restore_user_regs().
840 regs->msr &= ~MSR_SPE;
842 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
843 ELF_NEVRREG * sizeof(u32)))
845 } else if (current->thread.used_spe)
846 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
848 /* Always get SPEFSCR back */
849 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
852 #endif /* CONFIG_SPE */
854 /* Now, recheckpoint. This loads up all of the checkpointed (older)
855 * registers, including FP and V[S]Rs. After recheckpointing, the
856 * transactional versions should be loaded.
859 /* This loads the checkpointed FP/VEC state, if used */
860 tm_recheckpoint(¤t->thread, msr);
861 /* The task has moved into TM state S, so ensure MSR reflects this */
862 regs->msr = (regs->msr & ~MSR_TS_MASK) | MSR_TS_S;
864 /* This loads the speculative FP/VEC state, if used */
866 do_load_up_transact_fpu(¤t->thread);
867 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
869 #ifdef CONFIG_ALTIVEC
871 do_load_up_transact_altivec(¤t->thread);
872 regs->msr |= MSR_VEC;
881 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
885 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
888 /* If you change siginfo_t structure, please be sure
889 * this code is fixed accordingly.
890 * It should never copy any pad contained in the structure
891 * to avoid security leaks, but must copy the generic
892 * 3 ints plus the relevant union member.
893 * This routine must convert siginfo from 64bit to 32bit as well
896 err = __put_user(s->si_signo, &d->si_signo);
897 err |= __put_user(s->si_errno, &d->si_errno);
898 err |= __put_user((short)s->si_code, &d->si_code);
900 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
902 else switch(s->si_code >> 16) {
903 case __SI_CHLD >> 16:
904 err |= __put_user(s->si_pid, &d->si_pid);
905 err |= __put_user(s->si_uid, &d->si_uid);
906 err |= __put_user(s->si_utime, &d->si_utime);
907 err |= __put_user(s->si_stime, &d->si_stime);
908 err |= __put_user(s->si_status, &d->si_status);
910 case __SI_FAULT >> 16:
911 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
914 case __SI_POLL >> 16:
915 err |= __put_user(s->si_band, &d->si_band);
916 err |= __put_user(s->si_fd, &d->si_fd);
918 case __SI_TIMER >> 16:
919 err |= __put_user(s->si_tid, &d->si_tid);
920 err |= __put_user(s->si_overrun, &d->si_overrun);
921 err |= __put_user(s->si_int, &d->si_int);
923 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
924 case __SI_MESGQ >> 16:
925 err |= __put_user(s->si_int, &d->si_int);
927 case __SI_KILL >> 16:
929 err |= __put_user(s->si_pid, &d->si_pid);
930 err |= __put_user(s->si_uid, &d->si_uid);
936 #define copy_siginfo_to_user copy_siginfo_to_user32
938 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
940 memset(to, 0, sizeof *to);
942 if (copy_from_user(to, from, 3*sizeof(int)) ||
943 copy_from_user(to->_sifields._pad,
944 from->_sifields._pad, SI_PAD_SIZE32))
949 #endif /* CONFIG_PPC64 */
952 * Set up a signal frame for a "real-time" signal handler
953 * (one which gets siginfo).
955 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
956 siginfo_t *info, sigset_t *oldset,
957 struct pt_regs *regs)
959 struct rt_sigframe __user *rt_sf;
960 struct mcontext __user *frame;
962 unsigned long newsp = 0;
966 /* Set up Signal Frame */
967 /* Put a Real Time Context onto stack */
968 rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf), 1);
970 if (unlikely(rt_sf == NULL))
973 /* Put the siginfo & fill in most of the ucontext */
974 if (copy_siginfo_to_user(&rt_sf->info, info)
975 || __put_user(0, &rt_sf->uc.uc_flags)
976 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
977 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
979 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
982 /* Save user registers on the stack */
983 frame = &rt_sf->uc.uc_mcontext;
985 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
987 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
989 sigret = __NR_rt_sigreturn;
990 tramp = (unsigned long) frame->tramp;
993 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
994 if (MSR_TM_ACTIVE(regs->msr)) {
995 if (save_tm_user_regs(regs, &rt_sf->uc.uc_mcontext,
996 &rt_sf->uc_transact.uc_mcontext, sigret))
1001 if (save_user_regs(regs, frame, sigret, 1))
1005 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1006 if (MSR_TM_ACTIVE(regs->msr)) {
1007 if (__put_user((unsigned long)&rt_sf->uc_transact,
1009 || __put_user(to_user_ptr(&rt_sf->uc_transact.uc_mcontext),
1010 &rt_sf->uc_transact.uc_regs))
1015 if (__put_user(0, &rt_sf->uc.uc_link))
1018 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1020 /* create a stack frame for the caller of the handler */
1021 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1022 addr = (void __user *)regs->gpr[1];
1023 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1026 /* Fill registers for signal handler */
1027 regs->gpr[1] = newsp;
1029 regs->gpr[4] = (unsigned long) &rt_sf->info;
1030 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1031 regs->gpr[6] = (unsigned long) rt_sf;
1032 regs->nip = (unsigned long) ka->sa.sa_handler;
1033 /* enter the signal handler in big-endian mode */
1034 regs->msr &= ~MSR_LE;
1035 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1036 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1037 * just indicates to userland that we were doing a transaction, but we
1038 * don't want to return in transactional state:
1040 regs->msr &= ~MSR_TS_MASK;
1046 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
1047 regs, frame, newsp);
1049 if (show_unhandled_signals)
1050 printk_ratelimited(KERN_INFO
1051 "%s[%d]: bad frame in handle_rt_signal32: "
1052 "%p nip %08lx lr %08lx\n",
1053 current->comm, current->pid,
1054 addr, regs->nip, regs->link);
1056 force_sigsegv(sig, current);
1060 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1063 struct mcontext __user *mcp;
1065 if (get_sigset_t(&set, &ucp->uc_sigmask))
1071 if (__get_user(cmcp, &ucp->uc_regs))
1073 mcp = (struct mcontext __user *)(u64)cmcp;
1074 /* no need to check access_ok(mcp), since mcp < 4GB */
1077 if (__get_user(mcp, &ucp->uc_regs))
1079 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1082 set_current_blocked(&set);
1083 if (restore_user_regs(regs, mcp, sig))
1089 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1090 static int do_setcontext_tm(struct ucontext __user *ucp,
1091 struct ucontext __user *tm_ucp,
1092 struct pt_regs *regs)
1095 struct mcontext __user *mcp;
1096 struct mcontext __user *tm_mcp;
1100 if (get_sigset_t(&set, &ucp->uc_sigmask))
1103 if (__get_user(cmcp, &ucp->uc_regs) ||
1104 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1106 mcp = (struct mcontext __user *)(u64)cmcp;
1107 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1108 /* no need to check access_ok(mcp), since mcp < 4GB */
1110 set_current_blocked(&set);
1111 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1118 long sys_swapcontext(struct ucontext __user *old_ctx,
1119 struct ucontext __user *new_ctx,
1120 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1123 int ctx_has_vsx_region = 0;
1126 unsigned long new_msr = 0;
1129 struct mcontext __user *mcp;
1133 * Get pointer to the real mcontext. No need for
1134 * access_ok since we are dealing with compat
1137 if (__get_user(cmcp, &new_ctx->uc_regs))
1139 mcp = (struct mcontext __user *)(u64)cmcp;
1140 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1144 * Check that the context is not smaller than the original
1145 * size (with VMX but without VSX)
1147 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1150 * If the new context state sets the MSR VSX bits but
1151 * it doesn't provide VSX state.
1153 if ((ctx_size < sizeof(struct ucontext)) &&
1154 (new_msr & MSR_VSX))
1156 /* Does the context have enough room to store VSX data? */
1157 if (ctx_size >= sizeof(struct ucontext))
1158 ctx_has_vsx_region = 1;
1160 /* Context size is for future use. Right now, we only make sure
1161 * we are passed something we understand
1163 if (ctx_size < sizeof(struct ucontext))
1166 if (old_ctx != NULL) {
1167 struct mcontext __user *mctx;
1170 * old_ctx might not be 16-byte aligned, in which
1171 * case old_ctx->uc_mcontext won't be either.
1172 * Because we have the old_ctx->uc_pad2 field
1173 * before old_ctx->uc_mcontext, we need to round down
1174 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1176 mctx = (struct mcontext __user *)
1177 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1178 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1179 || save_user_regs(regs, mctx, 0, ctx_has_vsx_region)
1180 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1181 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1184 if (new_ctx == NULL)
1186 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1187 || __get_user(tmp, (u8 __user *) new_ctx)
1188 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1192 * If we get a fault copying the context into the kernel's
1193 * image of the user's registers, we can't just return -EFAULT
1194 * because the user's registers will be corrupted. For instance
1195 * the NIP value may have been updated but not some of the
1196 * other registers. Given that we have done the access_ok
1197 * and successfully read the first and last bytes of the region
1198 * above, this should only happen in an out-of-memory situation
1199 * or if another thread unmaps the region containing the context.
1200 * We kill the task with a SIGSEGV in this situation.
1202 if (do_setcontext(new_ctx, regs, 0))
1205 set_thread_flag(TIF_RESTOREALL);
1209 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1210 struct pt_regs *regs)
1212 struct rt_sigframe __user *rt_sf;
1213 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1214 struct ucontext __user *uc_transact;
1215 unsigned long msr_hi;
1219 /* Always make any pending restarted system calls return -EINTR */
1220 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1222 rt_sf = (struct rt_sigframe __user *)
1223 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1224 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1226 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1227 if (__get_user(tmp, &rt_sf->uc.uc_link))
1229 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1232 struct mcontext __user *mcp;
1234 if (__get_user(cmcp, &uc_transact->uc_regs))
1236 mcp = (struct mcontext __user *)(u64)cmcp;
1237 /* The top 32 bits of the MSR are stashed in the transactional
1239 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1242 if (MSR_TM_SUSPENDED(msr_hi<<32)) {
1243 /* We only recheckpoint on return if we're
1247 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1252 /* Fall through, for non-TM restore */
1254 if (do_setcontext(&rt_sf->uc, regs, 1))
1258 * It's not clear whether or why it is desirable to save the
1259 * sigaltstack setting on signal delivery and restore it on
1260 * signal return. But other architectures do this and we have
1261 * always done it up until now so it is probably better not to
1262 * change it. -- paulus
1265 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1268 if (restore_altstack(&rt_sf->uc.uc_stack))
1271 set_thread_flag(TIF_RESTOREALL);
1275 if (show_unhandled_signals)
1276 printk_ratelimited(KERN_INFO
1277 "%s[%d]: bad frame in sys_rt_sigreturn: "
1278 "%p nip %08lx lr %08lx\n",
1279 current->comm, current->pid,
1280 rt_sf, regs->nip, regs->link);
1282 force_sig(SIGSEGV, current);
1287 int sys_debug_setcontext(struct ucontext __user *ctx,
1288 int ndbg, struct sig_dbg_op __user *dbg,
1289 int r6, int r7, int r8,
1290 struct pt_regs *regs)
1292 struct sig_dbg_op op;
1295 unsigned long new_msr = regs->msr;
1296 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1297 unsigned long new_dbcr0 = current->thread.dbcr0;
1300 for (i=0; i<ndbg; i++) {
1301 if (copy_from_user(&op, dbg + i, sizeof(op)))
1303 switch (op.dbg_type) {
1304 case SIG_DBG_SINGLE_STEPPING:
1305 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1308 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1310 new_dbcr0 &= ~DBCR0_IC;
1311 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1312 current->thread.dbcr1)) {
1314 new_dbcr0 &= ~DBCR0_IDM;
1324 case SIG_DBG_BRANCH_TRACING:
1325 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1340 /* We wait until here to actually install the values in the
1341 registers so if we fail in the above loop, it will not
1342 affect the contents of these registers. After this point,
1343 failure is a problem, anyway, and it's very unlikely unless
1344 the user is really doing something wrong. */
1345 regs->msr = new_msr;
1346 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1347 current->thread.dbcr0 = new_dbcr0;
1350 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1351 || __get_user(tmp, (u8 __user *) ctx)
1352 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1356 * If we get a fault copying the context into the kernel's
1357 * image of the user's registers, we can't just return -EFAULT
1358 * because the user's registers will be corrupted. For instance
1359 * the NIP value may have been updated but not some of the
1360 * other registers. Given that we have done the access_ok
1361 * and successfully read the first and last bytes of the region
1362 * above, this should only happen in an out-of-memory situation
1363 * or if another thread unmaps the region containing the context.
1364 * We kill the task with a SIGSEGV in this situation.
1366 if (do_setcontext(ctx, regs, 1)) {
1367 if (show_unhandled_signals)
1368 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1369 "sys_debug_setcontext: %p nip %08lx "
1371 current->comm, current->pid,
1372 ctx, regs->nip, regs->link);
1374 force_sig(SIGSEGV, current);
1379 * It's not clear whether or why it is desirable to save the
1380 * sigaltstack setting on signal delivery and restore it on
1381 * signal return. But other architectures do this and we have
1382 * always done it up until now so it is probably better not to
1383 * change it. -- paulus
1385 restore_altstack(&ctx->uc_stack);
1387 set_thread_flag(TIF_RESTOREALL);
1394 * OK, we're invoking a handler
1396 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1397 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1399 struct sigcontext __user *sc;
1400 struct sigframe __user *frame;
1401 unsigned long newsp = 0;
1403 unsigned long tramp;
1405 /* Set up Signal Frame */
1406 frame = get_sigframe(ka, regs, sizeof(*frame), 1);
1407 if (unlikely(frame == NULL))
1409 sc = (struct sigcontext __user *) &frame->sctx;
1412 #error "Please adjust handle_signal()"
1414 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1415 || __put_user(oldset->sig[0], &sc->oldmask)
1417 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1419 || __put_user(oldset->sig[1], &sc->_unused[3])
1421 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1422 || __put_user(sig, &sc->signal))
1425 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1427 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1429 sigret = __NR_sigreturn;
1430 tramp = (unsigned long) frame->mctx.tramp;
1433 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1434 if (MSR_TM_ACTIVE(regs->msr)) {
1435 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1441 if (save_user_regs(regs, &frame->mctx, sigret, 1))
1446 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1448 /* create a stack frame for the caller of the handler */
1449 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1450 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1453 regs->gpr[1] = newsp;
1455 regs->gpr[4] = (unsigned long) sc;
1456 regs->nip = (unsigned long) ka->sa.sa_handler;
1457 /* enter the signal handler in big-endian mode */
1458 regs->msr &= ~MSR_LE;
1459 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1460 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1461 * just indicates to userland that we were doing a transaction, but we
1462 * don't want to return in transactional state:
1464 regs->msr &= ~MSR_TS_MASK;
1470 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1471 regs, frame, newsp);
1473 if (show_unhandled_signals)
1474 printk_ratelimited(KERN_INFO
1475 "%s[%d]: bad frame in handle_signal32: "
1476 "%p nip %08lx lr %08lx\n",
1477 current->comm, current->pid,
1478 frame, regs->nip, regs->link);
1480 force_sigsegv(sig, current);
1485 * Do a signal return; undo the signal stack.
1487 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1488 struct pt_regs *regs)
1490 struct sigcontext __user *sc;
1491 struct sigcontext sigctx;
1492 struct mcontext __user *sr;
1496 /* Always make any pending restarted system calls return -EINTR */
1497 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1499 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1501 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1506 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1507 * unused part of the signal stackframe
1509 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1511 set.sig[0] = sigctx.oldmask;
1512 set.sig[1] = sigctx._unused[3];
1514 set_current_blocked(&set);
1516 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1518 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1519 || restore_user_regs(regs, sr, 1))
1522 set_thread_flag(TIF_RESTOREALL);
1526 if (show_unhandled_signals)
1527 printk_ratelimited(KERN_INFO
1528 "%s[%d]: bad frame in sys_sigreturn: "
1529 "%p nip %08lx lr %08lx\n",
1530 current->comm, current->pid,
1531 addr, regs->nip, regs->link);
1533 force_sig(SIGSEGV, current);