1 /* $Id: signal.c,v 1.20 2004/01/13 05:52:11 kkojima Exp $
3 * linux/arch/sh/kernel/signal.c
5 * Copyright (C) 1991, 1992 Linus Torvalds
7 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
9 * SuperH version: Copyright (C) 1999, 2000 Niibe Yutaka & Kaz Kojima
13 #include <linux/sched.h>
15 #include <linux/smp.h>
16 #include <linux/smp_lock.h>
17 #include <linux/kernel.h>
18 #include <linux/signal.h>
19 #include <linux/errno.h>
20 #include <linux/wait.h>
21 #include <linux/ptrace.h>
22 #include <linux/unistd.h>
23 #include <linux/stddef.h>
24 #include <linux/tty.h>
25 #include <linux/personality.h>
26 #include <linux/binfmts.h>
27 #include <linux/suspend.h>
29 #include <asm/ucontext.h>
30 #include <asm/uaccess.h>
31 #include <asm/pgtable.h>
32 #include <asm/cacheflush.h>
36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
38 asmlinkage
int do_signal(struct pt_regs
*regs
, sigset_t
*oldset
);
41 * Atomically swap in the new signal mask, and wait for a signal.
44 sys_sigsuspend(old_sigset_t mask
,
45 unsigned long r5
, unsigned long r6
, unsigned long r7
,
51 spin_lock_irq(¤t
->sighand
->siglock
);
52 saveset
= current
->blocked
;
53 siginitset(¤t
->blocked
, mask
);
55 spin_unlock_irq(¤t
->sighand
->siglock
);
57 regs
.regs
[0] = -EINTR
;
59 current
->state
= TASK_INTERRUPTIBLE
;
61 if (do_signal(®s
, &saveset
))
67 sys_rt_sigsuspend(sigset_t
*unewset
, size_t sigsetsize
,
68 unsigned long r6
, unsigned long r7
,
71 sigset_t saveset
, newset
;
73 /* XXX: Don't preclude handling different sized sigset_t's. */
74 if (sigsetsize
!= sizeof(sigset_t
))
77 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
79 sigdelsetmask(&newset
, ~_BLOCKABLE
);
80 spin_lock_irq(¤t
->sighand
->siglock
);
81 saveset
= current
->blocked
;
82 current
->blocked
= newset
;
84 spin_unlock_irq(¤t
->sighand
->siglock
);
86 regs
.regs
[0] = -EINTR
;
88 current
->state
= TASK_INTERRUPTIBLE
;
90 if (do_signal(®s
, &saveset
))
96 sys_sigaction(int sig
, const struct old_sigaction __user
*act
,
97 struct old_sigaction __user
*oact
)
99 struct k_sigaction new_ka
, old_ka
;
104 if (verify_area(VERIFY_READ
, act
, sizeof(*act
)) ||
105 __get_user(new_ka
.sa
.sa_handler
, &act
->sa_handler
) ||
106 __get_user(new_ka
.sa
.sa_restorer
, &act
->sa_restorer
))
108 __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
109 __get_user(mask
, &act
->sa_mask
);
110 siginitset(&new_ka
.sa
.sa_mask
, mask
);
113 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
116 if (verify_area(VERIFY_WRITE
, oact
, sizeof(*oact
)) ||
117 __put_user(old_ka
.sa
.sa_handler
, &oact
->sa_handler
) ||
118 __put_user(old_ka
.sa
.sa_restorer
, &oact
->sa_restorer
))
120 __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
121 __put_user(old_ka
.sa
.sa_mask
.sig
[0], &oact
->sa_mask
);
128 sys_sigaltstack(const stack_t __user
*uss
, stack_t __user
*uoss
,
129 unsigned long r6
, unsigned long r7
,
132 return do_sigaltstack(uss
, uoss
, regs
.regs
[15]);
137 * Do a signal return; undo the signal stack.
140 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
141 #define TRAP16 0xc310 /* Syscall w/no args (NR in R3) */
142 #define OR_R0_R0 0x200b /* or r0,r0 (insert to avoid hardware bug) */
146 struct sigcontext sc
;
147 unsigned long extramask
[_NSIG_WORDS
-1];
158 #ifdef CONFIG_CPU_SH4
159 static inline int restore_sigcontext_fpu(struct sigcontext __user
*sc
)
161 struct task_struct
*tsk
= current
;
163 if (!(cpu_data
->flags
& CPU_HAS_FPU
))
167 return __copy_from_user(&tsk
->thread
.fpu
.hard
, &sc
->sc_fpregs
[0],
168 sizeof(long)*(16*2+2));
171 static inline int save_sigcontext_fpu(struct sigcontext __user
*sc
,
172 struct pt_regs
*regs
)
174 struct task_struct
*tsk
= current
;
176 if (!(cpu_data
->flags
& CPU_HAS_FPU
))
179 if (!tsk
->used_math
) {
180 __put_user(0, &sc
->sc_ownedfp
);
184 __put_user(1, &sc
->sc_ownedfp
);
186 /* This will cause a "finit" to be triggered by the next
187 attempted FPU operation by the 'current' process.
191 unlazy_fpu(tsk
, regs
);
192 return __copy_to_user(&sc
->sc_fpregs
[0], &tsk
->thread
.fpu
.hard
,
193 sizeof(long)*(16*2+2));
195 #endif /* CONFIG_CPU_SH4 */
198 restore_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
, int *r0_p
)
200 unsigned int err
= 0;
202 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
204 COPY(regs
[2]); COPY(regs
[3]);
205 COPY(regs
[4]); COPY(regs
[5]);
206 COPY(regs
[6]); COPY(regs
[7]);
207 COPY(regs
[8]); COPY(regs
[9]);
208 COPY(regs
[10]); COPY(regs
[11]);
209 COPY(regs
[12]); COPY(regs
[13]);
210 COPY(regs
[14]); COPY(regs
[15]);
211 COPY(gbr
); COPY(mach
);
212 COPY(macl
); COPY(pr
);
216 #ifdef CONFIG_CPU_SH4
217 if (cpu_data
->flags
& CPU_HAS_FPU
) {
219 struct task_struct
*tsk
= current
;
221 regs
->sr
|= SR_FD
; /* Release FPU */
222 clear_fpu(tsk
, regs
);
224 __get_user (owned_fp
, &sc
->sc_ownedfp
);
226 err
|= restore_sigcontext_fpu(sc
);
230 regs
->tra
= -1; /* disable syscall checks */
231 err
|= __get_user(*r0_p
, &sc
->sc_regs
[0]);
235 asmlinkage
int sys_sigreturn(unsigned long r4
, unsigned long r5
,
236 unsigned long r6
, unsigned long r7
,
239 struct sigframe __user
*frame
= (struct sigframe __user
*)regs
.regs
[15];
243 if (verify_area(VERIFY_READ
, frame
, sizeof(*frame
)))
246 if (__get_user(set
.sig
[0], &frame
->sc
.oldmask
)
248 && __copy_from_user(&set
.sig
[1], &frame
->extramask
,
249 sizeof(frame
->extramask
))))
252 sigdelsetmask(&set
, ~_BLOCKABLE
);
254 spin_lock_irq(¤t
->sighand
->siglock
);
255 current
->blocked
= set
;
257 spin_unlock_irq(¤t
->sighand
->siglock
);
259 if (restore_sigcontext(®s
, &frame
->sc
, &r0
))
264 force_sig(SIGSEGV
, current
);
268 asmlinkage
int sys_rt_sigreturn(unsigned long r4
, unsigned long r5
,
269 unsigned long r6
, unsigned long r7
,
272 struct rt_sigframe __user
*frame
= (struct rt_sigframe __user
*)regs
.regs
[15];
277 if (verify_area(VERIFY_READ
, frame
, sizeof(*frame
)))
280 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
283 sigdelsetmask(&set
, ~_BLOCKABLE
);
284 spin_lock_irq(¤t
->sighand
->siglock
);
285 current
->blocked
= set
;
287 spin_unlock_irq(¤t
->sighand
->siglock
);
289 if (restore_sigcontext(®s
, &frame
->uc
.uc_mcontext
, &r0
))
292 if (__copy_from_user(&st
, &frame
->uc
.uc_stack
, sizeof(st
)))
294 /* It is more difficult to avoid calling this function than to
295 call it and ignore errors. */
296 do_sigaltstack(&st
, NULL
, regs
.regs
[15]);
301 force_sig(SIGSEGV
, current
);
306 * Set up a signal frame.
310 setup_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
,
315 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
316 COPY(regs
[0]); COPY(regs
[1]);
317 COPY(regs
[2]); COPY(regs
[3]);
318 COPY(regs
[4]); COPY(regs
[5]);
319 COPY(regs
[6]); COPY(regs
[7]);
320 COPY(regs
[8]); COPY(regs
[9]);
321 COPY(regs
[10]); COPY(regs
[11]);
322 COPY(regs
[12]); COPY(regs
[13]);
323 COPY(regs
[14]); COPY(regs
[15]);
324 COPY(gbr
); COPY(mach
);
325 COPY(macl
); COPY(pr
);
329 #ifdef CONFIG_CPU_SH4
330 err
|= save_sigcontext_fpu(sc
, regs
);
333 /* non-iBCS2 extensions.. */
334 err
|= __put_user(mask
, &sc
->oldmask
);
340 * Determine which stack to use..
342 static inline void __user
*
343 get_sigframe(struct k_sigaction
*ka
, unsigned long sp
, size_t frame_size
)
345 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) != 0 && ! on_sig_stack(sp
))
346 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
348 return (void __user
*)((sp
- frame_size
) & -8ul);
351 static void setup_frame(int sig
, struct k_sigaction
*ka
,
352 sigset_t
*set
, struct pt_regs
*regs
)
354 struct sigframe __user
*frame
;
358 frame
= get_sigframe(ka
, regs
->regs
[15], sizeof(*frame
));
360 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
363 signal
= current_thread_info()->exec_domain
364 && current_thread_info()->exec_domain
->signal_invmap
366 ? current_thread_info()->exec_domain
->signal_invmap
[sig
]
369 err
|= setup_sigcontext(&frame
->sc
, regs
, set
->sig
[0]);
371 if (_NSIG_WORDS
> 1) {
372 err
|= __copy_to_user(frame
->extramask
, &set
->sig
[1],
373 sizeof(frame
->extramask
));
376 /* Set up to return from userspace. If provided, use a stub
377 already in userspace. */
378 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
379 regs
->pr
= (unsigned long) ka
->sa
.sa_restorer
;
381 /* Generate return code (system call to sigreturn) */
382 err
|= __put_user(MOVW(7), &frame
->retcode
[0]);
383 err
|= __put_user(TRAP16
, &frame
->retcode
[1]);
384 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[2]);
385 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[3]);
386 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[4]);
387 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[5]);
388 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[6]);
389 err
|= __put_user((__NR_sigreturn
), &frame
->retcode
[7]);
390 regs
->pr
= (unsigned long) frame
->retcode
;
396 /* Set up registers for signal handler */
397 regs
->regs
[15] = (unsigned long) frame
;
398 regs
->regs
[4] = signal
; /* Arg for signal handler */
400 regs
->regs
[6] = (unsigned long) &frame
->sc
;
401 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
406 printk("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
407 current
->comm
, current
->pid
, frame
, regs
->pc
, regs
->pr
);
410 flush_cache_sigtramp(regs
->pr
);
411 if ((-regs
->pr
& (L1_CACHE_BYTES
-1)) < sizeof(frame
->retcode
))
412 flush_cache_sigtramp(regs
->pr
+ L1_CACHE_BYTES
);
416 force_sigsegv(sig
, current
);
419 static void setup_rt_frame(int sig
, struct k_sigaction
*ka
, siginfo_t
*info
,
420 sigset_t
*set
, struct pt_regs
*regs
)
422 struct rt_sigframe __user
*frame
;
426 frame
= get_sigframe(ka
, regs
->regs
[15], sizeof(*frame
));
428 if (!access_ok(VERIFY_WRITE
, frame
, sizeof(*frame
)))
431 signal
= current_thread_info()->exec_domain
432 && current_thread_info()->exec_domain
->signal_invmap
434 ? current_thread_info()->exec_domain
->signal_invmap
[sig
]
437 err
|= copy_siginfo_to_user(&frame
->info
, info
);
439 /* Create the ucontext. */
440 err
|= __put_user(0, &frame
->uc
.uc_flags
);
441 err
|= __put_user(0, &frame
->uc
.uc_link
);
442 err
|= __put_user((void *)current
->sas_ss_sp
,
443 &frame
->uc
.uc_stack
.ss_sp
);
444 err
|= __put_user(sas_ss_flags(regs
->regs
[15]),
445 &frame
->uc
.uc_stack
.ss_flags
);
446 err
|= __put_user(current
->sas_ss_size
, &frame
->uc
.uc_stack
.ss_size
);
447 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
,
449 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
451 /* Set up to return from userspace. If provided, use a stub
452 already in userspace. */
453 if (ka
->sa
.sa_flags
& SA_RESTORER
) {
454 regs
->pr
= (unsigned long) ka
->sa
.sa_restorer
;
456 /* Generate return code (system call to rt_sigreturn) */
457 err
|= __put_user(MOVW(7), &frame
->retcode
[0]);
458 err
|= __put_user(TRAP16
, &frame
->retcode
[1]);
459 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[2]);
460 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[3]);
461 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[4]);
462 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[5]);
463 err
|= __put_user(OR_R0_R0
, &frame
->retcode
[6]);
464 err
|= __put_user((__NR_rt_sigreturn
), &frame
->retcode
[7]);
465 regs
->pr
= (unsigned long) frame
->retcode
;
471 /* Set up registers for signal handler */
472 regs
->regs
[15] = (unsigned long) frame
;
473 regs
->regs
[4] = signal
; /* Arg for signal handler */
474 regs
->regs
[5] = (unsigned long) &frame
->info
;
475 regs
->regs
[6] = (unsigned long) &frame
->uc
;
476 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
481 printk("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
482 current
->comm
, current
->pid
, frame
, regs
->pc
, regs
->pr
);
485 flush_cache_sigtramp(regs
->pr
);
486 if ((-regs
->pr
& (L1_CACHE_BYTES
-1)) < sizeof(frame
->retcode
))
487 flush_cache_sigtramp(regs
->pr
+ L1_CACHE_BYTES
);
491 force_sigsegv(sig
, current
);
495 * OK, we're invoking a handler
499 handle_signal(unsigned long sig
, siginfo_t
*info
, sigset_t
*oldset
,
500 struct pt_regs
* regs
)
502 struct k_sigaction
*ka
= ¤t
->sighand
->action
[sig
-1];
504 /* Are we from a system call? */
505 if (regs
->tra
>= 0) {
506 /* If so, check system call restarting.. */
507 switch (regs
->regs
[0]) {
508 case -ERESTARTNOHAND
:
509 regs
->regs
[0] = -EINTR
;
513 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
514 regs
->regs
[0] = -EINTR
;
518 case -ERESTARTNOINTR
:
523 #ifdef CONFIG_PREEMPT
526 local_irq_save(flags
);
528 if (regs
->regs
[15] >= 0xc0000000) {
529 int offset
= (int)regs
->regs
[15];
531 /* Reset stack pointer: clear critical region mark */
532 regs
->regs
[15] = regs
->regs
[1];
533 if (regs
->pc
< regs
->regs
[0])
534 /* Go to rewind point #1 */
535 regs
->pc
= regs
->regs
[0] + offset
- 2;
537 #ifdef CONFIG_PREEMPT
538 local_irq_restore(flags
);
542 /* Set up the stack frame */
543 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
544 setup_rt_frame(sig
, ka
, info
, oldset
, regs
);
546 setup_frame(sig
, ka
, oldset
, regs
);
548 if (ka
->sa
.sa_flags
& SA_ONESHOT
)
549 ka
->sa
.sa_handler
= SIG_DFL
;
551 if (!(ka
->sa
.sa_flags
& SA_NODEFER
)) {
552 spin_lock_irq(¤t
->sighand
->siglock
);
553 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
554 sigaddset(¤t
->blocked
,sig
);
556 spin_unlock_irq(¤t
->sighand
->siglock
);
561 * Note that 'init' is a special process: it doesn't get signals it doesn't
562 * want to handle. Thus you cannot kill init even with a SIGKILL even by
565 * Note that we go through the signals twice: once to check the signals that
566 * the kernel can handle, and then we build all the user-level signal handling
567 * stack-frames in one go after that.
569 int do_signal(struct pt_regs
*regs
, sigset_t
*oldset
)
575 * We want the common case to go fast, which
576 * is why we may in certain cases get here from
577 * kernel mode. Just return without doing anything
580 if (!user_mode(regs
))
583 if (current
->flags
& PF_FREEZE
) {
589 oldset
= ¤t
->blocked
;
591 signr
= get_signal_to_deliver(&info
, regs
, NULL
);
593 /* Whee! Actually deliver the signal. */
594 handle_signal(signr
, &info
, oldset
, regs
);
599 /* Did we come from a system call? */
600 if (regs
->tra
>= 0) {
601 /* Restart the system call - no handlers present */
602 if (regs
->regs
[0] == -ERESTARTNOHAND
||
603 regs
->regs
[0] == -ERESTARTSYS
||
604 regs
->regs
[0] == -ERESTARTNOINTR
||
605 regs
->regs
[0] == -ERESTART_RESTARTBLOCK
) {