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>
47 #include <asm/unistd.h>
50 #include <asm/ucontext.h>
51 #include <asm/pgtable.h>
56 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
59 #define do_signal do_signal32
60 #define sys_sigsuspend compat_sys_sigsuspend
61 #define sys_rt_sigsuspend compat_sys_rt_sigsuspend
62 #define sys_rt_sigreturn compat_sys_rt_sigreturn
63 #define sys_sigaction compat_sys_sigaction
64 #define sys_swapcontext compat_sys_swapcontext
65 #define sys_sigreturn compat_sys_sigreturn
67 #define old_sigaction old_sigaction32
68 #define sigcontext sigcontext32
69 #define mcontext mcontext32
70 #define ucontext ucontext32
73 * Returning 0 means we return to userspace via
74 * ret_from_except and thus restore all user
75 * registers from *regs. This is what we need
76 * to do when a signal has been delivered.
78 #define sigreturn_exit(regs) return 0
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 for (i = 0; i <= PT_RESULT; i ++)
159 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
164 static inline int restore_general_regs(struct pt_regs *regs,
165 struct mcontext __user *sr)
167 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
170 for (i = 0; i <= PT_RESULT; i++) {
171 if ((i == PT_MSR) || (i == PT_SOFTE))
173 if (__get_user(gregs[i], &sr->mc_gregs[i]))
179 #else /* CONFIG_PPC64 */
181 extern void sigreturn_exit(struct pt_regs *);
183 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
185 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
187 return copy_to_user(uset, set, sizeof(*uset));
190 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
192 return copy_from_user(set, uset, sizeof(*uset));
195 static inline int get_old_sigaction(struct k_sigaction *new_ka,
196 struct old_sigaction __user *act)
200 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
201 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
202 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
204 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
205 __get_user(mask, &act->sa_mask);
206 siginitset(&new_ka->sa.sa_mask, mask);
210 #define to_user_ptr(p) (p)
211 #define from_user_ptr(p) (p)
213 static inline int save_general_regs(struct pt_regs *regs,
214 struct mcontext __user *frame)
216 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
219 static inline int restore_general_regs(struct pt_regs *regs,
220 struct mcontext __user *sr)
222 /* copy up to but not including MSR */
223 if (__copy_from_user(regs, &sr->mc_gregs,
224 PT_MSR * sizeof(elf_greg_t)))
226 /* copy from orig_r3 (the word after the MSR) up to the end */
227 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
228 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
233 #endif /* CONFIG_PPC64 */
235 int do_signal(sigset_t *oldset, struct pt_regs *regs);
238 * Atomically swap in the new signal mask, and wait for a signal.
240 long sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
241 struct pt_regs *regs)
246 spin_lock_irq(¤t->sighand->siglock);
247 saveset = current->blocked;
248 siginitset(¤t->blocked, mask);
250 spin_unlock_irq(¤t->sighand->siglock);
252 regs->result = -EINTR;
253 regs->gpr[3] = EINTR;
254 regs->ccr |= 0x10000000;
256 current->state = TASK_INTERRUPTIBLE;
258 if (do_signal(&saveset, regs))
259 sigreturn_exit(regs);
263 long sys_rt_sigsuspend(
265 compat_sigset_t __user *unewset,
267 sigset_t __user *unewset,
269 size_t sigsetsize, int p3, int p4,
270 int p6, int p7, struct pt_regs *regs)
272 sigset_t saveset, newset;
274 /* XXX: Don't preclude handling different sized sigset_t's. */
275 if (sigsetsize != sizeof(sigset_t))
278 if (get_sigset_t(&newset, unewset))
280 sigdelsetmask(&newset, ~_BLOCKABLE);
282 spin_lock_irq(¤t->sighand->siglock);
283 saveset = current->blocked;
284 current->blocked = newset;
286 spin_unlock_irq(¤t->sighand->siglock);
288 regs->result = -EINTR;
289 regs->gpr[3] = EINTR;
290 regs->ccr |= 0x10000000;
292 current->state = TASK_INTERRUPTIBLE;
294 if (do_signal(&saveset, regs))
295 sigreturn_exit(regs);
300 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
301 int r6, int r7, int r8, struct pt_regs *regs)
303 return do_sigaltstack(uss, uoss, regs->gpr[1]);
307 long sys_sigaction(int sig, struct old_sigaction __user *act,
308 struct old_sigaction __user *oact)
310 struct k_sigaction new_ka, old_ka;
319 if (get_old_sigaction(&new_ka, act))
323 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
325 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
326 __put_user(to_user_ptr(old_ka.sa.sa_handler),
327 &oact->sa_handler) ||
328 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
329 &oact->sa_restorer) ||
330 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
331 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
339 * When we have signals to deliver, we set up on the
340 * user stack, going down from the original stack pointer:
342 * a sigcontext struct
343 * a gap of __SIGNAL_FRAMESIZE bytes
345 * Each of these things must be a multiple of 16 bytes in size.
349 struct mcontext mctx; /* all the register values */
351 * Programs using the rs6000/xcoff abi can save up to 19 gp
352 * regs and 18 fp regs below sp before decrementing it.
357 /* We use the mc_pad field for the signal return trampoline. */
361 * When we have rt signals to deliver, we set up on the
362 * user stack, going down from the original stack pointer:
363 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
364 * a gap of __SIGNAL_FRAMESIZE+16 bytes
365 * (the +16 is to get the siginfo and ucontext in the same
366 * positions as in older kernels).
368 * Each of these things must be a multiple of 16 bytes in size.
373 compat_siginfo_t info;
379 * Programs using the rs6000/xcoff abi can save up to 19 gp
380 * regs and 18 fp regs below sp before decrementing it.
386 * Save the current user registers on the user stack.
387 * We only save the altivec/spe registers if the process has used
388 * altivec/spe instructions at some point.
390 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
394 CHECK_FULL_REGS(regs);
396 /* Make sure floating point registers are stored in regs */
397 flush_fp_to_thread(current);
399 /* save general and floating-point registers */
400 if (save_general_regs(regs, frame) ||
401 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
402 ELF_NFPREG * sizeof(double)))
405 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
407 #ifdef CONFIG_ALTIVEC
408 /* save altivec registers */
409 if (current->thread.used_vr) {
410 flush_altivec_to_thread(current);
411 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
412 ELF_NVRREG * sizeof(vector128)))
414 /* set MSR_VEC in the saved MSR value to indicate that
415 frame->mc_vregs contains valid data */
416 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
419 /* else assert((regs->msr & MSR_VEC) == 0) */
421 /* We always copy to/from vrsave, it's 0 if we don't have or don't
422 * use altivec. Since VSCR only contains 32 bits saved in the least
423 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
424 * most significant bits of that same vector. --BenH
426 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
428 #endif /* CONFIG_ALTIVEC */
431 /* save spe registers */
432 if (current->thread.used_spe) {
433 flush_spe_to_thread(current);
434 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
435 ELF_NEVRREG * sizeof(u32)))
437 /* set MSR_SPE in the saved MSR value to indicate that
438 frame->mc_vregs contains valid data */
439 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
442 /* else assert((regs->msr & MSR_SPE) == 0) */
444 /* We always copy to/from spefscr */
445 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
447 #endif /* CONFIG_SPE */
450 /* Set up the sigreturn trampoline: li r0,sigret; sc */
451 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
452 || __put_user(0x44000002UL, &frame->tramp[1]))
454 flush_icache_range((unsigned long) &frame->tramp[0],
455 (unsigned long) &frame->tramp[2]);
462 * Restore the current user register values from the user stack,
465 static long restore_user_regs(struct pt_regs *regs,
466 struct mcontext __user *sr, int sig)
469 unsigned int save_r2 = 0;
470 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
475 * restore general registers but not including MSR or SOFTE. Also
476 * take care of keeping r2 (TLS) intact if not a signal
479 save_r2 = (unsigned int)regs->gpr[2];
480 err = restore_general_regs(regs, sr);
482 regs->gpr[2] = (unsigned long) save_r2;
486 /* force the process to reload the FP registers from
487 current->thread when it next does FP instructions */
488 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
489 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
490 sizeof(sr->mc_fregs)))
493 #ifdef CONFIG_ALTIVEC
494 /* force the process to reload the altivec registers from
495 current->thread when it next does altivec instructions */
496 regs->msr &= ~MSR_VEC;
497 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
498 /* restore altivec registers from the stack */
499 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
500 sizeof(sr->mc_vregs)))
502 } else if (current->thread.used_vr)
503 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
505 /* Always get VRSAVE back */
506 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
508 #endif /* CONFIG_ALTIVEC */
511 /* force the process to reload the spe registers from
512 current->thread when it next does spe instructions */
513 regs->msr &= ~MSR_SPE;
514 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
515 /* restore spe registers from the stack */
516 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
517 ELF_NEVRREG * sizeof(u32)))
519 } else if (current->thread.used_spe)
520 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
522 /* Always get SPEFSCR back */
523 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
525 #endif /* CONFIG_SPE */
529 if (last_task_used_math == current)
530 last_task_used_math = NULL;
531 if (last_task_used_altivec == current)
532 last_task_used_altivec = NULL;
534 if (last_task_used_spe == current)
535 last_task_used_spe = NULL;
543 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
544 struct sigaction32 __user *oact, size_t sigsetsize)
546 struct k_sigaction new_ka, old_ka;
549 /* XXX: Don't preclude handling different sized sigset_t's. */
550 if (sigsetsize != sizeof(compat_sigset_t))
554 compat_uptr_t handler;
556 ret = get_user(handler, &act->sa_handler);
557 new_ka.sa.sa_handler = compat_ptr(handler);
558 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
559 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
564 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
566 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
567 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
568 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
574 * Note: it is necessary to treat how as an unsigned int, with the
575 * corresponding cast to a signed int to insure that the proper
576 * conversion (sign extension) between the register representation
577 * of a signed int (msr in 32-bit mode) and the register representation
578 * of a signed int (msr in 64-bit mode) is performed.
580 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
581 compat_sigset_t __user *oset, size_t sigsetsize)
586 mm_segment_t old_fs = get_fs();
589 if (get_sigset_t(&s, set))
594 /* This is valid because of the set_fs() */
595 up = (sigset_t __user *) &s;
596 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
602 if (put_sigset_t(oset, &s))
608 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
612 mm_segment_t old_fs = get_fs();
615 /* The __user pointer cast is valid because of the set_fs() */
616 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
619 if (put_sigset_t(set, &s))
626 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
630 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
633 /* If you change siginfo_t structure, please be sure
634 * this code is fixed accordingly.
635 * It should never copy any pad contained in the structure
636 * to avoid security leaks, but must copy the generic
637 * 3 ints plus the relevant union member.
638 * This routine must convert siginfo from 64bit to 32bit as well
641 err = __put_user(s->si_signo, &d->si_signo);
642 err |= __put_user(s->si_errno, &d->si_errno);
643 err |= __put_user((short)s->si_code, &d->si_code);
645 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
647 else switch(s->si_code >> 16) {
648 case __SI_CHLD >> 16:
649 err |= __put_user(s->si_pid, &d->si_pid);
650 err |= __put_user(s->si_uid, &d->si_uid);
651 err |= __put_user(s->si_utime, &d->si_utime);
652 err |= __put_user(s->si_stime, &d->si_stime);
653 err |= __put_user(s->si_status, &d->si_status);
655 case __SI_FAULT >> 16:
656 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
659 case __SI_POLL >> 16:
660 err |= __put_user(s->si_band, &d->si_band);
661 err |= __put_user(s->si_fd, &d->si_fd);
663 case __SI_TIMER >> 16:
664 err |= __put_user(s->si_tid, &d->si_tid);
665 err |= __put_user(s->si_overrun, &d->si_overrun);
666 err |= __put_user(s->si_int, &d->si_int);
668 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
669 case __SI_MESGQ >> 16:
670 err |= __put_user(s->si_int, &d->si_int);
672 case __SI_KILL >> 16:
674 err |= __put_user(s->si_pid, &d->si_pid);
675 err |= __put_user(s->si_uid, &d->si_uid);
681 #define copy_siginfo_to_user copy_siginfo_to_user32
684 * Note: it is necessary to treat pid and sig as unsigned ints, with the
685 * corresponding cast to a signed int to insure that the proper conversion
686 * (sign extension) between the register representation of a signed int
687 * (msr in 32-bit mode) and the register representation of a signed int
688 * (msr in 64-bit mode) is performed.
690 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
694 mm_segment_t old_fs = get_fs();
696 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
697 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
700 /* The __user pointer cast is valid becasuse of the set_fs() */
701 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
706 * Start Alternate signal stack support
709 * sigaltatck compat_sys_sigaltstack
712 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
713 int r6, int r7, int r8, struct pt_regs *regs)
715 stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
716 stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
724 * set sp to the user stack on entry to the system call
725 * the system call router sets R9 to the saved registers
729 /* Put new stack info in local 64 bit stack struct */
731 if (get_user(ss_sp, &newstack->ss_sp) ||
732 __get_user(uss.ss_flags, &newstack->ss_flags) ||
733 __get_user(uss.ss_size, &newstack->ss_size))
735 uss.ss_sp = compat_ptr(ss_sp);
740 /* The __user pointer casts are valid because of the set_fs() */
741 ret = do_sigaltstack(
742 newstack ? (stack_t __user *) &uss : NULL,
743 oldstack ? (stack_t __user *) &uoss : NULL,
746 /* Copy the stack information to the user output buffer */
747 if (!ret && oldstack &&
748 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
749 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
750 __put_user(uoss.ss_size, &oldstack->ss_size)))
754 #endif /* CONFIG_PPC64 */
758 * Restore the user process's signal mask
761 extern void restore_sigmask(sigset_t *set);
762 #else /* CONFIG_PPC64 */
763 static void restore_sigmask(sigset_t *set)
765 sigdelsetmask(set, ~_BLOCKABLE);
766 spin_lock_irq(¤t->sighand->siglock);
767 current->blocked = *set;
769 spin_unlock_irq(¤t->sighand->siglock);
774 * Set up a signal frame for a "real-time" signal handler
775 * (one which gets siginfo).
777 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
778 siginfo_t *info, sigset_t *oldset,
779 struct pt_regs *regs, unsigned long newsp)
781 struct rt_sigframe __user *rt_sf;
782 struct mcontext __user *frame;
783 unsigned long origsp = newsp;
785 /* Set up Signal Frame */
786 /* Put a Real Time Context onto stack */
787 newsp -= sizeof(*rt_sf);
788 rt_sf = (struct rt_sigframe __user *)newsp;
790 /* create a stack frame for the caller of the handler */
791 newsp -= __SIGNAL_FRAMESIZE + 16;
793 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
796 /* Put the siginfo & fill in most of the ucontext */
797 if (copy_siginfo_to_user(&rt_sf->info, info)
798 || __put_user(0, &rt_sf->uc.uc_flags)
799 || __put_user(0, &rt_sf->uc.uc_link)
800 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
801 || __put_user(sas_ss_flags(regs->gpr[1]),
802 &rt_sf->uc.uc_stack.ss_flags)
803 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
804 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
806 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
809 /* Save user registers on the stack */
810 frame = &rt_sf->uc.uc_mcontext;
812 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
813 if (save_user_regs(regs, frame, 0))
815 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
819 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
821 regs->link = (unsigned long) frame->tramp;
823 if (put_user(regs->gpr[1], (u32 __user *)newsp))
825 regs->gpr[1] = newsp;
827 regs->gpr[4] = (unsigned long) &rt_sf->info;
828 regs->gpr[5] = (unsigned long) &rt_sf->uc;
829 regs->gpr[6] = (unsigned long) rt_sf;
830 regs->nip = (unsigned long) ka->sa.sa_handler;
835 if (test_thread_flag(TIF_SINGLESTEP))
836 ptrace_notify(SIGTRAP);
842 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
845 force_sigsegv(sig, current);
849 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
852 struct mcontext __user *mcp;
854 if (get_sigset_t(&set, &ucp->uc_sigmask))
860 if (__get_user(cmcp, &ucp->uc_regs))
862 mcp = (struct mcontext __user *)(u64)cmcp;
865 if (__get_user(mcp, &ucp->uc_regs))
868 restore_sigmask(&set);
869 if (restore_user_regs(regs, mcp, sig))
875 long sys_swapcontext(struct ucontext __user *old_ctx,
876 struct ucontext __user *new_ctx,
877 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
881 /* Context size is for future use. Right now, we only make sure
882 * we are passed something we understand
884 if (ctx_size < sizeof(struct ucontext))
887 if (old_ctx != NULL) {
888 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
889 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
890 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
891 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
897 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
898 || __get_user(tmp, (u8 __user *) new_ctx)
899 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
903 * If we get a fault copying the context into the kernel's
904 * image of the user's registers, we can't just return -EFAULT
905 * because the user's registers will be corrupted. For instance
906 * the NIP value may have been updated but not some of the
907 * other registers. Given that we have done the access_ok
908 * and successfully read the first and last bytes of the region
909 * above, this should only happen in an out-of-memory situation
910 * or if another thread unmaps the region containing the context.
911 * We kill the task with a SIGSEGV in this situation.
913 if (do_setcontext(new_ctx, regs, 0))
915 sigreturn_exit(regs);
916 /* doesn't actually return back to here */
920 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
921 struct pt_regs *regs)
923 struct rt_sigframe __user *rt_sf;
925 /* Always make any pending restarted system calls return -EINTR */
926 current_thread_info()->restart_block.fn = do_no_restart_syscall;
928 rt_sf = (struct rt_sigframe __user *)
929 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
930 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
932 if (do_setcontext(&rt_sf->uc, regs, 1))
936 * It's not clear whether or why it is desirable to save the
937 * sigaltstack setting on signal delivery and restore it on
938 * signal return. But other architectures do this and we have
939 * always done it up until now so it is probably better not to
940 * change it. -- paulus
944 * We use the compat_sys_ version that does the 32/64 bits conversion
945 * and takes userland pointer directly. What about error checking ?
948 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
949 return (int)regs->result;
951 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
952 sigreturn_exit(regs); /* doesn't return here */
957 force_sig(SIGSEGV, current);
962 int sys_debug_setcontext(struct ucontext __user *ctx,
963 int ndbg, struct sig_dbg_op __user *dbg,
964 int r6, int r7, int r8,
965 struct pt_regs *regs)
967 struct sig_dbg_op op;
969 unsigned long new_msr = regs->msr;
970 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
971 unsigned long new_dbcr0 = current->thread.dbcr0;
974 for (i=0; i<ndbg; i++) {
975 if (__copy_from_user(&op, dbg, sizeof(op)))
977 switch (op.dbg_type) {
978 case SIG_DBG_SINGLE_STEPPING:
979 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
982 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
985 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
994 case SIG_DBG_BRANCH_TRACING:
995 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1010 /* We wait until here to actually install the values in the
1011 registers so if we fail in the above loop, it will not
1012 affect the contents of these registers. After this point,
1013 failure is a problem, anyway, and it's very unlikely unless
1014 the user is really doing something wrong. */
1015 regs->msr = new_msr;
1016 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1017 current->thread.dbcr0 = new_dbcr0;
1021 * If we get a fault copying the context into the kernel's
1022 * image of the user's registers, we can't just return -EFAULT
1023 * because the user's registers will be corrupted. For instance
1024 * the NIP value may have been updated but not some of the
1025 * other registers. Given that we have done the access_ok
1026 * and successfully read the first and last bytes of the region
1027 * above, this should only happen in an out-of-memory situation
1028 * or if another thread unmaps the region containing the context.
1029 * We kill the task with a SIGSEGV in this situation.
1031 if (do_setcontext(ctx, regs, 1)) {
1032 force_sig(SIGSEGV, current);
1037 * It's not clear whether or why it is desirable to save the
1038 * sigaltstack setting on signal delivery and restore it on
1039 * signal return. But other architectures do this and we have
1040 * always done it up until now so it is probably better not to
1041 * change it. -- paulus
1043 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1045 sigreturn_exit(regs);
1046 /* doesn't actually return back to here */
1054 * OK, we're invoking a handler
1056 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1057 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1058 unsigned long newsp)
1060 struct sigcontext __user *sc;
1061 struct sigregs __user *frame;
1062 unsigned long origsp = newsp;
1064 /* Set up Signal Frame */
1065 newsp -= sizeof(struct sigregs);
1066 frame = (struct sigregs __user *) newsp;
1068 /* Put a sigcontext on the stack */
1069 newsp -= sizeof(*sc);
1070 sc = (struct sigcontext __user *) newsp;
1072 /* create a stack frame for the caller of the handler */
1073 newsp -= __SIGNAL_FRAMESIZE;
1075 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1079 #error "Please adjust handle_signal()"
1081 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1082 || __put_user(oldset->sig[0], &sc->oldmask)
1084 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1086 || __put_user(oldset->sig[1], &sc->_unused[3])
1088 || __put_user(to_user_ptr(frame), &sc->regs)
1089 || __put_user(sig, &sc->signal))
1093 if (vdso32_sigtramp && current->thread.vdso_base) {
1094 if (save_user_regs(regs, &frame->mctx, 0))
1096 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1100 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1102 regs->link = (unsigned long) frame->mctx.tramp;
1105 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1107 regs->gpr[1] = newsp;
1109 regs->gpr[4] = (unsigned long) sc;
1110 regs->nip = (unsigned long) ka->sa.sa_handler;
1115 if (test_thread_flag(TIF_SINGLESTEP))
1116 ptrace_notify(SIGTRAP);
1123 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1124 regs, frame, newsp);
1126 force_sigsegv(sig, current);
1131 * Do a signal return; undo the signal stack.
1133 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1134 struct pt_regs *regs)
1136 struct sigcontext __user *sc;
1137 struct sigcontext sigctx;
1138 struct mcontext __user *sr;
1141 /* Always make any pending restarted system calls return -EINTR */
1142 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1144 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1145 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1150 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1151 * unused part of the signal stackframe
1153 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1155 set.sig[0] = sigctx.oldmask;
1156 set.sig[1] = sigctx._unused[3];
1158 restore_sigmask(&set);
1160 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1161 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1162 || restore_user_regs(regs, sr, 1))
1166 return (int)regs->result;
1168 sigreturn_exit(regs); /* doesn't return */
1173 force_sig(SIGSEGV, current);
1178 * Note that 'init' is a special process: it doesn't get signals it doesn't
1179 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1182 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1185 struct k_sigaction ka;
1186 unsigned int frame, newsp;
1190 if (try_to_freeze()) {
1192 if (!signal_pending(current))
1198 oldset = ¤t->blocked;
1202 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1206 if (TRAP(regs) == 0x0C00 /* System Call! */
1207 && regs->ccr & 0x10000000 /* error signalled */
1208 && ((ret = regs->gpr[3]) == ERESTARTSYS
1209 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1210 || ret == ERESTART_RESTARTBLOCK)) {
1213 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1214 || (ret == ERESTARTSYS
1215 && !(ka.sa.sa_flags & SA_RESTART)))) {
1216 /* make the system call return an EINTR error */
1217 regs->result = -EINTR;
1218 regs->gpr[3] = EINTR;
1219 /* note that the cr0.SO bit is already set */
1221 regs->nip -= 4; /* Back up & retry system call */
1224 if (ret == ERESTART_RESTARTBLOCK)
1225 regs->gpr[0] = __NR_restart_syscall;
1227 regs->gpr[3] = regs->orig_gpr3;
1232 return 0; /* no signals delivered */
1234 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1235 && !on_sig_stack(regs->gpr[1]))
1236 newsp = current->sas_ss_sp + current->sas_ss_size;
1238 newsp = regs->gpr[1];
1243 * Reenable the DABR before delivering the signal to
1244 * user space. The DABR will have been cleared if it
1245 * triggered inside the kernel.
1247 if (current->thread.dabr)
1248 set_dabr(current->thread.dabr);
1251 /* Whee! Actually deliver the signal. */
1252 if (ka.sa.sa_flags & SA_SIGINFO)
1253 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1255 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1258 spin_lock_irq(¤t->sighand->siglock);
1259 sigorsets(¤t->blocked, ¤t->blocked,
1261 if (!(ka.sa.sa_flags & SA_NODEFER))
1262 sigaddset(¤t->blocked, signr);
1263 recalc_sigpending();
1264 spin_unlock_irq(¤t->sighand->siglock);