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;
500 /* force the process to reload the FP registers from
501 current->thread when it next does FP instructions */
502 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
503 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
504 sizeof(sr->mc_fregs)))
507 #ifdef CONFIG_ALTIVEC
508 /* force the process to reload the altivec registers from
509 current->thread when it next does altivec instructions */
510 regs->msr &= ~MSR_VEC;
511 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
512 /* restore altivec registers from the stack */
513 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
514 sizeof(sr->mc_vregs)))
516 } else if (current->thread.used_vr)
517 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
519 /* Always get VRSAVE back */
520 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
522 #endif /* CONFIG_ALTIVEC */
525 /* force the process to reload the spe registers from
526 current->thread when it next does spe instructions */
527 regs->msr &= ~MSR_SPE;
528 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
529 /* restore spe registers from the stack */
530 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
531 ELF_NEVRREG * sizeof(u32)))
533 } else if (current->thread.used_spe)
534 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
536 /* Always get SPEFSCR back */
537 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
539 #endif /* CONFIG_SPE */
543 if (last_task_used_math == current)
544 last_task_used_math = NULL;
545 if (last_task_used_altivec == current)
546 last_task_used_altivec = NULL;
548 if (last_task_used_spe == current)
549 last_task_used_spe = NULL;
557 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
558 struct sigaction32 __user *oact, size_t sigsetsize)
560 struct k_sigaction new_ka, old_ka;
563 /* XXX: Don't preclude handling different sized sigset_t's. */
564 if (sigsetsize != sizeof(compat_sigset_t))
568 compat_uptr_t handler;
570 ret = get_user(handler, &act->sa_handler);
571 new_ka.sa.sa_handler = compat_ptr(handler);
572 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
573 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
578 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
580 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
581 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
582 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
588 * Note: it is necessary to treat how as an unsigned int, with the
589 * corresponding cast to a signed int to insure that the proper
590 * conversion (sign extension) between the register representation
591 * of a signed int (msr in 32-bit mode) and the register representation
592 * of a signed int (msr in 64-bit mode) is performed.
594 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
595 compat_sigset_t __user *oset, size_t sigsetsize)
600 mm_segment_t old_fs = get_fs();
603 if (get_sigset_t(&s, set))
608 /* This is valid because of the set_fs() */
609 up = (sigset_t __user *) &s;
610 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
616 if (put_sigset_t(oset, &s))
622 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
626 mm_segment_t old_fs = get_fs();
629 /* The __user pointer cast is valid because of the set_fs() */
630 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
633 if (put_sigset_t(set, &s))
640 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
644 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
647 /* If you change siginfo_t structure, please be sure
648 * this code is fixed accordingly.
649 * It should never copy any pad contained in the structure
650 * to avoid security leaks, but must copy the generic
651 * 3 ints plus the relevant union member.
652 * This routine must convert siginfo from 64bit to 32bit as well
655 err = __put_user(s->si_signo, &d->si_signo);
656 err |= __put_user(s->si_errno, &d->si_errno);
657 err |= __put_user((short)s->si_code, &d->si_code);
659 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
661 else switch(s->si_code >> 16) {
662 case __SI_CHLD >> 16:
663 err |= __put_user(s->si_pid, &d->si_pid);
664 err |= __put_user(s->si_uid, &d->si_uid);
665 err |= __put_user(s->si_utime, &d->si_utime);
666 err |= __put_user(s->si_stime, &d->si_stime);
667 err |= __put_user(s->si_status, &d->si_status);
669 case __SI_FAULT >> 16:
670 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
673 case __SI_POLL >> 16:
674 err |= __put_user(s->si_band, &d->si_band);
675 err |= __put_user(s->si_fd, &d->si_fd);
677 case __SI_TIMER >> 16:
678 err |= __put_user(s->si_tid, &d->si_tid);
679 err |= __put_user(s->si_overrun, &d->si_overrun);
680 err |= __put_user(s->si_int, &d->si_int);
682 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
683 case __SI_MESGQ >> 16:
684 err |= __put_user(s->si_int, &d->si_int);
686 case __SI_KILL >> 16:
688 err |= __put_user(s->si_pid, &d->si_pid);
689 err |= __put_user(s->si_uid, &d->si_uid);
695 #define copy_siginfo_to_user copy_siginfo_to_user32
698 * Note: it is necessary to treat pid and sig as unsigned ints, with the
699 * corresponding cast to a signed int to insure that the proper conversion
700 * (sign extension) between the register representation of a signed int
701 * (msr in 32-bit mode) and the register representation of a signed int
702 * (msr in 64-bit mode) is performed.
704 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
708 mm_segment_t old_fs = get_fs();
710 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
711 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
714 /* The __user pointer cast is valid becasuse of the set_fs() */
715 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
720 * Start Alternate signal stack support
723 * sigaltatck compat_sys_sigaltstack
726 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
727 int r6, int r7, int r8, struct pt_regs *regs)
729 stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
730 stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
738 * set sp to the user stack on entry to the system call
739 * the system call router sets R9 to the saved registers
743 /* Put new stack info in local 64 bit stack struct */
745 if (get_user(ss_sp, &newstack->ss_sp) ||
746 __get_user(uss.ss_flags, &newstack->ss_flags) ||
747 __get_user(uss.ss_size, &newstack->ss_size))
749 uss.ss_sp = compat_ptr(ss_sp);
754 /* The __user pointer casts are valid because of the set_fs() */
755 ret = do_sigaltstack(
756 newstack ? (stack_t __user *) &uss : NULL,
757 oldstack ? (stack_t __user *) &uoss : NULL,
760 /* Copy the stack information to the user output buffer */
761 if (!ret && oldstack &&
762 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
763 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
764 __put_user(uoss.ss_size, &oldstack->ss_size)))
768 #endif /* CONFIG_PPC64 */
772 * Restore the user process's signal mask
775 extern void restore_sigmask(sigset_t *set);
776 #else /* CONFIG_PPC64 */
777 static void restore_sigmask(sigset_t *set)
779 sigdelsetmask(set, ~_BLOCKABLE);
780 spin_lock_irq(¤t->sighand->siglock);
781 current->blocked = *set;
783 spin_unlock_irq(¤t->sighand->siglock);
788 * Set up a signal frame for a "real-time" signal handler
789 * (one which gets siginfo).
791 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
792 siginfo_t *info, sigset_t *oldset,
793 struct pt_regs *regs, unsigned long newsp)
795 struct rt_sigframe __user *rt_sf;
796 struct mcontext __user *frame;
797 unsigned long origsp = newsp;
799 /* Set up Signal Frame */
800 /* Put a Real Time Context onto stack */
801 newsp -= sizeof(*rt_sf);
802 rt_sf = (struct rt_sigframe __user *)newsp;
804 /* create a stack frame for the caller of the handler */
805 newsp -= __SIGNAL_FRAMESIZE + 16;
807 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
810 /* Put the siginfo & fill in most of the ucontext */
811 if (copy_siginfo_to_user(&rt_sf->info, info)
812 || __put_user(0, &rt_sf->uc.uc_flags)
813 || __put_user(0, &rt_sf->uc.uc_link)
814 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
815 || __put_user(sas_ss_flags(regs->gpr[1]),
816 &rt_sf->uc.uc_stack.ss_flags)
817 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
818 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
820 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
823 /* Save user registers on the stack */
824 frame = &rt_sf->uc.uc_mcontext;
825 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
826 if (save_user_regs(regs, frame, 0))
828 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
830 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
832 regs->link = (unsigned long) frame->tramp;
835 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
837 if (put_user(regs->gpr[1], (u32 __user *)newsp))
839 regs->gpr[1] = newsp;
841 regs->gpr[4] = (unsigned long) &rt_sf->info;
842 regs->gpr[5] = (unsigned long) &rt_sf->uc;
843 regs->gpr[6] = (unsigned long) rt_sf;
844 regs->nip = (unsigned long) ka->sa.sa_handler;
850 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
853 force_sigsegv(sig, current);
857 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
860 struct mcontext __user *mcp;
862 if (get_sigset_t(&set, &ucp->uc_sigmask))
868 if (__get_user(cmcp, &ucp->uc_regs))
870 mcp = (struct mcontext __user *)(u64)cmcp;
873 if (__get_user(mcp, &ucp->uc_regs))
876 restore_sigmask(&set);
877 if (restore_user_regs(regs, mcp, sig))
883 long sys_swapcontext(struct ucontext __user *old_ctx,
884 struct ucontext __user *new_ctx,
885 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
889 /* Context size is for future use. Right now, we only make sure
890 * we are passed something we understand
892 if (ctx_size < sizeof(struct ucontext))
895 if (old_ctx != NULL) {
896 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
897 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
898 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
899 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
905 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
906 || __get_user(tmp, (u8 __user *) new_ctx)
907 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
911 * If we get a fault copying the context into the kernel's
912 * image of the user's registers, we can't just return -EFAULT
913 * because the user's registers will be corrupted. For instance
914 * the NIP value may have been updated but not some of the
915 * other registers. Given that we have done the access_ok
916 * and successfully read the first and last bytes of the region
917 * above, this should only happen in an out-of-memory situation
918 * or if another thread unmaps the region containing the context.
919 * We kill the task with a SIGSEGV in this situation.
921 if (do_setcontext(new_ctx, regs, 0))
924 set_thread_flag(TIF_RESTOREALL);
928 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
929 struct pt_regs *regs)
931 struct rt_sigframe __user *rt_sf;
933 /* Always make any pending restarted system calls return -EINTR */
934 current_thread_info()->restart_block.fn = do_no_restart_syscall;
936 rt_sf = (struct rt_sigframe __user *)
937 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
938 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
940 if (do_setcontext(&rt_sf->uc, regs, 1))
944 * It's not clear whether or why it is desirable to save the
945 * sigaltstack setting on signal delivery and restore it on
946 * signal return. But other architectures do this and we have
947 * always done it up until now so it is probably better not to
948 * change it. -- paulus
952 * We use the compat_sys_ version that does the 32/64 bits conversion
953 * and takes userland pointer directly. What about error checking ?
956 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
958 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
960 set_thread_flag(TIF_RESTOREALL);
964 force_sig(SIGSEGV, current);
969 int sys_debug_setcontext(struct ucontext __user *ctx,
970 int ndbg, struct sig_dbg_op __user *dbg,
971 int r6, int r7, int r8,
972 struct pt_regs *regs)
974 struct sig_dbg_op op;
976 unsigned long new_msr = regs->msr;
977 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
978 unsigned long new_dbcr0 = current->thread.dbcr0;
981 for (i=0; i<ndbg; i++) {
982 if (__copy_from_user(&op, dbg, sizeof(op)))
984 switch (op.dbg_type) {
985 case SIG_DBG_SINGLE_STEPPING:
986 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
989 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
992 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
1001 case SIG_DBG_BRANCH_TRACING:
1002 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1017 /* We wait until here to actually install the values in the
1018 registers so if we fail in the above loop, it will not
1019 affect the contents of these registers. After this point,
1020 failure is a problem, anyway, and it's very unlikely unless
1021 the user is really doing something wrong. */
1022 regs->msr = new_msr;
1023 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1024 current->thread.dbcr0 = new_dbcr0;
1028 * If we get a fault copying the context into the kernel's
1029 * image of the user's registers, we can't just return -EFAULT
1030 * because the user's registers will be corrupted. For instance
1031 * the NIP value may have been updated but not some of the
1032 * other registers. Given that we have done the access_ok
1033 * and successfully read the first and last bytes of the region
1034 * above, this should only happen in an out-of-memory situation
1035 * or if another thread unmaps the region containing the context.
1036 * We kill the task with a SIGSEGV in this situation.
1038 if (do_setcontext(ctx, regs, 1)) {
1039 force_sig(SIGSEGV, current);
1044 * It's not clear whether or why it is desirable to save the
1045 * sigaltstack setting on signal delivery and restore it on
1046 * signal return. But other architectures do this and we have
1047 * always done it up until now so it is probably better not to
1048 * change it. -- paulus
1050 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1052 set_thread_flag(TIF_RESTOREALL);
1059 * OK, we're invoking a handler
1061 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1062 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1063 unsigned long newsp)
1065 struct sigcontext __user *sc;
1066 struct sigregs __user *frame;
1067 unsigned long origsp = newsp;
1069 /* Set up Signal Frame */
1070 newsp -= sizeof(struct sigregs);
1071 frame = (struct sigregs __user *) newsp;
1073 /* Put a sigcontext on the stack */
1074 newsp -= sizeof(*sc);
1075 sc = (struct sigcontext __user *) newsp;
1077 /* create a stack frame for the caller of the handler */
1078 newsp -= __SIGNAL_FRAMESIZE;
1080 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1084 #error "Please adjust handle_signal()"
1086 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1087 || __put_user(oldset->sig[0], &sc->oldmask)
1089 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1091 || __put_user(oldset->sig[1], &sc->_unused[3])
1093 || __put_user(to_user_ptr(frame), &sc->regs)
1094 || __put_user(sig, &sc->signal))
1097 if (vdso32_sigtramp && current->thread.vdso_base) {
1098 if (save_user_regs(regs, &frame->mctx, 0))
1100 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1102 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1104 regs->link = (unsigned long) frame->mctx.tramp;
1107 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1109 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1111 regs->gpr[1] = newsp;
1113 regs->gpr[4] = (unsigned long) sc;
1114 regs->nip = (unsigned long) ka->sa.sa_handler;
1121 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1122 regs, frame, newsp);
1124 force_sigsegv(sig, current);
1129 * Do a signal return; undo the signal stack.
1131 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1132 struct pt_regs *regs)
1134 struct sigcontext __user *sc;
1135 struct sigcontext sigctx;
1136 struct mcontext __user *sr;
1139 /* Always make any pending restarted system calls return -EINTR */
1140 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1142 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1143 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1148 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1149 * unused part of the signal stackframe
1151 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1153 set.sig[0] = sigctx.oldmask;
1154 set.sig[1] = sigctx._unused[3];
1156 restore_sigmask(&set);
1158 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1159 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1160 || restore_user_regs(regs, sr, 1))
1163 set_thread_flag(TIF_RESTOREALL);
1167 force_sig(SIGSEGV, current);
1172 * Note that 'init' is a special process: it doesn't get signals it doesn't
1173 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1176 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1179 struct k_sigaction ka;
1180 unsigned int frame, newsp;
1184 if (try_to_freeze()) {
1186 if (!signal_pending(current))
1192 oldset = ¤t->blocked;
1196 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1200 if (TRAP(regs) == 0x0C00 /* System Call! */
1201 && regs->ccr & 0x10000000 /* error signalled */
1202 && ((ret = regs->gpr[3]) == ERESTARTSYS
1203 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1204 || ret == ERESTART_RESTARTBLOCK)) {
1207 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1208 || (ret == ERESTARTSYS
1209 && !(ka.sa.sa_flags & SA_RESTART)))) {
1210 /* make the system call return an EINTR error */
1211 regs->result = -EINTR;
1212 regs->gpr[3] = EINTR;
1213 /* note that the cr0.SO bit is already set */
1215 regs->nip -= 4; /* Back up & retry system call */
1218 if (ret == ERESTART_RESTARTBLOCK)
1219 regs->gpr[0] = __NR_restart_syscall;
1221 regs->gpr[3] = regs->orig_gpr3;
1226 return 0; /* no signals delivered */
1228 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1229 && !on_sig_stack(regs->gpr[1]))
1230 newsp = current->sas_ss_sp + current->sas_ss_size;
1232 newsp = regs->gpr[1];
1237 * Reenable the DABR before delivering the signal to
1238 * user space. The DABR will have been cleared if it
1239 * triggered inside the kernel.
1241 if (current->thread.dabr)
1242 set_dabr(current->thread.dabr);
1245 /* Whee! Actually deliver the signal. */
1246 if (ka.sa.sa_flags & SA_SIGINFO)
1247 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1249 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1252 spin_lock_irq(¤t->sighand->siglock);
1253 sigorsets(¤t->blocked, ¤t->blocked,
1255 if (!(ka.sa.sa_flags & SA_NODEFER))
1256 sigaddset(¤t->blocked, signr);
1257 recalc_sigpending();
1258 spin_unlock_irq(¤t->sighand->siglock);