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 struct mcontext __user *tm_frame, int sigret,
411 int ctx_has_vsx_region)
413 unsigned long msr = regs->msr;
415 /* Make sure floating point registers are stored in regs */
416 flush_fp_to_thread(current);
418 /* save general registers */
419 if (save_general_regs(regs, frame))
422 #ifdef CONFIG_ALTIVEC
423 /* save altivec registers */
424 if (current->thread.used_vr) {
425 flush_altivec_to_thread(current);
426 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
427 ELF_NVRREG * sizeof(vector128)))
429 /* set MSR_VEC in the saved MSR value to indicate that
430 frame->mc_vregs contains valid data */
433 /* else assert((regs->msr & MSR_VEC) == 0) */
435 /* We always copy to/from vrsave, it's 0 if we don't have or don't
436 * use altivec. Since VSCR only contains 32 bits saved in the least
437 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
438 * most significant bits of that same vector. --BenH
440 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
442 #endif /* CONFIG_ALTIVEC */
443 if (copy_fpr_to_user(&frame->mc_fregs, current))
447 * Clear the MSR VSX bit to indicate there is no valid state attached
448 * to this context, except in the specific case below where we set it.
453 * Copy VSR 0-31 upper half from thread_struct to local
454 * buffer, then write that to userspace. Also set MSR_VSX in
455 * the saved MSR value to indicate that frame->mc_vregs
456 * contains valid data
458 if (current->thread.used_vsr && ctx_has_vsx_region) {
459 __giveup_vsx(current);
460 if (copy_vsx_to_user(&frame->mc_vsregs, current))
464 #endif /* CONFIG_VSX */
466 /* save spe registers */
467 if (current->thread.used_spe) {
468 flush_spe_to_thread(current);
469 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
470 ELF_NEVRREG * sizeof(u32)))
472 /* set MSR_SPE in the saved MSR value to indicate that
473 frame->mc_vregs contains valid data */
476 /* else assert((regs->msr & MSR_SPE) == 0) */
478 /* We always copy to/from spefscr */
479 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
481 #endif /* CONFIG_SPE */
483 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
485 /* We need to write 0 the MSR top 32 bits in the tm frame so that we
486 * can check it on the restore to see if TM is active
488 if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
492 /* Set up the sigreturn trampoline: li r0,sigret; sc */
493 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
494 || __put_user(0x44000002UL, &frame->tramp[1]))
496 flush_icache_range((unsigned long) &frame->tramp[0],
497 (unsigned long) &frame->tramp[2]);
503 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
505 * Save the current user registers on the user stack.
506 * We only save the altivec/spe registers if the process has used
507 * altivec/spe instructions at some point.
508 * We also save the transactional registers to a second ucontext in the
511 * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
513 static int save_tm_user_regs(struct pt_regs *regs,
514 struct mcontext __user *frame,
515 struct mcontext __user *tm_frame, int sigret)
517 unsigned long msr = regs->msr;
519 /* Make sure floating point registers are stored in regs */
520 flush_fp_to_thread(current);
522 /* Save both sets of general registers */
523 if (save_general_regs(¤t->thread.ckpt_regs, frame)
524 || save_general_regs(regs, tm_frame))
527 /* Stash the top half of the 64bit MSR into the 32bit MSR word
528 * of the transactional mcontext. This way we have a backward-compatible
529 * MSR in the 'normal' (checkpointed) mcontext and additionally one can
530 * also look at what type of transaction (T or S) was active at the
531 * time of the signal.
533 if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
536 #ifdef CONFIG_ALTIVEC
537 /* save altivec registers */
538 if (current->thread.used_vr) {
539 flush_altivec_to_thread(current);
540 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
541 ELF_NVRREG * sizeof(vector128)))
544 if (__copy_to_user(&tm_frame->mc_vregs,
545 current->thread.transact_vr,
546 ELF_NVRREG * sizeof(vector128)))
549 if (__copy_to_user(&tm_frame->mc_vregs,
551 ELF_NVRREG * sizeof(vector128)))
555 /* set MSR_VEC in the saved MSR value to indicate that
556 * frame->mc_vregs contains valid data
561 /* We always copy to/from vrsave, it's 0 if we don't have or don't
562 * use altivec. Since VSCR only contains 32 bits saved in the least
563 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
564 * most significant bits of that same vector. --BenH
566 if (__put_user(current->thread.vrsave,
567 (u32 __user *)&frame->mc_vregs[32]))
570 if (__put_user(current->thread.transact_vrsave,
571 (u32 __user *)&tm_frame->mc_vregs[32]))
574 if (__put_user(current->thread.vrsave,
575 (u32 __user *)&tm_frame->mc_vregs[32]))
578 #endif /* CONFIG_ALTIVEC */
580 if (copy_fpr_to_user(&frame->mc_fregs, current))
583 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
586 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
592 * Copy VSR 0-31 upper half from thread_struct to local
593 * buffer, then write that to userspace. Also set MSR_VSX in
594 * the saved MSR value to indicate that frame->mc_vregs
595 * contains valid data
597 if (current->thread.used_vsr) {
598 __giveup_vsx(current);
599 if (copy_vsx_to_user(&frame->mc_vsregs, current))
602 if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
606 if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
612 #endif /* CONFIG_VSX */
614 /* SPE regs are not checkpointed with TM, so this section is
615 * simply the same as in save_user_regs().
617 if (current->thread.used_spe) {
618 flush_spe_to_thread(current);
619 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
620 ELF_NEVRREG * sizeof(u32)))
622 /* set MSR_SPE in the saved MSR value to indicate that
623 * frame->mc_vregs contains valid data */
627 /* We always copy to/from spefscr */
628 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
630 #endif /* CONFIG_SPE */
632 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
635 /* Set up the sigreturn trampoline: li r0,sigret; sc */
636 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
637 || __put_user(0x44000002UL, &frame->tramp[1]))
639 flush_icache_range((unsigned long) &frame->tramp[0],
640 (unsigned long) &frame->tramp[2]);
648 * Restore the current user register values from the user stack,
651 static long restore_user_regs(struct pt_regs *regs,
652 struct mcontext __user *sr, int sig)
655 unsigned int save_r2 = 0;
662 * restore general registers but not including MSR or SOFTE. Also
663 * take care of keeping r2 (TLS) intact if not a signal
666 save_r2 = (unsigned int)regs->gpr[2];
667 err = restore_general_regs(regs, sr);
669 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
671 regs->gpr[2] = (unsigned long) save_r2;
675 /* if doing signal return, restore the previous little-endian mode */
677 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
680 * Do this before updating the thread state in
681 * current->thread.fpr/vr/evr. That way, if we get preempted
682 * and another task grabs the FPU/Altivec/SPE, it won't be
683 * tempted to save the current CPU state into the thread_struct
684 * and corrupt what we are writing there.
686 discard_lazy_cpu_state();
688 #ifdef CONFIG_ALTIVEC
690 * Force the process to reload the altivec registers from
691 * current->thread when it next does altivec instructions
693 regs->msr &= ~MSR_VEC;
695 /* restore altivec registers from the stack */
696 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
697 sizeof(sr->mc_vregs)))
699 } else if (current->thread.used_vr)
700 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
702 /* Always get VRSAVE back */
703 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
705 #endif /* CONFIG_ALTIVEC */
706 if (copy_fpr_from_user(current, &sr->mc_fregs))
711 * Force the process to reload the VSX registers from
712 * current->thread when it next does VSX instruction.
714 regs->msr &= ~MSR_VSX;
717 * Restore altivec registers from the stack to a local
718 * buffer, then write this out to the thread_struct
720 if (copy_vsx_from_user(current, &sr->mc_vsregs))
722 } else if (current->thread.used_vsr)
723 for (i = 0; i < 32 ; i++)
724 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
725 #endif /* CONFIG_VSX */
727 * force the process to reload the FP registers from
728 * current->thread when it next does FP instructions
730 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
733 /* force the process to reload the spe registers from
734 current->thread when it next does spe instructions */
735 regs->msr &= ~MSR_SPE;
737 /* restore spe registers from the stack */
738 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
739 ELF_NEVRREG * sizeof(u32)))
741 } else if (current->thread.used_spe)
742 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
744 /* Always get SPEFSCR back */
745 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
747 #endif /* CONFIG_SPE */
752 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
754 * Restore the current user register values from the user stack, except for
755 * MSR, and recheckpoint the original checkpointed register state for processes
758 static long restore_tm_user_regs(struct pt_regs *regs,
759 struct mcontext __user *sr,
760 struct mcontext __user *tm_sr)
763 unsigned long msr, msr_hi;
769 * restore general registers but not including MSR or SOFTE. Also
770 * take care of keeping r2 (TLS) intact if not a signal.
771 * See comment in signal_64.c:restore_tm_sigcontexts();
772 * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
773 * were set by the signal delivery.
775 err = restore_general_regs(regs, tm_sr);
776 err |= restore_general_regs(¤t->thread.ckpt_regs, sr);
778 err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
780 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
784 /* Restore the previous little-endian mode */
785 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
788 * Do this before updating the thread state in
789 * current->thread.fpr/vr/evr. That way, if we get preempted
790 * and another task grabs the FPU/Altivec/SPE, it won't be
791 * tempted to save the current CPU state into the thread_struct
792 * and corrupt what we are writing there.
794 discard_lazy_cpu_state();
796 #ifdef CONFIG_ALTIVEC
797 regs->msr &= ~MSR_VEC;
799 /* restore altivec registers from the stack */
800 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
801 sizeof(sr->mc_vregs)) ||
802 __copy_from_user(current->thread.transact_vr,
804 sizeof(sr->mc_vregs)))
806 } else if (current->thread.used_vr) {
807 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
808 memset(current->thread.transact_vr, 0,
809 ELF_NVRREG * sizeof(vector128));
812 /* Always get VRSAVE back */
813 if (__get_user(current->thread.vrsave,
814 (u32 __user *)&sr->mc_vregs[32]) ||
815 __get_user(current->thread.transact_vrsave,
816 (u32 __user *)&tm_sr->mc_vregs[32]))
818 #endif /* CONFIG_ALTIVEC */
820 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
822 if (copy_fpr_from_user(current, &sr->mc_fregs) ||
823 copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
827 regs->msr &= ~MSR_VSX;
830 * Restore altivec registers from the stack to a local
831 * buffer, then write this out to the thread_struct
833 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
834 copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
836 } else if (current->thread.used_vsr)
837 for (i = 0; i < 32 ; i++) {
838 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
839 current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
841 #endif /* CONFIG_VSX */
844 /* SPE regs are not checkpointed with TM, so this section is
845 * simply the same as in restore_user_regs().
847 regs->msr &= ~MSR_SPE;
849 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
850 ELF_NEVRREG * sizeof(u32)))
852 } else if (current->thread.used_spe)
853 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
855 /* Always get SPEFSCR back */
856 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
859 #endif /* CONFIG_SPE */
861 /* Now, recheckpoint. This loads up all of the checkpointed (older)
862 * registers, including FP and V[S]Rs. After recheckpointing, the
863 * transactional versions should be loaded.
866 /* This loads the checkpointed FP/VEC state, if used */
867 tm_recheckpoint(¤t->thread, msr);
868 /* Get the top half of the MSR */
869 if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
871 /* Pull in MSR TM from user context */
872 regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK);
874 /* This loads the speculative FP/VEC state, if used */
876 do_load_up_transact_fpu(¤t->thread);
877 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
879 #ifdef CONFIG_ALTIVEC
881 do_load_up_transact_altivec(¤t->thread);
882 regs->msr |= MSR_VEC;
891 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
895 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
898 /* If you change siginfo_t structure, please be sure
899 * this code is fixed accordingly.
900 * It should never copy any pad contained in the structure
901 * to avoid security leaks, but must copy the generic
902 * 3 ints plus the relevant union member.
903 * This routine must convert siginfo from 64bit to 32bit as well
906 err = __put_user(s->si_signo, &d->si_signo);
907 err |= __put_user(s->si_errno, &d->si_errno);
908 err |= __put_user((short)s->si_code, &d->si_code);
910 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
912 else switch(s->si_code >> 16) {
913 case __SI_CHLD >> 16:
914 err |= __put_user(s->si_pid, &d->si_pid);
915 err |= __put_user(s->si_uid, &d->si_uid);
916 err |= __put_user(s->si_utime, &d->si_utime);
917 err |= __put_user(s->si_stime, &d->si_stime);
918 err |= __put_user(s->si_status, &d->si_status);
920 case __SI_FAULT >> 16:
921 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
924 case __SI_POLL >> 16:
925 err |= __put_user(s->si_band, &d->si_band);
926 err |= __put_user(s->si_fd, &d->si_fd);
928 case __SI_TIMER >> 16:
929 err |= __put_user(s->si_tid, &d->si_tid);
930 err |= __put_user(s->si_overrun, &d->si_overrun);
931 err |= __put_user(s->si_int, &d->si_int);
933 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
934 case __SI_MESGQ >> 16:
935 err |= __put_user(s->si_int, &d->si_int);
937 case __SI_KILL >> 16:
939 err |= __put_user(s->si_pid, &d->si_pid);
940 err |= __put_user(s->si_uid, &d->si_uid);
946 #define copy_siginfo_to_user copy_siginfo_to_user32
948 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
950 memset(to, 0, sizeof *to);
952 if (copy_from_user(to, from, 3*sizeof(int)) ||
953 copy_from_user(to->_sifields._pad,
954 from->_sifields._pad, SI_PAD_SIZE32))
959 #endif /* CONFIG_PPC64 */
962 * Set up a signal frame for a "real-time" signal handler
963 * (one which gets siginfo).
965 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
966 siginfo_t *info, sigset_t *oldset,
967 struct pt_regs *regs)
969 struct rt_sigframe __user *rt_sf;
970 struct mcontext __user *frame;
971 struct mcontext __user *tm_frame = NULL;
973 unsigned long newsp = 0;
977 /* Set up Signal Frame */
978 /* Put a Real Time Context onto stack */
979 rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
981 if (unlikely(rt_sf == NULL))
984 /* Put the siginfo & fill in most of the ucontext */
985 if (copy_siginfo_to_user(&rt_sf->info, info)
986 || __put_user(0, &rt_sf->uc.uc_flags)
987 || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
988 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
990 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
993 /* Save user registers on the stack */
994 frame = &rt_sf->uc.uc_mcontext;
996 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
998 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
1000 sigret = __NR_rt_sigreturn;
1001 tramp = (unsigned long) frame->tramp;
1004 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1005 tm_frame = &rt_sf->uc_transact.uc_mcontext;
1006 if (MSR_TM_ACTIVE(regs->msr)) {
1007 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1013 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1018 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1019 if (MSR_TM_ACTIVE(regs->msr)) {
1020 if (__put_user((unsigned long)&rt_sf->uc_transact,
1022 || __put_user((unsigned long)tm_frame, &rt_sf->uc_transact.uc_regs))
1027 if (__put_user(0, &rt_sf->uc.uc_link))
1030 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1032 /* create a stack frame for the caller of the handler */
1033 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1034 addr = (void __user *)regs->gpr[1];
1035 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1038 /* Fill registers for signal handler */
1039 regs->gpr[1] = newsp;
1041 regs->gpr[4] = (unsigned long) &rt_sf->info;
1042 regs->gpr[5] = (unsigned long) &rt_sf->uc;
1043 regs->gpr[6] = (unsigned long) rt_sf;
1044 regs->nip = (unsigned long) ka->sa.sa_handler;
1045 /* enter the signal handler in big-endian mode */
1046 regs->msr &= ~MSR_LE;
1047 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1048 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1049 * just indicates to userland that we were doing a transaction, but we
1050 * don't want to return in transactional state:
1052 regs->msr &= ~MSR_TS_MASK;
1058 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
1059 regs, frame, newsp);
1061 if (show_unhandled_signals)
1062 printk_ratelimited(KERN_INFO
1063 "%s[%d]: bad frame in handle_rt_signal32: "
1064 "%p nip %08lx lr %08lx\n",
1065 current->comm, current->pid,
1066 addr, regs->nip, regs->link);
1068 force_sigsegv(sig, current);
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_thread_info()->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.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.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.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(unsigned long sig, struct k_sigaction *ka,
1409 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1411 struct sigcontext __user *sc;
1412 struct sigframe __user *frame;
1413 struct mcontext __user *tm_mctx = NULL;
1414 unsigned long newsp = 0;
1416 unsigned long tramp;
1418 /* Set up Signal Frame */
1419 frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1);
1420 if (unlikely(frame == NULL))
1422 sc = (struct sigcontext __user *) &frame->sctx;
1425 #error "Please adjust handle_signal()"
1427 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1428 || __put_user(oldset->sig[0], &sc->oldmask)
1430 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1432 || __put_user(oldset->sig[1], &sc->_unused[3])
1434 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1435 || __put_user(sig, &sc->signal))
1438 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1440 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1442 sigret = __NR_sigreturn;
1443 tramp = (unsigned long) frame->mctx.tramp;
1446 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1447 tm_mctx = &frame->mctx_transact;
1448 if (MSR_TM_ACTIVE(regs->msr)) {
1449 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1456 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1462 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1464 /* create a stack frame for the caller of the handler */
1465 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1466 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1469 regs->gpr[1] = newsp;
1471 regs->gpr[4] = (unsigned long) sc;
1472 regs->nip = (unsigned long) ka->sa.sa_handler;
1473 /* enter the signal handler in big-endian mode */
1474 regs->msr &= ~MSR_LE;
1475 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1476 /* Remove TM bits from thread's MSR. The MSR in the sigcontext
1477 * just indicates to userland that we were doing a transaction, but we
1478 * don't want to return in transactional state:
1480 regs->msr &= ~MSR_TS_MASK;
1486 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1487 regs, frame, newsp);
1489 if (show_unhandled_signals)
1490 printk_ratelimited(KERN_INFO
1491 "%s[%d]: bad frame in handle_signal32: "
1492 "%p nip %08lx lr %08lx\n",
1493 current->comm, current->pid,
1494 frame, regs->nip, regs->link);
1496 force_sigsegv(sig, current);
1501 * Do a signal return; undo the signal stack.
1503 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1504 struct pt_regs *regs)
1506 struct sigframe __user *sf;
1507 struct sigcontext __user *sc;
1508 struct sigcontext sigctx;
1509 struct mcontext __user *sr;
1512 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1513 struct mcontext __user *mcp, *tm_mcp;
1514 unsigned long msr_hi;
1517 /* Always make any pending restarted system calls return -EINTR */
1518 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1520 sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1523 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1528 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1529 * unused part of the signal stackframe
1531 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1533 set.sig[0] = sigctx.oldmask;
1534 set.sig[1] = sigctx._unused[3];
1536 set_current_blocked(&set);
1538 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1539 mcp = (struct mcontext __user *)&sf->mctx;
1540 tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1541 if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1543 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1544 if (!cpu_has_feature(CPU_FTR_TM))
1546 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1551 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1553 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1554 || restore_user_regs(regs, sr, 1))
1558 set_thread_flag(TIF_RESTOREALL);
1562 if (show_unhandled_signals)
1563 printk_ratelimited(KERN_INFO
1564 "%s[%d]: bad frame in sys_sigreturn: "
1565 "%p nip %08lx lr %08lx\n",
1566 current->comm, current->pid,
1567 addr, regs->nip, regs->link);
1569 force_sig(SIGSEGV, current);