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/sched.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/kernel.h>
25 #include <linux/signal.h>
26 #include <linux/errno.h>
27 #include <linux/elf.h>
28 #include <linux/tracehook.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/freezer.h>
43 #include <asm/uaccess.h>
44 #include <asm/cacheflush.h>
45 #include <asm/syscalls.h>
46 #include <asm/sigcontext.h>
50 #include <asm/unistd.h>
52 #include <asm/ucontext.h>
53 #include <asm/pgtable.h>
58 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
61 #define do_signal do_signal32
62 #define sys_sigsuspend compat_sys_sigsuspend
63 #define sys_rt_sigsuspend compat_sys_rt_sigsuspend
64 #define sys_rt_sigreturn compat_sys_rt_sigreturn
65 #define sys_sigaction compat_sys_sigaction
66 #define sys_swapcontext compat_sys_swapcontext
67 #define sys_sigreturn compat_sys_sigreturn
69 #define old_sigaction old_sigaction32
70 #define sigcontext sigcontext32
71 #define mcontext mcontext32
72 #define ucontext ucontext32
75 * Returning 0 means we return to userspace via
76 * ret_from_except and thus restore all user
77 * registers from *regs. This is what we need
78 * to do when a signal has been delivered.
81 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
82 #undef __SIGNAL_FRAMESIZE
83 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
85 #define ELF_NVRREG ELF_NVRREG32
88 * Functions for flipping sigsets (thanks to brain dead generic
89 * implementation that makes things simple for little endian only)
91 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
95 switch (_NSIG_WORDS) {
96 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
97 cset.sig[7] = set->sig[3] >> 32;
98 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
99 cset.sig[5] = set->sig[2] >> 32;
100 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
101 cset.sig[3] = set->sig[1] >> 32;
102 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
103 cset.sig[1] = set->sig[0] >> 32;
105 return copy_to_user(uset, &cset, sizeof(*uset));
108 static inline int get_sigset_t(sigset_t *set,
109 const compat_sigset_t __user *uset)
113 if (copy_from_user(&s32, uset, sizeof(*uset)))
117 * Swap the 2 words of the 64-bit sigset_t (they are stored
118 * in the "wrong" endian in 32-bit user storage).
120 switch (_NSIG_WORDS) {
121 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
122 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
123 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
124 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
129 static inline int get_old_sigaction(struct k_sigaction *new_ka,
130 struct old_sigaction __user *act)
132 compat_old_sigset_t mask;
133 compat_uptr_t handler, restorer;
135 if (get_user(handler, &act->sa_handler) ||
136 __get_user(restorer, &act->sa_restorer) ||
137 __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
138 __get_user(mask, &act->sa_mask))
140 new_ka->sa.sa_handler = compat_ptr(handler);
141 new_ka->sa.sa_restorer = compat_ptr(restorer);
142 siginitset(&new_ka->sa.sa_mask, mask);
146 #define to_user_ptr(p) ptr_to_compat(p)
147 #define from_user_ptr(p) compat_ptr(p)
149 static inline int save_general_regs(struct pt_regs *regs,
150 struct mcontext __user *frame)
152 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
155 WARN_ON(!FULL_REGS(regs));
157 for (i = 0; i <= PT_RESULT; i ++) {
158 if (i == 14 && !FULL_REGS(regs))
160 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
166 static inline int restore_general_regs(struct pt_regs *regs,
167 struct mcontext __user *sr)
169 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
172 for (i = 0; i <= PT_RESULT; i++) {
173 if ((i == PT_MSR) || (i == PT_SOFTE))
175 if (__get_user(gregs[i], &sr->mc_gregs[i]))
181 #else /* CONFIG_PPC64 */
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) ((unsigned long)(p))
211 #define from_user_ptr(p) ((void __user *)(p))
213 static inline int save_general_regs(struct pt_regs *regs,
214 struct mcontext __user *frame)
216 WARN_ON(!FULL_REGS(regs));
217 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
220 static inline int restore_general_regs(struct pt_regs *regs,
221 struct mcontext __user *sr)
223 /* copy up to but not including MSR */
224 if (__copy_from_user(regs, &sr->mc_gregs,
225 PT_MSR * sizeof(elf_greg_t)))
227 /* copy from orig_r3 (the word after the MSR) up to the end */
228 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
229 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
234 #endif /* CONFIG_PPC64 */
236 int do_signal(sigset_t *oldset, struct pt_regs *regs);
239 * Atomically swap in the new signal mask, and wait for a signal.
241 long sys_sigsuspend(old_sigset_t mask)
244 spin_lock_irq(¤t->sighand->siglock);
245 current->saved_sigmask = current->blocked;
246 siginitset(¤t->blocked, mask);
248 spin_unlock_irq(¤t->sighand->siglock);
250 current->state = TASK_INTERRUPTIBLE;
252 set_thread_flag(TIF_RESTORE_SIGMASK);
253 return -ERESTARTNOHAND;
257 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
258 int r6, int r7, int r8, struct pt_regs *regs)
260 return do_sigaltstack(uss, uoss, regs->gpr[1]);
264 long sys_sigaction(int sig, struct old_sigaction __user *act,
265 struct old_sigaction __user *oact)
267 struct k_sigaction new_ka, old_ka;
276 if (get_old_sigaction(&new_ka, act))
280 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
282 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
283 __put_user(to_user_ptr(old_ka.sa.sa_handler),
284 &oact->sa_handler) ||
285 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
286 &oact->sa_restorer) ||
287 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
288 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
296 * When we have signals to deliver, we set up on the
297 * user stack, going down from the original stack pointer:
299 * a sigcontext struct
300 * a gap of __SIGNAL_FRAMESIZE bytes
302 * Each of these things must be a multiple of 16 bytes in size.
306 struct mcontext mctx; /* all the register values */
308 * Programs using the rs6000/xcoff abi can save up to 19 gp
309 * regs and 18 fp regs below sp before decrementing it.
314 /* We use the mc_pad field for the signal return trampoline. */
318 * When we have rt signals to deliver, we set up on the
319 * user stack, going down from the original stack pointer:
320 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
321 * a gap of __SIGNAL_FRAMESIZE+16 bytes
322 * (the +16 is to get the siginfo and ucontext in the same
323 * positions as in older kernels).
325 * Each of these things must be a multiple of 16 bytes in size.
330 compat_siginfo_t info;
336 * Programs using the rs6000/xcoff abi can save up to 19 gp
337 * regs and 18 fp regs below sp before decrementing it.
343 * Save the current user registers on the user stack.
344 * We only save the altivec/spe registers if the process has used
345 * altivec/spe instructions at some point.
347 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
350 /* Make sure floating point registers are stored in regs */
351 flush_fp_to_thread(current);
353 /* save general and floating-point registers */
354 if (save_general_regs(regs, frame) ||
355 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
356 ELF_NFPREG * sizeof(double)))
359 #ifdef CONFIG_ALTIVEC
360 /* save altivec registers */
361 if (current->thread.used_vr) {
362 flush_altivec_to_thread(current);
363 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
364 ELF_NVRREG * sizeof(vector128)))
366 /* set MSR_VEC in the saved MSR value to indicate that
367 frame->mc_vregs contains valid data */
368 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
371 /* else assert((regs->msr & MSR_VEC) == 0) */
373 /* We always copy to/from vrsave, it's 0 if we don't have or don't
374 * use altivec. Since VSCR only contains 32 bits saved in the least
375 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
376 * most significant bits of that same vector. --BenH
378 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
380 #endif /* CONFIG_ALTIVEC */
383 /* save spe registers */
384 if (current->thread.used_spe) {
385 flush_spe_to_thread(current);
386 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
387 ELF_NEVRREG * sizeof(u32)))
389 /* set MSR_SPE in the saved MSR value to indicate that
390 frame->mc_vregs contains valid data */
391 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
394 /* else assert((regs->msr & MSR_SPE) == 0) */
396 /* We always copy to/from spefscr */
397 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
399 #endif /* CONFIG_SPE */
402 /* Set up the sigreturn trampoline: li r0,sigret; sc */
403 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
404 || __put_user(0x44000002UL, &frame->tramp[1]))
406 flush_icache_range((unsigned long) &frame->tramp[0],
407 (unsigned long) &frame->tramp[2]);
414 * Restore the current user register values from the user stack,
417 static long restore_user_regs(struct pt_regs *regs,
418 struct mcontext __user *sr, int sig)
421 unsigned int save_r2 = 0;
425 * restore general registers but not including MSR or SOFTE. Also
426 * take care of keeping r2 (TLS) intact if not a signal
429 save_r2 = (unsigned int)regs->gpr[2];
430 err = restore_general_regs(regs, sr);
431 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
433 regs->gpr[2] = (unsigned long) save_r2;
437 /* if doing signal return, restore the previous little-endian mode */
439 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
442 * Do this before updating the thread state in
443 * current->thread.fpr/vr/evr. That way, if we get preempted
444 * and another task grabs the FPU/Altivec/SPE, it won't be
445 * tempted to save the current CPU state into the thread_struct
446 * and corrupt what we are writing there.
448 discard_lazy_cpu_state();
450 /* force the process to reload the FP registers from
451 current->thread when it next does FP instructions */
452 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
453 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
454 sizeof(sr->mc_fregs)))
457 #ifdef CONFIG_ALTIVEC
458 /* force the process to reload the altivec registers from
459 current->thread when it next does altivec instructions */
460 regs->msr &= ~MSR_VEC;
462 /* restore altivec registers from the stack */
463 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
464 sizeof(sr->mc_vregs)))
466 } else if (current->thread.used_vr)
467 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
469 /* Always get VRSAVE back */
470 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
472 #endif /* CONFIG_ALTIVEC */
475 /* force the process to reload the spe registers from
476 current->thread when it next does spe instructions */
477 regs->msr &= ~MSR_SPE;
479 /* restore spe registers from the stack */
480 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
481 ELF_NEVRREG * sizeof(u32)))
483 } else if (current->thread.used_spe)
484 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
486 /* Always get SPEFSCR back */
487 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
489 #endif /* CONFIG_SPE */
495 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
496 struct sigaction32 __user *oact, size_t sigsetsize)
498 struct k_sigaction new_ka, old_ka;
501 /* XXX: Don't preclude handling different sized sigset_t's. */
502 if (sigsetsize != sizeof(compat_sigset_t))
506 compat_uptr_t handler;
508 ret = get_user(handler, &act->sa_handler);
509 new_ka.sa.sa_handler = compat_ptr(handler);
510 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
511 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
516 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
518 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
519 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
520 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
526 * Note: it is necessary to treat how as an unsigned int, with the
527 * corresponding cast to a signed int to insure that the proper
528 * conversion (sign extension) between the register representation
529 * of a signed int (msr in 32-bit mode) and the register representation
530 * of a signed int (msr in 64-bit mode) is performed.
532 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
533 compat_sigset_t __user *oset, size_t sigsetsize)
538 mm_segment_t old_fs = get_fs();
541 if (get_sigset_t(&s, set))
546 /* This is valid because of the set_fs() */
547 up = (sigset_t __user *) &s;
548 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
554 if (put_sigset_t(oset, &s))
560 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
564 mm_segment_t old_fs = get_fs();
567 /* The __user pointer cast is valid because of the set_fs() */
568 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
571 if (put_sigset_t(set, &s))
578 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
582 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
585 /* If you change siginfo_t structure, please be sure
586 * this code is fixed accordingly.
587 * It should never copy any pad contained in the structure
588 * to avoid security leaks, but must copy the generic
589 * 3 ints plus the relevant union member.
590 * This routine must convert siginfo from 64bit to 32bit as well
593 err = __put_user(s->si_signo, &d->si_signo);
594 err |= __put_user(s->si_errno, &d->si_errno);
595 err |= __put_user((short)s->si_code, &d->si_code);
597 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
599 else switch(s->si_code >> 16) {
600 case __SI_CHLD >> 16:
601 err |= __put_user(s->si_pid, &d->si_pid);
602 err |= __put_user(s->si_uid, &d->si_uid);
603 err |= __put_user(s->si_utime, &d->si_utime);
604 err |= __put_user(s->si_stime, &d->si_stime);
605 err |= __put_user(s->si_status, &d->si_status);
607 case __SI_FAULT >> 16:
608 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
611 case __SI_POLL >> 16:
612 err |= __put_user(s->si_band, &d->si_band);
613 err |= __put_user(s->si_fd, &d->si_fd);
615 case __SI_TIMER >> 16:
616 err |= __put_user(s->si_tid, &d->si_tid);
617 err |= __put_user(s->si_overrun, &d->si_overrun);
618 err |= __put_user(s->si_int, &d->si_int);
620 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
621 case __SI_MESGQ >> 16:
622 err |= __put_user(s->si_int, &d->si_int);
624 case __SI_KILL >> 16:
626 err |= __put_user(s->si_pid, &d->si_pid);
627 err |= __put_user(s->si_uid, &d->si_uid);
633 #define copy_siginfo_to_user copy_siginfo_to_user32
635 /* mostly stolen from arch/s390/kernel/compat_signal.c */
636 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
641 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
644 err = __get_user(to->si_signo, &from->si_signo);
645 err |= __get_user(to->si_errno, &from->si_errno);
646 err |= __get_user(to->si_code, &from->si_code);
649 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
651 switch (to->si_code >> 16) {
652 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
653 case __SI_MESGQ >> 16:
654 err |= __get_user(to->si_int, &from->si_int);
656 case __SI_KILL >> 16:
657 err |= __get_user(to->si_pid, &from->si_pid);
658 err |= __get_user(to->si_uid, &from->si_uid);
660 case __SI_CHLD >> 16:
661 err |= __get_user(to->si_pid, &from->si_pid);
662 err |= __get_user(to->si_uid, &from->si_uid);
663 err |= __get_user(to->si_utime, &from->si_utime);
664 err |= __get_user(to->si_stime, &from->si_stime);
665 err |= __get_user(to->si_status, &from->si_status);
667 case __SI_FAULT >> 16:
668 err |= __get_user(tmp, &from->si_addr);
669 to->si_addr = (void __user *)(u64) tmp;
671 case __SI_POLL >> 16:
672 err |= __get_user(to->si_band, &from->si_band);
673 err |= __get_user(to->si_fd, &from->si_fd);
675 case __SI_TIMER >> 16:
676 err |= __get_user(to->si_tid, &from->si_tid);
677 err |= __get_user(to->si_overrun, &from->si_overrun);
678 err |= __get_user(to->si_int, &from->si_int);
688 * Note: it is necessary to treat pid and sig as unsigned ints, with the
689 * corresponding cast to a signed int to insure that the proper conversion
690 * (sign extension) between the register representation of a signed int
691 * (msr in 32-bit mode) and the register representation of a signed int
692 * (msr in 64-bit mode) is performed.
694 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
698 mm_segment_t old_fs = get_fs();
700 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
701 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
704 /* The __user pointer cast is valid becasuse of the set_fs() */
705 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
710 * Start Alternate signal stack support
713 * sigaltatck compat_sys_sigaltstack
716 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
717 int r6, int r7, int r8, struct pt_regs *regs)
719 stack_32_t __user * newstack = compat_ptr(__new);
720 stack_32_t __user * oldstack = compat_ptr(__old);
728 * set sp to the user stack on entry to the system call
729 * the system call router sets R9 to the saved registers
733 /* Put new stack info in local 64 bit stack struct */
735 if (get_user(ss_sp, &newstack->ss_sp) ||
736 __get_user(uss.ss_flags, &newstack->ss_flags) ||
737 __get_user(uss.ss_size, &newstack->ss_size))
739 uss.ss_sp = compat_ptr(ss_sp);
744 /* The __user pointer casts are valid because of the set_fs() */
745 ret = do_sigaltstack(
746 newstack ? (stack_t __user *) &uss : NULL,
747 oldstack ? (stack_t __user *) &uoss : NULL,
750 /* Copy the stack information to the user output buffer */
751 if (!ret && oldstack &&
752 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
753 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
754 __put_user(uoss.ss_size, &oldstack->ss_size)))
758 #endif /* CONFIG_PPC64 */
762 * Restore the user process's signal mask
765 extern void restore_sigmask(sigset_t *set);
766 #else /* CONFIG_PPC64 */
767 static void restore_sigmask(sigset_t *set)
769 sigdelsetmask(set, ~_BLOCKABLE);
770 spin_lock_irq(¤t->sighand->siglock);
771 current->blocked = *set;
773 spin_unlock_irq(¤t->sighand->siglock);
778 * Set up a signal frame for a "real-time" signal handler
779 * (one which gets siginfo).
781 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
782 siginfo_t *info, sigset_t *oldset,
783 struct pt_regs *regs, unsigned long newsp)
785 struct rt_sigframe __user *rt_sf;
786 struct mcontext __user *frame;
787 unsigned long origsp = newsp;
789 /* Set up Signal Frame */
790 /* Put a Real Time Context onto stack */
791 newsp -= sizeof(*rt_sf);
792 rt_sf = (struct rt_sigframe __user *)newsp;
794 /* create a stack frame for the caller of the handler */
795 newsp -= __SIGNAL_FRAMESIZE + 16;
797 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
800 /* Put the siginfo & fill in most of the ucontext */
801 if (copy_siginfo_to_user(&rt_sf->info, info)
802 || __put_user(0, &rt_sf->uc.uc_flags)
803 || __put_user(0, &rt_sf->uc.uc_link)
804 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
805 || __put_user(sas_ss_flags(regs->gpr[1]),
806 &rt_sf->uc.uc_stack.ss_flags)
807 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
808 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
810 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
813 /* Save user registers on the stack */
814 frame = &rt_sf->uc.uc_mcontext;
815 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
816 if (save_user_regs(regs, frame, 0))
818 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
820 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
822 regs->link = (unsigned long) frame->tramp;
825 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
827 if (put_user(regs->gpr[1], (u32 __user *)newsp))
829 regs->gpr[1] = newsp;
831 regs->gpr[4] = (unsigned long) &rt_sf->info;
832 regs->gpr[5] = (unsigned long) &rt_sf->uc;
833 regs->gpr[6] = (unsigned long) rt_sf;
834 regs->nip = (unsigned long) ka->sa.sa_handler;
835 /* enter the signal handler in big-endian mode */
836 regs->msr &= ~MSR_LE;
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;
863 /* no need to check access_ok(mcp), since mcp < 4GB */
866 if (__get_user(mcp, &ucp->uc_regs))
868 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
871 restore_sigmask(&set);
872 if (restore_user_regs(regs, mcp, sig))
878 long sys_swapcontext(struct ucontext __user *old_ctx,
879 struct ucontext __user *new_ctx,
880 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
884 /* Context size is for future use. Right now, we only make sure
885 * we are passed something we understand
887 if (ctx_size < sizeof(struct ucontext))
890 if (old_ctx != NULL) {
891 struct mcontext __user *mctx;
894 * old_ctx might not be 16-byte aligned, in which
895 * case old_ctx->uc_mcontext won't be either.
896 * Because we have the old_ctx->uc_pad2 field
897 * before old_ctx->uc_mcontext, we need to round down
898 * from &old_ctx->uc_mcontext to a 16-byte boundary.
900 mctx = (struct mcontext __user *)
901 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
902 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
903 || save_user_regs(regs, mctx, 0)
904 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
905 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
910 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
911 || __get_user(tmp, (u8 __user *) new_ctx)
912 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
916 * If we get a fault copying the context into the kernel's
917 * image of the user's registers, we can't just return -EFAULT
918 * because the user's registers will be corrupted. For instance
919 * the NIP value may have been updated but not some of the
920 * other registers. Given that we have done the access_ok
921 * and successfully read the first and last bytes of the region
922 * above, this should only happen in an out-of-memory situation
923 * or if another thread unmaps the region containing the context.
924 * We kill the task with a SIGSEGV in this situation.
926 if (do_setcontext(new_ctx, regs, 0))
929 set_thread_flag(TIF_RESTOREALL);
933 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
934 struct pt_regs *regs)
936 struct rt_sigframe __user *rt_sf;
938 /* Always make any pending restarted system calls return -EINTR */
939 current_thread_info()->restart_block.fn = do_no_restart_syscall;
941 rt_sf = (struct rt_sigframe __user *)
942 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
943 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
945 if (do_setcontext(&rt_sf->uc, regs, 1))
949 * It's not clear whether or why it is desirable to save the
950 * sigaltstack setting on signal delivery and restore it on
951 * signal return. But other architectures do this and we have
952 * always done it up until now so it is probably better not to
953 * change it. -- paulus
957 * We use the compat_sys_ version that does the 32/64 bits conversion
958 * and takes userland pointer directly. What about error checking ?
961 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
963 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
965 set_thread_flag(TIF_RESTOREALL);
969 force_sig(SIGSEGV, current);
974 int sys_debug_setcontext(struct ucontext __user *ctx,
975 int ndbg, struct sig_dbg_op __user *dbg,
976 int r6, int r7, int r8,
977 struct pt_regs *regs)
979 struct sig_dbg_op op;
982 unsigned long new_msr = regs->msr;
983 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
984 unsigned long new_dbcr0 = current->thread.dbcr0;
987 for (i=0; i<ndbg; i++) {
988 if (copy_from_user(&op, dbg + i, sizeof(op)))
990 switch (op.dbg_type) {
991 case SIG_DBG_SINGLE_STEPPING:
992 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
995 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
998 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
1007 case SIG_DBG_BRANCH_TRACING:
1008 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1023 /* We wait until here to actually install the values in the
1024 registers so if we fail in the above loop, it will not
1025 affect the contents of these registers. After this point,
1026 failure is a problem, anyway, and it's very unlikely unless
1027 the user is really doing something wrong. */
1028 regs->msr = new_msr;
1029 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1030 current->thread.dbcr0 = new_dbcr0;
1033 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1034 || __get_user(tmp, (u8 __user *) ctx)
1035 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1039 * If we get a fault copying the context into the kernel's
1040 * image of the user's registers, we can't just return -EFAULT
1041 * because the user's registers will be corrupted. For instance
1042 * the NIP value may have been updated but not some of the
1043 * other registers. Given that we have done the access_ok
1044 * and successfully read the first and last bytes of the region
1045 * above, this should only happen in an out-of-memory situation
1046 * or if another thread unmaps the region containing the context.
1047 * We kill the task with a SIGSEGV in this situation.
1049 if (do_setcontext(ctx, regs, 1)) {
1050 force_sig(SIGSEGV, current);
1055 * It's not clear whether or why it is desirable to save the
1056 * sigaltstack setting on signal delivery and restore it on
1057 * signal return. But other architectures do this and we have
1058 * always done it up until now so it is probably better not to
1059 * change it. -- paulus
1061 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1063 set_thread_flag(TIF_RESTOREALL);
1070 * OK, we're invoking a handler
1072 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1073 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1074 unsigned long newsp)
1076 struct sigcontext __user *sc;
1077 struct sigregs __user *frame;
1078 unsigned long origsp = newsp;
1080 /* Set up Signal Frame */
1081 newsp -= sizeof(struct sigregs);
1082 frame = (struct sigregs __user *) newsp;
1084 /* Put a sigcontext on the stack */
1085 newsp -= sizeof(*sc);
1086 sc = (struct sigcontext __user *) newsp;
1088 /* create a stack frame for the caller of the handler */
1089 newsp -= __SIGNAL_FRAMESIZE;
1091 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1095 #error "Please adjust handle_signal()"
1097 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1098 || __put_user(oldset->sig[0], &sc->oldmask)
1100 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1102 || __put_user(oldset->sig[1], &sc->_unused[3])
1104 || __put_user(to_user_ptr(frame), &sc->regs)
1105 || __put_user(sig, &sc->signal))
1108 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1109 if (save_user_regs(regs, &frame->mctx, 0))
1111 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1113 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1115 regs->link = (unsigned long) frame->mctx.tramp;
1118 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1120 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1122 regs->gpr[1] = newsp;
1124 regs->gpr[4] = (unsigned long) sc;
1125 regs->nip = (unsigned long) ka->sa.sa_handler;
1126 /* enter the signal handler in big-endian mode */
1127 regs->msr &= ~MSR_LE;
1134 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1135 regs, frame, newsp);
1137 force_sigsegv(sig, current);
1142 * Do a signal return; undo the signal stack.
1144 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1145 struct pt_regs *regs)
1147 struct sigcontext __user *sc;
1148 struct sigcontext sigctx;
1149 struct mcontext __user *sr;
1152 /* Always make any pending restarted system calls return -EINTR */
1153 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1155 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1156 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1161 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1162 * unused part of the signal stackframe
1164 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1166 set.sig[0] = sigctx.oldmask;
1167 set.sig[1] = sigctx._unused[3];
1169 restore_sigmask(&set);
1171 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1172 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1173 || restore_user_regs(regs, sr, 1))
1176 set_thread_flag(TIF_RESTOREALL);
1180 force_sig(SIGSEGV, current);
1185 * Note that 'init' is a special process: it doesn't get signals it doesn't
1186 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1189 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1192 struct k_sigaction ka;
1197 if (try_to_freeze()) {
1199 if (!signal_pending(current))
1204 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1205 oldset = ¤t->saved_sigmask;
1207 oldset = ¤t->blocked;
1209 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1213 if (TRAP(regs) == 0x0C00 /* System Call! */
1214 && regs->ccr & 0x10000000 /* error signalled */
1215 && ((ret = regs->gpr[3]) == ERESTARTSYS
1216 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1217 || ret == ERESTART_RESTARTBLOCK)) {
1220 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1221 || (ret == ERESTARTSYS
1222 && !(ka.sa.sa_flags & SA_RESTART)))) {
1223 /* make the system call return an EINTR error */
1224 regs->result = -EINTR;
1225 regs->gpr[3] = EINTR;
1226 /* note that the cr0.SO bit is already set */
1228 regs->nip -= 4; /* Back up & retry system call */
1231 if (ret == ERESTART_RESTARTBLOCK)
1232 regs->gpr[0] = __NR_restart_syscall;
1234 regs->gpr[3] = regs->orig_gpr3;
1239 /* No signal to deliver -- put the saved sigmask back */
1240 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1241 clear_thread_flag(TIF_RESTORE_SIGMASK);
1242 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
1244 return 0; /* no signals delivered */
1247 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1248 && !on_sig_stack(regs->gpr[1]))
1249 newsp = current->sas_ss_sp + current->sas_ss_size;
1251 newsp = regs->gpr[1];
1256 * Reenable the DABR before delivering the signal to
1257 * user space. The DABR will have been cleared if it
1258 * triggered inside the kernel.
1260 if (current->thread.dabr)
1261 set_dabr(current->thread.dabr);
1264 /* Whee! Actually deliver the signal. */
1265 if (ka.sa.sa_flags & SA_SIGINFO)
1266 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1268 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1271 spin_lock_irq(¤t->sighand->siglock);
1272 sigorsets(¤t->blocked, ¤t->blocked,
1274 if (!(ka.sa.sa_flags & SA_NODEFER))
1275 sigaddset(¤t->blocked, signr);
1276 recalc_sigpending();
1277 spin_unlock_irq(¤t->sighand->siglock);
1278 /* A signal was successfully delivered; the saved sigmask is in
1279 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
1280 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1281 clear_thread_flag(TIF_RESTORE_SIGMASK);
1283 tracehook_report_handle_signal(signr, &ka, oldset, regs);