1 /* $Id: signal.c,v 1.101 2000/01/21 11:38:38 jj 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/smp.h>
19 #include <linux/smp_lock.h>
21 #include <asm/uaccess.h>
22 #include <asm/bitops.h>
23 #include <asm/ptrace.h>
25 #include <asm/pgalloc.h>
26 #include <asm/pgtable.h>
28 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
30 asmlinkage
int sys_wait4(pid_t pid
, unsigned long *stat_addr
,
31 int options
, unsigned long *ru
);
33 extern void fpsave(unsigned long *fpregs
, unsigned long *fsr
,
34 void *fpqueue
, unsigned long *fpqdepth
);
35 extern void fpload(unsigned long *fpregs
, unsigned long *fsr
);
37 asmlinkage
int do_signal(sigset_t
*oldset
, struct pt_regs
* regs
,
38 unsigned long orig_o0
, int ret_from_syscall
);
40 /* This turned off for production... */
41 /* #define DEBUG_SIGNALS 1 */
42 /* #define DEBUG_SIGNALS_TRACE 1 */
43 /* #define DEBUG_SIGNALS_MAPS 1 */
45 /* Signal frames: the original one (compatible with SunOS):
47 * Set up a signal frame... Make the stack look the way SunOS
48 * expects it to look which is basically:
50 * ---------------------------------- <-- %sp at signal time
53 * Ptr to sigcontext area above
55 * The signal number itself
57 * ---------------------------------- <-- New %sp
59 struct signal_sframe
{
60 struct reg_window sig_window
;
63 struct sigcontext
*sig_scptr
;
65 struct sigcontext sig_context
;
66 unsigned int extramask
[_NSIG_WORDS
- 1];
70 * And the new one, intended to be used for Linux applications only
71 * (we have enough in there to work with clone).
72 * All the interesting bits are in the info field.
75 struct new_signal_frame
{
76 struct sparc_stackf ss
;
78 __siginfo_fpu_t
*fpu_save
;
79 unsigned long insns
[2] __attribute__ ((aligned (8)));
80 unsigned int extramask
[_NSIG_WORDS
- 1];
81 unsigned int extra_size
; /* Should be 0 */
82 __siginfo_fpu_t fpu_state
;
85 struct rt_signal_frame
{
86 struct sparc_stackf ss
;
90 __siginfo_fpu_t
*fpu_save
;
91 unsigned int insns
[2];
93 unsigned int extra_size
; /* Should be 0 */
94 __siginfo_fpu_t fpu_state
;
98 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))
99 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame) + 7) & (~7)))
100 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
103 * atomically swap in the new signal mask, and wait for a signal.
104 * This is really tricky on the Sparc, watch out...
106 asmlinkage
void _sigpause_common(old_sigset_t set
, struct pt_regs
*regs
)
111 spin_lock_irq(¤t
->sigmask_lock
);
112 saveset
= current
->blocked
;
113 siginitset(¤t
->blocked
, set
);
114 recalc_sigpending(current
);
115 spin_unlock_irq(¤t
->sigmask_lock
);
117 regs
->pc
= regs
->npc
;
120 /* Condition codes and return value where set here for sigpause,
121 * and so got used by setup_frame, which again causes sigreturn()
125 current
->state
= TASK_INTERRUPTIBLE
;
128 * Return -EINTR and set condition code here,
129 * so the interrupted system call actually returns
133 regs
->u_regs
[UREG_I0
] = EINTR
;
134 if (do_signal(&saveset
, regs
, 0, 0))
139 asmlinkage
void do_sigpause(unsigned int set
, struct pt_regs
*regs
)
141 _sigpause_common(set
, regs
);
144 asmlinkage
void do_sigsuspend (struct pt_regs
*regs
)
146 _sigpause_common(regs
->u_regs
[UREG_I0
], regs
);
149 asmlinkage
void do_rt_sigsuspend(sigset_t
*uset
, size_t sigsetsize
,
150 struct pt_regs
*regs
)
152 sigset_t oldset
, set
;
154 /* XXX: Don't preclude handling different sized sigset_t's. */
155 if (sigsetsize
!= sizeof(sigset_t
)) {
157 regs
->u_regs
[UREG_I0
] = EINVAL
;
161 if (copy_from_user(&set
, uset
, sizeof(set
))) {
163 regs
->u_regs
[UREG_I0
] = EFAULT
;
167 sigdelsetmask(&set
, ~_BLOCKABLE
);
168 spin_lock_irq(¤t
->sigmask_lock
);
169 oldset
= current
->blocked
;
170 current
->blocked
= set
;
171 recalc_sigpending(current
);
172 spin_unlock_irq(¤t
->sigmask_lock
);
174 regs
->pc
= regs
->npc
;
177 /* Condition codes and return value where set here for sigpause,
178 * and so got used by setup_frame, which again causes sigreturn()
182 current
->state
= TASK_INTERRUPTIBLE
;
185 * Return -EINTR and set condition code here,
186 * so the interrupted system call actually returns
190 regs
->u_regs
[UREG_I0
] = EINTR
;
191 if (do_signal(&oldset
, regs
, 0, 0))
197 restore_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
201 if (current
->flags
& PF_USEDFPU
)
202 regs
->psr
&= ~PSR_EF
;
204 if (current
== last_task_used_math
) {
205 last_task_used_math
= 0;
206 regs
->psr
&= ~PSR_EF
;
209 current
->used_math
= 1;
210 current
->flags
&= ~PF_USEDFPU
;
212 if (verify_area (VERIFY_READ
, fpu
, sizeof(*fpu
)))
215 err
= __copy_from_user(¤t
->thread
.float_regs
[0], &fpu
->si_float_regs
[0],
216 (sizeof(unsigned long) * 32));
217 err
|= __get_user(current
->thread
.fsr
, &fpu
->si_fsr
);
218 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
219 if (current
->thread
.fpqdepth
!= 0)
220 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
222 ((sizeof(unsigned long) +
223 (sizeof(unsigned long *)))*16));
227 static inline void do_new_sigreturn (struct pt_regs
*regs
)
229 struct new_signal_frame
*sf
;
230 unsigned long up_psr
, pc
, npc
;
232 __siginfo_fpu_t
*fpu_save
;
235 sf
= (struct new_signal_frame
*) regs
->u_regs
[UREG_FP
];
237 /* 1. Make sure we are not getting garbage from the user */
238 if (verify_area (VERIFY_READ
, sf
, sizeof (*sf
)))
244 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
245 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
250 /* 2. Restore the state */
252 err
|= __copy_from_user(regs
, &sf
->info
.si_regs
, sizeof (struct pt_regs
));
254 /* User can only change condition codes and FPU enabling in %psr. */
255 regs
->psr
= (up_psr
& ~(PSR_ICC
| PSR_EF
))
256 | (regs
->psr
& (PSR_ICC
| PSR_EF
));
258 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
261 err
|= restore_fpu_state(regs
, fpu_save
);
263 /* This is pretty much atomic, no amount locking would prevent
264 * the races which exist anyways.
266 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
267 err
|= __copy_from_user(&set
.sig
[1], &sf
->extramask
,
268 (_NSIG_WORDS
-1) * sizeof(unsigned int));
273 sigdelsetmask(&set
, ~_BLOCKABLE
);
274 spin_lock_irq(¤t
->sigmask_lock
);
275 current
->blocked
= set
;
276 recalc_sigpending(current
);
277 spin_unlock_irq(¤t
->sigmask_lock
);
284 asmlinkage
void do_sigreturn(struct pt_regs
*regs
)
286 struct sigcontext
*scptr
;
287 unsigned long pc
, npc
, psr
;
291 synchronize_user_stack();
293 if (current
->thread
.new_signal
)
294 return do_new_sigreturn (regs
);
296 scptr
= (struct sigcontext
*) regs
->u_regs
[UREG_I0
];
298 /* Check sanity of the user arg. */
299 if(verify_area(VERIFY_READ
, scptr
, sizeof(struct sigcontext
)) ||
300 (((unsigned long) scptr
) & 3))
303 err
= __get_user(pc
, &scptr
->sigc_pc
);
304 err
|= __get_user(npc
, &scptr
->sigc_npc
);
309 /* This is pretty much atomic, no amount locking would prevent
310 * the races which exist anyways.
312 err
|= __get_user(set
.sig
[0], &scptr
->sigc_mask
);
313 /* Note that scptr + 1 points to extramask */
314 err
|= __copy_from_user(&set
.sig
[1], scptr
+ 1,
315 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
320 sigdelsetmask(&set
, ~_BLOCKABLE
);
321 spin_lock_irq(¤t
->sigmask_lock
);
322 current
->blocked
= set
;
323 recalc_sigpending(current
);
324 spin_unlock_irq(¤t
->sigmask_lock
);
329 err
= __get_user(regs
->u_regs
[UREG_FP
], &scptr
->sigc_sp
);
330 err
|= __get_user(regs
->u_regs
[UREG_I0
], &scptr
->sigc_o0
);
331 err
|= __get_user(regs
->u_regs
[UREG_G1
], &scptr
->sigc_g1
);
333 /* User can only change condition codes in %psr. */
334 err
|= __get_user(psr
, &scptr
->sigc_psr
);
338 regs
->psr
&= ~(PSR_ICC
);
339 regs
->psr
|= (psr
& PSR_ICC
);
343 send_sig(SIGSEGV
, current
, 1);
346 asmlinkage
void do_rt_sigreturn(struct pt_regs
*regs
)
348 struct rt_signal_frame
*sf
;
349 unsigned int psr
, pc
, npc
;
350 __siginfo_fpu_t
*fpu_save
;
355 synchronize_user_stack();
356 sf
= (struct rt_signal_frame
*) regs
->u_regs
[UREG_FP
];
357 if(verify_area(VERIFY_READ
, sf
, sizeof(*sf
)) ||
358 (((unsigned long) sf
) & 0x03))
361 err
= __get_user(pc
, &sf
->regs
.pc
);
362 err
|= __get_user(npc
, &sf
->regs
.npc
);
363 err
|= ((pc
| npc
) & 0x03);
365 err
|= __get_user(regs
->y
, &sf
->regs
.y
);
366 err
|= __get_user(psr
, &sf
->regs
.psr
);
368 err
|= __copy_from_user(®s
->u_regs
[UREG_G1
], &sf
->regs
.u_regs
[UREG_G1
], 15*sizeof(u32
));
370 regs
->psr
= (regs
->psr
& ~PSR_ICC
) | (psr
& PSR_ICC
);
372 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
375 err
|= restore_fpu_state(regs
, fpu_save
);
376 err
|= __copy_from_user(&set
, &sf
->mask
, sizeof(sigset_t
));
378 err
|= __copy_from_user(&st
, &sf
->stack
, sizeof(stack_t
));
386 /* It is more difficult to avoid calling this function than to
387 call it and ignore errors. */
388 do_sigaltstack(&st
, NULL
, (unsigned long)sf
);
390 sigdelsetmask(&set
, ~_BLOCKABLE
);
391 spin_lock_irq(¤t
->sigmask_lock
);
392 current
->blocked
= set
;
393 recalc_sigpending(current
);
394 spin_unlock_irq(¤t
->sigmask_lock
);
397 send_sig(SIGSEGV
, current
, 1);
400 /* Checks if the fp is valid */
401 static inline int invalid_frame_pointer (void *fp
, int fplen
)
403 if ((((unsigned long) fp
) & 7) ||
404 !__access_ok((unsigned long)fp
, fplen
) ||
405 ((sparc_cpu_model
== sun4
|| sparc_cpu_model
== sun4c
) &&
406 ((unsigned long) fp
< 0xe0000000 && (unsigned long) fp
>= 0x20000000)))
412 static inline void *get_sigframe(struct sigaction
*sa
, struct pt_regs
*regs
, unsigned long framesize
)
416 sp
= regs
->u_regs
[UREG_FP
];
418 /* This is the X/Open sanctioned signal stack switching. */
419 if (sa
->sa_flags
& SA_ONSTACK
) {
420 if (!on_sig_stack(sp
) && !((current
->sas_ss_sp
+ current
->sas_ss_size
) & 7))
421 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
423 return (void *)(sp
- framesize
);
427 setup_frame(struct sigaction
*sa
, struct pt_regs
*regs
, int signr
, sigset_t
*oldset
, siginfo_t
*info
)
429 struct signal_sframe
*sframep
;
430 struct sigcontext
*sc
;
432 unsigned long pc
= regs
->pc
;
433 unsigned long npc
= regs
->npc
;
437 synchronize_user_stack();
438 sframep
= (struct signal_sframe
*)get_sigframe(sa
, regs
, SF_ALIGNEDSZ
);
439 if (invalid_frame_pointer (sframep
, sizeof(*sframep
))){
440 #ifdef DEBUG_SIGNALS /* fills up the console logs during crashme runs, yuck... */
441 printk("%s [%d]: User has trashed signal stack\n",
442 current
->comm
, current
->pid
);
443 printk("Sigstack ptr %p handler at pc<%08lx> for sig<%d>\n",
446 /* Don't change signal code and address, so that
447 * post mortem debuggers can have a look.
449 goto sigill_and_return
;
452 sc
= &sframep
->sig_context
;
454 /* We've already made sure frame pointer isn't in kernel space... */
455 err
= __put_user((sas_ss_flags(regs
->u_regs
[UREG_FP
]) == SS_ONSTACK
),
457 err
|= __put_user(oldset
->sig
[0], &sc
->sigc_mask
);
458 err
|= __copy_to_user(sframep
->extramask
, &oldset
->sig
[1],
459 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
460 err
|= __put_user(regs
->u_regs
[UREG_FP
], &sc
->sigc_sp
);
461 err
|= __put_user(pc
, &sc
->sigc_pc
);
462 err
|= __put_user(npc
, &sc
->sigc_npc
);
463 err
|= __put_user(regs
->psr
, &sc
->sigc_psr
);
464 err
|= __put_user(regs
->u_regs
[UREG_G1
], &sc
->sigc_g1
);
465 err
|= __put_user(regs
->u_regs
[UREG_I0
], &sc
->sigc_o0
);
466 err
|= __put_user(current
->thread
.w_saved
, &sc
->sigc_oswins
);
467 if(current
->thread
.w_saved
)
468 for(window
= 0; window
< current
->thread
.w_saved
; window
++) {
469 sc
->sigc_spbuf
[window
] =
470 (char *)current
->thread
.rwbuf_stkptrs
[window
];
471 err
|= __copy_to_user(&sc
->sigc_wbuf
[window
],
472 ¤t
->thread
.reg_window
[window
],
473 sizeof(struct reg_window
));
476 err
|= __copy_to_user(sframep
, (char *)regs
->u_regs
[UREG_FP
],
477 sizeof(struct reg_window
));
479 current
->thread
.w_saved
= 0; /* So process is allowed to execute. */
481 err
|= __put_user(signr
, &sframep
->sig_num
);
484 if (SI_FROMKERNEL (info
) && (info
->si_code
& __SI_MASK
) == __SI_FAULT
) {
485 sig_address
= info
->si_addr
;
488 switch (info
->si_code
) {
489 case SEGV_MAPERR
: sig_code
= SUBSIG_NOMAPPING
; break;
490 default: sig_code
= SUBSIG_PROTECTION
; break;
494 switch (info
->si_code
) {
495 case ILL_ILLOPC
: sig_code
= SUBSIG_ILLINST
; break;
496 case ILL_PRVOPC
: sig_code
= SUBSIG_PRIVINST
; break;
497 case ILL_ILLTRP
: sig_code
= SUBSIG_BADTRAP (info
->si_trapno
); break;
498 default: sig_code
= SUBSIG_STACK
; break;
502 switch (info
->si_code
) {
503 case FPE_INTDIV
: sig_code
= SUBSIG_IDIVZERO
; break;
504 case FPE_INTOVF
: sig_code
= SUBSIG_FPINTOVFL
; break;
505 case FPE_FLTDIV
: sig_code
= SUBSIG_FPDIVZERO
; break;
506 case FPE_FLTOVF
: sig_code
= SUBSIG_FPOVFLOW
; break;
507 case FPE_FLTUND
: sig_code
= SUBSIG_FPUNFLOW
; break;
508 case FPE_FLTRES
: sig_code
= SUBSIG_FPINEXACT
; break;
509 case FPE_FLTINV
: sig_code
= SUBSIG_FPOPERROR
; break;
510 default: sig_code
= SUBSIG_FPERROR
; break;
514 switch (info
->si_code
) {
515 case BUS_ADRALN
: sig_code
= SUBSIG_ALIGNMENT
; break;
516 case BUS_ADRERR
: sig_code
= SUBSIG_MISCERROR
; break;
517 default: sig_code
= SUBSIG_BUSTIMEOUT
; break;
521 switch (info
->si_code
) {
522 case EMT_TAGOVF
: sig_code
= SUBSIG_TAG
; break;
526 if (info
->si_code
== (__SI_FAULT
|0x100)) {
527 /* See sys_sunos.c */
528 sig_code
= info
->si_trapno
;
535 err
|= __put_user((long)sig_address
, &sframep
->sig_address
);
536 err
|= __put_user(sig_code
, &sframep
->sig_code
);
537 err
|= __put_user(sc
, &sframep
->sig_scptr
);
541 regs
->u_regs
[UREG_FP
] = (unsigned long) sframep
;
542 regs
->pc
= (unsigned long) sa
->sa_handler
;
543 regs
->npc
= (regs
->pc
+ 4);
554 save_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
558 if (current
->flags
& PF_USEDFPU
) {
559 put_psr(get_psr() | PSR_EF
);
560 fpsave(¤t
->thread
.float_regs
[0], ¤t
->thread
.fsr
,
561 ¤t
->thread
.fpqueue
[0], ¤t
->thread
.fpqdepth
);
562 regs
->psr
&= ~(PSR_EF
);
563 current
->flags
&= ~(PF_USEDFPU
);
566 if (current
== last_task_used_math
) {
567 put_psr(get_psr() | PSR_EF
);
568 fpsave(¤t
->thread
.float_regs
[0], ¤t
->thread
.fsr
,
569 ¤t
->thread
.fpqueue
[0], ¤t
->thread
.fpqdepth
);
570 last_task_used_math
= 0;
571 regs
->psr
&= ~(PSR_EF
);
574 err
|= __copy_to_user(&fpu
->si_float_regs
[0], ¤t
->thread
.float_regs
[0],
575 (sizeof(unsigned long) * 32));
576 err
|= __put_user(current
->thread
.fsr
, &fpu
->si_fsr
);
577 err
|= __put_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
578 if (current
->thread
.fpqdepth
!= 0)
579 err
|= __copy_to_user(&fpu
->si_fpqueue
[0], ¤t
->thread
.fpqueue
[0],
580 ((sizeof(unsigned long) +
581 (sizeof(unsigned long *)))*16));
582 current
->used_math
= 0;
587 new_setup_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
588 int signo
, sigset_t
*oldset
)
590 struct new_signal_frame
*sf
;
591 int sigframe_size
, err
;
593 /* 1. Make sure everything is clean */
594 synchronize_user_stack();
596 sigframe_size
= NF_ALIGNEDSZ
;
597 if (!current
->used_math
)
598 sigframe_size
-= sizeof(__siginfo_fpu_t
);
600 sf
= (struct new_signal_frame
*)get_sigframe(&ka
->sa
, regs
, sigframe_size
);
602 if (invalid_frame_pointer (sf
, sigframe_size
))
603 goto sigill_and_return
;
605 if (current
->thread
.w_saved
!= 0) {
607 printk ("%s [%d]: Invalid user stack frame for "
608 "signal delivery.\n", current
->comm
, current
->pid
);
610 goto sigill_and_return
;
613 /* 2. Save the current process state */
614 err
= __copy_to_user(&sf
->info
.si_regs
, regs
, sizeof (struct pt_regs
));
616 err
|= __put_user(0, &sf
->extra_size
);
618 if (current
->used_math
) {
619 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
620 err
|= __put_user(&sf
->fpu_state
, &sf
->fpu_save
);
622 err
|= __put_user(0, &sf
->fpu_save
);
625 err
|= __put_user(oldset
->sig
[0], &sf
->info
.si_mask
);
626 err
|= __copy_to_user(sf
->extramask
, &oldset
->sig
[1],
627 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
628 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
629 sizeof (struct reg_window
));
633 /* 3. signal handler back-trampoline and parameters */
634 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
635 regs
->u_regs
[UREG_I0
] = signo
;
636 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
638 /* 4. signal handler */
639 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
640 regs
->npc
= (regs
->pc
+ 4);
642 /* 5. return to kernel instructions */
644 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
646 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
648 /* mov __NR_sigreturn, %g1 */
649 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
652 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
656 /* Flush instruction space. */
657 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
668 new_setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
669 int signo
, sigset_t
*oldset
, siginfo_t
*info
)
671 struct rt_signal_frame
*sf
;
676 synchronize_user_stack();
677 sigframe_size
= RT_ALIGNEDSZ
;
678 if(!current
->used_math
)
679 sigframe_size
-= sizeof(__siginfo_fpu_t
);
680 sf
= (struct rt_signal_frame
*)get_sigframe(&ka
->sa
, regs
, sigframe_size
);
681 if(invalid_frame_pointer(sf
, sigframe_size
))
683 if(current
->thread
.w_saved
!= 0)
686 err
= __put_user(regs
->pc
, &sf
->regs
.pc
);
687 err
|= __put_user(regs
->npc
, &sf
->regs
.npc
);
688 err
|= __put_user(regs
->y
, &sf
->regs
.y
);
690 if(current
->used_math
)
692 err
|= __put_user(psr
, &sf
->regs
.psr
);
693 err
|= __copy_to_user(&sf
->regs
.u_regs
, regs
->u_regs
, sizeof(regs
->u_regs
));
694 err
|= __put_user(0, &sf
->extra_size
);
697 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
698 err
|= __put_user(&sf
->fpu_state
, &sf
->fpu_save
);
700 err
|= __put_user(0, &sf
->fpu_save
);
702 err
|= __copy_to_user(&sf
->mask
, &oldset
->sig
[0], sizeof(sigset_t
));
704 /* Setup sigaltstack */
705 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
706 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
707 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
709 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
710 sizeof (struct reg_window
));
712 err
|= __copy_to_user(&sf
->info
, info
, sizeof(siginfo_t
));
717 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
718 regs
->u_regs
[UREG_I0
] = signo
;
719 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
721 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
722 regs
->npc
= (regs
->pc
+ 4);
725 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
727 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
729 /* mov __NR_sigreturn, %g1 */
730 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
733 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
737 /* Flush instruction space. */
738 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
748 /* Setup a Solaris stack frame */
750 setup_svr4_frame(struct sigaction
*sa
, unsigned long pc
, unsigned long npc
,
751 struct pt_regs
*regs
, int signr
, sigset_t
*oldset
)
753 svr4_signal_frame_t
*sfp
;
762 synchronize_user_stack();
763 sfp
= (svr4_signal_frame_t
*) get_sigframe(sa
, regs
, SVR4_SF_ALIGNED
+ REGWIN_SZ
);
765 if (invalid_frame_pointer (sfp
, sizeof (*sfp
))){
767 printk ("Invalid stack frame\n");
769 goto sigill_and_return
;
772 /* Start with a clean frame pointer and fill it */
773 err
= __clear_user(sfp
, sizeof (*sfp
));
775 /* Setup convenience variables */
782 /* FIXME: where am I supposed to put this?
783 * sc->sigc_onstack = old_status;
784 * anyways, it does not look like it is used for anything at all.
786 setv
.sigbits
[0] = oldset
->sig
[0];
787 setv
.sigbits
[1] = oldset
->sig
[1];
788 if (_NSIG_WORDS
>= 4) {
789 setv
.sigbits
[2] = oldset
->sig
[2];
790 setv
.sigbits
[3] = oldset
->sig
[3];
791 err
|= __copy_to_user(&uc
->sigmask
, &setv
, sizeof(svr4_sigset_t
));
793 err
|= __copy_to_user(&uc
->sigmask
, &setv
, 2 * sizeof(unsigned int));
795 /* Store registers */
796 err
|= __put_user(regs
->pc
, &((*gr
) [SVR4_PC
]));
797 err
|= __put_user(regs
->npc
, &((*gr
) [SVR4_NPC
]));
798 err
|= __put_user(regs
->psr
, &((*gr
) [SVR4_PSR
]));
799 err
|= __put_user(regs
->y
, &((*gr
) [SVR4_Y
]));
801 /* Copy g [1..7] and o [0..7] registers */
802 err
|= __copy_to_user(&(*gr
)[SVR4_G1
], ®s
->u_regs
[UREG_G1
], sizeof (long) * 7);
803 err
|= __copy_to_user(&(*gr
)[SVR4_O0
], ®s
->u_regs
[UREG_I0
], sizeof (long) * 8);
805 /* Setup sigaltstack */
806 err
|= __put_user(current
->sas_ss_sp
, &uc
->stack
.sp
);
807 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &uc
->stack
.flags
);
808 err
|= __put_user(current
->sas_ss_size
, &uc
->stack
.size
);
810 /* Save the currently window file: */
812 /* 1. Link sfp->uc->gwins to our windows */
813 err
|= __put_user(gw
, &mc
->gwin
);
815 /* 2. Number of windows to restore at setcontext (): */
816 err
|= __put_user(current
->thread
.w_saved
, &gw
->count
);
818 /* 3. Save each valid window
819 * Currently, it makes a copy of the windows from the kernel copy.
820 * David's code for SunOS, makes the copy but keeps the pointer to
821 * the kernel. My version makes the pointer point to a userland
822 * copy of those. Mhm, I wonder if I shouldn't just ignore those
823 * on setcontext and use those that are on the kernel, the signal
824 * handler should not be modyfing those, mhm.
826 * These windows are just used in case synchronize_user_stack failed
827 * to flush the user windows.
829 for(window
= 0; window
< current
->thread
.w_saved
; window
++) {
830 err
|= __put_user((int *) &(gw
->win
[window
]), &gw
->winptr
[window
]);
831 err
|= __copy_to_user(&gw
->win
[window
],
832 ¤t
->thread
.reg_window
[window
],
833 sizeof (svr4_rwindow_t
));
834 err
|= __put_user(0, gw
->winptr
[window
]);
837 /* 4. We just pay attention to the gw->count field on setcontext */
838 current
->thread
.w_saved
= 0; /* So process is allowed to execute. */
840 /* Setup the signal information. Solaris expects a bunch of
841 * information to be passed to the signal handler, we don't provide
842 * that much currently, should use siginfo.
844 err
|= __put_user(signr
, &si
->siginfo
.signo
);
845 err
|= __put_user(SVR4_SINOINFO
, &si
->siginfo
.code
);
849 regs
->u_regs
[UREG_FP
] = (unsigned long) sfp
;
850 regs
->pc
= (unsigned long) sa
->sa_handler
;
851 regs
->npc
= (regs
->pc
+ 4);
854 printk ("Solaris-frame: %x %x\n", (int) regs
->pc
, (int) regs
->npc
);
856 /* Arguments passed to signal handler */
857 if (regs
->u_regs
[14]){
858 struct reg_window
*rw
= (struct reg_window
*) regs
->u_regs
[14];
860 err
|= __put_user(signr
, &rw
->ins
[0]);
861 err
|= __put_user(si
, &rw
->ins
[1]);
862 err
|= __put_user(uc
, &rw
->ins
[2]);
863 err
|= __put_user(sfp
, &rw
->ins
[6]); /* frame pointer */
867 regs
->u_regs
[UREG_I0
] = signr
;
868 regs
->u_regs
[UREG_I1
] = (uint
) si
;
869 regs
->u_regs
[UREG_I2
] = (uint
) uc
;
879 asmlinkage
int svr4_getcontext (svr4_ucontext_t
*uc
, struct pt_regs
*regs
)
886 synchronize_user_stack();
888 if (current
->thread
.w_saved
)
889 goto sigsegv_and_return
;
891 err
= clear_user(uc
, sizeof (*uc
));
895 /* Setup convenience variables */
899 setv
.sigbits
[0] = current
->blocked
.sig
[0];
900 setv
.sigbits
[1] = current
->blocked
.sig
[1];
901 if (_NSIG_WORDS
>= 4) {
902 setv
.sigbits
[2] = current
->blocked
.sig
[2];
903 setv
.sigbits
[3] = current
->blocked
.sig
[3];
904 err
|= __copy_to_user(&uc
->sigmask
, &setv
, sizeof(svr4_sigset_t
));
906 err
|= __copy_to_user(&uc
->sigmask
, &setv
, 2 * sizeof(unsigned int));
908 /* Store registers */
909 err
|= __put_user(regs
->pc
, &uc
->mcontext
.greg
[SVR4_PC
]);
910 err
|= __put_user(regs
->npc
, &uc
->mcontext
.greg
[SVR4_NPC
]);
911 err
|= __put_user(regs
->psr
, &uc
->mcontext
.greg
[SVR4_PSR
]);
912 err
|= __put_user(regs
->y
, &uc
->mcontext
.greg
[SVR4_Y
]);
914 /* Copy g [1..7] and o [0..7] registers */
915 err
|= __copy_to_user(&(*gr
)[SVR4_G1
], ®s
->u_regs
[UREG_G1
], sizeof (uint
) * 7);
916 err
|= __copy_to_user(&(*gr
)[SVR4_O0
], ®s
->u_regs
[UREG_I0
], sizeof (uint
) * 8);
918 /* Setup sigaltstack */
919 err
|= __put_user(current
->sas_ss_sp
, &uc
->stack
.sp
);
920 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &uc
->stack
.flags
);
921 err
|= __put_user(current
->sas_ss_size
, &uc
->stack
.size
);
923 /* The register file is not saved
924 * we have already stuffed all of it with sync_user_stack
926 return (err
? -EFAULT
: 0);
932 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
933 asmlinkage
int svr4_setcontext (svr4_ucontext_t
*c
, struct pt_regs
*regs
)
935 struct thread_struct
*tp
= ¤t
->thread
;
937 unsigned long pc
, npc
, psr
;
943 /* Fixme: restore windows, or is this already taken care of in
944 * svr4_setup_frame when sync_user_windows is done?
946 flush_user_windows();
949 goto sigsegv_and_return
;
952 goto sigsegv_and_return
;
954 if(!__access_ok((unsigned long)c
, sizeof(*c
)))
955 goto sigsegv_and_return
;
957 /* Check for valid PC and nPC */
958 gr
= &c
->mcontext
.greg
;
959 err
= __get_user(pc
, &((*gr
)[SVR4_PC
]));
960 err
|= __get_user(npc
, &((*gr
)[SVR4_NPC
]));
963 goto sigsegv_and_return
;
965 /* Retrieve information from passed ucontext */
966 /* note that nPC is ored a 1, this is used to inform entry.S */
967 /* that we don't want it to mess with our PC and nPC */
969 /* This is pretty much atomic, no amount locking would prevent
970 * the races which exist anyways.
972 err
|= __copy_from_user(&setv
, &c
->sigmask
, sizeof(svr4_sigset_t
));
974 err
|= __get_user(st
.ss_sp
, &c
->stack
.sp
);
975 err
|= __get_user(st
.ss_flags
, &c
->stack
.flags
);
976 err
|= __get_user(st
.ss_size
, &c
->stack
.size
);
979 goto sigsegv_and_return
;
981 /* It is more difficult to avoid calling this function than to
982 call it and ignore errors. */
983 do_sigaltstack(&st
, NULL
, regs
->u_regs
[UREG_I6
]);
985 set
.sig
[0] = setv
.sigbits
[0];
986 set
.sig
[1] = setv
.sigbits
[1];
987 if (_NSIG_WORDS
>= 4) {
988 set
.sig
[2] = setv
.sigbits
[2];
989 set
.sig
[3] = setv
.sigbits
[3];
991 sigdelsetmask(&set
, ~_BLOCKABLE
);
992 spin_lock_irq(¤t
->sigmask_lock
);
993 current
->blocked
= set
;
994 recalc_sigpending(current
);
995 spin_unlock_irq(¤t
->sigmask_lock
);
998 err
|= __get_user(regs
->y
, &((*gr
) [SVR4_Y
]));
999 err
|= __get_user(psr
, &((*gr
) [SVR4_PSR
]));
1000 regs
->psr
&= ~(PSR_ICC
);
1001 regs
->psr
|= (psr
& PSR_ICC
);
1003 /* Restore g[1..7] and o[0..7] registers */
1004 err
|= __copy_from_user(®s
->u_regs
[UREG_G1
], &(*gr
)[SVR4_G1
],
1006 err
|= __copy_from_user(®s
->u_regs
[UREG_I0
], &(*gr
)[SVR4_O0
],
1008 return (err
? -EFAULT
: 0);
1015 handle_signal(unsigned long signr
, struct k_sigaction
*ka
,
1016 siginfo_t
*info
, sigset_t
*oldset
, struct pt_regs
*regs
,
1020 setup_svr4_frame(&ka
->sa
, regs
->pc
, regs
->npc
, regs
, signr
, oldset
);
1022 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
1023 new_setup_rt_frame(ka
, regs
, signr
, oldset
, info
);
1024 else if (current
->thread
.new_signal
)
1025 new_setup_frame (ka
, regs
, signr
, oldset
);
1027 setup_frame(&ka
->sa
, regs
, signr
, oldset
, info
);
1029 if(ka
->sa
.sa_flags
& SA_ONESHOT
)
1030 ka
->sa
.sa_handler
= SIG_DFL
;
1031 if(!(ka
->sa
.sa_flags
& SA_NOMASK
)) {
1032 spin_lock_irq(¤t
->sigmask_lock
);
1033 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
1034 sigaddset(¤t
->blocked
, signr
);
1035 recalc_sigpending(current
);
1036 spin_unlock_irq(¤t
->sigmask_lock
);
1040 static inline void syscall_restart(unsigned long orig_i0
, struct pt_regs
*regs
,
1041 struct sigaction
*sa
)
1043 switch(regs
->u_regs
[UREG_I0
]) {
1044 case ERESTARTNOHAND
:
1045 no_system_call_restart
:
1046 regs
->u_regs
[UREG_I0
] = EINTR
;
1050 if(!(sa
->sa_flags
& SA_RESTART
))
1051 goto no_system_call_restart
;
1053 case ERESTARTNOINTR
:
1054 regs
->u_regs
[UREG_I0
] = orig_i0
;
1060 #ifdef DEBUG_SIGNALS_MAPS
1062 #define MAPS_LINE_FORMAT "%08lx-%08lx %s %08lx %s %lu "
1064 static inline void read_maps (void)
1066 struct vm_area_struct
* map
, * next
;
1070 buffer
= (char*)__get_free_page(GFP_KERNEL
);
1074 for (map
= current
->mm
->mmap
; map
; map
= next
) {
1075 /* produce the next line */
1077 char str
[5], *cp
= str
;
1083 * Get the next vma now (but it won't be used if we sleep).
1085 next
= map
->vm_next
;
1086 flags
= map
->vm_flags
;
1088 *cp
++ = flags
& VM_READ
? 'r' : '-';
1089 *cp
++ = flags
& VM_WRITE
? 'w' : '-';
1090 *cp
++ = flags
& VM_EXEC
? 'x' : '-';
1091 *cp
++ = flags
& VM_MAYSHARE
? 's' : 'p';
1096 if (map
->vm_file
!= NULL
) {
1097 dev
= map
->vm_file
->f_dentry
->d_inode
->i_dev
;
1098 ino
= map
->vm_file
->f_dentry
->d_inode
->i_ino
;
1099 line
= d_path(map
->vm_file
->f_dentry
, buffer
, PAGE_SIZE
);
1101 printk(MAPS_LINE_FORMAT
, map
->vm_start
, map
->vm_end
, str
, map
->vm_pgoff
<< PAGE_SHIFT
,
1102 kdevname(dev
), ino
);
1103 if (map
->vm_file
!= NULL
)
1104 printk("%s\n", line
);
1108 free_page((unsigned long)buffer
);
1113 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1114 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1117 asmlinkage
int do_signal(sigset_t
*oldset
, struct pt_regs
* regs
,
1118 unsigned long orig_i0
, int restart_syscall
)
1120 unsigned long signr
;
1121 struct k_sigaction
*ka
;
1125 * XXX Disable svr4 signal handling until solaris emulation works.
1126 * It is buggy - Anton
1128 #define SVR4_SIGNAL_BROKEN 1
1129 #ifdef SVR4_SIGNAL_BROKEN
1130 int svr4_signal
= 0;
1132 int svr4_signal
= current
->personality
== PER_SVR4
;
1136 oldset
= ¤t
->blocked
;
1139 spin_lock_irq(¤t
->sigmask_lock
);
1140 signr
= dequeue_signal(¤t
->blocked
, &info
);
1141 spin_unlock_irq(¤t
->sigmask_lock
);
1145 if ((current
->flags
& PF_PTRACED
) && signr
!= SIGKILL
) {
1146 current
->exit_code
= signr
;
1147 current
->state
= TASK_STOPPED
;
1149 /* This happens to be SMP safe so no need to
1150 * grab master kernel lock even in this case.
1152 notify_parent(current
, SIGCHLD
);
1154 if (!(signr
= current
->exit_code
))
1156 current
->exit_code
= 0;
1157 if (signr
== SIGSTOP
)
1160 /* Update the siginfo structure. Is this good? */
1161 if (signr
!= info
.si_signo
) {
1162 info
.si_signo
= signr
;
1164 info
.si_code
= SI_USER
;
1165 info
.si_pid
= current
->p_pptr
->pid
;
1166 info
.si_uid
= current
->p_pptr
->uid
;
1169 /* If the (new) signal is now blocked, requeue it. */
1170 if (sigismember(¤t
->blocked
, signr
)) {
1171 send_sig_info(signr
, &info
, current
);
1176 ka
= ¤t
->sig
->action
[signr
-1];
1178 if(ka
->sa
.sa_handler
== SIG_IGN
) {
1179 if(signr
!= SIGCHLD
)
1182 /* sys_wait4() grabs the master kernel lock, so
1183 * we need not do so, that sucker should be
1184 * threaded and would not be that difficult to
1187 while(sys_wait4(-1, NULL
, WNOHANG
, NULL
) > 0)
1191 if(ka
->sa
.sa_handler
== SIG_DFL
) {
1192 unsigned long exit_code
= signr
;
1194 if(current
->pid
== 1)
1197 case SIGCONT
: case SIGCHLD
: case SIGWINCH
:
1200 case SIGTSTP
: case SIGTTIN
: case SIGTTOU
:
1201 /* The operations performed by
1202 * is_orphaned_pgrp() are protected by
1203 * the tasklist_lock.
1205 if (is_orphaned_pgrp(current
->pgrp
))
1209 if (current
->flags
& PF_PTRACED
)
1211 current
->state
= TASK_STOPPED
;
1212 current
->exit_code
= signr
;
1214 /* notify_parent() is SMP safe */
1215 if(!(current
->p_pptr
->sig
->action
[SIGCHLD
-1].sa
.sa_flags
&
1217 notify_parent(current
, SIGCHLD
);
1221 case SIGQUIT
: case SIGILL
: case SIGTRAP
:
1222 case SIGABRT
: case SIGFPE
: case SIGSEGV
:
1223 case SIGBUS
: case SIGSYS
: case SIGXCPU
: case SIGXFSZ
:
1224 if (do_coredump(signr
, regs
))
1226 #ifdef DEBUG_SIGNALS
1227 /* Very useful to debug dynamic linker problems */
1228 printk ("Sig %ld going for %s[%d]...\n", signr
, current
->comm
, current
->pid
);
1230 #ifdef DEBUG_SIGNALS_TRACE
1232 struct reg_window
*rw
= (struct reg_window
*)regs
->u_regs
[UREG_FP
];
1233 unsigned int ins
[8];
1236 !(((unsigned long) rw
) & 0x3)) {
1237 copy_from_user(ins
, &rw
->ins
[0], sizeof(ins
));
1238 printk("Caller[%08x](%08x,%08x,%08x,%08x,%08x,%08x)\n", ins
[7], ins
[0], ins
[1], ins
[2], ins
[3], ins
[4], ins
[5]);
1239 rw
= (struct reg_window
*)(unsigned long)ins
[6];
1243 #ifdef DEBUG_SIGNALS_MAPS
1251 sigaddset(¤t
->signal
, signr
);
1252 recalc_sigpending(current
);
1253 current
->flags
|= PF_SIGNALED
;
1259 syscall_restart(orig_i0
, regs
, &ka
->sa
);
1260 handle_signal(signr
, ka
, &info
, oldset
, regs
, svr4_signal
);
1263 if(restart_syscall
&&
1264 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
1265 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
1266 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
1267 /* replay the system call when we are done */
1268 regs
->u_regs
[UREG_I0
] = orig_i0
;
1276 do_sys_sigstack(struct sigstack
*ssptr
, struct sigstack
*ossptr
, unsigned long sp
)
1280 /* First see if old state is wanted. */
1282 if (put_user(current
->sas_ss_sp
+ current
->sas_ss_size
, &ossptr
->the_stack
) ||
1283 __put_user(on_sig_stack(sp
), &ossptr
->cur_status
))
1287 /* Now see if we want to update the new state. */
1291 if (get_user((long)ss_sp
, &ssptr
->the_stack
))
1293 /* If the current stack was set with sigaltstack, don't
1294 swap stacks while we are on it. */
1296 if (current
->sas_ss_sp
&& on_sig_stack(sp
))
1299 /* Since we don't know the extent of the stack, and we don't
1300 track onstack-ness, but rather calculate it, we must
1301 presume a size. Ho hum this interface is lossy. */
1302 current
->sas_ss_sp
= (unsigned long)ss_sp
- SIGSTKSZ
;
1303 current
->sas_ss_size
= SIGSTKSZ
;