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 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
225 static inline int restore_general_regs(struct pt_regs *regs,
226 struct mcontext __user *sr)
228 /* copy up to but not including MSR */
229 if (__copy_from_user(regs, &sr->mc_gregs,
230 PT_MSR * sizeof(elf_greg_t)))
232 /* copy from orig_r3 (the word after the MSR) up to the end */
233 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
234 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
239 #endif /* CONFIG_PPC64 */
241 int do_signal(sigset_t *oldset, struct pt_regs *regs);
244 * Atomically swap in the new signal mask, and wait for a signal.
246 long sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
247 struct pt_regs *regs)
252 spin_lock_irq(¤t->sighand->siglock);
253 saveset = current->blocked;
254 siginitset(¤t->blocked, mask);
256 spin_unlock_irq(¤t->sighand->siglock);
258 regs->result = -EINTR;
259 regs->gpr[3] = EINTR;
260 regs->ccr |= 0x10000000;
262 current->state = TASK_INTERRUPTIBLE;
264 if (do_signal(&saveset, regs)) {
265 set_thread_flag(TIF_RESTOREALL);
271 long sys_rt_sigsuspend(
273 compat_sigset_t __user *unewset,
275 sigset_t __user *unewset,
277 size_t sigsetsize, int p3, int p4,
278 int p6, int p7, struct pt_regs *regs)
280 sigset_t saveset, newset;
282 /* XXX: Don't preclude handling different sized sigset_t's. */
283 if (sigsetsize != sizeof(sigset_t))
286 if (get_sigset_t(&newset, unewset))
288 sigdelsetmask(&newset, ~_BLOCKABLE);
290 spin_lock_irq(¤t->sighand->siglock);
291 saveset = current->blocked;
292 current->blocked = newset;
294 spin_unlock_irq(¤t->sighand->siglock);
296 regs->result = -EINTR;
297 regs->gpr[3] = EINTR;
298 regs->ccr |= 0x10000000;
300 current->state = TASK_INTERRUPTIBLE;
302 if (do_signal(&saveset, regs)) {
303 set_thread_flag(TIF_RESTOREALL);
310 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
311 int r6, int r7, int r8, struct pt_regs *regs)
313 return do_sigaltstack(uss, uoss, regs->gpr[1]);
317 long sys_sigaction(int sig, struct old_sigaction __user *act,
318 struct old_sigaction __user *oact)
320 struct k_sigaction new_ka, old_ka;
329 if (get_old_sigaction(&new_ka, act))
333 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
335 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
336 __put_user(to_user_ptr(old_ka.sa.sa_handler),
337 &oact->sa_handler) ||
338 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
339 &oact->sa_restorer) ||
340 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
341 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
349 * When we have signals to deliver, we set up on the
350 * user stack, going down from the original stack pointer:
352 * a sigcontext struct
353 * a gap of __SIGNAL_FRAMESIZE bytes
355 * Each of these things must be a multiple of 16 bytes in size.
359 struct mcontext mctx; /* all the register values */
361 * Programs using the rs6000/xcoff abi can save up to 19 gp
362 * regs and 18 fp regs below sp before decrementing it.
367 /* We use the mc_pad field for the signal return trampoline. */
371 * When we have rt signals to deliver, we set up on the
372 * user stack, going down from the original stack pointer:
373 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
374 * a gap of __SIGNAL_FRAMESIZE+16 bytes
375 * (the +16 is to get the siginfo and ucontext in the same
376 * positions as in older kernels).
378 * Each of these things must be a multiple of 16 bytes in size.
383 compat_siginfo_t info;
389 * Programs using the rs6000/xcoff abi can save up to 19 gp
390 * regs and 18 fp regs below sp before decrementing it.
396 * Save the current user registers on the user stack.
397 * We only save the altivec/spe registers if the process has used
398 * altivec/spe instructions at some point.
400 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
403 /* Make sure floating point registers are stored in regs */
404 flush_fp_to_thread(current);
406 /* save general and floating-point registers */
407 if (save_general_regs(regs, frame) ||
408 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
409 ELF_NFPREG * sizeof(double)))
412 #ifdef CONFIG_ALTIVEC
413 /* save altivec registers */
414 if (current->thread.used_vr) {
415 flush_altivec_to_thread(current);
416 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
417 ELF_NVRREG * sizeof(vector128)))
419 /* set MSR_VEC in the saved MSR value to indicate that
420 frame->mc_vregs contains valid data */
421 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
424 /* else assert((regs->msr & MSR_VEC) == 0) */
426 /* We always copy to/from vrsave, it's 0 if we don't have or don't
427 * use altivec. Since VSCR only contains 32 bits saved in the least
428 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
429 * most significant bits of that same vector. --BenH
431 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
433 #endif /* CONFIG_ALTIVEC */
436 /* save spe registers */
437 if (current->thread.used_spe) {
438 flush_spe_to_thread(current);
439 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
440 ELF_NEVRREG * sizeof(u32)))
442 /* set MSR_SPE in the saved MSR value to indicate that
443 frame->mc_vregs contains valid data */
444 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
447 /* else assert((regs->msr & MSR_SPE) == 0) */
449 /* We always copy to/from spefscr */
450 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
452 #endif /* CONFIG_SPE */
455 /* Set up the sigreturn trampoline: li r0,sigret; sc */
456 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
457 || __put_user(0x44000002UL, &frame->tramp[1]))
459 flush_icache_range((unsigned long) &frame->tramp[0],
460 (unsigned long) &frame->tramp[2]);
467 * Restore the current user register values from the user stack,
470 static long restore_user_regs(struct pt_regs *regs,
471 struct mcontext __user *sr, int sig)
474 unsigned int save_r2 = 0;
475 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
480 * restore general registers but not including MSR or SOFTE. Also
481 * take care of keeping r2 (TLS) intact if not a signal
484 save_r2 = (unsigned int)regs->gpr[2];
485 err = restore_general_regs(regs, sr);
487 regs->gpr[2] = (unsigned long) save_r2;
491 /* force the process to reload the FP registers from
492 current->thread when it next does FP instructions */
493 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
494 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
495 sizeof(sr->mc_fregs)))
498 #ifdef CONFIG_ALTIVEC
499 /* force the process to reload the altivec registers from
500 current->thread when it next does altivec instructions */
501 regs->msr &= ~MSR_VEC;
502 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
503 /* restore altivec registers from the stack */
504 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
505 sizeof(sr->mc_vregs)))
507 } else if (current->thread.used_vr)
508 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
510 /* Always get VRSAVE back */
511 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
513 #endif /* CONFIG_ALTIVEC */
516 /* force the process to reload the spe registers from
517 current->thread when it next does spe instructions */
518 regs->msr &= ~MSR_SPE;
519 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
520 /* restore spe registers from the stack */
521 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
522 ELF_NEVRREG * sizeof(u32)))
524 } else if (current->thread.used_spe)
525 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
527 /* Always get SPEFSCR back */
528 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
530 #endif /* CONFIG_SPE */
534 if (last_task_used_math == current)
535 last_task_used_math = NULL;
536 if (last_task_used_altivec == current)
537 last_task_used_altivec = NULL;
539 if (last_task_used_spe == current)
540 last_task_used_spe = NULL;
548 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
549 struct sigaction32 __user *oact, size_t sigsetsize)
551 struct k_sigaction new_ka, old_ka;
554 /* XXX: Don't preclude handling different sized sigset_t's. */
555 if (sigsetsize != sizeof(compat_sigset_t))
559 compat_uptr_t handler;
561 ret = get_user(handler, &act->sa_handler);
562 new_ka.sa.sa_handler = compat_ptr(handler);
563 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
564 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
569 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
571 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
572 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
573 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
579 * Note: it is necessary to treat how as an unsigned int, with the
580 * corresponding cast to a signed int to insure that the proper
581 * conversion (sign extension) between the register representation
582 * of a signed int (msr in 32-bit mode) and the register representation
583 * of a signed int (msr in 64-bit mode) is performed.
585 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
586 compat_sigset_t __user *oset, size_t sigsetsize)
591 mm_segment_t old_fs = get_fs();
594 if (get_sigset_t(&s, set))
599 /* This is valid because of the set_fs() */
600 up = (sigset_t __user *) &s;
601 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
607 if (put_sigset_t(oset, &s))
613 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
617 mm_segment_t old_fs = get_fs();
620 /* The __user pointer cast is valid because of the set_fs() */
621 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
624 if (put_sigset_t(set, &s))
631 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
635 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
638 /* If you change siginfo_t structure, please be sure
639 * this code is fixed accordingly.
640 * It should never copy any pad contained in the structure
641 * to avoid security leaks, but must copy the generic
642 * 3 ints plus the relevant union member.
643 * This routine must convert siginfo from 64bit to 32bit as well
646 err = __put_user(s->si_signo, &d->si_signo);
647 err |= __put_user(s->si_errno, &d->si_errno);
648 err |= __put_user((short)s->si_code, &d->si_code);
650 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
652 else switch(s->si_code >> 16) {
653 case __SI_CHLD >> 16:
654 err |= __put_user(s->si_pid, &d->si_pid);
655 err |= __put_user(s->si_uid, &d->si_uid);
656 err |= __put_user(s->si_utime, &d->si_utime);
657 err |= __put_user(s->si_stime, &d->si_stime);
658 err |= __put_user(s->si_status, &d->si_status);
660 case __SI_FAULT >> 16:
661 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
664 case __SI_POLL >> 16:
665 err |= __put_user(s->si_band, &d->si_band);
666 err |= __put_user(s->si_fd, &d->si_fd);
668 case __SI_TIMER >> 16:
669 err |= __put_user(s->si_tid, &d->si_tid);
670 err |= __put_user(s->si_overrun, &d->si_overrun);
671 err |= __put_user(s->si_int, &d->si_int);
673 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
674 case __SI_MESGQ >> 16:
675 err |= __put_user(s->si_int, &d->si_int);
677 case __SI_KILL >> 16:
679 err |= __put_user(s->si_pid, &d->si_pid);
680 err |= __put_user(s->si_uid, &d->si_uid);
686 #define copy_siginfo_to_user copy_siginfo_to_user32
689 * Note: it is necessary to treat pid and sig as unsigned ints, with the
690 * corresponding cast to a signed int to insure that the proper conversion
691 * (sign extension) between the register representation of a signed int
692 * (msr in 32-bit mode) and the register representation of a signed int
693 * (msr in 64-bit mode) is performed.
695 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
699 mm_segment_t old_fs = get_fs();
701 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
702 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
705 /* The __user pointer cast is valid becasuse of the set_fs() */
706 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
711 * Start Alternate signal stack support
714 * sigaltatck compat_sys_sigaltstack
717 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
718 int r6, int r7, int r8, struct pt_regs *regs)
720 stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
721 stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
729 * set sp to the user stack on entry to the system call
730 * the system call router sets R9 to the saved registers
734 /* Put new stack info in local 64 bit stack struct */
736 if (get_user(ss_sp, &newstack->ss_sp) ||
737 __get_user(uss.ss_flags, &newstack->ss_flags) ||
738 __get_user(uss.ss_size, &newstack->ss_size))
740 uss.ss_sp = compat_ptr(ss_sp);
745 /* The __user pointer casts are valid because of the set_fs() */
746 ret = do_sigaltstack(
747 newstack ? (stack_t __user *) &uss : NULL,
748 oldstack ? (stack_t __user *) &uoss : NULL,
751 /* Copy the stack information to the user output buffer */
752 if (!ret && oldstack &&
753 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
754 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
755 __put_user(uoss.ss_size, &oldstack->ss_size)))
759 #endif /* CONFIG_PPC64 */
763 * Restore the user process's signal mask
766 extern void restore_sigmask(sigset_t *set);
767 #else /* CONFIG_PPC64 */
768 static void restore_sigmask(sigset_t *set)
770 sigdelsetmask(set, ~_BLOCKABLE);
771 spin_lock_irq(¤t->sighand->siglock);
772 current->blocked = *set;
774 spin_unlock_irq(¤t->sighand->siglock);
779 * Set up a signal frame for a "real-time" signal handler
780 * (one which gets siginfo).
782 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
783 siginfo_t *info, sigset_t *oldset,
784 struct pt_regs *regs, unsigned long newsp)
786 struct rt_sigframe __user *rt_sf;
787 struct mcontext __user *frame;
788 unsigned long origsp = newsp;
790 /* Set up Signal Frame */
791 /* Put a Real Time Context onto stack */
792 newsp -= sizeof(*rt_sf);
793 rt_sf = (struct rt_sigframe __user *)newsp;
795 /* create a stack frame for the caller of the handler */
796 newsp -= __SIGNAL_FRAMESIZE + 16;
798 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
801 /* Put the siginfo & fill in most of the ucontext */
802 if (copy_siginfo_to_user(&rt_sf->info, info)
803 || __put_user(0, &rt_sf->uc.uc_flags)
804 || __put_user(0, &rt_sf->uc.uc_link)
805 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
806 || __put_user(sas_ss_flags(regs->gpr[1]),
807 &rt_sf->uc.uc_stack.ss_flags)
808 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
809 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
811 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
814 /* Save user registers on the stack */
815 frame = &rt_sf->uc.uc_mcontext;
816 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
817 if (save_user_regs(regs, frame, 0))
819 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
821 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
823 regs->link = (unsigned long) frame->tramp;
826 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
828 if (put_user(regs->gpr[1], (u32 __user *)newsp))
830 regs->gpr[1] = newsp;
832 regs->gpr[4] = (unsigned long) &rt_sf->info;
833 regs->gpr[5] = (unsigned long) &rt_sf->uc;
834 regs->gpr[6] = (unsigned long) rt_sf;
835 regs->nip = (unsigned long) ka->sa.sa_handler;
841 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
844 force_sigsegv(sig, current);
848 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
851 struct mcontext __user *mcp;
853 if (get_sigset_t(&set, &ucp->uc_sigmask))
859 if (__get_user(cmcp, &ucp->uc_regs))
861 mcp = (struct mcontext __user *)(u64)cmcp;
864 if (__get_user(mcp, &ucp->uc_regs))
867 restore_sigmask(&set);
868 if (restore_user_regs(regs, mcp, sig))
874 long sys_swapcontext(struct ucontext __user *old_ctx,
875 struct ucontext __user *new_ctx,
876 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
880 /* Context size is for future use. Right now, we only make sure
881 * we are passed something we understand
883 if (ctx_size < sizeof(struct ucontext))
886 if (old_ctx != NULL) {
887 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
888 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
889 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
890 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
896 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
897 || __get_user(tmp, (u8 __user *) new_ctx)
898 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
902 * If we get a fault copying the context into the kernel's
903 * image of the user's registers, we can't just return -EFAULT
904 * because the user's registers will be corrupted. For instance
905 * the NIP value may have been updated but not some of the
906 * other registers. Given that we have done the access_ok
907 * and successfully read the first and last bytes of the region
908 * above, this should only happen in an out-of-memory situation
909 * or if another thread unmaps the region containing the context.
910 * We kill the task with a SIGSEGV in this situation.
912 if (do_setcontext(new_ctx, regs, 0))
915 set_thread_flag(TIF_RESTOREALL);
919 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
920 struct pt_regs *regs)
922 struct rt_sigframe __user *rt_sf;
924 /* Always make any pending restarted system calls return -EINTR */
925 current_thread_info()->restart_block.fn = do_no_restart_syscall;
927 rt_sf = (struct rt_sigframe __user *)
928 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
929 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
931 if (do_setcontext(&rt_sf->uc, regs, 1))
935 * It's not clear whether or why it is desirable to save the
936 * sigaltstack setting on signal delivery and restore it on
937 * signal return. But other architectures do this and we have
938 * always done it up until now so it is probably better not to
939 * change it. -- paulus
943 * We use the compat_sys_ version that does the 32/64 bits conversion
944 * and takes userland pointer directly. What about error checking ?
947 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
949 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
951 set_thread_flag(TIF_RESTOREALL);
955 force_sig(SIGSEGV, current);
960 int sys_debug_setcontext(struct ucontext __user *ctx,
961 int ndbg, struct sig_dbg_op __user *dbg,
962 int r6, int r7, int r8,
963 struct pt_regs *regs)
965 struct sig_dbg_op op;
967 unsigned long new_msr = regs->msr;
968 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
969 unsigned long new_dbcr0 = current->thread.dbcr0;
972 for (i=0; i<ndbg; i++) {
973 if (__copy_from_user(&op, dbg, sizeof(op)))
975 switch (op.dbg_type) {
976 case SIG_DBG_SINGLE_STEPPING:
977 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
980 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
983 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
992 case SIG_DBG_BRANCH_TRACING:
993 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1008 /* We wait until here to actually install the values in the
1009 registers so if we fail in the above loop, it will not
1010 affect the contents of these registers. After this point,
1011 failure is a problem, anyway, and it's very unlikely unless
1012 the user is really doing something wrong. */
1013 regs->msr = new_msr;
1014 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1015 current->thread.dbcr0 = new_dbcr0;
1019 * If we get a fault copying the context into the kernel's
1020 * image of the user's registers, we can't just return -EFAULT
1021 * because the user's registers will be corrupted. For instance
1022 * the NIP value may have been updated but not some of the
1023 * other registers. Given that we have done the access_ok
1024 * and successfully read the first and last bytes of the region
1025 * above, this should only happen in an out-of-memory situation
1026 * or if another thread unmaps the region containing the context.
1027 * We kill the task with a SIGSEGV in this situation.
1029 if (do_setcontext(ctx, regs, 1)) {
1030 force_sig(SIGSEGV, current);
1035 * It's not clear whether or why it is desirable to save the
1036 * sigaltstack setting on signal delivery and restore it on
1037 * signal return. But other architectures do this and we have
1038 * always done it up until now so it is probably better not to
1039 * change it. -- paulus
1041 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1043 set_thread_flag(TIF_RESTOREALL);
1050 * OK, we're invoking a handler
1052 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1053 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1054 unsigned long newsp)
1056 struct sigcontext __user *sc;
1057 struct sigregs __user *frame;
1058 unsigned long origsp = newsp;
1060 /* Set up Signal Frame */
1061 newsp -= sizeof(struct sigregs);
1062 frame = (struct sigregs __user *) newsp;
1064 /* Put a sigcontext on the stack */
1065 newsp -= sizeof(*sc);
1066 sc = (struct sigcontext __user *) newsp;
1068 /* create a stack frame for the caller of the handler */
1069 newsp -= __SIGNAL_FRAMESIZE;
1071 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1075 #error "Please adjust handle_signal()"
1077 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1078 || __put_user(oldset->sig[0], &sc->oldmask)
1080 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1082 || __put_user(oldset->sig[1], &sc->_unused[3])
1084 || __put_user(to_user_ptr(frame), &sc->regs)
1085 || __put_user(sig, &sc->signal))
1088 if (vdso32_sigtramp && current->thread.vdso_base) {
1089 if (save_user_regs(regs, &frame->mctx, 0))
1091 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1093 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1095 regs->link = (unsigned long) frame->mctx.tramp;
1098 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1100 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1102 regs->gpr[1] = newsp;
1104 regs->gpr[4] = (unsigned long) sc;
1105 regs->nip = (unsigned long) ka->sa.sa_handler;
1112 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1113 regs, frame, newsp);
1115 force_sigsegv(sig, current);
1120 * Do a signal return; undo the signal stack.
1122 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1123 struct pt_regs *regs)
1125 struct sigcontext __user *sc;
1126 struct sigcontext sigctx;
1127 struct mcontext __user *sr;
1130 /* Always make any pending restarted system calls return -EINTR */
1131 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1133 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1134 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1139 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1140 * unused part of the signal stackframe
1142 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1144 set.sig[0] = sigctx.oldmask;
1145 set.sig[1] = sigctx._unused[3];
1147 restore_sigmask(&set);
1149 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1150 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1151 || restore_user_regs(regs, sr, 1))
1154 set_thread_flag(TIF_RESTOREALL);
1158 force_sig(SIGSEGV, current);
1163 * Note that 'init' is a special process: it doesn't get signals it doesn't
1164 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1167 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1170 struct k_sigaction ka;
1171 unsigned int frame, newsp;
1175 if (try_to_freeze()) {
1177 if (!signal_pending(current))
1183 oldset = ¤t->blocked;
1187 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1191 if (TRAP(regs) == 0x0C00 /* System Call! */
1192 && regs->ccr & 0x10000000 /* error signalled */
1193 && ((ret = regs->gpr[3]) == ERESTARTSYS
1194 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1195 || ret == ERESTART_RESTARTBLOCK)) {
1198 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1199 || (ret == ERESTARTSYS
1200 && !(ka.sa.sa_flags & SA_RESTART)))) {
1201 /* make the system call return an EINTR error */
1202 regs->result = -EINTR;
1203 regs->gpr[3] = EINTR;
1204 /* note that the cr0.SO bit is already set */
1206 regs->nip -= 4; /* Back up & retry system call */
1209 if (ret == ERESTART_RESTARTBLOCK)
1210 regs->gpr[0] = __NR_restart_syscall;
1212 regs->gpr[3] = regs->orig_gpr3;
1217 return 0; /* no signals delivered */
1219 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1220 && !on_sig_stack(regs->gpr[1]))
1221 newsp = current->sas_ss_sp + current->sas_ss_size;
1223 newsp = regs->gpr[1];
1228 * Reenable the DABR before delivering the signal to
1229 * user space. The DABR will have been cleared if it
1230 * triggered inside the kernel.
1232 if (current->thread.dabr)
1233 set_dabr(current->thread.dabr);
1236 /* Whee! Actually deliver the signal. */
1237 if (ka.sa.sa_flags & SA_SIGINFO)
1238 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1240 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1243 spin_lock_irq(¤t->sighand->siglock);
1244 sigorsets(¤t->blocked, ¤t->blocked,
1246 if (!(ka.sa.sa_flags & SA_NODEFER))
1247 sigaddset(¤t->blocked, signr);
1248 recalc_sigpending();
1249 spin_unlock_irq(¤t->sighand->siglock);