Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / arch / powerpc / kernel / signal_32.c
blob78b76dc54dfb27847a24228e1bac2e2ef804354a
1 /*
2 * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
4 * PowerPC version
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>
21 #include <linux/mm.h>
22 #include <linux/smp.h>
23 #include <linux/kernel.h>
24 #include <linux/signal.h>
25 #include <linux/errno.h>
26 #include <linux/elf.h>
27 #include <linux/ptrace.h>
28 #include <linux/ratelimit.h>
29 #ifdef CONFIG_PPC64
30 #include <linux/syscalls.h>
31 #include <linux/compat.h>
32 #else
33 #include <linux/wait.h>
34 #include <linux/unistd.h>
35 #include <linux/stddef.h>
36 #include <linux/tty.h>
37 #include <linux/binfmts.h>
38 #include <linux/freezer.h>
39 #endif
41 #include <asm/uaccess.h>
42 #include <asm/cacheflush.h>
43 #include <asm/syscalls.h>
44 #include <asm/sigcontext.h>
45 #include <asm/vdso.h>
46 #ifdef CONFIG_PPC64
47 #include "ppc32.h"
48 #include <asm/unistd.h>
49 #else
50 #include <asm/ucontext.h>
51 #include <asm/pgtable.h>
52 #endif
54 #include "signal.h"
56 #undef DEBUG_SIG
58 #ifdef CONFIG_PPC64
59 #define sys_sigsuspend compat_sys_sigsuspend
60 #define sys_rt_sigsuspend compat_sys_rt_sigsuspend
61 #define sys_rt_sigreturn compat_sys_rt_sigreturn
62 #define sys_sigaction compat_sys_sigaction
63 #define sys_swapcontext compat_sys_swapcontext
64 #define sys_sigreturn compat_sys_sigreturn
66 #define old_sigaction old_sigaction32
67 #define sigcontext sigcontext32
68 #define mcontext mcontext32
69 #define ucontext ucontext32
72 * Userspace code may pass a ucontext which doesn't include VSX added
73 * at the end. We need to check for this case.
75 #define UCONTEXTSIZEWITHOUTVSX \
76 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
79 * Returning 0 means we return to userspace via
80 * ret_from_except and thus restore all user
81 * registers from *regs. This is what we need
82 * to do when a signal has been delivered.
85 #define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
86 #undef __SIGNAL_FRAMESIZE
87 #define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
88 #undef ELF_NVRREG
89 #define ELF_NVRREG ELF_NVRREG32
92 * Functions for flipping sigsets (thanks to brain dead generic
93 * implementation that makes things simple for little endian only)
95 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
97 compat_sigset_t cset;
99 switch (_NSIG_WORDS) {
100 case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
101 cset.sig[7] = set->sig[3] >> 32;
102 case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
103 cset.sig[5] = set->sig[2] >> 32;
104 case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
105 cset.sig[3] = set->sig[1] >> 32;
106 case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
107 cset.sig[1] = set->sig[0] >> 32;
109 return copy_to_user(uset, &cset, sizeof(*uset));
112 static inline int get_sigset_t(sigset_t *set,
113 const compat_sigset_t __user *uset)
115 compat_sigset_t s32;
117 if (copy_from_user(&s32, uset, sizeof(*uset)))
118 return -EFAULT;
121 * Swap the 2 words of the 64-bit sigset_t (they are stored
122 * in the "wrong" endian in 32-bit user storage).
124 switch (_NSIG_WORDS) {
125 case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
126 case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
127 case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
128 case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
130 return 0;
133 static inline int get_old_sigaction(struct k_sigaction *new_ka,
134 struct old_sigaction __user *act)
136 compat_old_sigset_t mask;
137 compat_uptr_t handler, restorer;
139 if (get_user(handler, &act->sa_handler) ||
140 __get_user(restorer, &act->sa_restorer) ||
141 __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
142 __get_user(mask, &act->sa_mask))
143 return -EFAULT;
144 new_ka->sa.sa_handler = compat_ptr(handler);
145 new_ka->sa.sa_restorer = compat_ptr(restorer);
146 siginitset(&new_ka->sa.sa_mask, mask);
147 return 0;
150 #define to_user_ptr(p) ptr_to_compat(p)
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;
157 int i;
159 WARN_ON(!FULL_REGS(regs));
161 for (i = 0; i <= PT_RESULT; i ++) {
162 if (i == 14 && !FULL_REGS(regs))
163 i = 32;
164 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
165 return -EFAULT;
167 return 0;
170 static inline int restore_general_regs(struct pt_regs *regs,
171 struct mcontext __user *sr)
173 elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
174 int i;
176 for (i = 0; i <= PT_RESULT; i++) {
177 if ((i == PT_MSR) || (i == PT_SOFTE))
178 continue;
179 if (__get_user(gregs[i], &sr->mc_gregs[i]))
180 return -EFAULT;
182 return 0;
185 #else /* CONFIG_PPC64 */
187 #define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
189 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
191 return copy_to_user(uset, set, sizeof(*uset));
194 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
196 return copy_from_user(set, uset, sizeof(*uset));
199 static inline int get_old_sigaction(struct k_sigaction *new_ka,
200 struct old_sigaction __user *act)
202 old_sigset_t mask;
204 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
205 __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
206 __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
207 return -EFAULT;
208 __get_user(new_ka->sa.sa_flags, &act->sa_flags);
209 __get_user(mask, &act->sa_mask);
210 siginitset(&new_ka->sa.sa_mask, mask);
211 return 0;
214 #define to_user_ptr(p) ((unsigned long)(p))
215 #define from_user_ptr(p) ((void __user *)(p))
217 static inline int save_general_regs(struct pt_regs *regs,
218 struct mcontext __user *frame)
220 WARN_ON(!FULL_REGS(regs));
221 return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
224 static inline int restore_general_regs(struct pt_regs *regs,
225 struct mcontext __user *sr)
227 /* copy up to but not including MSR */
228 if (__copy_from_user(regs, &sr->mc_gregs,
229 PT_MSR * sizeof(elf_greg_t)))
230 return -EFAULT;
231 /* copy from orig_r3 (the word after the MSR) up to the end */
232 if (__copy_from_user(&regs->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
233 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
234 return -EFAULT;
235 return 0;
238 #endif /* CONFIG_PPC64 */
241 * Atomically swap in the new signal mask, and wait for a signal.
243 long sys_sigsuspend(old_sigset_t mask)
245 mask &= _BLOCKABLE;
246 spin_lock_irq(&current->sighand->siglock);
247 current->saved_sigmask = current->blocked;
248 siginitset(&current->blocked, mask);
249 recalc_sigpending();
250 spin_unlock_irq(&current->sighand->siglock);
252 current->state = TASK_INTERRUPTIBLE;
253 schedule();
254 set_restore_sigmask();
255 return -ERESTARTNOHAND;
258 long sys_sigaction(int sig, struct old_sigaction __user *act,
259 struct old_sigaction __user *oact)
261 struct k_sigaction new_ka, old_ka;
262 int ret;
264 #ifdef CONFIG_PPC64
265 if (sig < 0)
266 sig = -sig;
267 #endif
269 if (act) {
270 if (get_old_sigaction(&new_ka, act))
271 return -EFAULT;
274 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
275 if (!ret && oact) {
276 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
277 __put_user(to_user_ptr(old_ka.sa.sa_handler),
278 &oact->sa_handler) ||
279 __put_user(to_user_ptr(old_ka.sa.sa_restorer),
280 &oact->sa_restorer) ||
281 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
282 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
283 return -EFAULT;
286 return ret;
290 * When we have signals to deliver, we set up on the
291 * user stack, going down from the original stack pointer:
292 * an ABI gap of 56 words
293 * an mcontext struct
294 * a sigcontext struct
295 * a gap of __SIGNAL_FRAMESIZE bytes
297 * Each of these things must be a multiple of 16 bytes in size. The following
298 * structure represent all of this except the __SIGNAL_FRAMESIZE gap
301 struct sigframe {
302 struct sigcontext sctx; /* the sigcontext */
303 struct mcontext mctx; /* all the register values */
305 * Programs using the rs6000/xcoff abi can save up to 19 gp
306 * regs and 18 fp regs below sp before decrementing it.
308 int abigap[56];
311 /* We use the mc_pad field for the signal return trampoline. */
312 #define tramp mc_pad
315 * When we have rt signals to deliver, we set up on the
316 * user stack, going down from the original stack pointer:
317 * one rt_sigframe struct (siginfo + ucontext + ABI gap)
318 * a gap of __SIGNAL_FRAMESIZE+16 bytes
319 * (the +16 is to get the siginfo and ucontext in the same
320 * positions as in older kernels).
322 * Each of these things must be a multiple of 16 bytes in size.
325 struct rt_sigframe {
326 #ifdef CONFIG_PPC64
327 compat_siginfo_t info;
328 #else
329 struct siginfo info;
330 #endif
331 struct ucontext uc;
333 * Programs using the rs6000/xcoff abi can save up to 19 gp
334 * regs and 18 fp regs below sp before decrementing it.
336 int abigap[56];
339 #ifdef CONFIG_VSX
340 unsigned long copy_fpr_to_user(void __user *to,
341 struct task_struct *task)
343 double buf[ELF_NFPREG];
344 int i;
346 /* save FPR copy to local buffer then write to the thread_struct */
347 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
348 buf[i] = task->thread.TS_FPR(i);
349 memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
350 return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
353 unsigned long copy_fpr_from_user(struct task_struct *task,
354 void __user *from)
356 double buf[ELF_NFPREG];
357 int i;
359 if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
360 return 1;
361 for (i = 0; i < (ELF_NFPREG - 1) ; i++)
362 task->thread.TS_FPR(i) = buf[i];
363 memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
365 return 0;
368 unsigned long copy_vsx_to_user(void __user *to,
369 struct task_struct *task)
371 double buf[ELF_NVSRHALFREG];
372 int i;
374 /* save FPR copy to local buffer then write to the thread_struct */
375 for (i = 0; i < ELF_NVSRHALFREG; i++)
376 buf[i] = task->thread.fpr[i][TS_VSRLOWOFFSET];
377 return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
380 unsigned long copy_vsx_from_user(struct task_struct *task,
381 void __user *from)
383 double buf[ELF_NVSRHALFREG];
384 int i;
386 if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
387 return 1;
388 for (i = 0; i < ELF_NVSRHALFREG ; i++)
389 task->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
390 return 0;
392 #else
393 inline unsigned long copy_fpr_to_user(void __user *to,
394 struct task_struct *task)
396 return __copy_to_user(to, task->thread.fpr,
397 ELF_NFPREG * sizeof(double));
400 inline unsigned long copy_fpr_from_user(struct task_struct *task,
401 void __user *from)
403 return __copy_from_user(task->thread.fpr, from,
404 ELF_NFPREG * sizeof(double));
406 #endif
409 * Save the current user registers on the user stack.
410 * We only save the altivec/spe registers if the process has used
411 * altivec/spe instructions at some point.
413 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
414 int sigret, int ctx_has_vsx_region)
416 unsigned long msr = regs->msr;
418 /* Make sure floating point registers are stored in regs */
419 flush_fp_to_thread(current);
421 /* save general registers */
422 if (save_general_regs(regs, frame))
423 return 1;
425 #ifdef CONFIG_ALTIVEC
426 /* save altivec registers */
427 if (current->thread.used_vr) {
428 flush_altivec_to_thread(current);
429 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
430 ELF_NVRREG * sizeof(vector128)))
431 return 1;
432 /* set MSR_VEC in the saved MSR value to indicate that
433 frame->mc_vregs contains valid data */
434 msr |= MSR_VEC;
436 /* else assert((regs->msr & MSR_VEC) == 0) */
438 /* We always copy to/from vrsave, it's 0 if we don't have or don't
439 * use altivec. Since VSCR only contains 32 bits saved in the least
440 * significant bits of a vector, we "cheat" and stuff VRSAVE in the
441 * most significant bits of that same vector. --BenH
443 if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
444 return 1;
445 #endif /* CONFIG_ALTIVEC */
446 if (copy_fpr_to_user(&frame->mc_fregs, current))
447 return 1;
448 #ifdef CONFIG_VSX
450 * Copy VSR 0-31 upper half from thread_struct to local
451 * buffer, then write that to userspace. Also set MSR_VSX in
452 * the saved MSR value to indicate that frame->mc_vregs
453 * contains valid data
455 if (current->thread.used_vsr && ctx_has_vsx_region) {
456 __giveup_vsx(current);
457 if (copy_vsx_to_user(&frame->mc_vsregs, current))
458 return 1;
459 msr |= MSR_VSX;
461 #endif /* CONFIG_VSX */
462 #ifdef CONFIG_SPE
463 /* save spe registers */
464 if (current->thread.used_spe) {
465 flush_spe_to_thread(current);
466 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
467 ELF_NEVRREG * sizeof(u32)))
468 return 1;
469 /* set MSR_SPE in the saved MSR value to indicate that
470 frame->mc_vregs contains valid data */
471 msr |= MSR_SPE;
473 /* else assert((regs->msr & MSR_SPE) == 0) */
475 /* We always copy to/from spefscr */
476 if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
477 return 1;
478 #endif /* CONFIG_SPE */
480 if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
481 return 1;
482 if (sigret) {
483 /* Set up the sigreturn trampoline: li r0,sigret; sc */
484 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
485 || __put_user(0x44000002UL, &frame->tramp[1]))
486 return 1;
487 flush_icache_range((unsigned long) &frame->tramp[0],
488 (unsigned long) &frame->tramp[2]);
491 return 0;
495 * Restore the current user register values from the user stack,
496 * (except for MSR).
498 static long restore_user_regs(struct pt_regs *regs,
499 struct mcontext __user *sr, int sig)
501 long err;
502 unsigned int save_r2 = 0;
503 unsigned long msr;
504 #ifdef CONFIG_VSX
505 int i;
506 #endif
509 * restore general registers but not including MSR or SOFTE. Also
510 * take care of keeping r2 (TLS) intact if not a signal
512 if (!sig)
513 save_r2 = (unsigned int)regs->gpr[2];
514 err = restore_general_regs(regs, sr);
515 regs->trap = 0;
516 err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
517 if (!sig)
518 regs->gpr[2] = (unsigned long) save_r2;
519 if (err)
520 return 1;
522 /* if doing signal return, restore the previous little-endian mode */
523 if (sig)
524 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
527 * Do this before updating the thread state in
528 * current->thread.fpr/vr/evr. That way, if we get preempted
529 * and another task grabs the FPU/Altivec/SPE, it won't be
530 * tempted to save the current CPU state into the thread_struct
531 * and corrupt what we are writing there.
533 discard_lazy_cpu_state();
535 #ifdef CONFIG_ALTIVEC
537 * Force the process to reload the altivec registers from
538 * current->thread when it next does altivec instructions
540 regs->msr &= ~MSR_VEC;
541 if (msr & MSR_VEC) {
542 /* restore altivec registers from the stack */
543 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
544 sizeof(sr->mc_vregs)))
545 return 1;
546 } else if (current->thread.used_vr)
547 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
549 /* Always get VRSAVE back */
550 if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
551 return 1;
552 #endif /* CONFIG_ALTIVEC */
553 if (copy_fpr_from_user(current, &sr->mc_fregs))
554 return 1;
556 #ifdef CONFIG_VSX
558 * Force the process to reload the VSX registers from
559 * current->thread when it next does VSX instruction.
561 regs->msr &= ~MSR_VSX;
562 if (msr & MSR_VSX) {
564 * Restore altivec registers from the stack to a local
565 * buffer, then write this out to the thread_struct
567 if (copy_vsx_from_user(current, &sr->mc_vsregs))
568 return 1;
569 } else if (current->thread.used_vsr)
570 for (i = 0; i < 32 ; i++)
571 current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
572 #endif /* CONFIG_VSX */
574 * force the process to reload the FP registers from
575 * current->thread when it next does FP instructions
577 regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
579 #ifdef CONFIG_SPE
580 /* force the process to reload the spe registers from
581 current->thread when it next does spe instructions */
582 regs->msr &= ~MSR_SPE;
583 if (msr & MSR_SPE) {
584 /* restore spe registers from the stack */
585 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
586 ELF_NEVRREG * sizeof(u32)))
587 return 1;
588 } else if (current->thread.used_spe)
589 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
591 /* Always get SPEFSCR back */
592 if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
593 return 1;
594 #endif /* CONFIG_SPE */
596 return 0;
599 #ifdef CONFIG_PPC64
600 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
601 struct sigaction32 __user *oact, size_t sigsetsize)
603 struct k_sigaction new_ka, old_ka;
604 int ret;
606 /* XXX: Don't preclude handling different sized sigset_t's. */
607 if (sigsetsize != sizeof(compat_sigset_t))
608 return -EINVAL;
610 if (act) {
611 compat_uptr_t handler;
613 ret = get_user(handler, &act->sa_handler);
614 new_ka.sa.sa_handler = compat_ptr(handler);
615 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
616 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
617 if (ret)
618 return -EFAULT;
621 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
622 if (!ret && oact) {
623 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
624 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
625 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
627 return ret;
631 * Note: it is necessary to treat how as an unsigned int, with the
632 * corresponding cast to a signed int to insure that the proper
633 * conversion (sign extension) between the register representation
634 * of a signed int (msr in 32-bit mode) and the register representation
635 * of a signed int (msr in 64-bit mode) is performed.
637 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
638 compat_sigset_t __user *oset, size_t sigsetsize)
640 sigset_t s;
641 sigset_t __user *up;
642 int ret;
643 mm_segment_t old_fs = get_fs();
645 if (set) {
646 if (get_sigset_t(&s, set))
647 return -EFAULT;
650 set_fs(KERNEL_DS);
651 /* This is valid because of the set_fs() */
652 up = (sigset_t __user *) &s;
653 ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
654 sigsetsize);
655 set_fs(old_fs);
656 if (ret)
657 return ret;
658 if (oset) {
659 if (put_sigset_t(oset, &s))
660 return -EFAULT;
662 return 0;
665 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
667 sigset_t s;
668 int ret;
669 mm_segment_t old_fs = get_fs();
671 set_fs(KERNEL_DS);
672 /* The __user pointer cast is valid because of the set_fs() */
673 ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
674 set_fs(old_fs);
675 if (!ret) {
676 if (put_sigset_t(set, &s))
677 return -EFAULT;
679 return ret;
683 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
685 int err;
687 if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
688 return -EFAULT;
690 /* If you change siginfo_t structure, please be sure
691 * this code is fixed accordingly.
692 * It should never copy any pad contained in the structure
693 * to avoid security leaks, but must copy the generic
694 * 3 ints plus the relevant union member.
695 * This routine must convert siginfo from 64bit to 32bit as well
696 * at the same time.
698 err = __put_user(s->si_signo, &d->si_signo);
699 err |= __put_user(s->si_errno, &d->si_errno);
700 err |= __put_user((short)s->si_code, &d->si_code);
701 if (s->si_code < 0)
702 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
703 SI_PAD_SIZE32);
704 else switch(s->si_code >> 16) {
705 case __SI_CHLD >> 16:
706 err |= __put_user(s->si_pid, &d->si_pid);
707 err |= __put_user(s->si_uid, &d->si_uid);
708 err |= __put_user(s->si_utime, &d->si_utime);
709 err |= __put_user(s->si_stime, &d->si_stime);
710 err |= __put_user(s->si_status, &d->si_status);
711 break;
712 case __SI_FAULT >> 16:
713 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
714 &d->si_addr);
715 break;
716 case __SI_POLL >> 16:
717 err |= __put_user(s->si_band, &d->si_band);
718 err |= __put_user(s->si_fd, &d->si_fd);
719 break;
720 case __SI_TIMER >> 16:
721 err |= __put_user(s->si_tid, &d->si_tid);
722 err |= __put_user(s->si_overrun, &d->si_overrun);
723 err |= __put_user(s->si_int, &d->si_int);
724 break;
725 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
726 case __SI_MESGQ >> 16:
727 err |= __put_user(s->si_int, &d->si_int);
728 /* fallthrough */
729 case __SI_KILL >> 16:
730 default:
731 err |= __put_user(s->si_pid, &d->si_pid);
732 err |= __put_user(s->si_uid, &d->si_uid);
733 break;
735 return err;
738 #define copy_siginfo_to_user copy_siginfo_to_user32
740 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
742 memset(to, 0, sizeof *to);
744 if (copy_from_user(to, from, 3*sizeof(int)) ||
745 copy_from_user(to->_sifields._pad,
746 from->_sifields._pad, SI_PAD_SIZE32))
747 return -EFAULT;
749 return 0;
753 * Note: it is necessary to treat pid and sig as unsigned ints, with the
754 * corresponding cast to a signed int to insure that the proper conversion
755 * (sign extension) between the register representation of a signed int
756 * (msr in 32-bit mode) and the register representation of a signed int
757 * (msr in 64-bit mode) is performed.
759 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
761 siginfo_t info;
762 int ret;
763 mm_segment_t old_fs = get_fs();
765 ret = copy_siginfo_from_user32(&info, uinfo);
766 if (unlikely(ret))
767 return ret;
769 set_fs (KERNEL_DS);
770 /* The __user pointer cast is valid becasuse of the set_fs() */
771 ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
772 set_fs (old_fs);
773 return ret;
776 * Start Alternate signal stack support
778 * System Calls
779 * sigaltatck compat_sys_sigaltstack
782 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
783 int r6, int r7, int r8, struct pt_regs *regs)
785 stack_32_t __user * newstack = compat_ptr(__new);
786 stack_32_t __user * oldstack = compat_ptr(__old);
787 stack_t uss, uoss;
788 int ret;
789 mm_segment_t old_fs;
790 unsigned long sp;
791 compat_uptr_t ss_sp;
794 * set sp to the user stack on entry to the system call
795 * the system call router sets R9 to the saved registers
797 sp = regs->gpr[1];
799 /* Put new stack info in local 64 bit stack struct */
800 if (newstack) {
801 if (get_user(ss_sp, &newstack->ss_sp) ||
802 __get_user(uss.ss_flags, &newstack->ss_flags) ||
803 __get_user(uss.ss_size, &newstack->ss_size))
804 return -EFAULT;
805 uss.ss_sp = compat_ptr(ss_sp);
808 old_fs = get_fs();
809 set_fs(KERNEL_DS);
810 /* The __user pointer casts are valid because of the set_fs() */
811 ret = do_sigaltstack(
812 newstack ? (stack_t __user *) &uss : NULL,
813 oldstack ? (stack_t __user *) &uoss : NULL,
814 sp);
815 set_fs(old_fs);
816 /* Copy the stack information to the user output buffer */
817 if (!ret && oldstack &&
818 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
819 __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
820 __put_user(uoss.ss_size, &oldstack->ss_size)))
821 return -EFAULT;
822 return ret;
824 #endif /* CONFIG_PPC64 */
827 * Set up a signal frame for a "real-time" signal handler
828 * (one which gets siginfo).
830 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
831 siginfo_t *info, sigset_t *oldset,
832 struct pt_regs *regs)
834 struct rt_sigframe __user *rt_sf;
835 struct mcontext __user *frame;
836 void __user *addr;
837 unsigned long newsp = 0;
839 /* Set up Signal Frame */
840 /* Put a Real Time Context onto stack */
841 rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf), 1);
842 addr = rt_sf;
843 if (unlikely(rt_sf == NULL))
844 goto badframe;
846 /* Put the siginfo & fill in most of the ucontext */
847 if (copy_siginfo_to_user(&rt_sf->info, info)
848 || __put_user(0, &rt_sf->uc.uc_flags)
849 || __put_user(0, &rt_sf->uc.uc_link)
850 || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
851 || __put_user(sas_ss_flags(regs->gpr[1]),
852 &rt_sf->uc.uc_stack.ss_flags)
853 || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
854 || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
855 &rt_sf->uc.uc_regs)
856 || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
857 goto badframe;
859 /* Save user registers on the stack */
860 frame = &rt_sf->uc.uc_mcontext;
861 addr = frame;
862 if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
863 if (save_user_regs(regs, frame, 0, 1))
864 goto badframe;
865 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
866 } else {
867 if (save_user_regs(regs, frame, __NR_rt_sigreturn, 1))
868 goto badframe;
869 regs->link = (unsigned long) frame->tramp;
872 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
874 /* create a stack frame for the caller of the handler */
875 newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
876 addr = (void __user *)regs->gpr[1];
877 if (put_user(regs->gpr[1], (u32 __user *)newsp))
878 goto badframe;
880 /* Fill registers for signal handler */
881 regs->gpr[1] = newsp;
882 regs->gpr[3] = sig;
883 regs->gpr[4] = (unsigned long) &rt_sf->info;
884 regs->gpr[5] = (unsigned long) &rt_sf->uc;
885 regs->gpr[6] = (unsigned long) rt_sf;
886 regs->nip = (unsigned long) ka->sa.sa_handler;
887 /* enter the signal handler in big-endian mode */
888 regs->msr &= ~MSR_LE;
889 return 1;
891 badframe:
892 #ifdef DEBUG_SIG
893 printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
894 regs, frame, newsp);
895 #endif
896 if (show_unhandled_signals)
897 printk_ratelimited(KERN_INFO
898 "%s[%d]: bad frame in handle_rt_signal32: "
899 "%p nip %08lx lr %08lx\n",
900 current->comm, current->pid,
901 addr, regs->nip, regs->link);
903 force_sigsegv(sig, current);
904 return 0;
907 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
909 sigset_t set;
910 struct mcontext __user *mcp;
912 if (get_sigset_t(&set, &ucp->uc_sigmask))
913 return -EFAULT;
914 #ifdef CONFIG_PPC64
916 u32 cmcp;
918 if (__get_user(cmcp, &ucp->uc_regs))
919 return -EFAULT;
920 mcp = (struct mcontext __user *)(u64)cmcp;
921 /* no need to check access_ok(mcp), since mcp < 4GB */
923 #else
924 if (__get_user(mcp, &ucp->uc_regs))
925 return -EFAULT;
926 if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
927 return -EFAULT;
928 #endif
929 restore_sigmask(&set);
930 if (restore_user_regs(regs, mcp, sig))
931 return -EFAULT;
933 return 0;
936 long sys_swapcontext(struct ucontext __user *old_ctx,
937 struct ucontext __user *new_ctx,
938 int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
940 unsigned char tmp;
941 int ctx_has_vsx_region = 0;
943 #ifdef CONFIG_PPC64
944 unsigned long new_msr = 0;
946 if (new_ctx) {
947 struct mcontext __user *mcp;
948 u32 cmcp;
951 * Get pointer to the real mcontext. No need for
952 * access_ok since we are dealing with compat
953 * pointers.
955 if (__get_user(cmcp, &new_ctx->uc_regs))
956 return -EFAULT;
957 mcp = (struct mcontext __user *)(u64)cmcp;
958 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
959 return -EFAULT;
962 * Check that the context is not smaller than the original
963 * size (with VMX but without VSX)
965 if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
966 return -EINVAL;
968 * If the new context state sets the MSR VSX bits but
969 * it doesn't provide VSX state.
971 if ((ctx_size < sizeof(struct ucontext)) &&
972 (new_msr & MSR_VSX))
973 return -EINVAL;
974 /* Does the context have enough room to store VSX data? */
975 if (ctx_size >= sizeof(struct ucontext))
976 ctx_has_vsx_region = 1;
977 #else
978 /* Context size is for future use. Right now, we only make sure
979 * we are passed something we understand
981 if (ctx_size < sizeof(struct ucontext))
982 return -EINVAL;
983 #endif
984 if (old_ctx != NULL) {
985 struct mcontext __user *mctx;
988 * old_ctx might not be 16-byte aligned, in which
989 * case old_ctx->uc_mcontext won't be either.
990 * Because we have the old_ctx->uc_pad2 field
991 * before old_ctx->uc_mcontext, we need to round down
992 * from &old_ctx->uc_mcontext to a 16-byte boundary.
994 mctx = (struct mcontext __user *)
995 ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
996 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
997 || save_user_regs(regs, mctx, 0, ctx_has_vsx_region)
998 || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
999 || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1000 return -EFAULT;
1002 if (new_ctx == NULL)
1003 return 0;
1004 if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1005 || __get_user(tmp, (u8 __user *) new_ctx)
1006 || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1007 return -EFAULT;
1010 * If we get a fault copying the context into the kernel's
1011 * image of the user's registers, we can't just return -EFAULT
1012 * because the user's registers will be corrupted. For instance
1013 * the NIP value may have been updated but not some of the
1014 * other registers. Given that we have done the access_ok
1015 * and successfully read the first and last bytes of the region
1016 * above, this should only happen in an out-of-memory situation
1017 * or if another thread unmaps the region containing the context.
1018 * We kill the task with a SIGSEGV in this situation.
1020 if (do_setcontext(new_ctx, regs, 0))
1021 do_exit(SIGSEGV);
1023 set_thread_flag(TIF_RESTOREALL);
1024 return 0;
1027 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1028 struct pt_regs *regs)
1030 struct rt_sigframe __user *rt_sf;
1032 /* Always make any pending restarted system calls return -EINTR */
1033 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1035 rt_sf = (struct rt_sigframe __user *)
1036 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1037 if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1038 goto bad;
1039 if (do_setcontext(&rt_sf->uc, regs, 1))
1040 goto bad;
1043 * It's not clear whether or why it is desirable to save the
1044 * sigaltstack setting on signal delivery and restore it on
1045 * signal return. But other architectures do this and we have
1046 * always done it up until now so it is probably better not to
1047 * change it. -- paulus
1049 #ifdef CONFIG_PPC64
1051 * We use the compat_sys_ version that does the 32/64 bits conversion
1052 * and takes userland pointer directly. What about error checking ?
1053 * nobody does any...
1055 compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
1056 #else
1057 do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
1058 #endif
1059 set_thread_flag(TIF_RESTOREALL);
1060 return 0;
1062 bad:
1063 if (show_unhandled_signals)
1064 printk_ratelimited(KERN_INFO
1065 "%s[%d]: bad frame in sys_rt_sigreturn: "
1066 "%p nip %08lx lr %08lx\n",
1067 current->comm, current->pid,
1068 rt_sf, regs->nip, regs->link);
1070 force_sig(SIGSEGV, current);
1071 return 0;
1074 #ifdef CONFIG_PPC32
1075 int sys_debug_setcontext(struct ucontext __user *ctx,
1076 int ndbg, struct sig_dbg_op __user *dbg,
1077 int r6, int r7, int r8,
1078 struct pt_regs *regs)
1080 struct sig_dbg_op op;
1081 int i;
1082 unsigned char tmp;
1083 unsigned long new_msr = regs->msr;
1084 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1085 unsigned long new_dbcr0 = current->thread.dbcr0;
1086 #endif
1088 for (i=0; i<ndbg; i++) {
1089 if (copy_from_user(&op, dbg + i, sizeof(op)))
1090 return -EFAULT;
1091 switch (op.dbg_type) {
1092 case SIG_DBG_SINGLE_STEPPING:
1093 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1094 if (op.dbg_value) {
1095 new_msr |= MSR_DE;
1096 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1097 } else {
1098 new_dbcr0 &= ~DBCR0_IC;
1099 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1100 current->thread.dbcr1)) {
1101 new_msr &= ~MSR_DE;
1102 new_dbcr0 &= ~DBCR0_IDM;
1105 #else
1106 if (op.dbg_value)
1107 new_msr |= MSR_SE;
1108 else
1109 new_msr &= ~MSR_SE;
1110 #endif
1111 break;
1112 case SIG_DBG_BRANCH_TRACING:
1113 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1114 return -EINVAL;
1115 #else
1116 if (op.dbg_value)
1117 new_msr |= MSR_BE;
1118 else
1119 new_msr &= ~MSR_BE;
1120 #endif
1121 break;
1123 default:
1124 return -EINVAL;
1128 /* We wait until here to actually install the values in the
1129 registers so if we fail in the above loop, it will not
1130 affect the contents of these registers. After this point,
1131 failure is a problem, anyway, and it's very unlikely unless
1132 the user is really doing something wrong. */
1133 regs->msr = new_msr;
1134 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1135 current->thread.dbcr0 = new_dbcr0;
1136 #endif
1138 if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1139 || __get_user(tmp, (u8 __user *) ctx)
1140 || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1141 return -EFAULT;
1144 * If we get a fault copying the context into the kernel's
1145 * image of the user's registers, we can't just return -EFAULT
1146 * because the user's registers will be corrupted. For instance
1147 * the NIP value may have been updated but not some of the
1148 * other registers. Given that we have done the access_ok
1149 * and successfully read the first and last bytes of the region
1150 * above, this should only happen in an out-of-memory situation
1151 * or if another thread unmaps the region containing the context.
1152 * We kill the task with a SIGSEGV in this situation.
1154 if (do_setcontext(ctx, regs, 1)) {
1155 if (show_unhandled_signals)
1156 printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1157 "sys_debug_setcontext: %p nip %08lx "
1158 "lr %08lx\n",
1159 current->comm, current->pid,
1160 ctx, regs->nip, regs->link);
1162 force_sig(SIGSEGV, current);
1163 goto out;
1167 * It's not clear whether or why it is desirable to save the
1168 * sigaltstack setting on signal delivery and restore it on
1169 * signal return. But other architectures do this and we have
1170 * always done it up until now so it is probably better not to
1171 * change it. -- paulus
1173 do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1175 set_thread_flag(TIF_RESTOREALL);
1176 out:
1177 return 0;
1179 #endif
1182 * OK, we're invoking a handler
1184 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1185 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1187 struct sigcontext __user *sc;
1188 struct sigframe __user *frame;
1189 unsigned long newsp = 0;
1191 /* Set up Signal Frame */
1192 frame = get_sigframe(ka, regs, sizeof(*frame), 1);
1193 if (unlikely(frame == NULL))
1194 goto badframe;
1195 sc = (struct sigcontext __user *) &frame->sctx;
1197 #if _NSIG != 64
1198 #error "Please adjust handle_signal()"
1199 #endif
1200 if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1201 || __put_user(oldset->sig[0], &sc->oldmask)
1202 #ifdef CONFIG_PPC64
1203 || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1204 #else
1205 || __put_user(oldset->sig[1], &sc->_unused[3])
1206 #endif
1207 || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1208 || __put_user(sig, &sc->signal))
1209 goto badframe;
1211 if (vdso32_sigtramp && current->mm->context.vdso_base) {
1212 if (save_user_regs(regs, &frame->mctx, 0, 1))
1213 goto badframe;
1214 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1215 } else {
1216 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn, 1))
1217 goto badframe;
1218 regs->link = (unsigned long) frame->mctx.tramp;
1221 current->thread.fpscr.val = 0; /* turn off all fp exceptions */
1223 /* create a stack frame for the caller of the handler */
1224 newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1225 if (put_user(regs->gpr[1], (u32 __user *)newsp))
1226 goto badframe;
1228 regs->gpr[1] = newsp;
1229 regs->gpr[3] = sig;
1230 regs->gpr[4] = (unsigned long) sc;
1231 regs->nip = (unsigned long) ka->sa.sa_handler;
1232 /* enter the signal handler in big-endian mode */
1233 regs->msr &= ~MSR_LE;
1235 return 1;
1237 badframe:
1238 #ifdef DEBUG_SIG
1239 printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1240 regs, frame, newsp);
1241 #endif
1242 if (show_unhandled_signals)
1243 printk_ratelimited(KERN_INFO
1244 "%s[%d]: bad frame in handle_signal32: "
1245 "%p nip %08lx lr %08lx\n",
1246 current->comm, current->pid,
1247 frame, regs->nip, regs->link);
1249 force_sigsegv(sig, current);
1250 return 0;
1254 * Do a signal return; undo the signal stack.
1256 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1257 struct pt_regs *regs)
1259 struct sigcontext __user *sc;
1260 struct sigcontext sigctx;
1261 struct mcontext __user *sr;
1262 void __user *addr;
1263 sigset_t set;
1265 /* Always make any pending restarted system calls return -EINTR */
1266 current_thread_info()->restart_block.fn = do_no_restart_syscall;
1268 sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1269 addr = sc;
1270 if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1271 goto badframe;
1273 #ifdef CONFIG_PPC64
1275 * Note that PPC32 puts the upper 32 bits of the sigmask in the
1276 * unused part of the signal stackframe
1278 set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1279 #else
1280 set.sig[0] = sigctx.oldmask;
1281 set.sig[1] = sigctx._unused[3];
1282 #endif
1283 restore_sigmask(&set);
1285 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1286 addr = sr;
1287 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1288 || restore_user_regs(regs, sr, 1))
1289 goto badframe;
1291 set_thread_flag(TIF_RESTOREALL);
1292 return 0;
1294 badframe:
1295 if (show_unhandled_signals)
1296 printk_ratelimited(KERN_INFO
1297 "%s[%d]: bad frame in sys_sigreturn: "
1298 "%p nip %08lx lr %08lx\n",
1299 current->comm, current->pid,
1300 addr, regs->nip, regs->link);
1302 force_sig(SIGSEGV, current);
1303 return 0;