metag: Signal handling
Add signal handling code for metag. Signed-off-by: James Hogan <james.hogan@imgtec.com> Cc: Al Viro <viro@zeniv.linux.org.uk>
This commit is contained in:
James Hogan
parent
c438b58e65
commit
262d96b0de
31
arch/metag/include/uapi/asm/sigcontext.h
Normal file
31
arch/metag/include/uapi/asm/sigcontext.h
Normal file
@ -0,0 +1,31 @@
|
||||
#ifndef _ASM_METAG_SIGCONTEXT_H
|
||||
#define _ASM_METAG_SIGCONTEXT_H
|
||||
|
||||
#include <asm/ptrace.h>
|
||||
|
||||
/*
|
||||
* In a sigcontext structure we need to store the active state of the
|
||||
* user process so that it does not get trashed when we call the signal
|
||||
* handler. That not really the same as a user context that we are
|
||||
* going to store on syscall etc.
|
||||
*/
|
||||
struct sigcontext {
|
||||
struct user_gp_regs regs; /* needs to be first */
|
||||
|
||||
/*
|
||||
* Catch registers describing a memory fault.
|
||||
* If USER_GP_REGS_STATUS_CATCH_BIT is set in regs.status then catch
|
||||
* buffers have been saved and will be replayed on sigreturn.
|
||||
* Clear that bit to discard the catch state instead of replaying it.
|
||||
*/
|
||||
struct user_cb_regs cb;
|
||||
|
||||
/*
|
||||
* Read pipeline state. This will get restored on sigreturn.
|
||||
*/
|
||||
struct user_rp_state rp;
|
||||
|
||||
unsigned long oldmask;
|
||||
};
|
||||
|
||||
#endif
|
||||
8
arch/metag/include/uapi/asm/siginfo.h
Normal file
8
arch/metag/include/uapi/asm/siginfo.h
Normal file
@ -0,0 +1,8 @@
|
||||
#ifndef _METAG_SIGINFO_H
|
||||
#define _METAG_SIGINFO_H
|
||||
|
||||
#define __ARCH_SI_TRAPNO
|
||||
|
||||
#include <asm-generic/siginfo.h>
|
||||
|
||||
#endif
|
||||
344
arch/metag/kernel/signal.c
Normal file
344
arch/metag/kernel/signal.c
Normal file
@ -0,0 +1,344 @@
|
||||
/*
|
||||
* Copyright (C) 1991,1992 Linus Torvalds
|
||||
* Copyright (C) 2005-2012 Imagination Technologies Ltd.
|
||||
*
|
||||
* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/sched.h>
|
||||
#include <linux/mm.h>
|
||||
#include <linux/smp.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/signal.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/wait.h>
|
||||
#include <linux/ptrace.h>
|
||||
#include <linux/unistd.h>
|
||||
#include <linux/stddef.h>
|
||||
#include <linux/personality.h>
|
||||
#include <linux/uaccess.h>
|
||||
#include <linux/tracehook.h>
|
||||
|
||||
#include <asm/ucontext.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <asm/switch.h>
|
||||
#include <asm/syscall.h>
|
||||
#include <asm/syscalls.h>
|
||||
|
||||
#define REG_FLAGS ctx.SaveMask
|
||||
#define REG_RETVAL ctx.DX[0].U0
|
||||
#define REG_SYSCALL ctx.DX[0].U1
|
||||
#define REG_SP ctx.AX[0].U0
|
||||
#define REG_ARG1 ctx.DX[3].U1
|
||||
#define REG_ARG2 ctx.DX[3].U0
|
||||
#define REG_ARG3 ctx.DX[2].U1
|
||||
#define REG_PC ctx.CurrPC
|
||||
#define REG_RTP ctx.DX[4].U1
|
||||
|
||||
struct rt_sigframe {
|
||||
struct siginfo info;
|
||||
struct ucontext uc;
|
||||
unsigned long retcode[2];
|
||||
};
|
||||
|
||||
static int restore_sigcontext(struct pt_regs *regs,
|
||||
struct sigcontext __user *sc)
|
||||
{
|
||||
int err;
|
||||
|
||||
/* Always make any pending restarted system calls return -EINTR */
|
||||
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
||||
|
||||
err = metag_gp_regs_copyin(regs, 0, sizeof(struct user_gp_regs), NULL,
|
||||
&sc->regs);
|
||||
if (!err)
|
||||
err = metag_cb_regs_copyin(regs, 0,
|
||||
sizeof(struct user_cb_regs), NULL,
|
||||
&sc->cb);
|
||||
if (!err)
|
||||
err = metag_rp_state_copyin(regs, 0,
|
||||
sizeof(struct user_rp_state), NULL,
|
||||
&sc->rp);
|
||||
|
||||
/* This is a user-mode context. */
|
||||
regs->REG_FLAGS |= TBICTX_PRIV_BIT;
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
long sys_rt_sigreturn(void)
|
||||
{
|
||||
/* NOTE - Meta stack goes UPWARDS - so we wind the stack back */
|
||||
struct pt_regs *regs = current_pt_regs();
|
||||
struct rt_sigframe __user *frame;
|
||||
sigset_t set;
|
||||
|
||||
frame = (__force struct rt_sigframe __user *)(regs->REG_SP -
|
||||
sizeof(*frame));
|
||||
|
||||
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
|
||||
goto badframe;
|
||||
|
||||
if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
|
||||
goto badframe;
|
||||
|
||||
set_current_blocked(&set);
|
||||
|
||||
if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
|
||||
goto badframe;
|
||||
|
||||
if (restore_altstack(&frame->uc.uc_stack))
|
||||
goto badframe;
|
||||
|
||||
return regs->REG_RETVAL;
|
||||
|
||||
badframe:
|
||||
force_sig(SIGSEGV, current);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
|
||||
unsigned long mask)
|
||||
{
|
||||
int err;
|
||||
|
||||
err = metag_gp_regs_copyout(regs, 0, sizeof(struct user_gp_regs), NULL,
|
||||
&sc->regs);
|
||||
|
||||
if (!err)
|
||||
err = metag_cb_regs_copyout(regs, 0,
|
||||
sizeof(struct user_cb_regs), NULL,
|
||||
&sc->cb);
|
||||
if (!err)
|
||||
err = metag_rp_state_copyout(regs, 0,
|
||||
sizeof(struct user_rp_state), NULL,
|
||||
&sc->rp);
|
||||
|
||||
/* OK, clear that cbuf flag in the old context, or our stored
|
||||
* catch buffer will be restored when we go to call the signal
|
||||
* handler. Also clear out the CBRP RA/RD pipe bit incase
|
||||
* that is pending as well!
|
||||
* Note that as we have already stored this context, these
|
||||
* flags will get restored on sigreturn to their original
|
||||
* state.
|
||||
*/
|
||||
regs->REG_FLAGS &= ~(TBICTX_XCBF_BIT | TBICTX_CBUF_BIT |
|
||||
TBICTX_CBRP_BIT);
|
||||
|
||||
/* Clear out the LSM_STEP bits in case we are in the middle of
|
||||
* and MSET/MGET.
|
||||
*/
|
||||
regs->ctx.Flags &= ~TXSTATUS_LSM_STEP_BITS;
|
||||
|
||||
err |= __put_user(mask, &sc->oldmask);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/*
|
||||
* Determine which stack to use..
|
||||
*/
|
||||
static void __user *get_sigframe(struct k_sigaction *ka, unsigned long sp,
|
||||
size_t frame_size)
|
||||
{
|
||||
/* Meta stacks grows upwards */
|
||||
if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags(sp) == 0))
|
||||
sp = current->sas_ss_sp;
|
||||
|
||||
sp = (sp + 7) & ~7; /* 8byte align stack */
|
||||
|
||||
return (void __user *)sp;
|
||||
}
|
||||
|
||||
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
|
||||
sigset_t *set, struct pt_regs *regs)
|
||||
{
|
||||
struct rt_sigframe __user *frame;
|
||||
int err = -EFAULT;
|
||||
unsigned long code;
|
||||
|
||||
frame = get_sigframe(ka, regs->REG_SP, sizeof(*frame));
|
||||
if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
|
||||
goto out;
|
||||
|
||||
err = copy_siginfo_to_user(&frame->info, info);
|
||||
|
||||
/* Create the ucontext. */
|
||||
err |= __put_user(0, &frame->uc.uc_flags);
|
||||
err |= __put_user(0, (unsigned long __user *)&frame->uc.uc_link);
|
||||
err |= __save_altstack(&frame->uc.uc_stack, regs->REG_SP);
|
||||
err |= setup_sigcontext(&frame->uc.uc_mcontext,
|
||||
regs, set->sig[0]);
|
||||
err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
|
||||
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
/* Set up to return from userspace. */
|
||||
|
||||
/* MOV D1Re0 (D1.0), #__NR_rt_sigreturn */
|
||||
code = 0x03000004 | (__NR_rt_sigreturn << 3);
|
||||
err |= __put_user(code, (unsigned long __user *)(&frame->retcode[0]));
|
||||
|
||||
/* SWITCH #__METAG_SW_SYS */
|
||||
code = __METAG_SW_ENCODING(SYS);
|
||||
err |= __put_user(code, (unsigned long __user *)(&frame->retcode[1]));
|
||||
|
||||
if (err)
|
||||
goto out;
|
||||
|
||||
/* Set up registers for signal handler */
|
||||
regs->REG_RTP = (unsigned long) frame->retcode;
|
||||
regs->REG_SP = (unsigned long) frame + sizeof(*frame);
|
||||
regs->REG_ARG1 = sig;
|
||||
regs->REG_ARG2 = (unsigned long) &frame->info;
|
||||
regs->REG_ARG3 = (unsigned long) &frame->uc;
|
||||
regs->REG_PC = (unsigned long) ka->sa.sa_handler;
|
||||
|
||||
pr_debug("SIG deliver (%s:%d): sp=%p pc=%08x pr=%08x\n",
|
||||
current->comm, current->pid, frame, regs->REG_PC,
|
||||
regs->REG_RTP);
|
||||
|
||||
/* Now pass size of 'new code' into sigtramp so we can do a more
|
||||
* effective cache flush - directed rather than 'full flush'.
|
||||
*/
|
||||
flush_cache_sigtramp(regs->REG_RTP, sizeof(frame->retcode));
|
||||
out:
|
||||
if (err) {
|
||||
force_sigsegv(sig, current);
|
||||
return -EFAULT;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void handle_signal(unsigned long sig, siginfo_t *info,
|
||||
struct k_sigaction *ka, struct pt_regs *regs)
|
||||
{
|
||||
sigset_t *oldset = sigmask_to_save();
|
||||
|
||||
/* Set up the stack frame */
|
||||
if (setup_rt_frame(sig, ka, info, oldset, regs))
|
||||
return;
|
||||
|
||||
signal_delivered(sig, info, ka, regs, test_thread_flag(TIF_SINGLESTEP));
|
||||
}
|
||||
|
||||
/*
|
||||
* Notes for Meta.
|
||||
* We have moved from the old 2.4.9 SH way of using syscall_nr (in the stored
|
||||
* context) to passing in the syscall flag on the stack.
|
||||
* This is because having syscall_nr in our context does not fit with TBX, and
|
||||
* corrupted the stack.
|
||||
*/
|
||||
static int do_signal(struct pt_regs *regs, int syscall)
|
||||
{
|
||||
unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
|
||||
struct k_sigaction ka;
|
||||
siginfo_t info;
|
||||
int signr;
|
||||
int restart = 0;
|
||||
|
||||
/*
|
||||
* By the end of rt_sigreturn the context describes the point that the
|
||||
* signal was taken (which may happen to be just before a syscall if
|
||||
* it's already been restarted). This should *never* be mistaken for a
|
||||
* system call in need of restarting.
|
||||
*/
|
||||
if (syscall == __NR_rt_sigreturn)
|
||||
syscall = -1;
|
||||
|
||||
/* Did we come from a system call? */
|
||||
if (syscall >= 0) {
|
||||
continue_addr = regs->REG_PC;
|
||||
restart_addr = continue_addr - 4;
|
||||
retval = regs->REG_RETVAL;
|
||||
|
||||
/*
|
||||
* Prepare for system call restart. We do this here so that a
|
||||
* debugger will see the already changed PC.
|
||||
*/
|
||||
switch (retval) {
|
||||
case -ERESTART_RESTARTBLOCK:
|
||||
restart = -2;
|
||||
case -ERESTARTNOHAND:
|
||||
case -ERESTARTSYS:
|
||||
case -ERESTARTNOINTR:
|
||||
++restart;
|
||||
regs->REG_PC = restart_addr;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Get the signal to deliver. When running under ptrace, at this point
|
||||
* the debugger may change all our registers ...
|
||||
*/
|
||||
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
|
||||
/*
|
||||
* Depending on the signal settings we may need to revert the decision
|
||||
* to restart the system call. But skip this if a debugger has chosen to
|
||||
* restart at a different PC.
|
||||
*/
|
||||
if (regs->REG_PC != restart_addr)
|
||||
restart = 0;
|
||||
if (signr > 0) {
|
||||
if (unlikely(restart)) {
|
||||
if (retval == -ERESTARTNOHAND
|
||||
|| retval == -ERESTART_RESTARTBLOCK
|
||||
|| (retval == -ERESTARTSYS
|
||||
&& !(ka.sa.sa_flags & SA_RESTART))) {
|
||||
regs->REG_RETVAL = -EINTR;
|
||||
regs->REG_PC = continue_addr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Whee! Actually deliver the signal. */
|
||||
handle_signal(signr, &info, &ka, regs);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Handlerless -ERESTART_RESTARTBLOCK re-enters via restart_syscall */
|
||||
if (unlikely(restart < 0))
|
||||
regs->REG_SYSCALL = __NR_restart_syscall;
|
||||
|
||||
/*
|
||||
* If there's no signal to deliver, we just put the saved sigmask back.
|
||||
*/
|
||||
restore_saved_sigmask();
|
||||
|
||||
return restart;
|
||||
}
|
||||
|
||||
int do_work_pending(struct pt_regs *regs, unsigned int thread_flags,
|
||||
int syscall)
|
||||
{
|
||||
do {
|
||||
if (likely(thread_flags & _TIF_NEED_RESCHED)) {
|
||||
schedule();
|
||||
} else {
|
||||
if (unlikely(!user_mode(regs)))
|
||||
return 0;
|
||||
local_irq_enable();
|
||||
if (thread_flags & _TIF_SIGPENDING) {
|
||||
int restart = do_signal(regs, syscall);
|
||||
if (unlikely(restart)) {
|
||||
/*
|
||||
* Restart without handlers.
|
||||
* Deal with it without leaving
|
||||
* the kernel space.
|
||||
*/
|
||||
return restart;
|
||||
}
|
||||
syscall = -1;
|
||||
} else {
|
||||
clear_thread_flag(TIF_NOTIFY_RESUME);
|
||||
tracehook_notify_resume(regs);
|
||||
}
|
||||
}
|
||||
local_irq_disable();
|
||||
thread_flags = current_thread_info()->flags;
|
||||
} while (thread_flags & _TIF_WORK_MASK);
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user