2 * arch/sparc64/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * Copyright (C) 1995, 2008 David S. Miller (davem@davemloft.net)
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)
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/tracehook.h>
21 #include <linux/unistd.h>
23 #include <linux/tty.h>
24 #include <linux/binfmts.h>
25 #include <linux/bitops.h>
27 #include <asm/uaccess.h>
28 #include <asm/ptrace.h>
29 #include <asm/pgtable.h>
30 #include <asm/fpumacro.h>
32 #include <asm/siginfo.h>
33 #include <asm/visasm.h>
39 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
41 /* {set, get}context() needed for 64-bit SparcLinux userland. */
42 asmlinkage
void sparc64_set_context(struct pt_regs
*regs
)
44 struct ucontext __user
*ucp
= (struct ucontext __user
*)
45 regs
->u_regs
[UREG_I0
];
46 mc_gregset_t __user
*grp
;
47 unsigned long pc
, npc
, tstate
;
53 if (get_thread_wsaved() ||
54 (((unsigned long)ucp
) & (sizeof(unsigned long)-1)) ||
55 (!__access_ok(ucp
, sizeof(*ucp
))))
57 grp
= &ucp
->uc_mcontext
.mc_gregs
;
58 err
= __get_user(pc
, &((*grp
)[MC_PC
]));
59 err
|= __get_user(npc
, &((*grp
)[MC_NPC
]));
60 if (err
|| ((pc
| npc
) & 3))
62 if (regs
->u_regs
[UREG_I1
]) {
65 if (_NSIG_WORDS
== 1) {
66 if (__get_user(set
.sig
[0], &ucp
->uc_sigmask
.sig
[0]))
69 if (__copy_from_user(&set
, &ucp
->uc_sigmask
, sizeof(sigset_t
)))
72 sigdelsetmask(&set
, ~_BLOCKABLE
);
73 set_current_blocked(&set
);
75 if (test_thread_flag(TIF_32BIT
)) {
81 err
|= __get_user(regs
->y
, &((*grp
)[MC_Y
]));
82 err
|= __get_user(tstate
, &((*grp
)[MC_TSTATE
]));
83 regs
->tstate
&= ~(TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
);
84 regs
->tstate
|= (tstate
& (TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
));
85 err
|= __get_user(regs
->u_regs
[UREG_G1
], (&(*grp
)[MC_G1
]));
86 err
|= __get_user(regs
->u_regs
[UREG_G2
], (&(*grp
)[MC_G2
]));
87 err
|= __get_user(regs
->u_regs
[UREG_G3
], (&(*grp
)[MC_G3
]));
88 err
|= __get_user(regs
->u_regs
[UREG_G4
], (&(*grp
)[MC_G4
]));
89 err
|= __get_user(regs
->u_regs
[UREG_G5
], (&(*grp
)[MC_G5
]));
90 err
|= __get_user(regs
->u_regs
[UREG_G6
], (&(*grp
)[MC_G6
]));
92 /* Skip %g7 as that's the thread register in userspace. */
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_rwin_t
*rwin_save
;
240 static long _sigpause_common(old_sigset_t set
)
244 current
->saved_sigmask
= current
->blocked
;
247 siginitset(&blocked
, set
);
248 set_current_blocked(&blocked
);
250 current
->state
= TASK_INTERRUPTIBLE
;
253 set_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
);
268 void do_rt_sigreturn(struct pt_regs
*regs
)
270 struct rt_signal_frame __user
*sf
;
271 unsigned long tpc
, tnpc
, tstate
;
272 __siginfo_fpu_t __user
*fpu_save
;
273 __siginfo_rwin_t __user
*rwin_save
;
277 /* Always make any pending restarted system calls return -EINTR */
278 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
280 synchronize_user_stack ();
281 sf
= (struct rt_signal_frame __user
*)
282 (regs
->u_regs
[UREG_FP
] + STACK_BIAS
);
284 /* 1. Make sure we are not getting garbage from the user */
285 if (((unsigned long) sf
) & 3)
288 err
= get_user(tpc
, &sf
->regs
.tpc
);
289 err
|= __get_user(tnpc
, &sf
->regs
.tnpc
);
290 if (test_thread_flag(TIF_32BIT
)) {
294 err
|= ((tpc
| tnpc
) & 3);
296 /* 2. Restore the state */
297 err
|= __get_user(regs
->y
, &sf
->regs
.y
);
298 err
|= __get_user(tstate
, &sf
->regs
.tstate
);
299 err
|= copy_from_user(regs
->u_regs
, sf
->regs
.u_regs
, sizeof(regs
->u_regs
));
301 /* User can only change condition codes and %asi in %tstate. */
302 regs
->tstate
&= ~(TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
);
303 regs
->tstate
|= (tstate
& (TSTATE_ASI
| TSTATE_ICC
| TSTATE_XCC
));
305 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
306 if (!err
&& fpu_save
)
307 err
|= restore_fpu_state(regs
, fpu_save
);
309 err
|= __copy_from_user(&set
, &sf
->mask
, sizeof(sigset_t
));
310 err
|= do_sigaltstack(&sf
->stack
, NULL
, (unsigned long)sf
);
315 err
|= __get_user(rwin_save
, &sf
->rwin_save
);
316 if (!err
&& rwin_save
) {
317 if (restore_rwin_state(rwin_save
))
324 /* Prevent syscall restart. */
325 pt_regs_clear_syscall(regs
);
327 sigdelsetmask(&set
, ~_BLOCKABLE
);
328 set_current_blocked(&set
);
331 force_sig(SIGSEGV
, current
);
334 /* Checks if the fp is valid */
335 static int invalid_frame_pointer(void __user
*fp
)
337 if (((unsigned long) fp
) & 15)
342 static inline void __user
*get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
, unsigned long framesize
)
344 unsigned long sp
= regs
->u_regs
[UREG_FP
] + STACK_BIAS
;
347 * If we are on the alternate signal stack and would overflow it, don't.
348 * Return an always-bogus address instead so we will die with SIGSEGV.
350 if (on_sig_stack(sp
) && !likely(on_sig_stack(sp
- framesize
)))
351 return (void __user
*) -1L;
353 /* This is the X/Open sanctioned signal stack switching. */
354 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
355 if (sas_ss_flags(sp
) == 0)
356 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
361 /* Always align the stack frame. This handles two cases. First,
362 * sigaltstack need not be mindful of platform specific stack
363 * alignment. Second, if we took this signal because the stack
364 * is not aligned properly, we'd like to take the signal cleanly
369 return (void __user
*) sp
;
373 setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
374 int signo
, sigset_t
*oldset
, siginfo_t
*info
)
376 struct rt_signal_frame __user
*sf
;
377 int wsaved
, err
, sf_size
;
380 /* 1. Make sure everything is clean */
381 synchronize_user_stack();
382 save_and_clear_fpu();
384 wsaved
= get_thread_wsaved();
386 sf_size
= sizeof(struct rt_signal_frame
);
387 if (current_thread_info()->fpsaved
[0] & FPRS_FEF
)
388 sf_size
+= sizeof(__siginfo_fpu_t
);
390 sf_size
+= sizeof(__siginfo_rwin_t
);
391 sf
= (struct rt_signal_frame __user
*)
392 get_sigframe(ka
, regs
, sf_size
);
394 if (invalid_frame_pointer (sf
))
399 /* 2. Save the current process state */
400 err
= copy_to_user(&sf
->regs
, regs
, sizeof (*regs
));
402 if (current_thread_info()->fpsaved
[0] & FPRS_FEF
) {
403 __siginfo_fpu_t __user
*fpu_save
= tail
;
404 tail
+= sizeof(__siginfo_fpu_t
);
405 err
|= save_fpu_state(regs
, fpu_save
);
406 err
|= __put_user((u64
)fpu_save
, &sf
->fpu_save
);
408 err
|= __put_user(0, &sf
->fpu_save
);
411 __siginfo_rwin_t __user
*rwin_save
= tail
;
412 tail
+= sizeof(__siginfo_rwin_t
);
413 err
|= save_rwin_state(wsaved
, rwin_save
);
414 err
|= __put_user((u64
)rwin_save
, &sf
->rwin_save
);
415 set_thread_wsaved(0);
417 err
|= __put_user(0, &sf
->rwin_save
);
420 /* Setup sigaltstack */
421 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
422 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
423 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
425 err
|= copy_to_user(&sf
->mask
, oldset
, sizeof(sigset_t
));
428 err
|= copy_in_user((u64 __user
*)sf
,
429 (u64 __user
*)(regs
->u_regs
[UREG_FP
] +
431 sizeof(struct reg_window
));
433 struct reg_window
*rp
;
435 rp
= ¤t_thread_info()->reg_window
[wsaved
- 1];
436 err
|= copy_to_user(sf
, rp
, 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
;
474 force_sigsegv(signo
, current
);
478 static inline int handle_signal(unsigned long signr
, struct k_sigaction
*ka
,
480 sigset_t
*oldset
, struct pt_regs
*regs
)
484 err
= setup_rt_frame(ka
, regs
, signr
, oldset
,
485 (ka
->sa
.sa_flags
& SA_SIGINFO
) ? info
: NULL
);
489 block_sigmask(ka
, signr
);
491 tracehook_signal_handler(signr
, info
, ka
, regs
, 0);
496 static inline void syscall_restart(unsigned long orig_i0
, struct pt_regs
*regs
,
497 struct sigaction
*sa
)
499 switch (regs
->u_regs
[UREG_I0
]) {
500 case ERESTART_RESTARTBLOCK
:
502 no_system_call_restart
:
503 regs
->u_regs
[UREG_I0
] = EINTR
;
504 regs
->tstate
|= (TSTATE_ICARRY
|TSTATE_XCARRY
);
507 if (!(sa
->sa_flags
& SA_RESTART
))
508 goto no_system_call_restart
;
511 regs
->u_regs
[UREG_I0
] = orig_i0
;
517 /* Note that 'init' is a special process: it doesn't get signals it doesn't
518 * want to handle. Thus you cannot kill init even with a SIGKILL even by
521 static void do_signal(struct pt_regs
*regs
, unsigned long orig_i0
)
523 struct k_sigaction ka
;
529 if (pt_regs_is_syscall(regs
) &&
530 (regs
->tstate
& (TSTATE_XCARRY
| TSTATE_ICARRY
))) {
535 if (current_thread_info()->status
& TS_RESTORE_SIGMASK
)
536 oldset
= ¤t
->saved_sigmask
;
538 oldset
= ¤t
->blocked
;
541 if (test_thread_flag(TIF_32BIT
)) {
542 extern void do_signal32(sigset_t
*, struct pt_regs
*,
544 unsigned long orig_i0
);
545 do_signal32(oldset
, regs
, restart_syscall
, orig_i0
);
550 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
552 /* If the debugger messes with the program counter, it clears
553 * the software "in syscall" bit, directing us to not perform
556 if (restart_syscall
&& !pt_regs_is_syscall(regs
))
561 syscall_restart(orig_i0
, regs
, &ka
.sa
);
562 if (handle_signal(signr
, &ka
, &info
, oldset
, regs
) == 0) {
563 /* A signal was successfully delivered; the saved
564 * sigmask will have been stored in the signal frame,
565 * and will be restored by sigreturn, so we can simply
566 * clear the TS_RESTORE_SIGMASK flag.
568 current_thread_info()->status
&= ~TS_RESTORE_SIGMASK
;
572 if (restart_syscall
&&
573 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
574 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
575 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
576 /* replay the system call when we are done */
577 regs
->u_regs
[UREG_I0
] = orig_i0
;
580 pt_regs_clear_syscall(regs
);
582 if (restart_syscall
&&
583 regs
->u_regs
[UREG_I0
] == ERESTART_RESTARTBLOCK
) {
584 regs
->u_regs
[UREG_G1
] = __NR_restart_syscall
;
587 pt_regs_clear_syscall(regs
);
590 /* If there's no signal to deliver, we just put the saved sigmask
593 if (current_thread_info()->status
& TS_RESTORE_SIGMASK
) {
594 current_thread_info()->status
&= ~TS_RESTORE_SIGMASK
;
595 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
599 void do_notify_resume(struct pt_regs
*regs
, unsigned long orig_i0
, unsigned long thread_info_flags
)
601 if (thread_info_flags
& _TIF_SIGPENDING
)
602 do_signal(regs
, orig_i0
);
603 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
604 clear_thread_flag(TIF_NOTIFY_RESUME
);
605 tracehook_notify_resume(regs
);
606 if (current
->replacement_session_keyring
)
607 key_replace_session_keyring();