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.
79 #define sigreturn_exit(regs) return 0
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 static inline compat_uptr_t to_user_ptr(void *kp)
148 return (compat_uptr_t)(u64)kp;
151 #define from_user_ptr(p) compat_ptr(p)
153 static inline int save_general_regs(struct pt_regs *regs,
154 struct mcontext __user *frame)
156 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
159 for (i = 0; i <= PT_RESULT; i ++)
160 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
165 static inline int restore_general_regs(struct pt_regs *regs,
166 struct mcontext __user *sr)
168 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
171 for (i = 0; i <= PT_RESULT; i++) {
172 if ((i == PT_MSR) || (i == PT_SOFTE))
174 if (__get_user(gregs[i], &sr->mc_gregs[i]))
180 #else /* CONFIG_PPC64 */
182 extern void sigreturn_exit(struct pt_regs *);
184 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
186 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
188 return copy_to_user(uset, set, sizeof(*uset));
191 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
193 return copy_from_user(set, uset, sizeof(*uset));
196 static inline int get_old_sigaction(struct k_sigaction *new_ka,
197 struct old_sigaction __user *act)
201 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
202 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
203 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
205 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
206 __get_user(mask, &act->sa_mask);
207 siginitset(&new_ka->sa.sa_mask, mask);
211 #define to_user_ptr(p) (p)
212 #define from_user_ptr(p) (p)
214 static inline int save_general_regs(struct pt_regs *regs,
215 struct mcontext __user *frame)
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, int p2, int p3, int p4, int p6, int p7,
242 struct pt_regs *regs)
247 spin_lock_irq(¤t->sighand->siglock);
248 saveset = current->blocked;
249 siginitset(¤t->blocked, mask);
251 spin_unlock_irq(¤t->sighand->siglock);
253 regs->result = -EINTR;
254 regs->gpr[3] = EINTR;
255 regs->ccr |= 0x10000000;
257 current->state = TASK_INTERRUPTIBLE;
259 if (do_signal(&saveset, regs))
260 sigreturn_exit(regs);
264 long sys_rt_sigsuspend(
266 compat_sigset_t __user *unewset,
268 sigset_t __user *unewset,
270 size_t sigsetsize, int p3, int p4,
271 int p6, int p7, struct pt_regs *regs)
273 sigset_t saveset, newset;
275 /* XXX: Don't preclude handling different sized sigset_t's. */
276 if (sigsetsize != sizeof(sigset_t))
279 if (get_sigset_t(&newset, unewset))
281 sigdelsetmask(&newset, ~_BLOCKABLE);
283 spin_lock_irq(¤t->sighand->siglock);
284 saveset = current->blocked;
285 current->blocked = newset;
287 spin_unlock_irq(¤t->sighand->siglock);
289 regs->result = -EINTR;
290 regs->gpr[3] = EINTR;
291 regs->ccr |= 0x10000000;
293 current->state = TASK_INTERRUPTIBLE;
295 if (do_signal(&saveset, regs))
296 sigreturn_exit(regs);
301 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
302 int r6, int r7, int r8, struct pt_regs *regs)
304 return do_sigaltstack(uss, uoss, regs->gpr[1]);
308 long sys_sigaction(int sig, struct old_sigaction __user *act,
309 struct old_sigaction __user *oact)
311 struct k_sigaction new_ka, old_ka;
320 if (get_old_sigaction(&new_ka, act))
324 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
326 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
327 __put_user(to_user_ptr(old_ka.sa.sa_handler),
328 &oact->sa_handler) ||
329 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
330 &oact->sa_restorer) ||
331 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
332 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
340 * When we have signals to deliver, we set up on the
341 * user stack, going down from the original stack pointer:
343 * a sigcontext struct
344 * a gap of __SIGNAL_FRAMESIZE bytes
346 * Each of these things must be a multiple of 16 bytes in size.
350 struct mcontext mctx; /* all the register values */
352 * Programs using the rs6000/xcoff abi can save up to 19 gp
353 * regs and 18 fp regs below sp before decrementing it.
358 /* We use the mc_pad field for the signal return trampoline. */
362 * When we have rt signals to deliver, we set up on the
363 * user stack, going down from the original stack pointer:
364 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
365 * a gap of __SIGNAL_FRAMESIZE+16 bytes
366 * (the +16 is to get the siginfo and ucontext in the same
367 * positions as in older kernels).
369 * Each of these things must be a multiple of 16 bytes in size.
374 compat_siginfo_t info;
380 * Programs using the rs6000/xcoff abi can save up to 19 gp
381 * regs and 18 fp regs below sp before decrementing it.
387 * Save the current user registers on the user stack.
388 * We only save the altivec/spe registers if the process has used
389 * altivec/spe instructions at some point.
391 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
395 CHECK_FULL_REGS(regs);
397 /* Make sure floating point registers are stored in regs */
398 flush_fp_to_thread(current);
400 /* save general and floating-point registers */
401 if (save_general_regs(regs, frame) ||
402 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
403 ELF_NFPREG * sizeof(double)))
406 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
408 #ifdef CONFIG_ALTIVEC
409 /* save altivec registers */
410 if (current->thread.used_vr) {
411 flush_altivec_to_thread(current);
412 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
413 ELF_NVRREG * sizeof(vector128)))
415 /* set MSR_VEC in the saved MSR value to indicate that
416 frame->mc_vregs contains valid data */
417 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
420 /* else assert((regs->msr & MSR_VEC) == 0) */
422 /* We always copy to/from vrsave, it's 0 if we don't have or don't
423 * use altivec. Since VSCR only contains 32 bits saved in the least
424 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
425 * most significant bits of that same vector. --BenH
427 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
429 #endif /* CONFIG_ALTIVEC */
432 /* save spe registers */
433 if (current->thread.used_spe) {
434 flush_spe_to_thread(current);
435 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
436 ELF_NEVRREG * sizeof(u32)))
438 /* set MSR_SPE in the saved MSR value to indicate that
439 frame->mc_vregs contains valid data */
440 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
443 /* else assert((regs->msr & MSR_SPE) == 0) */
445 /* We always copy to/from spefscr */
446 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
448 #endif /* CONFIG_SPE */
451 /* Set up the sigreturn trampoline: li r0,sigret; sc */
452 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
453 || __put_user(0x44000002UL, &frame->tramp[1]))
455 flush_icache_range((unsigned long) &frame->tramp[0],
456 (unsigned long) &frame->tramp[2]);
463 * Restore the current user register values from the user stack,
466 static long restore_user_regs(struct pt_regs *regs,
467 struct mcontext __user *sr, int sig)
470 unsigned int save_r2 = 0;
471 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
476 * restore general registers but not including MSR or SOFTE. Also
477 * take care of keeping r2 (TLS) intact if not a signal
480 save_r2 = (unsigned int)regs->gpr[2];
481 err = restore_general_regs(regs, sr);
483 regs->gpr[2] = (unsigned long) save_r2;
487 /* force the process to reload the FP registers from
488 current->thread when it next does FP instructions */
489 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
490 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
491 sizeof(sr->mc_fregs)))
494 #ifdef CONFIG_ALTIVEC
495 /* force the process to reload the altivec registers from
496 current->thread when it next does altivec instructions */
497 regs->msr &= ~MSR_VEC;
498 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
499 /* restore altivec registers from the stack */
500 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
501 sizeof(sr->mc_vregs)))
503 } else if (current->thread.used_vr)
504 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
506 /* Always get VRSAVE back */
507 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
509 #endif /* CONFIG_ALTIVEC */
512 /* force the process to reload the spe registers from
513 current->thread when it next does spe instructions */
514 regs->msr &= ~MSR_SPE;
515 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
516 /* restore spe registers from the stack */
517 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
518 ELF_NEVRREG * sizeof(u32)))
520 } else if (current->thread.used_spe)
521 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
523 /* Always get SPEFSCR back */
524 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
526 #endif /* CONFIG_SPE */
530 if (last_task_used_math == current)
531 last_task_used_math = NULL;
532 if (last_task_used_altivec == current)
533 last_task_used_altivec = NULL;
535 if (last_task_used_spe == current)
536 last_task_used_spe = NULL;
544 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
545 struct sigaction32 __user *oact, size_t sigsetsize)
547 struct k_sigaction new_ka, old_ka;
550 /* XXX: Don't preclude handling different sized sigset_t's. */
551 if (sigsetsize != sizeof(compat_sigset_t))
555 compat_uptr_t handler;
557 ret = get_user(handler, &act->sa_handler);
558 new_ka.sa.sa_handler = compat_ptr(handler);
559 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
560 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
565 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
567 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
568 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
569 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
575 * Note: it is necessary to treat how as an unsigned int, with the
576 * corresponding cast to a signed int to insure that the proper
577 * conversion (sign extension) between the register representation
578 * of a signed int (msr in 32-bit mode) and the register representation
579 * of a signed int (msr in 64-bit mode) is performed.
581 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
582 compat_sigset_t __user *oset, size_t sigsetsize)
587 mm_segment_t old_fs = get_fs();
590 if (get_sigset_t(&s, set))
595 /* This is valid because of the set_fs() */
596 up = (sigset_t __user *) &s;
597 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
603 if (put_sigset_t(oset, &s))
609 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
613 mm_segment_t old_fs = get_fs();
616 /* The __user pointer cast is valid because of the set_fs() */
617 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
620 if (put_sigset_t(set, &s))
627 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
631 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
634 /* If you change siginfo_t structure, please be sure
635 * this code is fixed accordingly.
636 * It should never copy any pad contained in the structure
637 * to avoid security leaks, but must copy the generic
638 * 3 ints plus the relevant union member.
639 * This routine must convert siginfo from 64bit to 32bit as well
642 err = __put_user(s->si_signo, &d->si_signo);
643 err |= __put_user(s->si_errno, &d->si_errno);
644 err |= __put_user((short)s->si_code, &d->si_code);
646 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
648 else switch(s->si_code >> 16) {
649 case __SI_CHLD >> 16:
650 err |= __put_user(s->si_pid, &d->si_pid);
651 err |= __put_user(s->si_uid, &d->si_uid);
652 err |= __put_user(s->si_utime, &d->si_utime);
653 err |= __put_user(s->si_stime, &d->si_stime);
654 err |= __put_user(s->si_status, &d->si_status);
656 case __SI_FAULT >> 16:
657 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
660 case __SI_POLL >> 16:
661 err |= __put_user(s->si_band, &d->si_band);
662 err |= __put_user(s->si_fd, &d->si_fd);
664 case __SI_TIMER >> 16:
665 err |= __put_user(s->si_tid, &d->si_tid);
666 err |= __put_user(s->si_overrun, &d->si_overrun);
667 err |= __put_user(s->si_int, &d->si_int);
669 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
670 case __SI_MESGQ >> 16:
671 err |= __put_user(s->si_int, &d->si_int);
673 case __SI_KILL >> 16:
675 err |= __put_user(s->si_pid, &d->si_pid);
676 err |= __put_user(s->si_uid, &d->si_uid);
682 #define copy_siginfo_to_user copy_siginfo_to_user32
685 * Note: it is necessary to treat pid and sig as unsigned ints, with the
686 * corresponding cast to a signed int to insure that the proper conversion
687 * (sign extension) between the register representation of a signed int
688 * (msr in 32-bit mode) and the register representation of a signed int
689 * (msr in 64-bit mode) is performed.
691 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
695 mm_segment_t old_fs = get_fs();
697 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
698 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
701 /* The __user pointer cast is valid becasuse of the set_fs() */
702 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
707 * Start Alternate signal stack support
710 * sigaltatck compat_sys_sigaltstack
713 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
714 int r6, int r7, int r8, struct pt_regs *regs)
716 stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
717 stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
725 * set sp to the user stack on entry to the system call
726 * the system call router sets R9 to the saved registers
730 /* Put new stack info in local 64 bit stack struct */
732 if (get_user(ss_sp, &newstack->ss_sp) ||
733 __get_user(uss.ss_flags, &newstack->ss_flags) ||
734 __get_user(uss.ss_size, &newstack->ss_size))
736 uss.ss_sp = compat_ptr(ss_sp);
741 /* The __user pointer casts are valid because of the set_fs() */
742 ret = do_sigaltstack(
743 newstack ? (stack_t __user *) &uss : NULL,
744 oldstack ? (stack_t __user *) &uoss : NULL,
747 /* Copy the stack information to the user output buffer */
748 if (!ret && oldstack &&
749 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
750 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
751 __put_user(uoss.ss_size, &oldstack->ss_size)))
755 #endif /* CONFIG_PPC64 */
759 * Restore the user process's signal mask
762 extern void restore_sigmask(sigset_t *set);
763 #else /* CONFIG_PPC64 */
764 static void restore_sigmask(sigset_t *set)
766 sigdelsetmask(set, ~_BLOCKABLE);
767 spin_lock_irq(¤t->sighand->siglock);
768 current->blocked = *set;
770 spin_unlock_irq(¤t->sighand->siglock);
775 * Set up a signal frame for a "real-time" signal handler
776 * (one which gets siginfo).
778 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
779 siginfo_t *info, sigset_t *oldset,
780 struct pt_regs *regs, unsigned long newsp)
782 struct rt_sigframe __user *rt_sf;
783 struct mcontext __user *frame;
784 unsigned long origsp = newsp;
786 /* Set up Signal Frame */
787 /* Put a Real Time Context onto stack */
788 newsp -= sizeof(*rt_sf);
789 rt_sf = (struct rt_sigframe __user *)newsp;
791 /* create a stack frame for the caller of the handler */
792 newsp -= __SIGNAL_FRAMESIZE + 16;
794 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
797 /* Put the siginfo & fill in most of the ucontext */
798 if (copy_siginfo_to_user(&rt_sf->info, info)
799 || __put_user(0, &rt_sf->uc.uc_flags)
800 || __put_user(0, &rt_sf->uc.uc_link)
801 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
802 || __put_user(sas_ss_flags(regs->gpr[1]),
803 &rt_sf->uc.uc_stack.ss_flags)
804 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
805 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
807 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
810 /* Save user registers on the stack */
811 frame = &rt_sf->uc.uc_mcontext;
812 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
813 if (save_user_regs(regs, frame, 0))
815 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
817 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
819 regs->link = (unsigned long) frame->tramp;
821 if (put_user(regs->gpr[1], (u32 __user *)newsp))
823 regs->gpr[1] = newsp;
825 regs->gpr[4] = (unsigned long) &rt_sf->info;
826 regs->gpr[5] = (unsigned long) &rt_sf->uc;
827 regs->gpr[6] = (unsigned long) rt_sf;
828 regs->nip = (unsigned long) ka->sa.sa_handler;
833 if (test_thread_flag(TIF_SINGLESTEP))
834 ptrace_notify(SIGTRAP);
840 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
843 force_sigsegv(sig, current);
847 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
850 struct mcontext __user *mcp;
852 if (get_sigset_t(&set, &ucp->uc_sigmask))
858 if (__get_user(cmcp, &ucp->uc_regs))
860 mcp = (struct mcontext __user *)(u64)cmcp;
863 if (__get_user(mcp, &ucp->uc_regs))
866 restore_sigmask(&set);
867 if (restore_user_regs(regs, mcp, sig))
873 long sys_swapcontext(struct ucontext __user *old_ctx,
874 struct ucontext __user *new_ctx,
875 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
879 /* Context size is for future use. Right now, we only make sure
880 * we are passed something we understand
882 if (ctx_size < sizeof(struct ucontext))
885 if (old_ctx != NULL) {
886 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
887 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
888 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
889 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
895 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
896 || __get_user(tmp, (u8 __user *) new_ctx)
897 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
901 * If we get a fault copying the context into the kernel's
902 * image of the user's registers, we can't just return -EFAULT
903 * because the user's registers will be corrupted. For instance
904 * the NIP value may have been updated but not some of the
905 * other registers. Given that we have done the access_ok
906 * and successfully read the first and last bytes of the region
907 * above, this should only happen in an out-of-memory situation
908 * or if another thread unmaps the region containing the context.
909 * We kill the task with a SIGSEGV in this situation.
911 if (do_setcontext(new_ctx, regs, 0))
913 sigreturn_exit(regs);
914 /* doesn't actually return back to here */
918 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
919 struct pt_regs *regs)
921 struct rt_sigframe __user *rt_sf;
923 /* Always make any pending restarted system calls return -EINTR */
924 current_thread_info()->restart_block.fn = do_no_restart_syscall;
926 rt_sf = (struct rt_sigframe __user *)
927 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
928 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
930 if (do_setcontext(&rt_sf->uc, regs, 1))
934 * It's not clear whether or why it is desirable to save the
935 * sigaltstack setting on signal delivery and restore it on
936 * signal return. But other architectures do this and we have
937 * always done it up until now so it is probably better not to
938 * change it. -- paulus
942 * We use the compat_sys_ version that does the 32/64 bits conversion
943 * and takes userland pointer directly. What about error checking ?
946 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
947 return (int)regs->result;
949 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
950 sigreturn_exit(regs); /* doesn't return here */
955 force_sig(SIGSEGV, current);
960 int sys_debug_setcontext(struct ucontext __user *ctx,
961 int ndbg, struct sig_dbg_op __user *dbg,
962 int r6, int r7, int r8,
963 struct pt_regs *regs)
965 struct sig_dbg_op op;
967 unsigned long new_msr = regs->msr;
968 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
969 unsigned long new_dbcr0 = current->thread.dbcr0;
972 for (i=0; i<ndbg; i++) {
973 if (__copy_from_user(&op, dbg, sizeof(op)))
975 switch (op.dbg_type) {
976 case SIG_DBG_SINGLE_STEPPING:
977 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
980 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
983 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
992 case SIG_DBG_BRANCH_TRACING:
993 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1008 /* We wait until here to actually install the values in the
1009 registers so if we fail in the above loop, it will not
1010 affect the contents of these registers. After this point,
1011 failure is a problem, anyway, and it's very unlikely unless
1012 the user is really doing something wrong. */
1013 regs->msr = new_msr;
1014 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1015 current->thread.dbcr0 = new_dbcr0;
1019 * If we get a fault copying the context into the kernel's
1020 * image of the user's registers, we can't just return -EFAULT
1021 * because the user's registers will be corrupted. For instance
1022 * the NIP value may have been updated but not some of the
1023 * other registers. Given that we have done the access_ok
1024 * and successfully read the first and last bytes of the region
1025 * above, this should only happen in an out-of-memory situation
1026 * or if another thread unmaps the region containing the context.
1027 * We kill the task with a SIGSEGV in this situation.
1029 if (do_setcontext(ctx, regs, 1)) {
1030 force_sig(SIGSEGV, current);
1035 * It's not clear whether or why it is desirable to save the
1036 * sigaltstack setting on signal delivery and restore it on
1037 * signal return. But other architectures do this and we have
1038 * always done it up until now so it is probably better not to
1039 * change it. -- paulus
1041 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1043 sigreturn_exit(regs);
1044 /* doesn't actually return back to here */
1052 * OK, we're invoking a handler
1054 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1055 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1056 unsigned long newsp)
1058 struct sigcontext __user *sc;
1059 struct sigregs __user *frame;
1060 unsigned long origsp = newsp;
1062 /* Set up Signal Frame */
1063 newsp -= sizeof(struct sigregs);
1064 frame = (struct sigregs __user *) newsp;
1066 /* Put a sigcontext on the stack */
1067 newsp -= sizeof(*sc);
1068 sc = (struct sigcontext __user *) newsp;
1070 /* create a stack frame for the caller of the handler */
1071 newsp -= __SIGNAL_FRAMESIZE;
1073 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1077 #error "Please adjust handle_signal()"
1079 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1080 || __put_user(oldset->sig[0], &sc->oldmask)
1082 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1084 || __put_user(oldset->sig[1], &sc->_unused[3])
1086 || __put_user(to_user_ptr(frame), &sc->regs)
1087 || __put_user(sig, &sc->signal))
1090 if (vdso32_sigtramp && current->thread.vdso_base) {
1091 if (save_user_regs(regs, &frame->mctx, 0))
1093 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1095 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1097 regs->link = (unsigned long) frame->mctx.tramp;
1100 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1102 regs->gpr[1] = newsp;
1104 regs->gpr[4] = (unsigned long) sc;
1105 regs->nip = (unsigned long) ka->sa.sa_handler;
1110 if (test_thread_flag(TIF_SINGLESTEP))
1111 ptrace_notify(SIGTRAP);
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))
1161 return (int)regs->result;
1163 sigreturn_exit(regs); /* doesn't return */
1168 force_sig(SIGSEGV, current);
1173 * Note that 'init' is a special process: it doesn't get signals it doesn't
1174 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1177 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1180 struct k_sigaction ka;
1181 unsigned int frame, newsp;
1185 if (try_to_freeze()) {
1187 if (!signal_pending(current))
1193 oldset = ¤t->blocked;
1197 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1201 if (TRAP(regs) == 0x0C00 /* System Call! */
1202 && regs->ccr & 0x10000000 /* error signalled */
1203 && ((ret = regs->gpr[3]) == ERESTARTSYS
1204 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1205 || ret == ERESTART_RESTARTBLOCK)) {
1208 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1209 || (ret == ERESTARTSYS
1210 && !(ka.sa.sa_flags & SA_RESTART)))) {
1211 /* make the system call return an EINTR error */
1212 regs->result = -EINTR;
1213 regs->gpr[3] = EINTR;
1214 /* note that the cr0.SO bit is already set */
1216 regs->nip -= 4; /* Back up & retry system call */
1219 if (ret == ERESTART_RESTARTBLOCK)
1220 regs->gpr[0] = __NR_restart_syscall;
1222 regs->gpr[3] = regs->orig_gpr3;
1227 return 0; /* no signals delivered */
1229 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1230 && !on_sig_stack(regs->gpr[1]))
1231 newsp = current->sas_ss_sp + current->sas_ss_size;
1233 newsp = regs->gpr[1];
1238 * Reenable the DABR before delivering the signal to
1239 * user space. The DABR will have been cleared if it
1240 * triggered inside the kernel.
1242 if (current->thread.dabr)
1243 set_dabr(current->thread.dabr);
1246 /* Whee! Actually deliver the signal. */
1247 if (ka.sa.sa_flags & SA_SIGINFO)
1248 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1250 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1253 spin_lock_irq(¤t->sighand->siglock);
1254 sigorsets(¤t->blocked, ¤t->blocked,
1256 if (!(ka.sa.sa_flags & SA_NODEFER))
1257 sigaddset(¤t->blocked, signr);
1258 recalc_sigpending();
1259 spin_unlock_irq(¤t->sighand->siglock);