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 void do_signal(struct pt_regs *regs)
90 struct k_sigaction ka;
94 * We want the common case to go fast, which
95 * is why we may in certain cases get here from
96 * kernel mode. Just return without doing anything
102 if (current_thread_info()->status & TS_RESTORE_SIGMASK)
103 oldset = ¤t->saved_sigmask;
105 oldset = ¤t->blocked;
107 signr = get_signal_to_deliver(&info, &ka, regs, 0);
109 handle_syscall_restart(regs, &ka.sa);
111 /* Whee! Actually deliver the signal. */
112 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
114 * If a signal was successfully delivered, the
115 * saved sigmask is in its frame, and we can
116 * clear the TS_RESTORE_SIGMASK flag.
118 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
120 tracehook_signal_handler(signr, &info, &ka, regs,
121 test_thread_flag(TIF_SINGLESTEP));
126 /* Did we come from a system call? */
127 if (regs->syscall_nr >= 0) {
128 /* Restart the system call - no handlers present */
129 switch (regs->regs[REG_RET]) {
130 case -ERESTARTNOHAND:
132 case -ERESTARTNOINTR:
133 /* Decode Syscall # */
134 regs->regs[REG_RET] = regs->syscall_nr;
138 case -ERESTART_RESTARTBLOCK:
139 regs->regs[REG_RET] = __NR_restart_syscall;
145 /* No signal to deliver -- put the saved sigmask back */
146 if (current_thread_info()->status & TS_RESTORE_SIGMASK) {
147 current_thread_info()->status &= ~TS_RESTORE_SIGMASK;
148 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
155 * Atomically swap in the new signal mask, and wait for a signal.
158 sys_sigsuspend(old_sigset_t mask)
161 siginitset(&blocked, mask);
162 return sigsuspend(&blocked);
166 sys_sigaction(int sig, const struct old_sigaction __user *act,
167 struct old_sigaction __user *oact)
169 struct k_sigaction new_ka, old_ka;
174 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
175 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
176 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
177 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
178 __get_user(mask, &act->sa_mask))
180 siginitset(&new_ka.sa.sa_mask, mask);
183 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
186 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
187 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
188 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
189 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
190 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
198 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
199 unsigned long r4, unsigned long r5, unsigned long r6,
201 struct pt_regs * regs)
203 return do_sigaltstack(uss, uoss, REF_REG_SP);
207 * Do a signal return; undo the signal stack.
210 struct sigcontext sc;
211 unsigned long extramask[_NSIG_WORDS-1];
212 long long retcode[2];
216 struct siginfo __user *pinfo;
220 long long retcode[2];
225 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
230 err |= __get_user (fpvalid, &sc->sc_fpvalid);
231 conditional_used_math(fpvalid);
235 if (current == last_task_used_math) {
236 last_task_used_math = NULL;
240 err |= __copy_from_user(¤t->thread.xstate->hardfpu, &sc->sc_fpregs[0],
241 (sizeof(long long) * 32) + (sizeof(int) * 1));
247 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
252 fpvalid = !!used_math();
253 err |= __put_user(fpvalid, &sc->sc_fpvalid);
257 if (current == last_task_used_math) {
261 last_task_used_math = NULL;
265 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.xstate->hardfpu,
266 (sizeof(long long) * 32) + (sizeof(int) * 1));
273 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
278 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
285 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
287 unsigned int err = 0;
288 unsigned long long current_sr, new_sr;
289 #define SR_MASK 0xffff8cfd
291 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
293 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
294 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
295 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
296 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
297 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
298 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
299 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
300 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
301 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
302 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
303 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
304 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
305 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
306 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
307 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
308 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
309 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
310 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
312 /* Prevent the signal handler manipulating SR in a way that can
313 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
315 current_sr = regs->sr;
316 err |= __get_user(new_sr, &sc->sc_sr);
318 regs->sr |= (new_sr & ~SR_MASK);
324 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
325 * has been restored above.) */
326 err |= restore_sigcontext_fpu(regs, sc);
328 regs->syscall_nr = -1; /* disable syscall checks */
329 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
333 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
334 unsigned long r4, unsigned long r5,
335 unsigned long r6, unsigned long r7,
336 struct pt_regs * regs)
338 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
342 /* Always make any pending restarted system calls return -EINTR */
343 current_thread_info()->restart_block.fn = do_no_restart_syscall;
345 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
348 if (__get_user(set.sig[0], &frame->sc.oldmask)
350 && __copy_from_user(&set.sig[1], &frame->extramask,
351 sizeof(frame->extramask))))
354 sigdelsetmask(&set, ~_BLOCKABLE);
355 set_current_blocked(&set);
357 if (restore_sigcontext(regs, &frame->sc, &ret))
364 force_sig(SIGSEGV, current);
368 asmlinkage int sys_rt_sigreturn(unsigned long r2, unsigned long r3,
369 unsigned long r4, unsigned long r5,
370 unsigned long r6, unsigned long r7,
371 struct pt_regs * regs)
373 struct rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
378 /* Always make any pending restarted system calls return -EINTR */
379 current_thread_info()->restart_block.fn = do_no_restart_syscall;
381 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
384 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
387 sigdelsetmask(&set, ~_BLOCKABLE);
388 set_current_blocked(&set);
390 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
394 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
396 /* It is more difficult to avoid calling this function than to
397 call it and ignore errors. */
398 do_sigaltstack(&st, NULL, REF_REG_SP);
403 force_sig(SIGSEGV, current);
408 * Set up a signal frame.
411 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
416 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
417 err |= setup_sigcontext_fpu(regs, sc);
419 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
421 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
422 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
423 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
424 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
425 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
426 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
427 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
428 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
429 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
430 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
431 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
432 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
433 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
434 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
435 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
436 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
437 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
438 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
443 err |= __put_user(mask, &sc->oldmask);
449 * Determine which stack to use..
451 static inline void __user *
452 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
454 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
455 sp = current->sas_ss_sp + current->sas_ss_size;
457 return (void __user *)((sp - frame_size) & -8ul);
460 void sa_default_restorer(void); /* See comments below */
461 void sa_default_rt_restorer(void); /* See comments below */
463 static int setup_frame(int sig, struct k_sigaction *ka,
464 sigset_t *set, struct pt_regs *regs)
466 struct sigframe __user *frame;
470 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
472 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
475 signal = current_thread_info()->exec_domain
476 && current_thread_info()->exec_domain->signal_invmap
478 ? current_thread_info()->exec_domain->signal_invmap[sig]
481 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
483 /* Give up earlier as i386, in case */
487 if (_NSIG_WORDS > 1) {
488 err |= __copy_to_user(frame->extramask, &set->sig[1],
489 sizeof(frame->extramask)); }
491 /* Give up earlier as i386, in case */
495 /* Set up to return from userspace. If provided, use a stub
496 already in userspace. */
497 if (ka->sa.sa_flags & SA_RESTORER) {
499 * On SH5 all edited pointers are subject to NEFF
501 DEREF_REG_PR = neff_sign_extend((unsigned long)
502 ka->sa.sa_restorer | 0x1);
505 * Different approach on SH5.
506 * . Endianness independent asm code gets placed in entry.S .
507 * This is limited to four ASM instructions corresponding
508 * to two long longs in size.
509 * . err checking is done on the else branch only
510 * . flush_icache_range() is called upon __put_user() only
511 * . all edited pointers are subject to NEFF
512 * . being code, linker turns ShMedia bit on, always
513 * dereference index -1.
515 DEREF_REG_PR = neff_sign_extend((unsigned long)
516 frame->retcode | 0x01);
518 if (__copy_to_user(frame->retcode,
519 (void *)((unsigned long)sa_default_restorer & (~1)), 16) != 0)
522 /* Cohere the trampoline with the I-cache. */
523 flush_cache_sigtramp(DEREF_REG_PR-1);
527 * Set up registers for signal handler.
528 * All edited pointers are subject to NEFF.
530 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
531 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
534 The glibc profiling support for SH-5 needs to be passed a sigcontext
535 so it can retrieve the PC. At some point during 2003 the glibc
536 support was changed to receive the sigcontext through the 2nd
537 argument, but there are still versions of libc.so in use that use
538 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
539 through both 2nd and 3rd arguments.
542 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
543 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
545 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
550 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
551 signal, current->comm, current->pid, frame,
552 regs->pc >> 32, regs->pc & 0xffffffff,
553 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
558 force_sigsegv(sig, current);
562 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
563 sigset_t *set, struct pt_regs *regs)
565 struct rt_sigframe __user *frame;
569 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
571 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
574 signal = current_thread_info()->exec_domain
575 && current_thread_info()->exec_domain->signal_invmap
577 ? current_thread_info()->exec_domain->signal_invmap[sig]
580 err |= __put_user(&frame->info, &frame->pinfo);
581 err |= __put_user(&frame->uc, &frame->puc);
582 err |= copy_siginfo_to_user(&frame->info, info);
584 /* Give up earlier as i386, in case */
588 /* Create the ucontext. */
589 err |= __put_user(0, &frame->uc.uc_flags);
590 err |= __put_user(0, &frame->uc.uc_link);
591 err |= __put_user((void *)current->sas_ss_sp,
592 &frame->uc.uc_stack.ss_sp);
593 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
594 &frame->uc.uc_stack.ss_flags);
595 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
596 err |= setup_sigcontext(&frame->uc.uc_mcontext,
598 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
600 /* Give up earlier as i386, in case */
604 /* Set up to return from userspace. If provided, use a stub
605 already in userspace. */
606 if (ka->sa.sa_flags & SA_RESTORER) {
608 * On SH5 all edited pointers are subject to NEFF
610 DEREF_REG_PR = neff_sign_extend((unsigned long)
611 ka->sa.sa_restorer | 0x1);
614 * Different approach on SH5.
615 * . Endianness independent asm code gets placed in entry.S .
616 * This is limited to four ASM instructions corresponding
617 * to two long longs in size.
618 * . err checking is done on the else branch only
619 * . flush_icache_range() is called upon __put_user() only
620 * . all edited pointers are subject to NEFF
621 * . being code, linker turns ShMedia bit on, always
622 * dereference index -1.
624 DEREF_REG_PR = neff_sign_extend((unsigned long)
625 frame->retcode | 0x01);
627 if (__copy_to_user(frame->retcode,
628 (void *)((unsigned long)sa_default_rt_restorer & (~1)), 16) != 0)
631 /* Cohere the trampoline with the I-cache. */
632 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
636 * Set up registers for signal handler.
637 * All edited pointers are subject to NEFF.
639 regs->regs[REG_SP] = neff_sign_extend((unsigned long)frame);
640 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
641 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
642 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
643 regs->pc = neff_sign_extend((unsigned long)ka->sa.sa_handler);
647 pr_debug("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
648 signal, current->comm, current->pid, frame,
649 regs->pc >> 32, regs->pc & 0xffffffff,
650 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
655 force_sigsegv(sig, current);
660 * OK, we're invoking a handler
663 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
664 sigset_t *oldset, struct pt_regs * regs)
668 /* Set up the stack frame */
669 if (ka->sa.sa_flags & SA_SIGINFO)
670 ret = setup_rt_frame(sig, ka, info, oldset, regs);
672 ret = setup_frame(sig, ka, oldset, regs);
675 block_sigmask(ka, sig);
680 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
682 if (thread_info_flags & _TIF_SIGPENDING)
685 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
686 clear_thread_flag(TIF_NOTIFY_RESUME);
687 tracehook_notify_resume(regs);
688 if (current->replacement_session_keyring)
689 key_replace_session_keyring();