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/config.h>
21 #include <linux/sched.h>
23 #include <linux/smp.h>
24 #include <linux/smp_lock.h>
25 #include <linux/kernel.h>
26 #include <linux/signal.h>
27 #include <linux/errno.h>
28 #include <linux/elf.h>
30 #include <linux/syscalls.h>
31 #include <linux/compat.h>
32 #include <linux/ptrace.h>
34 #include <linux/wait.h>
35 #include <linux/ptrace.h>
36 #include <linux/unistd.h>
37 #include <linux/stddef.h>
38 #include <linux/tty.h>
39 #include <linux/binfmts.h>
40 #include <linux/suspend.h>
43 #include <asm/uaccess.h>
44 #include <asm/cacheflush.h>
45 #include <asm/sigcontext.h>
49 #include <asm/unistd.h>
51 #include <asm/ucontext.h>
52 #include <asm/pgtable.h>
57 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
60 #define do_signal do_signal32
61 #define sys_sigsuspend compat_sys_sigsuspend
62 #define sys_rt_sigsuspend compat_sys_rt_sigsuspend
63 #define sys_rt_sigreturn compat_sys_rt_sigreturn
64 #define sys_sigaction compat_sys_sigaction
65 #define sys_swapcontext compat_sys_swapcontext
66 #define sys_sigreturn compat_sys_sigreturn
68 #define old_sigaction old_sigaction32
69 #define sigcontext sigcontext32
70 #define mcontext mcontext32
71 #define ucontext ucontext32
74 * Returning 0 means we return to userspace via
75 * ret_from_except and thus restore all user
76 * registers from *regs. This is what we need
77 * to do when a signal has been delivered.
80 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
81 #undef __SIGNAL_FRAMESIZE
82 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
84 #define ELF_NVRREG ELF_NVRREG32
87 * Functions for flipping sigsets (thanks to brain dead generic
88 * implementation that makes things simple for little endian only)
90 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
94 switch (_NSIG_WORDS) {
95 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
96 cset.sig[7] = set->sig[3] >> 32;
97 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
98 cset.sig[5] = set->sig[2] >> 32;
99 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
100 cset.sig[3] = set->sig[1] >> 32;
101 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
102 cset.sig[1] = set->sig[0] >> 32;
104 return copy_to_user(uset, &cset, sizeof(*uset));
107 static inline int get_sigset_t(sigset_t *set,
108 const compat_sigset_t __user *uset)
112 if (copy_from_user(&s32, uset, sizeof(*uset)))
116 * Swap the 2 words of the 64-bit sigset_t (they are stored
117 * in the "wrong" endian in 32-bit user storage).
119 switch (_NSIG_WORDS) {
120 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
121 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
122 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
123 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
128 static inline int get_old_sigaction(struct k_sigaction *new_ka,
129 struct old_sigaction __user *act)
131 compat_old_sigset_t mask;
132 compat_uptr_t handler, restorer;
134 if (get_user(handler, &act->sa_handler) ||
135 __get_user(restorer, &act->sa_restorer) ||
136 __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
137 __get_user(mask, &act->sa_mask))
139 new_ka->sa.sa_handler = compat_ptr(handler);
140 new_ka->sa.sa_restorer = compat_ptr(restorer);
141 siginitset(&new_ka->sa.sa_mask, mask);
145 static inline compat_uptr_t to_user_ptr(void *kp)
147 return (compat_uptr_t)(u64)kp;
150 #define from_user_ptr(p) compat_ptr(p)
152 static inline int save_general_regs(struct pt_regs *regs,
153 struct mcontext __user *frame)
155 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
158 if (!FULL_REGS(regs)) {
159 set_thread_flag(TIF_SAVE_NVGPRS);
160 current_thread_info()->nvgprs_frame = frame->mc_gregs;
163 for (i = 0; i <= PT_RESULT; i ++) {
164 if (i == 14 && !FULL_REGS(regs))
166 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
172 static inline int restore_general_regs(struct pt_regs *regs,
173 struct mcontext __user *sr)
175 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
178 for (i = 0; i <= PT_RESULT; i++) {
179 if ((i == PT_MSR) || (i == PT_SOFTE))
181 if (__get_user(gregs[i], &sr->mc_gregs[i]))
187 #else /* CONFIG_PPC64 */
189 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
191 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
193 return copy_to_user(uset, set, sizeof(*uset));
196 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
198 return copy_from_user(set, uset, sizeof(*uset));
201 static inline int get_old_sigaction(struct k_sigaction *new_ka,
202 struct old_sigaction __user *act)
206 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
207 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
208 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
210 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
211 __get_user(mask, &act->sa_mask);
212 siginitset(&new_ka->sa.sa_mask, mask);
216 #define to_user_ptr(p) (p)
217 #define from_user_ptr(p) (p)
219 static inline int save_general_regs(struct pt_regs *regs,
220 struct mcontext __user *frame)
222 if (!FULL_REGS(regs)) {
223 /* Zero out the unsaved GPRs to avoid information
224 leak, and set TIF_SAVE_NVGPRS to ensure that the
225 registers do actually get saved later. */
226 memset(®s->gpr[14], 0, 18 * sizeof(unsigned long));
227 current_thread_info()->nvgprs_frame = &frame->mc_gregs;
228 set_thread_flag(TIF_SAVE_NVGPRS);
231 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
234 static inline int restore_general_regs(struct pt_regs *regs,
235 struct mcontext __user *sr)
237 /* copy up to but not including MSR */
238 if (__copy_from_user(regs, &sr->mc_gregs,
239 PT_MSR * sizeof(elf_greg_t)))
241 /* copy from orig_r3 (the word after the MSR) up to the end */
242 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
243 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
248 #endif /* CONFIG_PPC64 */
250 int do_signal(sigset_t *oldset, struct pt_regs *regs);
253 * Atomically swap in the new signal mask, and wait for a signal.
255 long sys_sigsuspend(old_sigset_t mask)
258 spin_lock_irq(¤t->sighand->siglock);
259 current->saved_sigmask = current->blocked;
260 siginitset(¤t->blocked, mask);
262 spin_unlock_irq(¤t->sighand->siglock);
264 current->state = TASK_INTERRUPTIBLE;
266 set_thread_flag(TIF_RESTORE_SIGMASK);
267 return -ERESTARTNOHAND;
271 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
272 int r6, int r7, int r8, struct pt_regs *regs)
274 return do_sigaltstack(uss, uoss, regs->gpr[1]);
278 long sys_sigaction(int sig, struct old_sigaction __user *act,
279 struct old_sigaction __user *oact)
281 struct k_sigaction new_ka, old_ka;
290 if (get_old_sigaction(&new_ka, act))
294 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
296 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
297 __put_user(to_user_ptr(old_ka.sa.sa_handler),
298 &oact->sa_handler) ||
299 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
300 &oact->sa_restorer) ||
301 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
302 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
310 * When we have signals to deliver, we set up on the
311 * user stack, going down from the original stack pointer:
313 * a sigcontext struct
314 * a gap of __SIGNAL_FRAMESIZE bytes
316 * Each of these things must be a multiple of 16 bytes in size.
320 struct mcontext mctx; /* all the register values */
322 * Programs using the rs6000/xcoff abi can save up to 19 gp
323 * regs and 18 fp regs below sp before decrementing it.
328 /* We use the mc_pad field for the signal return trampoline. */
332 * When we have rt signals to deliver, we set up on the
333 * user stack, going down from the original stack pointer:
334 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
335 * a gap of __SIGNAL_FRAMESIZE+16 bytes
336 * (the +16 is to get the siginfo and ucontext in the same
337 * positions as in older kernels).
339 * Each of these things must be a multiple of 16 bytes in size.
344 compat_siginfo_t info;
350 * Programs using the rs6000/xcoff abi can save up to 19 gp
351 * regs and 18 fp regs below sp before decrementing it.
357 * Save the current user registers on the user stack.
358 * We only save the altivec/spe registers if the process has used
359 * altivec/spe instructions at some point.
361 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
364 /* Make sure floating point registers are stored in regs */
365 flush_fp_to_thread(current);
367 /* save general and floating-point registers */
368 if (save_general_regs(regs, frame) ||
369 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
370 ELF_NFPREG * sizeof(double)))
373 #ifdef CONFIG_ALTIVEC
374 /* save altivec registers */
375 if (current->thread.used_vr) {
376 flush_altivec_to_thread(current);
377 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
378 ELF_NVRREG * sizeof(vector128)))
380 /* set MSR_VEC in the saved MSR value to indicate that
381 frame->mc_vregs contains valid data */
382 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
385 /* else assert((regs->msr & MSR_VEC) == 0) */
387 /* We always copy to/from vrsave, it's 0 if we don't have or don't
388 * use altivec. Since VSCR only contains 32 bits saved in the least
389 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
390 * most significant bits of that same vector. --BenH
392 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
394 #endif /* CONFIG_ALTIVEC */
397 /* save spe registers */
398 if (current->thread.used_spe) {
399 flush_spe_to_thread(current);
400 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
401 ELF_NEVRREG * sizeof(u32)))
403 /* set MSR_SPE in the saved MSR value to indicate that
404 frame->mc_vregs contains valid data */
405 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
408 /* else assert((regs->msr & MSR_SPE) == 0) */
410 /* We always copy to/from spefscr */
411 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
413 #endif /* CONFIG_SPE */
416 /* Set up the sigreturn trampoline: li r0,sigret; sc */
417 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
418 || __put_user(0x44000002UL, &frame->tramp[1]))
420 flush_icache_range((unsigned long) &frame->tramp[0],
421 (unsigned long) &frame->tramp[2]);
428 * Restore the current user register values from the user stack,
431 static long restore_user_regs(struct pt_regs *regs,
432 struct mcontext __user *sr, int sig)
435 unsigned int save_r2 = 0;
436 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
441 * restore general registers but not including MSR or SOFTE. Also
442 * take care of keeping r2 (TLS) intact if not a signal
445 save_r2 = (unsigned int)regs->gpr[2];
446 err = restore_general_regs(regs, sr);
448 regs->gpr[2] = (unsigned long) save_r2;
453 * Do this before updating the thread state in
454 * current->thread.fpr/vr/evr. That way, if we get preempted
455 * and another task grabs the FPU/Altivec/SPE, it won't be
456 * tempted to save the current CPU state into the thread_struct
457 * and corrupt what we are writing there.
459 discard_lazy_cpu_state();
461 /* force the process to reload the FP registers from
462 current->thread when it next does FP instructions */
463 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
464 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
465 sizeof(sr->mc_fregs)))
468 #ifdef CONFIG_ALTIVEC
469 /* force the process to reload the altivec registers from
470 current->thread when it next does altivec instructions */
471 regs->msr &= ~MSR_VEC;
472 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
473 /* restore altivec registers from the stack */
474 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
475 sizeof(sr->mc_vregs)))
477 } else if (current->thread.used_vr)
478 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
480 /* Always get VRSAVE back */
481 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
483 #endif /* CONFIG_ALTIVEC */
486 /* force the process to reload the spe registers from
487 current->thread when it next does spe instructions */
488 regs->msr &= ~MSR_SPE;
489 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
490 /* restore spe registers from the stack */
491 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
492 ELF_NEVRREG * sizeof(u32)))
494 } else if (current->thread.used_spe)
495 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
497 /* Always get SPEFSCR back */
498 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
500 #endif /* CONFIG_SPE */
506 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
507 struct sigaction32 __user *oact, size_t sigsetsize)
509 struct k_sigaction new_ka, old_ka;
512 /* XXX: Don't preclude handling different sized sigset_t's. */
513 if (sigsetsize != sizeof(compat_sigset_t))
517 compat_uptr_t handler;
519 ret = get_user(handler, &act->sa_handler);
520 new_ka.sa.sa_handler = compat_ptr(handler);
521 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
522 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
527 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
529 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
530 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
531 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
537 * Note: it is necessary to treat how as an unsigned int, with the
538 * corresponding cast to a signed int to insure that the proper
539 * conversion (sign extension) between the register representation
540 * of a signed int (msr in 32-bit mode) and the register representation
541 * of a signed int (msr in 64-bit mode) is performed.
543 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
544 compat_sigset_t __user *oset, size_t sigsetsize)
549 mm_segment_t old_fs = get_fs();
552 if (get_sigset_t(&s, set))
557 /* This is valid because of the set_fs() */
558 up = (sigset_t __user *) &s;
559 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
565 if (put_sigset_t(oset, &s))
571 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
575 mm_segment_t old_fs = get_fs();
578 /* The __user pointer cast is valid because of the set_fs() */
579 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
582 if (put_sigset_t(set, &s))
589 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
593 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
596 /* If you change siginfo_t structure, please be sure
597 * this code is fixed accordingly.
598 * It should never copy any pad contained in the structure
599 * to avoid security leaks, but must copy the generic
600 * 3 ints plus the relevant union member.
601 * This routine must convert siginfo from 64bit to 32bit as well
604 err = __put_user(s->si_signo, &d->si_signo);
605 err |= __put_user(s->si_errno, &d->si_errno);
606 err |= __put_user((short)s->si_code, &d->si_code);
608 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
610 else switch(s->si_code >> 16) {
611 case __SI_CHLD >> 16:
612 err |= __put_user(s->si_pid, &d->si_pid);
613 err |= __put_user(s->si_uid, &d->si_uid);
614 err |= __put_user(s->si_utime, &d->si_utime);
615 err |= __put_user(s->si_stime, &d->si_stime);
616 err |= __put_user(s->si_status, &d->si_status);
618 case __SI_FAULT >> 16:
619 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
622 case __SI_POLL >> 16:
623 err |= __put_user(s->si_band, &d->si_band);
624 err |= __put_user(s->si_fd, &d->si_fd);
626 case __SI_TIMER >> 16:
627 err |= __put_user(s->si_tid, &d->si_tid);
628 err |= __put_user(s->si_overrun, &d->si_overrun);
629 err |= __put_user(s->si_int, &d->si_int);
631 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
632 case __SI_MESGQ >> 16:
633 err |= __put_user(s->si_int, &d->si_int);
635 case __SI_KILL >> 16:
637 err |= __put_user(s->si_pid, &d->si_pid);
638 err |= __put_user(s->si_uid, &d->si_uid);
644 #define copy_siginfo_to_user copy_siginfo_to_user32
647 * Note: it is necessary to treat pid and sig as unsigned ints, with the
648 * corresponding cast to a signed int to insure that the proper conversion
649 * (sign extension) between the register representation of a signed int
650 * (msr in 32-bit mode) and the register representation of a signed int
651 * (msr in 64-bit mode) is performed.
653 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
657 mm_segment_t old_fs = get_fs();
659 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
660 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
663 /* The __user pointer cast is valid becasuse of the set_fs() */
664 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
669 * Start Alternate signal stack support
672 * sigaltatck compat_sys_sigaltstack
675 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
676 int r6, int r7, int r8, struct pt_regs *regs)
678 stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
679 stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
687 * set sp to the user stack on entry to the system call
688 * the system call router sets R9 to the saved registers
692 /* Put new stack info in local 64 bit stack struct */
694 if (get_user(ss_sp, &newstack->ss_sp) ||
695 __get_user(uss.ss_flags, &newstack->ss_flags) ||
696 __get_user(uss.ss_size, &newstack->ss_size))
698 uss.ss_sp = compat_ptr(ss_sp);
703 /* The __user pointer casts are valid because of the set_fs() */
704 ret = do_sigaltstack(
705 newstack ? (stack_t __user *) &uss : NULL,
706 oldstack ? (stack_t __user *) &uoss : NULL,
709 /* Copy the stack information to the user output buffer */
710 if (!ret && oldstack &&
711 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
712 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
713 __put_user(uoss.ss_size, &oldstack->ss_size)))
717 #endif /* CONFIG_PPC64 */
721 * Restore the user process's signal mask
724 extern void restore_sigmask(sigset_t *set);
725 #else /* CONFIG_PPC64 */
726 static void restore_sigmask(sigset_t *set)
728 sigdelsetmask(set, ~_BLOCKABLE);
729 spin_lock_irq(¤t->sighand->siglock);
730 current->blocked = *set;
732 spin_unlock_irq(¤t->sighand->siglock);
737 * Set up a signal frame for a "real-time" signal handler
738 * (one which gets siginfo).
740 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
741 siginfo_t *info, sigset_t *oldset,
742 struct pt_regs *regs, unsigned long newsp)
744 struct rt_sigframe __user *rt_sf;
745 struct mcontext __user *frame;
746 unsigned long origsp = newsp;
748 /* Set up Signal Frame */
749 /* Put a Real Time Context onto stack */
750 newsp -= sizeof(*rt_sf);
751 rt_sf = (struct rt_sigframe __user *)newsp;
753 /* create a stack frame for the caller of the handler */
754 newsp -= __SIGNAL_FRAMESIZE + 16;
756 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
759 /* Put the siginfo & fill in most of the ucontext */
760 if (copy_siginfo_to_user(&rt_sf->info, info)
761 || __put_user(0, &rt_sf->uc.uc_flags)
762 || __put_user(0, &rt_sf->uc.uc_link)
763 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
764 || __put_user(sas_ss_flags(regs->gpr[1]),
765 &rt_sf->uc.uc_stack.ss_flags)
766 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
767 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
769 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
772 /* Save user registers on the stack */
773 frame = &rt_sf->uc.uc_mcontext;
774 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
775 if (save_user_regs(regs, frame, 0))
777 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
779 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
781 regs->link = (unsigned long) frame->tramp;
784 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
786 if (put_user(regs->gpr[1], (u32 __user *)newsp))
788 regs->gpr[1] = newsp;
790 regs->gpr[4] = (unsigned long) &rt_sf->info;
791 regs->gpr[5] = (unsigned long) &rt_sf->uc;
792 regs->gpr[6] = (unsigned long) rt_sf;
793 regs->nip = (unsigned long) ka->sa.sa_handler;
799 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
802 force_sigsegv(sig, current);
806 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
809 struct mcontext __user *mcp;
811 if (get_sigset_t(&set, &ucp->uc_sigmask))
817 if (__get_user(cmcp, &ucp->uc_regs))
819 mcp = (struct mcontext __user *)(u64)cmcp;
822 if (__get_user(mcp, &ucp->uc_regs))
825 restore_sigmask(&set);
826 if (restore_user_regs(regs, mcp, sig))
832 long sys_swapcontext(struct ucontext __user *old_ctx,
833 struct ucontext __user *new_ctx,
834 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
838 /* Context size is for future use. Right now, we only make sure
839 * we are passed something we understand
841 if (ctx_size < sizeof(struct ucontext))
844 if (old_ctx != NULL) {
845 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
846 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
847 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
848 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
854 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
855 || __get_user(tmp, (u8 __user *) new_ctx)
856 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
860 * If we get a fault copying the context into the kernel's
861 * image of the user's registers, we can't just return -EFAULT
862 * because the user's registers will be corrupted. For instance
863 * the NIP value may have been updated but not some of the
864 * other registers. Given that we have done the access_ok
865 * and successfully read the first and last bytes of the region
866 * above, this should only happen in an out-of-memory situation
867 * or if another thread unmaps the region containing the context.
868 * We kill the task with a SIGSEGV in this situation.
870 if (do_setcontext(new_ctx, regs, 0))
873 set_thread_flag(TIF_RESTOREALL);
877 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
878 struct pt_regs *regs)
880 struct rt_sigframe __user *rt_sf;
882 /* Always make any pending restarted system calls return -EINTR */
883 current_thread_info()->restart_block.fn = do_no_restart_syscall;
885 rt_sf = (struct rt_sigframe __user *)
886 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
887 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
889 if (do_setcontext(&rt_sf->uc, regs, 1))
893 * It's not clear whether or why it is desirable to save the
894 * sigaltstack setting on signal delivery and restore it on
895 * signal return. But other architectures do this and we have
896 * always done it up until now so it is probably better not to
897 * change it. -- paulus
901 * We use the compat_sys_ version that does the 32/64 bits conversion
902 * and takes userland pointer directly. What about error checking ?
905 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
907 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
909 set_thread_flag(TIF_RESTOREALL);
913 force_sig(SIGSEGV, current);
918 int sys_debug_setcontext(struct ucontext __user *ctx,
919 int ndbg, struct sig_dbg_op __user *dbg,
920 int r6, int r7, int r8,
921 struct pt_regs *regs)
923 struct sig_dbg_op op;
925 unsigned long new_msr = regs->msr;
926 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
927 unsigned long new_dbcr0 = current->thread.dbcr0;
930 for (i=0; i<ndbg; i++) {
931 if (__copy_from_user(&op, dbg, sizeof(op)))
933 switch (op.dbg_type) {
934 case SIG_DBG_SINGLE_STEPPING:
935 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
938 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
941 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
950 case SIG_DBG_BRANCH_TRACING:
951 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
966 /* We wait until here to actually install the values in the
967 registers so if we fail in the above loop, it will not
968 affect the contents of these registers. After this point,
969 failure is a problem, anyway, and it's very unlikely unless
970 the user is really doing something wrong. */
972 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
973 current->thread.dbcr0 = new_dbcr0;
977 * If we get a fault copying the context into the kernel's
978 * image of the user's registers, we can't just return -EFAULT
979 * because the user's registers will be corrupted. For instance
980 * the NIP value may have been updated but not some of the
981 * other registers. Given that we have done the access_ok
982 * and successfully read the first and last bytes of the region
983 * above, this should only happen in an out-of-memory situation
984 * or if another thread unmaps the region containing the context.
985 * We kill the task with a SIGSEGV in this situation.
987 if (do_setcontext(ctx, regs, 1)) {
988 force_sig(SIGSEGV, current);
993 * It's not clear whether or why it is desirable to save the
994 * sigaltstack setting on signal delivery and restore it on
995 * signal return. But other architectures do this and we have
996 * always done it up until now so it is probably better not to
997 * change it. -- paulus
999 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1001 set_thread_flag(TIF_RESTOREALL);
1008 * OK, we're invoking a handler
1010 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1011 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1012 unsigned long newsp)
1014 struct sigcontext __user *sc;
1015 struct sigregs __user *frame;
1016 unsigned long origsp = newsp;
1018 /* Set up Signal Frame */
1019 newsp -= sizeof(struct sigregs);
1020 frame = (struct sigregs __user *) newsp;
1022 /* Put a sigcontext on the stack */
1023 newsp -= sizeof(*sc);
1024 sc = (struct sigcontext __user *) newsp;
1026 /* create a stack frame for the caller of the handler */
1027 newsp -= __SIGNAL_FRAMESIZE;
1029 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1033 #error "Please adjust handle_signal()"
1035 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1036 || __put_user(oldset->sig[0], &sc->oldmask)
1038 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1040 || __put_user(oldset->sig[1], &sc->_unused[3])
1042 || __put_user(to_user_ptr(frame), &sc->regs)
1043 || __put_user(sig, &sc->signal))
1046 if (vdso32_sigtramp && current->thread.vdso_base) {
1047 if (save_user_regs(regs, &frame->mctx, 0))
1049 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1051 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1053 regs->link = (unsigned long) frame->mctx.tramp;
1056 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1058 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1060 regs->gpr[1] = newsp;
1062 regs->gpr[4] = (unsigned long) sc;
1063 regs->nip = (unsigned long) ka->sa.sa_handler;
1070 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1071 regs, frame, newsp);
1073 force_sigsegv(sig, current);
1078 * Do a signal return; undo the signal stack.
1080 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1081 struct pt_regs *regs)
1083 struct sigcontext __user *sc;
1084 struct sigcontext sigctx;
1085 struct mcontext __user *sr;
1088 /* Always make any pending restarted system calls return -EINTR */
1089 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1091 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1092 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1097 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1098 * unused part of the signal stackframe
1100 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1102 set.sig[0] = sigctx.oldmask;
1103 set.sig[1] = sigctx._unused[3];
1105 restore_sigmask(&set);
1107 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1108 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1109 || restore_user_regs(regs, sr, 1))
1112 set_thread_flag(TIF_RESTOREALL);
1116 force_sig(SIGSEGV, current);
1121 * Note that 'init' is a special process: it doesn't get signals it doesn't
1122 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1125 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1128 struct k_sigaction ka;
1133 if (try_to_freeze()) {
1135 if (!signal_pending(current))
1140 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1141 oldset = ¤t->saved_sigmask;
1143 oldset = ¤t->blocked;
1145 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1149 if (TRAP(regs) == 0x0C00 /* System Call! */
1150 && regs->ccr & 0x10000000 /* error signalled */
1151 && ((ret = regs->gpr[3]) == ERESTARTSYS
1152 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1153 || ret == ERESTART_RESTARTBLOCK)) {
1156 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1157 || (ret == ERESTARTSYS
1158 && !(ka.sa.sa_flags & SA_RESTART)))) {
1159 /* make the system call return an EINTR error */
1160 regs->result = -EINTR;
1161 regs->gpr[3] = EINTR;
1162 /* note that the cr0.SO bit is already set */
1164 regs->nip -= 4; /* Back up & retry system call */
1167 if (ret == ERESTART_RESTARTBLOCK)
1168 regs->gpr[0] = __NR_restart_syscall;
1170 regs->gpr[3] = regs->orig_gpr3;
1175 /* No signal to deliver -- put the saved sigmask back */
1176 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1177 clear_thread_flag(TIF_RESTORE_SIGMASK);
1178 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
1180 return 0; /* no signals delivered */
1183 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1184 && !on_sig_stack(regs->gpr[1]))
1185 newsp = current->sas_ss_sp + current->sas_ss_size;
1187 newsp = regs->gpr[1];
1192 * Reenable the DABR before delivering the signal to
1193 * user space. The DABR will have been cleared if it
1194 * triggered inside the kernel.
1196 if (current->thread.dabr)
1197 set_dabr(current->thread.dabr);
1200 /* Whee! Actually deliver the signal. */
1201 if (ka.sa.sa_flags & SA_SIGINFO)
1202 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1204 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1207 spin_lock_irq(¤t->sighand->siglock);
1208 sigorsets(¤t->blocked, ¤t->blocked,
1210 if (!(ka.sa.sa_flags & SA_NODEFER))
1211 sigaddset(¤t->blocked, signr);
1212 recalc_sigpending();
1213 spin_unlock_irq(¤t->sighand->siglock);
1214 /* A signal was successfully delivered; the saved sigmask is in
1215 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
1216 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1217 clear_thread_flag(TIF_RESTORE_SIGMASK);