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 #define to_user_ptr(p) ptr_to_compat(p)
146 #define from_user_ptr(p) compat_ptr(p)
148 static inline int save_general_regs(struct pt_regs *regs,
149 struct mcontext __user *frame)
151 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
154 WARN_ON(!FULL_REGS(regs));
156 for (i = 0; i <= PT_RESULT; i ++) {
157 if (i == 14 && !FULL_REGS(regs))
159 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 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
184 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
186 return copy_to_user(uset, set, sizeof(*uset));
189 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
191 return copy_from_user(set, uset, sizeof(*uset));
194 static inline int get_old_sigaction(struct k_sigaction *new_ka,
195 struct old_sigaction __user *act)
199 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
200 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
201 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
203 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
204 __get_user(mask, &act->sa_mask);
205 siginitset(&new_ka->sa.sa_mask, mask);
209 #define to_user_ptr(p) ((unsigned long)(p))
210 #define from_user_ptr(p) ((void __user *)(p))
212 static inline int save_general_regs(struct pt_regs *regs,
213 struct mcontext __user *frame)
215 WARN_ON(!FULL_REGS(regs));
216 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
219 static inline int restore_general_regs(struct pt_regs *regs,
220 struct mcontext __user *sr)
222 /* copy up to but not including MSR */
223 if (__copy_from_user(regs, &sr->mc_gregs,
224 PT_MSR * sizeof(elf_greg_t)))
226 /* copy from orig_r3 (the word after the MSR) up to the end */
227 if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
228 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
233 #endif /* CONFIG_PPC64 */
235 int do_signal(sigset_t *oldset, struct pt_regs *regs);
238 * Atomically swap in the new signal mask, and wait for a signal.
240 long sys_sigsuspend(old_sigset_t mask)
243 spin_lock_irq(¤t->sighand->siglock);
244 current->saved_sigmask = current->blocked;
245 siginitset(¤t->blocked, mask);
247 spin_unlock_irq(¤t->sighand->siglock);
249 current->state = TASK_INTERRUPTIBLE;
251 set_thread_flag(TIF_RESTORE_SIGMASK);
252 return -ERESTARTNOHAND;
256 long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
257 int r6, int r7, int r8, struct pt_regs *regs)
259 return do_sigaltstack(uss, uoss, regs->gpr[1]);
263 long sys_sigaction(int sig, struct old_sigaction __user *act,
264 struct old_sigaction __user *oact)
266 struct k_sigaction new_ka, old_ka;
275 if (get_old_sigaction(&new_ka, act))
279 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
281 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
282 __put_user(to_user_ptr(old_ka.sa.sa_handler),
283 &oact->sa_handler) ||
284 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
285 &oact->sa_restorer) ||
286 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
287 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
295 * When we have signals to deliver, we set up on the
296 * user stack, going down from the original stack pointer:
298 * a sigcontext struct
299 * a gap of __SIGNAL_FRAMESIZE bytes
301 * Each of these things must be a multiple of 16 bytes in size.
305 struct mcontext mctx; /* all the register values */
307 * Programs using the rs6000/xcoff abi can save up to 19 gp
308 * regs and 18 fp regs below sp before decrementing it.
313 /* We use the mc_pad field for the signal return trampoline. */
317 * When we have rt signals to deliver, we set up on the
318 * user stack, going down from the original stack pointer:
319 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
320 * a gap of __SIGNAL_FRAMESIZE+16 bytes
321 * (the +16 is to get the siginfo and ucontext in the same
322 * positions as in older kernels).
324 * Each of these things must be a multiple of 16 bytes in size.
329 compat_siginfo_t info;
335 * Programs using the rs6000/xcoff abi can save up to 19 gp
336 * regs and 18 fp regs below sp before decrementing it.
342 * Save the current user registers on the user stack.
343 * We only save the altivec/spe registers if the process has used
344 * altivec/spe instructions at some point.
346 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
349 /* Make sure floating point registers are stored in regs */
350 flush_fp_to_thread(current);
352 /* save general and floating-point registers */
353 if (save_general_regs(regs, frame) ||
354 __copy_to_user(&frame->mc_fregs, current->thread.fpr,
355 ELF_NFPREG * sizeof(double)))
358 #ifdef CONFIG_ALTIVEC
359 /* save altivec registers */
360 if (current->thread.used_vr) {
361 flush_altivec_to_thread(current);
362 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
363 ELF_NVRREG * sizeof(vector128)))
365 /* set MSR_VEC in the saved MSR value to indicate that
366 frame->mc_vregs contains valid data */
367 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
370 /* else assert((regs->msr & MSR_VEC) == 0) */
372 /* We always copy to/from vrsave, it's 0 if we don't have or don't
373 * use altivec. Since VSCR only contains 32 bits saved in the least
374 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
375 * most significant bits of that same vector. --BenH
377 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
379 #endif /* CONFIG_ALTIVEC */
382 /* save spe registers */
383 if (current->thread.used_spe) {
384 flush_spe_to_thread(current);
385 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
386 ELF_NEVRREG * sizeof(u32)))
388 /* set MSR_SPE in the saved MSR value to indicate that
389 frame->mc_vregs contains valid data */
390 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
393 /* else assert((regs->msr & MSR_SPE) == 0) */
395 /* We always copy to/from spefscr */
396 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
398 #endif /* CONFIG_SPE */
401 /* Set up the sigreturn trampoline: li r0,sigret; sc */
402 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
403 || __put_user(0x44000002UL, &frame->tramp[1]))
405 flush_icache_range((unsigned long) &frame->tramp[0],
406 (unsigned long) &frame->tramp[2]);
413 * Restore the current user register values from the user stack,
416 static long restore_user_regs(struct pt_regs *regs,
417 struct mcontext __user *sr, int sig)
420 unsigned int save_r2 = 0;
421 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
426 * restore general registers but not including MSR or SOFTE. Also
427 * take care of keeping r2 (TLS) intact if not a signal
430 save_r2 = (unsigned int)regs->gpr[2];
431 err = restore_general_regs(regs, sr);
433 regs->gpr[2] = (unsigned long) save_r2;
438 * Do this before updating the thread state in
439 * current->thread.fpr/vr/evr. That way, if we get preempted
440 * and another task grabs the FPU/Altivec/SPE, it won't be
441 * tempted to save the current CPU state into the thread_struct
442 * and corrupt what we are writing there.
444 discard_lazy_cpu_state();
446 /* force the process to reload the FP registers from
447 current->thread when it next does FP instructions */
448 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
449 if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
450 sizeof(sr->mc_fregs)))
453 #ifdef CONFIG_ALTIVEC
454 /* force the process to reload the altivec registers from
455 current->thread when it next does altivec instructions */
456 regs->msr &= ~MSR_VEC;
457 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
458 /* restore altivec registers from the stack */
459 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
460 sizeof(sr->mc_vregs)))
462 } else if (current->thread.used_vr)
463 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
465 /* Always get VRSAVE back */
466 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
468 #endif /* CONFIG_ALTIVEC */
471 /* force the process to reload the spe registers from
472 current->thread when it next does spe instructions */
473 regs->msr &= ~MSR_SPE;
474 if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
475 /* restore spe registers from the stack */
476 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
477 ELF_NEVRREG * sizeof(u32)))
479 } else if (current->thread.used_spe)
480 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
482 /* Always get SPEFSCR back */
483 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
485 #endif /* CONFIG_SPE */
491 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
492 struct sigaction32 __user *oact, size_t sigsetsize)
494 struct k_sigaction new_ka, old_ka;
497 /* XXX: Don't preclude handling different sized sigset_t's. */
498 if (sigsetsize != sizeof(compat_sigset_t))
502 compat_uptr_t handler;
504 ret = get_user(handler, &act->sa_handler);
505 new_ka.sa.sa_handler = compat_ptr(handler);
506 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
507 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
512 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
514 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
515 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
516 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
522 * Note: it is necessary to treat how as an unsigned int, with the
523 * corresponding cast to a signed int to insure that the proper
524 * conversion (sign extension) between the register representation
525 * of a signed int (msr in 32-bit mode) and the register representation
526 * of a signed int (msr in 64-bit mode) is performed.
528 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
529 compat_sigset_t __user *oset, size_t sigsetsize)
534 mm_segment_t old_fs = get_fs();
537 if (get_sigset_t(&s, set))
542 /* This is valid because of the set_fs() */
543 up = (sigset_t __user *) &s;
544 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
550 if (put_sigset_t(oset, &s))
556 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
560 mm_segment_t old_fs = get_fs();
563 /* The __user pointer cast is valid because of the set_fs() */
564 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
567 if (put_sigset_t(set, &s))
574 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
578 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
581 /* If you change siginfo_t structure, please be sure
582 * this code is fixed accordingly.
583 * It should never copy any pad contained in the structure
584 * to avoid security leaks, but must copy the generic
585 * 3 ints plus the relevant union member.
586 * This routine must convert siginfo from 64bit to 32bit as well
589 err = __put_user(s->si_signo, &d->si_signo);
590 err |= __put_user(s->si_errno, &d->si_errno);
591 err |= __put_user((short)s->si_code, &d->si_code);
593 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
595 else switch(s->si_code >> 16) {
596 case __SI_CHLD >> 16:
597 err |= __put_user(s->si_pid, &d->si_pid);
598 err |= __put_user(s->si_uid, &d->si_uid);
599 err |= __put_user(s->si_utime, &d->si_utime);
600 err |= __put_user(s->si_stime, &d->si_stime);
601 err |= __put_user(s->si_status, &d->si_status);
603 case __SI_FAULT >> 16:
604 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
607 case __SI_POLL >> 16:
608 err |= __put_user(s->si_band, &d->si_band);
609 err |= __put_user(s->si_fd, &d->si_fd);
611 case __SI_TIMER >> 16:
612 err |= __put_user(s->si_tid, &d->si_tid);
613 err |= __put_user(s->si_overrun, &d->si_overrun);
614 err |= __put_user(s->si_int, &d->si_int);
616 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
617 case __SI_MESGQ >> 16:
618 err |= __put_user(s->si_int, &d->si_int);
620 case __SI_KILL >> 16:
622 err |= __put_user(s->si_pid, &d->si_pid);
623 err |= __put_user(s->si_uid, &d->si_uid);
629 #define copy_siginfo_to_user copy_siginfo_to_user32
632 * Note: it is necessary to treat pid and sig as unsigned ints, with the
633 * corresponding cast to a signed int to insure that the proper conversion
634 * (sign extension) between the register representation of a signed int
635 * (msr in 32-bit mode) and the register representation of a signed int
636 * (msr in 64-bit mode) is performed.
638 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
642 mm_segment_t old_fs = get_fs();
644 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
645 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
648 /* The __user pointer cast is valid becasuse of the set_fs() */
649 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
654 * Start Alternate signal stack support
657 * sigaltatck compat_sys_sigaltstack
660 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
661 int r6, int r7, int r8, struct pt_regs *regs)
663 stack_32_t __user * newstack = compat_ptr(__new);
664 stack_32_t __user * oldstack = compat_ptr(__old);
672 * set sp to the user stack on entry to the system call
673 * the system call router sets R9 to the saved registers
677 /* Put new stack info in local 64 bit stack struct */
679 if (get_user(ss_sp, &newstack->ss_sp) ||
680 __get_user(uss.ss_flags, &newstack->ss_flags) ||
681 __get_user(uss.ss_size, &newstack->ss_size))
683 uss.ss_sp = compat_ptr(ss_sp);
688 /* The __user pointer casts are valid because of the set_fs() */
689 ret = do_sigaltstack(
690 newstack ? (stack_t __user *) &uss : NULL,
691 oldstack ? (stack_t __user *) &uoss : NULL,
694 /* Copy the stack information to the user output buffer */
695 if (!ret && oldstack &&
696 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
697 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
698 __put_user(uoss.ss_size, &oldstack->ss_size)))
702 #endif /* CONFIG_PPC64 */
706 * Restore the user process's signal mask
709 extern void restore_sigmask(sigset_t *set);
710 #else /* CONFIG_PPC64 */
711 static void restore_sigmask(sigset_t *set)
713 sigdelsetmask(set, ~_BLOCKABLE);
714 spin_lock_irq(¤t->sighand->siglock);
715 current->blocked = *set;
717 spin_unlock_irq(¤t->sighand->siglock);
722 * Set up a signal frame for a "real-time" signal handler
723 * (one which gets siginfo).
725 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
726 siginfo_t *info, sigset_t *oldset,
727 struct pt_regs *regs, unsigned long newsp)
729 struct rt_sigframe __user *rt_sf;
730 struct mcontext __user *frame;
731 unsigned long origsp = newsp;
733 /* Set up Signal Frame */
734 /* Put a Real Time Context onto stack */
735 newsp -= sizeof(*rt_sf);
736 rt_sf = (struct rt_sigframe __user *)newsp;
738 /* create a stack frame for the caller of the handler */
739 newsp -= __SIGNAL_FRAMESIZE + 16;
741 if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
744 /* Put the siginfo & fill in most of the ucontext */
745 if (copy_siginfo_to_user(&rt_sf->info, info)
746 || __put_user(0, &rt_sf->uc.uc_flags)
747 || __put_user(0, &rt_sf->uc.uc_link)
748 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
749 || __put_user(sas_ss_flags(regs->gpr[1]),
750 &rt_sf->uc.uc_stack.ss_flags)
751 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
752 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
754 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
757 /* Save user registers on the stack */
758 frame = &rt_sf->uc.uc_mcontext;
759 if (vdso32_rt_sigtramp && current->thread.vdso_base) {
760 if (save_user_regs(regs, frame, 0))
762 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
764 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
766 regs->link = (unsigned long) frame->tramp;
769 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
771 if (put_user(regs->gpr[1], (u32 __user *)newsp))
773 regs->gpr[1] = newsp;
775 regs->gpr[4] = (unsigned long) &rt_sf->info;
776 regs->gpr[5] = (unsigned long) &rt_sf->uc;
777 regs->gpr[6] = (unsigned long) rt_sf;
778 regs->nip = (unsigned long) ka->sa.sa_handler;
784 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
787 force_sigsegv(sig, current);
791 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
794 struct mcontext __user *mcp;
796 if (get_sigset_t(&set, &ucp->uc_sigmask))
802 if (__get_user(cmcp, &ucp->uc_regs))
804 mcp = (struct mcontext __user *)(u64)cmcp;
807 if (__get_user(mcp, &ucp->uc_regs))
810 restore_sigmask(&set);
811 if (restore_user_regs(regs, mcp, sig))
817 long sys_swapcontext(struct ucontext __user *old_ctx,
818 struct ucontext __user *new_ctx,
819 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
823 /* Context size is for future use. Right now, we only make sure
824 * we are passed something we understand
826 if (ctx_size < sizeof(struct ucontext))
829 if (old_ctx != NULL) {
830 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
831 || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
832 || put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
833 || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
839 if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
840 || __get_user(tmp, (u8 __user *) new_ctx)
841 || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
845 * If we get a fault copying the context into the kernel's
846 * image of the user's registers, we can't just return -EFAULT
847 * because the user's registers will be corrupted. For instance
848 * the NIP value may have been updated but not some of the
849 * other registers. Given that we have done the access_ok
850 * and successfully read the first and last bytes of the region
851 * above, this should only happen in an out-of-memory situation
852 * or if another thread unmaps the region containing the context.
853 * We kill the task with a SIGSEGV in this situation.
855 if (do_setcontext(new_ctx, regs, 0))
858 set_thread_flag(TIF_RESTOREALL);
862 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
863 struct pt_regs *regs)
865 struct rt_sigframe __user *rt_sf;
867 /* Always make any pending restarted system calls return -EINTR */
868 current_thread_info()->restart_block.fn = do_no_restart_syscall;
870 rt_sf = (struct rt_sigframe __user *)
871 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
872 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
874 if (do_setcontext(&rt_sf->uc, regs, 1))
878 * It's not clear whether or why it is desirable to save the
879 * sigaltstack setting on signal delivery and restore it on
880 * signal return. But other architectures do this and we have
881 * always done it up until now so it is probably better not to
882 * change it. -- paulus
886 * We use the compat_sys_ version that does the 32/64 bits conversion
887 * and takes userland pointer directly. What about error checking ?
890 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
892 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
894 set_thread_flag(TIF_RESTOREALL);
898 force_sig(SIGSEGV, current);
903 int sys_debug_setcontext(struct ucontext __user *ctx,
904 int ndbg, struct sig_dbg_op __user *dbg,
905 int r6, int r7, int r8,
906 struct pt_regs *regs)
908 struct sig_dbg_op op;
910 unsigned long new_msr = regs->msr;
911 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
912 unsigned long new_dbcr0 = current->thread.dbcr0;
915 for (i=0; i<ndbg; i++) {
916 if (__copy_from_user(&op, dbg, sizeof(op)))
918 switch (op.dbg_type) {
919 case SIG_DBG_SINGLE_STEPPING:
920 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
923 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
926 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
935 case SIG_DBG_BRANCH_TRACING:
936 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
951 /* We wait until here to actually install the values in the
952 registers so if we fail in the above loop, it will not
953 affect the contents of these registers. After this point,
954 failure is a problem, anyway, and it's very unlikely unless
955 the user is really doing something wrong. */
957 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
958 current->thread.dbcr0 = new_dbcr0;
962 * If we get a fault copying the context into the kernel's
963 * image of the user's registers, we can't just return -EFAULT
964 * because the user's registers will be corrupted. For instance
965 * the NIP value may have been updated but not some of the
966 * other registers. Given that we have done the access_ok
967 * and successfully read the first and last bytes of the region
968 * above, this should only happen in an out-of-memory situation
969 * or if another thread unmaps the region containing the context.
970 * We kill the task with a SIGSEGV in this situation.
972 if (do_setcontext(ctx, regs, 1)) {
973 force_sig(SIGSEGV, current);
978 * It's not clear whether or why it is desirable to save the
979 * sigaltstack setting on signal delivery and restore it on
980 * signal return. But other architectures do this and we have
981 * always done it up until now so it is probably better not to
982 * change it. -- paulus
984 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
986 set_thread_flag(TIF_RESTOREALL);
993 * OK, we're invoking a handler
995 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
996 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
999 struct sigcontext __user *sc;
1000 struct sigregs __user *frame;
1001 unsigned long origsp = newsp;
1003 /* Set up Signal Frame */
1004 newsp -= sizeof(struct sigregs);
1005 frame = (struct sigregs __user *) newsp;
1007 /* Put a sigcontext on the stack */
1008 newsp -= sizeof(*sc);
1009 sc = (struct sigcontext __user *) newsp;
1011 /* create a stack frame for the caller of the handler */
1012 newsp -= __SIGNAL_FRAMESIZE;
1014 if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1018 #error "Please adjust handle_signal()"
1020 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1021 || __put_user(oldset->sig[0], &sc->oldmask)
1023 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1025 || __put_user(oldset->sig[1], &sc->_unused[3])
1027 || __put_user(to_user_ptr(frame), &sc->regs)
1028 || __put_user(sig, &sc->signal))
1031 if (vdso32_sigtramp && current->thread.vdso_base) {
1032 if (save_user_regs(regs, &frame->mctx, 0))
1034 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1036 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1038 regs->link = (unsigned long) frame->mctx.tramp;
1041 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1043 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1045 regs->gpr[1] = newsp;
1047 regs->gpr[4] = (unsigned long) sc;
1048 regs->nip = (unsigned long) ka->sa.sa_handler;
1055 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1056 regs, frame, newsp);
1058 force_sigsegv(sig, current);
1063 * Do a signal return; undo the signal stack.
1065 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1066 struct pt_regs *regs)
1068 struct sigcontext __user *sc;
1069 struct sigcontext sigctx;
1070 struct mcontext __user *sr;
1073 /* Always make any pending restarted system calls return -EINTR */
1074 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1076 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1077 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1082 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1083 * unused part of the signal stackframe
1085 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1087 set.sig[0] = sigctx.oldmask;
1088 set.sig[1] = sigctx._unused[3];
1090 restore_sigmask(&set);
1092 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1093 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1094 || restore_user_regs(regs, sr, 1))
1097 set_thread_flag(TIF_RESTOREALL);
1101 force_sig(SIGSEGV, current);
1106 * Note that 'init' is a special process: it doesn't get signals it doesn't
1107 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1110 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1113 struct k_sigaction ka;
1118 if (try_to_freeze()) {
1120 if (!signal_pending(current))
1125 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1126 oldset = ¤t->saved_sigmask;
1128 oldset = ¤t->blocked;
1130 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1134 if (TRAP(regs) == 0x0C00 /* System Call! */
1135 && regs->ccr & 0x10000000 /* error signalled */
1136 && ((ret = regs->gpr[3]) == ERESTARTSYS
1137 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1138 || ret == ERESTART_RESTARTBLOCK)) {
1141 && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1142 || (ret == ERESTARTSYS
1143 && !(ka.sa.sa_flags & SA_RESTART)))) {
1144 /* make the system call return an EINTR error */
1145 regs->result = -EINTR;
1146 regs->gpr[3] = EINTR;
1147 /* note that the cr0.SO bit is already set */
1149 regs->nip -= 4; /* Back up & retry system call */
1152 if (ret == ERESTART_RESTARTBLOCK)
1153 regs->gpr[0] = __NR_restart_syscall;
1155 regs->gpr[3] = regs->orig_gpr3;
1160 /* No signal to deliver -- put the saved sigmask back */
1161 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1162 clear_thread_flag(TIF_RESTORE_SIGMASK);
1163 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
1165 return 0; /* no signals delivered */
1168 if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1169 && !on_sig_stack(regs->gpr[1]))
1170 newsp = current->sas_ss_sp + current->sas_ss_size;
1172 newsp = regs->gpr[1];
1177 * Reenable the DABR before delivering the signal to
1178 * user space. The DABR will have been cleared if it
1179 * triggered inside the kernel.
1181 if (current->thread.dabr)
1182 set_dabr(current->thread.dabr);
1185 /* Whee! Actually deliver the signal. */
1186 if (ka.sa.sa_flags & SA_SIGINFO)
1187 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1189 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1192 spin_lock_irq(¤t->sighand->siglock);
1193 sigorsets(¤t->blocked, ¤t->blocked,
1195 if (!(ka.sa.sa_flags & SA_NODEFER))
1196 sigaddset(¤t->blocked, signr);
1197 recalc_sigpending();
1198 spin_unlock_irq(¤t->sighand->siglock);
1199 /* A signal was successfully delivered; the saved sigmask is in
1200 its frame, and we can clear the TIF_RESTORE_SIGMASK flag */
1201 if (test_thread_flag(TIF_RESTORE_SIGMASK))
1202 clear_thread_flag(TIF_RESTORE_SIGMASK);