1 /* $Id: signal.c,v 1.95 1999/08/14 03:51:22 anton 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/pgtable.h>
27 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
29 asmlinkage
int sys_wait4(pid_t pid
, unsigned long *stat_addr
,
30 int options
, unsigned long *ru
);
32 extern void fpsave(unsigned long *fpregs
, unsigned long *fsr
,
33 void *fpqueue
, unsigned long *fpqdepth
);
34 extern void fpload(unsigned long *fpregs
, unsigned long *fsr
);
36 asmlinkage
int do_signal(sigset_t
*oldset
, struct pt_regs
* regs
,
37 unsigned long orig_o0
, int ret_from_syscall
);
39 /* This turned off for production... */
40 /* #define DEBUG_SIGNALS 1 */
41 /* #define DEBUG_SIGNALS_TRACE 1 */
42 /* #define DEBUG_SIGNALS_MAPS 1 */
44 /* Signal frames: the original one (compatible with SunOS):
46 * Set up a signal frame... Make the stack look the way SunOS
47 * expects it to look which is basically:
49 * ---------------------------------- <-- %sp at signal time
52 * Ptr to sigcontext area above
54 * The signal number itself
56 * ---------------------------------- <-- New %sp
58 struct signal_sframe
{
59 struct reg_window sig_window
;
62 struct sigcontext
*sig_scptr
;
64 struct sigcontext sig_context
;
65 unsigned int extramask
[_NSIG_WORDS
- 1];
69 * And the new one, intended to be used for Linux applications only
70 * (we have enough in there to work with clone).
71 * All the interesting bits are in the info field.
74 struct new_signal_frame
{
75 struct sparc_stackf ss
;
77 __siginfo_fpu_t
*fpu_save
;
78 unsigned long insns
[2] __attribute__ ((aligned (8)));
79 unsigned int extramask
[_NSIG_WORDS
- 1];
80 unsigned int extra_size
; /* Should be 0 */
81 __siginfo_fpu_t fpu_state
;
84 struct rt_signal_frame
{
85 struct sparc_stackf ss
;
89 __siginfo_fpu_t
*fpu_save
;
90 unsigned int insns
[2];
92 unsigned int extra_size
; /* Should be 0 */
93 __siginfo_fpu_t fpu_state
;
97 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))
98 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame) + 7) & (~7)))
99 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
102 * atomically swap in the new signal mask, and wait for a signal.
103 * This is really tricky on the Sparc, watch out...
105 asmlinkage
void _sigpause_common(old_sigset_t set
, struct pt_regs
*regs
)
110 spin_lock_irq(¤t
->sigmask_lock
);
111 saveset
= current
->blocked
;
112 siginitset(¤t
->blocked
, set
);
113 recalc_sigpending(current
);
114 spin_unlock_irq(¤t
->sigmask_lock
);
116 regs
->pc
= regs
->npc
;
119 /* Condition codes and return value where set here for sigpause,
120 * and so got used by setup_frame, which again causes sigreturn()
124 current
->state
= TASK_INTERRUPTIBLE
;
127 * Return -EINTR and set condition code here,
128 * so the interrupted system call actually returns
132 regs
->u_regs
[UREG_I0
] = EINTR
;
133 if (do_signal(&saveset
, regs
, 0, 0))
138 asmlinkage
void do_sigpause(unsigned int set
, struct pt_regs
*regs
)
140 _sigpause_common(set
, regs
);
143 asmlinkage
void do_sigsuspend (struct pt_regs
*regs
)
145 _sigpause_common(regs
->u_regs
[UREG_I0
], regs
);
148 asmlinkage
void do_rt_sigsuspend(sigset_t
*uset
, size_t sigsetsize
,
149 struct pt_regs
*regs
)
151 sigset_t oldset
, set
;
153 /* XXX: Don't preclude handling different sized sigset_t's. */
154 if (sigsetsize
!= sizeof(sigset_t
)) {
156 regs
->u_regs
[UREG_I0
] = EINVAL
;
160 if (copy_from_user(&set
, uset
, sizeof(set
))) {
162 regs
->u_regs
[UREG_I0
] = EFAULT
;
166 sigdelsetmask(&set
, ~_BLOCKABLE
);
167 spin_lock_irq(¤t
->sigmask_lock
);
168 oldset
= current
->blocked
;
169 current
->blocked
= set
;
170 recalc_sigpending(current
);
171 spin_unlock_irq(¤t
->sigmask_lock
);
173 regs
->pc
= regs
->npc
;
176 /* Condition codes and return value where set here for sigpause,
177 * and so got used by setup_frame, which again causes sigreturn()
181 current
->state
= TASK_INTERRUPTIBLE
;
184 * Return -EINTR and set condition code here,
185 * so the interrupted system call actually returns
189 regs
->u_regs
[UREG_I0
] = EINTR
;
190 if (do_signal(&oldset
, regs
, 0, 0))
196 restore_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
200 if (current
->flags
& PF_USEDFPU
)
201 regs
->psr
&= ~PSR_EF
;
203 if (current
== last_task_used_math
) {
204 last_task_used_math
= 0;
205 regs
->psr
&= ~PSR_EF
;
208 current
->used_math
= 1;
209 current
->flags
&= ~PF_USEDFPU
;
211 if (verify_area (VERIFY_READ
, fpu
, sizeof(*fpu
)))
214 err
= __copy_from_user(¤t
->thread
.float_regs
[0], &fpu
->si_float_regs
[0],
215 (sizeof(unsigned long) * 32));
216 err
|= __get_user(current
->thread
.fsr
, &fpu
->si_fsr
);
217 err
|= __get_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
218 if (current
->thread
.fpqdepth
!= 0)
219 err
|= __copy_from_user(¤t
->thread
.fpqueue
[0],
221 ((sizeof(unsigned long) +
222 (sizeof(unsigned long *)))*16));
226 static inline void do_new_sigreturn (struct pt_regs
*regs
)
228 struct new_signal_frame
*sf
;
229 unsigned long up_psr
, pc
, npc
;
231 __siginfo_fpu_t
*fpu_save
;
234 sf
= (struct new_signal_frame
*) regs
->u_regs
[UREG_FP
];
236 /* 1. Make sure we are not getting garbage from the user */
237 if (verify_area (VERIFY_READ
, sf
, sizeof (*sf
)))
243 err
= __get_user(pc
, &sf
->info
.si_regs
.pc
);
244 err
|= __get_user(npc
, &sf
->info
.si_regs
.npc
);
249 /* 2. Restore the state */
251 err
|= __copy_from_user(regs
, &sf
->info
.si_regs
, sizeof (struct pt_regs
));
253 /* User can only change condition codes and FPU enabling in %psr. */
254 regs
->psr
= (up_psr
& ~(PSR_ICC
| PSR_EF
))
255 | (regs
->psr
& (PSR_ICC
| PSR_EF
));
257 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
260 err
|= restore_fpu_state(regs
, fpu_save
);
262 /* This is pretty much atomic, no amount locking would prevent
263 * the races which exist anyways.
265 err
|= __get_user(set
.sig
[0], &sf
->info
.si_mask
);
266 err
|= __copy_from_user(&set
.sig
[1], &sf
->extramask
,
267 (_NSIG_WORDS
-1) * sizeof(unsigned int));
272 sigdelsetmask(&set
, ~_BLOCKABLE
);
273 spin_lock_irq(¤t
->sigmask_lock
);
274 current
->blocked
= set
;
275 recalc_sigpending(current
);
276 spin_unlock_irq(¤t
->sigmask_lock
);
283 asmlinkage
void do_sigreturn(struct pt_regs
*regs
)
285 struct sigcontext
*scptr
;
286 unsigned long pc
, npc
, psr
;
290 synchronize_user_stack();
292 if (current
->thread
.new_signal
)
293 return do_new_sigreturn (regs
);
295 scptr
= (struct sigcontext
*) regs
->u_regs
[UREG_I0
];
297 /* Check sanity of the user arg. */
298 if(verify_area(VERIFY_READ
, scptr
, sizeof(struct sigcontext
)) ||
299 (((unsigned long) scptr
) & 3))
302 err
= __get_user(pc
, &scptr
->sigc_pc
);
303 err
|= __get_user(npc
, &scptr
->sigc_npc
);
308 /* This is pretty much atomic, no amount locking would prevent
309 * the races which exist anyways.
311 err
|= __get_user(set
.sig
[0], &scptr
->sigc_mask
);
312 /* Note that scptr + 1 points to extramask */
313 err
|= __copy_from_user(&set
.sig
[1], scptr
+ 1,
314 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
319 sigdelsetmask(&set
, ~_BLOCKABLE
);
320 spin_lock_irq(¤t
->sigmask_lock
);
321 current
->blocked
= set
;
322 recalc_sigpending(current
);
323 spin_unlock_irq(¤t
->sigmask_lock
);
328 err
= __get_user(regs
->u_regs
[UREG_FP
], &scptr
->sigc_sp
);
329 err
|= __get_user(regs
->u_regs
[UREG_I0
], &scptr
->sigc_o0
);
330 err
|= __get_user(regs
->u_regs
[UREG_G1
], &scptr
->sigc_g1
);
332 /* User can only change condition codes in %psr. */
333 err
|= __get_user(psr
, &scptr
->sigc_psr
);
337 regs
->psr
&= ~(PSR_ICC
);
338 regs
->psr
|= (psr
& PSR_ICC
);
342 send_sig(SIGSEGV
, current
, 1);
345 asmlinkage
void do_rt_sigreturn(struct pt_regs
*regs
)
347 struct rt_signal_frame
*sf
;
348 unsigned int psr
, pc
, npc
;
349 __siginfo_fpu_t
*fpu_save
;
354 synchronize_user_stack();
355 sf
= (struct rt_signal_frame
*) regs
->u_regs
[UREG_FP
];
356 if(verify_area(VERIFY_READ
, sf
, sizeof(*sf
)) ||
357 (((unsigned long) sf
) & 0x03))
360 err
= __get_user(pc
, &sf
->regs
.pc
);
361 err
|= __get_user(npc
, &sf
->regs
.npc
);
362 err
|= ((pc
| npc
) & 0x03);
364 err
|= __get_user(regs
->y
, &sf
->regs
.y
);
365 err
|= __get_user(psr
, &sf
->regs
.psr
);
367 err
|= __copy_from_user(®s
->u_regs
[UREG_G1
], &sf
->regs
.u_regs
[UREG_G1
], 15*sizeof(u32
));
369 regs
->psr
= (regs
->psr
& ~PSR_ICC
) | (psr
& PSR_ICC
);
371 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
374 err
|= restore_fpu_state(regs
, fpu_save
);
375 err
|= __copy_from_user(&set
, &sf
->mask
, sizeof(sigset_t
));
377 err
|= __copy_from_user(&st
, &sf
->stack
, sizeof(stack_t
));
385 /* It is more difficult to avoid calling this function than to
386 call it and ignore errors. */
387 do_sigaltstack(&st
, NULL
, (unsigned long)sf
);
389 sigdelsetmask(&set
, ~_BLOCKABLE
);
390 spin_lock_irq(¤t
->sigmask_lock
);
391 current
->blocked
= set
;
392 recalc_sigpending(current
);
393 spin_unlock_irq(¤t
->sigmask_lock
);
396 send_sig(SIGSEGV
, current
, 1);
399 /* Checks if the fp is valid */
400 static inline int invalid_frame_pointer (void *fp
, int fplen
)
402 if ((((unsigned long) fp
) & 7) ||
403 !__access_ok((unsigned long)fp
, fplen
) ||
404 ((sparc_cpu_model
== sun4
|| sparc_cpu_model
== sun4c
) &&
405 ((unsigned long) fp
< 0xe0000000 && (unsigned long) fp
>= 0x20000000)))
411 static inline void *get_sigframe(struct sigaction
*sa
, struct pt_regs
*regs
, unsigned long framesize
)
415 sp
= regs
->u_regs
[UREG_FP
];
417 /* This is the X/Open sanctioned signal stack switching. */
418 if (sa
->sa_flags
& SA_ONSTACK
) {
419 if (!on_sig_stack(sp
) && !((current
->sas_ss_sp
+ current
->sas_ss_size
) & 7))
420 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
422 return (void *)(sp
- framesize
);
426 setup_frame(struct sigaction
*sa
, unsigned long pc
, unsigned long npc
,
427 struct pt_regs
*regs
, int signr
, sigset_t
*oldset
)
429 struct signal_sframe
*sframep
;
430 struct sigcontext
*sc
;
433 synchronize_user_stack();
434 sframep
= (struct signal_sframe
*)get_sigframe(sa
, regs
, SF_ALIGNEDSZ
);
435 if (invalid_frame_pointer (sframep
, sizeof(*sframep
))){
436 #ifdef DEBUG_SIGNALS /* fills up the console logs during crashme runs, yuck... */
437 printk("%s [%d]: User has trashed signal stack\n",
438 current
->comm
, current
->pid
);
439 printk("Sigstack ptr %p handler at pc<%08lx> for sig<%d>\n",
442 /* Don't change signal code and address, so that
443 * post mortem debuggers can have a look.
445 goto sigill_and_return
;
448 sc
= &sframep
->sig_context
;
450 /* We've already made sure frame pointer isn't in kernel space... */
451 err
= __put_user((sas_ss_flags(regs
->u_regs
[UREG_FP
]) == SS_ONSTACK
),
453 err
|= __put_user(oldset
->sig
[0], &sc
->sigc_mask
);
454 err
|= __copy_to_user(sframep
->extramask
, &oldset
->sig
[1],
455 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
456 err
|= __put_user(regs
->u_regs
[UREG_FP
], &sc
->sigc_sp
);
457 err
|= __put_user(pc
, &sc
->sigc_pc
);
458 err
|= __put_user(npc
, &sc
->sigc_npc
);
459 err
|= __put_user(regs
->psr
, &sc
->sigc_psr
);
460 err
|= __put_user(regs
->u_regs
[UREG_G1
], &sc
->sigc_g1
);
461 err
|= __put_user(regs
->u_regs
[UREG_I0
], &sc
->sigc_o0
);
462 err
|= __put_user(current
->thread
.w_saved
, &sc
->sigc_oswins
);
463 if(current
->thread
.w_saved
)
464 for(window
= 0; window
< current
->thread
.w_saved
; window
++) {
465 sc
->sigc_spbuf
[window
] =
466 (char *)current
->thread
.rwbuf_stkptrs
[window
];
467 err
|= __copy_to_user(&sc
->sigc_wbuf
[window
],
468 ¤t
->thread
.reg_window
[window
],
469 sizeof(struct reg_window
));
472 err
|= __copy_to_user(sframep
, (char *)regs
->u_regs
[UREG_FP
],
473 sizeof(struct reg_window
));
475 current
->thread
.w_saved
= 0; /* So process is allowed to execute. */
476 err
|= __put_user(signr
, &sframep
->sig_num
);
477 if(signr
== SIGSEGV
||
482 err
|= __put_user(current
->thread
.sig_desc
, &sframep
->sig_code
);
483 err
|= __put_user(current
->thread
.sig_address
, &sframep
->sig_address
);
485 err
|= __put_user(0, &sframep
->sig_code
);
486 err
|= __put_user(0, &sframep
->sig_address
);
488 err
|= __put_user(sc
, &sframep
->sig_scptr
);
492 regs
->u_regs
[UREG_FP
] = (unsigned long) sframep
;
493 regs
->pc
= (unsigned long) sa
->sa_handler
;
494 regs
->npc
= (regs
->pc
+ 4);
505 save_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
509 if (current
->flags
& PF_USEDFPU
) {
510 put_psr(get_psr() | PSR_EF
);
511 fpsave(¤t
->thread
.float_regs
[0], ¤t
->thread
.fsr
,
512 ¤t
->thread
.fpqueue
[0], ¤t
->thread
.fpqdepth
);
513 regs
->psr
&= ~(PSR_EF
);
514 current
->flags
&= ~(PF_USEDFPU
);
517 if (current
== last_task_used_math
) {
518 put_psr(get_psr() | PSR_EF
);
519 fpsave(¤t
->thread
.float_regs
[0], ¤t
->thread
.fsr
,
520 ¤t
->thread
.fpqueue
[0], ¤t
->thread
.fpqdepth
);
521 last_task_used_math
= 0;
522 regs
->psr
&= ~(PSR_EF
);
525 err
|= __copy_to_user(&fpu
->si_float_regs
[0], ¤t
->thread
.float_regs
[0],
526 (sizeof(unsigned long) * 32));
527 err
|= __put_user(current
->thread
.fsr
, &fpu
->si_fsr
);
528 err
|= __put_user(current
->thread
.fpqdepth
, &fpu
->si_fpqdepth
);
529 if (current
->thread
.fpqdepth
!= 0)
530 err
|= __copy_to_user(&fpu
->si_fpqueue
[0], ¤t
->thread
.fpqueue
[0],
531 ((sizeof(unsigned long) +
532 (sizeof(unsigned long *)))*16));
533 current
->used_math
= 0;
538 new_setup_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
539 int signo
, sigset_t
*oldset
)
541 struct new_signal_frame
*sf
;
542 int sigframe_size
, err
;
544 /* 1. Make sure everything is clean */
545 synchronize_user_stack();
547 sigframe_size
= NF_ALIGNEDSZ
;
548 if (!current
->used_math
)
549 sigframe_size
-= sizeof(__siginfo_fpu_t
);
551 sf
= (struct new_signal_frame
*)get_sigframe(&ka
->sa
, regs
, sigframe_size
);
553 if (invalid_frame_pointer (sf
, sigframe_size
))
554 goto sigill_and_return
;
556 if (current
->thread
.w_saved
!= 0) {
558 printk ("%s [%d]: Invalid user stack frame for "
559 "signal delivery.\n", current
->comm
, current
->pid
);
561 goto sigill_and_return
;
564 /* 2. Save the current process state */
565 err
= __copy_to_user(&sf
->info
.si_regs
, regs
, sizeof (struct pt_regs
));
567 err
|= __put_user(0, &sf
->extra_size
);
569 if (current
->used_math
) {
570 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
571 err
|= __put_user(&sf
->fpu_state
, &sf
->fpu_save
);
573 err
|= __put_user(0, &sf
->fpu_save
);
576 err
|= __put_user(oldset
->sig
[0], &sf
->info
.si_mask
);
577 err
|= __copy_to_user(sf
->extramask
, &oldset
->sig
[1],
578 (_NSIG_WORDS
- 1) * sizeof(unsigned int));
579 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
580 sizeof (struct reg_window
));
584 /* 3. signal handler back-trampoline and parameters */
585 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
586 regs
->u_regs
[UREG_I0
] = signo
;
587 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
589 /* 4. signal handler */
590 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
591 regs
->npc
= (regs
->pc
+ 4);
593 /* 5. return to kernel instructions */
595 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
597 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
599 /* mov __NR_sigreturn, %g1 */
600 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
603 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
607 /* Flush instruction space. */
608 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
619 new_setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
620 int signo
, sigset_t
*oldset
, siginfo_t
*info
)
622 struct rt_signal_frame
*sf
;
627 synchronize_user_stack();
628 sigframe_size
= RT_ALIGNEDSZ
;
629 if(!current
->used_math
)
630 sigframe_size
-= sizeof(__siginfo_fpu_t
);
631 sf
= (struct rt_signal_frame
*)get_sigframe(&ka
->sa
, regs
, sigframe_size
);
632 if(invalid_frame_pointer(sf
, sigframe_size
))
634 if(current
->thread
.w_saved
!= 0)
637 err
= __put_user(regs
->pc
, &sf
->regs
.pc
);
638 err
|= __put_user(regs
->npc
, &sf
->regs
.npc
);
639 err
|= __put_user(regs
->y
, &sf
->regs
.y
);
641 if(current
->used_math
)
643 err
|= __put_user(psr
, &sf
->regs
.psr
);
644 err
|= __copy_to_user(&sf
->regs
.u_regs
, regs
->u_regs
, sizeof(regs
->u_regs
));
645 err
|= __put_user(0, &sf
->extra_size
);
648 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
649 err
|= __put_user(&sf
->fpu_state
, &sf
->fpu_save
);
651 err
|= __put_user(0, &sf
->fpu_save
);
653 err
|= __copy_to_user(&sf
->mask
, &oldset
->sig
[0], sizeof(sigset_t
));
655 /* Setup sigaltstack */
656 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
657 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
658 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
660 err
|= __copy_to_user(sf
, (char *) regs
->u_regs
[UREG_FP
],
661 sizeof (struct reg_window
));
663 err
|= __copy_to_user(&sf
->info
, info
, sizeof(siginfo_t
));
668 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
669 regs
->u_regs
[UREG_I0
] = signo
;
670 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
672 regs
->pc
= (unsigned long) ka
->sa
.sa_handler
;
673 regs
->npc
= (regs
->pc
+ 4);
676 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
678 regs
->u_regs
[UREG_I7
] = (unsigned long)(&(sf
->insns
[0]) - 2);
680 /* mov __NR_sigreturn, %g1 */
681 err
|= __put_user(0x821020d8, &sf
->insns
[0]);
684 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
688 /* Flush instruction space. */
689 flush_sig_insns(current
->mm
, (unsigned long) &(sf
->insns
[0]));
699 /* Setup a Solaris stack frame */
701 setup_svr4_frame(struct sigaction
*sa
, unsigned long pc
, unsigned long npc
,
702 struct pt_regs
*regs
, int signr
, sigset_t
*oldset
)
704 svr4_signal_frame_t
*sfp
;
713 synchronize_user_stack();
714 sfp
= (svr4_signal_frame_t
*) get_sigframe(sa
, regs
, SVR4_SF_ALIGNED
+ REGWIN_SZ
);
716 if (invalid_frame_pointer (sfp
, sizeof (*sfp
))){
718 printk ("Invalid stack frame\n");
720 goto sigill_and_return
;
723 /* Start with a clean frame pointer and fill it */
724 err
= __clear_user(sfp
, sizeof (*sfp
));
726 /* Setup convenience variables */
733 /* FIXME: where am I supposed to put this?
734 * sc->sigc_onstack = old_status;
735 * anyways, it does not look like it is used for anything at all.
737 setv
.sigbits
[0] = oldset
->sig
[0];
738 setv
.sigbits
[1] = oldset
->sig
[1];
739 if (_NSIG_WORDS
>= 4) {
740 setv
.sigbits
[2] = oldset
->sig
[2];
741 setv
.sigbits
[3] = oldset
->sig
[3];
742 err
|= __copy_to_user(&uc
->sigmask
, &setv
, sizeof(svr4_sigset_t
));
744 err
|= __copy_to_user(&uc
->sigmask
, &setv
, 2 * sizeof(unsigned int));
746 /* Store registers */
747 err
|= __put_user(regs
->pc
, &((*gr
) [SVR4_PC
]));
748 err
|= __put_user(regs
->npc
, &((*gr
) [SVR4_NPC
]));
749 err
|= __put_user(regs
->psr
, &((*gr
) [SVR4_PSR
]));
750 err
|= __put_user(regs
->y
, &((*gr
) [SVR4_Y
]));
752 /* Copy g [1..7] and o [0..7] registers */
753 err
|= __copy_to_user(&(*gr
)[SVR4_G1
], ®s
->u_regs
[UREG_G1
], sizeof (long) * 7);
754 err
|= __copy_to_user(&(*gr
)[SVR4_O0
], ®s
->u_regs
[UREG_I0
], sizeof (long) * 8);
756 /* Setup sigaltstack */
757 err
|= __put_user(current
->sas_ss_sp
, &uc
->stack
.sp
);
758 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &uc
->stack
.flags
);
759 err
|= __put_user(current
->sas_ss_size
, &uc
->stack
.size
);
761 /* Save the currently window file: */
763 /* 1. Link sfp->uc->gwins to our windows */
764 err
|= __put_user(gw
, &mc
->gwin
);
766 /* 2. Number of windows to restore at setcontext (): */
767 err
|= __put_user(current
->thread
.w_saved
, &gw
->count
);
769 /* 3. Save each valid window
770 * Currently, it makes a copy of the windows from the kernel copy.
771 * David's code for SunOS, makes the copy but keeps the pointer to
772 * the kernel. My version makes the pointer point to a userland
773 * copy of those. Mhm, I wonder if I shouldn't just ignore those
774 * on setcontext and use those that are on the kernel, the signal
775 * handler should not be modyfing those, mhm.
777 * These windows are just used in case synchronize_user_stack failed
778 * to flush the user windows.
780 for(window
= 0; window
< current
->thread
.w_saved
; window
++) {
781 err
|= __put_user((int *) &(gw
->win
[window
]), &gw
->winptr
[window
]);
782 err
|= __copy_to_user(&gw
->win
[window
],
783 ¤t
->thread
.reg_window
[window
],
784 sizeof (svr4_rwindow_t
));
785 err
|= __put_user(0, gw
->winptr
[window
]);
788 /* 4. We just pay attention to the gw->count field on setcontext */
789 current
->thread
.w_saved
= 0; /* So process is allowed to execute. */
791 /* Setup the signal information. Solaris expects a bunch of
792 * information to be passed to the signal handler, we don't provide
793 * that much currently, should use those that David already
794 * is providing with thread.sig_desc
796 err
|= __put_user(signr
, &si
->siginfo
.signo
);
797 err
|= __put_user(SVR4_SINOINFO
, &si
->siginfo
.code
);
801 regs
->u_regs
[UREG_FP
] = (unsigned long) sfp
;
802 regs
->pc
= (unsigned long) sa
->sa_handler
;
803 regs
->npc
= (regs
->pc
+ 4);
806 printk ("Solaris-frame: %x %x\n", (int) regs
->pc
, (int) regs
->npc
);
808 /* Arguments passed to signal handler */
809 if (regs
->u_regs
[14]){
810 struct reg_window
*rw
= (struct reg_window
*) regs
->u_regs
[14];
812 err
|= __put_user(signr
, &rw
->ins
[0]);
813 err
|= __put_user(si
, &rw
->ins
[1]);
814 err
|= __put_user(uc
, &rw
->ins
[2]);
815 err
|= __put_user(sfp
, &rw
->ins
[6]); /* frame pointer */
819 regs
->u_regs
[UREG_I0
] = signr
;
820 regs
->u_regs
[UREG_I1
] = (uint
) si
;
821 regs
->u_regs
[UREG_I2
] = (uint
) uc
;
831 asmlinkage
int svr4_getcontext (svr4_ucontext_t
*uc
, struct pt_regs
*regs
)
838 synchronize_user_stack();
840 if (current
->thread
.w_saved
)
841 goto sigsegv_and_return
;
843 err
= clear_user(uc
, sizeof (*uc
));
847 /* Setup convenience variables */
851 setv
.sigbits
[0] = current
->blocked
.sig
[0];
852 setv
.sigbits
[1] = current
->blocked
.sig
[1];
853 if (_NSIG_WORDS
>= 4) {
854 setv
.sigbits
[2] = current
->blocked
.sig
[2];
855 setv
.sigbits
[3] = current
->blocked
.sig
[3];
856 err
|= __copy_to_user(&uc
->sigmask
, &setv
, sizeof(svr4_sigset_t
));
858 err
|= __copy_to_user(&uc
->sigmask
, &setv
, 2 * sizeof(unsigned int));
860 /* Store registers */
861 err
|= __put_user(regs
->pc
, &uc
->mcontext
.greg
[SVR4_PC
]);
862 err
|= __put_user(regs
->npc
, &uc
->mcontext
.greg
[SVR4_NPC
]);
863 err
|= __put_user(regs
->psr
, &uc
->mcontext
.greg
[SVR4_PSR
]);
864 err
|= __put_user(regs
->y
, &uc
->mcontext
.greg
[SVR4_Y
]);
866 /* Copy g [1..7] and o [0..7] registers */
867 err
|= __copy_to_user(&(*gr
)[SVR4_G1
], ®s
->u_regs
[UREG_G1
], sizeof (uint
) * 7);
868 err
|= __copy_to_user(&(*gr
)[SVR4_O0
], ®s
->u_regs
[UREG_I0
], sizeof (uint
) * 8);
870 /* Setup sigaltstack */
871 err
|= __put_user(current
->sas_ss_sp
, &uc
->stack
.sp
);
872 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &uc
->stack
.flags
);
873 err
|= __put_user(current
->sas_ss_size
, &uc
->stack
.size
);
875 /* The register file is not saved
876 * we have already stuffed all of it with sync_user_stack
878 return (err
? -EFAULT
: 0);
884 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
885 asmlinkage
int svr4_setcontext (svr4_ucontext_t
*c
, struct pt_regs
*regs
)
887 struct thread_struct
*tp
= ¤t
->thread
;
889 unsigned long pc
, npc
, psr
;
895 /* Fixme: restore windows, or is this already taken care of in
896 * svr4_setup_frame when sync_user_windows is done?
898 flush_user_windows();
901 goto sigsegv_and_return
;
904 goto sigsegv_and_return
;
906 if(!__access_ok((unsigned long)c
, sizeof(*c
)))
907 goto sigsegv_and_return
;
909 /* Check for valid PC and nPC */
910 gr
= &c
->mcontext
.greg
;
911 err
= __get_user(pc
, &((*gr
)[SVR4_PC
]));
912 err
|= __get_user(npc
, &((*gr
)[SVR4_NPC
]));
915 goto sigsegv_and_return
;
917 /* Retrieve information from passed ucontext */
918 /* note that nPC is ored a 1, this is used to inform entry.S */
919 /* that we don't want it to mess with our PC and nPC */
921 /* This is pretty much atomic, no amount locking would prevent
922 * the races which exist anyways.
924 err
|= __copy_from_user(&setv
, &c
->sigmask
, sizeof(svr4_sigset_t
));
926 err
|= __get_user(st
.ss_sp
, &c
->stack
.sp
);
927 err
|= __get_user(st
.ss_flags
, &c
->stack
.flags
);
928 err
|= __get_user(st
.ss_size
, &c
->stack
.size
);
931 goto sigsegv_and_return
;
933 /* It is more difficult to avoid calling this function than to
934 call it and ignore errors. */
935 do_sigaltstack(&st
, NULL
, regs
->u_regs
[UREG_I6
]);
937 set
.sig
[0] = setv
.sigbits
[0];
938 set
.sig
[1] = setv
.sigbits
[1];
939 if (_NSIG_WORDS
>= 4) {
940 set
.sig
[2] = setv
.sigbits
[2];
941 set
.sig
[3] = setv
.sigbits
[3];
943 sigdelsetmask(&set
, ~_BLOCKABLE
);
944 spin_lock_irq(¤t
->sigmask_lock
);
945 current
->blocked
= set
;
946 recalc_sigpending(current
);
947 spin_unlock_irq(¤t
->sigmask_lock
);
950 err
|= __get_user(regs
->y
, &((*gr
) [SVR4_Y
]));
951 err
|= __get_user(psr
, &((*gr
) [SVR4_PSR
]));
952 regs
->psr
&= ~(PSR_ICC
);
953 regs
->psr
|= (psr
& PSR_ICC
);
955 /* Restore g[1..7] and o[0..7] registers */
956 err
|= __copy_from_user(®s
->u_regs
[UREG_G1
], &(*gr
)[SVR4_G1
],
958 err
|= __copy_from_user(®s
->u_regs
[UREG_I0
], &(*gr
)[SVR4_O0
],
960 return (err
? -EFAULT
: 0);
967 handle_signal(unsigned long signr
, struct k_sigaction
*ka
,
968 siginfo_t
*info
, sigset_t
*oldset
, struct pt_regs
*regs
,
972 setup_svr4_frame(&ka
->sa
, regs
->pc
, regs
->npc
, regs
, signr
, oldset
);
974 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
975 new_setup_rt_frame(ka
, regs
, signr
, oldset
, info
);
976 else if (current
->thread
.new_signal
)
977 new_setup_frame (ka
, regs
, signr
, oldset
);
979 setup_frame(&ka
->sa
, regs
->pc
, regs
->npc
, regs
, signr
, oldset
);
981 if(ka
->sa
.sa_flags
& SA_ONESHOT
)
982 ka
->sa
.sa_handler
= SIG_DFL
;
983 if(!(ka
->sa
.sa_flags
& SA_NOMASK
)) {
984 spin_lock_irq(¤t
->sigmask_lock
);
985 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
986 sigaddset(¤t
->blocked
, signr
);
987 recalc_sigpending(current
);
988 spin_unlock_irq(¤t
->sigmask_lock
);
992 static inline void syscall_restart(unsigned long orig_i0
, struct pt_regs
*regs
,
993 struct sigaction
*sa
)
995 switch(regs
->u_regs
[UREG_I0
]) {
997 no_system_call_restart
:
998 regs
->u_regs
[UREG_I0
] = EINTR
;
1002 if(!(sa
->sa_flags
& SA_RESTART
))
1003 goto no_system_call_restart
;
1005 case ERESTARTNOINTR
:
1006 regs
->u_regs
[UREG_I0
] = orig_i0
;
1012 #ifdef DEBUG_SIGNALS_MAPS
1014 #define MAPS_LINE_FORMAT "%08lx-%08lx %s %08lx %s %lu "
1016 static inline void read_maps (void)
1018 struct vm_area_struct
* map
, * next
;
1022 buffer
= (char*)__get_free_page(GFP_KERNEL
);
1026 for (map
= current
->mm
->mmap
; map
; map
= next
) {
1027 /* produce the next line */
1029 char str
[5], *cp
= str
;
1035 * Get the next vma now (but it won't be used if we sleep).
1037 next
= map
->vm_next
;
1038 flags
= map
->vm_flags
;
1040 *cp
++ = flags
& VM_READ
? 'r' : '-';
1041 *cp
++ = flags
& VM_WRITE
? 'w' : '-';
1042 *cp
++ = flags
& VM_EXEC
? 'x' : '-';
1043 *cp
++ = flags
& VM_MAYSHARE
? 's' : 'p';
1048 if (map
->vm_file
!= NULL
) {
1049 dev
= map
->vm_file
->f_dentry
->d_inode
->i_dev
;
1050 ino
= map
->vm_file
->f_dentry
->d_inode
->i_ino
;
1051 line
= d_path(map
->vm_file
->f_dentry
, buffer
, PAGE_SIZE
);
1053 printk(MAPS_LINE_FORMAT
, map
->vm_start
, map
->vm_end
, str
, map
->vm_offset
,
1054 kdevname(dev
), ino
);
1055 if (map
->vm_file
!= NULL
)
1056 printk("%s\n", line
);
1060 free_page((unsigned long)buffer
);
1065 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1066 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1069 asmlinkage
int do_signal(sigset_t
*oldset
, struct pt_regs
* regs
,
1070 unsigned long orig_i0
, int restart_syscall
)
1072 unsigned long signr
;
1073 struct k_sigaction
*ka
;
1076 int svr4_signal
= current
->personality
== PER_SVR4
;
1079 oldset
= ¤t
->blocked
;
1082 spin_lock_irq(¤t
->sigmask_lock
);
1083 signr
= dequeue_signal(¤t
->blocked
, &info
);
1084 spin_unlock_irq(¤t
->sigmask_lock
);
1088 if ((current
->flags
& PF_PTRACED
) && signr
!= SIGKILL
) {
1089 current
->exit_code
= signr
;
1090 current
->state
= TASK_STOPPED
;
1092 /* This happens to be SMP safe so no need to
1093 * grab master kernel lock even in this case.
1095 notify_parent(current
, SIGCHLD
);
1097 if (!(signr
= current
->exit_code
))
1099 current
->exit_code
= 0;
1100 if (signr
== SIGSTOP
)
1103 /* Update the siginfo structure. Is this good? */
1104 if (signr
!= info
.si_signo
) {
1105 info
.si_signo
= signr
;
1107 info
.si_code
= SI_USER
;
1108 info
.si_pid
= current
->p_pptr
->pid
;
1109 info
.si_uid
= current
->p_pptr
->uid
;
1112 /* If the (new) signal is now blocked, requeue it. */
1113 if (sigismember(¤t
->blocked
, signr
)) {
1114 send_sig_info(signr
, &info
, current
);
1119 ka
= ¤t
->sig
->action
[signr
-1];
1121 if(ka
->sa
.sa_handler
== SIG_IGN
) {
1122 if(signr
!= SIGCHLD
)
1125 /* sys_wait4() grabs the master kernel lock, so
1126 * we need not do so, that sucker should be
1127 * threaded and would not be that difficult to
1130 while(sys_wait4(-1, NULL
, WNOHANG
, NULL
) > 0)
1134 if(ka
->sa
.sa_handler
== SIG_DFL
) {
1135 unsigned long exit_code
= signr
;
1137 if(current
->pid
== 1)
1140 case SIGCONT
: case SIGCHLD
: case SIGWINCH
:
1143 case SIGTSTP
: case SIGTTIN
: case SIGTTOU
:
1144 /* The operations performed by
1145 * is_orphaned_pgrp() are protected by
1146 * the tasklist_lock.
1148 if (is_orphaned_pgrp(current
->pgrp
))
1152 if (current
->flags
& PF_PTRACED
)
1154 current
->state
= TASK_STOPPED
;
1155 current
->exit_code
= signr
;
1157 /* notify_parent() is SMP safe */
1158 if(!(current
->p_pptr
->sig
->action
[SIGCHLD
-1].sa
.sa_flags
&
1160 notify_parent(current
, SIGCHLD
);
1164 case SIGQUIT
: case SIGILL
: case SIGTRAP
:
1165 case SIGABRT
: case SIGFPE
: case SIGSEGV
: case SIGBUS
:
1166 if (do_coredump(signr
, regs
))
1168 #ifdef DEBUG_SIGNALS
1169 /* Very useful to debug dynamic linker problems */
1170 printk ("Sig %ld going for %s[%d]...\n", signr
, current
->comm
, current
->pid
);
1172 #ifdef DEBUG_SIGNALS_TRACE
1174 struct reg_window
*rw
= (struct reg_window
*)regs
->u_regs
[UREG_FP
];
1175 unsigned int ins
[8];
1178 !(((unsigned long) rw
) & 0x3)) {
1179 copy_from_user(ins
, &rw
->ins
[0], sizeof(ins
));
1180 printk("Caller[%08x](%08x,%08x,%08x,%08x,%08x,%08x)\n", ins
[7], ins
[0], ins
[1], ins
[2], ins
[3], ins
[4], ins
[5]);
1181 rw
= (struct reg_window
*)(unsigned long)ins
[6];
1185 #ifdef DEBUG_SIGNALS_MAPS
1193 sigaddset(¤t
->signal
, signr
);
1194 recalc_sigpending(current
);
1195 current
->flags
|= PF_SIGNALED
;
1201 syscall_restart(orig_i0
, regs
, &ka
->sa
);
1202 handle_signal(signr
, ka
, &info
, oldset
, regs
, svr4_signal
);
1205 if(restart_syscall
&&
1206 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
1207 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
1208 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
1209 /* replay the system call when we are done */
1210 regs
->u_regs
[UREG_I0
] = orig_i0
;
1218 do_sys_sigstack(struct sigstack
*ssptr
, struct sigstack
*ossptr
, unsigned long sp
)
1222 /* First see if old state is wanted. */
1224 if (put_user(current
->sas_ss_sp
+ current
->sas_ss_size
, &ossptr
->the_stack
) ||
1225 __put_user(on_sig_stack(sp
), &ossptr
->cur_status
))
1229 /* Now see if we want to update the new state. */
1233 if (get_user((long)ss_sp
, &ssptr
->the_stack
))
1235 /* If the current stack was set with sigaltstack, don't
1236 swap stacks while we are on it. */
1238 if (current
->sas_ss_sp
&& on_sig_stack(sp
))
1241 /* Since we don't know the extent of the stack, and we don't
1242 track onstack-ness, but rather calculate it, we must
1243 presume a size. Ho hum this interface is lossy. */
1244 current
->sas_ss_sp
= (unsigned long)ss_sp
- SIGSTKSZ
;
1245 current
->sas_ss_size
= SIGSTKSZ
;