2005-04-16 18:20:36 -04:00
|
|
|
/*
|
2005-10-17 21:17:58 -04:00
|
|
|
* Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
2005-10-17 21:17:58 -04:00
|
|
|
* PowerPC version
|
|
|
|
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
|
2005-04-16 18:20:36 -04:00
|
|
|
* Copyright (C) 2001 IBM
|
|
|
|
* Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
|
|
|
|
* Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
|
|
|
|
*
|
2005-10-17 21:17:58 -04:00
|
|
|
* Derived from "arch/i386/kernel/signal.c"
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
2005-10-17 21:17:58 -04:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/config.h>
|
|
|
|
#include <linux/sched.h>
|
2005-10-17 21:17:58 -04:00
|
|
|
#include <linux/mm.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/smp_lock.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/elf.h>
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
#include <linux/syscalls.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <linux/compat.h>
|
|
|
|
#include <linux/ptrace.h>
|
2005-10-17 21:17:58 -04:00
|
|
|
#else
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/binfmts.h>
|
|
|
|
#include <linux/suspend.h>
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <asm/uaccess.h>
|
2005-10-17 21:17:58 -04:00
|
|
|
#include <asm/cacheflush.h>
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
#include <asm/ppc32.h>
|
2005-04-16 18:20:36 -04:00
|
|
|
#include <asm/ppcdebug.h>
|
|
|
|
#include <asm/unistd.h>
|
|
|
|
#include <asm/vdso.h>
|
2005-10-17 21:17:58 -04:00
|
|
|
#else
|
|
|
|
#include <asm/ucontext.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#undef DEBUG_SIG
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
#define do_signal do_signal32
|
2005-10-18 00:51:57 -04:00
|
|
|
#define sys_sigsuspend compat_sys_sigsuspend
|
|
|
|
#define sys_rt_sigsuspend compat_sys_rt_sigsuspend
|
|
|
|
#define sys_rt_sigreturn compat_sys_rt_sigreturn
|
|
|
|
#define sys_sigaction compat_sys_sigaction
|
|
|
|
#define sys_swapcontext compat_sys_swapcontext
|
|
|
|
#define sys_sigreturn compat_sys_sigreturn
|
2005-10-17 21:17:58 -04:00
|
|
|
|
|
|
|
#define old_sigaction old_sigaction32
|
|
|
|
#define sigcontext sigcontext32
|
|
|
|
#define mcontext mcontext32
|
|
|
|
#define ucontext ucontext32
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Returning 0 means we return to userspace via
|
|
|
|
* ret_from_except and thus restore all user
|
|
|
|
* registers from *regs. This is what we need
|
|
|
|
* to do when a signal has been delivered.
|
|
|
|
*/
|
|
|
|
#define sigreturn_exit(regs) return 0
|
|
|
|
|
|
|
|
#define GP_REGS_SIZE min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
|
|
|
|
#undef __SIGNAL_FRAMESIZE
|
|
|
|
#define __SIGNAL_FRAMESIZE __SIGNAL_FRAMESIZE32
|
|
|
|
#undef ELF_NVRREG
|
|
|
|
#define ELF_NVRREG ELF_NVRREG32
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functions for flipping sigsets (thanks to brain dead generic
|
|
|
|
* implementation that makes things simple for little endian only)
|
|
|
|
*/
|
|
|
|
static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
|
|
|
|
{
|
|
|
|
compat_sigset_t cset;
|
|
|
|
|
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
|
|
|
|
cset.sig[7] = set->sig[3] >> 32;
|
|
|
|
case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
|
|
|
|
cset.sig[5] = set->sig[2] >> 32;
|
|
|
|
case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
|
|
|
|
cset.sig[3] = set->sig[1] >> 32;
|
|
|
|
case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
|
|
|
|
cset.sig[1] = set->sig[0] >> 32;
|
|
|
|
}
|
|
|
|
return copy_to_user(uset, &cset, sizeof(*uset));
|
|
|
|
}
|
|
|
|
|
2005-10-19 09:13:04 -04:00
|
|
|
static inline int get_sigset_t(sigset_t *set,
|
|
|
|
const compat_sigset_t __user *uset)
|
2005-10-17 21:17:58 -04:00
|
|
|
{
|
|
|
|
compat_sigset_t s32;
|
|
|
|
|
|
|
|
if (copy_from_user(&s32, uset, sizeof(*uset)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Swap the 2 words of the 64-bit sigset_t (they are stored
|
|
|
|
* in the "wrong" endian in 32-bit user storage).
|
|
|
|
*/
|
|
|
|
switch (_NSIG_WORDS) {
|
|
|
|
case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
|
|
|
|
case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
|
|
|
|
case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
|
|
|
|
case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_old_sigaction(struct k_sigaction *new_ka,
|
|
|
|
struct old_sigaction __user *act)
|
|
|
|
{
|
|
|
|
compat_old_sigset_t mask;
|
|
|
|
compat_uptr_t handler, restorer;
|
|
|
|
|
|
|
|
if (get_user(handler, &act->sa_handler) ||
|
|
|
|
__get_user(restorer, &act->sa_restorer) ||
|
|
|
|
__get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
|
|
|
|
__get_user(mask, &act->sa_mask))
|
|
|
|
return -EFAULT;
|
|
|
|
new_ka->sa.sa_handler = compat_ptr(handler);
|
|
|
|
new_ka->sa.sa_restorer = compat_ptr(restorer);
|
|
|
|
siginitset(&new_ka->sa.sa_mask, mask);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline compat_uptr_t to_user_ptr(void *kp)
|
|
|
|
{
|
|
|
|
return (compat_uptr_t)(u64)kp;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define from_user_ptr(p) compat_ptr(p)
|
|
|
|
|
|
|
|
static inline int save_general_regs(struct pt_regs *regs,
|
|
|
|
struct mcontext __user *frame)
|
|
|
|
{
|
|
|
|
elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i <= PT_RESULT; i ++)
|
|
|
|
if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int restore_general_regs(struct pt_regs *regs,
|
|
|
|
struct mcontext __user *sr)
|
|
|
|
{
|
|
|
|
elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i <= PT_RESULT; i++) {
|
|
|
|
if ((i == PT_MSR) || (i == PT_SOFTE))
|
|
|
|
continue;
|
|
|
|
if (__get_user(gregs[i], &sr->mc_gregs[i]))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else /* CONFIG_PPC64 */
|
|
|
|
|
|
|
|
extern void sigreturn_exit(struct pt_regs *);
|
|
|
|
|
|
|
|
#define GP_REGS_SIZE min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
|
|
|
|
|
|
|
|
static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
|
|
|
|
{
|
|
|
|
return copy_to_user(uset, set, sizeof(*uset));
|
|
|
|
}
|
|
|
|
|
2005-10-19 09:13:04 -04:00
|
|
|
static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
|
2005-10-17 21:17:58 -04:00
|
|
|
{
|
|
|
|
return copy_from_user(set, uset, sizeof(*uset));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int get_old_sigaction(struct k_sigaction *new_ka,
|
|
|
|
struct old_sigaction __user *act)
|
|
|
|
{
|
|
|
|
old_sigset_t mask;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
|
|
|
|
__get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
|
|
|
|
__get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
|
|
|
|
return -EFAULT;
|
|
|
|
__get_user(new_ka->sa.sa_flags, &act->sa_flags);
|
|
|
|
__get_user(mask, &act->sa_mask);
|
|
|
|
siginitset(&new_ka->sa.sa_mask, mask);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define to_user_ptr(p) (p)
|
|
|
|
#define from_user_ptr(p) (p)
|
|
|
|
|
|
|
|
static inline int save_general_regs(struct pt_regs *regs,
|
|
|
|
struct mcontext __user *frame)
|
|
|
|
{
|
|
|
|
return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int restore_general_regs(struct pt_regs *regs,
|
|
|
|
struct mcontext __user *sr)
|
|
|
|
{
|
|
|
|
/* copy up to but not including MSR */
|
|
|
|
if (__copy_from_user(regs, &sr->mc_gregs,
|
|
|
|
PT_MSR * sizeof(elf_greg_t)))
|
|
|
|
return -EFAULT;
|
|
|
|
/* copy from orig_r3 (the word after the MSR) up to the end */
|
|
|
|
if (__copy_from_user(®s->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
|
|
|
|
GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_PPC64 */
|
|
|
|
|
|
|
|
int do_signal(sigset_t *oldset, struct pt_regs *regs);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Atomically swap in the new signal mask, and wait for a signal.
|
|
|
|
*/
|
|
|
|
long sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
sigset_t saveset;
|
|
|
|
|
|
|
|
mask &= _BLOCKABLE;
|
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
|
|
|
saveset = current->blocked;
|
|
|
|
siginitset(¤t->blocked, mask);
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
|
|
|
|
|
|
|
regs->result = -EINTR;
|
|
|
|
regs->gpr[3] = EINTR;
|
|
|
|
regs->ccr |= 0x10000000;
|
|
|
|
while (1) {
|
|
|
|
current->state = TASK_INTERRUPTIBLE;
|
|
|
|
schedule();
|
|
|
|
if (do_signal(&saveset, regs))
|
|
|
|
sigreturn_exit(regs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
long sys_rt_sigsuspend(
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
compat_sigset_t __user *unewset,
|
|
|
|
#else
|
|
|
|
sigset_t __user *unewset,
|
|
|
|
#endif
|
|
|
|
size_t sigsetsize, int p3, int p4,
|
|
|
|
int p6, int p7, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
sigset_t saveset, newset;
|
|
|
|
|
|
|
|
/* XXX: Don't preclude handling different sized sigset_t's. */
|
|
|
|
if (sigsetsize != sizeof(sigset_t))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (get_sigset_t(&newset, unewset))
|
|
|
|
return -EFAULT;
|
|
|
|
sigdelsetmask(&newset, ~_BLOCKABLE);
|
|
|
|
|
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
|
|
|
saveset = current->blocked;
|
|
|
|
current->blocked = newset;
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
|
|
|
|
|
|
|
regs->result = -EINTR;
|
|
|
|
regs->gpr[3] = EINTR;
|
|
|
|
regs->ccr |= 0x10000000;
|
|
|
|
while (1) {
|
|
|
|
current->state = TASK_INTERRUPTIBLE;
|
|
|
|
schedule();
|
|
|
|
if (do_signal(&saveset, regs))
|
|
|
|
sigreturn_exit(regs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
long sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss, int r5,
|
|
|
|
int r6, int r7, int r8, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
return do_sigaltstack(uss, uoss, regs->gpr[1]);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
long sys_sigaction(int sig, struct old_sigaction __user *act,
|
|
|
|
struct old_sigaction __user *oact)
|
|
|
|
{
|
|
|
|
struct k_sigaction new_ka, old_ka;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
if (sig < 0)
|
|
|
|
sig = -sig;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (act) {
|
|
|
|
if (get_old_sigaction(&new_ka, act))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
|
|
|
|
if (!ret && oact) {
|
|
|
|
if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
|
|
|
|
__put_user(to_user_ptr(old_ka.sa.sa_handler),
|
|
|
|
&oact->sa_handler) ||
|
|
|
|
__put_user(to_user_ptr(old_ka.sa.sa_restorer),
|
|
|
|
&oact->sa_restorer) ||
|
|
|
|
__put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
|
|
|
|
__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* When we have signals to deliver, we set up on the
|
|
|
|
* user stack, going down from the original stack pointer:
|
2005-10-17 21:17:58 -04:00
|
|
|
* a sigregs struct
|
|
|
|
* a sigcontext struct
|
|
|
|
* a gap of __SIGNAL_FRAMESIZE bytes
|
2005-04-16 18:20:36 -04:00
|
|
|
*
|
|
|
|
* Each of these things must be a multiple of 16 bytes in size.
|
|
|
|
*
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
struct sigregs {
|
|
|
|
struct mcontext mctx; /* all the register values */
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Programs using the rs6000/xcoff abi can save up to 19 gp
|
|
|
|
* regs and 18 fp regs below sp before decrementing it.
|
|
|
|
*/
|
|
|
|
int abigap[56];
|
|
|
|
};
|
|
|
|
|
|
|
|
/* We use the mc_pad field for the signal return trampoline. */
|
|
|
|
#define tramp mc_pad
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When we have rt signals to deliver, we set up on the
|
|
|
|
* user stack, going down from the original stack pointer:
|
2005-10-17 21:17:58 -04:00
|
|
|
* one rt_sigframe struct (siginfo + ucontext + ABI gap)
|
|
|
|
* a gap of __SIGNAL_FRAMESIZE+16 bytes
|
|
|
|
* (the +16 is to get the siginfo and ucontext in the same
|
2005-04-16 18:20:36 -04:00
|
|
|
* positions as in older kernels).
|
|
|
|
*
|
|
|
|
* Each of these things must be a multiple of 16 bytes in size.
|
|
|
|
*
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
struct rt_sigframe {
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
compat_siginfo_t info;
|
|
|
|
#else
|
|
|
|
struct siginfo info;
|
|
|
|
#endif
|
|
|
|
struct ucontext uc;
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Programs using the rs6000/xcoff abi can save up to 19 gp
|
|
|
|
* regs and 18 fp regs below sp before decrementing it.
|
|
|
|
*/
|
|
|
|
int abigap[56];
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Save the current user registers on the user stack.
|
2005-10-17 21:17:58 -04:00
|
|
|
* We only save the altivec/spe registers if the process has used
|
|
|
|
* altivec/spe instructions at some point.
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
|
|
|
|
int sigret)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
CHECK_FULL_REGS(regs);
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Make sure floating point registers are stored in regs */
|
|
|
|
flush_fp_to_thread(current);
|
|
|
|
|
|
|
|
/* save general and floating-point registers */
|
2005-10-17 21:17:58 -04:00
|
|
|
if (save_general_regs(regs, frame) ||
|
|
|
|
__copy_to_user(&frame->mc_fregs, current->thread.fpr,
|
|
|
|
ELF_NFPREG * sizeof(double)))
|
2005-04-16 18:20:36 -04:00
|
|
|
return 1;
|
|
|
|
|
[PATCH] powerpc: Fix handling of fpscr on 64-bit
The recent merge of fpu.S broken the handling of fpscr for
ARCH=powerpc and CONFIG_PPC64=y. FP registers could be corrupted,
leading to strange random application crashes.
The confusion arises, because the thread_struct has (and requires) a
64-bit area to save the fpscr, because we use load/store double
instructions to get it in to/out of the FPU. However, only the low
32-bits are actually used, so we want to treat it as a 32-bit quantity
when manipulating its bits to avoid extra load/stores on 32-bit. This
patch replaces the current definition with a structure of two 32-bit
quantities (pad and val), to clarify things as much as is possible.
The 'val' field is used when manipulating bits, the structure itself
is used when obtaining the address for loading/unloading the value
from the FPU.
While we're at it, consolidate the 4 (!) almost identical versions of
cvt_fd() and cvt_df() (arch/ppc/kernel/misc.S,
arch/ppc64/kernel/misc.S, arch/powerpc/kernel/misc_32.S,
arch/powerpc/kernel/misc_64.S) into a single version in fpu.S. The
new version takes a pointer to thread_struct and applies the correct
offset itself, rather than a pointer to the fpscr field itself, again
to avoid confusion as to which is the correct field to use.
Finally, this patch makes ARCH=ppc64 also use the consolidated fpu.S
code, which it previously did not.
Built for G5 (ARCH=ppc64 and ARCH=powerpc), 32-bit powermac (ARCH=ppc
and ARCH=powerpc) and Walnut (ARCH=ppc, CONFIG_MATH_EMULATION=y).
Booted on G5 (ARCH=powerpc) and things which previously fell over no
longer do.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-10-27 02:27:25 -04:00
|
|
|
current->thread.fpscr.val = 0; /* turn off all fp exceptions */
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
/* save altivec registers */
|
|
|
|
if (current->thread.used_vr) {
|
|
|
|
flush_altivec_to_thread(current);
|
|
|
|
if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
|
2005-10-17 21:17:58 -04:00
|
|
|
ELF_NVRREG * sizeof(vector128)))
|
2005-04-16 18:20:36 -04:00
|
|
|
return 1;
|
|
|
|
/* set MSR_VEC in the saved MSR value to indicate that
|
|
|
|
frame->mc_vregs contains valid data */
|
|
|
|
if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/* else assert((regs->msr & MSR_VEC) == 0) */
|
|
|
|
|
|
|
|
/* We always copy to/from vrsave, it's 0 if we don't have or don't
|
|
|
|
* use altivec. Since VSCR only contains 32 bits saved in the least
|
|
|
|
* significant bits of a vector, we "cheat" and stuff VRSAVE in the
|
|
|
|
* most significant bits of that same vector. --BenH
|
|
|
|
*/
|
|
|
|
if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
|
|
|
|
return 1;
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
/* save spe registers */
|
|
|
|
if (current->thread.used_spe) {
|
|
|
|
flush_spe_to_thread(current);
|
|
|
|
if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
|
|
|
|
ELF_NEVRREG * sizeof(u32)))
|
|
|
|
return 1;
|
|
|
|
/* set MSR_SPE in the saved MSR value to indicate that
|
|
|
|
frame->mc_vregs contains valid data */
|
|
|
|
if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
/* else assert((regs->msr & MSR_SPE) == 0) */
|
|
|
|
|
|
|
|
/* We always copy to/from spefscr */
|
|
|
|
if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
|
|
|
|
return 1;
|
|
|
|
#endif /* CONFIG_SPE */
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (sigret) {
|
|
|
|
/* Set up the sigreturn trampoline: li r0,sigret; sc */
|
|
|
|
if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
|
|
|
|
|| __put_user(0x44000002UL, &frame->tramp[1]))
|
|
|
|
return 1;
|
|
|
|
flush_icache_range((unsigned long) &frame->tramp[0],
|
|
|
|
(unsigned long) &frame->tramp[2]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Restore the current user register values from the user stack,
|
|
|
|
* (except for MSR).
|
|
|
|
*/
|
|
|
|
static long restore_user_regs(struct pt_regs *regs,
|
2005-10-17 21:17:58 -04:00
|
|
|
struct mcontext __user *sr, int sig)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2005-10-17 21:17:58 -04:00
|
|
|
long err;
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned int save_r2 = 0;
|
2005-10-17 21:17:58 -04:00
|
|
|
#if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned long msr;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* restore general registers but not including MSR or SOFTE. Also
|
|
|
|
* take care of keeping r2 (TLS) intact if not a signal
|
|
|
|
*/
|
|
|
|
if (!sig)
|
|
|
|
save_r2 = (unsigned int)regs->gpr[2];
|
2005-10-17 21:17:58 -04:00
|
|
|
err = restore_general_regs(regs, sr);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!sig)
|
|
|
|
regs->gpr[2] = (unsigned long) save_r2;
|
|
|
|
if (err)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* force the process to reload the FP registers from
|
|
|
|
current->thread when it next does FP instructions */
|
|
|
|
regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
|
|
|
|
if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
|
|
|
|
sizeof(sr->mc_fregs)))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
#ifdef CONFIG_ALTIVEC
|
|
|
|
/* force the process to reload the altivec registers from
|
|
|
|
current->thread when it next does altivec instructions */
|
|
|
|
regs->msr &= ~MSR_VEC;
|
|
|
|
if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
|
|
|
|
/* restore altivec registers from the stack */
|
|
|
|
if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
|
|
|
|
sizeof(sr->mc_vregs)))
|
|
|
|
return 1;
|
|
|
|
} else if (current->thread.used_vr)
|
2005-10-17 21:17:58 -04:00
|
|
|
memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Always get VRSAVE back */
|
|
|
|
if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
|
|
|
|
return 1;
|
|
|
|
#endif /* CONFIG_ALTIVEC */
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
/* force the process to reload the spe registers from
|
|
|
|
current->thread when it next does spe instructions */
|
|
|
|
regs->msr &= ~MSR_SPE;
|
|
|
|
if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
|
|
|
|
/* restore spe registers from the stack */
|
|
|
|
if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
|
|
|
|
ELF_NEVRREG * sizeof(u32)))
|
|
|
|
return 1;
|
|
|
|
} else if (current->thread.used_spe)
|
|
|
|
memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
|
|
|
|
|
|
|
|
/* Always get SPEFSCR back */
|
|
|
|
if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
|
|
|
|
return 1;
|
|
|
|
#endif /* CONFIG_SPE */
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
#ifndef CONFIG_SMP
|
|
|
|
preempt_disable();
|
|
|
|
if (last_task_used_math == current)
|
|
|
|
last_task_used_math = NULL;
|
|
|
|
if (last_task_used_altivec == current)
|
|
|
|
last_task_used_altivec = NULL;
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_SPE
|
|
|
|
if (last_task_used_spe == current)
|
|
|
|
last_task_used_spe = NULL;
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
preempt_enable();
|
|
|
|
#endif
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-10-18 00:51:57 -04:00
|
|
|
long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
|
2005-04-16 18:20:36 -04:00
|
|
|
struct sigaction32 __user *oact, size_t sigsetsize)
|
|
|
|
{
|
|
|
|
struct k_sigaction new_ka, old_ka;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* XXX: Don't preclude handling different sized sigset_t's. */
|
|
|
|
if (sigsetsize != sizeof(compat_sigset_t))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (act) {
|
|
|
|
compat_uptr_t handler;
|
|
|
|
|
|
|
|
ret = get_user(handler, &act->sa_handler);
|
|
|
|
new_ka.sa.sa_handler = compat_ptr(handler);
|
2005-10-17 21:17:58 -04:00
|
|
|
ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
|
|
|
|
if (ret)
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
|
|
|
|
if (!ret && oact) {
|
|
|
|
ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
|
2005-10-17 21:17:58 -04:00
|
|
|
ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
|
2005-04-16 18:20:36 -04:00
|
|
|
ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note: it is necessary to treat how as an unsigned int, with the
|
|
|
|
* corresponding cast to a signed int to insure that the proper
|
|
|
|
* conversion (sign extension) between the register representation
|
|
|
|
* of a signed int (msr in 32-bit mode) and the register representation
|
|
|
|
* of a signed int (msr in 64-bit mode) is performed.
|
|
|
|
*/
|
2005-10-18 00:51:57 -04:00
|
|
|
long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
|
2005-04-16 18:20:36 -04:00
|
|
|
compat_sigset_t __user *oset, size_t sigsetsize)
|
|
|
|
{
|
|
|
|
sigset_t s;
|
|
|
|
sigset_t __user *up;
|
|
|
|
int ret;
|
|
|
|
mm_segment_t old_fs = get_fs();
|
|
|
|
|
|
|
|
if (set) {
|
2005-10-17 21:17:58 -04:00
|
|
|
if (get_sigset_t(&s, set))
|
|
|
|
return -EFAULT;
|
2005-04-16 18:20:36 -04:00
|
|
|
}
|
2005-10-17 21:17:58 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
/* This is valid because of the set_fs() */
|
|
|
|
up = (sigset_t __user *) &s;
|
|
|
|
ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
|
2005-10-17 21:17:58 -04:00
|
|
|
sigsetsize);
|
2005-04-16 18:20:36 -04:00
|
|
|
set_fs(old_fs);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (oset) {
|
2005-10-17 21:17:58 -04:00
|
|
|
if (put_sigset_t(oset, &s))
|
2005-04-16 18:20:36 -04:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-18 00:51:57 -04:00
|
|
|
long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
sigset_t s;
|
|
|
|
int ret;
|
|
|
|
mm_segment_t old_fs = get_fs();
|
|
|
|
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
/* The __user pointer cast is valid because of the set_fs() */
|
|
|
|
ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
|
|
|
|
set_fs(old_fs);
|
|
|
|
if (!ret) {
|
2005-10-17 21:17:58 -04:00
|
|
|
if (put_sigset_t(set, &s))
|
2005-04-16 18:20:36 -04:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/* If you change siginfo_t structure, please be sure
|
|
|
|
* this code is fixed accordingly.
|
|
|
|
* It should never copy any pad contained in the structure
|
|
|
|
* to avoid security leaks, but must copy the generic
|
|
|
|
* 3 ints plus the relevant union member.
|
|
|
|
* This routine must convert siginfo from 64bit to 32bit as well
|
|
|
|
* at the same time.
|
|
|
|
*/
|
|
|
|
err = __put_user(s->si_signo, &d->si_signo);
|
|
|
|
err |= __put_user(s->si_errno, &d->si_errno);
|
|
|
|
err |= __put_user((short)s->si_code, &d->si_code);
|
|
|
|
if (s->si_code < 0)
|
|
|
|
err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
|
|
|
|
SI_PAD_SIZE32);
|
|
|
|
else switch(s->si_code >> 16) {
|
|
|
|
case __SI_CHLD >> 16:
|
|
|
|
err |= __put_user(s->si_pid, &d->si_pid);
|
|
|
|
err |= __put_user(s->si_uid, &d->si_uid);
|
|
|
|
err |= __put_user(s->si_utime, &d->si_utime);
|
|
|
|
err |= __put_user(s->si_stime, &d->si_stime);
|
|
|
|
err |= __put_user(s->si_status, &d->si_status);
|
|
|
|
break;
|
|
|
|
case __SI_FAULT >> 16:
|
|
|
|
err |= __put_user((unsigned int)(unsigned long)s->si_addr,
|
|
|
|
&d->si_addr);
|
|
|
|
break;
|
|
|
|
case __SI_POLL >> 16:
|
|
|
|
err |= __put_user(s->si_band, &d->si_band);
|
|
|
|
err |= __put_user(s->si_fd, &d->si_fd);
|
|
|
|
break;
|
|
|
|
case __SI_TIMER >> 16:
|
|
|
|
err |= __put_user(s->si_tid, &d->si_tid);
|
|
|
|
err |= __put_user(s->si_overrun, &d->si_overrun);
|
|
|
|
err |= __put_user(s->si_int, &d->si_int);
|
|
|
|
break;
|
|
|
|
case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
|
|
|
|
case __SI_MESGQ >> 16:
|
|
|
|
err |= __put_user(s->si_int, &d->si_int);
|
|
|
|
/* fallthrough */
|
|
|
|
case __SI_KILL >> 16:
|
|
|
|
default:
|
|
|
|
err |= __put_user(s->si_pid, &d->si_pid);
|
|
|
|
err |= __put_user(s->si_uid, &d->si_uid);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#define copy_siginfo_to_user copy_siginfo_to_user32
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Note: it is necessary to treat pid and sig as unsigned ints, with the
|
|
|
|
* corresponding cast to a signed int to insure that the proper conversion
|
|
|
|
* (sign extension) between the register representation of a signed int
|
|
|
|
* (msr in 32-bit mode) and the register representation of a signed int
|
|
|
|
* (msr in 64-bit mode) is performed.
|
|
|
|
*/
|
2005-10-18 00:51:57 -04:00
|
|
|
long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
siginfo_t info;
|
|
|
|
int ret;
|
|
|
|
mm_segment_t old_fs = get_fs();
|
2005-10-17 21:17:58 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
|
|
|
|
copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
|
|
|
|
return -EFAULT;
|
|
|
|
set_fs (KERNEL_DS);
|
|
|
|
/* The __user pointer cast is valid becasuse of the set_fs() */
|
|
|
|
ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
|
|
|
|
set_fs (old_fs);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Start Alternate signal stack support
|
|
|
|
*
|
|
|
|
* System Calls
|
2005-10-18 00:51:57 -04:00
|
|
|
* sigaltatck compat_sys_sigaltstack
|
2005-04-16 18:20:36 -04:00
|
|
|
*/
|
|
|
|
|
2005-10-18 00:51:57 -04:00
|
|
|
int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
|
2005-04-16 18:20:36 -04:00
|
|
|
int r6, int r7, int r8, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
|
|
|
|
stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
|
|
|
|
stack_t uss, uoss;
|
|
|
|
int ret;
|
|
|
|
mm_segment_t old_fs;
|
|
|
|
unsigned long sp;
|
|
|
|
compat_uptr_t ss_sp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* set sp to the user stack on entry to the system call
|
|
|
|
* the system call router sets R9 to the saved registers
|
|
|
|
*/
|
|
|
|
sp = regs->gpr[1];
|
|
|
|
|
|
|
|
/* Put new stack info in local 64 bit stack struct */
|
|
|
|
if (newstack) {
|
|
|
|
if (get_user(ss_sp, &newstack->ss_sp) ||
|
|
|
|
__get_user(uss.ss_flags, &newstack->ss_flags) ||
|
|
|
|
__get_user(uss.ss_size, &newstack->ss_size))
|
|
|
|
return -EFAULT;
|
|
|
|
uss.ss_sp = compat_ptr(ss_sp);
|
|
|
|
}
|
|
|
|
|
|
|
|
old_fs = get_fs();
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
/* The __user pointer casts are valid because of the set_fs() */
|
|
|
|
ret = do_sigaltstack(
|
|
|
|
newstack ? (stack_t __user *) &uss : NULL,
|
|
|
|
oldstack ? (stack_t __user *) &uoss : NULL,
|
|
|
|
sp);
|
|
|
|
set_fs(old_fs);
|
|
|
|
/* Copy the stack information to the user output buffer */
|
|
|
|
if (!ret && oldstack &&
|
|
|
|
(put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
|
|
|
|
__put_user(uoss.ss_flags, &oldstack->ss_flags) ||
|
|
|
|
__put_user(uoss.ss_size, &oldstack->ss_size)))
|
|
|
|
return -EFAULT;
|
|
|
|
return ret;
|
|
|
|
}
|
2005-10-17 21:17:58 -04:00
|
|
|
#endif /* CONFIG_PPC64 */
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
/*
|
|
|
|
* Restore the user process's signal mask
|
|
|
|
*/
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
extern void restore_sigmask(sigset_t *set);
|
|
|
|
#else /* CONFIG_PPC64 */
|
|
|
|
static void restore_sigmask(sigset_t *set)
|
|
|
|
{
|
|
|
|
sigdelsetmask(set, ~_BLOCKABLE);
|
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
|
|
|
current->blocked = *set;
|
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Set up a signal frame for a "real-time" signal handler
|
|
|
|
* (one which gets siginfo).
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
|
|
|
|
siginfo_t *info, sigset_t *oldset,
|
|
|
|
struct pt_regs *regs, unsigned long newsp)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2005-10-17 21:17:58 -04:00
|
|
|
struct rt_sigframe __user *rt_sf;
|
|
|
|
struct mcontext __user *frame;
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned long origsp = newsp;
|
|
|
|
|
|
|
|
/* Set up Signal Frame */
|
|
|
|
/* Put a Real Time Context onto stack */
|
|
|
|
newsp -= sizeof(*rt_sf);
|
2005-10-17 21:17:58 -04:00
|
|
|
rt_sf = (struct rt_sigframe __user *)newsp;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* create a stack frame for the caller of the handler */
|
2005-10-17 21:17:58 -04:00
|
|
|
newsp -= __SIGNAL_FRAMESIZE + 16;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
/* Put the siginfo & fill in most of the ucontext */
|
2005-10-17 21:17:58 -04:00
|
|
|
if (copy_siginfo_to_user(&rt_sf->info, info)
|
2005-04-16 18:20:36 -04:00
|
|
|
|| __put_user(0, &rt_sf->uc.uc_flags)
|
|
|
|
|| __put_user(0, &rt_sf->uc.uc_link)
|
|
|
|
|| __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
|
|
|
|
|| __put_user(sas_ss_flags(regs->gpr[1]),
|
|
|
|
&rt_sf->uc.uc_stack.ss_flags)
|
|
|
|
|| __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
|
2005-10-17 21:17:58 -04:00
|
|
|
|| __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
|
|
|
|
&rt_sf->uc.uc_regs)
|
|
|
|
|| put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
|
2005-04-16 18:20:36 -04:00
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
/* Save user registers on the stack */
|
|
|
|
frame = &rt_sf->uc.uc_mcontext;
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 18:20:36 -04:00
|
|
|
if (vdso32_rt_sigtramp && current->thread.vdso_base) {
|
|
|
|
if (save_user_regs(regs, frame, 0))
|
|
|
|
goto badframe;
|
|
|
|
regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
|
2005-10-17 21:17:58 -04:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2005-04-16 18:20:36 -04:00
|
|
|
if (save_user_regs(regs, frame, __NR_rt_sigreturn))
|
|
|
|
goto badframe;
|
|
|
|
regs->link = (unsigned long) frame->tramp;
|
|
|
|
}
|
2005-10-22 00:46:33 -04:00
|
|
|
if (put_user(regs->gpr[1], (u32 __user *)newsp))
|
2005-10-17 21:17:58 -04:00
|
|
|
goto badframe;
|
|
|
|
regs->gpr[1] = newsp;
|
2005-04-16 18:20:36 -04:00
|
|
|
regs->gpr[3] = sig;
|
|
|
|
regs->gpr[4] = (unsigned long) &rt_sf->info;
|
|
|
|
regs->gpr[5] = (unsigned long) &rt_sf->uc;
|
|
|
|
regs->gpr[6] = (unsigned long) rt_sf;
|
|
|
|
regs->nip = (unsigned long) ka->sa.sa_handler;
|
|
|
|
regs->trap = 0;
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 18:20:36 -04:00
|
|
|
regs->result = 0;
|
|
|
|
|
|
|
|
if (test_thread_flag(TIF_SINGLESTEP))
|
|
|
|
ptrace_notify(SIGTRAP);
|
2005-10-17 21:17:58 -04:00
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
badframe:
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef DEBUG_SIG
|
2005-04-16 18:20:36 -04:00
|
|
|
printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
|
|
|
|
regs, frame, newsp);
|
|
|
|
#endif
|
|
|
|
force_sigsegv(sig, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
sigset_t set;
|
2005-10-17 21:17:58 -04:00
|
|
|
struct mcontext __user *mcp;
|
|
|
|
|
|
|
|
if (get_sigset_t(&set, &ucp->uc_sigmask))
|
|
|
|
return -EFAULT;
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
{
|
|
|
|
u32 cmcp;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
if (__get_user(cmcp, &ucp->uc_regs))
|
|
|
|
return -EFAULT;
|
|
|
|
mcp = (struct mcontext __user *)(u64)cmcp;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (__get_user(mcp, &ucp->uc_regs))
|
2005-04-16 18:20:36 -04:00
|
|
|
return -EFAULT;
|
2005-10-17 21:17:58 -04:00
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
restore_sigmask(&set);
|
2005-10-17 21:17:58 -04:00
|
|
|
if (restore_user_regs(regs, mcp, sig))
|
2005-04-16 18:20:36 -04:00
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
long sys_swapcontext(struct ucontext __user *old_ctx,
|
|
|
|
struct ucontext __user *new_ctx,
|
2005-04-16 18:20:36 -04:00
|
|
|
int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
unsigned char tmp;
|
|
|
|
|
|
|
|
/* Context size is for future use. Right now, we only make sure
|
|
|
|
* we are passed something we understand
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
if (ctx_size < sizeof(struct ucontext))
|
2005-04-16 18:20:36 -04:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (old_ctx != NULL) {
|
|
|
|
if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
|
|
|
|
|| save_user_regs(regs, &old_ctx->uc_mcontext, 0)
|
2005-10-17 21:17:58 -04:00
|
|
|
|| put_sigset_t(&old_ctx->uc_sigmask, ¤t->blocked)
|
|
|
|
|| __put_user(to_user_ptr(&old_ctx->uc_mcontext),
|
|
|
|
&old_ctx->uc_regs))
|
2005-04-16 18:20:36 -04:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
if (new_ctx == NULL)
|
|
|
|
return 0;
|
|
|
|
if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
|
|
|
|
|| __get_user(tmp, (u8 __user *) new_ctx)
|
|
|
|
|| __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get a fault copying the context into the kernel's
|
|
|
|
* image of the user's registers, we can't just return -EFAULT
|
|
|
|
* because the user's registers will be corrupted. For instance
|
|
|
|
* the NIP value may have been updated but not some of the
|
|
|
|
* other registers. Given that we have done the access_ok
|
|
|
|
* and successfully read the first and last bytes of the region
|
|
|
|
* above, this should only happen in an out-of-memory situation
|
|
|
|
* or if another thread unmaps the region containing the context.
|
|
|
|
* We kill the task with a SIGSEGV in this situation.
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
if (do_setcontext(new_ctx, regs, 0))
|
2005-04-16 18:20:36 -04:00
|
|
|
do_exit(SIGSEGV);
|
2005-10-17 21:17:58 -04:00
|
|
|
sigreturn_exit(regs);
|
|
|
|
/* doesn't actually return back to here */
|
2005-04-16 18:20:36 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
|
2005-04-16 18:20:36 -04:00
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
2005-10-17 21:17:58 -04:00
|
|
|
struct rt_sigframe __user *rt_sf;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
|
|
|
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
rt_sf = (struct rt_sigframe __user *)
|
|
|
|
(regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
|
|
|
|
goto bad;
|
2005-10-17 21:17:58 -04:00
|
|
|
if (do_setcontext(&rt_sf->uc, regs, 1))
|
2005-04-16 18:20:36 -04:00
|
|
|
goto bad;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It's not clear whether or why it is desirable to save the
|
|
|
|
* sigaltstack setting on signal delivery and restore it on
|
|
|
|
* signal return. But other architectures do this and we have
|
|
|
|
* always done it up until now so it is probably better not to
|
|
|
|
* change it. -- paulus
|
2005-10-17 21:17:58 -04:00
|
|
|
*/
|
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
/*
|
2005-10-18 00:51:57 -04:00
|
|
|
* We use the compat_sys_ version that does the 32/64 bits conversion
|
2005-04-16 18:20:36 -04:00
|
|
|
* and takes userland pointer directly. What about error checking ?
|
|
|
|
* nobody does any...
|
|
|
|
*/
|
2005-10-18 00:51:57 -04:00
|
|
|
compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
|
2005-10-17 21:17:58 -04:00
|
|
|
return (int)regs->result;
|
|
|
|
#else
|
|
|
|
do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
|
|
|
|
sigreturn_exit(regs); /* doesn't return here */
|
|
|
|
return 0;
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
bad:
|
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
int sys_debug_setcontext(struct ucontext __user *ctx,
|
|
|
|
int ndbg, struct sig_dbg_op __user *dbg,
|
|
|
|
int r6, int r7, int r8,
|
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
struct sig_dbg_op op;
|
|
|
|
int i;
|
|
|
|
unsigned long new_msr = regs->msr;
|
|
|
|
#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
|
|
|
|
unsigned long new_dbcr0 = current->thread.dbcr0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
for (i=0; i<ndbg; i++) {
|
|
|
|
if (__copy_from_user(&op, dbg, sizeof(op)))
|
|
|
|
return -EFAULT;
|
|
|
|
switch (op.dbg_type) {
|
|
|
|
case SIG_DBG_SINGLE_STEPPING:
|
|
|
|
#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
|
|
|
|
if (op.dbg_value) {
|
|
|
|
new_msr |= MSR_DE;
|
|
|
|
new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
|
|
|
|
} else {
|
|
|
|
new_msr &= ~MSR_DE;
|
|
|
|
new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (op.dbg_value)
|
|
|
|
new_msr |= MSR_SE;
|
|
|
|
else
|
|
|
|
new_msr &= ~MSR_SE;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
case SIG_DBG_BRANCH_TRACING:
|
|
|
|
#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
|
|
|
|
return -EINVAL;
|
|
|
|
#else
|
|
|
|
if (op.dbg_value)
|
|
|
|
new_msr |= MSR_BE;
|
|
|
|
else
|
|
|
|
new_msr &= ~MSR_BE;
|
|
|
|
#endif
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We wait until here to actually install the values in the
|
|
|
|
registers so if we fail in the above loop, it will not
|
|
|
|
affect the contents of these registers. After this point,
|
|
|
|
failure is a problem, anyway, and it's very unlikely unless
|
|
|
|
the user is really doing something wrong. */
|
|
|
|
regs->msr = new_msr;
|
|
|
|
#if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
|
|
|
|
current->thread.dbcr0 = new_dbcr0;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we get a fault copying the context into the kernel's
|
|
|
|
* image of the user's registers, we can't just return -EFAULT
|
|
|
|
* because the user's registers will be corrupted. For instance
|
|
|
|
* the NIP value may have been updated but not some of the
|
|
|
|
* other registers. Given that we have done the access_ok
|
|
|
|
* and successfully read the first and last bytes of the region
|
|
|
|
* above, this should only happen in an out-of-memory situation
|
|
|
|
* or if another thread unmaps the region containing the context.
|
|
|
|
* We kill the task with a SIGSEGV in this situation.
|
|
|
|
*/
|
|
|
|
if (do_setcontext(ctx, regs, 1)) {
|
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It's not clear whether or why it is desirable to save the
|
|
|
|
* sigaltstack setting on signal delivery and restore it on
|
|
|
|
* signal return. But other architectures do this and we have
|
|
|
|
* always done it up until now so it is probably better not to
|
|
|
|
* change it. -- paulus
|
|
|
|
*/
|
|
|
|
do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
|
|
|
|
|
|
|
|
sigreturn_exit(regs);
|
|
|
|
/* doesn't actually return back to here */
|
|
|
|
|
|
|
|
out:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* OK, we're invoking a handler
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
static int handle_signal(unsigned long sig, struct k_sigaction *ka,
|
|
|
|
siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
|
|
|
|
unsigned long newsp)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
2005-10-17 21:17:58 -04:00
|
|
|
struct sigcontext __user *sc;
|
|
|
|
struct sigregs __user *frame;
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned long origsp = newsp;
|
|
|
|
|
|
|
|
/* Set up Signal Frame */
|
2005-10-17 21:17:58 -04:00
|
|
|
newsp -= sizeof(struct sigregs);
|
|
|
|
frame = (struct sigregs __user *) newsp;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* Put a sigcontext on the stack */
|
|
|
|
newsp -= sizeof(*sc);
|
2005-10-17 21:17:58 -04:00
|
|
|
sc = (struct sigcontext __user *) newsp;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
/* create a stack frame for the caller of the handler */
|
2005-10-17 21:17:58 -04:00
|
|
|
newsp -= __SIGNAL_FRAMESIZE;
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
#if _NSIG != 64
|
2005-10-17 21:17:58 -04:00
|
|
|
#error "Please adjust handle_signal()"
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
2005-10-17 21:17:58 -04:00
|
|
|
if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
|
2005-04-16 18:20:36 -04:00
|
|
|
|| __put_user(oldset->sig[0], &sc->oldmask)
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 18:20:36 -04:00
|
|
|
|| __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
|
2005-10-17 21:17:58 -04:00
|
|
|
#else
|
|
|
|
|| __put_user(oldset->sig[1], &sc->_unused[3])
|
|
|
|
#endif
|
|
|
|
|| __put_user(to_user_ptr(frame), &sc->regs)
|
2005-04-16 18:20:36 -04:00
|
|
|
|| __put_user(sig, &sc->signal))
|
|
|
|
goto badframe;
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 18:20:36 -04:00
|
|
|
if (vdso32_sigtramp && current->thread.vdso_base) {
|
|
|
|
if (save_user_regs(regs, &frame->mctx, 0))
|
|
|
|
goto badframe;
|
|
|
|
regs->link = current->thread.vdso_base + vdso32_sigtramp;
|
2005-10-17 21:17:58 -04:00
|
|
|
} else
|
|
|
|
#endif
|
|
|
|
{
|
2005-04-16 18:20:36 -04:00
|
|
|
if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
|
|
|
|
goto badframe;
|
|
|
|
regs->link = (unsigned long) frame->mctx.tramp;
|
|
|
|
}
|
|
|
|
|
2005-04-30 13:01:40 -04:00
|
|
|
if (put_user(regs->gpr[1], (u32 __user *)newsp))
|
2005-04-16 18:20:36 -04:00
|
|
|
goto badframe;
|
2005-10-17 21:17:58 -04:00
|
|
|
regs->gpr[1] = newsp;
|
2005-04-16 18:20:36 -04:00
|
|
|
regs->gpr[3] = sig;
|
|
|
|
regs->gpr[4] = (unsigned long) sc;
|
|
|
|
regs->nip = (unsigned long) ka->sa.sa_handler;
|
|
|
|
regs->trap = 0;
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 18:20:36 -04:00
|
|
|
regs->result = 0;
|
|
|
|
|
|
|
|
if (test_thread_flag(TIF_SINGLESTEP))
|
|
|
|
ptrace_notify(SIGTRAP);
|
2005-10-17 21:17:58 -04:00
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
badframe:
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef DEBUG_SIG
|
|
|
|
printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
|
|
|
|
regs, frame, newsp);
|
2005-04-16 18:20:36 -04:00
|
|
|
#endif
|
|
|
|
force_sigsegv(sig, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do a signal return; undo the signal stack.
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
|
2005-04-16 18:20:36 -04:00
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
2005-10-17 21:17:58 -04:00
|
|
|
struct sigcontext __user *sc;
|
|
|
|
struct sigcontext sigctx;
|
|
|
|
struct mcontext __user *sr;
|
2005-04-16 18:20:36 -04:00
|
|
|
sigset_t set;
|
|
|
|
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
|
|
|
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
|
|
|
|
goto badframe;
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-04-16 18:20:36 -04:00
|
|
|
/*
|
|
|
|
* Note that PPC32 puts the upper 32 bits of the sigmask in the
|
|
|
|
* unused part of the signal stackframe
|
|
|
|
*/
|
|
|
|
set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
|
2005-10-17 21:17:58 -04:00
|
|
|
#else
|
|
|
|
set.sig[0] = sigctx.oldmask;
|
|
|
|
set.sig[1] = sigctx._unused[3];
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
restore_sigmask(&set);
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
|
2005-04-16 18:20:36 -04:00
|
|
|
if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
|
|
|
|
|| restore_user_regs(regs, sr, 1))
|
|
|
|
goto badframe;
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
|
|
|
return (int)regs->result;
|
|
|
|
#else
|
|
|
|
sigreturn_exit(regs); /* doesn't return */
|
|
|
|
return 0;
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
badframe:
|
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that 'init' is a special process: it doesn't get signals it doesn't
|
|
|
|
* want to handle. Thus you cannot kill init even with a SIGKILL even by
|
|
|
|
* mistake.
|
|
|
|
*/
|
2005-10-17 21:17:58 -04:00
|
|
|
int do_signal(sigset_t *oldset, struct pt_regs *regs)
|
2005-04-16 18:20:36 -04:00
|
|
|
{
|
|
|
|
siginfo_t info;
|
2005-10-17 21:17:58 -04:00
|
|
|
struct k_sigaction ka;
|
2005-04-16 18:20:36 -04:00
|
|
|
unsigned int frame, newsp;
|
|
|
|
int signr, ret;
|
2005-10-17 21:17:58 -04:00
|
|
|
|
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
if (try_to_freeze()) {
|
|
|
|
signr = 0;
|
|
|
|
if (!signal_pending(current))
|
|
|
|
goto no_signal;
|
|
|
|
}
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
|
|
|
|
if (!oldset)
|
|
|
|
oldset = ¤t->blocked;
|
|
|
|
|
|
|
|
newsp = frame = 0;
|
|
|
|
|
|
|
|
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC32
|
|
|
|
no_signal:
|
|
|
|
#endif
|
2005-04-16 18:20:36 -04:00
|
|
|
if (TRAP(regs) == 0x0C00 /* System Call! */
|
|
|
|
&& regs->ccr & 0x10000000 /* error signalled */
|
|
|
|
&& ((ret = regs->gpr[3]) == ERESTARTSYS
|
|
|
|
|| ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
|
|
|
|
|| ret == ERESTART_RESTARTBLOCK)) {
|
|
|
|
|
|
|
|
if (signr > 0
|
|
|
|
&& (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
|
|
|
|
|| (ret == ERESTARTSYS
|
|
|
|
&& !(ka.sa.sa_flags & SA_RESTART)))) {
|
|
|
|
/* make the system call return an EINTR error */
|
|
|
|
regs->result = -EINTR;
|
|
|
|
regs->gpr[3] = EINTR;
|
|
|
|
/* note that the cr0.SO bit is already set */
|
|
|
|
} else {
|
|
|
|
regs->nip -= 4; /* Back up & retry system call */
|
|
|
|
regs->result = 0;
|
|
|
|
regs->trap = 0;
|
|
|
|
if (ret == ERESTART_RESTARTBLOCK)
|
|
|
|
regs->gpr[0] = __NR_restart_syscall;
|
|
|
|
else
|
|
|
|
regs->gpr[3] = regs->orig_gpr3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (signr == 0)
|
|
|
|
return 0; /* no signals delivered */
|
|
|
|
|
|
|
|
if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
|
2005-10-17 21:17:58 -04:00
|
|
|
&& !on_sig_stack(regs->gpr[1]))
|
|
|
|
newsp = current->sas_ss_sp + current->sas_ss_size;
|
2005-04-16 18:20:36 -04:00
|
|
|
else
|
|
|
|
newsp = regs->gpr[1];
|
|
|
|
newsp &= ~0xfUL;
|
|
|
|
|
2005-10-17 21:17:58 -04:00
|
|
|
#ifdef CONFIG_PPC64
|
2005-09-10 02:01:11 -04:00
|
|
|
/*
|
|
|
|
* Reenable the DABR before delivering the signal to
|
|
|
|
* user space. The DABR will have been cleared if it
|
|
|
|
* triggered inside the kernel.
|
|
|
|
*/
|
|
|
|
if (current->thread.dabr)
|
|
|
|
set_dabr(current->thread.dabr);
|
2005-10-17 21:17:58 -04:00
|
|
|
#endif
|
2005-09-10 02:01:11 -04:00
|
|
|
|
2005-04-16 18:20:36 -04:00
|
|
|
/* Whee! Actually deliver the signal. */
|
|
|
|
if (ka.sa.sa_flags & SA_SIGINFO)
|
2005-10-17 21:17:58 -04:00
|
|
|
ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
|
2005-04-16 18:20:36 -04:00
|
|
|
else
|
2005-10-17 21:17:58 -04:00
|
|
|
ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
|
2005-04-16 18:20:36 -04:00
|
|
|
|
[PATCH] convert signal handling of NODEFER to act like other Unix boxes.
It has been reported that the way Linux handles NODEFER for signals is
not consistent with the way other Unix boxes handle it. I've written a
program to test the behavior of how this flag affects signals and had
several reports from people who ran this on various Unix boxes,
confirming that Linux seems to be unique on the way this is handled.
The way NODEFER affects signals on other Unix boxes is as follows:
1) If NODEFER is set, other signals in sa_mask are still blocked.
2) If NODEFER is set and the signal is in sa_mask, then the signal is
still blocked. (Note: this is the behavior of all tested but Linux _and_
NetBSD 2.0 *).
The way NODEFER affects signals on Linux:
1) If NODEFER is set, other signals are _not_ blocked regardless of
sa_mask (Even NetBSD doesn't do this).
2) If NODEFER is set and the signal is in sa_mask, then the signal being
handled is not blocked.
The patch converts signal handling in all current Linux architectures to
the way most Unix boxes work.
Unix boxes that were tested: DU4, AIX 5.2, Irix 6.5, NetBSD 2.0, SFU
3.5 on WinXP, AIX 5.3, Mac OSX, and of course Linux 2.6.13-rcX.
* NetBSD was the only other Unix to behave like Linux on point #2. The
main concern was brought up by point #1 which even NetBSD isn't like
Linux. So with this patch, we leave NetBSD as the lonely one that
behaves differently here with #2.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-08-29 11:44:09 -04:00
|
|
|
if (ret) {
|
2005-04-16 18:20:36 -04:00
|
|
|
spin_lock_irq(¤t->sighand->siglock);
|
|
|
|
sigorsets(¤t->blocked, ¤t->blocked,
|
|
|
|
&ka.sa.sa_mask);
|
[PATCH] convert signal handling of NODEFER to act like other Unix boxes.
It has been reported that the way Linux handles NODEFER for signals is
not consistent with the way other Unix boxes handle it. I've written a
program to test the behavior of how this flag affects signals and had
several reports from people who ran this on various Unix boxes,
confirming that Linux seems to be unique on the way this is handled.
The way NODEFER affects signals on other Unix boxes is as follows:
1) If NODEFER is set, other signals in sa_mask are still blocked.
2) If NODEFER is set and the signal is in sa_mask, then the signal is
still blocked. (Note: this is the behavior of all tested but Linux _and_
NetBSD 2.0 *).
The way NODEFER affects signals on Linux:
1) If NODEFER is set, other signals are _not_ blocked regardless of
sa_mask (Even NetBSD doesn't do this).
2) If NODEFER is set and the signal is in sa_mask, then the signal being
handled is not blocked.
The patch converts signal handling in all current Linux architectures to
the way most Unix boxes work.
Unix boxes that were tested: DU4, AIX 5.2, Irix 6.5, NetBSD 2.0, SFU
3.5 on WinXP, AIX 5.3, Mac OSX, and of course Linux 2.6.13-rcX.
* NetBSD was the only other Unix to behave like Linux on point #2. The
main concern was brought up by point #1 which even NetBSD isn't like
Linux. So with this patch, we leave NetBSD as the lonely one that
behaves differently here with #2.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-08-29 11:44:09 -04:00
|
|
|
if (!(ka.sa.sa_flags & SA_NODEFER))
|
|
|
|
sigaddset(¤t->blocked, signr);
|
2005-04-16 18:20:36 -04:00
|
|
|
recalc_sigpending();
|
|
|
|
spin_unlock_irq(¤t->sighand->siglock);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|