2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* arch/s390/kernel/signal.c
|
|
|
|
*
|
2006-02-01 11:06:38 +00:00
|
|
|
* Copyright (C) IBM Corp. 1999,2006
|
2005-04-16 22:20:36 +00:00
|
|
|
* Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
|
|
|
|
*
|
|
|
|
* Based on Intel version
|
|
|
|
*
|
|
|
|
* Copyright (C) 1991, 1992 Linus Torvalds
|
|
|
|
*
|
|
|
|
* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/unistd.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/personality.h>
|
|
|
|
#include <linux/binfmts.h>
|
2008-10-10 19:33:20 +00:00
|
|
|
#include <linux/tracehook.h>
|
2009-01-14 13:14:36 +00:00
|
|
|
#include <linux/syscalls.h>
|
2009-06-12 08:26:25 +00:00
|
|
|
#include <linux/compat.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/ucontext.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/lowcore.h>
|
2008-04-17 05:46:26 +00:00
|
|
|
#include "entry.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
|
|
|
|
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
|
|
|
|
struct sigcontext sc;
|
|
|
|
_sigregs sregs;
|
|
|
|
int signo;
|
|
|
|
__u8 retcode[S390_SYSCALL_SIZE];
|
|
|
|
} sigframe;
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
__u8 callee_used_stack[__SIGNAL_FRAMESIZE];
|
|
|
|
__u8 retcode[S390_SYSCALL_SIZE];
|
|
|
|
struct siginfo info;
|
|
|
|
struct ucontext uc;
|
|
|
|
} rt_sigframe;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Atomically swap in the new signal mask, and wait for a signal.
|
|
|
|
*/
|
2009-01-14 13:14:36 +00:00
|
|
|
SYSCALL_DEFINE3(sigsuspend, int, history0, int, history1, old_sigset_t, mask)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-08-03 14:44:26 +00:00
|
|
|
sigset_t blocked;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2011-08-03 14:44:26 +00:00
|
|
|
current->saved_sigmask = current->blocked;
|
|
|
|
mask &= _BLOCKABLE;
|
|
|
|
siginitset(&blocked, mask);
|
|
|
|
set_current_blocked(&blocked);
|
2010-01-27 09:12:37 +00:00
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
2006-02-01 11:06:38 +00:00
|
|
|
schedule();
|
2011-08-03 14:44:32 +00:00
|
|
|
set_restore_sigmask();
|
2006-02-01 11:06:38 +00:00
|
|
|
return -ERESTARTNOHAND;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 13:14:36 +00:00
|
|
|
SYSCALL_DEFINE3(sigaction, int, sig, const struct old_sigaction __user *, act,
|
|
|
|
struct old_sigaction __user *, oact)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
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) ||
|
2006-10-27 10:39:22 +00:00
|
|
|
__get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
|
|
|
|
__get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
|
|
|
|
__get_user(mask, &act->sa_mask))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
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) ||
|
2006-10-27 10:39:22 +00:00
|
|
|
__put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
|
|
|
|
__put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
|
|
|
|
__put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
|
2005-04-16 22:20:36 +00:00
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-01-14 13:14:36 +00:00
|
|
|
SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss,
|
|
|
|
stack_t __user *, uoss)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-04-27 14:01:40 +00:00
|
|
|
struct pt_regs *regs = task_pt_regs(current);
|
2005-04-16 22:20:36 +00:00
|
|
|
return do_sigaltstack(uss, uoss, regs->gprs[15]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns non-zero on fault. */
|
|
|
|
static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
|
|
|
|
{
|
2006-09-20 13:59:39 +00:00
|
|
|
_sigregs user_sregs;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
save_access_regs(current->thread.acrs);
|
|
|
|
|
|
|
|
/* Copy a 'clean' PSW mask to the user to avoid leaking
|
|
|
|
information about whether PER is currently on. */
|
2011-10-30 14:16:51 +00:00
|
|
|
user_sregs.regs.psw.mask = psw_user_bits |
|
|
|
|
(regs->psw.mask & PSW_MASK_USER);
|
2006-10-04 18:01:58 +00:00
|
|
|
user_sregs.regs.psw.addr = regs->psw.addr;
|
|
|
|
memcpy(&user_sregs.regs.gprs, ®s->gprs, sizeof(sregs->regs.gprs));
|
2006-09-20 13:59:39 +00:00
|
|
|
memcpy(&user_sregs.regs.acrs, current->thread.acrs,
|
|
|
|
sizeof(sregs->regs.acrs));
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* We have to store the fp registers to current->thread.fp_regs
|
|
|
|
* to merge them with the emulated registers.
|
|
|
|
*/
|
|
|
|
save_fp_regs(¤t->thread.fp_regs);
|
2006-09-20 13:59:39 +00:00
|
|
|
memcpy(&user_sregs.fpregs, ¤t->thread.fp_regs,
|
|
|
|
sizeof(s390_fp_regs));
|
|
|
|
return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Returns positive number on error */
|
|
|
|
static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
|
|
|
|
{
|
|
|
|
int err;
|
2006-09-20 13:59:39 +00:00
|
|
|
_sigregs user_sregs;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Alwys make any pending restarted system call return -EINTR */
|
|
|
|
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
|
|
|
|
2006-09-20 13:59:39 +00:00
|
|
|
err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
|
2005-04-16 22:20:36 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
2011-10-30 14:16:51 +00:00
|
|
|
/* Use regs->psw.mask instead of psw_user_bits to preserve PER bit. */
|
2011-10-30 14:16:50 +00:00
|
|
|
regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
|
2011-10-30 14:16:51 +00:00
|
|
|
(user_sregs.regs.psw.mask & PSW_MASK_USER);
|
|
|
|
/* Check for invalid amode */
|
|
|
|
if (regs->psw.mask & PSW_MASK_EA)
|
|
|
|
regs->psw.mask |= PSW_MASK_BA;
|
|
|
|
regs->psw.addr = user_sregs.regs.psw.addr;
|
2006-10-04 18:01:58 +00:00
|
|
|
memcpy(®s->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
|
2006-09-20 13:59:39 +00:00
|
|
|
memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
|
|
|
|
sizeof(sregs->regs.acrs));
|
2005-04-16 22:20:36 +00:00
|
|
|
restore_access_regs(current->thread.acrs);
|
|
|
|
|
2006-09-20 13:59:39 +00:00
|
|
|
memcpy(¤t->thread.fp_regs, &user_sregs.fpregs,
|
|
|
|
sizeof(s390_fp_regs));
|
2005-04-16 22:20:36 +00:00
|
|
|
current->thread.fp_regs.fpc &= FPC_VALID_MASK;
|
|
|
|
|
|
|
|
restore_fp_regs(¤t->thread.fp_regs);
|
2011-10-30 14:16:49 +00:00
|
|
|
clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-14 13:14:36 +00:00
|
|
|
SYSCALL_DEFINE0(sigreturn)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-04-27 14:01:40 +00:00
|
|
|
struct pt_regs *regs = task_pt_regs(current);
|
2005-04-16 22:20:36 +00:00
|
|
|
sigframe __user *frame = (sigframe __user *)regs->gprs[15];
|
|
|
|
sigset_t set;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
|
|
|
|
goto badframe;
|
|
|
|
if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
|
|
|
|
goto badframe;
|
|
|
|
sigdelsetmask(&set, ~_BLOCKABLE);
|
2011-08-03 14:44:26 +00:00
|
|
|
set_current_blocked(&set);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (restore_sigregs(regs, &frame->sregs))
|
|
|
|
goto badframe;
|
|
|
|
return regs->gprs[2];
|
|
|
|
badframe:
|
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-14 13:14:36 +00:00
|
|
|
SYSCALL_DEFINE0(rt_sigreturn)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-04-27 14:01:40 +00:00
|
|
|
struct pt_regs *regs = task_pt_regs(current);
|
2005-04-16 22:20:36 +00:00
|
|
|
rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
|
|
|
|
sigset_t set;
|
|
|
|
|
|
|
|
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
|
|
|
|
goto badframe;
|
|
|
|
if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
|
|
|
|
goto badframe;
|
|
|
|
sigdelsetmask(&set, ~_BLOCKABLE);
|
2011-08-03 14:44:26 +00:00
|
|
|
set_current_blocked(&set);
|
2005-04-16 22:20:36 +00:00
|
|
|
if (restore_sigregs(regs, &frame->uc.uc_mcontext))
|
|
|
|
goto badframe;
|
2006-01-06 08:19:10 +00:00
|
|
|
if (do_sigaltstack(&frame->uc.uc_stack, NULL,
|
|
|
|
regs->gprs[15]) == -EFAULT)
|
|
|
|
goto badframe;
|
2005-04-16 22:20:36 +00:00
|
|
|
return regs->gprs[2];
|
|
|
|
badframe:
|
|
|
|
force_sig(SIGSEGV, current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up a signal frame.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine which stack to use..
|
|
|
|
*/
|
|
|
|
static inline void __user *
|
|
|
|
get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
|
|
|
|
{
|
|
|
|
unsigned long sp;
|
|
|
|
|
|
|
|
/* Default to using normal stack */
|
|
|
|
sp = regs->gprs[15];
|
|
|
|
|
2008-04-17 05:45:57 +00:00
|
|
|
/* Overflow on alternate signal stack gives SIGSEGV. */
|
|
|
|
if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
|
|
|
|
return (void __user *) -1UL;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* This is the X/Open sanctioned signal stack switching. */
|
|
|
|
if (ka->sa.sa_flags & SA_ONSTACK) {
|
|
|
|
if (! sas_ss_flags(sp))
|
|
|
|
sp = current->sas_ss_sp + current->sas_ss_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is the legacy signal stack switching. */
|
|
|
|
else if (!user_mode(regs) &&
|
|
|
|
!(ka->sa.sa_flags & SA_RESTORER) &&
|
|
|
|
ka->sa.sa_restorer) {
|
|
|
|
sp = (unsigned long) ka->sa.sa_restorer;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (void __user *)((sp - frame_size) & -8ul);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int map_signal(int sig)
|
|
|
|
{
|
|
|
|
if (current_thread_info()->exec_domain
|
|
|
|
&& current_thread_info()->exec_domain->signal_invmap
|
|
|
|
&& sig < 32)
|
|
|
|
return current_thread_info()->exec_domain->signal_invmap[sig];
|
|
|
|
else
|
|
|
|
return sig;
|
|
|
|
}
|
|
|
|
|
2006-02-01 11:06:38 +00:00
|
|
|
static int setup_frame(int sig, struct k_sigaction *ka,
|
|
|
|
sigset_t *set, struct pt_regs * regs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
sigframe __user *frame;
|
|
|
|
|
|
|
|
frame = get_sigframe(ka, regs, sizeof(sigframe));
|
|
|
|
if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
2008-04-17 05:45:57 +00:00
|
|
|
if (frame == (void __user *) -1UL)
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
|
|
|
if (save_sigregs(regs, &frame->sregs))
|
|
|
|
goto give_sigsegv;
|
|
|
|
if (__put_user(&frame->sregs, &frame->sc.sregs))
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
|
|
|
/* Set up to return from userspace. If provided, use a stub
|
|
|
|
already in userspace. */
|
|
|
|
if (ka->sa.sa_flags & SA_RESTORER) {
|
|
|
|
regs->gprs[14] = (unsigned long)
|
|
|
|
ka->sa.sa_restorer | PSW_ADDR_AMODE;
|
|
|
|
} else {
|
|
|
|
regs->gprs[14] = (unsigned long)
|
|
|
|
frame->retcode | PSW_ADDR_AMODE;
|
|
|
|
if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
|
|
|
|
(u16 __user *)(frame->retcode)))
|
|
|
|
goto give_sigsegv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up backchain. */
|
|
|
|
if (__put_user(regs->gprs[15], (addr_t __user *) frame))
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
|
|
|
/* Set up registers for signal handler */
|
|
|
|
regs->gprs[15] = (unsigned long) frame;
|
2011-10-30 14:16:51 +00:00
|
|
|
regs->psw.mask |= PSW_MASK_EA | PSW_MASK_BA; /* 64 bit amode */
|
2005-04-16 22:20:36 +00:00
|
|
|
regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
|
|
|
|
|
|
|
|
regs->gprs[2] = map_signal(sig);
|
|
|
|
regs->gprs[3] = (unsigned long) &frame->sc;
|
|
|
|
|
|
|
|
/* We forgot to include these in the sigcontext.
|
|
|
|
To avoid breaking binary compatibility, they are passed as args. */
|
2011-12-27 10:27:18 +00:00
|
|
|
if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
|
|
|
|
sig == SIGTRAP || sig == SIGFPE) {
|
|
|
|
/* set extra registers only for synchronous signals */
|
|
|
|
regs->gprs[4] = regs->int_code & 127;
|
|
|
|
regs->gprs[5] = regs->int_parm_long;
|
|
|
|
regs->gprs[6] = task_thread_info(current)->last_break;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Place signal number on stack to allow backtrace from handler. */
|
|
|
|
if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
|
|
|
|
goto give_sigsegv;
|
2006-02-01 11:06:38 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
give_sigsegv:
|
|
|
|
force_sigsegv(sig, current);
|
2006-02-01 11:06:38 +00:00
|
|
|
return -EFAULT;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2006-02-01 11:06:38 +00:00
|
|
|
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
|
2005-04-16 22:20:36 +00:00
|
|
|
sigset_t *set, struct pt_regs * regs)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
rt_sigframe __user *frame;
|
|
|
|
|
|
|
|
frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
|
|
|
|
if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
2008-04-17 05:45:57 +00:00
|
|
|
if (frame == (void __user *) -1UL)
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
if (copy_siginfo_to_user(&frame->info, info))
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
|
|
|
/* Create the ucontext. */
|
|
|
|
err |= __put_user(0, &frame->uc.uc_flags);
|
2005-09-28 23:16:02 +00:00
|
|
|
err |= __put_user(NULL, &frame->uc.uc_link);
|
|
|
|
err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
|
2005-04-16 22:20:36 +00:00
|
|
|
err |= __put_user(sas_ss_flags(regs->gprs[15]),
|
|
|
|
&frame->uc.uc_stack.ss_flags);
|
|
|
|
err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
|
|
|
|
err |= save_sigregs(regs, &frame->uc.uc_mcontext);
|
|
|
|
err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
|
|
|
|
if (err)
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
|
|
|
/* Set up to return from userspace. If provided, use a stub
|
|
|
|
already in userspace. */
|
|
|
|
if (ka->sa.sa_flags & SA_RESTORER) {
|
|
|
|
regs->gprs[14] = (unsigned long)
|
|
|
|
ka->sa.sa_restorer | PSW_ADDR_AMODE;
|
|
|
|
} else {
|
|
|
|
regs->gprs[14] = (unsigned long)
|
|
|
|
frame->retcode | PSW_ADDR_AMODE;
|
2006-05-01 19:16:15 +00:00
|
|
|
if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
|
|
|
|
(u16 __user *)(frame->retcode)))
|
|
|
|
goto give_sigsegv;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up backchain. */
|
|
|
|
if (__put_user(regs->gprs[15], (addr_t __user *) frame))
|
|
|
|
goto give_sigsegv;
|
|
|
|
|
|
|
|
/* Set up registers for signal handler */
|
|
|
|
regs->gprs[15] = (unsigned long) frame;
|
2011-10-30 14:16:51 +00:00
|
|
|
regs->psw.mask |= PSW_MASK_EA | PSW_MASK_BA; /* 64 bit amode */
|
2005-04-16 22:20:36 +00:00
|
|
|
regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
|
|
|
|
|
|
|
|
regs->gprs[2] = map_signal(sig);
|
|
|
|
regs->gprs[3] = (unsigned long) &frame->info;
|
|
|
|
regs->gprs[4] = (unsigned long) &frame->uc;
|
2010-05-17 08:00:05 +00:00
|
|
|
regs->gprs[5] = task_thread_info(current)->last_break;
|
2006-02-01 11:06:38 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
give_sigsegv:
|
|
|
|
force_sigsegv(sig, current);
|
2006-02-01 11:06:38 +00:00
|
|
|
return -EFAULT;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2011-08-03 14:44:26 +00:00
|
|
|
static int handle_signal(unsigned long sig, struct k_sigaction *ka,
|
|
|
|
siginfo_t *info, sigset_t *oldset,
|
|
|
|
struct pt_regs *regs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2011-08-03 14:44:26 +00:00
|
|
|
sigset_t blocked;
|
2006-02-01 11:06:38 +00:00
|
|
|
int ret;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Set up the stack frame */
|
|
|
|
if (ka->sa.sa_flags & SA_SIGINFO)
|
2006-02-01 11:06:38 +00:00
|
|
|
ret = setup_rt_frame(sig, ka, info, oldset, regs);
|
2005-04-16 22:20:36 +00:00
|
|
|
else
|
2006-02-01 11:06:38 +00:00
|
|
|
ret = setup_frame(sig, ka, oldset, regs);
|
2011-08-03 14:44:26 +00:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
sigorsets(&blocked, ¤t->blocked, &ka->sa.sa_mask);
|
|
|
|
if (!(ka->sa.sa_flags & SA_NODEFER))
|
|
|
|
sigaddset(&blocked, sig);
|
|
|
|
set_current_blocked(&blocked);
|
|
|
|
return 0;
|
2005-04-16 22:20:36 +00: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.
|
|
|
|
*/
|
2006-02-01 11:06:38 +00:00
|
|
|
void do_signal(struct pt_regs *regs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
siginfo_t info;
|
|
|
|
int signr;
|
|
|
|
struct k_sigaction ka;
|
2006-02-01 11:06:38 +00:00
|
|
|
sigset_t *oldset;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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))
|
2006-02-01 11:06:38 +00:00
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-02-01 11:06:38 +00:00
|
|
|
if (test_thread_flag(TIF_RESTORE_SIGMASK))
|
|
|
|
oldset = ¤t->saved_sigmask;
|
|
|
|
else
|
2005-04-16 22:20:36 +00:00
|
|
|
oldset = ¤t->blocked;
|
|
|
|
|
2011-10-30 14:16:47 +00:00
|
|
|
/*
|
|
|
|
* Get signal to deliver. When running under ptrace, at this point
|
|
|
|
* the debugger may change all our registers, including the system
|
|
|
|
* call information.
|
|
|
|
*/
|
2011-10-30 14:16:49 +00:00
|
|
|
current_thread_info()->system_call =
|
2011-12-27 10:27:18 +00:00
|
|
|
test_thread_flag(TIF_SYSCALL) ? regs->int_code : 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
|
|
|
|
|
|
|
|
if (signr > 0) {
|
|
|
|
/* Whee! Actually deliver the signal. */
|
2011-10-30 14:16:49 +00:00
|
|
|
if (current_thread_info()->system_call) {
|
2011-12-27 10:27:18 +00:00
|
|
|
regs->int_code = current_thread_info()->system_call;
|
2011-10-30 14:16:47 +00:00
|
|
|
/* Check for system call restarting. */
|
|
|
|
switch (regs->gprs[2]) {
|
|
|
|
case -ERESTART_RESTARTBLOCK:
|
|
|
|
case -ERESTARTNOHAND:
|
|
|
|
regs->gprs[2] = -EINTR;
|
|
|
|
break;
|
|
|
|
case -ERESTARTSYS:
|
|
|
|
if (!(ka.sa.sa_flags & SA_RESTART)) {
|
|
|
|
regs->gprs[2] = -EINTR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fallthrough */
|
|
|
|
case -ERESTARTNOINTR:
|
|
|
|
regs->gprs[2] = regs->orig_gpr2;
|
2011-10-30 14:16:48 +00:00
|
|
|
regs->psw.addr =
|
|
|
|
__rewind_psw(regs->psw,
|
2011-12-27 10:27:18 +00:00
|
|
|
regs->int_code >> 16);
|
2011-10-30 14:16:47 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-12-01 12:32:15 +00:00
|
|
|
/* No longer in a system call */
|
|
|
|
clear_thread_flag(TIF_SYSCALL);
|
2011-10-30 14:16:47 +00:00
|
|
|
|
|
|
|
if ((is_compat_task() ?
|
|
|
|
handle_signal32(signr, &ka, &info, oldset, regs) :
|
|
|
|
handle_signal(signr, &ka, &info, oldset, regs)) == 0) {
|
2006-02-01 11:06:38 +00: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);
|
2008-01-26 13:11:22 +00:00
|
|
|
|
2008-10-10 19:33:20 +00:00
|
|
|
/*
|
|
|
|
* Let tracing know that we've done the handler setup.
|
|
|
|
*/
|
|
|
|
tracehook_signal_handler(signr, &info, &ka, regs,
|
2011-10-30 14:16:47 +00:00
|
|
|
test_thread_flag(TIF_SINGLE_STEP));
|
2006-02-01 11:06:38 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-10-30 14:16:47 +00:00
|
|
|
/* No handlers present - check for system call restart */
|
2011-12-01 12:32:15 +00:00
|
|
|
clear_thread_flag(TIF_SYSCALL);
|
2011-10-30 14:16:49 +00:00
|
|
|
if (current_thread_info()->system_call) {
|
2011-12-27 10:27:18 +00:00
|
|
|
regs->int_code = current_thread_info()->system_call;
|
2011-10-30 14:16:47 +00:00
|
|
|
switch (regs->gprs[2]) {
|
|
|
|
case -ERESTART_RESTARTBLOCK:
|
|
|
|
/* Restart with sys_restart_syscall */
|
2011-12-27 10:27:18 +00:00
|
|
|
regs->int_code = __NR_restart_syscall;
|
2011-10-30 14:16:47 +00:00
|
|
|
/* fallthrough */
|
|
|
|
case -ERESTARTNOHAND:
|
|
|
|
case -ERESTARTSYS:
|
|
|
|
case -ERESTARTNOINTR:
|
|
|
|
/* Restart system call with magic TIF bit. */
|
|
|
|
regs->gprs[2] = regs->orig_gpr2;
|
2011-10-30 14:16:49 +00:00
|
|
|
set_thread_flag(TIF_SYSCALL);
|
|
|
|
break;
|
2011-10-30 14:16:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-01 11:06:38 +00: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-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
2008-10-10 19:33:20 +00:00
|
|
|
|
|
|
|
void do_notify_resume(struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
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 08:14:21 +00:00
|
|
|
if (current->replacement_session_keyring)
|
|
|
|
key_replace_session_keyring();
|
2008-10-10 19:33:20 +00:00
|
|
|
}
|