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 * arch/sh64/kernel/signal.c
8 * Copyright (C) 2000, 2001 Paolo Alberelli
9 * Copyright (C) 2003 Paul Mundt
10 * Copyright (C) 2004 Richard Curnow
12 * Started from sh version.
15 #include <linux/rwsem.h>
16 #include <linux/sched.h>
18 #include <linux/smp.h>
19 #include <linux/kernel.h>
20 #include <linux/signal.h>
21 #include <linux/errno.h>
22 #include <linux/wait.h>
23 #include <linux/personality.h>
24 #include <linux/freezer.h>
25 #include <linux/ptrace.h>
26 #include <linux/unistd.h>
27 #include <linux/stddef.h>
28 #include <linux/personality.h>
29 #include <asm/ucontext.h>
30 #include <asm/uaccess.h>
31 #include <asm/pgtable.h>
40 #define REF_REG_RET regs->regs[REG_RET]
41 #define REF_REG_SP regs->regs[REG_SP]
42 #define DEREF_REG_PR regs->regs[REG_PR]
46 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
48 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
51 * Atomically swap in the new signal mask, and wait for a signal.
55 sys_sigsuspend(old_sigset_t mask,
56 unsigned long r3, unsigned long r4, unsigned long r5,
57 unsigned long r6, unsigned long r7,
58 struct pt_regs * regs)
63 spin_lock_irq(¤t->sighand->siglock);
64 saveset = current->blocked;
65 siginitset(¤t->blocked, mask);
67 spin_unlock_irq(¤t->sighand->siglock);
71 current->state = TASK_INTERRUPTIBLE;
73 regs->pc += 4; /* because sys_sigreturn decrements the pc */
74 if (do_signal(regs, &saveset)) {
75 /* pc now points at signal handler. Need to decrement
76 it because entry.S will increment it. */
84 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize,
85 unsigned long r4, unsigned long r5, unsigned long r6,
87 struct pt_regs * regs)
89 sigset_t saveset, newset;
91 /* XXX: Don't preclude handling different sized sigset_t's. */
92 if (sigsetsize != sizeof(sigset_t))
95 if (copy_from_user(&newset, unewset, sizeof(newset)))
97 sigdelsetmask(&newset, ~_BLOCKABLE);
98 spin_lock_irq(¤t->sighand->siglock);
99 saveset = current->blocked;
100 current->blocked = newset;
102 spin_unlock_irq(¤t->sighand->siglock);
104 REF_REG_RET = -EINTR;
106 current->state = TASK_INTERRUPTIBLE;
108 regs->pc += 4; /* because sys_sigreturn decrements the pc */
109 if (do_signal(regs, &saveset)) {
110 /* pc now points at signal handler. Need to decrement
111 it because entry.S will increment it. */
119 sys_sigaction(int sig, const struct old_sigaction __user *act,
120 struct old_sigaction __user *oact)
122 struct k_sigaction new_ka, old_ka;
127 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
128 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
129 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
131 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
132 __get_user(mask, &act->sa_mask);
133 siginitset(&new_ka.sa.sa_mask, mask);
136 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
139 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
140 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
141 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
143 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
144 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
151 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
152 unsigned long r4, unsigned long r5, unsigned long r6,
154 struct pt_regs * regs)
156 return do_sigaltstack(uss, uoss, REF_REG_SP);
161 * Do a signal return; undo the signal stack.
166 struct sigcontext sc;
167 unsigned long extramask[_NSIG_WORDS-1];
168 long long retcode[2];
173 struct siginfo __user *pinfo;
177 long long retcode[2];
182 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
187 err |= __get_user (fpvalid, &sc->sc_fpvalid);
188 conditional_used_math(fpvalid);
192 if (current == last_task_used_math) {
193 last_task_used_math = NULL;
197 err |= __copy_from_user(¤t->thread.fpu.hard, &sc->sc_fpregs[0],
198 (sizeof(long long) * 32) + (sizeof(int) * 1));
204 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
209 fpvalid = !!used_math();
210 err |= __put_user(fpvalid, &sc->sc_fpvalid);
214 if (current == last_task_used_math) {
216 fpsave(¤t->thread.fpu.hard);
218 last_task_used_math = NULL;
222 err |= __copy_to_user(&sc->sc_fpregs[0], ¤t->thread.fpu.hard,
223 (sizeof(long long) * 32) + (sizeof(int) * 1));
230 restore_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
233 setup_sigcontext_fpu(struct pt_regs *regs, struct sigcontext __user *sc)
238 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, long long *r2_p)
240 unsigned int err = 0;
241 unsigned long long current_sr, new_sr;
242 #define SR_MASK 0xffff8cfd
244 #define COPY(x) err |= __get_user(regs->x, &sc->sc_##x)
246 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
247 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
248 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
249 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
250 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
251 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
252 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
253 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
254 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
255 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
256 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
257 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
258 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
259 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
260 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
261 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
262 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
263 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
265 /* Prevent the signal handler manipulating SR in a way that can
266 crash the kernel. i.e. only allow S, Q, M, PR, SZ, FR to be
268 current_sr = regs->sr;
269 err |= __get_user(new_sr, &sc->sc_sr);
271 regs->sr |= (new_sr & ~SR_MASK);
277 /* Must do this last in case it sets regs->sr.fd (i.e. after rest of sr
278 * has been restored above.) */
279 err |= restore_sigcontext_fpu(regs, sc);
281 regs->syscall_nr = -1; /* disable syscall checks */
282 err |= __get_user(*r2_p, &sc->sc_regs[REG_RET]);
286 asmlinkage int sys_sigreturn(unsigned long r2, unsigned long r3,
287 unsigned long r4, unsigned long r5,
288 unsigned long r6, unsigned long r7,
289 struct pt_regs * regs)
291 struct sigframe __user *frame = (struct sigframe __user *) (long) REF_REG_SP;
295 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
298 if (__get_user(set.sig[0], &frame->sc.oldmask)
300 && __copy_from_user(&set.sig[1], &frame->extramask,
301 sizeof(frame->extramask))))
304 sigdelsetmask(&set, ~_BLOCKABLE);
306 spin_lock_irq(¤t->sighand->siglock);
307 current->blocked = set;
309 spin_unlock_irq(¤t->sighand->siglock);
311 if (restore_sigcontext(regs, &frame->sc, &ret))
318 force_sig(SIGSEGV, current);
322 asmlinkage int sys_rt_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 rt_sigframe __user *frame = (struct rt_sigframe __user *) (long) REF_REG_SP;
332 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
335 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
338 sigdelsetmask(&set, ~_BLOCKABLE);
339 spin_lock_irq(¤t->sighand->siglock);
340 current->blocked = set;
342 spin_unlock_irq(¤t->sighand->siglock);
344 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &ret))
348 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
350 /* It is more difficult to avoid calling this function than to
351 call it and ignore errors. */
352 do_sigaltstack(&st, NULL, REF_REG_SP);
357 force_sig(SIGSEGV, current);
362 * Set up a signal frame.
366 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
371 /* Do this first, otherwise is this sets sr->fd, that value isn't preserved. */
372 err |= setup_sigcontext_fpu(regs, sc);
374 #define COPY(x) err |= __put_user(regs->x, &sc->sc_##x)
376 COPY(regs[0]); COPY(regs[1]); COPY(regs[2]); COPY(regs[3]);
377 COPY(regs[4]); COPY(regs[5]); COPY(regs[6]); COPY(regs[7]);
378 COPY(regs[8]); COPY(regs[9]); COPY(regs[10]); COPY(regs[11]);
379 COPY(regs[12]); COPY(regs[13]); COPY(regs[14]); COPY(regs[15]);
380 COPY(regs[16]); COPY(regs[17]); COPY(regs[18]); COPY(regs[19]);
381 COPY(regs[20]); COPY(regs[21]); COPY(regs[22]); COPY(regs[23]);
382 COPY(regs[24]); COPY(regs[25]); COPY(regs[26]); COPY(regs[27]);
383 COPY(regs[28]); COPY(regs[29]); COPY(regs[30]); COPY(regs[31]);
384 COPY(regs[32]); COPY(regs[33]); COPY(regs[34]); COPY(regs[35]);
385 COPY(regs[36]); COPY(regs[37]); COPY(regs[38]); COPY(regs[39]);
386 COPY(regs[40]); COPY(regs[41]); COPY(regs[42]); COPY(regs[43]);
387 COPY(regs[44]); COPY(regs[45]); COPY(regs[46]); COPY(regs[47]);
388 COPY(regs[48]); COPY(regs[49]); COPY(regs[50]); COPY(regs[51]);
389 COPY(regs[52]); COPY(regs[53]); COPY(regs[54]); COPY(regs[55]);
390 COPY(regs[56]); COPY(regs[57]); COPY(regs[58]); COPY(regs[59]);
391 COPY(regs[60]); COPY(regs[61]); COPY(regs[62]);
392 COPY(tregs[0]); COPY(tregs[1]); COPY(tregs[2]); COPY(tregs[3]);
393 COPY(tregs[4]); COPY(tregs[5]); COPY(tregs[6]); COPY(tregs[7]);
398 err |= __put_user(mask, &sc->oldmask);
404 * Determine which stack to use..
406 static inline void __user *
407 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
409 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
410 sp = current->sas_ss_sp + current->sas_ss_size;
412 return (void __user *)((sp - frame_size) & -8ul);
415 void sa_default_restorer(void); /* See comments below */
416 void sa_default_rt_restorer(void); /* See comments below */
418 static void setup_frame(int sig, struct k_sigaction *ka,
419 sigset_t *set, struct pt_regs *regs)
421 struct sigframe __user *frame;
425 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
427 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
430 signal = current_thread_info()->exec_domain
431 && current_thread_info()->exec_domain->signal_invmap
433 ? current_thread_info()->exec_domain->signal_invmap[sig]
436 err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
438 /* Give up earlier as i386, in case */
442 if (_NSIG_WORDS > 1) {
443 err |= __copy_to_user(frame->extramask, &set->sig[1],
444 sizeof(frame->extramask)); }
446 /* Give up earlier as i386, in case */
450 /* Set up to return from userspace. If provided, use a stub
451 already in userspace. */
452 if (ka->sa.sa_flags & SA_RESTORER) {
453 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
456 * On SH5 all edited pointers are subject to NEFF
458 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
459 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
462 * Different approach on SH5.
463 * . Endianness independent asm code gets placed in entry.S .
464 * This is limited to four ASM instructions corresponding
465 * to two long longs in size.
466 * . err checking is done on the else branch only
467 * . flush_icache_range() is called upon __put_user() only
468 * . all edited pointers are subject to NEFF
469 * . being code, linker turns ShMedia bit on, always
470 * dereference index -1.
472 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
473 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
474 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
476 if (__copy_to_user(frame->retcode,
477 (unsigned long long)sa_default_restorer & (~1), 16) != 0)
480 /* Cohere the trampoline with the I-cache. */
481 flush_cache_sigtramp(DEREF_REG_PR-1, DEREF_REG_PR-1+16);
485 * Set up registers for signal handler.
486 * All edited pointers are subject to NEFF.
488 regs->regs[REG_SP] = (unsigned long) frame;
489 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
490 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
491 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
494 The glibc profiling support for SH-5 needs to be passed a sigcontext
495 so it can retrieve the PC. At some point during 2003 the glibc
496 support was changed to receive the sigcontext through the 2nd
497 argument, but there are still versions of libc.so in use that use
498 the 3rd argument. Until libc.so is stabilised, pass the sigcontext
499 through both 2nd and 3rd arguments.
502 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
503 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->sc;
505 regs->pc = (unsigned long) ka->sa.sa_handler;
506 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
512 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
514 current->comm, current->pid, frame,
515 regs->pc >> 32, regs->pc & 0xffffffff,
516 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
522 force_sigsegv(sig, current);
525 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
526 sigset_t *set, struct pt_regs *regs)
528 struct rt_sigframe __user *frame;
532 frame = get_sigframe(ka, regs->regs[REG_SP], sizeof(*frame));
534 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
537 signal = current_thread_info()->exec_domain
538 && current_thread_info()->exec_domain->signal_invmap
540 ? current_thread_info()->exec_domain->signal_invmap[sig]
543 err |= __put_user(&frame->info, &frame->pinfo);
544 err |= __put_user(&frame->uc, &frame->puc);
545 err |= copy_siginfo_to_user(&frame->info, info);
547 /* Give up earlier as i386, in case */
551 /* Create the ucontext. */
552 err |= __put_user(0, &frame->uc.uc_flags);
553 err |= __put_user(0, &frame->uc.uc_link);
554 err |= __put_user((void *)current->sas_ss_sp,
555 &frame->uc.uc_stack.ss_sp);
556 err |= __put_user(sas_ss_flags(regs->regs[REG_SP]),
557 &frame->uc.uc_stack.ss_flags);
558 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
559 err |= setup_sigcontext(&frame->uc.uc_mcontext,
561 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
563 /* Give up earlier as i386, in case */
567 /* Set up to return from userspace. If provided, use a stub
568 already in userspace. */
569 if (ka->sa.sa_flags & SA_RESTORER) {
570 DEREF_REG_PR = (unsigned long) ka->sa.sa_restorer | 0x1;
573 * On SH5 all edited pointers are subject to NEFF
575 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
576 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
579 * Different approach on SH5.
580 * . Endianness independent asm code gets placed in entry.S .
581 * This is limited to four ASM instructions corresponding
582 * to two long longs in size.
583 * . err checking is done on the else branch only
584 * . flush_icache_range() is called upon __put_user() only
585 * . all edited pointers are subject to NEFF
586 * . being code, linker turns ShMedia bit on, always
587 * dereference index -1.
590 DEREF_REG_PR = (unsigned long) frame->retcode | 0x01;
591 DEREF_REG_PR = (DEREF_REG_PR & NEFF_SIGN) ?
592 (DEREF_REG_PR | NEFF_MASK) : DEREF_REG_PR;
594 if (__copy_to_user(frame->retcode,
595 (unsigned long long)sa_default_rt_restorer & (~1), 16) != 0)
598 flush_icache_range(DEREF_REG_PR-1, DEREF_REG_PR-1+15);
602 * Set up registers for signal handler.
603 * All edited pointers are subject to NEFF.
605 regs->regs[REG_SP] = (unsigned long) frame;
606 regs->regs[REG_SP] = (regs->regs[REG_SP] & NEFF_SIGN) ?
607 (regs->regs[REG_SP] | NEFF_MASK) : regs->regs[REG_SP];
608 regs->regs[REG_ARG1] = signal; /* Arg for signal handler */
609 regs->regs[REG_ARG2] = (unsigned long long)(unsigned long)(signed long)&frame->info;
610 regs->regs[REG_ARG3] = (unsigned long long)(unsigned long)(signed long)&frame->uc.uc_mcontext;
611 regs->pc = (unsigned long) ka->sa.sa_handler;
612 regs->pc = (regs->pc & NEFF_SIGN) ? (regs->pc | NEFF_MASK) : regs->pc;
618 printk("SIG deliver (#%d,%s:%d): sp=%p pc=%08Lx%08Lx link=%08Lx%08Lx\n",
620 current->comm, current->pid, frame,
621 regs->pc >> 32, regs->pc & 0xffffffff,
622 DEREF_REG_PR >> 32, DEREF_REG_PR & 0xffffffff);
628 force_sigsegv(sig, current);
632 * OK, we're invoking a handler
636 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
637 sigset_t *oldset, struct pt_regs * regs)
639 /* Are we from a system call? */
640 if (regs->syscall_nr >= 0) {
641 /* If so, check system call restarting.. */
642 switch (regs->regs[REG_RET]) {
643 case -ERESTARTNOHAND:
644 regs->regs[REG_RET] = -EINTR;
648 if (!(ka->sa.sa_flags & SA_RESTART)) {
649 regs->regs[REG_RET] = -EINTR;
653 case -ERESTARTNOINTR:
654 /* Decode syscall # */
655 regs->regs[REG_RET] = regs->syscall_nr;
660 /* Set up the stack frame */
661 if (ka->sa.sa_flags & SA_SIGINFO)
662 setup_rt_frame(sig, ka, info, oldset, regs);
664 setup_frame(sig, ka, oldset, regs);
666 spin_lock_irq(¤t->sighand->siglock);
667 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
668 if (!(ka->sa.sa_flags & SA_NODEFER))
669 sigaddset(¤t->blocked,sig);
671 spin_unlock_irq(¤t->sighand->siglock);
675 * Note that 'init' is a special process: it doesn't get signals it doesn't
676 * want to handle. Thus you cannot kill init even with a SIGKILL even by
679 * Note that we go through the signals twice: once to check the signals that
680 * the kernel can handle, and then we build all the user-level signal handling
681 * stack-frames in one go after that.
683 int do_signal(struct pt_regs *regs, sigset_t *oldset)
687 struct k_sigaction ka;
690 * We want the common case to go fast, which
691 * is why we may in certain cases get here from
692 * kernel mode. Just return without doing anything
695 if (!user_mode(regs))
702 oldset = ¤t->blocked;
704 signr = get_signal_to_deliver(&info, &ka, regs, 0);
707 /* Whee! Actually deliver the signal. */
708 handle_signal(signr, &info, &ka, oldset, regs);
713 /* Did we come from a system call? */
714 if (regs->syscall_nr >= 0) {
715 /* Restart the system call - no handlers present */
716 if (regs->regs[REG_RET] == -ERESTARTNOHAND ||
717 regs->regs[REG_RET] == -ERESTARTSYS ||
718 regs->regs[REG_RET] == -ERESTARTNOINTR) {
719 /* Decode Syscall # */
720 regs->regs[REG_RET] = regs->syscall_nr;