1 /* linux/arch/sparc/kernel/signal.c
3 * Copyright (C) 1991, 1992 Linus Torvalds
4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
5 * Copyright (C) 1996 Miguel de Icaza (miguel@nuclecu.unam.mx)
6 * Copyright (C) 1997 Eddie C. Dost (ecd@skynet.be)
9 #include <linux/sched.h>
10 #include <linux/kernel.h>
11 #include <linux/signal.h>
12 #include <linux/errno.h>
13 #include <linux/wait.h>
14 #include <linux/ptrace.h>
15 #include <linux/unistd.h>
17 #include <linux/tty.h>
18 #include <linux/smp.h>
19 #include <linux/binfmts.h> /* do_coredum */
20 #include <linux/bitops.h>
21 #include <linux/tracehook.h>
23 #include <asm/uaccess.h>
24 #include <asm/ptrace.h>
25 #include <asm/pgalloc.h>
26 #include <asm/pgtable.h>
27 #include <asm/cacheflush.h> /* flush_sig_insns */
28 #include <asm/switch_to.h>
32 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
34 extern void fpsave(unsigned long *fpregs
, unsigned long *fsr
,
35 void *fpqueue
, unsigned long *fpqdepth
);
36 extern void fpload(unsigned long *fpregs
, unsigned long *fsr
);
39 struct sparc_stackf ss
;
41 __siginfo_fpu_t __user
*fpu_save
;
42 unsigned long insns
[2] __attribute__ ((aligned (8)));
43 unsigned int extramask
[_NSIG_WORDS
- 1];
44 unsigned int extra_size
; /* Should be 0 */
45 __siginfo_rwin_t __user
*rwin_save
;
46 } __attribute__((aligned(8)));
48 struct rt_signal_frame
{
49 struct sparc_stackf ss
;
53 __siginfo_fpu_t __user
*fpu_save
;
54 unsigned int insns
[2];
56 unsigned int extra_size
; /* Should be 0 */
57 __siginfo_rwin_t __user
*rwin_save
;
58 } __attribute__((aligned(8)));
61 #define SF_ALIGNEDSZ (((sizeof(struct signal_frame) + 7) & (~7)))
62 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
64 static int _sigpause_common(old_sigset_t set
)
67 siginitset(&blocked
, set
);
68 return sigsuspend(&blocked
);
71 asmlinkage
int sys_sigsuspend(old_sigset_t set
)
73 return _sigpause_common(set
);
76 asmlinkage
void do_sigreturn(struct pt_regs
*regs
)
78 struct signal_frame __user
*sf
;
79 unsigned long up_psr
, pc
, npc
;
81 __siginfo_fpu_t __user
*fpu_save
;
82 __siginfo_rwin_t __user
*rwin_save
;
85 /* Always make any pending restarted system calls return -EINTR */
86 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
88 synchronize_user_stack();
90 sf
= (struct signal_frame __user
*) regs
->u_regs
[UREG_FP
];
92 /* 1. Make sure we are not getting garbage from the user */
93 if (!access_ok(VERIFY_READ
, sf
, sizeof(*sf
)))
96 if (((unsigned long) sf
) & 3)
99 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
100 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
105 /* 2. Restore the state */
107 err
|= __copy_from_user(regs
, &sf
->info
.si_regs
, sizeof(struct pt_regs
));
109 /* User can only change condition codes and FPU enabling in %psr. */
110 regs
->psr
= (up_psr
& ~(PSR_ICC
| PSR_EF
))
111 | (regs
->psr
& (PSR_ICC
| PSR_EF
));
113 /* Prevent syscall restart. */
114 pt_regs_clear_syscall(regs
);
116 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
118 err
|= restore_fpu_state(regs
, fpu_save
);
119 err
|= __get_user(rwin_save
, &sf
->rwin_save
);
121 err
|= restore_rwin_state(rwin_save
);
123 /* This is pretty much atomic, no amount locking would prevent
124 * the races which exist anyways.
126 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
127 err
|= __copy_from_user(&set
.sig
[1], &sf
->extramask
,
128 (_NSIG_WORDS
-1) * sizeof(unsigned int));
133 sigdelsetmask(&set
, ~_BLOCKABLE
);
134 set_current_blocked(&set
);
138 force_sig(SIGSEGV
, current
);
141 asmlinkage
void do_rt_sigreturn(struct pt_regs
*regs
)
143 struct rt_signal_frame __user
*sf
;
144 unsigned int psr
, pc
, npc
;
145 __siginfo_fpu_t __user
*fpu_save
;
146 __siginfo_rwin_t __user
*rwin_save
;
152 synchronize_user_stack();
153 sf
= (struct rt_signal_frame __user
*) regs
->u_regs
[UREG_FP
];
154 if (!access_ok(VERIFY_READ
, sf
, sizeof(*sf
)) ||
155 (((unsigned long) sf
) & 0x03))
158 err
= __get_user(pc
, &sf
->regs
.pc
);
159 err
|= __get_user(npc
, &sf
->regs
.npc
);
160 err
|= ((pc
| npc
) & 0x03);
162 err
|= __get_user(regs
->y
, &sf
->regs
.y
);
163 err
|= __get_user(psr
, &sf
->regs
.psr
);
165 err
|= __copy_from_user(®s
->u_regs
[UREG_G1
],
166 &sf
->regs
.u_regs
[UREG_G1
], 15 * sizeof(u32
));
168 regs
->psr
= (regs
->psr
& ~PSR_ICC
) | (psr
& PSR_ICC
);
170 /* Prevent syscall restart. */
171 pt_regs_clear_syscall(regs
);
173 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
174 if (!err
&& fpu_save
)
175 err
|= restore_fpu_state(regs
, fpu_save
);
176 err
|= __copy_from_user(&set
, &sf
->mask
, sizeof(sigset_t
));
178 err
|= __copy_from_user(&st
, &sf
->stack
, sizeof(stack_t
));
186 /* It is more difficult to avoid calling this function than to
187 * call it and ignore errors.
191 do_sigaltstack((const stack_t __user
*) &st
, NULL
, (unsigned long)sf
);
194 err
|= __get_user(rwin_save
, &sf
->rwin_save
);
195 if (!err
&& rwin_save
) {
196 if (restore_rwin_state(rwin_save
))
200 sigdelsetmask(&set
, ~_BLOCKABLE
);
201 set_current_blocked(&set
);
204 force_sig(SIGSEGV
, current
);
207 /* Checks if the fp is valid */
208 static inline int invalid_frame_pointer(void __user
*fp
, int fplen
)
210 if ((((unsigned long) fp
) & 7) || !__access_ok((unsigned long)fp
, fplen
))
216 static inline void __user
*get_sigframe(struct sigaction
*sa
, struct pt_regs
*regs
, unsigned long framesize
)
218 unsigned long sp
= regs
->u_regs
[UREG_FP
];
221 * If we are on the alternate signal stack and would overflow it, don't.
222 * Return an always-bogus address instead so we will die with SIGSEGV.
224 if (on_sig_stack(sp
) && !likely(on_sig_stack(sp
- framesize
)))
225 return (void __user
*) -1L;
227 /* This is the X/Open sanctioned signal stack switching. */
228 if (sa
->sa_flags
& SA_ONSTACK
) {
229 if (sas_ss_flags(sp
) == 0)
230 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
235 /* Always align the stack frame. This handles two cases. First,
236 * sigaltstack need not be mindful of platform specific stack
237 * alignment. Second, if we took this signal because the stack
238 * is not aligned properly, we'd like to take the signal cleanly
243 return (void __user
*) sp
;
246 static int setup_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
247 int signo
, sigset_t
*oldset
)
249 struct signal_frame __user
*sf
;
250 int sigframe_size
, err
, wsaved
;
253 /* 1. Make sure everything is clean */
254 synchronize_user_stack();
256 wsaved
= current_thread_info()->w_saved
;
258 sigframe_size
= sizeof(*sf
);
260 sigframe_size
+= sizeof(__siginfo_fpu_t
);
262 sigframe_size
+= sizeof(__siginfo_rwin_t
);
264 sf
= (struct signal_frame __user
*)
265 get_sigframe(&ka
->sa
, regs
, sigframe_size
);
267 if (invalid_frame_pointer(sf
, sigframe_size
))
268 goto sigill_and_return
;
272 /* 2. Save the current process state */
273 err
= __copy_to_user(&sf
->info
.si_regs
, regs
, sizeof(struct pt_regs
));
275 err
|= __put_user(0, &sf
->extra_size
);
278 __siginfo_fpu_t __user
*fp
= tail
;
280 err
|= save_fpu_state(regs
, fp
);
281 err
|= __put_user(fp
, &sf
->fpu_save
);
283 err
|= __put_user(0, &sf
->fpu_save
);
286 __siginfo_rwin_t __user
*rwp
= tail
;
287 tail
+= sizeof(*rwp
);
288 err
|= save_rwin_state(wsaved
, rwp
);
289 err
|= __put_user(rwp
, &sf
->rwin_save
);
291 err
|= __put_user(0, &sf
->rwin_save
);
294 err
|= __put_user(oldset
->sig
[0], &sf
->info
.si_mask
);
295 err
|= __copy_to_user(sf
->extramask
, &oldset
->sig
[1],
296 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
298 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
299 sizeof(struct reg_window32
));
301 struct reg_window32
*rp
;
303 rp
= ¤t_thread_info()->reg_window
[wsaved
- 1];
304 err
|= __copy_to_user(sf
, rp
, sizeof(struct reg_window32
));
309 /* 3. signal handler back-trampoline and parameters */
310 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
311 regs
->u_regs
[UREG_I0
] = signo
;
312 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
313 regs
->u_regs
[UREG_I2
] = (unsigned long) &sf
->info
;
315 /* 4. signal handler */
316 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
317 regs
->npc
= (regs
->pc
+ 4);
319 /* 5. return to kernel instructions */
321 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
323 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
325 /* mov __NR_sigreturn, %g1 */
326 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
329 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
333 /* Flush instruction space. */
334 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
343 force_sigsegv(signo
, current
);
347 static int setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
348 int signo
, sigset_t
*oldset
, siginfo_t
*info
)
350 struct rt_signal_frame __user
*sf
;
351 int sigframe_size
, wsaved
;
356 synchronize_user_stack();
357 wsaved
= current_thread_info()->w_saved
;
358 sigframe_size
= sizeof(*sf
);
360 sigframe_size
+= sizeof(__siginfo_fpu_t
);
362 sigframe_size
+= sizeof(__siginfo_rwin_t
);
363 sf
= (struct rt_signal_frame __user
*)
364 get_sigframe(&ka
->sa
, regs
, sigframe_size
);
365 if (invalid_frame_pointer(sf
, sigframe_size
))
369 err
= __put_user(regs
->pc
, &sf
->regs
.pc
);
370 err
|= __put_user(regs
->npc
, &sf
->regs
.npc
);
371 err
|= __put_user(regs
->y
, &sf
->regs
.y
);
375 err
|= __put_user(psr
, &sf
->regs
.psr
);
376 err
|= __copy_to_user(&sf
->regs
.u_regs
, regs
->u_regs
, sizeof(regs
->u_regs
));
377 err
|= __put_user(0, &sf
->extra_size
);
380 __siginfo_fpu_t
*fp
= tail
;
382 err
|= save_fpu_state(regs
, fp
);
383 err
|= __put_user(fp
, &sf
->fpu_save
);
385 err
|= __put_user(0, &sf
->fpu_save
);
388 __siginfo_rwin_t
*rwp
= tail
;
389 tail
+= sizeof(*rwp
);
390 err
|= save_rwin_state(wsaved
, rwp
);
391 err
|= __put_user(rwp
, &sf
->rwin_save
);
393 err
|= __put_user(0, &sf
->rwin_save
);
395 err
|= __copy_to_user(&sf
->mask
, &oldset
->sig
[0], sizeof(sigset_t
));
397 /* Setup sigaltstack */
398 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
399 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
400 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
403 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
404 sizeof(struct reg_window32
));
406 struct reg_window32
*rp
;
408 rp
= ¤t_thread_info()->reg_window
[wsaved
- 1];
409 err
|= __copy_to_user(sf
, rp
, sizeof(struct reg_window32
));
412 err
|= copy_siginfo_to_user(&sf
->info
, info
);
417 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
418 regs
->u_regs
[UREG_I0
] = signo
;
419 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
420 regs
->u_regs
[UREG_I2
] = (unsigned long) &sf
->regs
;
422 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
423 regs
->npc
= (regs
->pc
+ 4);
426 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
428 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
430 /* mov __NR_sigreturn, %g1 */
431 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
434 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
438 /* Flush instruction space. */
439 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
448 force_sigsegv(signo
, current
);
453 handle_signal(unsigned long signr
, struct k_sigaction
*ka
,
454 siginfo_t
*info
, struct pt_regs
*regs
)
456 sigset_t
*oldset
= sigmask_to_save();
459 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
460 err
= setup_rt_frame(ka
, regs
, signr
, oldset
, info
);
462 err
= setup_frame(ka
, regs
, signr
, oldset
);
467 block_sigmask(ka
, signr
);
468 tracehook_signal_handler(signr
, info
, ka
, regs
, 0);
471 static inline void syscall_restart(unsigned long orig_i0
, struct pt_regs
*regs
,
472 struct sigaction
*sa
)
474 switch(regs
->u_regs
[UREG_I0
]) {
475 case ERESTART_RESTARTBLOCK
:
477 no_system_call_restart
:
478 regs
->u_regs
[UREG_I0
] = EINTR
;
482 if (!(sa
->sa_flags
& SA_RESTART
))
483 goto no_system_call_restart
;
486 regs
->u_regs
[UREG_I0
] = orig_i0
;
492 /* Note that 'init' is a special process: it doesn't get signals it doesn't
493 * want to handle. Thus you cannot kill init even with a SIGKILL even by
496 static void do_signal(struct pt_regs
*regs
, unsigned long orig_i0
)
498 struct k_sigaction ka
;
503 /* It's a lot of work and synchronization to add a new ptrace
504 * register for GDB to save and restore in order to get
505 * orig_i0 correct for syscall restarts when debugging.
507 * Although it should be the case that most of the global
508 * registers are volatile across a system call, glibc already
509 * depends upon that fact that we preserve them. So we can't
510 * just use any global register to save away the orig_i0 value.
512 * In particular %g2, %g3, %g4, and %g5 are all assumed to be
513 * preserved across a system call trap by various pieces of
516 * %g7 is used as the "thread register". %g6 is not used in
517 * any fixed manner. %g6 is used as a scratch register and
518 * a compiler temporary, but it's value is never used across
519 * a system call. Therefore %g6 is usable for orig_i0 storage.
521 if (pt_regs_is_syscall(regs
) && (regs
->psr
& PSR_C
))
522 regs
->u_regs
[UREG_G6
] = orig_i0
;
524 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
526 /* If the debugger messes with the program counter, it clears
527 * the software "in syscall" bit, directing us to not perform
531 if (pt_regs_is_syscall(regs
) && (regs
->psr
& PSR_C
)) {
533 orig_i0
= regs
->u_regs
[UREG_G6
];
539 syscall_restart(orig_i0
, regs
, &ka
.sa
);
540 handle_signal(signr
, &ka
, &info
, regs
);
543 if (restart_syscall
&&
544 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
545 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
546 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
547 /* replay the system call when we are done */
548 regs
->u_regs
[UREG_I0
] = orig_i0
;
551 pt_regs_clear_syscall(regs
);
553 if (restart_syscall
&&
554 regs
->u_regs
[UREG_I0
] == ERESTART_RESTARTBLOCK
) {
555 regs
->u_regs
[UREG_G1
] = __NR_restart_syscall
;
558 pt_regs_clear_syscall(regs
);
561 /* if there's no signal to deliver, we just put the saved sigmask
564 restore_saved_sigmask();
567 void do_notify_resume(struct pt_regs
*regs
, unsigned long orig_i0
,
568 unsigned long thread_info_flags
)
570 if (thread_info_flags
& _TIF_SIGPENDING
)
571 do_signal(regs
, orig_i0
);
572 if (thread_info_flags
& _TIF_NOTIFY_RESUME
) {
573 clear_thread_flag(TIF_NOTIFY_RESUME
);
574 tracehook_notify_resume(regs
);
579 do_sys_sigstack(struct sigstack __user
*ssptr
, struct sigstack __user
*ossptr
,
584 /* First see if old state is wanted. */
586 if (put_user(current
->sas_ss_sp
+ current
->sas_ss_size
,
587 &ossptr
->the_stack
) ||
588 __put_user(on_sig_stack(sp
), &ossptr
->cur_status
))
592 /* Now see if we want to update the new state. */
596 if (get_user(ss_sp
, &ssptr
->the_stack
))
598 /* If the current stack was set with sigaltstack, don't
599 swap stacks while we are on it. */
601 if (current
->sas_ss_sp
&& on_sig_stack(sp
))
604 /* Since we don't know the extent of the stack, and we don't
605 track onstack-ness, but rather calculate it, we must
606 presume a size. Ho hum this interface is lossy. */
607 current
->sas_ss_sp
= (unsigned long)ss_sp
- SIGSTKSZ
;
608 current
->sas_ss_size
= SIGSTKSZ
;
This page took 0.068028 seconds and 5 git commands to generate.