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, int p2, int p3, int p4, int p6, int p7,
256 struct pt_regs *regs)
261 spin_lock_irq(¤t->sighand->siglock);
262 saveset = current->blocked;
263 siginitset(¤t->blocked, mask);
265 spin_unlock_irq(¤t->sighand->siglock);
267 regs->result = -EINTR;
268 regs->gpr[3] = EINTR;
269 regs->ccr |= 0x10000000;
271 current->state = TASK_INTERRUPTIBLE;
273 if (do_signal(&saveset, regs)) {
274 set_thread_flag(TIF_RESTOREALL);
280 long sys_rt_sigsuspend(
282 compat_sigset_t __user *unewset,
284 sigset_t __user *unewset,
286 size_t sigsetsize, int p3, int p4,
287 int p6, int p7, struct pt_regs *regs)
289 sigset_t saveset, newset;
291 /* XXX: Don't preclude handling different sized sigset_t's. */
292 if (sigsetsize != sizeof(sigset_t))
295 if (get_sigset_t(&newset, unewset))
297 sigdelsetmask(&newset, ~_BLOCKABLE);
299 spin_lock_irq(¤t->sighand->siglock);
300 saveset = current->blocked;
301 current->blocked = newset;
303 spin_unlock_irq(¤t->sighand->siglock);
305 regs->result = -EINTR;
306 regs->gpr[3] = EINTR;
307 regs->ccr |= 0x10000000;
309 current->state = TASK_INTERRUPTIBLE;
311 if (do_signal(&saveset, regs)) {
312 set_thread_flag(TIF_RESTOREALL);
319 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
320 int r6, int r7, int r8, struct pt_regs *regs)
322 return do_sigaltstack(uss, uoss, regs->gpr[1]);
326 long sys_sigaction(int sig, struct old_sigaction __user *act,
327 struct old_sigaction __user *oact)
329 struct k_sigaction new_ka, old_ka;
338 if (get_old_sigaction(&new_ka, act))
342 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
344 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
345 __put_user(to_user_ptr(old_ka.sa.sa_handler),
346 &oact->sa_handler) ||
347 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
348 &oact->sa_restorer) ||
349 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
350 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
358 * When we have signals to deliver, we set up on the
359 * user stack, going down from the original stack pointer:
361 * a sigcontext struct
362 * a gap of __SIGNAL_FRAMESIZE bytes
364 * Each of these things must be a multiple of 16 bytes in size.
368 struct mcontext mctx; /* all the register values */
370 * Programs using the rs6000/xcoff abi can save up to 19 gp
371 * regs and 18 fp regs below sp before decrementing it.
376 /* We use the mc_pad field for the signal return trampoline. */
380 * When we have rt signals to deliver, we set up on the
381 * user stack, going down from the original stack pointer:
382 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
383 * a gap of __SIGNAL_FRAMESIZE+16 bytes
384 * (the +16 is to get the siginfo and ucontext in the same
385 * positions as in older kernels).
387 * Each of these things must be a multiple of 16 bytes in size.
392 compat_siginfo_t info;
398 * Programs using the rs6000/xcoff abi can save up to 19 gp
399 * regs and 18 fp regs below sp before decrementing it.
405 * Save the current user registers on the user stack.
406 * We only save the altivec/spe registers if the process has used
407 * altivec/spe instructions at some point.
409 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
412 /* Make sure floating point registers are stored in regs */
413 flush_fp_to_thread(current);
415 /* save general and floating-point registers */
416 if (save_general_regs(regs, frame) ||
417 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
418 ELF_NFPREG * sizeof(double)))
421 #ifdef CONFIG_ALTIVEC
422 /* save altivec registers */
423 if (current->thread.used_vr) {
424 flush_altivec_to_thread(current);
425 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
426 ELF_NVRREG * sizeof(vector128)))
428 /* set MSR_VEC in the saved MSR value to indicate that
429 frame->mc_vregs contains valid data */
430 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
433 /* else assert((regs->msr & MSR_VEC) == 0) */
435 /* We always copy to/from vrsave, it's 0 if we don't have or don't
436 * use altivec. Since VSCR only contains 32 bits saved in the least
437 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
438 * most significant bits of that same vector. --BenH
440 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
442 #endif /* CONFIG_ALTIVEC */
445 /* save spe registers */
446 if (current->thread.used_spe) {
447 flush_spe_to_thread(current);
448 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
449 ELF_NEVRREG * sizeof(u32)))
451 /* set MSR_SPE in the saved MSR value to indicate that
452 frame->mc_vregs contains valid data */
453 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
456 /* else assert((regs->msr & MSR_SPE) == 0) */
458 /* We always copy to/from spefscr */
459 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
461 #endif /* CONFIG_SPE */
464 /* Set up the sigreturn trampoline: li r0,sigret; sc */
465 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
466 || __put_user(0x44000002UL, &frame->tramp[1]))
468 flush_icache_range((unsigned long) &frame->tramp[0],
469 (unsigned long) &frame->tramp[2]);
476 * Restore the current user register values from the user stack,
479 static long restore_user_regs(struct pt_regs *regs,
480 struct mcontext __user *sr, int sig)
483 unsigned int save_r2 = 0;
484 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
489 * restore general registers but not including MSR or SOFTE. Also
490 * take care of keeping r2 (TLS) intact if not a signal
493 save_r2 = (unsigned int)regs->gpr[2];
494 err = restore_general_regs(regs, sr);
496 regs->gpr[2] = (unsigned long) save_r2;
501 * Do this before updating the thread state in
502 * current->thread.fpr/vr/evr. That way, if we get preempted
503 * and another task grabs the FPU/Altivec/SPE, it won't be
504 * tempted to save the current CPU state into the thread_struct
505 * and corrupt what we are writing there.
507 discard_lazy_cpu_state();
509 /* force the process to reload the FP registers from
510 current->thread when it next does FP instructions */
511 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
512 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
513 sizeof(sr->mc_fregs)))
516 #ifdef CONFIG_ALTIVEC
517 /* force the process to reload the altivec registers from
518 current->thread when it next does altivec instructions */
519 regs->msr &= ~MSR_VEC;
520 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
521 /* restore altivec registers from the stack */
522 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
523 sizeof(sr->mc_vregs)))
525 } else if (current->thread.used_vr)
526 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
528 /* Always get VRSAVE back */
529 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
531 #endif /* CONFIG_ALTIVEC */
534 /* force the process to reload the spe registers from
535 current->thread when it next does spe instructions */
536 regs->msr &= ~MSR_SPE;
537 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
538 /* restore spe registers from the stack */
539 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
540 ELF_NEVRREG * sizeof(u32)))
542 } else if (current->thread.used_spe)
543 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
545 /* Always get SPEFSCR back */
546 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
548 #endif /* CONFIG_SPE */
554 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
555 struct sigaction32 __user *oact, size_t sigsetsize)
557 struct k_sigaction new_ka, old_ka;
560 /* XXX: Don't preclude handling different sized sigset_t's. */
561 if (sigsetsize != sizeof(compat_sigset_t))
565 compat_uptr_t handler;
567 ret = get_user(handler, &act->sa_handler);
568 new_ka.sa.sa_handler = compat_ptr(handler);
569 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
570 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
575 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
577 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
578 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
579 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
585 * Note: it is necessary to treat how as an unsigned int, with the
586 * corresponding cast to a signed int to insure that the proper
587 * conversion (sign extension) between the register representation
588 * of a signed int (msr in 32-bit mode) and the register representation
589 * of a signed int (msr in 64-bit mode) is performed.
591 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
592 compat_sigset_t __user *oset, size_t sigsetsize)
597 mm_segment_t old_fs = get_fs();
600 if (get_sigset_t(&s, set))
605 /* This is valid because of the set_fs() */
606 up = (sigset_t __user *) &s;
607 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
613 if (put_sigset_t(oset, &s))
619 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
623 mm_segment_t old_fs = get_fs();
626 /* The __user pointer cast is valid because of the set_fs() */
627 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
630 if (put_sigset_t(set, &s))
637 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
641 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
644 /* If you change siginfo_t structure, please be sure
645 * this code is fixed accordingly.
646 * It should never copy any pad contained in the structure
647 * to avoid security leaks, but must copy the generic
648 * 3 ints plus the relevant union member.
649 * This routine must convert siginfo from 64bit to 32bit as well
652 err = __put_user(s->si_signo, &d->si_signo);
653 err |= __put_user(s->si_errno, &d->si_errno);
654 err |= __put_user((short)s->si_code, &d->si_code);
656 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
658 else switch(s->si_code >> 16) {
659 case __SI_CHLD >> 16:
660 err |= __put_user(s->si_pid, &d->si_pid);
661 err |= __put_user(s->si_uid, &d->si_uid);
662 err |= __put_user(s->si_utime, &d->si_utime);
663 err |= __put_user(s->si_stime, &d->si_stime);
664 err |= __put_user(s->si_status, &d->si_status);
666 case __SI_FAULT >> 16:
667 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
670 case __SI_POLL >> 16:
671 err |= __put_user(s->si_band, &d->si_band);
672 err |= __put_user(s->si_fd, &d->si_fd);
674 case __SI_TIMER >> 16:
675 err |= __put_user(s->si_tid, &d->si_tid);
676 err |= __put_user(s->si_overrun, &d->si_overrun);
677 err |= __put_user(s->si_int, &d->si_int);
679 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
680 case __SI_MESGQ >> 16:
681 err |= __put_user(s->si_int, &d->si_int);
683 case __SI_KILL >> 16:
685 err |= __put_user(s->si_pid, &d->si_pid);
686 err |= __put_user(s->si_uid, &d->si_uid);
692 #define copy_siginfo_to_user copy_siginfo_to_user32
695 * Note: it is necessary to treat pid and sig as unsigned ints, with the
696 * corresponding cast to a signed int to insure that the proper conversion
697 * (sign extension) between the register representation of a signed int
698 * (msr in 32-bit mode) and the register representation of a signed int
699 * (msr in 64-bit mode) is performed.
701 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
705 mm_segment_t old_fs = get_fs();
707 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
708 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
711 /* The __user pointer cast is valid becasuse of the set_fs() */
712 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
717 * Start Alternate signal stack support
720 * sigaltatck compat_sys_sigaltstack
723 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
724 int r6, int r7, int r8, struct pt_regs *regs)
726 stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
727 stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
735 * set sp to the user stack on entry to the system call
736 * the system call router sets R9 to the saved registers
740 /* Put new stack info in local 64 bit stack struct */
742 if (get_user(ss_sp, &newstack->ss_sp) ||
743 __get_user(uss.ss_flags, &newstack->ss_flags) ||
744 __get_user(uss.ss_size, &newstack->ss_size))
746 uss.ss_sp = compat_ptr(ss_sp);
751 /* The __user pointer casts are valid because of the set_fs() */
752 ret = do_sigaltstack(
753 newstack ? (stack_t __user *) &uss : NULL,
754 oldstack ? (stack_t __user *) &uoss : NULL,
757 /* Copy the stack information to the user output buffer */
758 if (!ret && oldstack &&
759 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
760 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
761 __put_user(uoss.ss_size, &oldstack->ss_size)))
765 #endif /* CONFIG_PPC64 */
769 * Restore the user process's signal mask
772 extern void restore_sigmask(sigset_t *set);
773 #else /* CONFIG_PPC64 */
774 static void restore_sigmask(sigset_t *set)
776 sigdelsetmask(set, ~_BLOCKABLE);
777 spin_lock_irq(¤t->sighand->siglock);
778 current->blocked = *set;
780 spin_unlock_irq(¤t->sighand->siglock);
785 * Set up a signal frame for a "real-time" signal handler
786 * (one which gets siginfo).
788 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
789 siginfo_t *info, sigset_t *oldset,
790 struct pt_regs *regs, unsigned long newsp)
792 struct rt_sigframe __user *rt_sf;
793 struct mcontext __user *frame;
794 unsigned long origsp = newsp;
796 /* Set up Signal Frame */
797 /* Put a Real Time Context onto stack */
798 newsp -= sizeof(*rt_sf);
799 rt_sf = (struct rt_sigframe __user *)newsp;
801 /* create a stack frame for the caller of the handler */
802 newsp -= __SIGNAL_FRAMESIZE + 16;
804 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
807 /* Put the siginfo & fill in most of the ucontext */
808 if (copy_siginfo_to_user(&rt_sf->info, info)
809 || __put_user(0, &rt_sf->uc.uc_flags)
810 || __put_user(0, &rt_sf->uc.uc_link)
811 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
812 || __put_user(sas_ss_flags(regs->gpr[1]),
813 &rt_sf->uc.uc_stack.ss_flags)
814 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
815 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
817 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
820 /* Save user registers on the stack */
821 frame = &rt_sf->uc.uc_mcontext;
822 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
823 if (save_user_regs(regs, frame, 0))
825 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
827 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
829 regs->link = (unsigned long) frame->tramp;
832 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
834 if (put_user(regs->gpr[1], (u32 __user *)newsp))
836 regs->gpr[1] = newsp;
838 regs->gpr[4] = (unsigned long) &rt_sf->info;
839 regs->gpr[5] = (unsigned long) &rt_sf->uc;
840 regs->gpr[6] = (unsigned long) rt_sf;
841 regs->nip = (unsigned long) ka->sa.sa_handler;
847 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
850 force_sigsegv(sig, current);
854 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
857 struct mcontext __user *mcp;
859 if (get_sigset_t(&set, &ucp->uc_sigmask))
865 if (__get_user(cmcp, &ucp->uc_regs))
867 mcp = (struct mcontext __user *)(u64)cmcp;
870 if (__get_user(mcp, &ucp->uc_regs))
873 restore_sigmask(&set);
874 if (restore_user_regs(regs, mcp, sig))
880 long sys_swapcontext(struct ucontext __user *old_ctx,
881 struct ucontext __user *new_ctx,
882 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
886 /* Context size is for future use. Right now, we only make sure
887 * we are passed something we understand
889 if (ctx_size < sizeof(struct ucontext))
892 if (old_ctx != NULL) {
893 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
894 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
895 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
896 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
902 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
903 || __get_user(tmp, (u8 __user *) new_ctx)
904 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
908 * If we get a fault copying the context into the kernel's
909 * image of the user's registers, we can't just return -EFAULT
910 * because the user's registers will be corrupted. For instance
911 * the NIP value may have been updated but not some of the
912 * other registers. Given that we have done the access_ok
913 * and successfully read the first and last bytes of the region
914 * above, this should only happen in an out-of-memory situation
915 * or if another thread unmaps the region containing the context.
916 * We kill the task with a SIGSEGV in this situation.
918 if (do_setcontext(new_ctx, regs, 0))
921 set_thread_flag(TIF_RESTOREALL);
925 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
926 struct pt_regs *regs)
928 struct rt_sigframe __user *rt_sf;
930 /* Always make any pending restarted system calls return -EINTR */
931 current_thread_info()->restart_block.fn = do_no_restart_syscall;
933 rt_sf = (struct rt_sigframe __user *)
934 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
935 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
937 if (do_setcontext(&rt_sf->uc, regs, 1))
941 * It's not clear whether or why it is desirable to save the
942 * sigaltstack setting on signal delivery and restore it on
943 * signal return. But other architectures do this and we have
944 * always done it up until now so it is probably better not to
945 * change it. -- paulus
949 * We use the compat_sys_ version that does the 32/64 bits conversion
950 * and takes userland pointer directly. What about error checking ?
953 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
955 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
957 set_thread_flag(TIF_RESTOREALL);
961 force_sig(SIGSEGV, current);
966 int sys_debug_setcontext(struct ucontext __user *ctx,
967 int ndbg, struct sig_dbg_op __user *dbg,
968 int r6, int r7, int r8,
969 struct pt_regs *regs)
971 struct sig_dbg_op op;
973 unsigned long new_msr = regs->msr;
974 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
975 unsigned long new_dbcr0 = current->thread.dbcr0;
978 for (i=0; i<ndbg; i++) {
979 if (__copy_from_user(&op, dbg, sizeof(op)))
981 switch (op.dbg_type) {
982 case SIG_DBG_SINGLE_STEPPING:
983 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
986 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
989 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
998 case SIG_DBG_BRANCH_TRACING:
999 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1014 /* We wait until here to actually install the values in the
1015 registers so if we fail in the above loop, it will not
1016 affect the contents of these registers. After this point,
1017 failure is a problem, anyway, and it's very unlikely unless
1018 the user is really doing something wrong. */
1019 regs->msr = new_msr;
1020 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1021 current->thread.dbcr0 = new_dbcr0;
1025 * If we get a fault copying the context into the kernel's
1026 * image of the user's registers, we can't just return -EFAULT
1027 * because the user's registers will be corrupted. For instance
1028 * the NIP value may have been updated but not some of the
1029 * other registers. Given that we have done the access_ok
1030 * and successfully read the first and last bytes of the region
1031 * above, this should only happen in an out-of-memory situation
1032 * or if another thread unmaps the region containing the context.
1033 * We kill the task with a SIGSEGV in this situation.
1035 if (do_setcontext(ctx, regs, 1)) {
1036 force_sig(SIGSEGV, current);
1041 * It's not clear whether or why it is desirable to save the
1042 * sigaltstack setting on signal delivery and restore it on
1043 * signal return. But other architectures do this and we have
1044 * always done it up until now so it is probably better not to
1045 * change it. -- paulus
1047 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1049 set_thread_flag(TIF_RESTOREALL);
1056 * OK, we're invoking a handler
1058 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1059 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1060 unsigned long newsp)
1062 struct sigcontext __user *sc;
1063 struct sigregs __user *frame;
1064 unsigned long origsp = newsp;
1066 /* Set up Signal Frame */
1067 newsp -= sizeof(struct sigregs);
1068 frame = (struct sigregs __user *) newsp;
1070 /* Put a sigcontext on the stack */
1071 newsp -= sizeof(*sc);
1072 sc = (struct sigcontext __user *) newsp;
1074 /* create a stack frame for the caller of the handler */
1075 newsp -= __SIGNAL_FRAMESIZE;
1077 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1081 #error "Please adjust handle_signal()"
1083 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1084 || __put_user(oldset->sig[0], &sc->oldmask)
1086 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1088 || __put_user(oldset->sig[1], &sc->_unused[3])
1090 || __put_user(to_user_ptr(frame), &sc->regs)
1091 || __put_user(sig, &sc->signal))
1094 if (vdso32_sigtramp && current->thread.vdso_base) {
1095 if (save_user_regs(regs, &frame->mctx, 0))
1097 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1099 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1101 regs->link = (unsigned long) frame->mctx.tramp;
1104 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1106 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1108 regs->gpr[1] = newsp;
1110 regs->gpr[4] = (unsigned long) sc;
1111 regs->nip = (unsigned long) ka->sa.sa_handler;
1118 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1119 regs, frame, newsp);
1121 force_sigsegv(sig, current);
1126 * Do a signal return; undo the signal stack.
1128 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1129 struct pt_regs *regs)
1131 struct sigcontext __user *sc;
1132 struct sigcontext sigctx;
1133 struct mcontext __user *sr;
1136 /* Always make any pending restarted system calls return -EINTR */
1137 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1139 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1140 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1145 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1146 * unused part of the signal stackframe
1148 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1150 set.sig[0] = sigctx.oldmask;
1151 set.sig[1] = sigctx._unused[3];
1153 restore_sigmask(&set);
1155 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1156 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1157 || restore_user_regs(regs, sr, 1))
1160 set_thread_flag(TIF_RESTOREALL);
1164 force_sig(SIGSEGV, current);
1169 * Note that 'init' is a special process: it doesn't get signals it doesn't
1170 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1173 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1176 struct k_sigaction ka;
1177 unsigned int frame, newsp;
1181 if (try_to_freeze()) {
1183 if (!signal_pending(current))
1189 oldset = ¤t->blocked;
1193 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1197 if (TRAP(regs) == 0x0C00 /* System Call! */
1198 && regs->ccr & 0x10000000 /* error signalled */
1199 && ((ret = regs->gpr[3]) == ERESTARTSYS
1200 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1201 || ret == ERESTART_RESTARTBLOCK)) {
1204 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1205 || (ret == ERESTARTSYS
1206 && !(ka.sa.sa_flags & SA_RESTART)))) {
1207 /* make the system call return an EINTR error */
1208 regs->result = -EINTR;
1209 regs->gpr[3] = EINTR;
1210 /* note that the cr0.SO bit is already set */
1212 regs->nip -= 4; /* Back up & retry system call */
1215 if (ret == ERESTART_RESTARTBLOCK)
1216 regs->gpr[0] = __NR_restart_syscall;
1218 regs->gpr[3] = regs->orig_gpr3;
1223 return 0; /* no signals delivered */
1225 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1226 && !on_sig_stack(regs->gpr[1]))
1227 newsp = current->sas_ss_sp + current->sas_ss_size;
1229 newsp = regs->gpr[1];
1234 * Reenable the DABR before delivering the signal to
1235 * user space. The DABR will have been cleared if it
1236 * triggered inside the kernel.
1238 if (current->thread.dabr)
1239 set_dabr(current->thread.dabr);
1242 /* Whee! Actually deliver the signal. */
1243 if (ka.sa.sa_flags & SA_SIGINFO)
1244 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1246 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1249 spin_lock_irq(¤t->sighand->siglock);
1250 sigorsets(¤t->blocked, ¤t->blocked,
1252 if (!(ka.sa.sa_flags & SA_NODEFER))
1253 sigaddset(¤t->blocked, signr);
1254 recalc_sigpending();
1255 spin_unlock_irq(¤t->sighand->siglock);