1 /* $Id: signal.c,v 1.60 2002/02/09 19:49:31 davem Exp $
2 * arch/sparc64/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
7 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
11 #ifdef CONFIG_SPARC32_COMPAT
12 #include <linux/compat.h> /* for compat_old_sigset_t */
14 #include <linux/sched.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/errno.h>
18 #include <linux/wait.h>
19 #include <linux/ptrace.h>
20 #include <linux/unistd.h>
22 #include <linux/tty.h>
23 #include <linux/binfmts.h>
24 #include <linux/bitops.h>
26 #include <asm/uaccess.h>
27 #include <asm/ptrace.h>
29 #include <asm/pgtable.h>
30 #include <asm/fpumacro.h>
32 #include <asm/siginfo.h>
33 #include <asm/visasm.h>
38 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
40 /* {set, get}context() needed for 64-bit SparcLinux userland. */
41 asmlinkage void sparc64_set_context(struct pt_regs *regs)
43 struct ucontext __user *ucp = (struct ucontext __user *)
44 regs->u_regs[UREG_I0];
45 mc_gregset_t __user *grp;
46 unsigned long pc, npc, tstate;
52 if (get_thread_wsaved() ||
53 (((unsigned long)ucp) & (sizeof(unsigned long)-1)) ||
54 (!__access_ok(ucp, sizeof(*ucp))))
56 grp = &ucp->uc_mcontext.mc_gregs;
57 err = __get_user(pc, &((*grp)[MC_PC]));
58 err |= __get_user(npc, &((*grp)[MC_NPC]));
59 if (err || ((pc | npc) & 3))
61 if (regs->u_regs[UREG_I1]) {
64 if (_NSIG_WORDS == 1) {
65 if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))
68 if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))
71 sigdelsetmask(&set, ~_BLOCKABLE);
72 spin_lock_irq(¤t->sighand->siglock);
73 current->blocked = set;
75 spin_unlock_irq(¤t->sighand->siglock);
77 if (test_thread_flag(TIF_32BIT)) {
83 err |= __get_user(regs->y, &((*grp)[MC_Y]));
84 err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
85 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);
86 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));
87 err |= __get_user(regs->u_regs[UREG_G1], (&(*grp)[MC_G1]));
88 err |= __get_user(regs->u_regs[UREG_G2], (&(*grp)[MC_G2]));
89 err |= __get_user(regs->u_regs[UREG_G3], (&(*grp)[MC_G3]));
90 err |= __get_user(regs->u_regs[UREG_G4], (&(*grp)[MC_G4]));
91 err |= __get_user(regs->u_regs[UREG_G5], (&(*grp)[MC_G5]));
92 err |= __get_user(regs->u_regs[UREG_G6], (&(*grp)[MC_G6]));
93 err |= __get_user(regs->u_regs[UREG_G7], (&(*grp)[MC_G7]));
94 err |= __get_user(regs->u_regs[UREG_I0], (&(*grp)[MC_O0]));
95 err |= __get_user(regs->u_regs[UREG_I1], (&(*grp)[MC_O1]));
96 err |= __get_user(regs->u_regs[UREG_I2], (&(*grp)[MC_O2]));
97 err |= __get_user(regs->u_regs[UREG_I3], (&(*grp)[MC_O3]));
98 err |= __get_user(regs->u_regs[UREG_I4], (&(*grp)[MC_O4]));
99 err |= __get_user(regs->u_regs[UREG_I5], (&(*grp)[MC_O5]));
100 err |= __get_user(regs->u_regs[UREG_I6], (&(*grp)[MC_O6]));
101 err |= __get_user(regs->u_regs[UREG_I7], (&(*grp)[MC_O7]));
103 err |= __get_user(fp, &(ucp->uc_mcontext.mc_fp));
104 err |= __get_user(i7, &(ucp->uc_mcontext.mc_i7));
105 err |= __put_user(fp,
106 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
107 err |= __put_user(i7,
108 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
110 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
112 unsigned long *fpregs = current_thread_info()->fpregs;
116 err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
118 err |= copy_from_user(fpregs,
119 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),
120 (sizeof(unsigned int) * 32));
122 err |= copy_from_user(fpregs+16,
123 ((unsigned long __user *)&(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs))+16,
124 (sizeof(unsigned int) * 32));
125 err |= __get_user(current_thread_info()->xfsr[0],
126 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
127 err |= __get_user(current_thread_info()->gsr[0],
128 &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
129 regs->tstate &= ~TSTATE_PEF;
136 force_sig(SIGSEGV, current);
139 asmlinkage void sparc64_get_context(struct pt_regs *regs)
141 struct ucontext __user *ucp = (struct ucontext __user *)
142 regs->u_regs[UREG_I0];
143 mc_gregset_t __user *grp;
144 mcontext_t __user *mcp;
145 unsigned long fp, i7;
149 synchronize_user_stack();
150 if (get_thread_wsaved() || clear_user(ucp, sizeof(*ucp)))
154 fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
156 fenab = (current_thread_info()->fpsaved[0] & FPRS_FEF);
159 mcp = &ucp->uc_mcontext;
160 grp = &mcp->mc_gregs;
162 /* Skip over the trap instruction, first. */
163 if (test_thread_flag(TIF_32BIT)) {
164 regs->tpc = (regs->tnpc & 0xffffffff);
165 regs->tnpc = (regs->tnpc + 4) & 0xffffffff;
167 regs->tpc = regs->tnpc;
171 if (_NSIG_WORDS == 1)
172 err |= __put_user(current->blocked.sig[0],
173 (unsigned long __user *)&ucp->uc_sigmask);
175 err |= __copy_to_user(&ucp->uc_sigmask, ¤t->blocked,
178 err |= __put_user(regs->tstate, &((*grp)[MC_TSTATE]));
179 err |= __put_user(regs->tpc, &((*grp)[MC_PC]));
180 err |= __put_user(regs->tnpc, &((*grp)[MC_NPC]));
181 err |= __put_user(regs->y, &((*grp)[MC_Y]));
182 err |= __put_user(regs->u_regs[UREG_G1], &((*grp)[MC_G1]));
183 err |= __put_user(regs->u_regs[UREG_G2], &((*grp)[MC_G2]));
184 err |= __put_user(regs->u_regs[UREG_G3], &((*grp)[MC_G3]));
185 err |= __put_user(regs->u_regs[UREG_G4], &((*grp)[MC_G4]));
186 err |= __put_user(regs->u_regs[UREG_G5], &((*grp)[MC_G5]));
187 err |= __put_user(regs->u_regs[UREG_G6], &((*grp)[MC_G6]));
188 err |= __put_user(regs->u_regs[UREG_G7], &((*grp)[MC_G7]));
189 err |= __put_user(regs->u_regs[UREG_I0], &((*grp)[MC_O0]));
190 err |= __put_user(regs->u_regs[UREG_I1], &((*grp)[MC_O1]));
191 err |= __put_user(regs->u_regs[UREG_I2], &((*grp)[MC_O2]));
192 err |= __put_user(regs->u_regs[UREG_I3], &((*grp)[MC_O3]));
193 err |= __put_user(regs->u_regs[UREG_I4], &((*grp)[MC_O4]));
194 err |= __put_user(regs->u_regs[UREG_I5], &((*grp)[MC_O5]));
195 err |= __put_user(regs->u_regs[UREG_I6], &((*grp)[MC_O6]));
196 err |= __put_user(regs->u_regs[UREG_I7], &((*grp)[MC_O7]));
198 err |= __get_user(fp,
199 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[6])));
200 err |= __get_user(i7,
201 (&(((struct reg_window __user *)(STACK_BIAS+regs->u_regs[UREG_I6]))->ins[7])));
202 err |= __put_user(fp, &(mcp->mc_fp));
203 err |= __put_user(i7, &(mcp->mc_i7));
205 err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));
207 unsigned long *fpregs = current_thread_info()->fpregs;
210 fprs = current_thread_info()->fpsaved[0];
212 err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,
213 (sizeof(unsigned int) * 32));
216 ((unsigned long __user *)&(mcp->mc_fpregs.mcfpu_fregs))+16, fpregs+16,
217 (sizeof(unsigned int) * 32));
218 err |= __put_user(current_thread_info()->xfsr[0], &(mcp->mc_fpregs.mcfpu_fsr));
219 err |= __put_user(current_thread_info()->gsr[0], &(mcp->mc_fpregs.mcfpu_gsr));
220 err |= __put_user(fprs, &(mcp->mc_fpregs.mcfpu_fprs));
227 force_sig(SIGSEGV, current);
230 struct rt_signal_frame {
231 struct sparc_stackf ss;
234 __siginfo_fpu_t __user *fpu_save;
237 __siginfo_fpu_t fpu_state;
241 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
243 static long _sigpause_common(old_sigset_t set)
246 spin_lock_irq(¤t->sighand->siglock);
247 current->saved_sigmask = current->blocked;
248 siginitset(¤t->blocked, set);
250 spin_unlock_irq(¤t->sighand->siglock);
252 current->state = TASK_INTERRUPTIBLE;
254 set_thread_flag(TIF_RESTORE_SIGMASK);
255 return -ERESTARTNOHAND;
258 asmlinkage long sys_sigpause(unsigned int set)
260 return _sigpause_common(set);
263 asmlinkage long sys_sigsuspend(old_sigset_t set)
265 return _sigpause_common(set);
269 restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
271 unsigned long *fpregs = current_thread_info()->fpregs;
275 err = __get_user(fprs, &fpu->si_fprs);
277 regs->tstate &= ~TSTATE_PEF;
279 err |= copy_from_user(fpregs, &fpu->si_float_regs[0],
280 (sizeof(unsigned int) * 32));
282 err |= copy_from_user(fpregs+16, &fpu->si_float_regs[32],
283 (sizeof(unsigned int) * 32));
284 err |= __get_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
285 err |= __get_user(current_thread_info()->gsr[0], &fpu->si_gsr);
286 current_thread_info()->fpsaved[0] |= fprs;
290 void do_rt_sigreturn(struct pt_regs *regs)
292 struct rt_signal_frame __user *sf;
293 unsigned long tpc, tnpc, tstate;
294 __siginfo_fpu_t __user *fpu_save;
298 /* Always make any pending restarted system calls return -EINTR */
299 current_thread_info()->restart_block.fn = do_no_restart_syscall;
301 synchronize_user_stack ();
302 sf = (struct rt_signal_frame __user *)
303 (regs->u_regs [UREG_FP] + STACK_BIAS);
305 /* 1. Make sure we are not getting garbage from the user */
306 if (((unsigned long) sf) & 3)
309 err = get_user(tpc, &sf->regs.tpc);
310 err |= __get_user(tnpc, &sf->regs.tnpc);
311 if (test_thread_flag(TIF_32BIT)) {
315 err |= ((tpc | tnpc) & 3);
317 /* 2. Restore the state */
318 err |= __get_user(regs->y, &sf->regs.y);
319 err |= __get_user(tstate, &sf->regs.tstate);
320 err |= copy_from_user(regs->u_regs, sf->regs.u_regs, sizeof(regs->u_regs));
322 /* User can only change condition codes and %asi in %tstate. */
323 regs->tstate &= ~(TSTATE_ASI | TSTATE_ICC | TSTATE_XCC);
324 regs->tstate |= (tstate & (TSTATE_ASI | TSTATE_ICC | TSTATE_XCC));
326 err |= __get_user(fpu_save, &sf->fpu_save);
328 err |= restore_fpu_state(regs, &sf->fpu_state);
330 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
331 err |= do_sigaltstack(&sf->stack, NULL, (unsigned long)sf);
339 sigdelsetmask(&set, ~_BLOCKABLE);
340 spin_lock_irq(¤t->sighand->siglock);
341 current->blocked = set;
343 spin_unlock_irq(¤t->sighand->siglock);
346 force_sig(SIGSEGV, current);
349 /* Checks if the fp is valid */
350 static int invalid_frame_pointer(void __user *fp, int fplen)
352 if (((unsigned long) fp) & 7)
358 save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t __user *fpu)
360 unsigned long *fpregs = (unsigned long *)(regs+1);
364 fprs = current_thread_info()->fpsaved[0];
366 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
367 (sizeof(unsigned int) * 32));
369 err |= copy_to_user(&fpu->si_float_regs[32], fpregs+16,
370 (sizeof(unsigned int) * 32));
371 err |= __put_user(current_thread_info()->xfsr[0], &fpu->si_fsr);
372 err |= __put_user(current_thread_info()->gsr[0], &fpu->si_gsr);
373 err |= __put_user(fprs, &fpu->si_fprs);
378 static inline void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize)
382 sp = regs->u_regs[UREG_FP] + STACK_BIAS;
384 /* This is the X/Open sanctioned signal stack switching. */
385 if (ka->sa.sa_flags & SA_ONSTACK) {
386 if (!on_sig_stack(sp) &&
387 !((current->sas_ss_sp + current->sas_ss_size) & 7))
388 sp = current->sas_ss_sp + current->sas_ss_size;
390 return (void __user *)(sp - framesize);
394 setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
395 int signo, sigset_t *oldset, siginfo_t *info)
397 struct rt_signal_frame __user *sf;
398 int sigframe_size, err;
400 /* 1. Make sure everything is clean */
401 synchronize_user_stack();
402 save_and_clear_fpu();
404 sigframe_size = RT_ALIGNEDSZ;
405 if (!(current_thread_info()->fpsaved[0] & FPRS_FEF))
406 sigframe_size -= sizeof(__siginfo_fpu_t);
408 sf = (struct rt_signal_frame __user *)
409 get_sigframe(ka, regs, sigframe_size);
411 if (invalid_frame_pointer (sf, sigframe_size))
414 if (get_thread_wsaved() != 0)
417 /* 2. Save the current process state */
418 err = copy_to_user(&sf->regs, regs, sizeof (*regs));
420 if (current_thread_info()->fpsaved[0] & FPRS_FEF) {
421 err |= save_fpu_state(regs, &sf->fpu_state);
422 err |= __put_user((u64)&sf->fpu_state, &sf->fpu_save);
424 err |= __put_user(0, &sf->fpu_save);
427 /* Setup sigaltstack */
428 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
429 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
430 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
432 err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));
434 err |= copy_in_user((u64 __user *)sf,
435 (u64 __user *)(regs->u_regs[UREG_FP]+STACK_BIAS),
436 sizeof(struct reg_window));
439 err |= copy_siginfo_to_user(&sf->info, info);
441 err |= __put_user(signo, &sf->info.si_signo);
442 err |= __put_user(SI_NOINFO, &sf->info.si_code);
447 /* 3. signal handler back-trampoline and parameters */
448 regs->u_regs[UREG_FP] = ((unsigned long) sf) - STACK_BIAS;
449 regs->u_regs[UREG_I0] = signo;
450 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
452 /* The sigcontext is passed in this way because of how it
453 * is defined in GLIBC's /usr/include/bits/sigcontext.h
454 * for sparc64. It includes the 128 bytes of siginfo_t.
456 regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
458 /* 5. signal handler */
459 regs->tpc = (unsigned long) ka->sa.sa_handler;
460 regs->tnpc = (regs->tpc + 4);
461 if (test_thread_flag(TIF_32BIT)) {
462 regs->tpc &= 0xffffffff;
463 regs->tnpc &= 0xffffffff;
465 /* 4. return to kernel instructions */
466 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
472 force_sigsegv(signo, current);
475 static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
477 sigset_t *oldset, struct pt_regs *regs)
479 setup_rt_frame(ka, regs, signr, oldset,
480 (ka->sa.sa_flags & SA_SIGINFO) ? info : NULL);
481 spin_lock_irq(¤t->sighand->siglock);
482 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
483 if (!(ka->sa.sa_flags & SA_NOMASK))
484 sigaddset(¤t->blocked,signr);
486 spin_unlock_irq(¤t->sighand->siglock);
489 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
490 struct sigaction *sa)
492 switch (regs->u_regs[UREG_I0]) {
493 case ERESTART_RESTARTBLOCK:
495 no_system_call_restart:
496 regs->u_regs[UREG_I0] = EINTR;
497 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
500 if (!(sa->sa_flags & SA_RESTART))
501 goto no_system_call_restart;
504 regs->u_regs[UREG_I0] = orig_i0;
510 /* Note that 'init' is a special process: it doesn't get signals it doesn't
511 * want to handle. Thus you cannot kill init even with a SIGKILL even by
514 static void do_signal(struct pt_regs *regs, unsigned long orig_i0, int restart_syscall)
517 struct signal_deliver_cookie cookie;
518 struct k_sigaction ka;
522 cookie.restart_syscall = restart_syscall;
523 cookie.orig_i0 = orig_i0;
525 if (test_thread_flag(TIF_RESTORE_SIGMASK))
526 oldset = ¤t->saved_sigmask;
528 oldset = ¤t->blocked;
530 #ifdef CONFIG_SPARC32_COMPAT
531 if (test_thread_flag(TIF_32BIT)) {
532 extern void do_signal32(sigset_t *, struct pt_regs *,
534 do_signal32(oldset, regs, orig_i0,
535 cookie.restart_syscall);
540 signr = get_signal_to_deliver(&info, &ka, regs, &cookie);
542 if (cookie.restart_syscall)
543 syscall_restart(orig_i0, regs, &ka.sa);
544 handle_signal(signr, &ka, &info, oldset, regs);
546 /* a signal was successfully delivered; the saved
547 * sigmask will have been stored in the signal frame,
548 * and will be restored by sigreturn, so we can simply
549 * clear the TIF_RESTORE_SIGMASK flag.
551 if (test_thread_flag(TIF_RESTORE_SIGMASK))
552 clear_thread_flag(TIF_RESTORE_SIGMASK);
555 if (cookie.restart_syscall &&
556 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
557 regs->u_regs[UREG_I0] == ERESTARTSYS ||
558 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
559 /* replay the system call when we are done */
560 regs->u_regs[UREG_I0] = cookie.orig_i0;
564 if (cookie.restart_syscall &&
565 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
566 regs->u_regs[UREG_G1] = __NR_restart_syscall;
571 /* if there's no signal to deliver, we just put the saved sigmask
574 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
575 clear_thread_flag(TIF_RESTORE_SIGMASK);
576 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
580 void do_notify_resume(struct pt_regs *regs, unsigned long orig_i0, int restart_syscall,
581 unsigned long thread_info_flags)
583 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
584 do_signal(regs, orig_i0, restart_syscall);
587 void ptrace_signal_deliver(struct pt_regs *regs, void *cookie)
589 struct signal_deliver_cookie *cp = cookie;
591 if (cp->restart_syscall &&
592 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
593 regs->u_regs[UREG_I0] == ERESTARTSYS ||
594 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
595 /* replay the system call when we are done */
596 regs->u_regs[UREG_I0] = cp->orig_i0;
599 cp->restart_syscall = 0;
601 if (cp->restart_syscall &&
602 regs->u_regs[UREG_I0] == ERESTART_RESTARTBLOCK) {
603 regs->u_regs[UREG_G1] = __NR_restart_syscall;
606 cp->restart_syscall = 0;