2 * arch/sh/kernel/signal_64.c
4 * Copyright (C) 2000, 2001 Paolo Alberelli
5 * Copyright (C) 2003 - 2008 Paul Mundt
6 * Copyright (C) 2004 Richard Curnow
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file "COPYING" in the main directory of this archive
12 #include <linux/rwsem.h>
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/personality.h>
21 #include <linux/freezer.h>
22 #include <linux/ptrace.h>
23 #include <linux/unistd.h>
24 #include <linux/stddef.h>
25 #include <linux/tracehook.h>
26 #include <asm/ucontext.h>
27 #include <asm/uaccess.h>
28 #include <asm/pgtable.h>
29 #include <asm/cacheflush.h>
38 #define REF_REG_RET regs->regs[REG_RET]
39 #define REF_REG_SP regs->regs[REG_SP]
40 #define DEREF_REG_PR regs->regs[REG_PR]
44 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
47 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
48 struct pt_regs * regs);
51 handle_syscall_restart(struct pt_regs *regs, struct sigaction *sa)
53 /* If we're not from a syscall, bail out */
54 if (regs->syscall_nr < 0)
57 /* check for system call restart.. */
58 switch (regs->regs[REG_RET]) {
59 case -ERESTART_RESTARTBLOCK:
61 no_system_call_restart:
62 regs->regs[REG_RET] = -EINTR;
66 if (!(sa->sa_flags & SA_RESTART))
67 goto no_system_call_restart;
70 /* Decode syscall # */
71 regs->regs[REG_RET] = regs->syscall_nr;
78 * Note that 'init' is a special process: it doesn't get signals it doesn't
79 * want to handle. Thus you cannot kill init even with a SIGKILL even by
82 * Note that we go through the signals twice: once to check the signals that
83 * the kernel can handle, and then we build all the user-level signal handling
84 * stack-frames in one go after that.
86 static void do_signal(struct pt_regs *regs)
90 struct k_sigaction ka;
93 * We want the common case to go fast, which
94 * is why we may in certain cases get here from
95 * kernel mode. Just return without doing anything
101 signr = get_signal_to_deliver(&info, &ka, regs, 0);
103 handle_syscall_restart(regs, &ka.sa);
105 /* Whee! Actually deliver the signal. */
106 if (handle_signal(signr, &info, &ka, regs) == 0) {
108 * If a signal was successfully delivered, the
109 * saved sigmask is in its frame, and we can
110 * clear the TS_RESTORE_SIGMASK flag.
112 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
114 tracehook_signal_handler(signr, &info, &ka, regs,
115 test_thread_flag(TIF_SINGLESTEP));
120 /* Did we come from a system call? */
121 if (regs->syscall_nr >= 0) {
122 /* Restart the system call - no handlers present */
123 switch (regs->regs[REG_RET]) {
124 case -ERESTARTNOHAND:
126 case -ERESTARTNOINTR:
127 /* Decode Syscall # */
128 regs->regs[REG_RET] = regs->syscall_nr;
132 case -ERESTART_RESTARTBLOCK:
133 regs->regs[REG_RET] = __NR_restart_syscall;
139 /* No signal to deliver -- put the saved sigmask back */
140 restore_saved_sigmask();
144 * Atomically swap in the new signal mask, and wait for a signal.
147 sys_sigsuspend(old_sigset_t mask)
150 siginitset(&blocked, mask);
151 return sigsuspend(&blocked);
155 sys_sigaction(int sig, const struct old_sigaction __user *act,
156 struct old_sigaction __user *oact)
158 struct k_sigaction new_ka, old_ka;
163 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
164 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
165 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
166 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
167 __get_user(mask, &act->sa_mask))
169 siginitset(&new_ka.sa.sa_mask, mask);
172 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
175 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
176 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
177 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
178 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
179 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
187 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
188 unsigned long r4, unsigned long r5, unsigned long r6,
190 struct pt_regs * regs)
192 return do_sigaltstack(uss, uoss, REF_REG_SP);
196 * Do a signal return; undo the signal stack.
199 struct sigcontext sc;
200 unsigned long extramask[_NSIG_WORDS-1];
201 long long retcode[2];
205 struct siginfo __user *pinfo;
209 long long retcode[2];
214 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
219 err |= __get_user (fpvalid, &sc->sc_fpvalid);
220 conditional_used_math(fpvalid);
224 if (current == last_task_used_math) {
225 last_task_used_math = NULL;
229 err |= __copy_from_user(¤t->thread.xstate->hardfpu, &sc->sc_fpregs[0],
230 (sizeof(long long) * 32) + (sizeof(int) * 1));
236 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
241 fpvalid = !!used_math();
242 err |= __put_user(fpvalid, &sc->sc_fpvalid);
246 if (current == last_task_used_math) {
250 last_task_used_math = NULL;
254 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.xstate->hardfpu,
255 (sizeof(long long) * 32) + (sizeof(int) * 1));
262 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
267 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
274 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
276 unsigned int err = 0;
277 unsigned long long current_sr, new_sr;
278 #define SR_MASK 0xffff8cfd
280 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
282 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
283 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
284 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
285 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
286 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
287 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
288 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
289 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
290 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
291 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
292 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
293 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
294 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
295 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
296 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
297 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
298 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
299 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
301 /* Prevent the signal handler manipulating SR in a way that can
302 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
304 current_sr = regs->sr;
305 err |= __get_user(new_sr, &sc->sc_sr);
307 regs->sr |= (new_sr & ~SR_MASK);
313 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
314 * has been restored above.) */
315 err |= restore_sigcontext_fpu(regs, sc);
317 regs->syscall_nr = -1; /* disable syscall checks */
318 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
322 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
323 unsigned long r4, unsigned long r5,
324 unsigned long r6, unsigned long r7,
325 struct pt_regs * regs)
327 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
331 /* Always make any pending restarted system calls return -EINTR */
332 current_thread_info()->restart_block.fn = do_no_restart_syscall;
334 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
337 if (__get_user(set.sig[0], &frame->sc.oldmask)
339 && __copy_from_user(&set.sig[1], &frame->extramask,
340 sizeof(frame->extramask))))
343 sigdelsetmask(&set, ~_BLOCKABLE);
344 set_current_blocked(&set);
346 if (restore_sigcontext(regs, &frame->sc, &ret))
353 force_sig(SIGSEGV, current);
357 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
358 unsigned long r4, unsigned long r5,
359 unsigned long r6, unsigned long r7,
360 struct pt_regs * regs)
362 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
367 /* Always make any pending restarted system calls return -EINTR */
368 current_thread_info()->restart_block.fn = do_no_restart_syscall;
370 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
373 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
376 sigdelsetmask(&set, ~_BLOCKABLE);
377 set_current_blocked(&set);
379 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
383 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
385 /* It is more difficult to avoid calling this function than to
386 call it and ignore errors. */
387 do_sigaltstack(&st, NULL, REF_REG_SP);
392 force_sig(SIGSEGV, current);
397 * Set up a signal frame.
400 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
405 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
406 err |= setup_sigcontext_fpu(regs, sc);
408 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
410 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
411 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
412 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
413 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
414 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
415 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
416 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
417 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
418 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
419 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
420 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
421 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
422 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
423 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
424 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
425 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
426 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
427 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
432 err |= __put_user(mask, &sc->oldmask);
438 * Determine which stack to use..
440 static inline void __user *
441 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
443 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
444 sp = current->sas_ss_sp + current->sas_ss_size;
446 return (void __user *)((sp - frame_size) & -8ul);
449 void sa_default_restorer(void); /* See comments below */
450 void sa_default_rt_restorer(void); /* See comments below */
452 static int setup_frame(int sig, struct k_sigaction *ka,
453 sigset_t *set, struct pt_regs *regs)
455 struct sigframe __user *frame;
459 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
461 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
464 signal = current_thread_info()->exec_domain
465 && current_thread_info()->exec_domain->signal_invmap
467 ? current_thread_info()->exec_domain->signal_invmap[sig]
470 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
472 /* Give up earlier as i386, in case */
476 if (_NSIG_WORDS > 1) {
477 err |= __copy_to_user(frame->extramask, &set->sig[1],
478 sizeof(frame->extramask)); }
480 /* Give up earlier as i386, in case */
484 /* Set up to return from userspace. If provided, use a stub
485 already in userspace. */
486 if (ka->sa.sa_flags & SA_RESTORER) {
488 * On SH5 all edited pointers are subject to NEFF
490 DEREF_REG_PR = neff_sign_extend((unsigned long)
491 ka->sa.sa_restorer | 0x1);
494 * Different approach on SH5.
495 * . Endianness independent asm code gets placed in entry.S .
496 * This is limited to four ASM instructions corresponding
497 * to two long longs in size.
498 * . err checking is done on the else branch only
499 * . flush_icache_range() is called upon __put_user() only
500 * . all edited pointers are subject to NEFF
501 * . being code, linker turns ShMedia bit on, always
502 * dereference index -1.
504 DEREF_REG_PR = neff_sign_extend((unsigned long)
505 frame->retcode | 0x01);
507 if (__copy_to_user(frame->retcode,
508 (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
511 /* Cohere the trampoline with the I-cache. */
512 flush_cache_sigtramp(DEREF_REG_PR-1);
516 * Set up registers for signal handler.
517 * All edited pointers are subject to NEFF.
519 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
520 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
523 The glibc profiling support for SH-5 needs to be passed a sigcontext
524 so it can retrieve the PC. At some point during 2003 the glibc
525 support was changed to receive the sigcontext through the 2nd
526 argument, but there are still versions of libc.so in use that use
527 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
528 through both 2nd and 3rd arguments.
531 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
532 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
534 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
539 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
540 signal, current->comm, current->pid, frame,
541 regs->pc >> 32, regs->pc & 0xffffffff,
542 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
547 force_sigsegv(sig, current);
551 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
552 sigset_t *set, struct pt_regs *regs)
554 struct rt_sigframe __user *frame;
558 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
560 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
563 signal = current_thread_info()->exec_domain
564 && current_thread_info()->exec_domain->signal_invmap
566 ? current_thread_info()->exec_domain->signal_invmap[sig]
569 err |= __put_user(&frame->info, &frame->pinfo);
570 err |= __put_user(&frame->uc, &frame->puc);
571 err |= copy_siginfo_to_user(&frame->info, info);
573 /* Give up earlier as i386, in case */
577 /* Create the ucontext. */
578 err |= __put_user(0, &frame->uc.uc_flags);
579 err |= __put_user(0, &frame->uc.uc_link);
580 err |= __put_user((void *)current->sas_ss_sp,
581 &frame->uc.uc_stack.ss_sp);
582 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
583 &frame->uc.uc_stack.ss_flags);
584 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
585 err |= setup_sigcontext(&frame->uc.uc_mcontext,
587 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
589 /* Give up earlier as i386, in case */
593 /* Set up to return from userspace. If provided, use a stub
594 already in userspace. */
595 if (ka->sa.sa_flags & SA_RESTORER) {
597 * On SH5 all edited pointers are subject to NEFF
599 DEREF_REG_PR = neff_sign_extend((unsigned long)
600 ka->sa.sa_restorer | 0x1);
603 * Different approach on SH5.
604 * . Endianness independent asm code gets placed in entry.S .
605 * This is limited to four ASM instructions corresponding
606 * to two long longs in size.
607 * . err checking is done on the else branch only
608 * . flush_icache_range() is called upon __put_user() only
609 * . all edited pointers are subject to NEFF
610 * . being code, linker turns ShMedia bit on, always
611 * dereference index -1.
613 DEREF_REG_PR = neff_sign_extend((unsigned long)
614 frame->retcode | 0x01);
616 if (__copy_to_user(frame->retcode,
617 (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
620 /* Cohere the trampoline with the I-cache. */
621 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
625 * Set up registers for signal handler.
626 * All edited pointers are subject to NEFF.
628 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
629 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
630 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
631 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
632 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
636 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
637 signal, current->comm, current->pid, frame,
638 regs->pc >> 32, regs->pc & 0xffffffff,
639 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
644 force_sigsegv(sig, current);
649 * OK, we're invoking a handler
652 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
653 struct pt_regs * regs)
655 sigset_t *oldset = sigmask_to_save();
658 /* Set up the stack frame */
659 if (ka->sa.sa_flags & SA_SIGINFO)
660 ret = setup_rt_frame(sig, ka, info, oldset, regs);
662 ret = setup_frame(sig, ka, oldset, regs);
665 block_sigmask(ka, sig);
670 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
672 if (thread_info_flags & _TIF_SIGPENDING)
675 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
676 clear_thread_flag(TIF_NOTIFY_RESUME);
677 tracehook_notify_resume(regs);