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>
59 #define sys_rt_sigreturn compat_sys_rt_sigreturn
60 #define sys_swapcontext compat_sys_swapcontext
61 #define sys_sigreturn compat_sys_sigreturn
63 #define old_sigaction old_sigaction32
64 #define sigcontext sigcontext32
65 #define mcontext mcontext32
66 #define ucontext ucontext32
68 #define __save_altstack __compat_save_altstack
71 * Userspace code may pass a ucontext which doesn't include VSX added
72 * at the end. We need to check for this case.
74 #define UCONTEXTSIZEWITHOUTVSX \
75 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
78 * Returning 0 means we return to userspace via
79 * ret_from_except and thus restore all user
80 * registers from *regs. This is what we need
81 * to do when a signal has been delivered.
84 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
85 #undef __SIGNAL_FRAMESIZE
86 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
88 #define ELF_NVRREG ELF_NVRREG32
91 * Functions for flipping sigsets (thanks to brain dead generic
92 * implementation that makes things simple for little endian only)
94 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
98 switch (_NSIG_WORDS) {
99 case 4: cset.sig[6] = set->sig[3] & 0xffffffffull;
100 cset.sig[7] = set->sig[3] >> 32;
101 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
102 cset.sig[5] = set->sig[2] >> 32;
103 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
104 cset.sig[3] = set->sig[1] >> 32;
105 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
106 cset.sig[1] = set->sig[0] >> 32;
108 return copy_to_user(uset, &cset, sizeof(*uset));
111 static inline int get_sigset_t(sigset_t *set,
112 const compat_sigset_t __user *uset)
116 if (copy_from_user(&s32, uset, sizeof(*uset)))
120 * Swap the 2 words of the 64-bit sigset_t (they are stored
121 * in the "wrong" endian in 32-bit user storage).
123 switch (_NSIG_WORDS) {
124 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
125 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
126 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
127 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
132 #define to_user_ptr(p) ptr_to_compat(p)
133 #define from_user_ptr(p) compat_ptr(p)
135 static inline int save_general_regs(struct pt_regs *regs,
136 struct mcontext __user *frame)
138 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
141 WARN_ON(!FULL_REGS(regs));
143 for (i = 0; i <= PT_RESULT; i ++) {
144 if (i == 14 && !FULL_REGS(regs))
146 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
152 static inline int restore_general_regs(struct pt_regs *regs,
153 struct mcontext __user *sr)
155 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
158 for (i = 0; i <= PT_RESULT; i++) {
159 if ((i == PT_MSR) || (i == PT_SOFTE))
161 if (__get_user(gregs[i], &sr->mc_gregs[i]))
167 #else /* CONFIG_PPC64 */
169 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
171 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
173 return copy_to_user(uset, set, sizeof(*uset));
176 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
178 return copy_from_user(set, uset, sizeof(*uset));
181 #define to_user_ptr(p) ((unsigned long)(p))
182 #define from_user_ptr(p) ((void __user *)(p))
184 static inline int save_general_regs(struct pt_regs *regs,
185 struct mcontext __user *frame)
187 WARN_ON(!FULL_REGS(regs));
188 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
191 static inline int restore_general_regs(struct pt_regs *regs,
192 struct mcontext __user *sr)
194 /* copy up to but not including MSR */
195 if (__copy_from_user(regs, &sr->mc_gregs,
196 PT_MSR * sizeof(elf_greg_t)))
198 /* copy from orig_r3 (the word after the MSR) up to the end */
199 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
200 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
207 * When we have signals to deliver, we set up on the
208 * user stack, going down from the original stack pointer:
209 * an ABI gap of 56 words
211 * a sigcontext struct
212 * a gap of __SIGNAL_FRAMESIZE bytes
214 * Each of these things must be a multiple of 16 bytes in size. The following
215 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
219 struct sigcontext sctx; /* the sigcontext */
220 struct mcontext mctx; /* all the register values */
221 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
222 struct sigcontext sctx_transact;
223 struct mcontext mctx_transact;
226 * Programs using the rs6000/xcoff abi can save up to 19 gp
227 * regs and 18 fp regs below sp before decrementing it.
232 /* We use the mc_pad field for the signal return trampoline. */
236 * When we have rt signals to deliver, we set up on the
237 * user stack, going down from the original stack pointer:
238 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
239 * a gap of __SIGNAL_FRAMESIZE+16 bytes
240 * (the +16 is to get the siginfo and ucontext in the same
241 * positions as in older kernels).
243 * Each of these things must be a multiple of 16 bytes in size.
248 compat_siginfo_t info;
253 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
254 struct ucontext uc_transact;
257 * Programs using the rs6000/xcoff abi can save up to 19 gp
258 * regs and 18 fp regs below sp before decrementing it.
264 unsigned long copy_fpr_to_user(void __user *to,
265 struct task_struct *task)
270 /* save FPR copy to local buffer then write to the thread_struct */
271 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
272 buf[i] = task->thread.TS_FPR(i);
273 buf[i] = task->thread.fp_state.fpscr;
274 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
277 unsigned long copy_fpr_from_user(struct task_struct *task,
283 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
285 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
286 task->thread.TS_FPR(i) = buf[i];
287 task->thread.fp_state.fpscr = buf[i];
292 unsigned long copy_vsx_to_user(void __user *to,
293 struct task_struct *task)
295 u64 buf[ELF_NVSRHALFREG];
298 /* save FPR copy to local buffer then write to the thread_struct */
299 for (i = 0; i < ELF_NVSRHALFREG; i++)
300 buf[i] = task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET];
301 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
304 unsigned long copy_vsx_from_user(struct task_struct *task,
307 u64 buf[ELF_NVSRHALFREG];
310 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
312 for (i = 0; i < ELF_NVSRHALFREG ; i++)
313 task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
317 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
318 unsigned long copy_transact_fpr_to_user(void __user *to,
319 struct task_struct *task)
324 /* save FPR copy to local buffer then write to the thread_struct */
325 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
326 buf[i] = task->thread.TS_TRANS_FPR(i);
327 buf[i] = task->thread.transact_fp.fpscr;
328 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
331 unsigned long copy_transact_fpr_from_user(struct task_struct *task,
337 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
339 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
340 task->thread.TS_TRANS_FPR(i) = buf[i];
341 task->thread.transact_fp.fpscr = buf[i];
346 unsigned long copy_transact_vsx_to_user(void __user *to,
347 struct task_struct *task)
349 u64 buf[ELF_NVSRHALFREG];
352 /* save FPR copy to local buffer then write to the thread_struct */
353 for (i = 0; i < ELF_NVSRHALFREG; i++)
354 buf[i] = task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET];
355 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
358 unsigned long copy_transact_vsx_from_user(struct task_struct *task,
361 u64 buf[ELF_NVSRHALFREG];
364 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
366 for (i = 0; i < ELF_NVSRHALFREG ; i++)
367 task->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = buf[i];
370 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
372 inline unsigned long copy_fpr_to_user(void __user *to,
373 struct task_struct *task)
375 return __copy_to_user(to, task->thread.fp_state.fpr,
376 ELF_NFPREG * sizeof(double));
379 inline unsigned long copy_fpr_from_user(struct task_struct *task,
382 return __copy_from_user(task->thread.fp_state.fpr, from,
383 ELF_NFPREG * sizeof(double));
386 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
387 inline unsigned long copy_transact_fpr_to_user(void __user *to,
388 struct task_struct *task)
390 return __copy_to_user(to, task->thread.transact_fp.fpr,
391 ELF_NFPREG * sizeof(double));
394 inline unsigned long copy_transact_fpr_from_user(struct task_struct *task,
397 return __copy_from_user(task->thread.transact_fp.fpr, from,
398 ELF_NFPREG * sizeof(double));
400 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
404 * Save the current user registers on the user stack.
405 * We only save the altivec/spe registers if the process has used
406 * altivec/spe instructions at some point.
408 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
409 struct mcontext __user *tm_frame, int sigret,
410 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, ¤t->thread.vr_state,
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
438 * Note that the current VRSAVE value is in the SPR at this point.
440 if (cpu_has_feature(CPU_FTR_ALTIVEC))
441 current->thread.vrsave = mfspr(SPRN_VRSAVE);
442 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
444 #endif /* CONFIG_ALTIVEC */
445 if (copy_fpr_to_user(&frame->mc_fregs, current))
449 * Clear the MSR VSX bit to indicate there is no valid state attached
450 * to this context, except in the specific case below where we set it.
455 * Copy VSR 0-31 upper half from thread_struct to local
456 * buffer, then write that to userspace. Also set MSR_VSX in
457 * the saved MSR value to indicate that frame->mc_vregs
458 * contains valid data
460 if (current->thread.used_vsr && ctx_has_vsx_region) {
461 __giveup_vsx(current);
462 if (copy_vsx_to_user(&frame->mc_vsregs, current))
466 #endif /* CONFIG_VSX */
468 /* save spe registers */
469 if (current->thread.used_spe) {
470 flush_spe_to_thread(current);
471 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
472 ELF_NEVRREG * sizeof(u32)))
474 /* set MSR_SPE in the saved MSR value to indicate that
475 frame->mc_vregs contains valid data */
478 /* else assert((regs->msr & MSR_SPE) == 0) */
480 /* We always copy to/from spefscr */
481 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
483 #endif /* CONFIG_SPE */
485 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
487 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
488 * can check it on the restore to see if TM is active
490 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
494 /* Set up the sigreturn trampoline: li r0,sigret; sc */
495 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
496 || __put_user(0x44000002UL, &frame->tramp[1]))
498 flush_icache_range((unsigned long) &frame->tramp[0],
499 (unsigned long) &frame->tramp[2]);
505 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
507 * Save the current user registers on the user stack.
508 * We only save the altivec/spe registers if the process has used
509 * altivec/spe instructions at some point.
510 * We also save the transactional registers to a second ucontext in the
513 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
515 static int save_tm_user_regs(struct pt_regs *regs,
516 struct mcontext __user *frame,
517 struct mcontext __user *tm_frame, int sigret)
519 unsigned long msr = regs->msr;
521 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
522 * just indicates to userland that we were doing a transaction, but we
523 * don't want to return in transactional state. This also ensures
524 * that flush_fp_to_thread won't set TIF_RESTORE_TM again.
526 regs->msr &= ~MSR_TS_MASK;
528 /* Make sure floating point registers are stored in regs */
529 flush_fp_to_thread(current);
531 /* Save both sets of general registers */
532 if (save_general_regs(¤t->thread.ckpt_regs, frame)
533 || save_general_regs(regs, tm_frame))
536 /* Stash the top half of the 64bit MSR into the 32bit MSR word
537 * of the transactional mcontext. This way we have a backward-compatible
538 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
539 * also look at what type of transaction (T or S) was active at the
540 * time of the signal.
542 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
545 #ifdef CONFIG_ALTIVEC
546 /* save altivec registers */
547 if (current->thread.used_vr) {
548 flush_altivec_to_thread(current);
549 if (__copy_to_user(&frame->mc_vregs, ¤t->thread.vr_state,
550 ELF_NVRREG * sizeof(vector128)))
553 if (__copy_to_user(&tm_frame->mc_vregs,
554 ¤t->thread.transact_vr,
555 ELF_NVRREG * sizeof(vector128)))
558 if (__copy_to_user(&tm_frame->mc_vregs,
559 ¤t->thread.vr_state,
560 ELF_NVRREG * sizeof(vector128)))
564 /* set MSR_VEC in the saved MSR value to indicate that
565 * frame->mc_vregs contains valid data
570 /* We always copy to/from vrsave, it's 0 if we don't have or don't
571 * use altivec. Since VSCR only contains 32 bits saved in the least
572 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
573 * most significant bits of that same vector. --BenH
575 if (cpu_has_feature(CPU_FTR_ALTIVEC))
576 current->thread.vrsave = mfspr(SPRN_VRSAVE);
577 if (__put_user(current->thread.vrsave,
578 (u32 __user *)&frame->mc_vregs[32]))
581 if (__put_user(current->thread.transact_vrsave,
582 (u32 __user *)&tm_frame->mc_vregs[32]))
585 if (__put_user(current->thread.vrsave,
586 (u32 __user *)&tm_frame->mc_vregs[32]))
589 #endif /* CONFIG_ALTIVEC */
591 if (copy_fpr_to_user(&frame->mc_fregs, current))
594 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
597 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
603 * Copy VSR 0-31 upper half from thread_struct to local
604 * buffer, then write that to userspace. Also set MSR_VSX in
605 * the saved MSR value to indicate that frame->mc_vregs
606 * contains valid data
608 if (current->thread.used_vsr) {
609 __giveup_vsx(current);
610 if (copy_vsx_to_user(&frame->mc_vsregs, current))
613 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
617 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
623 #endif /* CONFIG_VSX */
625 /* SPE regs are not checkpointed with TM, so this section is
626 * simply the same as in save_user_regs().
628 if (current->thread.used_spe) {
629 flush_spe_to_thread(current);
630 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
631 ELF_NEVRREG * sizeof(u32)))
633 /* set MSR_SPE in the saved MSR value to indicate that
634 * frame->mc_vregs contains valid data */
638 /* We always copy to/from spefscr */
639 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
641 #endif /* CONFIG_SPE */
643 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
646 /* Set up the sigreturn trampoline: li r0,sigret; sc */
647 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
648 || __put_user(0x44000002UL, &frame->tramp[1]))
650 flush_icache_range((unsigned long) &frame->tramp[0],
651 (unsigned long) &frame->tramp[2]);
659 * Restore the current user register values from the user stack,
662 static long restore_user_regs(struct pt_regs *regs,
663 struct mcontext __user *sr, int sig)
666 unsigned int save_r2 = 0;
673 * restore general registers but not including MSR or SOFTE. Also
674 * take care of keeping r2 (TLS) intact if not a signal
677 save_r2 = (unsigned int)regs->gpr[2];
678 err = restore_general_regs(regs, sr);
680 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
682 regs->gpr[2] = (unsigned long) save_r2;
686 /* if doing signal return, restore the previous little-endian mode */
688 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
691 * Do this before updating the thread state in
692 * current->thread.fpr/vr/evr. That way, if we get preempted
693 * and another task grabs the FPU/Altivec/SPE, it won't be
694 * tempted to save the current CPU state into the thread_struct
695 * and corrupt what we are writing there.
697 discard_lazy_cpu_state();
699 #ifdef CONFIG_ALTIVEC
701 * Force the process to reload the altivec registers from
702 * current->thread when it next does altivec instructions
704 regs->msr &= ~MSR_VEC;
706 /* restore altivec registers from the stack */
707 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
708 sizeof(sr->mc_vregs)))
710 } else if (current->thread.used_vr)
711 memset(¤t->thread.vr_state, 0,
712 ELF_NVRREG * sizeof(vector128));
714 /* Always get VRSAVE back */
715 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
717 if (cpu_has_feature(CPU_FTR_ALTIVEC))
718 mtspr(SPRN_VRSAVE, current->thread.vrsave);
719 #endif /* CONFIG_ALTIVEC */
720 if (copy_fpr_from_user(current, &sr->mc_fregs))
725 * Force the process to reload the VSX registers from
726 * current->thread when it next does VSX instruction.
728 regs->msr &= ~MSR_VSX;
731 * Restore altivec registers from the stack to a local
732 * buffer, then write this out to the thread_struct
734 if (copy_vsx_from_user(current, &sr->mc_vsregs))
736 } else if (current->thread.used_vsr)
737 for (i = 0; i < 32 ; i++)
738 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
739 #endif /* CONFIG_VSX */
741 * force the process to reload the FP registers from
742 * current->thread when it next does FP instructions
744 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
747 /* force the process to reload the spe registers from
748 current->thread when it next does spe instructions */
749 regs->msr &= ~MSR_SPE;
751 /* restore spe registers from the stack */
752 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
753 ELF_NEVRREG * sizeof(u32)))
755 } else if (current->thread.used_spe)
756 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
758 /* Always get SPEFSCR back */
759 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
761 #endif /* CONFIG_SPE */
766 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
768 * Restore the current user register values from the user stack, except for
769 * MSR, and recheckpoint the original checkpointed register state for processes
772 static long restore_tm_user_regs(struct pt_regs *regs,
773 struct mcontext __user *sr,
774 struct mcontext __user *tm_sr)
777 unsigned long msr, msr_hi;
783 * restore general registers but not including MSR or SOFTE. Also
784 * take care of keeping r2 (TLS) intact if not a signal.
785 * See comment in signal_64.c:restore_tm_sigcontexts();
786 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
787 * were set by the signal delivery.
789 err = restore_general_regs(regs, tm_sr);
790 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
792 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
794 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
798 /* Restore the previous little-endian mode */
799 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
802 * Do this before updating the thread state in
803 * current->thread.fpr/vr/evr. That way, if we get preempted
804 * and another task grabs the FPU/Altivec/SPE, it won't be
805 * tempted to save the current CPU state into the thread_struct
806 * and corrupt what we are writing there.
808 discard_lazy_cpu_state();
810 #ifdef CONFIG_ALTIVEC
811 regs->msr &= ~MSR_VEC;
813 /* restore altivec registers from the stack */
814 if (__copy_from_user(¤t->thread.vr_state, &sr->mc_vregs,
815 sizeof(sr->mc_vregs)) ||
816 __copy_from_user(¤t->thread.transact_vr,
818 sizeof(sr->mc_vregs)))
820 } else if (current->thread.used_vr) {
821 memset(¤t->thread.vr_state, 0,
822 ELF_NVRREG * sizeof(vector128));
823 memset(¤t->thread.transact_vr, 0,
824 ELF_NVRREG * sizeof(vector128));
827 /* Always get VRSAVE back */
828 if (__get_user(current->thread.vrsave,
829 (u32 __user *)&sr->mc_vregs[32]) ||
830 __get_user(current->thread.transact_vrsave,
831 (u32 __user *)&tm_sr->mc_vregs[32]))
833 if (cpu_has_feature(CPU_FTR_ALTIVEC))
834 mtspr(SPRN_VRSAVE, current->thread.vrsave);
835 #endif /* CONFIG_ALTIVEC */
837 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
839 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
840 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
844 regs->msr &= ~MSR_VSX;
847 * Restore altivec registers from the stack to a local
848 * buffer, then write this out to the thread_struct
850 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
851 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
853 } else if (current->thread.used_vsr)
854 for (i = 0; i < 32 ; i++) {
855 current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
856 current->thread.transact_fp.fpr[i][TS_VSRLOWOFFSET] = 0;
858 #endif /* CONFIG_VSX */
861 /* SPE regs are not checkpointed with TM, so this section is
862 * simply the same as in restore_user_regs().
864 regs->msr &= ~MSR_SPE;
866 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
867 ELF_NEVRREG * sizeof(u32)))
869 } else if (current->thread.used_spe)
870 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
872 /* Always get SPEFSCR back */
873 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
876 #endif /* CONFIG_SPE */
878 /* Now, recheckpoint. This loads up all of the checkpointed (older)
879 * registers, including FP and V[S]Rs. After recheckpointing, the
880 * transactional versions should be loaded.
883 /* Make sure the transaction is marked as failed */
884 current->thread.tm_texasr |= TEXASR_FS;
885 /* This loads the checkpointed FP/VEC state, if used */
886 tm_recheckpoint(¤t->thread, msr);
887 /* Get the top half of the MSR */
888 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
890 /* Pull in MSR TM from user context */
891 regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK);
893 /* This loads the speculative FP/VEC state, if used */
895 do_load_up_transact_fpu(¤t->thread);
896 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
898 #ifdef CONFIG_ALTIVEC
900 do_load_up_transact_altivec(¤t->thread);
901 regs->msr |= MSR_VEC;
910 int copy_siginfo_to_user32(struct compat_siginfo __user *d, const siginfo_t *s)
914 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
917 /* If you change siginfo_t structure, please be sure
918 * this code is fixed accordingly.
919 * It should never copy any pad contained in the structure
920 * to avoid security leaks, but must copy the generic
921 * 3 ints plus the relevant union member.
922 * This routine must convert siginfo from 64bit to 32bit as well
925 err = __put_user(s->si_signo, &d->si_signo);
926 err |= __put_user(s->si_errno, &d->si_errno);
927 err |= __put_user((short)s->si_code, &d->si_code);
929 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
931 else switch(s->si_code >> 16) {
932 case __SI_CHLD >> 16:
933 err |= __put_user(s->si_pid, &d->si_pid);
934 err |= __put_user(s->si_uid, &d->si_uid);
935 err |= __put_user(s->si_utime, &d->si_utime);
936 err |= __put_user(s->si_stime, &d->si_stime);
937 err |= __put_user(s->si_status, &d->si_status);
939 case __SI_FAULT >> 16:
940 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
943 case __SI_POLL >> 16:
944 err |= __put_user(s->si_band, &d->si_band);
945 err |= __put_user(s->si_fd, &d->si_fd);
947 case __SI_TIMER >> 16:
948 err |= __put_user(s->si_tid, &d->si_tid);
949 err |= __put_user(s->si_overrun, &d->si_overrun);
950 err |= __put_user(s->si_int, &d->si_int);
952 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
953 case __SI_MESGQ >> 16:
954 err |= __put_user(s->si_int, &d->si_int);
956 case __SI_KILL >> 16:
958 err |= __put_user(s->si_pid, &d->si_pid);
959 err |= __put_user(s->si_uid, &d->si_uid);
965 #define copy_siginfo_to_user copy_siginfo_to_user32
967 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
969 if (copy_from_user(to, from, 3*sizeof(int)) ||
970 copy_from_user(to->_sifields._pad,
971 from->_sifields._pad, SI_PAD_SIZE32))
976 #endif /* CONFIG_PPC64 */
979 * Set up a signal frame for a "real-time" signal handler
980 * (one which gets siginfo).
982 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
983 struct pt_regs *regs)
985 struct rt_sigframe __user *rt_sf;
986 struct mcontext __user *frame;
987 struct mcontext __user *tm_frame = NULL;
989 unsigned long newsp = 0;
993 /* Set up Signal Frame */
994 /* Put a Real Time Context onto stack */
995 rt_sf = get_sigframe(ksig, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
997 if (unlikely(rt_sf == NULL))
1000 /* Put the siginfo & fill in most of the ucontext */
1001 if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
1002 || __put_user(0, &rt_sf->uc.uc_flags)
1003 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
1004 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
1006 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
1009 /* Save user registers on the stack */
1010 frame = &rt_sf->uc.uc_mcontext;
1012 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
1014 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
1016 sigret = __NR_rt_sigreturn;
1017 tramp = (unsigned long) frame->tramp;
1020 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1021 tm_frame = &rt_sf->uc_transact.uc_mcontext;
1022 if (MSR_TM_ACTIVE(regs->msr)) {
1023 if (__put_user((unsigned long)&rt_sf->uc_transact,
1024 &rt_sf->uc.uc_link) ||
1025 __put_user((unsigned long)tm_frame,
1026 &rt_sf->uc_transact.uc_regs))
1028 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1034 if (__put_user(0, &rt_sf->uc.uc_link))
1036 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1041 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1043 /* create a stack frame for the caller of the handler */
1044 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1045 addr = (void __user *)regs->gpr[1];
1046 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1049 /* Fill registers for signal handler */
1050 regs->gpr[1] = newsp;
1051 regs->gpr[3] = ksig->sig;
1052 regs->gpr[4] = (unsigned long) &rt_sf->info;
1053 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1054 regs->gpr[6] = (unsigned long) rt_sf;
1055 regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
1056 /* enter the signal handler in native-endian mode */
1057 regs->msr &= ~MSR_LE;
1058 regs->msr |= (MSR_KERNEL & MSR_LE);
1062 if (show_unhandled_signals)
1063 printk_ratelimited(KERN_INFO
1064 "%s[%d]: bad frame in handle_rt_signal32: "
1065 "%p nip %08lx lr %08lx\n",
1066 current->comm, current->pid,
1067 addr, regs->nip, regs->link);
1072 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1075 struct mcontext __user *mcp;
1077 if (get_sigset_t(&set, &ucp->uc_sigmask))
1083 if (__get_user(cmcp, &ucp->uc_regs))
1085 mcp = (struct mcontext __user *)(u64)cmcp;
1086 /* no need to check access_ok(mcp), since mcp < 4GB */
1089 if (__get_user(mcp, &ucp->uc_regs))
1091 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1094 set_current_blocked(&set);
1095 if (restore_user_regs(regs, mcp, sig))
1101 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1102 static int do_setcontext_tm(struct ucontext __user *ucp,
1103 struct ucontext __user *tm_ucp,
1104 struct pt_regs *regs)
1107 struct mcontext __user *mcp;
1108 struct mcontext __user *tm_mcp;
1112 if (get_sigset_t(&set, &ucp->uc_sigmask))
1115 if (__get_user(cmcp, &ucp->uc_regs) ||
1116 __get_user(tm_cmcp, &tm_ucp->uc_regs))
1118 mcp = (struct mcontext __user *)(u64)cmcp;
1119 tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1120 /* no need to check access_ok(mcp), since mcp < 4GB */
1122 set_current_blocked(&set);
1123 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1130 long sys_swapcontext(struct ucontext __user *old_ctx,
1131 struct ucontext __user *new_ctx,
1132 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1135 int ctx_has_vsx_region = 0;
1138 unsigned long new_msr = 0;
1141 struct mcontext __user *mcp;
1145 * Get pointer to the real mcontext. No need for
1146 * access_ok since we are dealing with compat
1149 if (__get_user(cmcp, &new_ctx->uc_regs))
1151 mcp = (struct mcontext __user *)(u64)cmcp;
1152 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1156 * Check that the context is not smaller than the original
1157 * size (with VMX but without VSX)
1159 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1162 * If the new context state sets the MSR VSX bits but
1163 * it doesn't provide VSX state.
1165 if ((ctx_size < sizeof(struct ucontext)) &&
1166 (new_msr & MSR_VSX))
1168 /* Does the context have enough room to store VSX data? */
1169 if (ctx_size >= sizeof(struct ucontext))
1170 ctx_has_vsx_region = 1;
1172 /* Context size is for future use. Right now, we only make sure
1173 * we are passed something we understand
1175 if (ctx_size < sizeof(struct ucontext))
1178 if (old_ctx != NULL) {
1179 struct mcontext __user *mctx;
1182 * old_ctx might not be 16-byte aligned, in which
1183 * case old_ctx->uc_mcontext won't be either.
1184 * Because we have the old_ctx->uc_pad2 field
1185 * before old_ctx->uc_mcontext, we need to round down
1186 * from &old_ctx->uc_mcontext to a 16-byte boundary.
1188 mctx = (struct mcontext __user *)
1189 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1190 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1191 || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1192 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
1193 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1196 if (new_ctx == NULL)
1198 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1199 || __get_user(tmp, (u8 __user *) new_ctx)
1200 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1204 * If we get a fault copying the context into the kernel's
1205 * image of the user's registers, we can't just return -EFAULT
1206 * because the user's registers will be corrupted. For instance
1207 * the NIP value may have been updated but not some of the
1208 * other registers. Given that we have done the access_ok
1209 * and successfully read the first and last bytes of the region
1210 * above, this should only happen in an out-of-memory situation
1211 * or if another thread unmaps the region containing the context.
1212 * We kill the task with a SIGSEGV in this situation.
1214 if (do_setcontext(new_ctx, regs, 0))
1217 set_thread_flag(TIF_RESTOREALL);
1221 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1222 struct pt_regs *regs)
1224 struct rt_sigframe __user *rt_sf;
1225 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1226 struct ucontext __user *uc_transact;
1227 unsigned long msr_hi;
1231 /* Always make any pending restarted system calls return -EINTR */
1232 current->restart_block.fn = do_no_restart_syscall;
1234 rt_sf = (struct rt_sigframe __user *)
1235 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1236 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1238 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1239 if (__get_user(tmp, &rt_sf->uc.uc_link))
1241 uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1244 struct mcontext __user *mcp;
1246 if (__get_user(cmcp, &uc_transact->uc_regs))
1248 mcp = (struct mcontext __user *)(u64)cmcp;
1249 /* The top 32 bits of the MSR are stashed in the transactional
1251 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1254 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1255 /* We only recheckpoint on return if we're
1259 if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1264 /* Fall through, for non-TM restore */
1266 if (do_setcontext(&rt_sf->uc, regs, 1))
1270 * It's not clear whether or why it is desirable to save the
1271 * sigaltstack setting on signal delivery and restore it on
1272 * signal return. But other architectures do this and we have
1273 * always done it up until now so it is probably better not to
1274 * change it. -- paulus
1277 if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1280 if (restore_altstack(&rt_sf->uc.uc_stack))
1283 set_thread_flag(TIF_RESTOREALL);
1287 if (show_unhandled_signals)
1288 printk_ratelimited(KERN_INFO
1289 "%s[%d]: bad frame in sys_rt_sigreturn: "
1290 "%p nip %08lx lr %08lx\n",
1291 current->comm, current->pid,
1292 rt_sf, regs->nip, regs->link);
1294 force_sig(SIGSEGV, current);
1299 int sys_debug_setcontext(struct ucontext __user *ctx,
1300 int ndbg, struct sig_dbg_op __user *dbg,
1301 int r6, int r7, int r8,
1302 struct pt_regs *regs)
1304 struct sig_dbg_op op;
1307 unsigned long new_msr = regs->msr;
1308 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1309 unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1312 for (i=0; i<ndbg; i++) {
1313 if (copy_from_user(&op, dbg + i, sizeof(op)))
1315 switch (op.dbg_type) {
1316 case SIG_DBG_SINGLE_STEPPING:
1317 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1320 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1322 new_dbcr0 &= ~DBCR0_IC;
1323 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1324 current->thread.debug.dbcr1)) {
1326 new_dbcr0 &= ~DBCR0_IDM;
1336 case SIG_DBG_BRANCH_TRACING:
1337 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1352 /* We wait until here to actually install the values in the
1353 registers so if we fail in the above loop, it will not
1354 affect the contents of these registers. After this point,
1355 failure is a problem, anyway, and it's very unlikely unless
1356 the user is really doing something wrong. */
1357 regs->msr = new_msr;
1358 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1359 current->thread.debug.dbcr0 = new_dbcr0;
1362 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1363 || __get_user(tmp, (u8 __user *) ctx)
1364 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1368 * If we get a fault copying the context into the kernel's
1369 * image of the user's registers, we can't just return -EFAULT
1370 * because the user's registers will be corrupted. For instance
1371 * the NIP value may have been updated but not some of the
1372 * other registers. Given that we have done the access_ok
1373 * and successfully read the first and last bytes of the region
1374 * above, this should only happen in an out-of-memory situation
1375 * or if another thread unmaps the region containing the context.
1376 * We kill the task with a SIGSEGV in this situation.
1378 if (do_setcontext(ctx, regs, 1)) {
1379 if (show_unhandled_signals)
1380 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1381 "sys_debug_setcontext: %p nip %08lx "
1383 current->comm, current->pid,
1384 ctx, regs->nip, regs->link);
1386 force_sig(SIGSEGV, current);
1391 * It's not clear whether or why it is desirable to save the
1392 * sigaltstack setting on signal delivery and restore it on
1393 * signal return. But other architectures do this and we have
1394 * always done it up until now so it is probably better not to
1395 * change it. -- paulus
1397 restore_altstack(&ctx->uc_stack);
1399 set_thread_flag(TIF_RESTOREALL);
1406 * OK, we're invoking a handler
1408 int handle_signal32(struct ksignal *ksig, sigset_t *oldset, struct pt_regs *regs)
1410 struct sigcontext __user *sc;
1411 struct sigframe __user *frame;
1412 struct mcontext __user *tm_mctx = NULL;
1413 unsigned long newsp = 0;
1415 unsigned long tramp;
1417 /* Set up Signal Frame */
1418 frame = get_sigframe(ksig, get_tm_stackpointer(regs), sizeof(*frame), 1);
1419 if (unlikely(frame == NULL))
1421 sc = (struct sigcontext __user *) &frame->sctx;
1424 #error "Please adjust handle_signal()"
1426 if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1427 || __put_user(oldset->sig[0], &sc->oldmask)
1429 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1431 || __put_user(oldset->sig[1], &sc->_unused[3])
1433 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1434 || __put_user(ksig->sig, &sc->signal))
1437 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1439 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1441 sigret = __NR_sigreturn;
1442 tramp = (unsigned long) frame->mctx.tramp;
1445 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1446 tm_mctx = &frame->mctx_transact;
1447 if (MSR_TM_ACTIVE(regs->msr)) {
1448 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1455 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1461 current->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1463 /* create a stack frame for the caller of the handler */
1464 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1465 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1468 regs->gpr[1] = newsp;
1469 regs->gpr[3] = ksig->sig;
1470 regs->gpr[4] = (unsigned long) sc;
1471 regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1472 /* enter the signal handler in big-endian mode */
1473 regs->msr &= ~MSR_LE;
1477 if (show_unhandled_signals)
1478 printk_ratelimited(KERN_INFO
1479 "%s[%d]: bad frame in handle_signal32: "
1480 "%p nip %08lx lr %08lx\n",
1481 current->comm, current->pid,
1482 frame, regs->nip, regs->link);
1488 * Do a signal return; undo the signal stack.
1490 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1491 struct pt_regs *regs)
1493 struct sigframe __user *sf;
1494 struct sigcontext __user *sc;
1495 struct sigcontext sigctx;
1496 struct mcontext __user *sr;
1499 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1500 struct mcontext __user *mcp, *tm_mcp;
1501 unsigned long msr_hi;
1504 /* Always make any pending restarted system calls return -EINTR */
1505 current->restart_block.fn = do_no_restart_syscall;
1507 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1510 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1515 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1516 * unused part of the signal stackframe
1518 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1520 set.sig[0] = sigctx.oldmask;
1521 set.sig[1] = sigctx._unused[3];
1523 set_current_blocked(&set);
1525 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1526 mcp = (struct mcontext __user *)&sf->mctx;
1527 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1528 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1530 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1531 if (!cpu_has_feature(CPU_FTR_TM))
1533 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1538 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1540 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1541 || restore_user_regs(regs, sr, 1))
1545 set_thread_flag(TIF_RESTOREALL);
1549 if (show_unhandled_signals)
1550 printk_ratelimited(KERN_INFO
1551 "%s[%d]: bad frame in sys_sigreturn: "
1552 "%p nip %08lx lr %08lx\n",
1553 current->comm, current->pid,
1554 addr, regs->nip, regs->link);
1556 force_sig(SIGSEGV, current);