1 /* $Id: signal32.c,v 1.58 2000/01/14 09:40:08 jj Exp $
2 * arch/sparc64/kernel/signal32.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)
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
11 #include <linux/sched.h>
12 #include <linux/kernel.h>
13 #include <linux/signal.h>
14 #include <linux/errno.h>
15 #include <linux/wait.h>
16 #include <linux/ptrace.h>
17 #include <linux/unistd.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>
26 #include <asm/psrcompat.h>
27 #include <asm/fpumacro.h>
28 #include <asm/visasm.h>
30 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
32 asmlinkage
int sys_wait4(pid_t pid
, unsigned long *stat_addr
,
33 int options
, unsigned long *ru
);
35 asmlinkage
int do_signal32(sigset_t
*oldset
, struct pt_regs
*regs
,
36 unsigned long orig_o0
, int ret_from_syscall
);
38 /* This turned off for production... */
39 /* #define DEBUG_SIGNALS 1 */
40 /* #define DEBUG_SIGNALS_TRACE 1 */
41 /* #define DEBUG_SIGNALS_MAPS 1 */
42 /* #define DEBUG_SIGNALS_TLB 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_sframe32
{
59 struct reg_window32 sig_window
;
62 /* struct sigcontext32 * */ u32 sig_scptr
;
64 struct sigcontext32 sig_context
;
65 unsigned extramask
[_NSIG_WORDS32
- 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.
73 struct new_signal_frame32
{
74 struct sparc_stackf32 ss
;
76 /* __siginfo_fpu32_t * */ u32 fpu_save
;
77 unsigned int insns
[2];
78 unsigned extramask
[_NSIG_WORDS32
- 1];
79 unsigned extra_size
; /* Should be sizeof(siginfo_extra_v8plus_t) */
80 /* Only valid if (info.si_regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
81 siginfo_extra_v8plus_t v8plus
;
82 __siginfo_fpu_t fpu_state
;
85 struct rt_signal_frame32
{
86 struct sparc_stackf32 ss
;
88 struct pt_regs32 regs
;
90 /* __siginfo_fpu32_t * */ u32 fpu_save
;
91 unsigned int insns
[2];
93 unsigned extra_size
; /* Should be sizeof(siginfo_extra_v8plus_t) */
94 /* Only valid if (regs.psr & (PSR_VERS|PSR_IMPL)) == PSR_V8PLUS */
95 siginfo_extra_v8plus_t v8plus
;
96 __siginfo_fpu_t fpu_state
;
100 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe32) + 7) & (~7)))
101 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame32) + 7) & (~7)))
102 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame32) + 7) & (~7)))
105 * atomically swap in the new signal mask, and wait for a signal.
106 * This is really tricky on the Sparc, watch out...
108 asmlinkage
void _sigpause32_common(old_sigset_t32 set
, struct pt_regs
*regs
)
113 spin_lock_irq(¤t
->sigmask_lock
);
114 saveset
= current
->blocked
;
115 siginitset(¤t
->blocked
, set
);
116 recalc_sigpending(current
);
117 spin_unlock_irq(¤t
->sigmask_lock
);
119 regs
->tpc
= regs
->tnpc
;
122 /* Condition codes and return value where set here for sigpause,
123 * and so got used by setup_frame, which again causes sigreturn()
127 current
->state
= TASK_INTERRUPTIBLE
;
130 * Return -EINTR and set condition code here,
131 * so the interrupted system call actually returns
134 regs
->tstate
|= TSTATE_ICARRY
;
135 regs
->u_regs
[UREG_I0
] = EINTR
;
136 if (do_signal32(&saveset
, regs
, 0, 0))
141 asmlinkage
void do_rt_sigsuspend32(u32 uset
, size_t sigsetsize
, struct pt_regs
*regs
)
143 sigset_t oldset
, set
;
146 /* XXX: Don't preclude handling different sized sigset_t's. */
147 if (((__kernel_size_t32
)sigsetsize
) != sizeof(sigset_t
)) {
148 regs
->tstate
|= TSTATE_ICARRY
;
149 regs
->u_regs
[UREG_I0
] = EINVAL
;
152 if (copy_from_user(&set32
, (void *)(long)uset
, sizeof(set32
))) {
153 regs
->tstate
|= TSTATE_ICARRY
;
154 regs
->u_regs
[UREG_I0
] = EFAULT
;
157 switch (_NSIG_WORDS
) {
158 case 4: set
.sig
[3] = set32
.sig
[6] + (((long)set32
.sig
[7]) << 32);
159 case 3: set
.sig
[2] = set32
.sig
[4] + (((long)set32
.sig
[5]) << 32);
160 case 2: set
.sig
[1] = set32
.sig
[2] + (((long)set32
.sig
[3]) << 32);
161 case 1: set
.sig
[0] = set32
.sig
[0] + (((long)set32
.sig
[1]) << 32);
163 sigdelsetmask(&set
, ~_BLOCKABLE
);
164 spin_lock_irq(¤t
->sigmask_lock
);
165 oldset
= current
->blocked
;
166 current
->blocked
= set
;
167 recalc_sigpending(current
);
168 spin_unlock_irq(¤t
->sigmask_lock
);
170 regs
->tpc
= regs
->tnpc
;
173 /* Condition codes and return value where set here for sigpause,
174 * and so got used by setup_frame, which again causes sigreturn()
178 current
->state
= TASK_INTERRUPTIBLE
;
181 * Return -EINTR and set condition code here,
182 * so the interrupted system call actually returns
185 regs
->tstate
|= TSTATE_ICARRY
;
186 regs
->u_regs
[UREG_I0
] = EINTR
;
187 if (do_signal32(&oldset
, regs
, 0, 0))
192 static inline int restore_fpu_state32(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
194 unsigned long *fpregs
= (unsigned long *)(((char *)current
) + AOFF_task_fpregs
);
198 err
= __get_user(fprs
, &fpu
->si_fprs
);
200 regs
->tstate
&= ~TSTATE_PEF
;
202 err
|= copy_from_user(fpregs
, &fpu
->si_float_regs
[0], (sizeof(unsigned int) * 32));
204 err
|= copy_from_user(fpregs
+16, &fpu
->si_float_regs
[32], (sizeof(unsigned int) * 32));
205 err
|= __get_user(current
->thread
.xfsr
[0], &fpu
->si_fsr
);
206 err
|= __get_user(current
->thread
.gsr
[0], &fpu
->si_gsr
);
207 current
->thread
.fpsaved
[0] |= fprs
;
211 void do_new_sigreturn32(struct pt_regs
*regs
)
213 struct new_signal_frame32
*sf
;
215 unsigned pc
, npc
, fpu_save
;
217 unsigned seta
[_NSIG_WORDS32
];
220 regs
->u_regs
[UREG_FP
] &= 0x00000000ffffffffUL
;
221 sf
= (struct new_signal_frame32
*) regs
->u_regs
[UREG_FP
];
223 /* 1. Make sure we are not getting garbage from the user */
224 if (verify_area (VERIFY_READ
, sf
, sizeof (*sf
)) ||
225 (((unsigned long) sf
) & 3))
228 get_user(pc
, &sf
->info
.si_regs
.pc
);
229 __get_user(npc
, &sf
->info
.si_regs
.npc
);
237 /* 2. Restore the state */
238 err
= __get_user(regs
->y
, &sf
->info
.si_regs
.y
);
239 err
|= __get_user(psr
, &sf
->info
.si_regs
.psr
);
241 for (i
= UREG_G1
; i
<= UREG_I7
; i
++)
242 err
|= __get_user(regs
->u_regs
[i
], &sf
->info
.si_regs
.u_regs
[i
]);
243 if ((psr
& (PSR_VERS
|PSR_IMPL
)) == PSR_V8PLUS
) {
244 err
|= __get_user(i
, &sf
->v8plus
.g_upper
[0]);
245 if (i
== SIGINFO_EXTRA_V8PLUS_MAGIC
) {
246 for (i
= UREG_G1
; i
<= UREG_I7
; i
++)
247 err
|= __get_user(((u32
*)regs
->u_regs
)[2*i
], &sf
->v8plus
.g_upper
[i
]);
251 /* User can only change condition codes in %tstate. */
252 regs
->tstate
&= ~(TSTATE_ICC
|TSTATE_XCC
);
253 regs
->tstate
|= psr_to_tstate_icc(psr
);
255 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
257 err
|= restore_fpu_state32(regs
, &sf
->fpu_state
);
258 err
|= __get_user(seta
[0], &sf
->info
.si_mask
);
259 err
|= copy_from_user(seta
+1, &sf
->extramask
, (_NSIG_WORDS32
- 1) * sizeof(unsigned));
262 switch (_NSIG_WORDS
) {
263 case 4: set
.sig
[3] = seta
[6] + (((long)seta
[7]) << 32);
264 case 3: set
.sig
[2] = seta
[4] + (((long)seta
[5]) << 32);
265 case 2: set
.sig
[1] = seta
[2] + (((long)seta
[3]) << 32);
266 case 1: set
.sig
[0] = seta
[0] + (((long)seta
[1]) << 32);
268 sigdelsetmask(&set
, ~_BLOCKABLE
);
269 spin_lock_irq(¤t
->sigmask_lock
);
270 current
->blocked
= set
;
271 recalc_sigpending(current
);
272 spin_unlock_irq(¤t
->sigmask_lock
);
279 asmlinkage
void do_sigreturn32(struct pt_regs
*regs
)
281 struct sigcontext32
*scptr
;
282 unsigned pc
, npc
, psr
;
284 unsigned seta
[_NSIG_WORDS32
];
287 synchronize_user_stack();
288 if (current
->thread
.flags
& SPARC_FLAG_NEWSIGNALS
)
289 return do_new_sigreturn32(regs
);
291 scptr
= (struct sigcontext32
*)
292 (regs
->u_regs
[UREG_I0
] & 0x00000000ffffffffUL
);
293 /* Check sanity of the user arg. */
294 if(verify_area(VERIFY_READ
, scptr
, sizeof(struct sigcontext32
)) ||
295 (((unsigned long) scptr
) & 3))
298 err
= __get_user(pc
, &scptr
->sigc_pc
);
299 err
|= __get_user(npc
, &scptr
->sigc_npc
);
302 goto segv
; /* Nice try. */
304 err
|= __get_user(seta
[0], &scptr
->sigc_mask
);
305 /* Note that scptr + 1 points to extramask */
306 err
|= copy_from_user(seta
+1, scptr
+ 1, (_NSIG_WORDS32
- 1) * sizeof(unsigned));
309 switch (_NSIG_WORDS
) {
310 case 4: set
.sig
[3] = seta
[6] + (((long)seta
[7]) << 32);
311 case 3: set
.sig
[2] = seta
[4] + (((long)seta
[5]) << 32);
312 case 2: set
.sig
[1] = seta
[2] + (((long)seta
[3]) << 32);
313 case 1: set
.sig
[0] = seta
[0] + (((long)seta
[1]) << 32);
315 sigdelsetmask(&set
, ~_BLOCKABLE
);
316 spin_lock_irq(¤t
->sigmask_lock
);
317 current
->blocked
= set
;
318 recalc_sigpending(current
);
319 spin_unlock_irq(¤t
->sigmask_lock
);
323 err
= __get_user(regs
->u_regs
[UREG_FP
], &scptr
->sigc_sp
);
324 err
|= __get_user(regs
->u_regs
[UREG_I0
], &scptr
->sigc_o0
);
325 err
|= __get_user(regs
->u_regs
[UREG_G1
], &scptr
->sigc_g1
);
327 /* User can only change condition codes in %tstate. */
328 err
|= __get_user(psr
, &scptr
->sigc_psr
);
331 regs
->tstate
&= ~(TSTATE_ICC
|TSTATE_XCC
);
332 regs
->tstate
|= psr_to_tstate_icc(psr
);
339 asmlinkage
void do_rt_sigreturn32(struct pt_regs
*regs
)
341 struct rt_signal_frame32
*sf
;
343 unsigned pc
, npc
, fpu_save
;
349 synchronize_user_stack();
350 regs
->u_regs
[UREG_FP
] &= 0x00000000ffffffffUL
;
351 sf
= (struct rt_signal_frame32
*) regs
->u_regs
[UREG_FP
];
353 /* 1. Make sure we are not getting garbage from the user */
354 if (verify_area (VERIFY_READ
, sf
, sizeof (*sf
)) ||
355 (((unsigned long) sf
) & 3))
358 get_user(pc
, &sf
->regs
.pc
);
359 __get_user(npc
, &sf
->regs
.npc
);
367 /* 2. Restore the state */
368 err
= __get_user(regs
->y
, &sf
->regs
.y
);
369 err
|= __get_user(psr
, &sf
->regs
.psr
);
371 for (i
= UREG_G1
; i
<= UREG_I7
; i
++)
372 err
|= __get_user(regs
->u_regs
[i
], &sf
->regs
.u_regs
[i
]);
373 if ((psr
& (PSR_VERS
|PSR_IMPL
)) == PSR_V8PLUS
) {
374 err
|= __get_user(i
, &sf
->v8plus
.g_upper
[0]);
375 if (i
== SIGINFO_EXTRA_V8PLUS_MAGIC
) {
376 for (i
= UREG_G1
; i
<= UREG_I7
; i
++)
377 err
|= __get_user(((u32
*)regs
->u_regs
)[2*i
], &sf
->v8plus
.g_upper
[i
]);
381 /* User can only change condition codes in %tstate. */
382 regs
->tstate
&= ~(TSTATE_ICC
|TSTATE_XCC
);
383 regs
->tstate
|= psr_to_tstate_icc(psr
);
385 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
387 err
|= restore_fpu_state32(regs
, &sf
->fpu_state
);
388 err
|= copy_from_user(&seta
, &sf
->mask
, sizeof(sigset_t32
));
389 err
|= __get_user((long)st
.ss_sp
, &sf
->stack
.ss_sp
);
390 err
|= __get_user(st
.ss_flags
, &sf
->stack
.ss_flags
);
391 err
|= __get_user(st
.ss_size
, &sf
->stack
.ss_size
);
395 /* It is more difficult to avoid calling this function than to
396 call it and ignore errors. */
397 do_sigaltstack(&st
, NULL
, (unsigned long)sf
);
399 switch (_NSIG_WORDS
) {
400 case 4: set
.sig
[3] = seta
.sig
[6] + (((long)seta
.sig
[7]) << 32);
401 case 3: set
.sig
[2] = seta
.sig
[4] + (((long)seta
.sig
[5]) << 32);
402 case 2: set
.sig
[1] = seta
.sig
[2] + (((long)seta
.sig
[3]) << 32);
403 case 1: set
.sig
[0] = seta
.sig
[0] + (((long)seta
.sig
[1]) << 32);
405 sigdelsetmask(&set
, ~_BLOCKABLE
);
406 spin_lock_irq(¤t
->sigmask_lock
);
407 current
->blocked
= set
;
408 recalc_sigpending(current
);
409 spin_unlock_irq(¤t
->sigmask_lock
);
415 /* Checks if the fp is valid */
416 static int invalid_frame_pointer(void *fp
, int fplen
)
418 if ((((unsigned long) fp
) & 7) || ((unsigned long)fp
) > 0x100000000ULL
- fplen
)
423 static inline void *get_sigframe(struct sigaction
*sa
, struct pt_regs
*regs
, unsigned long framesize
)
427 regs
->u_regs
[UREG_FP
] &= 0x00000000ffffffffUL
;
428 sp
= regs
->u_regs
[UREG_FP
];
430 /* This is the X/Open sanctioned signal stack switching. */
431 if (sa
->sa_flags
& SA_ONSTACK
) {
432 if (!on_sig_stack(sp
) && !((current
->sas_ss_sp
+ current
->sas_ss_size
) & 7))
433 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
435 return (void *)(sp
- framesize
);
439 setup_frame32(struct sigaction
*sa
, unsigned long pc
, unsigned long npc
,
440 struct pt_regs
*regs
, int signr
, sigset_t
*oldset
)
442 struct signal_sframe32
*sframep
;
443 struct sigcontext32
*sc
;
444 unsigned seta
[_NSIG_WORDS32
];
452 synchronize_user_stack();
453 save_and_clear_fpu();
455 sframep
= (struct signal_sframe32
*)get_sigframe(sa
, regs
, SF_ALIGNEDSZ
);
456 if (invalid_frame_pointer (sframep
, sizeof(*sframep
))){
457 #ifdef DEBUG_SIGNALS /* fills up the console logs during crashme runs, yuck... */
458 printk("%s [%d]: User has trashed signal stack\n",
459 current
->comm
, current
->pid
);
460 printk("Sigstack ptr %p handler at pc<%016lx> for sig<%d>\n",
463 /* Don't change signal code and address, so that
464 * post mortem debuggers can have a look.
469 sc
= &sframep
->sig_context
;
471 /* We've already made sure frame pointer isn't in kernel space... */
472 err
= __put_user((sas_ss_flags(regs
->u_regs
[UREG_FP
]) == SS_ONSTACK
),
475 switch (_NSIG_WORDS
) {
476 case 4: seta
[7] = (oldset
->sig
[3] >> 32);
477 seta
[6] = oldset
->sig
[3];
478 case 3: seta
[5] = (oldset
->sig
[2] >> 32);
479 seta
[4] = oldset
->sig
[2];
480 case 2: seta
[3] = (oldset
->sig
[1] >> 32);
481 seta
[2] = oldset
->sig
[1];
482 case 1: seta
[1] = (oldset
->sig
[0] >> 32);
483 seta
[0] = oldset
->sig
[0];
485 err
|= __put_user(seta
[0], &sc
->sigc_mask
);
486 err
|= __copy_to_user(sframep
->extramask
, seta
+ 1,
487 (_NSIG_WORDS32
- 1) * sizeof(unsigned));
488 err
|= __put_user(regs
->u_regs
[UREG_FP
], &sc
->sigc_sp
);
489 err
|= __put_user(pc
, &sc
->sigc_pc
);
490 err
|= __put_user(npc
, &sc
->sigc_npc
);
491 psr
= tstate_to_psr (regs
->tstate
);
492 if(current
->thread
.fpsaved
[0] & FPRS_FEF
)
494 err
|= __put_user(psr
, &sc
->sigc_psr
);
495 err
|= __put_user(regs
->u_regs
[UREG_G1
], &sc
->sigc_g1
);
496 err
|= __put_user(regs
->u_regs
[UREG_I0
], &sc
->sigc_o0
);
497 err
|= __put_user(current
->thread
.w_saved
, &sc
->sigc_oswins
);
499 /* w_saved is not currently used... */
500 if(current
->thread
.w_saved
)
501 for(window
= 0; window
< current
->thread
.w_saved
; window
++) {
502 sc
->sigc_spbuf
[window
] =
503 (char *)current
->thread
.rwbuf_stkptrs
[window
];
504 err
|= copy_to_user(&sc
->sigc_wbuf
[window
],
505 ¤t
->thread
.reg_window
[window
],
506 sizeof(struct reg_window
));
510 err
|= copy_in_user((u32
*)sframep
,
511 (u32
*)(regs
->u_regs
[UREG_FP
]),
512 sizeof(struct reg_window32
));
514 current
->thread
.w_saved
= 0; /* So process is allowed to execute. */
515 err
|= __put_user(signr
, &sframep
->sig_num
);
516 if(signr
== SIGSEGV
||
521 err
|= __put_user(current
->thread
.sig_desc
, &sframep
->sig_code
);
522 err
|= __put_user(current
->thread
.sig_address
, &sframep
->sig_address
);
524 err
|= __put_user(0, &sframep
->sig_code
);
525 err
|= __put_user(0, &sframep
->sig_address
);
527 err
|= __put_user((u64
)sc
, &sframep
->sig_scptr
);
531 regs
->u_regs
[UREG_FP
] = (unsigned long) sframep
;
532 regs
->tpc
= (unsigned long) sa
->sa_handler
;
533 regs
->tnpc
= (regs
->tpc
+ 4);
541 static inline int save_fpu_state32(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
543 unsigned long *fpregs
= (unsigned long *)(((char *)current
) + AOFF_task_fpregs
);
547 fprs
= current
->thread
.fpsaved
[0];
549 err
|= copy_to_user(&fpu
->si_float_regs
[0], fpregs
,
550 (sizeof(unsigned int) * 32));
552 err
|= copy_to_user(&fpu
->si_float_regs
[32], fpregs
+16,
553 (sizeof(unsigned int) * 32));
554 err
|= __put_user(current
->thread
.xfsr
[0], &fpu
->si_fsr
);
555 err
|= __put_user(current
->thread
.gsr
[0], &fpu
->si_gsr
);
556 err
|= __put_user(fprs
, &fpu
->si_fprs
);
561 static inline void new_setup_frame32(struct k_sigaction
*ka
, struct pt_regs
*regs
,
562 int signo
, sigset_t
*oldset
)
564 struct new_signal_frame32
*sf
;
568 unsigned seta
[_NSIG_WORDS32
];
570 /* 1. Make sure everything is clean */
571 synchronize_user_stack();
572 save_and_clear_fpu();
574 sigframe_size
= NF_ALIGNEDSZ
;
575 if (!(current
->thread
.fpsaved
[0] & FPRS_FEF
))
576 sigframe_size
-= sizeof(__siginfo_fpu_t
);
578 sf
= (struct new_signal_frame32
*)get_sigframe(&ka
->sa
, regs
, sigframe_size
);
580 if (invalid_frame_pointer (sf
, sigframe_size
)) {
582 printk("new_setup_frame32(%s:%d): invalid_frame_pointer(%p, %d)\n",
583 current
->comm
, current
->pid
, sf
, sigframe_size
);
588 if (current
->thread
.w_saved
!= 0) {
590 printk ("%s[%d]: Invalid user stack frame for "
591 "signal delivery.\n", current
->comm
, current
->pid
);
596 /* 2. Save the current process state */
597 err
= put_user(regs
->tpc
, &sf
->info
.si_regs
.pc
);
598 err
|= __put_user(regs
->tnpc
, &sf
->info
.si_regs
.npc
);
599 err
|= __put_user(regs
->y
, &sf
->info
.si_regs
.y
);
600 psr
= tstate_to_psr (regs
->tstate
);
601 if(current
->thread
.fpsaved
[0] & FPRS_FEF
)
603 err
|= __put_user(psr
, &sf
->info
.si_regs
.psr
);
604 for (i
= 0; i
< 16; i
++)
605 err
|= __put_user(regs
->u_regs
[i
], &sf
->info
.si_regs
.u_regs
[i
]);
606 err
|= __put_user(sizeof(siginfo_extra_v8plus_t
), &sf
->extra_size
);
607 err
|= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC
, &sf
->v8plus
.g_upper
[0]);
608 for (i
= 1; i
< 16; i
++)
609 err
|= __put_user(((u32
*)regs
->u_regs
)[2*i
], &sf
->v8plus
.g_upper
[i
]);
612 err
|= save_fpu_state32(regs
, &sf
->fpu_state
);
613 err
|= __put_user((u64
)&sf
->fpu_state
, &sf
->fpu_save
);
615 err
|= __put_user(0, &sf
->fpu_save
);
618 switch (_NSIG_WORDS
) {
619 case 4: seta
[7] = (oldset
->sig
[3] >> 32);
620 seta
[6] = oldset
->sig
[3];
621 case 3: seta
[5] = (oldset
->sig
[2] >> 32);
622 seta
[4] = oldset
->sig
[2];
623 case 2: seta
[3] = (oldset
->sig
[1] >> 32);
624 seta
[2] = oldset
->sig
[1];
625 case 1: seta
[1] = (oldset
->sig
[0] >> 32);
626 seta
[0] = oldset
->sig
[0];
628 err
|= __put_user(seta
[0], &sf
->info
.si_mask
);
629 err
|= __copy_to_user(sf
->extramask
, seta
+ 1,
630 (_NSIG_WORDS32
- 1) * sizeof(unsigned));
632 err
|= copy_in_user((u32
*)sf
,
633 (u32
*)(regs
->u_regs
[UREG_FP
]),
634 sizeof(struct reg_window32
));
639 /* 3. signal handler back-trampoline and parameters */
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
;
644 /* 4. signal handler */
645 regs
->tpc
= (unsigned long) ka
->sa
.sa_handler
;
646 regs
->tnpc
= (regs
->tpc
+ 4);
648 /* 5. return to kernel instructions */
650 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
652 /* Flush instruction space. */
653 unsigned long address
= ((unsigned long)&(sf
->insns
[0]));
654 pgd_t
*pgdp
= pgd_offset(current
->mm
, address
);
655 pmd_t
*pmdp
= pmd_offset(pgdp
, address
);
656 pte_t
*ptep
= pte_offset(pmdp
, address
);
658 regs
->u_regs
[UREG_I7
] = (unsigned long) (&(sf
->insns
[0]) - 2);
660 err
= __put_user(0x821020d8, &sf
->insns
[0]); /*mov __NR_sigreturn, %g1*/
661 err
|= __put_user(0x91d02010, &sf
->insns
[1]); /*t 0x10*/
665 if(pte_present(*ptep
)) {
666 unsigned long page
= (unsigned long)
667 __va(pte_pagenr(*ptep
) << PAGE_SHIFT
);
669 __asm__
__volatile__("
672 : : "r" (page
), "r" (address
& (PAGE_SIZE
- 1))
684 /* Setup a Solaris stack frame */
686 setup_svr4_frame32(struct sigaction
*sa
, unsigned long pc
, unsigned long npc
,
687 struct pt_regs
*regs
, int signr
, sigset_t
*oldset
)
689 svr4_signal_frame_t
*sfp
;
702 synchronize_user_stack();
703 save_and_clear_fpu();
705 regs
->u_regs
[UREG_FP
] &= 0x00000000ffffffffUL
;
706 sfp
= (svr4_signal_frame_t
*) get_sigframe(sa
, regs
, REGWIN_SZ
+ SVR4_SF_ALIGNED
);
708 if (invalid_frame_pointer (sfp
, sizeof (*sfp
))){
710 printk ("Invalid stack frame\n");
715 /* Start with a clean frame pointer and fill it */
716 err
= clear_user(sfp
, sizeof (*sfp
));
718 /* Setup convenience variables */
725 /* FIXME: where am I supposed to put this?
726 * sc->sigc_onstack = old_status;
727 * anyways, it does not look like it is used for anything at all.
729 setv
.sigbits
[0] = oldset
->sig
[0];
730 setv
.sigbits
[1] = (oldset
->sig
[0] >> 32);
731 if (_NSIG_WORDS
>= 2) {
732 setv
.sigbits
[2] = oldset
->sig
[1];
733 setv
.sigbits
[3] = (oldset
->sig
[1] >> 32);
734 err
|= __copy_to_user(&uc
->sigmask
, &setv
, sizeof(svr4_sigset_t
));
736 err
|= __copy_to_user(&uc
->sigmask
, &setv
, 2 * sizeof(unsigned));
738 /* Store registers */
739 err
|= __put_user(regs
->tpc
, &((*gr
) [SVR4_PC
]));
740 err
|= __put_user(regs
->tnpc
, &((*gr
) [SVR4_NPC
]));
741 psr
= tstate_to_psr (regs
->tstate
);
742 if(current
->thread
.fpsaved
[0] & FPRS_FEF
)
744 err
|= __put_user(psr
, &((*gr
) [SVR4_PSR
]));
745 err
|= __put_user(regs
->y
, &((*gr
) [SVR4_Y
]));
747 /* Copy g [1..7] and o [0..7] registers */
748 for (i
= 0; i
< 7; i
++)
749 err
|= __put_user(regs
->u_regs
[UREG_G1
+i
], (&(*gr
)[SVR4_G1
])+i
);
750 for (i
= 0; i
< 8; i
++)
751 err
|= __put_user(regs
->u_regs
[UREG_I0
+i
], (&(*gr
)[SVR4_O0
])+i
);
753 /* Setup sigaltstack */
754 err
|= __put_user(current
->sas_ss_sp
, &uc
->stack
.sp
);
755 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &uc
->stack
.flags
);
756 err
|= __put_user(current
->sas_ss_size
, &uc
->stack
.size
);
758 /* Save the currently window file: */
760 /* 1. Link sfp->uc->gwins to our windows */
761 err
|= __put_user((u32
)(long)gw
, &mc
->gwin
);
763 /* 2. Number of windows to restore at setcontext (): */
764 err
|= __put_user(current
->thread
.w_saved
, &gw
->count
);
766 /* 3. Save each valid window
767 * Currently, it makes a copy of the windows from the kernel copy.
768 * David's code for SunOS, makes the copy but keeps the pointer to
769 * the kernel. My version makes the pointer point to a userland
770 * copy of those. Mhm, I wonder if I shouldn't just ignore those
771 * on setcontext and use those that are on the kernel, the signal
772 * handler should not be modyfing those, mhm.
774 * These windows are just used in case synchronize_user_stack failed
775 * to flush the user windows.
778 for(window
= 0; window
< current
->thread
.w_saved
; window
++) {
779 err
|= __put_user((int *) &(gw
->win
[window
]),
780 (int **)gw
->winptr
+window
);
781 err
|= copy_to_user(&gw
->win
[window
],
782 ¤t
->thread
.reg_window
[window
],
783 sizeof (svr4_rwindow_t
));
784 err
|= __put_user(0, (int *)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
->tpc
= (unsigned long) sa
->sa_handler
;
803 regs
->tnpc
= (regs
->tpc
+ 4);
806 printk ("Solaris-frame: %x %x\n", (int) regs
->tpc
, (int) regs
->tnpc
);
808 /* Arguments passed to signal handler */
809 if (regs
->u_regs
[14]){
810 struct reg_window32
*rw
= (struct reg_window32
*)
811 (regs
->u_regs
[14] & 0x00000000ffffffffUL
);
813 err
|= __put_user(signr
, &rw
->ins
[0]);
814 err
|= __put_user((u64
)si
, &rw
->ins
[1]);
815 err
|= __put_user((u64
)uc
, &rw
->ins
[2]);
816 err
|= __put_user((u64
)sfp
, &rw
->ins
[6]); /* frame pointer */
820 regs
->u_regs
[UREG_I0
] = signr
;
821 regs
->u_regs
[UREG_I1
] = (u32
)(u64
) si
;
822 regs
->u_regs
[UREG_I2
] = (u32
)(u64
) uc
;
831 svr4_getcontext(svr4_ucontext_t
*uc
, struct pt_regs
*regs
)
838 synchronize_user_stack();
839 save_and_clear_fpu();
841 if (current
->thread
.w_saved
){
842 printk ("Uh oh, w_saved is not zero (%d)\n", (int) current
->thread
.w_saved
);
845 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
[0] >> 32);
853 if (_NSIG_WORDS
>= 2) {
854 setv
.sigbits
[2] = current
->blocked
.sig
[1];
855 setv
.sigbits
[3] = (current
->blocked
.sig
[1] >> 32);
856 err
|= __copy_to_user(&uc
->sigmask
, &setv
, sizeof(svr4_sigset_t
));
858 err
|= __copy_to_user(&uc
->sigmask
, &setv
, 2 * sizeof(unsigned));
860 /* Store registers */
861 err
|= __put_user(regs
->tpc
, &uc
->mcontext
.greg
[SVR4_PC
]);
862 err
|= __put_user(regs
->tnpc
, &uc
->mcontext
.greg
[SVR4_NPC
]);
864 err
|= __put_user(0, &uc
->mcontext
.greg
[SVR4_PSR
]);
866 i
= tstate_to_psr(regs
->tstate
) & ~PSR_EF
;
867 if (current
->thread
.fpsaved
[0] & FPRS_FEF
)
869 err
|= __put_user(i
, &uc
->mcontext
.greg
[SVR4_PSR
]);
871 err
|= __put_user(regs
->y
, &uc
->mcontext
.greg
[SVR4_Y
]);
873 /* Copy g [1..7] and o [0..7] registers */
874 for (i
= 0; i
< 7; i
++)
875 err
|= __put_user(regs
->u_regs
[UREG_G1
+i
], (&(*gr
)[SVR4_G1
])+i
);
876 for (i
= 0; i
< 8; i
++)
877 err
|= __put_user(regs
->u_regs
[UREG_I0
+i
], (&(*gr
)[SVR4_O0
])+i
);
879 /* Setup sigaltstack */
880 err
|= __put_user(current
->sas_ss_sp
, &uc
->stack
.sp
);
881 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &uc
->stack
.flags
);
882 err
|= __put_user(current
->sas_ss_size
, &uc
->stack
.size
);
884 /* The register file is not saved
885 * we have already stuffed all of it with sync_user_stack
887 return (err
? -EFAULT
: 0);
891 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
892 asmlinkage
int svr4_setcontext(svr4_ucontext_t
*c
, struct pt_regs
*regs
)
894 struct thread_struct
*tp
= ¤t
->thread
;
902 /* Fixme: restore windows, or is this already taken care of in
903 * svr4_setup_frame when sync_user_windows is done?
905 flush_user_windows();
908 printk ("Uh oh, w_saved is: 0x%x\n", tp
->w_saved
);
911 if (((unsigned long) c
) & 3){
912 printk ("Unaligned structure passed\n");
916 if(!__access_ok((unsigned long)c
, sizeof(*c
))) {
917 /* Miguel, add nice debugging msg _here_. ;-) */
921 /* Check for valid PC and nPC */
922 gr
= &c
->mcontext
.greg
;
923 err
= __get_user(pc
, &((*gr
)[SVR4_PC
]));
924 err
|= __get_user(npc
, &((*gr
)[SVR4_NPC
]));
927 printk ("setcontext, PC or nPC were bogus\n");
932 /* Retrieve information from passed ucontext */
933 /* note that nPC is ored a 1, this is used to inform entry.S */
934 /* that we don't want it to mess with our PC and nPC */
936 err
|= copy_from_user (&setv
, &c
->sigmask
, sizeof(svr4_sigset_t
));
937 set
.sig
[0] = setv
.sigbits
[0] | (((long)setv
.sigbits
[1]) << 32);
938 if (_NSIG_WORDS
>= 2)
939 set
.sig
[1] = setv
.sigbits
[2] | (((long)setv
.sigbits
[3]) << 32);
941 err
|= __get_user((long)st
.ss_sp
, &c
->stack
.sp
);
942 err
|= __get_user(st
.ss_flags
, &c
->stack
.flags
);
943 err
|= __get_user(st
.ss_size
, &c
->stack
.size
);
947 /* It is more difficult to avoid calling this function than to
948 call it and ignore errors. */
949 do_sigaltstack(&st
, NULL
, regs
->u_regs
[UREG_I6
]);
951 sigdelsetmask(&set
, ~_BLOCKABLE
);
952 spin_lock_irq(¤t
->sigmask_lock
);
953 current
->blocked
= set
;
954 recalc_sigpending(current
);
955 spin_unlock_irq(¤t
->sigmask_lock
);
957 regs
->tnpc
= npc
| 1;
958 err
|= __get_user(regs
->y
, &((*gr
) [SVR4_Y
]));
959 err
|= __get_user(psr
, &((*gr
) [SVR4_PSR
]));
960 regs
->tstate
&= ~(TSTATE_ICC
|TSTATE_XCC
);
961 regs
->tstate
|= psr_to_tstate_icc(psr
);
964 regs
->tstate
|= TSTATE_PEF
;
966 /* Restore g[1..7] and o[0..7] registers */
967 for (i
= 0; i
< 7; i
++)
968 err
|= __get_user(regs
->u_regs
[UREG_G1
+i
], (&(*gr
)[SVR4_G1
])+i
);
969 for (i
= 0; i
< 8; i
++)
970 err
|= __get_user(regs
->u_regs
[UREG_I0
+i
], (&(*gr
)[SVR4_O0
])+i
);
979 static inline void setup_rt_frame32(struct k_sigaction
*ka
, struct pt_regs
*regs
,
980 unsigned long signr
, sigset_t
*oldset
,
983 struct rt_signal_frame32
*sf
;
989 /* 1. Make sure everything is clean */
990 synchronize_user_stack();
991 save_and_clear_fpu();
993 sigframe_size
= RT_ALIGNEDSZ
;
994 if (!(current
->thread
.fpsaved
[0] & FPRS_FEF
))
995 sigframe_size
-= sizeof(__siginfo_fpu_t
);
997 sf
= (struct rt_signal_frame32
*)get_sigframe(&ka
->sa
, regs
, sigframe_size
);
999 if (invalid_frame_pointer (sf
, sigframe_size
)) {
1000 #ifdef DEBUG_SIGNALS
1001 printk("rt_setup_frame32(%s:%d): invalid_frame_pointer(%p, %d)\n",
1002 current
->comm
, current
->pid
, sf
, sigframe_size
);
1007 if (current
->thread
.w_saved
!= 0) {
1008 #ifdef DEBUG_SIGNALS
1009 printk ("%s[%d]: Invalid user stack frame for "
1010 "signal delivery.\n", current
->comm
, current
->pid
);
1015 /* 2. Save the current process state */
1016 err
= put_user(regs
->tpc
, &sf
->regs
.pc
);
1017 err
|= __put_user(regs
->tnpc
, &sf
->regs
.npc
);
1018 err
|= __put_user(regs
->y
, &sf
->regs
.y
);
1019 psr
= tstate_to_psr (regs
->tstate
);
1020 if(current
->thread
.fpsaved
[0] & FPRS_FEF
)
1022 err
|= __put_user(psr
, &sf
->regs
.psr
);
1023 for (i
= 0; i
< 16; i
++)
1024 err
|= __put_user(regs
->u_regs
[i
], &sf
->regs
.u_regs
[i
]);
1025 err
|= __put_user(sizeof(siginfo_extra_v8plus_t
), &sf
->extra_size
);
1026 err
|= __put_user(SIGINFO_EXTRA_V8PLUS_MAGIC
, &sf
->v8plus
.g_upper
[0]);
1027 for (i
= 1; i
< 16; i
++)
1028 err
|= __put_user(((u32
*)regs
->u_regs
)[2*i
], &sf
->v8plus
.g_upper
[i
]);
1031 err
|= save_fpu_state32(regs
, &sf
->fpu_state
);
1032 err
|= __put_user((u64
)&sf
->fpu_state
, &sf
->fpu_save
);
1034 err
|= __put_user(0, &sf
->fpu_save
);
1037 /* Update the siginfo structure. Is this good? */
1038 if (info
->si_code
== 0) {
1039 info
->si_signo
= signr
;
1048 info
->si_code
= current
->thread
.sig_desc
;
1049 info
->si_addr
= (void *)current
->thread
.sig_address
;
1050 info
->si_trapno
= 0;
1057 err
= __put_user (info
->si_signo
, &sf
->info
.si_signo
);
1058 err
|= __put_user (info
->si_errno
, &sf
->info
.si_errno
);
1059 err
|= __put_user (info
->si_code
, &sf
->info
.si_code
);
1060 if (info
->si_code
< 0)
1061 err
|= __copy_to_user (sf
->info
._sifields
._pad
, info
->_sifields
._pad
, SI_PAD_SIZE
);
1064 if (info
->si_code
== SI_USER
)
1068 err
|= __put_user (info
->si_band
, &sf
->info
.si_band
);
1069 err
|= __put_user (info
->si_fd
, &sf
->info
.si_fd
);
1072 err
|= __put_user (info
->si_pid
, &sf
->info
.si_pid
);
1073 err
|= __put_user (info
->si_uid
, &sf
->info
.si_uid
);
1074 err
|= __put_user (info
->si_status
, &sf
->info
.si_status
);
1075 err
|= __put_user (info
->si_utime
, &sf
->info
.si_utime
);
1076 err
|= __put_user (info
->si_stime
, &sf
->info
.si_stime
);
1083 err
|= __put_user ((long)info
->si_addr
, &sf
->info
.si_addr
);
1084 err
|= __put_user (info
->si_trapno
, &sf
->info
.si_trapno
);
1087 err
|= __put_user (info
->si_pid
, &sf
->info
.si_pid
);
1088 err
|= __put_user (info
->si_uid
, &sf
->info
.si_uid
);
1093 /* Setup sigaltstack */
1094 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
1095 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
1096 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
1098 switch (_NSIG_WORDS
) {
1099 case 4: seta
.sig
[7] = (oldset
->sig
[3] >> 32);
1100 seta
.sig
[6] = oldset
->sig
[3];
1101 case 3: seta
.sig
[5] = (oldset
->sig
[2] >> 32);
1102 seta
.sig
[4] = oldset
->sig
[2];
1103 case 2: seta
.sig
[3] = (oldset
->sig
[1] >> 32);
1104 seta
.sig
[2] = oldset
->sig
[1];
1105 case 1: seta
.sig
[1] = (oldset
->sig
[0] >> 32);
1106 seta
.sig
[0] = oldset
->sig
[0];
1108 err
|= __copy_to_user(&sf
->mask
, &seta
, sizeof(sigset_t32
));
1110 err
|= copy_in_user((u32
*)sf
,
1111 (u32
*)(regs
->u_regs
[UREG_FP
]),
1112 sizeof(struct reg_window32
));
1116 /* 3. signal handler back-trampoline and parameters */
1117 regs
->u_regs
[UREG_FP
] = (unsigned long) sf
;
1118 regs
->u_regs
[UREG_I0
] = signr
;
1119 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
1121 /* 4. signal handler */
1122 regs
->tpc
= (unsigned long) ka
->sa
.sa_handler
;
1123 regs
->tnpc
= (regs
->tpc
+ 4);
1125 /* 5. return to kernel instructions */
1126 if (ka
->ka_restorer
)
1127 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
1129 /* Flush instruction space. */
1130 unsigned long address
= ((unsigned long)&(sf
->insns
[0]));
1131 pgd_t
*pgdp
= pgd_offset(current
->mm
, address
);
1132 pmd_t
*pmdp
= pmd_offset(pgdp
, address
);
1133 pte_t
*ptep
= pte_offset(pmdp
, address
);
1135 regs
->u_regs
[UREG_I7
] = (unsigned long) (&(sf
->insns
[0]) - 2);
1137 /* mov __NR_rt_sigreturn, %g1 */
1138 err
|= __put_user(0x82102065, &sf
->insns
[0]);
1141 err
|= __put_user(0x91d02010, &sf
->insns
[1]);
1145 if(pte_present(*ptep
)) {
1146 unsigned long page
= (unsigned long)
1147 __va(pte_pagenr(*ptep
) << PAGE_SHIFT
);
1149 __asm__
__volatile__("
1152 : : "r" (page
), "r" (address
& (PAGE_SIZE
- 1))
1164 static inline void handle_signal32(unsigned long signr
, struct k_sigaction
*ka
,
1166 sigset_t
*oldset
, struct pt_regs
*regs
,
1170 setup_svr4_frame32(&ka
->sa
, regs
->tpc
, regs
->tnpc
, regs
, signr
, oldset
);
1172 if (ka
->sa
.sa_flags
& SA_SIGINFO
)
1173 setup_rt_frame32(ka
, regs
, signr
, oldset
, info
);
1174 else if (current
->thread
.flags
& SPARC_FLAG_NEWSIGNALS
)
1175 new_setup_frame32(ka
, regs
, signr
, oldset
);
1177 setup_frame32(&ka
->sa
, regs
->tpc
, regs
->tnpc
, regs
, signr
, oldset
);
1179 if(ka
->sa
.sa_flags
& SA_ONESHOT
)
1180 ka
->sa
.sa_handler
= SIG_DFL
;
1181 if(!(ka
->sa
.sa_flags
& SA_NOMASK
)) {
1182 spin_lock_irq(¤t
->sigmask_lock
);
1183 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
1184 sigaddset(¤t
->blocked
,signr
);
1185 recalc_sigpending(current
);
1186 spin_unlock_irq(¤t
->sigmask_lock
);
1190 static inline void syscall_restart32(unsigned long orig_i0
, struct pt_regs
*regs
,
1191 struct sigaction
*sa
)
1193 switch(regs
->u_regs
[UREG_I0
]) {
1194 case ERESTARTNOHAND
:
1195 no_system_call_restart
:
1196 regs
->u_regs
[UREG_I0
] = EINTR
;
1197 regs
->tstate
|= TSTATE_ICARRY
;
1200 if(!(sa
->sa_flags
& SA_RESTART
))
1201 goto no_system_call_restart
;
1203 case ERESTARTNOINTR
:
1204 regs
->u_regs
[UREG_I0
] = orig_i0
;
1210 #ifdef DEBUG_SIGNALS_MAPS
1212 #define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %s %lu "
1214 static inline void read_maps (void)
1216 struct vm_area_struct
* map
, * next
;
1220 buffer
= (char*)__get_free_page(GFP_KERNEL
);
1224 for (map
= current
->mm
->mmap
; map
; map
= next
) {
1225 /* produce the next line */
1227 char str
[5], *cp
= str
;
1233 * Get the next vma now (but it won't be used if we sleep).
1235 next
= map
->vm_next
;
1236 flags
= map
->vm_flags
;
1238 *cp
++ = flags
& VM_READ
? 'r' : '-';
1239 *cp
++ = flags
& VM_WRITE
? 'w' : '-';
1240 *cp
++ = flags
& VM_EXEC
? 'x' : '-';
1241 *cp
++ = flags
& VM_MAYSHARE
? 's' : 'p';
1246 if (map
->vm_file
!= NULL
) {
1247 dev
= map
->vm_file
->f_dentry
->d_inode
->i_dev
;
1248 ino
= map
->vm_file
->f_dentry
->d_inode
->i_ino
;
1249 line
= d_path(map
->vm_file
->f_dentry
, buffer
, PAGE_SIZE
);
1251 printk(MAPS_LINE_FORMAT
, map
->vm_start
, map
->vm_end
, str
, map
->vm_pgoff
<< PAGE_SHIFT
,
1252 kdevname(dev
), ino
);
1253 if (map
->vm_file
!= NULL
)
1254 printk("%s\n", line
);
1258 free_page((unsigned long)buffer
);
1264 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1265 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1268 asmlinkage
int do_signal32(sigset_t
*oldset
, struct pt_regs
* regs
,
1269 unsigned long orig_i0
, int restart_syscall
)
1271 unsigned long signr
;
1272 struct k_sigaction
*ka
;
1275 int svr4_signal
= current
->personality
== PER_SVR4
;
1278 spin_lock_irq(¤t
->sigmask_lock
);
1279 signr
= dequeue_signal(¤t
->blocked
, &info
);
1280 spin_unlock_irq(¤t
->sigmask_lock
);
1284 if ((current
->flags
& PF_PTRACED
) && signr
!= SIGKILL
) {
1285 current
->exit_code
= signr
;
1286 current
->state
= TASK_STOPPED
;
1287 notify_parent(current
, SIGCHLD
);
1289 if (!(signr
= current
->exit_code
))
1291 current
->exit_code
= 0;
1292 if (signr
== SIGSTOP
)
1295 /* Update the siginfo structure. Is this good? */
1296 if (signr
!= info
.si_signo
) {
1297 info
.si_signo
= signr
;
1299 info
.si_code
= SI_USER
;
1300 info
.si_pid
= current
->p_pptr
->pid
;
1301 info
.si_uid
= current
->p_pptr
->uid
;
1304 /* If the (new) signal is now blocked, requeue it. */
1305 if (sigismember(¤t
->blocked
, signr
)) {
1306 send_sig_info(signr
, &info
, current
);
1311 ka
= ¤t
->sig
->action
[signr
-1];
1313 if(ka
->sa
.sa_handler
== SIG_IGN
) {
1314 if(signr
!= SIGCHLD
)
1317 /* sys_wait4() grabs the master kernel lock, so
1318 * we need not do so, that sucker should be
1319 * threaded and would not be that difficult to
1322 while(sys_wait4(-1, NULL
, WNOHANG
, NULL
) > 0)
1326 if(ka
->sa
.sa_handler
== SIG_DFL
) {
1327 unsigned long exit_code
= signr
;
1329 if(current
->pid
== 1)
1332 case SIGCONT
: case SIGCHLD
: case SIGWINCH
:
1335 case SIGTSTP
: case SIGTTIN
: case SIGTTOU
:
1336 if (is_orphaned_pgrp(current
->pgrp
))
1340 if (current
->flags
& PF_PTRACED
)
1342 current
->state
= TASK_STOPPED
;
1343 current
->exit_code
= signr
;
1344 if(!(current
->p_pptr
->sig
->action
[SIGCHLD
-1].sa
.sa_flags
&
1346 notify_parent(current
, SIGCHLD
);
1350 case SIGQUIT
: case SIGILL
: case SIGTRAP
:
1351 case SIGABRT
: case SIGFPE
: case SIGSEGV
:
1352 case SIGBUS
: case SIGSYS
: case SIGXCPU
: case SIGXFSZ
:
1353 if (do_coredump(signr
, regs
))
1355 #ifdef DEBUG_SIGNALS
1356 /* Very useful to debug dynamic linker problems */
1357 printk ("Sig %ld going for %s[%d]...\n", signr
, current
->comm
, current
->pid
);
1358 /* On SMP we are only interested in the current
1362 #ifdef DEBUG_SIGNALS_TLB
1364 extern void sparc_ultra_dump_itlb(void);
1365 extern void sparc_ultra_dump_dtlb(void);
1366 sparc_ultra_dump_dtlb();
1367 sparc_ultra_dump_itlb();
1370 #ifdef DEBUG_SIGNALS_TRACE
1372 struct reg_window32
*rw
= (struct reg_window32
*)(regs
->u_regs
[UREG_FP
] & 0xffffffff);
1373 unsigned int ins
[8];
1376 !(((unsigned long) rw
) & 0x3)) {
1377 copy_from_user(ins
, &rw
->ins
[0], sizeof(ins
));
1378 printk("Caller[%08x](%08x,%08x,%08x,%08x,%08x,%08x)\n", ins
[7], ins
[0], ins
[1], ins
[2], ins
[3], ins
[4], ins
[5]);
1379 rw
= (struct reg_window32
*)(unsigned long)ins
[6];
1383 #ifdef DEBUG_SIGNALS_MAPS
1391 sigaddset(¤t
->signal
, signr
);
1392 recalc_sigpending(current
);
1393 current
->flags
|= PF_SIGNALED
;
1399 syscall_restart32(orig_i0
, regs
, &ka
->sa
);
1400 handle_signal32(signr
, ka
, &info
, oldset
, regs
, svr4_signal
);
1403 if(restart_syscall
&&
1404 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
1405 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
1406 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
1407 /* replay the system call when we are done */
1408 regs
->u_regs
[UREG_I0
] = orig_i0
;
1420 asmlinkage
int do_sys32_sigstack(u32 u_ssptr
, u32 u_ossptr
, unsigned long sp
)
1422 struct sigstack32
*ssptr
= (struct sigstack32
*)((unsigned long)(u_ssptr
));
1423 struct sigstack32
*ossptr
= (struct sigstack32
*)((unsigned long)(u_ossptr
));
1426 /* First see if old state is wanted. */
1428 if (put_user(current
->sas_ss_sp
+ current
->sas_ss_size
, &ossptr
->the_stack
) ||
1429 __put_user(on_sig_stack(sp
), &ossptr
->cur_status
))
1433 /* Now see if we want to update the new state. */
1437 if (get_user((long)ss_sp
, &ssptr
->the_stack
))
1439 /* If the current stack was set with sigaltstack, don't
1440 swap stacks while we are on it. */
1442 if (current
->sas_ss_sp
&& on_sig_stack(sp
))
1445 /* Since we don't know the extent of the stack, and we don't
1446 track onstack-ness, but rather calculate it, we must
1447 presume a size. Ho hum this interface is lossy. */
1448 current
->sas_ss_sp
= (unsigned long)ss_sp
- SIGSTKSZ
;
1449 current
->sas_ss_size
= SIGSTKSZ
;
1457 asmlinkage
int do_sys32_sigaltstack(u32 ussa
, u32 uossa
, unsigned long sp
)
1461 mm_segment_t old_fs
;
1463 if (ussa
&& (get_user((long)uss
.ss_sp
, &((stack_t32
*)(long)ussa
)->ss_sp
) ||
1464 __get_user(uss
.ss_flags
, &((stack_t32
*)(long)ussa
)->ss_flags
) ||
1465 __get_user(uss
.ss_size
, &((stack_t32
*)(long)ussa
)->ss_size
)))
1469 ret
= do_sigaltstack(ussa
? &uss
: NULL
, uossa
? &uoss
: NULL
, sp
);
1471 if (!ret
&& uossa
&& (put_user((long)uoss
.ss_sp
, &((stack_t32
*)(long)uossa
)->ss_sp
) ||
1472 __put_user(uoss
.ss_flags
, &((stack_t32
*)(long)uossa
)->ss_flags
) ||
1473 __put_user(uoss
.ss_size
, &((stack_t32
*)(long)uossa
)->ss_size
)))