1 /* $Id: signal.c,v 1.110 2002/02/08 03:57:14 davem Exp $
2 * linux/arch/sparc/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)
10 #include <linux/sched.h>
11 #include <linux/kernel.h>
12 #include <linux/signal.h>
13 #include <linux/errno.h>
14 #include <linux/wait.h>
15 #include <linux/ptrace.h>
16 #include <linux/unistd.h>
18 #include <linux/tty.h>
19 #include <linux/smp.h>
20 #include <linux/binfmts.h> /* do_coredum */
21 #include <linux/bitops.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 */
29 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
31 extern void fpsave(unsigned long *fpregs
, unsigned long *fsr
,
32 void *fpqueue
, unsigned long *fpqdepth
);
33 extern void fpload(unsigned long *fpregs
, unsigned long *fsr
);
35 /* Signal frames: the original one (compatible with SunOS):
37 * Set up a signal frame... Make the stack look the way SunOS
38 * expects it to look which is basically:
40 * ---------------------------------- <-- %sp at signal time
43 * Ptr to sigcontext area above
45 * The signal number itself
47 * ---------------------------------- <-- New %sp
49 struct signal_sframe
{
50 struct reg_window sig_window
;
53 struct sigcontext __user
*sig_scptr
;
55 struct sigcontext sig_context
;
56 unsigned int extramask
[_NSIG_WORDS
- 1];
60 * And the new one, intended to be used for Linux applications only
61 * (we have enough in there to work with clone).
62 * All the interesting bits are in the info field.
65 struct new_signal_frame
{
66 struct sparc_stackf ss
;
68 __siginfo_fpu_t __user
*fpu_save
;
69 unsigned long insns
[2] __attribute__ ((aligned (8)));
70 unsigned int extramask
[_NSIG_WORDS
- 1];
71 unsigned int extra_size
; /* Should be 0 */
72 __siginfo_fpu_t fpu_state
;
75 struct rt_signal_frame
{
76 struct sparc_stackf ss
;
80 __siginfo_fpu_t __user
*fpu_save
;
81 unsigned int insns
[2];
83 unsigned int extra_size
; /* Should be 0 */
84 __siginfo_fpu_t fpu_state
;
88 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))
89 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame) + 7) & (~7)))
90 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
92 static int _sigpause_common(old_sigset_t set
)
95 spin_lock_irq(¤t
->sighand
->siglock
);
96 current
->saved_sigmask
= current
->blocked
;
97 siginitset(¤t
->blocked
, set
);
99 spin_unlock_irq(¤t
->sighand
->siglock
);
101 current
->state
= TASK_INTERRUPTIBLE
;
103 set_thread_flag(TIF_RESTORE_SIGMASK
);
105 return -ERESTARTNOHAND
;
108 asmlinkage
int sys_sigsuspend(old_sigset_t set
)
110 return _sigpause_common(set
);
114 restore_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t __user
*fpu
)
118 if (test_tsk_thread_flag(current
, TIF_USEDFPU
))
119 regs
->psr
&= ~PSR_EF
;
121 if (current
== last_task_used_math
) {
122 last_task_used_math
= NULL
;
123 regs
->psr
&= ~PSR_EF
;
127 clear_tsk_thread_flag(current
, TIF_USEDFPU
);
129 if (!access_ok(VERIFY_READ
, fpu
, sizeof(*fpu
)))
132 err
= __copy_from_user(¤t
->thread
.float_regs
[0], &fpu
->si_float_regs
[0],
133 (sizeof(unsigned long) * 32));
134 err
|= __get_user(current
->thread
.fsr
, &fpu
->si_fsr
);
135 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
136 if (current
->thread
.fpqdepth
!= 0)
137 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
139 ((sizeof(unsigned long) +
140 (sizeof(unsigned long *)))*16));
144 static inline void do_new_sigreturn (struct pt_regs
*regs
)
146 struct new_signal_frame __user
*sf
;
147 unsigned long up_psr
, pc
, npc
;
149 __siginfo_fpu_t __user
*fpu_save
;
152 sf
= (struct new_signal_frame __user
*) regs
->u_regs
[UREG_FP
];
154 /* 1. Make sure we are not getting garbage from the user */
155 if (!access_ok(VERIFY_READ
, sf
, sizeof(*sf
)))
158 if (((unsigned long) sf
) & 3)
161 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
162 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
167 /* 2. Restore the state */
169 err
|= __copy_from_user(regs
, &sf
->info
.si_regs
, sizeof(struct pt_regs
));
171 /* User can only change condition codes and FPU enabling in %psr. */
172 regs
->psr
= (up_psr
& ~(PSR_ICC
| PSR_EF
))
173 | (regs
->psr
& (PSR_ICC
| PSR_EF
));
175 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
178 err
|= restore_fpu_state(regs
, fpu_save
);
180 /* This is pretty much atomic, no amount locking would prevent
181 * the races which exist anyways.
183 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
184 err
|= __copy_from_user(&set
.sig
[1], &sf
->extramask
,
185 (_NSIG_WORDS
-1) * sizeof(unsigned int));
190 sigdelsetmask(&set
, ~_BLOCKABLE
);
191 spin_lock_irq(¤t
->sighand
->siglock
);
192 current
->blocked
= set
;
194 spin_unlock_irq(¤t
->sighand
->siglock
);
198 force_sig(SIGSEGV
, current
);
201 asmlinkage
void do_sigreturn(struct pt_regs
*regs
)
203 struct sigcontext __user
*scptr
;
204 unsigned long pc
, npc
, psr
;
208 /* Always make any pending restarted system calls return -EINTR */
209 current_thread_info()->restart_block
.fn
= do_no_restart_syscall
;
211 synchronize_user_stack();
213 if (current
->thread
.new_signal
) {
214 do_new_sigreturn(regs
);
218 scptr
= (struct sigcontext __user
*) regs
->u_regs
[UREG_I0
];
220 /* Check sanity of the user arg. */
221 if (!access_ok(VERIFY_READ
, scptr
, sizeof(struct sigcontext
)) ||
222 (((unsigned long) scptr
) & 3))
225 err
= __get_user(pc
, &scptr
->sigc_pc
);
226 err
|= __get_user(npc
, &scptr
->sigc_npc
);
231 /* This is pretty much atomic, no amount locking would prevent
232 * the races which exist anyways.
234 err
|= __get_user(set
.sig
[0], &scptr
->sigc_mask
);
235 /* Note that scptr + 1 points to extramask */
236 err
|= __copy_from_user(&set
.sig
[1], scptr
+ 1,
237 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
242 sigdelsetmask(&set
, ~_BLOCKABLE
);
243 spin_lock_irq(¤t
->sighand
->siglock
);
244 current
->blocked
= set
;
246 spin_unlock_irq(¤t
->sighand
->siglock
);
251 err
= __get_user(regs
->u_regs
[UREG_FP
], &scptr
->sigc_sp
);
252 err
|= __get_user(regs
->u_regs
[UREG_I0
], &scptr
->sigc_o0
);
253 err
|= __get_user(regs
->u_regs
[UREG_G1
], &scptr
->sigc_g1
);
255 /* User can only change condition codes in %psr. */
256 err
|= __get_user(psr
, &scptr
->sigc_psr
);
260 regs
->psr
&= ~(PSR_ICC
);
261 regs
->psr
|= (psr
& PSR_ICC
);
265 force_sig(SIGSEGV
, current
);
268 asmlinkage
void do_rt_sigreturn(struct pt_regs
*regs
)
270 struct rt_signal_frame __user
*sf
;
271 unsigned int psr
, pc
, npc
;
272 __siginfo_fpu_t __user
*fpu_save
;
278 synchronize_user_stack();
279 sf
= (struct rt_signal_frame __user
*) regs
->u_regs
[UREG_FP
];
280 if (!access_ok(VERIFY_READ
, sf
, sizeof(*sf
)) ||
281 (((unsigned long) sf
) & 0x03))
284 err
= __get_user(pc
, &sf
->regs
.pc
);
285 err
|= __get_user(npc
, &sf
->regs
.npc
);
286 err
|= ((pc
| npc
) & 0x03);
288 err
|= __get_user(regs
->y
, &sf
->regs
.y
);
289 err
|= __get_user(psr
, &sf
->regs
.psr
);
291 err
|= __copy_from_user(®s
->u_regs
[UREG_G1
],
292 &sf
->regs
.u_regs
[UREG_G1
], 15 * sizeof(u32
));
294 regs
->psr
= (regs
->psr
& ~PSR_ICC
) | (psr
& PSR_ICC
);
296 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
299 err
|= restore_fpu_state(regs
, fpu_save
);
300 err
|= __copy_from_user(&set
, &sf
->mask
, sizeof(sigset_t
));
302 err
|= __copy_from_user(&st
, &sf
->stack
, sizeof(stack_t
));
310 /* It is more difficult to avoid calling this function than to
311 * call it and ignore errors.
315 do_sigaltstack((const stack_t __user
*) &st
, NULL
, (unsigned long)sf
);
318 sigdelsetmask(&set
, ~_BLOCKABLE
);
319 spin_lock_irq(¤t
->sighand
->siglock
);
320 current
->blocked
= set
;
322 spin_unlock_irq(¤t
->sighand
->siglock
);
325 force_sig(SIGSEGV
, current
);
328 /* Checks if the fp is valid */
329 static inline int invalid_frame_pointer(void __user
*fp
, int fplen
)
331 if ((((unsigned long) fp
) & 7) ||
332 !__access_ok((unsigned long)fp
, fplen
) ||
333 ((sparc_cpu_model
== sun4
|| sparc_cpu_model
== sun4c
) &&
334 ((unsigned long) fp
< 0xe0000000 && (unsigned long) fp
>= 0x20000000)))
340 static inline void __user
*get_sigframe(struct sigaction
*sa
, struct pt_regs
*regs
, unsigned long framesize
)
344 sp
= regs
->u_regs
[UREG_FP
];
346 /* This is the X/Open sanctioned signal stack switching. */
347 if (sa
->sa_flags
& SA_ONSTACK
) {
348 if (!on_sig_stack(sp
) && !((current
->sas_ss_sp
+ current
->sas_ss_size
) & 7))
349 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
351 return (void __user
*)(sp
- framesize
);
355 setup_frame(struct sigaction
*sa
, struct pt_regs
*regs
, int signr
, sigset_t
*oldset
, siginfo_t
*info
)
357 struct signal_sframe __user
*sframep
;
358 struct sigcontext __user
*sc
;
360 unsigned long pc
= regs
->pc
;
361 unsigned long npc
= regs
->npc
;
362 struct thread_info
*tp
= current_thread_info();
363 void __user
*sig_address
;
366 synchronize_user_stack();
367 sframep
= (struct signal_sframe __user
*)
368 get_sigframe(sa
, regs
, SF_ALIGNEDSZ
);
369 if (invalid_frame_pointer(sframep
, sizeof(*sframep
))){
370 /* Don't change signal code and address, so that
371 * post mortem debuggers can have a look.
373 goto sigill_and_return
;
376 sc
= &sframep
->sig_context
;
378 /* We've already made sure frame pointer isn't in kernel space... */
379 err
= __put_user((sas_ss_flags(regs
->u_regs
[UREG_FP
]) == SS_ONSTACK
),
381 err
|= __put_user(oldset
->sig
[0], &sc
->sigc_mask
);
382 err
|= __copy_to_user(sframep
->extramask
, &oldset
->sig
[1],
383 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
384 err
|= __put_user(regs
->u_regs
[UREG_FP
], &sc
->sigc_sp
);
385 err
|= __put_user(pc
, &sc
->sigc_pc
);
386 err
|= __put_user(npc
, &sc
->sigc_npc
);
387 err
|= __put_user(regs
->psr
, &sc
->sigc_psr
);
388 err
|= __put_user(regs
->u_regs
[UREG_G1
], &sc
->sigc_g1
);
389 err
|= __put_user(regs
->u_regs
[UREG_I0
], &sc
->sigc_o0
);
390 err
|= __put_user(tp
->w_saved
, &sc
->sigc_oswins
);
392 for (window
= 0; window
< tp
->w_saved
; window
++) {
393 put_user((char *)tp
->rwbuf_stkptrs
[window
],
394 &sc
->sigc_spbuf
[window
]);
395 err
|= __copy_to_user(&sc
->sigc_wbuf
[window
],
396 &tp
->reg_window
[window
],
397 sizeof(struct reg_window
));
400 err
|= __copy_to_user(sframep
, (char *) regs
->u_regs
[UREG_FP
],
401 sizeof(struct reg_window
));
403 tp
->w_saved
= 0; /* So process is allowed to execute. */
405 err
|= __put_user(signr
, &sframep
->sig_num
);
408 if (SI_FROMKERNEL (info
) && (info
->si_code
& __SI_MASK
) == __SI_FAULT
) {
409 sig_address
= info
->si_addr
;
412 switch (info
->si_code
) {
413 case SEGV_MAPERR
: sig_code
= SUBSIG_NOMAPPING
; break;
414 default: sig_code
= SUBSIG_PROTECTION
; break;
418 switch (info
->si_code
) {
419 case ILL_ILLOPC
: sig_code
= SUBSIG_ILLINST
; break;
420 case ILL_PRVOPC
: sig_code
= SUBSIG_PRIVINST
; break;
421 case ILL_ILLTRP
: sig_code
= SUBSIG_BADTRAP(info
->si_trapno
); break;
422 default: sig_code
= SUBSIG_STACK
; break;
426 switch (info
->si_code
) {
427 case FPE_INTDIV
: sig_code
= SUBSIG_IDIVZERO
; break;
428 case FPE_INTOVF
: sig_code
= SUBSIG_FPINTOVFL
; break;
429 case FPE_FLTDIV
: sig_code
= SUBSIG_FPDIVZERO
; break;
430 case FPE_FLTOVF
: sig_code
= SUBSIG_FPOVFLOW
; break;
431 case FPE_FLTUND
: sig_code
= SUBSIG_FPUNFLOW
; break;
432 case FPE_FLTRES
: sig_code
= SUBSIG_FPINEXACT
; break;
433 case FPE_FLTINV
: sig_code
= SUBSIG_FPOPERROR
; break;
434 default: sig_code
= SUBSIG_FPERROR
; break;
438 switch (info
->si_code
) {
439 case BUS_ADRALN
: sig_code
= SUBSIG_ALIGNMENT
; break;
440 case BUS_ADRERR
: sig_code
= SUBSIG_MISCERROR
; break;
441 default: sig_code
= SUBSIG_BUSTIMEOUT
; break;
445 switch (info
->si_code
) {
446 case EMT_TAGOVF
: sig_code
= SUBSIG_TAG
; break;
450 if (info
->si_code
== (__SI_FAULT
|0x100)) {
451 sig_code
= info
->si_trapno
;
458 err
|= __put_user((unsigned long)sig_address
, &sframep
->sig_address
);
459 err
|= __put_user(sig_code
, &sframep
->sig_code
);
460 err
|= __put_user(sc
, &sframep
->sig_scptr
);
464 regs
->u_regs
[UREG_FP
] = (unsigned long) sframep
;
465 regs
->pc
= (unsigned long) sa
->sa_handler
;
466 regs
->npc
= (regs
->pc
+ 4);
472 force_sigsegv(signr
, current
);
477 save_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t __user
*fpu
)
481 if (test_tsk_thread_flag(current
, TIF_USEDFPU
)) {
482 put_psr(get_psr() | PSR_EF
);
483 fpsave(¤t
->thread
.float_regs
[0], ¤t
->thread
.fsr
,
484 ¤t
->thread
.fpqueue
[0], ¤t
->thread
.fpqdepth
);
485 regs
->psr
&= ~(PSR_EF
);
486 clear_tsk_thread_flag(current
, TIF_USEDFPU
);
489 if (current
== last_task_used_math
) {
490 put_psr(get_psr() | PSR_EF
);
491 fpsave(¤t
->thread
.float_regs
[0], ¤t
->thread
.fsr
,
492 ¤t
->thread
.fpqueue
[0], ¤t
->thread
.fpqdepth
);
493 last_task_used_math
= NULL
;
494 regs
->psr
&= ~(PSR_EF
);
497 err
|= __copy_to_user(&fpu
->si_float_regs
[0],
498 ¤t
->thread
.float_regs
[0],
499 (sizeof(unsigned long) * 32));
500 err
|= __put_user(current
->thread
.fsr
, &fpu
->si_fsr
);
501 err
|= __put_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
502 if (current
->thread
.fpqdepth
!= 0)
503 err
|= __copy_to_user(&fpu
->si_fpqueue
[0],
504 ¤t
->thread
.fpqueue
[0],
505 ((sizeof(unsigned long) +
506 (sizeof(unsigned long *)))*16));
512 new_setup_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
513 int signo
, sigset_t
*oldset
)
515 struct new_signal_frame __user
*sf
;
516 int sigframe_size
, err
;
518 /* 1. Make sure everything is clean */
519 synchronize_user_stack();
521 sigframe_size
= NF_ALIGNEDSZ
;
523 sigframe_size
-= sizeof(__siginfo_fpu_t
);
525 sf
= (struct new_signal_frame __user
*)
526 get_sigframe(&ka
->sa
, regs
, sigframe_size
);
528 if (invalid_frame_pointer(sf
, sigframe_size
))
529 goto sigill_and_return
;
531 if (current_thread_info()->w_saved
!= 0)
532 goto sigill_and_return
;
534 /* 2. Save the current process state */
535 err
= __copy_to_user(&sf
->info
.si_regs
, regs
, sizeof(struct pt_regs
));
537 err
|= __put_user(0, &sf
->extra_size
);
540 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
541 err
|= __put_user(&sf
->fpu_state
, &sf
->fpu_save
);
543 err
|= __put_user(0, &sf
->fpu_save
);
546 err
|= __put_user(oldset
->sig
[0], &sf
->info
.si_mask
);
547 err
|= __copy_to_user(sf
->extramask
, &oldset
->sig
[1],
548 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
549 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
550 sizeof(struct reg_window
));
554 /* 3. signal handler back-trampoline and parameters */
555 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
556 regs
->u_regs
[UREG_I0
] = signo
;
557 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
558 regs
->u_regs
[UREG_I2
] = (unsigned long) &sf
->info
;
560 /* 4. signal handler */
561 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
562 regs
->npc
= (regs
->pc
+ 4);
564 /* 5. return to kernel instructions */
566 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
568 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
570 /* mov __NR_sigreturn, %g1 */
571 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
574 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
578 /* Flush instruction space. */
579 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
586 force_sigsegv(signo
, current
);
590 new_setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
591 int signo
, sigset_t
*oldset
, siginfo_t
*info
)
593 struct rt_signal_frame __user
*sf
;
598 synchronize_user_stack();
599 sigframe_size
= RT_ALIGNEDSZ
;
601 sigframe_size
-= sizeof(__siginfo_fpu_t
);
602 sf
= (struct rt_signal_frame __user
*)
603 get_sigframe(&ka
->sa
, regs
, sigframe_size
);
604 if (invalid_frame_pointer(sf
, sigframe_size
))
606 if (current_thread_info()->w_saved
!= 0)
609 err
= __put_user(regs
->pc
, &sf
->regs
.pc
);
610 err
|= __put_user(regs
->npc
, &sf
->regs
.npc
);
611 err
|= __put_user(regs
->y
, &sf
->regs
.y
);
615 err
|= __put_user(psr
, &sf
->regs
.psr
);
616 err
|= __copy_to_user(&sf
->regs
.u_regs
, regs
->u_regs
, sizeof(regs
->u_regs
));
617 err
|= __put_user(0, &sf
->extra_size
);
620 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
621 err
|= __put_user(&sf
->fpu_state
, &sf
->fpu_save
);
623 err
|= __put_user(0, &sf
->fpu_save
);
625 err
|= __copy_to_user(&sf
->mask
, &oldset
->sig
[0], sizeof(sigset_t
));
627 /* Setup sigaltstack */
628 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
629 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
630 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
632 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
633 sizeof(struct reg_window
));
635 err
|= copy_siginfo_to_user(&sf
->info
, info
);
640 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
641 regs
->u_regs
[UREG_I0
] = signo
;
642 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
643 regs
->u_regs
[UREG_I2
] = (unsigned long) &sf
->regs
;
645 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
646 regs
->npc
= (regs
->pc
+ 4);
649 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
651 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
653 /* mov __NR_sigreturn, %g1 */
654 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
657 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
661 /* Flush instruction space. */
662 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
669 force_sigsegv(signo
, current
);
673 handle_signal(unsigned long signr
, struct k_sigaction
*ka
,
674 siginfo_t
*info
, sigset_t
*oldset
, struct pt_regs
*regs
)
676 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
677 new_setup_rt_frame(ka
, regs
, signr
, oldset
, info
);
678 else if (current
->thread
.new_signal
)
679 new_setup_frame(ka
, regs
, signr
, oldset
);
681 setup_frame(&ka
->sa
, regs
, signr
, oldset
, info
);
683 spin_lock_irq(¤t
->sighand
->siglock
);
684 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
685 if (!(ka
->sa
.sa_flags
& SA_NOMASK
))
686 sigaddset(¤t
->blocked
, signr
);
688 spin_unlock_irq(¤t
->sighand
->siglock
);
691 static inline void syscall_restart(unsigned long orig_i0
, struct pt_regs
*regs
,
692 struct sigaction
*sa
)
694 switch(regs
->u_regs
[UREG_I0
]) {
695 case ERESTART_RESTARTBLOCK
:
697 no_system_call_restart
:
698 regs
->u_regs
[UREG_I0
] = EINTR
;
702 if (!(sa
->sa_flags
& SA_RESTART
))
703 goto no_system_call_restart
;
706 regs
->u_regs
[UREG_I0
] = orig_i0
;
712 /* Note that 'init' is a special process: it doesn't get signals it doesn't
713 * want to handle. Thus you cannot kill init even with a SIGKILL even by
716 asmlinkage
void do_signal(struct pt_regs
* regs
, unsigned long orig_i0
, int restart_syscall
)
719 struct sparc_deliver_cookie cookie
;
720 struct k_sigaction ka
;
724 cookie
.restart_syscall
= restart_syscall
;
725 cookie
.orig_i0
= orig_i0
;
727 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
728 oldset
= ¤t
->saved_sigmask
;
730 oldset
= ¤t
->blocked
;
732 signr
= get_signal_to_deliver(&info
, &ka
, regs
, &cookie
);
734 if (cookie
.restart_syscall
)
735 syscall_restart(cookie
.orig_i0
, regs
, &ka
.sa
);
736 handle_signal(signr
, &ka
, &info
, oldset
, regs
);
738 /* a signal was successfully delivered; the saved
739 * sigmask will have been stored in the signal frame,
740 * and will be restored by sigreturn, so we can simply
741 * clear the TIF_RESTORE_SIGMASK flag.
743 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
744 clear_thread_flag(TIF_RESTORE_SIGMASK
);
747 if (cookie
.restart_syscall
&&
748 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
749 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
750 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
751 /* replay the system call when we are done */
752 regs
->u_regs
[UREG_I0
] = cookie
.orig_i0
;
756 if (cookie
.restart_syscall
&&
757 regs
->u_regs
[UREG_I0
] == ERESTART_RESTARTBLOCK
) {
758 regs
->u_regs
[UREG_G1
] = __NR_restart_syscall
;
763 /* if there's no signal to deliver, we just put the saved sigmask
766 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
767 clear_thread_flag(TIF_RESTORE_SIGMASK
);
768 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
773 do_sys_sigstack(struct sigstack __user
*ssptr
, struct sigstack __user
*ossptr
,
778 /* First see if old state is wanted. */
780 if (put_user(current
->sas_ss_sp
+ current
->sas_ss_size
,
781 &ossptr
->the_stack
) ||
782 __put_user(on_sig_stack(sp
), &ossptr
->cur_status
))
786 /* Now see if we want to update the new state. */
790 if (get_user(ss_sp
, &ssptr
->the_stack
))
792 /* If the current stack was set with sigaltstack, don't
793 swap stacks while we are on it. */
795 if (current
->sas_ss_sp
&& on_sig_stack(sp
))
798 /* Since we don't know the extent of the stack, and we don't
799 track onstack-ness, but rather calculate it, we must
800 presume a size. Ho hum this interface is lossy. */
801 current
->sas_ss_sp
= (unsigned long)ss_sp
- SIGSTKSZ
;
802 current
->sas_ss_size
= SIGSTKSZ
;
809 void ptrace_signal_deliver(struct pt_regs
*regs
, void *cookie
)
811 struct sparc_deliver_cookie
*cp
= cookie
;
813 if (cp
->restart_syscall
&&
814 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
815 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
816 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
817 /* replay the system call when we are done */
818 regs
->u_regs
[UREG_I0
] = cp
->orig_i0
;
821 cp
->restart_syscall
= 0;
824 if (cp
->restart_syscall
&&
825 regs
->u_regs
[UREG_I0
] == ERESTART_RESTARTBLOCK
) {
826 regs
->u_regs
[UREG_G1
] = __NR_restart_syscall
;
829 cp
->restart_syscall
= 0;