2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* linux/arch/arm/kernel/signal.c
|
|
|
|
|
*
|
2009-10-25 23:39:37 +08:00
|
|
|
* Copyright (C) 1995-2009 Russell King
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
|
*/
|
|
|
|
|
#include <linux/errno.h>
|
2013-07-24 07:29:18 +08:00
|
|
|
#include <linux/random.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/signal.h>
|
|
|
|
|
#include <linux/personality.h>
|
2008-09-06 18:35:55 +08:00
|
|
|
#include <linux/uaccess.h>
|
2009-09-09 15:30:21 +08:00
|
|
|
#include <linux/tracehook.h>
|
2014-03-08 00:23:04 +08:00
|
|
|
#include <linux/uprobes.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-11-09 22:20:47 +08:00
|
|
|
#include <asm/elf.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/cacheflush.h>
|
2013-07-24 07:29:18 +08:00
|
|
|
#include <asm/traps.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/ucontext.h>
|
|
|
|
|
#include <asm/unistd.h>
|
2010-04-11 22:58:27 +08:00
|
|
|
#include <asm/vfp.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-08-28 13:41:57 +08:00
|
|
|
extern const unsigned long sigreturn_codes[7];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-07-24 07:29:18 +08:00
|
|
|
static unsigned long signal_return_offset;
|
|
|
|
|
|
2006-06-28 05:56:18 +08:00
|
|
|
#ifdef CONFIG_CRUNCH
|
2009-08-05 06:20:45 +08:00
|
|
|
static int preserve_crunch_context(struct crunch_sigframe __user *frame)
|
2006-06-28 05:56:18 +08:00
|
|
|
{
|
|
|
|
|
char kbuf[sizeof(*frame) + 8];
|
|
|
|
|
struct crunch_sigframe *kframe;
|
|
|
|
|
|
|
|
|
|
/* the crunch context must be 64 bit aligned */
|
|
|
|
|
kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
|
|
|
|
|
kframe->magic = CRUNCH_MAGIC;
|
|
|
|
|
kframe->size = CRUNCH_STORAGE_SIZE;
|
|
|
|
|
crunch_task_copy(current_thread_info(), &kframe->storage);
|
|
|
|
|
return __copy_to_user(frame, kframe, sizeof(*frame));
|
|
|
|
|
}
|
|
|
|
|
|
2009-08-05 06:20:45 +08:00
|
|
|
static int restore_crunch_context(struct crunch_sigframe __user *frame)
|
2006-06-28 05:56:18 +08:00
|
|
|
{
|
|
|
|
|
char kbuf[sizeof(*frame) + 8];
|
|
|
|
|
struct crunch_sigframe *kframe;
|
|
|
|
|
|
|
|
|
|
/* the crunch context must be 64 bit aligned */
|
|
|
|
|
kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
|
|
|
|
|
if (__copy_from_user(kframe, frame, sizeof(*frame)))
|
|
|
|
|
return -1;
|
|
|
|
|
if (kframe->magic != CRUNCH_MAGIC ||
|
|
|
|
|
kframe->size != CRUNCH_STORAGE_SIZE)
|
|
|
|
|
return -1;
|
|
|
|
|
crunch_task_restore(current_thread_info(), &kframe->storage);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_IWMMXT
|
|
|
|
|
|
|
|
|
|
static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
|
|
|
|
|
{
|
[PATCH] mm: arm ready for split ptlock
Prepare arm for the split page_table_lock: three issues.
Signal handling's preserve and restore of iwmmxt context currently involves
reading and writing that context to and from user space, while holding
page_table_lock to secure the user page(s) against kswapd. If we split the
lock, then the structure might span two pages, secured by to read into and
write from a kernel stack buffer, copying that out and in without locking (the
structure is 160 bytes in size, and here we're near the top of the kernel
stack). Or would the overhead be noticeable?
arm_syscall's cmpxchg emulation use pte_offset_map_lock, instead of
pte_offset_map and mm-wide page_table_lock; and strictly, it should now also
take mmap_sem before descending to pmd, to guard against another thread
munmapping, and the page table pulled out beneath this thread.
Updated two comments in fault-armv.c. adjust_pte is interesting, since its
modification of a pte in one part of the mm depends on the lock held when
calling update_mmu_cache for a pte in some other part of that mm. This can't
be done with a split page_table_lock (and we've already taken the lowest lock
in the hierarchy here): so we'll have to disable split on arm, unless
CONFIG_CPU_CACHE_VIPT to ensures adjust_pte never used.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 09:16:36 +08:00
|
|
|
char kbuf[sizeof(*frame) + 8];
|
|
|
|
|
struct iwmmxt_sigframe *kframe;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* the iWMMXt context must be 64 bit aligned */
|
[PATCH] mm: arm ready for split ptlock
Prepare arm for the split page_table_lock: three issues.
Signal handling's preserve and restore of iwmmxt context currently involves
reading and writing that context to and from user space, while holding
page_table_lock to secure the user page(s) against kswapd. If we split the
lock, then the structure might span two pages, secured by to read into and
write from a kernel stack buffer, copying that out and in without locking (the
structure is 160 bytes in size, and here we're near the top of the kernel
stack). Or would the overhead be noticeable?
arm_syscall's cmpxchg emulation use pte_offset_map_lock, instead of
pte_offset_map and mm-wide page_table_lock; and strictly, it should now also
take mmap_sem before descending to pmd, to guard against another thread
munmapping, and the page table pulled out beneath this thread.
Updated two comments in fault-armv.c. adjust_pte is interesting, since its
modification of a pte in one part of the mm depends on the lock held when
calling update_mmu_cache for a pte in some other part of that mm. This can't
be done with a split page_table_lock (and we've already taken the lowest lock
in the hierarchy here): so we'll have to disable split on arm, unless
CONFIG_CPU_CACHE_VIPT to ensures adjust_pte never used.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 09:16:36 +08:00
|
|
|
kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
|
2006-06-25 06:46:21 +08:00
|
|
|
kframe->magic = IWMMXT_MAGIC;
|
|
|
|
|
kframe->size = IWMMXT_STORAGE_SIZE;
|
[PATCH] mm: arm ready for split ptlock
Prepare arm for the split page_table_lock: three issues.
Signal handling's preserve and restore of iwmmxt context currently involves
reading and writing that context to and from user space, while holding
page_table_lock to secure the user page(s) against kswapd. If we split the
lock, then the structure might span two pages, secured by to read into and
write from a kernel stack buffer, copying that out and in without locking (the
structure is 160 bytes in size, and here we're near the top of the kernel
stack). Or would the overhead be noticeable?
arm_syscall's cmpxchg emulation use pte_offset_map_lock, instead of
pte_offset_map and mm-wide page_table_lock; and strictly, it should now also
take mmap_sem before descending to pmd, to guard against another thread
munmapping, and the page table pulled out beneath this thread.
Updated two comments in fault-armv.c. adjust_pte is interesting, since its
modification of a pte in one part of the mm depends on the lock held when
calling update_mmu_cache for a pte in some other part of that mm. This can't
be done with a split page_table_lock (and we've already taken the lowest lock
in the hierarchy here): so we'll have to disable split on arm, unless
CONFIG_CPU_CACHE_VIPT to ensures adjust_pte never used.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 09:16:36 +08:00
|
|
|
iwmmxt_task_copy(current_thread_info(), &kframe->storage);
|
|
|
|
|
return __copy_to_user(frame, kframe, sizeof(*frame));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int restore_iwmmxt_context(struct iwmmxt_sigframe *frame)
|
|
|
|
|
{
|
[PATCH] mm: arm ready for split ptlock
Prepare arm for the split page_table_lock: three issues.
Signal handling's preserve and restore of iwmmxt context currently involves
reading and writing that context to and from user space, while holding
page_table_lock to secure the user page(s) against kswapd. If we split the
lock, then the structure might span two pages, secured by to read into and
write from a kernel stack buffer, copying that out and in without locking (the
structure is 160 bytes in size, and here we're near the top of the kernel
stack). Or would the overhead be noticeable?
arm_syscall's cmpxchg emulation use pte_offset_map_lock, instead of
pte_offset_map and mm-wide page_table_lock; and strictly, it should now also
take mmap_sem before descending to pmd, to guard against another thread
munmapping, and the page table pulled out beneath this thread.
Updated two comments in fault-armv.c. adjust_pte is interesting, since its
modification of a pte in one part of the mm depends on the lock held when
calling update_mmu_cache for a pte in some other part of that mm. This can't
be done with a split page_table_lock (and we've already taken the lowest lock
in the hierarchy here): so we'll have to disable split on arm, unless
CONFIG_CPU_CACHE_VIPT to ensures adjust_pte never used.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 09:16:36 +08:00
|
|
|
char kbuf[sizeof(*frame) + 8];
|
|
|
|
|
struct iwmmxt_sigframe *kframe;
|
|
|
|
|
|
|
|
|
|
/* the iWMMXt context must be 64 bit aligned */
|
|
|
|
|
kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
|
|
|
|
|
if (__copy_from_user(kframe, frame, sizeof(*frame)))
|
|
|
|
|
return -1;
|
2006-06-25 06:46:21 +08:00
|
|
|
if (kframe->magic != IWMMXT_MAGIC ||
|
|
|
|
|
kframe->size != IWMMXT_STORAGE_SIZE)
|
[PATCH] mm: arm ready for split ptlock
Prepare arm for the split page_table_lock: three issues.
Signal handling's preserve and restore of iwmmxt context currently involves
reading and writing that context to and from user space, while holding
page_table_lock to secure the user page(s) against kswapd. If we split the
lock, then the structure might span two pages, secured by to read into and
write from a kernel stack buffer, copying that out and in without locking (the
structure is 160 bytes in size, and here we're near the top of the kernel
stack). Or would the overhead be noticeable?
arm_syscall's cmpxchg emulation use pte_offset_map_lock, instead of
pte_offset_map and mm-wide page_table_lock; and strictly, it should now also
take mmap_sem before descending to pmd, to guard against another thread
munmapping, and the page table pulled out beneath this thread.
Updated two comments in fault-armv.c. adjust_pte is interesting, since its
modification of a pte in one part of the mm depends on the lock held when
calling update_mmu_cache for a pte in some other part of that mm. This can't
be done with a split page_table_lock (and we've already taken the lowest lock
in the hierarchy here): so we'll have to disable split on arm, unless
CONFIG_CPU_CACHE_VIPT to ensures adjust_pte never used.
Signed-off-by: Hugh Dickins <hugh@veritas.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-10-30 09:16:36 +08:00
|
|
|
return -1;
|
|
|
|
|
iwmmxt_task_restore(current_thread_info(), &kframe->storage);
|
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-04-11 22:58:27 +08:00
|
|
|
#ifdef CONFIG_VFP
|
|
|
|
|
|
|
|
|
|
static int preserve_vfp_context(struct vfp_sigframe __user *frame)
|
|
|
|
|
{
|
|
|
|
|
const unsigned long magic = VFP_MAGIC;
|
|
|
|
|
const unsigned long size = VFP_STORAGE_SIZE;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
__put_user_error(magic, &frame->magic, err);
|
|
|
|
|
__put_user_error(size, &frame->size, err);
|
|
|
|
|
|
2012-04-23 22:38:28 +08:00
|
|
|
if (err)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
|
|
return vfp_preserve_user_clear_hwstate(&frame->ufp, &frame->ufp_exc);
|
2010-04-11 22:58:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int restore_vfp_context(struct vfp_sigframe __user *frame)
|
|
|
|
|
{
|
|
|
|
|
unsigned long magic;
|
|
|
|
|
unsigned long size;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
__get_user_error(magic, &frame->magic, err);
|
|
|
|
|
__get_user_error(size, &frame->size, err);
|
|
|
|
|
|
|
|
|
|
if (err)
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2012-04-23 22:38:28 +08:00
|
|
|
return vfp_restore_user_hwstate(&frame->ufp, &frame->ufp_exc);
|
2010-04-11 22:58:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* Do a signal return; undo the signal stack. These are aligned to 64-bit.
|
|
|
|
|
*/
|
|
|
|
|
struct sigframe {
|
2006-06-16 03:13:25 +08:00
|
|
|
struct ucontext uc;
|
2006-01-19 06:38:47 +08:00
|
|
|
unsigned long retcode[2];
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct rt_sigframe {
|
|
|
|
|
struct siginfo info;
|
2006-06-16 03:18:25 +08:00
|
|
|
struct sigframe sig;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2006-06-16 03:23:02 +08:00
|
|
|
static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-06-25 06:46:21 +08:00
|
|
|
struct aux_sigframe __user *aux;
|
2006-06-16 03:23:02 +08:00
|
|
|
sigset_t set;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
|
2012-04-28 01:58:59 +08:00
|
|
|
if (err == 0)
|
2012-03-06 07:05:34 +08:00
|
|
|
set_current_blocked(&set);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-06-16 03:23:02 +08:00
|
|
|
__get_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
|
|
|
|
|
__get_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
|
|
|
|
|
__get_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
|
|
|
|
|
__get_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
|
|
|
|
|
__get_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
|
|
|
|
|
__get_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
|
|
|
|
|
__get_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
|
|
|
|
|
__get_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
|
|
|
|
|
__get_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
|
|
|
|
|
__get_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
|
|
|
|
|
__get_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
|
|
|
|
|
__get_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
|
|
|
|
|
__get_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
|
|
|
|
|
__get_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
|
|
|
|
|
__get_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
|
|
|
|
|
__get_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
|
|
|
|
|
__get_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
err |= !valid_user_regs(regs);
|
|
|
|
|
|
2006-06-25 06:46:21 +08:00
|
|
|
aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
|
2006-06-28 05:56:18 +08:00
|
|
|
#ifdef CONFIG_CRUNCH
|
|
|
|
|
if (err == 0)
|
|
|
|
|
err |= restore_crunch_context(&aux->crunch);
|
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_IWMMXT
|
|
|
|
|
if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
|
|
|
|
|
err |= restore_iwmmxt_context(&aux->iwmmxt);
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_VFP
|
2010-04-11 22:58:27 +08:00
|
|
|
if (err == 0)
|
|
|
|
|
err |= restore_vfp_context(&aux->vfp);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
asmlinkage int sys_sigreturn(struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
struct sigframe __user *frame;
|
|
|
|
|
|
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
|
|
|
|
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Since we stacked the signal on a 64-bit boundary,
|
|
|
|
|
* then 'sp' should be word aligned here. If it's
|
|
|
|
|
* not, then the user is trying to mess with us.
|
|
|
|
|
*/
|
|
|
|
|
if (regs->ARM_sp & 7)
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
frame = (struct sigframe __user *)regs->ARM_sp;
|
|
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
2006-06-16 03:23:02 +08:00
|
|
|
if (restore_sigframe(regs, frame))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
return regs->ARM_r0;
|
|
|
|
|
|
|
|
|
|
badframe:
|
|
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
struct rt_sigframe __user *frame;
|
|
|
|
|
|
|
|
|
|
/* Always make any pending restarted system calls return -EINTR */
|
|
|
|
|
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Since we stacked the signal on a 64-bit boundary,
|
|
|
|
|
* then 'sp' should be word aligned here. If it's
|
|
|
|
|
* not, then the user is trying to mess with us.
|
|
|
|
|
*/
|
|
|
|
|
if (regs->ARM_sp & 7)
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
frame = (struct rt_sigframe __user *)regs->ARM_sp;
|
|
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
|
|
|
|
|
goto badframe;
|
|
|
|
|
|
2006-06-16 03:23:02 +08:00
|
|
|
if (restore_sigframe(regs, &frame->sig))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto badframe;
|
|
|
|
|
|
2012-12-23 14:52:54 +08:00
|
|
|
if (restore_altstack(&frame->sig.uc.uc_stack))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto badframe;
|
|
|
|
|
|
|
|
|
|
return regs->ARM_r0;
|
|
|
|
|
|
|
|
|
|
badframe:
|
|
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2006-06-16 03:28:03 +08:00
|
|
|
setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-06-25 06:46:21 +08:00
|
|
|
struct aux_sigframe __user *aux;
|
2005-04-17 06:20:36 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
2006-06-16 03:28:03 +08:00
|
|
|
__put_user_error(regs->ARM_r0, &sf->uc.uc_mcontext.arm_r0, err);
|
|
|
|
|
__put_user_error(regs->ARM_r1, &sf->uc.uc_mcontext.arm_r1, err);
|
|
|
|
|
__put_user_error(regs->ARM_r2, &sf->uc.uc_mcontext.arm_r2, err);
|
|
|
|
|
__put_user_error(regs->ARM_r3, &sf->uc.uc_mcontext.arm_r3, err);
|
|
|
|
|
__put_user_error(regs->ARM_r4, &sf->uc.uc_mcontext.arm_r4, err);
|
|
|
|
|
__put_user_error(regs->ARM_r5, &sf->uc.uc_mcontext.arm_r5, err);
|
|
|
|
|
__put_user_error(regs->ARM_r6, &sf->uc.uc_mcontext.arm_r6, err);
|
|
|
|
|
__put_user_error(regs->ARM_r7, &sf->uc.uc_mcontext.arm_r7, err);
|
|
|
|
|
__put_user_error(regs->ARM_r8, &sf->uc.uc_mcontext.arm_r8, err);
|
|
|
|
|
__put_user_error(regs->ARM_r9, &sf->uc.uc_mcontext.arm_r9, err);
|
|
|
|
|
__put_user_error(regs->ARM_r10, &sf->uc.uc_mcontext.arm_r10, err);
|
|
|
|
|
__put_user_error(regs->ARM_fp, &sf->uc.uc_mcontext.arm_fp, err);
|
|
|
|
|
__put_user_error(regs->ARM_ip, &sf->uc.uc_mcontext.arm_ip, err);
|
|
|
|
|
__put_user_error(regs->ARM_sp, &sf->uc.uc_mcontext.arm_sp, err);
|
|
|
|
|
__put_user_error(regs->ARM_lr, &sf->uc.uc_mcontext.arm_lr, err);
|
|
|
|
|
__put_user_error(regs->ARM_pc, &sf->uc.uc_mcontext.arm_pc, err);
|
|
|
|
|
__put_user_error(regs->ARM_cpsr, &sf->uc.uc_mcontext.arm_cpsr, err);
|
|
|
|
|
|
|
|
|
|
__put_user_error(current->thread.trap_no, &sf->uc.uc_mcontext.trap_no, err);
|
|
|
|
|
__put_user_error(current->thread.error_code, &sf->uc.uc_mcontext.error_code, err);
|
|
|
|
|
__put_user_error(current->thread.address, &sf->uc.uc_mcontext.fault_address, err);
|
|
|
|
|
__put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
|
|
|
|
|
|
|
|
|
|
err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-06-25 06:46:21 +08:00
|
|
|
aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
|
2006-06-28 05:56:18 +08:00
|
|
|
#ifdef CONFIG_CRUNCH
|
|
|
|
|
if (err == 0)
|
|
|
|
|
err |= preserve_crunch_context(&aux->crunch);
|
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_IWMMXT
|
|
|
|
|
if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
|
|
|
|
|
err |= preserve_iwmmxt_context(&aux->iwmmxt);
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_VFP
|
2010-04-11 22:58:27 +08:00
|
|
|
if (err == 0)
|
|
|
|
|
err |= preserve_vfp_context(&aux->vfp);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
2006-06-25 06:46:21 +08:00
|
|
|
__put_user_error(0, &aux->end_magic, err);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void __user *
|
2012-11-08 06:53:13 +08:00
|
|
|
get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-11-08 06:53:13 +08:00
|
|
|
unsigned long sp = sigsp(regs->ARM_sp, ksig);
|
2005-04-17 06:20:36 +08:00
|
|
|
void __user *frame;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* ATPCS B01 mandates 8-byte alignment
|
|
|
|
|
*/
|
|
|
|
|
frame = (void __user *)((sp - framesize) & ~7);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that we can actually write to the signal frame.
|
|
|
|
|
*/
|
|
|
|
|
if (!access_ok(VERIFY_WRITE, frame, framesize))
|
|
|
|
|
frame = NULL;
|
|
|
|
|
|
|
|
|
|
return frame;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-08 06:53:13 +08:00
|
|
|
/*
|
|
|
|
|
* translate the signal
|
|
|
|
|
*/
|
|
|
|
|
static inline int map_sig(int sig)
|
|
|
|
|
{
|
|
|
|
|
struct thread_info *thread = current_thread_info();
|
|
|
|
|
if (sig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
|
|
|
|
|
sig = thread->exec_domain->signal_invmap[sig];
|
|
|
|
|
return sig;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static int
|
2012-11-08 06:53:13 +08:00
|
|
|
setup_return(struct pt_regs *regs, struct ksignal *ksig,
|
|
|
|
|
unsigned long __user *rc, void __user *frame)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-11-08 06:53:13 +08:00
|
|
|
unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long retcode;
|
|
|
|
|
int thumb = 0;
|
2011-02-20 20:22:52 +08:00
|
|
|
unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
|
|
|
|
|
|
|
|
|
|
cpsr |= PSR_ENDSTATE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Maybe we need to deliver a 32-bit signal to a 26-bit task.
|
|
|
|
|
*/
|
2012-11-08 06:53:13 +08:00
|
|
|
if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
|
2005-04-17 06:20:36 +08:00
|
|
|
cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_ARM_THUMB
|
|
|
|
|
if (elf_hwcap & HWCAP_THUMB) {
|
|
|
|
|
/*
|
|
|
|
|
* The LSB of the handler determines if we're going to
|
|
|
|
|
* be using THUMB or ARM mode for this signal handler.
|
|
|
|
|
*/
|
|
|
|
|
thumb = handler & 1;
|
|
|
|
|
|
2009-05-30 21:00:15 +08:00
|
|
|
#if __LINUX_ARM_ARCH__ >= 7
|
2013-11-07 01:38:05 +08:00
|
|
|
/*
|
|
|
|
|
* Clear the If-Then Thumb-2 execution state
|
|
|
|
|
* ARM spec requires this to be all 000s in ARM mode
|
|
|
|
|
* Snapdragon S4/Krait misbehaves on a Thumb=>ARM
|
|
|
|
|
* signal transition without this.
|
|
|
|
|
*/
|
|
|
|
|
cpsr &= ~PSR_IT_MASK;
|
2009-05-30 21:00:15 +08:00
|
|
|
#endif
|
2013-11-07 01:38:05 +08:00
|
|
|
|
|
|
|
|
if (thumb) {
|
|
|
|
|
cpsr |= PSR_T_BIT;
|
2009-05-30 21:00:15 +08:00
|
|
|
} else
|
2005-04-17 06:20:36 +08:00
|
|
|
cpsr &= ~PSR_T_BIT;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-11-08 06:53:13 +08:00
|
|
|
if (ksig->ka.sa.sa_flags & SA_RESTORER) {
|
|
|
|
|
retcode = (unsigned long)ksig->ka.sa.sa_restorer;
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
2006-01-19 06:38:47 +08:00
|
|
|
unsigned int idx = thumb << 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-11-08 06:53:13 +08:00
|
|
|
if (ksig->ka.sa.sa_flags & SA_SIGINFO)
|
2006-01-19 06:38:47 +08:00
|
|
|
idx += 3;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-04-19 01:37:24 +08:00
|
|
|
/*
|
|
|
|
|
* Put the sigreturn code on the stack no matter which return
|
|
|
|
|
* mechanism we use in order to remain ABI compliant
|
|
|
|
|
*/
|
2006-01-19 06:38:47 +08:00
|
|
|
if (__put_user(sigreturn_codes[idx], rc) ||
|
|
|
|
|
__put_user(sigreturn_codes[idx+1], rc+1))
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
|
|
2013-08-03 17:39:51 +08:00
|
|
|
#ifdef CONFIG_MMU
|
|
|
|
|
if (cpsr & MODE32_BIT) {
|
2013-07-24 07:29:18 +08:00
|
|
|
struct mm_struct *mm = current->mm;
|
|
|
|
|
|
2005-06-23 03:26:05 +08:00
|
|
|
/*
|
2013-07-24 07:29:18 +08:00
|
|
|
* 32-bit code can use the signal return page
|
|
|
|
|
* except when the MPU has protected the vectors
|
|
|
|
|
* page from PL0
|
2005-06-23 03:26:05 +08:00
|
|
|
*/
|
2013-07-24 07:29:18 +08:00
|
|
|
retcode = mm->context.sigpage + signal_return_offset +
|
|
|
|
|
(idx << 2) + thumb;
|
2013-08-03 17:39:51 +08:00
|
|
|
} else
|
|
|
|
|
#endif
|
|
|
|
|
{
|
2005-06-23 03:26:05 +08:00
|
|
|
/*
|
|
|
|
|
* Ensure that the instruction cache sees
|
|
|
|
|
* the return code written onto the stack.
|
|
|
|
|
*/
|
|
|
|
|
flush_icache_range((unsigned long)rc,
|
2006-01-19 06:38:47 +08:00
|
|
|
(unsigned long)(rc + 2));
|
2005-06-23 03:26:05 +08:00
|
|
|
|
|
|
|
|
retcode = ((unsigned long)rc) + thumb;
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2012-11-08 06:53:13 +08:00
|
|
|
regs->ARM_r0 = map_sig(ksig->sig);
|
2005-04-17 06:20:36 +08:00
|
|
|
regs->ARM_sp = (unsigned long)frame;
|
|
|
|
|
regs->ARM_lr = retcode;
|
|
|
|
|
regs->ARM_pc = handler;
|
|
|
|
|
regs->ARM_cpsr = cpsr;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2012-11-08 06:53:13 +08:00
|
|
|
setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-11-08 06:53:13 +08:00
|
|
|
struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
|
2005-04-17 06:20:36 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
if (!frame)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2006-06-25 05:41:09 +08:00
|
|
|
/*
|
|
|
|
|
* Set uc.uc_flags to a value which sc.trap_no would never have.
|
|
|
|
|
*/
|
|
|
|
|
__put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-06-16 03:28:03 +08:00
|
|
|
err |= setup_sigframe(frame, regs, set);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (err == 0)
|
2012-11-08 06:53:13 +08:00
|
|
|
err = setup_return(regs, ksig, frame->retcode, frame);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2012-11-08 06:53:13 +08:00
|
|
|
setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-11-08 06:53:13 +08:00
|
|
|
struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
|
2005-04-17 06:20:36 +08:00
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
if (!frame)
|
|
|
|
|
return 1;
|
|
|
|
|
|
2012-11-08 06:53:13 +08:00
|
|
|
err |= copy_siginfo_to_user(&frame->info, &ksig->info);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-06-16 03:18:25 +08:00
|
|
|
__put_user_error(0, &frame->sig.uc.uc_flags, err);
|
|
|
|
|
__put_user_error(NULL, &frame->sig.uc.uc_link, err);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-12-23 14:52:54 +08:00
|
|
|
err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
|
2006-06-16 03:28:03 +08:00
|
|
|
err |= setup_sigframe(&frame->sig, regs, set);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (err == 0)
|
2012-11-08 06:53:13 +08:00
|
|
|
err = setup_return(regs, ksig, frame->sig.retcode, frame);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (err == 0) {
|
|
|
|
|
/*
|
|
|
|
|
* For realtime signals we must also set the second and third
|
|
|
|
|
* arguments for the signal handler.
|
|
|
|
|
* -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
|
|
|
|
|
*/
|
|
|
|
|
regs->ARM_r1 = (unsigned long)&frame->info;
|
2006-06-16 03:18:25 +08:00
|
|
|
regs->ARM_r2 = (unsigned long)&frame->sig.uc;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* OK, we're invoking a handler
|
|
|
|
|
*/
|
2012-11-08 06:53:13 +08:00
|
|
|
static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-05-02 21:59:21 +08:00
|
|
|
sigset_t *oldset = sigmask_to_save();
|
2005-04-17 06:20:36 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Set up the stack frame
|
|
|
|
|
*/
|
2012-11-08 06:53:13 +08:00
|
|
|
if (ksig->ka.sa.sa_flags & SA_SIGINFO)
|
|
|
|
|
ret = setup_rt_frame(ksig, oldset, regs);
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2012-11-08 06:53:13 +08:00
|
|
|
ret = setup_frame(ksig, oldset, regs);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that the resulting registers are actually sane.
|
|
|
|
|
*/
|
|
|
|
|
ret |= !valid_user_regs(regs);
|
|
|
|
|
|
2012-11-08 06:53:13 +08:00
|
|
|
signal_setup_done(ret, ksig, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*
|
|
|
|
|
* Note that we go through the signals twice: once to check the signals that
|
|
|
|
|
* the kernel can handle, and then we build all the user-level signal handling
|
|
|
|
|
* stack-frames in one go after that.
|
|
|
|
|
*/
|
2012-07-20 00:48:21 +08:00
|
|
|
static int do_signal(struct pt_regs *regs, int syscall)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
ARM: 6892/1: handle ptrace requests to change PC during interrupted system calls
GDB's interrupt.exp test cases currenly fail on ARM. The problem is how do_signal
handled restarting interrupted system calls:
The entry.S assembler code determines that we come from a system call; and that
information is passed as "syscall" parameter to do_signal. That routine then
calls get_signal_to_deliver [*] and if a signal is to be delivered, calls into
handle_signal. If a system call is to be restarted either after the signal
handler returns, or if no handler is to be called in the first place, the PC
is updated after the get_signal_to_deliver call, either in handle_signal (if
we have a handler) or at the end of do_signal (otherwise).
Now the problem is that during [*], the call to get_signal_to_deliver, a ptrace
intercept may happen. During this intercept, the debugger may change registers,
including the PC. This is done by GDB if it wants to execute an "inferior call",
i.e. the execution of some code in the debugged program triggered by GDB.
To this purpose, GDB will save all registers, allocate a stack frame, set up
PC and arguments as appropriate for the call, and point the link register to
a dummy breakpoint instruction. Once the process is restarted, it will execute
the call and then trap back to the debugger, at which point GDB will restore
all registers and continue original execution.
This generally works fine. However, now consider what happens when GDB attempts
to do exactly that while the process was interrupted during execution of a to-be-
restarted system call: do_signal is called with the syscall flag set; it calls
get_signal_to_deliver, at which point the debugger takes over and changes the PC
to point to a completely different place. Now get_signal_to_deliver returns
without a signal to deliver; but now do_signal decides it should be restarting
a system call, and decrements the PC by 2 or 4 -- so it now points to 2 or 4
bytes before the function GDB wants to call -- which leads to a subsequent crash.
To fix this problem, two things need to be supported:
- do_signal must be able to recognize that get_signal_to_deliver changed the PC
to a different location, and skip the restart-syscall sequence
- once the debugger has restored all registers at the end of the inferior call
sequence, do_signal must recognize that *now* it needs to restart the pending
system call, even though it was now entered from a breakpoint instead of an
actual svc instruction
This set of issues is solved on other platforms, usually by one of two
mechanisms:
- The status information "do_signal is handling a system call that may need
restarting" is itself carried in some register that can be accessed via
ptrace. This is e.g. on Intel the "orig_eax" register; on Sparc the kernel
defines a magic extra bit in the flags register for this purpose.
This allows GDB to manage that state: reset it when doing an inferior call,
and restore it after the call is finished.
- On s390, do_signal transparently handles this problem without requiring
GDB interaction, by performing system call restarting in the following
way: first, adjust the PC as necessary for restarting the call. Then,
call get_signal_to_deliver; and finally just continue execution at the
PC. This way, if GDB does not change the PC, everything is as before.
If GDB *does* change the PC, execution will simply continue there --
and once GDB restores the PC it saved at that point, it will automatically
point to the *restarted* system call. (There is the minor twist how to
handle system calls that do *not* need restarting -- do_signal will undo
the PC change in this case, after get_signal_to_deliver has returned, and
only if ptrace did not change the PC during that call.)
Because there does not appear to be any obvious register to carry the
syscall-restart information on ARM, we'd either have to introduce a new
artificial ptrace register just for that purpose, or else handle the issue
transparently like on s390. The patch below implements the second option;
using this patch makes the interrupt.exp test cases pass on ARM, with no
regression in the GDB test suite otherwise.
Cc: patches@linaro.org
Signed-off-by: Ulrich Weigand <ulrich.weigand@linaro.org>
Signed-off-by: Arnd Bergmann <arnd.bergmann@linaro.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2011-05-04 01:32:55 +08:00
|
|
|
unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
|
2012-11-08 06:53:13 +08:00
|
|
|
struct ksignal ksig;
|
2012-07-20 00:48:21 +08:00
|
|
|
int restart = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
ARM: 6892/1: handle ptrace requests to change PC during interrupted system calls
GDB's interrupt.exp test cases currenly fail on ARM. The problem is how do_signal
handled restarting interrupted system calls:
The entry.S assembler code determines that we come from a system call; and that
information is passed as "syscall" parameter to do_signal. That routine then
calls get_signal_to_deliver [*] and if a signal is to be delivered, calls into
handle_signal. If a system call is to be restarted either after the signal
handler returns, or if no handler is to be called in the first place, the PC
is updated after the get_signal_to_deliver call, either in handle_signal (if
we have a handler) or at the end of do_signal (otherwise).
Now the problem is that during [*], the call to get_signal_to_deliver, a ptrace
intercept may happen. During this intercept, the debugger may change registers,
including the PC. This is done by GDB if it wants to execute an "inferior call",
i.e. the execution of some code in the debugged program triggered by GDB.
To this purpose, GDB will save all registers, allocate a stack frame, set up
PC and arguments as appropriate for the call, and point the link register to
a dummy breakpoint instruction. Once the process is restarted, it will execute
the call and then trap back to the debugger, at which point GDB will restore
all registers and continue original execution.
This generally works fine. However, now consider what happens when GDB attempts
to do exactly that while the process was interrupted during execution of a to-be-
restarted system call: do_signal is called with the syscall flag set; it calls
get_signal_to_deliver, at which point the debugger takes over and changes the PC
to point to a completely different place. Now get_signal_to_deliver returns
without a signal to deliver; but now do_signal decides it should be restarting
a system call, and decrements the PC by 2 or 4 -- so it now points to 2 or 4
bytes before the function GDB wants to call -- which leads to a subsequent crash.
To fix this problem, two things need to be supported:
- do_signal must be able to recognize that get_signal_to_deliver changed the PC
to a different location, and skip the restart-syscall sequence
- once the debugger has restored all registers at the end of the inferior call
sequence, do_signal must recognize that *now* it needs to restart the pending
system call, even though it was now entered from a breakpoint instead of an
actual svc instruction
This set of issues is solved on other platforms, usually by one of two
mechanisms:
- The status information "do_signal is handling a system call that may need
restarting" is itself carried in some register that can be accessed via
ptrace. This is e.g. on Intel the "orig_eax" register; on Sparc the kernel
defines a magic extra bit in the flags register for this purpose.
This allows GDB to manage that state: reset it when doing an inferior call,
and restore it after the call is finished.
- On s390, do_signal transparently handles this problem without requiring
GDB interaction, by performing system call restarting in the following
way: first, adjust the PC as necessary for restarting the call. Then,
call get_signal_to_deliver; and finally just continue execution at the
PC. This way, if GDB does not change the PC, everything is as before.
If GDB *does* change the PC, execution will simply continue there --
and once GDB restores the PC it saved at that point, it will automatically
point to the *restarted* system call. (There is the minor twist how to
handle system calls that do *not* need restarting -- do_signal will undo
the PC change in this case, after get_signal_to_deliver has returned, and
only if ptrace did not change the PC during that call.)
Because there does not appear to be any obvious register to carry the
syscall-restart information on ARM, we'd either have to introduce a new
artificial ptrace register just for that purpose, or else handle the issue
transparently like on s390. The patch below implements the second option;
using this patch makes the interrupt.exp test cases pass on ARM, with no
regression in the GDB test suite otherwise.
Cc: patches@linaro.org
Signed-off-by: Ulrich Weigand <ulrich.weigand@linaro.org>
Signed-off-by: Arnd Bergmann <arnd.bergmann@linaro.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2011-05-04 01:32:55 +08:00
|
|
|
/*
|
|
|
|
|
* If we were from a system call, check for system call restarting...
|
|
|
|
|
*/
|
|
|
|
|
if (syscall) {
|
|
|
|
|
continue_addr = regs->ARM_pc;
|
|
|
|
|
restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
|
|
|
|
|
retval = regs->ARM_r0;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Prepare for system call restart. We do this here so that a
|
|
|
|
|
* debugger will see the already changed PSW.
|
|
|
|
|
*/
|
|
|
|
|
switch (retval) {
|
2012-07-20 00:48:21 +08:00
|
|
|
case -ERESTART_RESTARTBLOCK:
|
2012-07-20 00:48:50 +08:00
|
|
|
restart -= 2;
|
ARM: 6892/1: handle ptrace requests to change PC during interrupted system calls
GDB's interrupt.exp test cases currenly fail on ARM. The problem is how do_signal
handled restarting interrupted system calls:
The entry.S assembler code determines that we come from a system call; and that
information is passed as "syscall" parameter to do_signal. That routine then
calls get_signal_to_deliver [*] and if a signal is to be delivered, calls into
handle_signal. If a system call is to be restarted either after the signal
handler returns, or if no handler is to be called in the first place, the PC
is updated after the get_signal_to_deliver call, either in handle_signal (if
we have a handler) or at the end of do_signal (otherwise).
Now the problem is that during [*], the call to get_signal_to_deliver, a ptrace
intercept may happen. During this intercept, the debugger may change registers,
including the PC. This is done by GDB if it wants to execute an "inferior call",
i.e. the execution of some code in the debugged program triggered by GDB.
To this purpose, GDB will save all registers, allocate a stack frame, set up
PC and arguments as appropriate for the call, and point the link register to
a dummy breakpoint instruction. Once the process is restarted, it will execute
the call and then trap back to the debugger, at which point GDB will restore
all registers and continue original execution.
This generally works fine. However, now consider what happens when GDB attempts
to do exactly that while the process was interrupted during execution of a to-be-
restarted system call: do_signal is called with the syscall flag set; it calls
get_signal_to_deliver, at which point the debugger takes over and changes the PC
to point to a completely different place. Now get_signal_to_deliver returns
without a signal to deliver; but now do_signal decides it should be restarting
a system call, and decrements the PC by 2 or 4 -- so it now points to 2 or 4
bytes before the function GDB wants to call -- which leads to a subsequent crash.
To fix this problem, two things need to be supported:
- do_signal must be able to recognize that get_signal_to_deliver changed the PC
to a different location, and skip the restart-syscall sequence
- once the debugger has restored all registers at the end of the inferior call
sequence, do_signal must recognize that *now* it needs to restart the pending
system call, even though it was now entered from a breakpoint instead of an
actual svc instruction
This set of issues is solved on other platforms, usually by one of two
mechanisms:
- The status information "do_signal is handling a system call that may need
restarting" is itself carried in some register that can be accessed via
ptrace. This is e.g. on Intel the "orig_eax" register; on Sparc the kernel
defines a magic extra bit in the flags register for this purpose.
This allows GDB to manage that state: reset it when doing an inferior call,
and restore it after the call is finished.
- On s390, do_signal transparently handles this problem without requiring
GDB interaction, by performing system call restarting in the following
way: first, adjust the PC as necessary for restarting the call. Then,
call get_signal_to_deliver; and finally just continue execution at the
PC. This way, if GDB does not change the PC, everything is as before.
If GDB *does* change the PC, execution will simply continue there --
and once GDB restores the PC it saved at that point, it will automatically
point to the *restarted* system call. (There is the minor twist how to
handle system calls that do *not* need restarting -- do_signal will undo
the PC change in this case, after get_signal_to_deliver has returned, and
only if ptrace did not change the PC during that call.)
Because there does not appear to be any obvious register to carry the
syscall-restart information on ARM, we'd either have to introduce a new
artificial ptrace register just for that purpose, or else handle the issue
transparently like on s390. The patch below implements the second option;
using this patch makes the interrupt.exp test cases pass on ARM, with no
regression in the GDB test suite otherwise.
Cc: patches@linaro.org
Signed-off-by: Ulrich Weigand <ulrich.weigand@linaro.org>
Signed-off-by: Arnd Bergmann <arnd.bergmann@linaro.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2011-05-04 01:32:55 +08:00
|
|
|
case -ERESTARTNOHAND:
|
|
|
|
|
case -ERESTARTSYS:
|
|
|
|
|
case -ERESTARTNOINTR:
|
2012-07-20 00:48:21 +08:00
|
|
|
restart++;
|
ARM: 6892/1: handle ptrace requests to change PC during interrupted system calls
GDB's interrupt.exp test cases currenly fail on ARM. The problem is how do_signal
handled restarting interrupted system calls:
The entry.S assembler code determines that we come from a system call; and that
information is passed as "syscall" parameter to do_signal. That routine then
calls get_signal_to_deliver [*] and if a signal is to be delivered, calls into
handle_signal. If a system call is to be restarted either after the signal
handler returns, or if no handler is to be called in the first place, the PC
is updated after the get_signal_to_deliver call, either in handle_signal (if
we have a handler) or at the end of do_signal (otherwise).
Now the problem is that during [*], the call to get_signal_to_deliver, a ptrace
intercept may happen. During this intercept, the debugger may change registers,
including the PC. This is done by GDB if it wants to execute an "inferior call",
i.e. the execution of some code in the debugged program triggered by GDB.
To this purpose, GDB will save all registers, allocate a stack frame, set up
PC and arguments as appropriate for the call, and point the link register to
a dummy breakpoint instruction. Once the process is restarted, it will execute
the call and then trap back to the debugger, at which point GDB will restore
all registers and continue original execution.
This generally works fine. However, now consider what happens when GDB attempts
to do exactly that while the process was interrupted during execution of a to-be-
restarted system call: do_signal is called with the syscall flag set; it calls
get_signal_to_deliver, at which point the debugger takes over and changes the PC
to point to a completely different place. Now get_signal_to_deliver returns
without a signal to deliver; but now do_signal decides it should be restarting
a system call, and decrements the PC by 2 or 4 -- so it now points to 2 or 4
bytes before the function GDB wants to call -- which leads to a subsequent crash.
To fix this problem, two things need to be supported:
- do_signal must be able to recognize that get_signal_to_deliver changed the PC
to a different location, and skip the restart-syscall sequence
- once the debugger has restored all registers at the end of the inferior call
sequence, do_signal must recognize that *now* it needs to restart the pending
system call, even though it was now entered from a breakpoint instead of an
actual svc instruction
This set of issues is solved on other platforms, usually by one of two
mechanisms:
- The status information "do_signal is handling a system call that may need
restarting" is itself carried in some register that can be accessed via
ptrace. This is e.g. on Intel the "orig_eax" register; on Sparc the kernel
defines a magic extra bit in the flags register for this purpose.
This allows GDB to manage that state: reset it when doing an inferior call,
and restore it after the call is finished.
- On s390, do_signal transparently handles this problem without requiring
GDB interaction, by performing system call restarting in the following
way: first, adjust the PC as necessary for restarting the call. Then,
call get_signal_to_deliver; and finally just continue execution at the
PC. This way, if GDB does not change the PC, everything is as before.
If GDB *does* change the PC, execution will simply continue there --
and once GDB restores the PC it saved at that point, it will automatically
point to the *restarted* system call. (There is the minor twist how to
handle system calls that do *not* need restarting -- do_signal will undo
the PC change in this case, after get_signal_to_deliver has returned, and
only if ptrace did not change the PC during that call.)
Because there does not appear to be any obvious register to carry the
syscall-restart information on ARM, we'd either have to introduce a new
artificial ptrace register just for that purpose, or else handle the issue
transparently like on s390. The patch below implements the second option;
using this patch makes the interrupt.exp test cases pass on ARM, with no
regression in the GDB test suite otherwise.
Cc: patches@linaro.org
Signed-off-by: Ulrich Weigand <ulrich.weigand@linaro.org>
Signed-off-by: Arnd Bergmann <arnd.bergmann@linaro.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2011-05-04 01:32:55 +08:00
|
|
|
regs->ARM_r0 = regs->ARM_ORIG_r0;
|
|
|
|
|
regs->ARM_pc = restart_addr;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Get the signal to deliver. When running under ptrace, at this
|
|
|
|
|
* point the debugger may change all our registers ...
|
|
|
|
|
*/
|
2012-07-20 00:48:21 +08:00
|
|
|
/*
|
|
|
|
|
* 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.
|
|
|
|
|
*/
|
2012-11-08 06:53:13 +08:00
|
|
|
if (get_signal(&ksig)) {
|
|
|
|
|
/* handler */
|
|
|
|
|
if (unlikely(restart) && regs->ARM_pc == restart_addr) {
|
2012-07-20 00:46:44 +08:00
|
|
|
if (retval == -ERESTARTNOHAND ||
|
|
|
|
|
retval == -ERESTART_RESTARTBLOCK
|
ARM: 6892/1: handle ptrace requests to change PC during interrupted system calls
GDB's interrupt.exp test cases currenly fail on ARM. The problem is how do_signal
handled restarting interrupted system calls:
The entry.S assembler code determines that we come from a system call; and that
information is passed as "syscall" parameter to do_signal. That routine then
calls get_signal_to_deliver [*] and if a signal is to be delivered, calls into
handle_signal. If a system call is to be restarted either after the signal
handler returns, or if no handler is to be called in the first place, the PC
is updated after the get_signal_to_deliver call, either in handle_signal (if
we have a handler) or at the end of do_signal (otherwise).
Now the problem is that during [*], the call to get_signal_to_deliver, a ptrace
intercept may happen. During this intercept, the debugger may change registers,
including the PC. This is done by GDB if it wants to execute an "inferior call",
i.e. the execution of some code in the debugged program triggered by GDB.
To this purpose, GDB will save all registers, allocate a stack frame, set up
PC and arguments as appropriate for the call, and point the link register to
a dummy breakpoint instruction. Once the process is restarted, it will execute
the call and then trap back to the debugger, at which point GDB will restore
all registers and continue original execution.
This generally works fine. However, now consider what happens when GDB attempts
to do exactly that while the process was interrupted during execution of a to-be-
restarted system call: do_signal is called with the syscall flag set; it calls
get_signal_to_deliver, at which point the debugger takes over and changes the PC
to point to a completely different place. Now get_signal_to_deliver returns
without a signal to deliver; but now do_signal decides it should be restarting
a system call, and decrements the PC by 2 or 4 -- so it now points to 2 or 4
bytes before the function GDB wants to call -- which leads to a subsequent crash.
To fix this problem, two things need to be supported:
- do_signal must be able to recognize that get_signal_to_deliver changed the PC
to a different location, and skip the restart-syscall sequence
- once the debugger has restored all registers at the end of the inferior call
sequence, do_signal must recognize that *now* it needs to restart the pending
system call, even though it was now entered from a breakpoint instead of an
actual svc instruction
This set of issues is solved on other platforms, usually by one of two
mechanisms:
- The status information "do_signal is handling a system call that may need
restarting" is itself carried in some register that can be accessed via
ptrace. This is e.g. on Intel the "orig_eax" register; on Sparc the kernel
defines a magic extra bit in the flags register for this purpose.
This allows GDB to manage that state: reset it when doing an inferior call,
and restore it after the call is finished.
- On s390, do_signal transparently handles this problem without requiring
GDB interaction, by performing system call restarting in the following
way: first, adjust the PC as necessary for restarting the call. Then,
call get_signal_to_deliver; and finally just continue execution at the
PC. This way, if GDB does not change the PC, everything is as before.
If GDB *does* change the PC, execution will simply continue there --
and once GDB restores the PC it saved at that point, it will automatically
point to the *restarted* system call. (There is the minor twist how to
handle system calls that do *not* need restarting -- do_signal will undo
the PC change in this case, after get_signal_to_deliver has returned, and
only if ptrace did not change the PC during that call.)
Because there does not appear to be any obvious register to carry the
syscall-restart information on ARM, we'd either have to introduce a new
artificial ptrace register just for that purpose, or else handle the issue
transparently like on s390. The patch below implements the second option;
using this patch makes the interrupt.exp test cases pass on ARM, with no
regression in the GDB test suite otherwise.
Cc: patches@linaro.org
Signed-off-by: Ulrich Weigand <ulrich.weigand@linaro.org>
Signed-off-by: Arnd Bergmann <arnd.bergmann@linaro.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2011-05-04 01:32:55 +08:00
|
|
|
|| (retval == -ERESTARTSYS
|
2012-11-08 06:53:13 +08:00
|
|
|
&& !(ksig.ka.sa.sa_flags & SA_RESTART))) {
|
ARM: 6892/1: handle ptrace requests to change PC during interrupted system calls
GDB's interrupt.exp test cases currenly fail on ARM. The problem is how do_signal
handled restarting interrupted system calls:
The entry.S assembler code determines that we come from a system call; and that
information is passed as "syscall" parameter to do_signal. That routine then
calls get_signal_to_deliver [*] and if a signal is to be delivered, calls into
handle_signal. If a system call is to be restarted either after the signal
handler returns, or if no handler is to be called in the first place, the PC
is updated after the get_signal_to_deliver call, either in handle_signal (if
we have a handler) or at the end of do_signal (otherwise).
Now the problem is that during [*], the call to get_signal_to_deliver, a ptrace
intercept may happen. During this intercept, the debugger may change registers,
including the PC. This is done by GDB if it wants to execute an "inferior call",
i.e. the execution of some code in the debugged program triggered by GDB.
To this purpose, GDB will save all registers, allocate a stack frame, set up
PC and arguments as appropriate for the call, and point the link register to
a dummy breakpoint instruction. Once the process is restarted, it will execute
the call and then trap back to the debugger, at which point GDB will restore
all registers and continue original execution.
This generally works fine. However, now consider what happens when GDB attempts
to do exactly that while the process was interrupted during execution of a to-be-
restarted system call: do_signal is called with the syscall flag set; it calls
get_signal_to_deliver, at which point the debugger takes over and changes the PC
to point to a completely different place. Now get_signal_to_deliver returns
without a signal to deliver; but now do_signal decides it should be restarting
a system call, and decrements the PC by 2 or 4 -- so it now points to 2 or 4
bytes before the function GDB wants to call -- which leads to a subsequent crash.
To fix this problem, two things need to be supported:
- do_signal must be able to recognize that get_signal_to_deliver changed the PC
to a different location, and skip the restart-syscall sequence
- once the debugger has restored all registers at the end of the inferior call
sequence, do_signal must recognize that *now* it needs to restart the pending
system call, even though it was now entered from a breakpoint instead of an
actual svc instruction
This set of issues is solved on other platforms, usually by one of two
mechanisms:
- The status information "do_signal is handling a system call that may need
restarting" is itself carried in some register that can be accessed via
ptrace. This is e.g. on Intel the "orig_eax" register; on Sparc the kernel
defines a magic extra bit in the flags register for this purpose.
This allows GDB to manage that state: reset it when doing an inferior call,
and restore it after the call is finished.
- On s390, do_signal transparently handles this problem without requiring
GDB interaction, by performing system call restarting in the following
way: first, adjust the PC as necessary for restarting the call. Then,
call get_signal_to_deliver; and finally just continue execution at the
PC. This way, if GDB does not change the PC, everything is as before.
If GDB *does* change the PC, execution will simply continue there --
and once GDB restores the PC it saved at that point, it will automatically
point to the *restarted* system call. (There is the minor twist how to
handle system calls that do *not* need restarting -- do_signal will undo
the PC change in this case, after get_signal_to_deliver has returned, and
only if ptrace did not change the PC during that call.)
Because there does not appear to be any obvious register to carry the
syscall-restart information on ARM, we'd either have to introduce a new
artificial ptrace register just for that purpose, or else handle the issue
transparently like on s390. The patch below implements the second option;
using this patch makes the interrupt.exp test cases pass on ARM, with no
regression in the GDB test suite otherwise.
Cc: patches@linaro.org
Signed-off-by: Ulrich Weigand <ulrich.weigand@linaro.org>
Signed-off-by: Arnd Bergmann <arnd.bergmann@linaro.org>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2011-05-04 01:32:55 +08:00
|
|
|
regs->ARM_r0 = -EINTR;
|
|
|
|
|
regs->ARM_pc = continue_addr;
|
|
|
|
|
}
|
|
|
|
|
}
|
2012-11-08 06:53:13 +08:00
|
|
|
handle_signal(&ksig, regs);
|
|
|
|
|
} else {
|
|
|
|
|
/* no handler */
|
|
|
|
|
restore_saved_sigmask();
|
|
|
|
|
if (unlikely(restart) && regs->ARM_pc == restart_addr) {
|
|
|
|
|
regs->ARM_pc = continue_addr;
|
|
|
|
|
return restart;
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2012-11-08 06:53:13 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2012-07-20 00:48:21 +08:00
|
|
|
asmlinkage int
|
2012-07-20 00:47:55 +08:00
|
|
|
do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-07-20 00:47:55 +08:00
|
|
|
do {
|
|
|
|
|
if (likely(thread_flags & _TIF_NEED_RESCHED)) {
|
|
|
|
|
schedule();
|
|
|
|
|
} else {
|
|
|
|
|
if (unlikely(!user_mode(regs)))
|
2012-07-20 00:48:21 +08:00
|
|
|
return 0;
|
2012-07-20 00:47:55 +08:00
|
|
|
local_irq_enable();
|
|
|
|
|
if (thread_flags & _TIF_SIGPENDING) {
|
2012-07-20 00:48:50 +08:00
|
|
|
int restart = do_signal(regs, syscall);
|
|
|
|
|
if (unlikely(restart)) {
|
2012-07-20 00:48:21 +08:00
|
|
|
/*
|
|
|
|
|
* Restart without handlers.
|
|
|
|
|
* Deal with it without leaving
|
|
|
|
|
* the kernel space.
|
|
|
|
|
*/
|
2012-07-20 00:48:50 +08:00
|
|
|
return restart;
|
2012-07-20 00:48:21 +08:00
|
|
|
}
|
2012-07-20 00:47:55 +08:00
|
|
|
syscall = 0;
|
2014-03-08 00:23:04 +08:00
|
|
|
} else if (thread_flags & _TIF_UPROBE) {
|
|
|
|
|
clear_thread_flag(TIF_UPROBE);
|
|
|
|
|
uprobe_notify_resume(regs);
|
2012-07-20 00:47:55 +08:00
|
|
|
} 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);
|
2012-07-20 00:48:21 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2013-07-24 07:29:18 +08:00
|
|
|
|
|
|
|
|
struct page *get_signal_page(void)
|
|
|
|
|
{
|
2013-08-03 17:30:05 +08:00
|
|
|
unsigned long ptr;
|
|
|
|
|
unsigned offset;
|
|
|
|
|
struct page *page;
|
|
|
|
|
void *addr;
|
2013-07-24 07:29:18 +08:00
|
|
|
|
2013-08-03 17:30:05 +08:00
|
|
|
page = alloc_pages(GFP_KERNEL, 0);
|
2013-07-24 07:29:18 +08:00
|
|
|
|
2013-08-03 17:30:05 +08:00
|
|
|
if (!page)
|
|
|
|
|
return NULL;
|
2013-07-24 07:29:18 +08:00
|
|
|
|
2013-08-03 17:30:05 +08:00
|
|
|
addr = page_address(page);
|
2013-07-24 07:29:18 +08:00
|
|
|
|
2013-08-03 17:30:05 +08:00
|
|
|
/* Give the signal return code some randomness */
|
|
|
|
|
offset = 0x200 + (get_random_int() & 0x7fc);
|
|
|
|
|
signal_return_offset = offset;
|
2013-07-24 07:29:18 +08:00
|
|
|
|
2013-08-03 17:30:05 +08:00
|
|
|
/*
|
|
|
|
|
* Copy signal return handlers into the vector page, and
|
|
|
|
|
* set sigreturn to be a pointer to these.
|
|
|
|
|
*/
|
|
|
|
|
memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
|
2013-07-24 07:29:18 +08:00
|
|
|
|
2013-08-03 17:30:05 +08:00
|
|
|
ptr = (unsigned long)addr + offset;
|
|
|
|
|
flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
|
2013-07-24 07:29:18 +08:00
|
|
|
|
2013-08-03 17:30:05 +08:00
|
|
|
return page;
|
2013-07-24 07:29:18 +08:00
|
|
|
}
|
