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 sigset_t *oldset, 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 int do_signal(struct pt_regs *regs, sigset_t *oldset)
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 if (current_thread_info()->status & TS_RESTORE_SIGMASK)
102 oldset = ¤t->saved_sigmask;
104 oldset = ¤t->blocked;
106 signr = get_signal_to_deliver(&info, &ka, regs, 0);
108 handle_syscall_restart(regs, &ka.sa);
110 /* Whee! Actually deliver the signal. */
111 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
113 * If a signal was successfully delivered, the
114 * saved sigmask is in its frame, and we can
115 * clear the TS_RESTORE_SIGMASK flag.
117 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
119 tracehook_signal_handler(signr, &info, &ka, regs,
120 test_thread_flag(TIF_SINGLESTEP));
125 /* Did we come from a system call? */
126 if (regs->syscall_nr >= 0) {
127 /* Restart the system call - no handlers present */
128 switch (regs->regs[REG_RET]) {
129 case -ERESTARTNOHAND:
131 case -ERESTARTNOINTR:
132 /* Decode Syscall # */
133 regs->regs[REG_RET] = regs->syscall_nr;
137 case -ERESTART_RESTARTBLOCK:
138 regs->regs[REG_RET] = __NR_restart_syscall;
144 /* No signal to deliver -- put the saved sigmask back */
145 if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
146 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
147 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
154 * Atomically swap in the new signal mask, and wait for a signal.
157 sys_sigsuspend(old_sigset_t mask,
158 unsigned long r3, unsigned long r4, unsigned long r5,
159 unsigned long r6, unsigned long r7,
160 struct pt_regs * regs)
162 sigset_t saveset, blocked;
164 saveset = current->blocked;
167 siginitset(&blocked, mask);
168 set_current_blocked(&blocked);
170 REF_REG_RET = -EINTR;
172 current->state = TASK_INTERRUPTIBLE;
174 set_restore_sigmask();
175 regs->pc += 4; /* because sys_sigreturn decrements the pc */
176 if (do_signal(regs, &saveset)) {
177 /* pc now points at signal handler. Need to decrement
178 it because entry.S will increment it. */
186 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
187 unsigned long r4, unsigned long r5, unsigned long r6,
189 struct pt_regs * regs)
191 sigset_t saveset, newset;
193 /* XXX: Don't preclude handling different sized sigset_t's. */
194 if (sigsetsize != sizeof(sigset_t))
197 if (copy_from_user(&newset, unewset, sizeof(newset)))
199 sigdelsetmask(&newset, ~_BLOCKABLE);
200 saveset = current->blocked;
201 set_current_blocked(&newset);
203 REF_REG_RET = -EINTR;
205 current->state = TASK_INTERRUPTIBLE;
207 regs->pc += 4; /* because sys_sigreturn decrements the pc */
208 if (do_signal(regs, &saveset)) {
209 /* pc now points at signal handler. Need to decrement
210 it because entry.S will increment it. */
218 sys_sigaction(int sig, const struct old_sigaction __user *act,
219 struct old_sigaction __user *oact)
221 struct k_sigaction new_ka, old_ka;
226 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
227 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
228 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
230 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
231 __get_user(mask, &act->sa_mask);
232 siginitset(&new_ka.sa.sa_mask, mask);
235 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
238 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
239 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
240 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
242 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
243 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
250 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
251 unsigned long r4, unsigned long r5, unsigned long r6,
253 struct pt_regs * regs)
255 return do_sigaltstack(uss, uoss, REF_REG_SP);
259 * Do a signal return; undo the signal stack.
262 struct sigcontext sc;
263 unsigned long extramask[_NSIG_WORDS-1];
264 long long retcode[2];
268 struct siginfo __user *pinfo;
272 long long retcode[2];
277 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
282 err |= __get_user (fpvalid, &sc->sc_fpvalid);
283 conditional_used_math(fpvalid);
287 if (current == last_task_used_math) {
288 last_task_used_math = NULL;
292 err |= __copy_from_user(¤t->thread.xstate->hardfpu, &sc->sc_fpregs[0],
293 (sizeof(long long) * 32) + (sizeof(int) * 1));
299 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
304 fpvalid = !!used_math();
305 err |= __put_user(fpvalid, &sc->sc_fpvalid);
309 if (current == last_task_used_math) {
313 last_task_used_math = NULL;
317 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.xstate->hardfpu,
318 (sizeof(long long) * 32) + (sizeof(int) * 1));
325 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
330 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
337 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
339 unsigned int err = 0;
340 unsigned long long current_sr, new_sr;
341 #define SR_MASK 0xffff8cfd
343 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
345 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
346 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
347 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
348 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
349 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
350 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
351 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
352 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
353 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
354 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
355 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
356 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
357 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
358 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
359 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
360 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
361 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
362 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
364 /* Prevent the signal handler manipulating SR in a way that can
365 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
367 current_sr = regs->sr;
368 err |= __get_user(new_sr, &sc->sc_sr);
370 regs->sr |= (new_sr & ~SR_MASK);
376 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
377 * has been restored above.) */
378 err |= restore_sigcontext_fpu(regs, sc);
380 regs->syscall_nr = -1; /* disable syscall checks */
381 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
385 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
386 unsigned long r4, unsigned long r5,
387 unsigned long r6, unsigned long r7,
388 struct pt_regs * regs)
390 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
394 /* Always make any pending restarted system calls return -EINTR */
395 current_thread_info()->restart_block.fn = do_no_restart_syscall;
397 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
400 if (__get_user(set.sig[0], &frame->sc.oldmask)
402 && __copy_from_user(&set.sig[1], &frame->extramask,
403 sizeof(frame->extramask))))
406 sigdelsetmask(&set, ~_BLOCKABLE);
407 set_current_blocked(&set);
409 if (restore_sigcontext(regs, &frame->sc, &ret))
416 force_sig(SIGSEGV, current);
420 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
421 unsigned long r4, unsigned long r5,
422 unsigned long r6, unsigned long r7,
423 struct pt_regs * regs)
425 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
430 /* Always make any pending restarted system calls return -EINTR */
431 current_thread_info()->restart_block.fn = do_no_restart_syscall;
433 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
436 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
439 sigdelsetmask(&set, ~_BLOCKABLE);
440 set_current_blocked(&set);
442 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
446 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
448 /* It is more difficult to avoid calling this function than to
449 call it and ignore errors. */
450 do_sigaltstack(&st, NULL, REF_REG_SP);
455 force_sig(SIGSEGV, current);
460 * Set up a signal frame.
463 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
468 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
469 err |= setup_sigcontext_fpu(regs, sc);
471 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
473 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
474 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
475 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
476 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
477 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
478 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
479 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
480 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
481 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
482 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
483 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
484 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
485 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
486 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
487 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
488 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
489 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
490 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
495 err |= __put_user(mask, &sc->oldmask);
501 * Determine which stack to use..
503 static inline void __user *
504 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
506 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
507 sp = current->sas_ss_sp + current->sas_ss_size;
509 return (void __user *)((sp - frame_size) & -8ul);
512 void sa_default_restorer(void); /* See comments below */
513 void sa_default_rt_restorer(void); /* See comments below */
515 static int setup_frame(int sig, struct k_sigaction *ka,
516 sigset_t *set, struct pt_regs *regs)
518 struct sigframe __user *frame;
522 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
524 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
527 signal = current_thread_info()->exec_domain
528 && current_thread_info()->exec_domain->signal_invmap
530 ? current_thread_info()->exec_domain->signal_invmap[sig]
533 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
535 /* Give up earlier as i386, in case */
539 if (_NSIG_WORDS > 1) {
540 err |= __copy_to_user(frame->extramask, &set->sig[1],
541 sizeof(frame->extramask)); }
543 /* Give up earlier as i386, in case */
547 /* Set up to return from userspace. If provided, use a stub
548 already in userspace. */
549 if (ka->sa.sa_flags & SA_RESTORER) {
551 * On SH5 all edited pointers are subject to NEFF
553 DEREF_REG_PR = neff_sign_extend((unsigned long)
554 ka->sa.sa_restorer | 0x1);
557 * Different approach on SH5.
558 * . Endianness independent asm code gets placed in entry.S .
559 * This is limited to four ASM instructions corresponding
560 * to two long longs in size.
561 * . err checking is done on the else branch only
562 * . flush_icache_range() is called upon __put_user() only
563 * . all edited pointers are subject to NEFF
564 * . being code, linker turns ShMedia bit on, always
565 * dereference index -1.
567 DEREF_REG_PR = neff_sign_extend((unsigned long)
568 frame->retcode | 0x01);
570 if (__copy_to_user(frame->retcode,
571 (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
574 /* Cohere the trampoline with the I-cache. */
575 flush_cache_sigtramp(DEREF_REG_PR-1);
579 * Set up registers for signal handler.
580 * All edited pointers are subject to NEFF.
582 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
583 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
586 The glibc profiling support for SH-5 needs to be passed a sigcontext
587 so it can retrieve the PC. At some point during 2003 the glibc
588 support was changed to receive the sigcontext through the 2nd
589 argument, but there are still versions of libc.so in use that use
590 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
591 through both 2nd and 3rd arguments.
594 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
595 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
597 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
602 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
603 signal, current->comm, current->pid, frame,
604 regs->pc >> 32, regs->pc & 0xffffffff,
605 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
610 force_sigsegv(sig, current);
614 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
615 sigset_t *set, struct pt_regs *regs)
617 struct rt_sigframe __user *frame;
621 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
623 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
626 signal = current_thread_info()->exec_domain
627 && current_thread_info()->exec_domain->signal_invmap
629 ? current_thread_info()->exec_domain->signal_invmap[sig]
632 err |= __put_user(&frame->info, &frame->pinfo);
633 err |= __put_user(&frame->uc, &frame->puc);
634 err |= copy_siginfo_to_user(&frame->info, info);
636 /* Give up earlier as i386, in case */
640 /* Create the ucontext. */
641 err |= __put_user(0, &frame->uc.uc_flags);
642 err |= __put_user(0, &frame->uc.uc_link);
643 err |= __put_user((void *)current->sas_ss_sp,
644 &frame->uc.uc_stack.ss_sp);
645 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
646 &frame->uc.uc_stack.ss_flags);
647 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
648 err |= setup_sigcontext(&frame->uc.uc_mcontext,
650 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
652 /* Give up earlier as i386, in case */
656 /* Set up to return from userspace. If provided, use a stub
657 already in userspace. */
658 if (ka->sa.sa_flags & SA_RESTORER) {
660 * On SH5 all edited pointers are subject to NEFF
662 DEREF_REG_PR = neff_sign_extend((unsigned long)
663 ka->sa.sa_restorer | 0x1);
666 * Different approach on SH5.
667 * . Endianness independent asm code gets placed in entry.S .
668 * This is limited to four ASM instructions corresponding
669 * to two long longs in size.
670 * . err checking is done on the else branch only
671 * . flush_icache_range() is called upon __put_user() only
672 * . all edited pointers are subject to NEFF
673 * . being code, linker turns ShMedia bit on, always
674 * dereference index -1.
676 DEREF_REG_PR = neff_sign_extend((unsigned long)
677 frame->retcode | 0x01);
679 if (__copy_to_user(frame->retcode,
680 (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
683 /* Cohere the trampoline with the I-cache. */
684 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
688 * Set up registers for signal handler.
689 * All edited pointers are subject to NEFF.
691 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
692 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
693 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
694 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
695 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
699 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
700 signal, current->comm, current->pid, frame,
701 regs->pc >> 32, regs->pc & 0xffffffff,
702 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
707 force_sigsegv(sig, current);
712 * OK, we're invoking a handler
715 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
716 sigset_t *oldset, struct pt_regs * regs)
720 /* Set up the stack frame */
721 if (ka->sa.sa_flags & SA_SIGINFO)
722 ret = setup_rt_frame(sig, ka, info, oldset, regs);
724 ret = setup_frame(sig, ka, oldset, regs);
727 block_sigmask(ka, sig);
732 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
734 if (thread_info_flags & _TIF_SIGPENDING)
737 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
738 clear_thread_flag(TIF_NOTIFY_RESUME);
739 tracehook_notify_resume(regs);
740 if (current->replacement_session_keyring)
741 key_replace_session_keyring();