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>
|
|
|
|
|
#include <linux/signal.h>
|
|
|
|
|
#include <linux/personality.h>
|
2006-12-07 12:34:23 +08:00
|
|
|
#include <linux/freezer.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>
|
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>
|
|
|
|
|
#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
|
|
|
|
2005-06-23 03:26:05 +08:00
|
|
|
#include "signal.h"
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* For ARM syscalls, we encode the syscall number into the instruction.
|
|
|
|
|
*/
|
2008-03-19 10:34:23 +08:00
|
|
|
#define SWI_SYS_SIGRETURN (0xef000000|(__NR_sigreturn)|(__NR_OABI_SYSCALL_BASE))
|
|
|
|
|
#define SWI_SYS_RT_SIGRETURN (0xef000000|(__NR_rt_sigreturn)|(__NR_OABI_SYSCALL_BASE))
|
2009-10-25 23:39:37 +08:00
|
|
|
#define SWI_SYS_RESTART (0xef000000|__NR_restart_syscall|__NR_OABI_SYSCALL_BASE)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-01-19 06:38:47 +08:00
|
|
|
/*
|
|
|
|
|
* With EABI, the syscall number has to be loaded into r7.
|
|
|
|
|
*/
|
|
|
|
|
#define MOV_R7_NR_SIGRETURN (0xe3a07000 | (__NR_sigreturn - __NR_SYSCALL_BASE))
|
|
|
|
|
#define MOV_R7_NR_RT_SIGRETURN (0xe3a07000 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* For Thumb syscalls, we pass the syscall number via r7. We therefore
|
|
|
|
|
* need two 16-bit instructions.
|
|
|
|
|
*/
|
|
|
|
|
#define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_sigreturn - __NR_SYSCALL_BASE))
|
|
|
|
|
#define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (__NR_rt_sigreturn - __NR_SYSCALL_BASE))
|
|
|
|
|
|
2006-01-19 06:38:47 +08:00
|
|
|
const unsigned long sigreturn_codes[7] = {
|
|
|
|
|
MOV_R7_NR_SIGRETURN, SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
|
|
|
|
|
MOV_R7_NR_RT_SIGRETURN, SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
2009-10-25 23:39:37 +08:00
|
|
|
/*
|
|
|
|
|
* Either we support OABI only, or we have EABI with the OABI
|
|
|
|
|
* compat layer enabled. In the later case we don't know if
|
|
|
|
|
* user space is EABI or not, and if not we must not clobber r7.
|
|
|
|
|
* Always using the OABI syscall solves that issue and works for
|
|
|
|
|
* all those cases.
|
|
|
|
|
*/
|
|
|
|
|
const unsigned long syscall_restart_code[2] = {
|
|
|
|
|
SWI_SYS_RESTART, /* swi __NR_restart_syscall */
|
|
|
|
|
0xe49df004, /* ldr pc, [sp], #4 */
|
|
|
|
|
};
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* atomically swap in the new signal mask, and wait for a signal.
|
|
|
|
|
*/
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
asmlinkage int sys_sigsuspend(int restart, unsigned long oldmask, old_sigset_t mask)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-03-06 07:05:34 +08:00
|
|
|
sigset_t blocked;
|
|
|
|
|
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
current->saved_sigmask = current->blocked;
|
2012-03-06 07:05:34 +08:00
|
|
|
|
|
|
|
|
mask &= _BLOCKABLE;
|
|
|
|
|
siginitset(&blocked, mask);
|
|
|
|
|
set_current_blocked(&blocked);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
current->state = TASK_INTERRUPTIBLE;
|
|
|
|
|
schedule();
|
|
|
|
|
set_restore_sigmask();
|
|
|
|
|
return -ERESTARTNOHAND;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
asmlinkage int
|
|
|
|
|
sys_sigaction(int sig, const struct old_sigaction __user *act,
|
|
|
|
|
struct old_sigaction __user *oact)
|
|
|
|
|
{
|
|
|
|
|
struct k_sigaction new_ka, old_ka;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
if (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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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(old_ka.sa.sa_handler, &oact->sa_handler) ||
|
|
|
|
|
__put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
|
|
|
|
|
return -EFAULT;
|
|
|
|
|
__put_user(old_ka.sa.sa_flags, &oact->sa_flags);
|
|
|
|
|
__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
struct thread_info *thread = current_thread_info();
|
|
|
|
|
struct vfp_hard_struct *h = &thread->vfpstate.hard;
|
|
|
|
|
const unsigned long magic = VFP_MAGIC;
|
|
|
|
|
const unsigned long size = VFP_STORAGE_SIZE;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
vfp_sync_hwstate(thread);
|
|
|
|
|
__put_user_error(magic, &frame->magic, err);
|
|
|
|
|
__put_user_error(size, &frame->size, err);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Copy the floating point registers. There can be unused
|
|
|
|
|
* registers see asm/hwcap.h for details.
|
|
|
|
|
*/
|
|
|
|
|
err |= __copy_to_user(&frame->ufp.fpregs, &h->fpregs,
|
|
|
|
|
sizeof(h->fpregs));
|
|
|
|
|
/*
|
|
|
|
|
* Copy the status and control register.
|
|
|
|
|
*/
|
|
|
|
|
__put_user_error(h->fpscr, &frame->ufp.fpscr, err);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Copy the exception registers.
|
|
|
|
|
*/
|
|
|
|
|
__put_user_error(h->fpexc, &frame->ufp_exc.fpexc, err);
|
|
|
|
|
__put_user_error(h->fpinst, &frame->ufp_exc.fpinst, err);
|
|
|
|
|
__put_user_error(h->fpinst2, &frame->ufp_exc.fpinst2, err);
|
|
|
|
|
|
|
|
|
|
return err ? -EFAULT : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int restore_vfp_context(struct vfp_sigframe __user *frame)
|
|
|
|
|
{
|
|
|
|
|
struct thread_info *thread = current_thread_info();
|
|
|
|
|
struct vfp_hard_struct *h = &thread->vfpstate.hard;
|
|
|
|
|
unsigned long magic;
|
|
|
|
|
unsigned long size;
|
|
|
|
|
unsigned long fpexc;
|
|
|
|
|
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-01-31 03:21:42 +08:00
|
|
|
vfp_flush_hwstate(thread);
|
|
|
|
|
|
2010-04-11 22:58:27 +08:00
|
|
|
/*
|
|
|
|
|
* Copy the floating point registers. There can be unused
|
|
|
|
|
* registers see asm/hwcap.h for details.
|
|
|
|
|
*/
|
|
|
|
|
err |= __copy_from_user(&h->fpregs, &frame->ufp.fpregs,
|
|
|
|
|
sizeof(h->fpregs));
|
|
|
|
|
/*
|
|
|
|
|
* Copy the status and control register.
|
|
|
|
|
*/
|
|
|
|
|
__get_user_error(h->fpscr, &frame->ufp.fpscr, err);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Sanitise and restore the exception registers.
|
|
|
|
|
*/
|
|
|
|
|
__get_user_error(fpexc, &frame->ufp_exc.fpexc, err);
|
|
|
|
|
/* Ensure the VFP is enabled. */
|
|
|
|
|
fpexc |= FPEXC_EN;
|
|
|
|
|
/* Ensure FPINST2 is invalid and the exception flag is cleared. */
|
|
|
|
|
fpexc &= ~(FPEXC_EX | FPEXC_FP2V);
|
|
|
|
|
h->fpexc = fpexc;
|
|
|
|
|
|
|
|
|
|
__get_user_error(h->fpinst, &frame->ufp_exc.fpinst, err);
|
|
|
|
|
__get_user_error(h->fpinst2, &frame->ufp_exc.fpinst2, err);
|
|
|
|
|
|
|
|
|
|
return err ? -EFAULT : 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#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));
|
|
|
|
|
if (err == 0) {
|
|
|
|
|
sigdelsetmask(&set, ~_BLOCKABLE);
|
2012-03-06 07:05:34 +08:00
|
|
|
set_current_blocked(&set);
|
2006-06-16 03:23:02 +08:00
|
|
|
}
|
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;
|
|
|
|
|
|
2006-06-16 03:18:25 +08:00
|
|
|
if (do_sigaltstack(&frame->sig.uc.uc_stack, NULL, regs->ARM_sp) == -EFAULT)
|
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 *
|
|
|
|
|
get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, int framesize)
|
|
|
|
|
{
|
|
|
|
|
unsigned long sp = regs->ARM_sp;
|
|
|
|
|
void __user *frame;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This is the X/Open sanctioned signal stack switching.
|
|
|
|
|
*/
|
|
|
|
|
if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
|
|
|
|
|
sp = current->sas_ss_sp + current->sas_ss_size;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
setup_return(struct pt_regs *regs, struct k_sigaction *ka,
|
|
|
|
|
unsigned long __user *rc, void __user *frame, int usig)
|
|
|
|
|
{
|
|
|
|
|
unsigned long handler = (unsigned long)ka->sa.sa_handler;
|
|
|
|
|
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.
|
|
|
|
|
*/
|
|
|
|
|
if (ka->sa.sa_flags & SA_THIRTYTWO)
|
|
|
|
|
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 (thumb) {
|
2005-04-17 06:20:36 +08:00
|
|
|
cpsr |= PSR_T_BIT;
|
2009-05-30 21:00:15 +08:00
|
|
|
#if __LINUX_ARM_ARCH__ >= 7
|
|
|
|
|
/* clear the If-Then Thumb-2 execution state */
|
|
|
|
|
cpsr &= ~PSR_IT_MASK;
|
|
|
|
|
#endif
|
|
|
|
|
} else
|
2005-04-17 06:20:36 +08:00
|
|
|
cpsr &= ~PSR_T_BIT;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
if (ka->sa.sa_flags & SA_RESTORER) {
|
|
|
|
|
retcode = (unsigned long)ka->sa.sa_restorer;
|
|
|
|
|
} else {
|
2006-01-19 06:38:47 +08:00
|
|
|
unsigned int idx = thumb << 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (ka->sa.sa_flags & SA_SIGINFO)
|
2006-01-19 06:38:47 +08:00
|
|
|
idx += 3;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
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;
|
|
|
|
|
|
2005-06-23 03:26:05 +08:00
|
|
|
if (cpsr & MODE32_BIT) {
|
|
|
|
|
/*
|
|
|
|
|
* 32-bit code can use the new high-page
|
|
|
|
|
* signal return code support.
|
|
|
|
|
*/
|
|
|
|
|
retcode = KERN_SIGRETURN_CODE + (idx << 2) + thumb;
|
|
|
|
|
} else {
|
|
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
regs->ARM_r0 = usig;
|
|
|
|
|
regs->ARM_sp = (unsigned long)frame;
|
|
|
|
|
regs->ARM_lr = retcode;
|
|
|
|
|
regs->ARM_pc = handler;
|
|
|
|
|
regs->ARM_cpsr = cpsr;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
setup_frame(int usig, struct k_sigaction *ka, sigset_t *set, struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
struct sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
|
|
|
|
|
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)
|
2006-01-19 06:38:47 +08:00
|
|
|
err = setup_return(regs, ka, frame->retcode, frame, usig);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
|
|
|
|
|
sigset_t *set, struct pt_regs *regs)
|
|
|
|
|
{
|
|
|
|
|
struct rt_sigframe __user *frame = get_sigframe(ka, regs, sizeof(*frame));
|
|
|
|
|
stack_t stack;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
if (!frame)
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
err |= copy_siginfo_to_user(&frame->info, info);
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
memset(&stack, 0, sizeof(stack));
|
|
|
|
|
stack.ss_sp = (void __user *)current->sas_ss_sp;
|
|
|
|
|
stack.ss_flags = sas_ss_flags(regs->ARM_sp);
|
|
|
|
|
stack.ss_size = current->sas_ss_size;
|
2006-06-16 03:18:25 +08:00
|
|
|
err |= __copy_to_user(&frame->sig.uc.uc_stack, &stack, sizeof(stack));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
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)
|
2006-06-16 03:18:25 +08:00
|
|
|
err = setup_return(regs, ka, frame->sig.retcode, frame, usig);
|
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
|
|
|
|
|
*/
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
static int
|
2005-04-17 06:20:36 +08:00
|
|
|
handle_signal(unsigned long sig, struct k_sigaction *ka,
|
|
|
|
|
siginfo_t *info, sigset_t *oldset,
|
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
|
|
|
struct pt_regs * regs)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
struct thread_info *thread = current_thread_info();
|
|
|
|
|
struct task_struct *tsk = current;
|
|
|
|
|
int usig = sig;
|
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* translate the signal
|
|
|
|
|
*/
|
|
|
|
|
if (usig < 32 && thread->exec_domain && thread->exec_domain->signal_invmap)
|
|
|
|
|
usig = thread->exec_domain->signal_invmap[usig];
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Set up the stack frame
|
|
|
|
|
*/
|
|
|
|
|
if (ka->sa.sa_flags & SA_SIGINFO)
|
|
|
|
|
ret = setup_rt_frame(usig, ka, info, oldset, regs);
|
|
|
|
|
else
|
|
|
|
|
ret = setup_frame(usig, ka, oldset, regs);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that the resulting registers are actually sane.
|
|
|
|
|
*/
|
|
|
|
|
ret |= !valid_user_regs(regs);
|
|
|
|
|
|
[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 23:44:09 +08:00
|
|
|
if (ret != 0) {
|
2005-11-19 18:01:07 +08:00
|
|
|
force_sigsegv(sig, tsk);
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-11-19 18:01:07 +08:00
|
|
|
/*
|
|
|
|
|
* Block the signal if we were successful.
|
|
|
|
|
*/
|
2012-03-06 07:05:34 +08:00
|
|
|
block_sigmask(ka, sig);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
return 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.
|
|
|
|
|
*/
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
static void 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;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct k_sigaction ka;
|
|
|
|
|
siginfo_t info;
|
|
|
|
|
int signr;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We want the common case to go fast, which
|
|
|
|
|
* is why we may in certain cases get here from
|
|
|
|
|
* kernel mode. Just return without doing anything
|
|
|
|
|
* if so.
|
|
|
|
|
*/
|
|
|
|
|
if (!user_mode(regs))
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
return;
|
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) {
|
|
|
|
|
case -ERESTARTNOHAND:
|
|
|
|
|
case -ERESTARTSYS:
|
|
|
|
|
case -ERESTARTNOINTR:
|
|
|
|
|
regs->ARM_r0 = regs->ARM_ORIG_r0;
|
|
|
|
|
regs->ARM_pc = restart_addr;
|
|
|
|
|
break;
|
|
|
|
|
case -ERESTART_RESTARTBLOCK:
|
|
|
|
|
regs->ARM_r0 = -EINTR;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-06-26 18:27:21 +08:00
|
|
|
if (try_to_freeze())
|
2005-04-17 06:20:36 +08:00
|
|
|
goto no_signal;
|
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
|
* Get the signal to deliver. When running under ptrace, at this
|
|
|
|
|
* point the debugger may change all our registers ...
|
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
|
|
|
|
|
if (signr > 0) {
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
sigset_t *oldset;
|
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
|
* 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->ARM_pc == restart_addr) {
|
|
|
|
|
if (retval == -ERESTARTNOHAND
|
|
|
|
|
|| (retval == -ERESTARTSYS
|
|
|
|
|
&& !(ka.sa.sa_flags & SA_RESTART))) {
|
|
|
|
|
regs->ARM_r0 = -EINTR;
|
|
|
|
|
regs->ARM_pc = continue_addr;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
if (test_thread_flag(TIF_RESTORE_SIGMASK))
|
|
|
|
|
oldset = ¤t->saved_sigmask;
|
|
|
|
|
else
|
|
|
|
|
oldset = ¤t->blocked;
|
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 (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
/*
|
|
|
|
|
* A signal was successfully delivered; the saved
|
|
|
|
|
* sigmask will have been stored in the signal frame,
|
|
|
|
|
* and will be restored by sigreturn, so we can simply
|
|
|
|
|
* clear the TIF_RESTORE_SIGMASK flag.
|
|
|
|
|
*/
|
|
|
|
|
if (test_thread_flag(TIF_RESTORE_SIGMASK))
|
|
|
|
|
clear_thread_flag(TIF_RESTORE_SIGMASK);
|
|
|
|
|
}
|
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
no_signal:
|
|
|
|
|
if (syscall) {
|
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
|
|
|
/*
|
|
|
|
|
* Handle restarting a different system call. As above,
|
|
|
|
|
* if a debugger has chosen to restart at a different PC,
|
|
|
|
|
* ignore the restart.
|
|
|
|
|
*/
|
|
|
|
|
if (retval == -ERESTART_RESTARTBLOCK
|
|
|
|
|
&& regs->ARM_pc == continue_addr) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (thumb_mode(regs)) {
|
2006-06-23 05:18:45 +08:00
|
|
|
regs->ARM_r7 = __NR_restart_syscall - __NR_SYSCALL_BASE;
|
2005-04-17 06:20:36 +08:00
|
|
|
regs->ARM_pc -= 2;
|
|
|
|
|
} else {
|
2006-06-23 05:18:45 +08:00
|
|
|
#if defined(CONFIG_AEABI) && !defined(CONFIG_OABI_COMPAT)
|
|
|
|
|
regs->ARM_r7 = __NR_restart_syscall;
|
|
|
|
|
regs->ARM_pc -= 4;
|
|
|
|
|
#else
|
2005-04-17 06:20:36 +08:00
|
|
|
u32 __user *usp;
|
|
|
|
|
|
2009-10-25 23:39:37 +08:00
|
|
|
regs->ARM_sp -= 4;
|
2005-04-17 06:20:36 +08:00
|
|
|
usp = (u32 __user *)regs->ARM_sp;
|
|
|
|
|
|
2009-11-24 00:03:32 +08:00
|
|
|
if (put_user(regs->ARM_pc, usp) == 0) {
|
|
|
|
|
regs->ARM_pc = KERN_RESTART_CODE;
|
|
|
|
|
} else {
|
|
|
|
|
regs->ARM_sp += 4;
|
|
|
|
|
force_sigsegv(0, current);
|
|
|
|
|
}
|
2006-06-23 05:18:45 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
|
|
|
|
|
/* If there's no signal to deliver, we just put the saved sigmask
|
|
|
|
|
* back.
|
|
|
|
|
*/
|
|
|
|
|
if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
|
|
|
|
|
clear_thread_flag(TIF_RESTORE_SIGMASK);
|
|
|
|
|
sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
asmlinkage void
|
|
|
|
|
do_notify_resume(struct pt_regs *regs, unsigned int thread_flags, int syscall)
|
|
|
|
|
{
|
|
|
|
|
if (thread_flags & _TIF_SIGPENDING)
|
ARM: 5677/1: ARM support for TIF_RESTORE_SIGMASK/pselect6/ppoll/epoll_pwait
This patch adds support for TIF_RESTORE_SIGMASK to ARM's
signal handling, which allows to hook up the pselect6, ppoll,
and epoll_pwait syscalls on ARM.
Tested here with eabi userspace and a test program with a
deliberate race between a child's exit and the parent's
sigprocmask/select sequence. Using sys_pselect6() instead
of sigprocmask/select reliably prevents the race.
The other arch's support for TIF_RESTORE_SIGMASK has evolved
over time:
In 2.6.16:
- add TIF_RESTORE_SIGMASK which parallels TIF_SIGPENDING
- test both when checking for pending signal [changed later]
- reimplement sys_sigsuspend() to use current->saved_sigmask,
TIF_RESTORE_SIGMASK [changed later], and -ERESTARTNOHAND;
ditto for sys_rt_sigsuspend(), but drop private code and
use common code via __ARCH_WANT_SYS_RT_SIGSUSPEND;
- there are now no "extra" calls to do_signal() so its oldset
parameter is always ¤t->blocked so need not be passed,
also its return value is changed to void
- change handle_signal() to return 0/-errno
- change do_signal() to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- hook up sys_pselect6() and sys_ppoll()
In 2.6.19:
- hook up sys_epoll_pwait()
In 2.6.26:
- allow archs to override how TIF_RESTORE_SIGMASK is implemented;
default set_restore_sigmask() sets both TIF_RESTORE_SIGMASK and
TIF_SIGPENDING; archs need now just test TIF_SIGPENDING again
when checking for pending signal work; some archs now implement
TIF_RESTORE_SIGMASK as a secondary/non-atomic thread flag bit
- call set_restore_sigmask() in sys_sigsuspend() instead of setting
TIF_RESTORE_SIGMASK
In 2.6.29-rc:
- kill sys_pselect7() which no arch wanted
So for 2.6.31-rc6/ARM this patch does the following:
- Add TIF_RESTORE_SIGMASK. Use the generic set_restore_sigmask()
which sets both TIF_SIGPENDING and TIF_RESTORE_SIGMASK, so
TIF_RESTORE_SIGMASK need not claim one of the scarce low thread
flags, and existing TIF_SIGPENDING and _TIF_WORK_MASK tests need
not be extended for TIF_RESTORE_SIGMASK.
- sys_sigsuspend() is reimplemented to use current->saved_sigmask
and set_restore_sigmask(), making it identical to most other archs
- The private code for sys_rt_sigsuspend() is removed, instead
generic code supplies it via __ARCH_WANT_SYS_RT_SIGSUSPEND.
- sys_sigsuspend() and sys_rt_sigsuspend() no longer need a pt_regs
parameter, so their assembly code wrappers are removed.
- handle_signal() is changed to return 0 on success or -errno.
- The oldset parameter to do_signal() is now redundant and removed,
and the return value is now also redundant and changed to void.
- do_signal() is changed to honor TIF_RESTORE_SIGMASK:
+ get oldset from current->saved_sigmask if TIF_RESTORE_SIGMASK
is set
+ if handle_signal() was successful then clear TIF_RESTORE_SIGMASK
+ if no signal was delivered and TIF_RESTORE_SIGMASK is set then
clear it and restore the sigmask
- Hook up sys_pselect6, sys_ppoll, and sys_epoll_pwait.
Signed-off-by: Mikael Pettersson <mikpe@it.uu.se>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2009-08-15 19:58:11 +08:00
|
|
|
do_signal(regs, syscall);
|
2009-09-02 16:14:16 +08:00
|
|
|
|
|
|
|
|
if (thread_flags & _TIF_NOTIFY_RESUME) {
|
|
|
|
|
clear_thread_flag(TIF_NOTIFY_RESUME);
|
|
|
|
|
tracehook_notify_resume(regs);
|
KEYS: Add a keyctl to install a process's session keyring on its parent [try #6]
Add a keyctl to install a process's session keyring onto its parent. This
replaces the parent's session keyring. Because the COW credential code does
not permit one process to change another process's credentials directly, the
change is deferred until userspace next starts executing again. Normally this
will be after a wait*() syscall.
To support this, three new security hooks have been provided:
cred_alloc_blank() to allocate unset security creds, cred_transfer() to fill in
the blank security creds and key_session_to_parent() - which asks the LSM if
the process may replace its parent's session keyring.
The replacement may only happen if the process has the same ownership details
as its parent, and the process has LINK permission on the session keyring, and
the session keyring is owned by the process, and the LSM permits it.
Note that this requires alteration to each architecture's notify_resume path.
This has been done for all arches barring blackfin, m68k* and xtensa, all of
which need assembly alteration to support TIF_NOTIFY_RESUME. This allows the
replacement to be performed at the point the parent process resumes userspace
execution.
This allows the userspace AFS pioctl emulation to fully emulate newpag() and
the VIOCSETTOK and VIOCSETTOK2 pioctls, all of which require the ability to
alter the parent process's PAG membership. However, since kAFS doesn't use
PAGs per se, but rather dumps the keys into the session keyring, the session
keyring of the parent must be replaced if, for example, VIOCSETTOK is passed
the newpag flag.
This can be tested with the following program:
#include <stdio.h>
#include <stdlib.h>
#include <keyutils.h>
#define KEYCTL_SESSION_TO_PARENT 18
#define OSERROR(X, S) do { if ((long)(X) == -1) { perror(S); exit(1); } } while(0)
int main(int argc, char **argv)
{
key_serial_t keyring, key;
long ret;
keyring = keyctl_join_session_keyring(argv[1]);
OSERROR(keyring, "keyctl_join_session_keyring");
key = add_key("user", "a", "b", 1, keyring);
OSERROR(key, "add_key");
ret = keyctl(KEYCTL_SESSION_TO_PARENT);
OSERROR(ret, "KEYCTL_SESSION_TO_PARENT");
return 0;
}
Compiled and linked with -lkeyutils, you should see something like:
[dhowells@andromeda ~]$ keyctl show
Session Keyring
-3 --alswrv 4043 4043 keyring: _ses
355907932 --alswrv 4043 -1 \_ keyring: _uid.4043
[dhowells@andromeda ~]$ /tmp/newpag
[dhowells@andromeda ~]$ keyctl show
Session Keyring
-3 --alswrv 4043 4043 keyring: _ses
1055658746 --alswrv 4043 4043 \_ user: a
[dhowells@andromeda ~]$ /tmp/newpag hello
[dhowells@andromeda ~]$ keyctl show
Session Keyring
-3 --alswrv 4043 4043 keyring: hello
340417692 --alswrv 4043 4043 \_ user: a
Where the test program creates a new session keyring, sticks a user key named
'a' into it and then installs it on its parent.
Signed-off-by: David Howells <dhowells@redhat.com>
Signed-off-by: James Morris <jmorris@namei.org>
2009-09-02 16:14:21 +08:00
|
|
|
if (current->replacement_session_keyring)
|
|
|
|
|
key_replace_session_keyring();
|
2009-09-02 16:14:16 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|