2
* linux/arch/m32r/kernel/signal.c
4
* Copyright (c) 2003 Hitoshi Yamamoto
6
* Taken from i386 version.
7
* Copyright (C) 1991, 1992 Linus Torvalds
9
* 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
10
* 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
13
#include <linux/sched.h>
15
#include <linux/smp.h>
16
#include <linux/kernel.h>
17
#include <linux/signal.h>
18
#include <linux/errno.h>
19
#include <linux/wait.h>
20
#include <linux/unistd.h>
21
#include <linux/stddef.h>
22
#include <linux/personality.h>
23
#include <linux/freezer.h>
24
#include <linux/tracehook.h>
25
#include <asm/cacheflush.h>
26
#include <asm/ucontext.h>
27
#include <asm/uaccess.h>
31
#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
34
sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
35
unsigned long r2, unsigned long r3, unsigned long r4,
36
unsigned long r5, unsigned long r6, struct pt_regs *regs)
38
return do_sigaltstack(uss, uoss, regs->spu);
43
* Do a signal return; undo the signal stack.
49
struct siginfo __user *pinfo;
53
// struct _fpstate fpstate;
57
restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc,
62
/* Always make any pending restarted system calls return -EINTR */
63
current_thread_info()->restart_block.fn = do_no_restart_syscall;
65
#define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
70
/* COPY(r0); Skip r0 */
82
COPY(acc1h); /* ISA_DSP_LEVEL2 only */
83
COPY(acc1l); /* ISA_DSP_LEVEL2 only */
94
regs->syscall_nr = -1; /* disable syscall checks */
95
err |= __get_user(*r0_p, &sc->sc_r0);
101
sys_rt_sigreturn(unsigned long r0, unsigned long r1,
102
unsigned long r2, unsigned long r3, unsigned long r4,
103
unsigned long r5, unsigned long r6, struct pt_regs *regs)
105
struct rt_sigframe __user *frame = (struct rt_sigframe __user *)regs->spu;
109
if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
111
if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
114
sigdelsetmask(&set, ~_BLOCKABLE);
115
spin_lock_irq(¤t->sighand->siglock);
116
current->blocked = set;
118
spin_unlock_irq(¤t->sighand->siglock);
120
if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &result))
123
if (do_sigaltstack(&frame->uc.uc_stack, NULL, regs->spu) == -EFAULT)
129
force_sig(SIGSEGV, current);
134
* Set up a signal frame.
138
setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
143
#define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
160
COPY(acc1h); /* ISA_DSP_LEVEL2 only */
161
COPY(acc1l); /* ISA_DSP_LEVEL2 only */
172
err |= __put_user(mask, &sc->oldmask);
178
* Determine which stack to use..
180
static inline void __user *
181
get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
183
/* This is the X/Open sanctioned signal stack switching. */
184
if (ka->sa.sa_flags & SA_ONSTACK) {
185
if (sas_ss_flags(sp) == 0)
186
sp = current->sas_ss_sp + current->sas_ss_size;
189
return (void __user *)((sp - frame_size) & -8ul);
192
static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
193
sigset_t *set, struct pt_regs *regs)
195
struct rt_sigframe __user *frame;
199
frame = get_sigframe(ka, regs->spu, sizeof(*frame));
201
if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
204
signal = current_thread_info()->exec_domain
205
&& current_thread_info()->exec_domain->signal_invmap
207
? current_thread_info()->exec_domain->signal_invmap[sig]
210
err |= __put_user(signal, &frame->sig);
214
err |= __put_user(&frame->info, &frame->pinfo);
215
err |= __put_user(&frame->uc, &frame->puc);
216
err |= copy_siginfo_to_user(&frame->info, info);
220
/* Create the ucontext. */
221
err |= __put_user(0, &frame->uc.uc_flags);
222
err |= __put_user(0, &frame->uc.uc_link);
223
err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
224
err |= __put_user(sas_ss_flags(regs->spu),
225
&frame->uc.uc_stack.ss_flags);
226
err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
227
err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
228
err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
232
/* Set up to return from userspace. */
233
regs->lr = (unsigned long)ka->sa.sa_restorer;
235
/* Set up registers for signal handler */
236
regs->spu = (unsigned long)frame;
237
regs->r0 = signal; /* Arg for signal handler */
238
regs->r1 = (unsigned long)&frame->info;
239
regs->r2 = (unsigned long)&frame->uc;
240
regs->bpc = (unsigned long)ka->sa.sa_handler;
245
printk("SIG deliver (%s:%d): sp=%p pc=%p\n",
246
current->comm, current->pid, frame, regs->pc);
252
force_sigsegv(sig, current);
256
static int prev_insn(struct pt_regs *regs)
259
if (get_user(inst, (u16 __user *)(regs->bpc - 2)))
261
if ((inst & 0xfff0) == 0x10f0) /* trap ? */
265
regs->syscall_nr = -1;
270
* OK, we're invoking a handler
274
handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
275
sigset_t *oldset, struct pt_regs *regs)
277
/* Are we from a system call? */
278
if (regs->syscall_nr >= 0) {
279
/* If so, check system call restarting.. */
281
case -ERESTART_RESTARTBLOCK:
282
case -ERESTARTNOHAND:
287
if (!(ka->sa.sa_flags & SA_RESTART)) {
292
case -ERESTARTNOINTR:
293
regs->r0 = regs->orig_r0;
294
if (prev_insn(regs) < 0)
299
/* Set up the stack frame */
300
if (setup_rt_frame(sig, ka, info, oldset, regs))
303
spin_lock_irq(¤t->sighand->siglock);
304
sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
305
if (!(ka->sa.sa_flags & SA_NODEFER))
306
sigaddset(¤t->blocked,sig);
308
spin_unlock_irq(¤t->sighand->siglock);
313
* Note that 'init' is a special process: it doesn't get signals it doesn't
314
* want to handle. Thus you cannot kill init even with a SIGKILL even by
317
static void do_signal(struct pt_regs *regs)
321
struct k_sigaction ka;
325
* We want the common case to go fast, which
326
* is why we may in certain cases get here from
327
* kernel mode. Just return without doing anything
330
if (!user_mode(regs))
336
if (test_thread_flag(TIF_RESTORE_SIGMASK))
337
oldset = ¤t->saved_sigmask;
339
oldset = ¤t->blocked;
341
signr = get_signal_to_deliver(&info, &ka, regs, NULL);
343
/* Re-enable any watchpoints before delivering the
344
* signal to user space. The processor register will
345
* have been cleared if the watchpoint triggered
349
/* Whee! Actually deliver the signal. */
350
if (handle_signal(signr, &ka, &info, oldset, regs) == 0)
351
clear_thread_flag(TIF_RESTORE_SIGMASK);
357
/* Did we come from a system call? */
358
if (regs->syscall_nr >= 0) {
359
/* Restart the system call - no handlers present */
360
if (regs->r0 == -ERESTARTNOHAND ||
361
regs->r0 == -ERESTARTSYS ||
362
regs->r0 == -ERESTARTNOINTR) {
363
regs->r0 = regs->orig_r0;
365
} else if (regs->r0 == -ERESTART_RESTARTBLOCK){
366
regs->r0 = regs->orig_r0;
367
regs->r7 = __NR_restart_syscall;
371
if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
372
clear_thread_flag(TIF_RESTORE_SIGMASK);
373
sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
378
* notification of userspace execution resumption
379
* - triggered by current->work.notify_resume
381
void do_notify_resume(struct pt_regs *regs, __u32 thread_info_flags)
383
/* Pending single-step? */
384
if (thread_info_flags & _TIF_SINGLESTEP)
385
clear_thread_flag(TIF_SINGLESTEP);
387
/* deal with pending signal delivery */
388
if (thread_info_flags & _TIF_SIGPENDING)
391
if (thread_info_flags & _TIF_NOTIFY_RESUME) {
392
clear_thread_flag(TIF_NOTIFY_RESUME);
393
tracehook_notify_resume(regs);
394
if (current->replacement_session_keyring)
395
key_replace_session_keyring();
398
clear_thread_flag(TIF_IRET);