2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 2000 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
10 #include <linux/cache.h>
11 #include <linux/irqflags.h>
12 #include <linux/sched.h>
14 #include <linux/personality.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/ptrace.h>
21 #include <linux/unistd.h>
22 #include <linux/compiler.h>
23 #include <linux/syscalls.h>
24 #include <linux/uaccess.h>
25 #include <linux/tracehook.h>
29 #include <linux/bitops.h>
30 #include <asm/cacheflush.h>
33 #include <asm/ucontext.h>
34 #include <asm/cpu-features.h>
39 #include "signal-common.h"
41 static int (*save_fp_context
)(struct sigcontext __user
*sc
);
42 static int (*restore_fp_context
)(struct sigcontext __user
*sc
);
44 extern asmlinkage
int _save_fp_context(struct sigcontext __user
*sc
);
45 extern asmlinkage
int _restore_fp_context(struct sigcontext __user
*sc
);
47 extern asmlinkage
int fpu_emulator_save_context(struct sigcontext __user
*sc
);
48 extern asmlinkage
int fpu_emulator_restore_context(struct sigcontext __user
*sc
);
51 u32 sf_ass
[4]; /* argument save space for o32 */
52 u32 sf_pad
[2]; /* Was: signal trampoline */
53 struct sigcontext sf_sc
;
58 u32 rs_ass
[4]; /* argument save space for o32 */
59 u32 rs_pad
[2]; /* Was: signal trampoline */
60 struct siginfo rs_info
;
61 struct ucontext rs_uc
;
67 static int protected_save_fp_context(struct sigcontext __user
*sc
)
73 err
= save_fp_context(sc
); /* this might fail */
77 /* touch the sigcontext and try again */
78 err
= __put_user(0, &sc
->sc_fpregs
[0]) |
79 __put_user(0, &sc
->sc_fpregs
[31]) |
80 __put_user(0, &sc
->sc_fpc_csr
);
82 break; /* really bad sigcontext */
87 static int protected_restore_fp_context(struct sigcontext __user
*sc
)
89 int err
, tmp __maybe_unused
;
93 err
= restore_fp_context(sc
); /* this might fail */
97 /* touch the sigcontext and try again */
98 err
= __get_user(tmp
, &sc
->sc_fpregs
[0]) |
99 __get_user(tmp
, &sc
->sc_fpregs
[31]) |
100 __get_user(tmp
, &sc
->sc_fpc_csr
);
102 break; /* really bad sigcontext */
107 int setup_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
)
111 unsigned int used_math
;
113 err
|= __put_user(regs
->cp0_epc
, &sc
->sc_pc
);
115 err
|= __put_user(0, &sc
->sc_regs
[0]);
116 for (i
= 1; i
< 32; i
++)
117 err
|= __put_user(regs
->regs
[i
], &sc
->sc_regs
[i
]);
119 #ifdef CONFIG_CPU_HAS_SMARTMIPS
120 err
|= __put_user(regs
->acx
, &sc
->sc_acx
);
122 err
|= __put_user(regs
->hi
, &sc
->sc_mdhi
);
123 err
|= __put_user(regs
->lo
, &sc
->sc_mdlo
);
125 err
|= __put_user(mfhi1(), &sc
->sc_hi1
);
126 err
|= __put_user(mflo1(), &sc
->sc_lo1
);
127 err
|= __put_user(mfhi2(), &sc
->sc_hi2
);
128 err
|= __put_user(mflo2(), &sc
->sc_lo2
);
129 err
|= __put_user(mfhi3(), &sc
->sc_hi3
);
130 err
|= __put_user(mflo3(), &sc
->sc_lo3
);
131 err
|= __put_user(rddsp(DSP_MASK
), &sc
->sc_dsp
);
134 used_math
= !!used_math();
135 err
|= __put_user(used_math
, &sc
->sc_used_math
);
139 * Save FPU state to signal context. Signal handler
140 * will "inherit" current FPU state.
142 err
|= protected_save_fp_context(sc
);
147 int fpcsr_pending(unsigned int __user
*fpcsr
)
150 unsigned int csr
, enabled
;
152 err
= __get_user(csr
, fpcsr
);
153 enabled
= FPU_CSR_UNI_X
| ((csr
& FPU_CSR_ALL_E
) << 5);
155 * If the signal handler set some FPU exceptions, clear it and
160 err
|= __put_user(csr
, fpcsr
);
167 check_and_restore_fp_context(struct sigcontext __user
*sc
)
171 err
= sig
= fpcsr_pending(&sc
->sc_fpc_csr
);
174 err
|= protected_restore_fp_context(sc
);
178 int restore_sigcontext(struct pt_regs
*regs
, struct sigcontext __user
*sc
)
180 unsigned int used_math
;
185 /* Always make any pending restarted system calls return -EINTR */
186 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
188 err
|= __get_user(regs
->cp0_epc
, &sc
->sc_pc
);
190 #ifdef CONFIG_CPU_HAS_SMARTMIPS
191 err
|= __get_user(regs
->acx
, &sc
->sc_acx
);
193 err
|= __get_user(regs
->hi
, &sc
->sc_mdhi
);
194 err
|= __get_user(regs
->lo
, &sc
->sc_mdlo
);
196 err
|= __get_user(treg
, &sc
->sc_hi1
); mthi1(treg
);
197 err
|= __get_user(treg
, &sc
->sc_lo1
); mtlo1(treg
);
198 err
|= __get_user(treg
, &sc
->sc_hi2
); mthi2(treg
);
199 err
|= __get_user(treg
, &sc
->sc_lo2
); mtlo2(treg
);
200 err
|= __get_user(treg
, &sc
->sc_hi3
); mthi3(treg
);
201 err
|= __get_user(treg
, &sc
->sc_lo3
); mtlo3(treg
);
202 err
|= __get_user(treg
, &sc
->sc_dsp
); wrdsp(treg
, DSP_MASK
);
205 for (i
= 1; i
< 32; i
++)
206 err
|= __get_user(regs
->regs
[i
], &sc
->sc_regs
[i
]);
208 err
|= __get_user(used_math
, &sc
->sc_used_math
);
209 conditional_used_math(used_math
);
212 /* restore fpu context if we have used it before */
214 err
= check_and_restore_fp_context(sc
);
216 /* signal handler may have used FPU. Give it up. */
223 void __user
*get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
,
228 /* Default to using normal stack */
232 * FPU emulator may have it's own trampoline active just
233 * above the user stack, 16-bytes before the next lowest
234 * 16 byte boundary. Try to avoid trashing it.
238 /* This is the X/Open sanctioned signal stack switching. */
239 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) && (sas_ss_flags (sp
) == 0))
240 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
242 return (void __user
*)((sp
- frame_size
) & (ICACHE_REFILLS_WORKAROUND_WAR
? ~(cpu_icache_line_size()-1) : ALMASK
));
246 * Atomically swap in the new signal mask, and wait for a signal.
249 #ifdef CONFIG_TRAD_SIGNALS
250 asmlinkage
int sys_sigsuspend(nabi_no_regargs
struct pt_regs regs
)
253 sigset_t __user
*uset
;
255 uset
= (sigset_t __user
*) regs
.regs
[4];
256 if (copy_from_user(&newset
, uset
, sizeof(sigset_t
)))
258 sigdelsetmask(&newset
, ~_BLOCKABLE
);
260 current
->saved_sigmask
= current
->blocked
;
261 set_current_blocked(&newset
);
263 current
->state
= TASK_INTERRUPTIBLE
;
265 set_thread_flag(TIF_RESTORE_SIGMASK
);
266 return -ERESTARTNOHAND
;
270 asmlinkage
int sys_rt_sigsuspend(nabi_no_regargs
struct pt_regs regs
)
273 sigset_t __user
*unewset
;
276 /* XXX Don't preclude handling different sized sigset_t's. */
277 sigsetsize
= regs
.regs
[5];
278 if (sigsetsize
!= sizeof(sigset_t
))
281 unewset
= (sigset_t __user
*) regs
.regs
[4];
282 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
284 sigdelsetmask(&newset
, ~_BLOCKABLE
);
286 current
->saved_sigmask
= current
->blocked
;
287 set_current_blocked(&newset
);
289 current
->state
= TASK_INTERRUPTIBLE
;
291 set_thread_flag(TIF_RESTORE_SIGMASK
);
292 return -ERESTARTNOHAND
;
295 #ifdef CONFIG_TRAD_SIGNALS
296 SYSCALL_DEFINE3(sigaction
, int, sig
, const struct sigaction __user
*, act
,
297 struct sigaction __user
*, oact
)
299 struct k_sigaction new_ka
, old_ka
;
306 if (!access_ok(VERIFY_READ
, act
, sizeof(*act
)))
308 err
|= __get_user(new_ka
.sa
.sa_handler
, &act
->sa_handler
);
309 err
|= __get_user(new_ka
.sa
.sa_flags
, &act
->sa_flags
);
310 err
|= __get_user(mask
, &act
->sa_mask
.sig
[0]);
314 siginitset(&new_ka
.sa
.sa_mask
, mask
);
317 ret
= do_sigaction(sig
, act
? &new_ka
: NULL
, oact
? &old_ka
: NULL
);
320 if (!access_ok(VERIFY_WRITE
, oact
, sizeof(*oact
)))
322 err
|= __put_user(old_ka
.sa
.sa_flags
, &oact
->sa_flags
);
323 err
|= __put_user(old_ka
.sa
.sa_handler
, &oact
->sa_handler
);
324 err
|= __put_user(old_ka
.sa
.sa_mask
.sig
[0], oact
->sa_mask
.sig
);
325 err
|= __put_user(0, &oact
->sa_mask
.sig
[1]);
326 err
|= __put_user(0, &oact
->sa_mask
.sig
[2]);
327 err
|= __put_user(0, &oact
->sa_mask
.sig
[3]);
336 asmlinkage
int sys_sigaltstack(nabi_no_regargs
struct pt_regs regs
)
338 const stack_t __user
*uss
= (const stack_t __user
*) regs
.regs
[4];
339 stack_t __user
*uoss
= (stack_t __user
*) regs
.regs
[5];
340 unsigned long usp
= regs
.regs
[29];
342 return do_sigaltstack(uss
, uoss
, usp
);
345 #ifdef CONFIG_TRAD_SIGNALS
346 asmlinkage
void sys_sigreturn(nabi_no_regargs
struct pt_regs regs
)
348 struct sigframe __user
*frame
;
352 frame
= (struct sigframe __user
*) regs
.regs
[29];
353 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
355 if (__copy_from_user(&blocked
, &frame
->sf_mask
, sizeof(blocked
)))
358 sigdelsetmask(&blocked
, ~_BLOCKABLE
);
359 set_current_blocked(&blocked
);
361 sig
= restore_sigcontext(®s
, &frame
->sf_sc
);
365 force_sig(sig
, current
);
368 * Don't let your children do this ...
370 __asm__
__volatile__(
378 force_sig(SIGSEGV
, current
);
380 #endif /* CONFIG_TRAD_SIGNALS */
382 asmlinkage
void sys_rt_sigreturn(nabi_no_regargs
struct pt_regs regs
)
384 struct rt_sigframe __user
*frame
;
388 frame
= (struct rt_sigframe __user
*) regs
.regs
[29];
389 if (!access_ok(VERIFY_READ
, frame
, sizeof(*frame
)))
391 if (__copy_from_user(&set
, &frame
->rs_uc
.uc_sigmask
, sizeof(set
)))
394 sigdelsetmask(&set
, ~_BLOCKABLE
);
395 set_current_blocked(&set
);
397 sig
= restore_sigcontext(®s
, &frame
->rs_uc
.uc_mcontext
);
401 force_sig(sig
, current
);
403 /* It is more difficult to avoid calling this function than to
404 call it and ignore errors. */
405 do_sigaltstack(&frame
->rs_uc
.uc_stack
, NULL
, regs
.regs
[29]);
408 * Don't let your children do this ...
410 __asm__
__volatile__(
418 force_sig(SIGSEGV
, current
);
421 #ifdef CONFIG_TRAD_SIGNALS
422 static int setup_frame(void *sig_return
, struct k_sigaction
*ka
,
423 struct pt_regs
*regs
, int signr
, sigset_t
*set
)
425 struct sigframe __user
*frame
;
428 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
429 if (!access_ok(VERIFY_WRITE
, frame
, sizeof (*frame
)))
432 err
|= setup_sigcontext(regs
, &frame
->sf_sc
);
433 err
|= __copy_to_user(&frame
->sf_mask
, set
, sizeof(*set
));
438 * Arguments to signal handler:
441 * a1 = 0 (should be cause)
442 * a2 = pointer to struct sigcontext
444 * $25 and c0_epc point to the signal handler, $29 points to the
447 regs
->regs
[ 4] = signr
;
449 regs
->regs
[ 6] = (unsigned long) &frame
->sf_sc
;
450 regs
->regs
[29] = (unsigned long) frame
;
451 regs
->regs
[31] = (unsigned long) sig_return
;
452 regs
->cp0_epc
= regs
->regs
[25] = (unsigned long) ka
->sa
.sa_handler
;
454 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
455 current
->comm
, current
->pid
,
456 frame
, regs
->cp0_epc
, regs
->regs
[31]);
460 force_sigsegv(signr
, current
);
465 static int setup_rt_frame(void *sig_return
, struct k_sigaction
*ka
,
466 struct pt_regs
*regs
, int signr
, sigset_t
*set
,
469 struct rt_sigframe __user
*frame
;
472 frame
= get_sigframe(ka
, regs
, sizeof(*frame
));
473 if (!access_ok(VERIFY_WRITE
, frame
, sizeof (*frame
)))
476 /* Create siginfo. */
477 err
|= copy_siginfo_to_user(&frame
->rs_info
, info
);
479 /* Create the ucontext. */
480 err
|= __put_user(0, &frame
->rs_uc
.uc_flags
);
481 err
|= __put_user(NULL
, &frame
->rs_uc
.uc_link
);
482 err
|= __put_user((void __user
*)current
->sas_ss_sp
,
483 &frame
->rs_uc
.uc_stack
.ss_sp
);
484 err
|= __put_user(sas_ss_flags(regs
->regs
[29]),
485 &frame
->rs_uc
.uc_stack
.ss_flags
);
486 err
|= __put_user(current
->sas_ss_size
,
487 &frame
->rs_uc
.uc_stack
.ss_size
);
488 err
|= setup_sigcontext(regs
, &frame
->rs_uc
.uc_mcontext
);
489 err
|= __copy_to_user(&frame
->rs_uc
.uc_sigmask
, set
, sizeof(*set
));
495 * Arguments to signal handler:
498 * a1 = 0 (should be cause)
499 * a2 = pointer to ucontext
501 * $25 and c0_epc point to the signal handler, $29 points to
502 * the struct rt_sigframe.
504 regs
->regs
[ 4] = signr
;
505 regs
->regs
[ 5] = (unsigned long) &frame
->rs_info
;
506 regs
->regs
[ 6] = (unsigned long) &frame
->rs_uc
;
507 regs
->regs
[29] = (unsigned long) frame
;
508 regs
->regs
[31] = (unsigned long) sig_return
;
509 regs
->cp0_epc
= regs
->regs
[25] = (unsigned long) ka
->sa
.sa_handler
;
511 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
512 current
->comm
, current
->pid
,
513 frame
, regs
->cp0_epc
, regs
->regs
[31]);
518 force_sigsegv(signr
, current
);
522 struct mips_abi mips_abi
= {
523 #ifdef CONFIG_TRAD_SIGNALS
524 .setup_frame
= setup_frame
,
525 .signal_return_offset
= offsetof(struct mips_vdso
, signal_trampoline
),
527 .setup_rt_frame
= setup_rt_frame
,
528 .rt_signal_return_offset
=
529 offsetof(struct mips_vdso
, rt_signal_trampoline
),
530 .restart
= __NR_restart_syscall
533 static int handle_signal(unsigned long sig
, siginfo_t
*info
,
534 struct k_sigaction
*ka
, sigset_t
*oldset
, struct pt_regs
*regs
)
537 struct mips_abi
*abi
= current
->thread
.abi
;
538 void *vdso
= current
->mm
->context
.vdso
;
541 switch(regs
->regs
[2]) {
542 case ERESTART_RESTARTBLOCK
:
544 regs
->regs
[2] = EINTR
;
547 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
548 regs
->regs
[2] = EINTR
;
553 regs
->regs
[7] = regs
->regs
[26];
554 regs
->regs
[2] = regs
->regs
[0];
558 regs
->regs
[0] = 0; /* Don't deal with this again. */
561 if (sig_uses_siginfo(ka
))
562 ret
= abi
->setup_rt_frame(vdso
+ abi
->rt_signal_return_offset
,
563 ka
, regs
, sig
, oldset
, info
);
565 ret
= abi
->setup_frame(vdso
+ abi
->signal_return_offset
,
566 ka
, regs
, sig
, oldset
);
571 block_sigmask(ka
, sig
);
576 static void do_signal(struct pt_regs
*regs
)
578 struct k_sigaction ka
;
584 * We want the common case to go fast, which is why we may in certain
585 * cases get here from kernel mode. Just return without doing anything
588 if (!user_mode(regs
))
591 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
592 oldset
= ¤t
->saved_sigmask
;
594 oldset
= ¤t
->blocked
;
596 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
598 /* Whee! Actually deliver the signal. */
599 if (handle_signal(signr
, &info
, &ka
, oldset
, regs
) == 0) {
601 * A signal was successfully delivered; the saved
602 * sigmask will have been stored in the signal frame,
603 * and will be restored by sigreturn, so we can simply
604 * clear the TIF_RESTORE_SIGMASK flag.
606 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
607 clear_thread_flag(TIF_RESTORE_SIGMASK
);
614 if (regs
->regs
[2] == ERESTARTNOHAND
||
615 regs
->regs
[2] == ERESTARTSYS
||
616 regs
->regs
[2] == ERESTARTNOINTR
) {
617 regs
->regs
[2] = regs
->regs
[0];
618 regs
->regs
[7] = regs
->regs
[26];
621 if (regs
->regs
[2] == ERESTART_RESTARTBLOCK
) {
622 regs
->regs
[2] = current
->thread
.abi
->restart
;
623 regs
->regs
[7] = regs
->regs
[26];
626 regs
->regs
[0] = 0; /* Don't deal with this again. */
630 * If there's no signal to deliver, we just put the saved sigmask
633 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
634 clear_thread_flag(TIF_RESTORE_SIGMASK
);
635 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
640 * notification of userspace execution resumption
641 * - triggered by the TIF_WORK_MASK flags
643 asmlinkage
void do_notify_resume(struct pt_regs
*regs
, void *unused
,
644 __u32 thread_info_flags
)
648 /* deal with pending signal delivery */
649 if (thread_info_flags
& (_TIF_SIGPENDING
| _TIF_RESTORE_SIGMASK
))
652 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
653 clear_thread_flag(TIF_NOTIFY_RESUME
);
654 tracehook_notify_resume(regs
);
655 if (current
->replacement_session_keyring
)
656 key_replace_session_keyring();
661 static int smp_save_fp_context(struct sigcontext __user
*sc
)
663 return raw_cpu_has_fpu
664 ? _save_fp_context(sc
)
665 : fpu_emulator_save_context(sc
);
668 static int smp_restore_fp_context(struct sigcontext __user
*sc
)
670 return raw_cpu_has_fpu
671 ? _restore_fp_context(sc
)
672 : fpu_emulator_restore_context(sc
);
676 static int signal_setup(void)
679 /* For now just do the cpu_has_fpu check when the functions are invoked */
680 save_fp_context
= smp_save_fp_context
;
681 restore_fp_context
= smp_restore_fp_context
;
684 save_fp_context
= _save_fp_context
;
685 restore_fp_context
= _restore_fp_context
;
687 save_fp_context
= fpu_emulator_save_context
;
688 restore_fp_context
= fpu_emulator_restore_context
;
695 arch_initcall(signal_setup
);