1 /* $Id: signal.c,v 1.45 1999/09/06 08:21:59 jj Exp $
2 * arch/sparc64/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)
8 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
11 #include <linux/config.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
14 #include <linux/signal.h>
15 #include <linux/errno.h>
16 #include <linux/wait.h>
17 #include <linux/ptrace.h>
18 #include <linux/unistd.h>
20 #include <linux/smp_lock.h>
22 #include <asm/uaccess.h>
23 #include <asm/bitops.h>
24 #include <asm/ptrace.h>
26 #include <asm/pgtable.h>
27 #include <asm/fpumacro.h>
29 #include <asm/siginfo.h>
30 #include <asm/visasm.h>
32 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
34 asmlinkage
int sys_wait4(pid_t pid
, unsigned long *stat_addr
,
35 int options
, unsigned long *ru
);
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 /* {set, get}context() needed for 64-bit SparcLinux userland. */
46 asmlinkage
void sparc64_set_context(struct pt_regs
*regs
)
48 struct ucontext
*ucp
= (struct ucontext
*) regs
->u_regs
[UREG_I0
];
49 struct thread_struct
*tp
= ¤t
->thread
;
51 unsigned long pc
, npc
, tstate
;
58 (((unsigned long)ucp
) & (sizeof(unsigned long)-1)) ||
59 (!__access_ok((unsigned long)ucp
, sizeof(*ucp
))))
61 grp
= &ucp
->uc_mcontext
.mc_gregs
;
62 err
= __get_user(pc
, &((*grp
)[MC_PC
]));
63 err
|= __get_user(npc
, &((*grp
)[MC_NPC
]));
64 if(err
|| ((pc
| npc
) & 3))
66 if(regs
->u_regs
[UREG_I1
]) {
69 if (_NSIG_WORDS
== 1) {
70 if (__get_user(set
.sig
[0], &ucp
->uc_sigmask
.sig
[0]))
73 if (__copy_from_user(&set
, &ucp
->uc_sigmask
, sizeof(sigset_t
)))
76 sigdelsetmask(&set
, ~_BLOCKABLE
);
77 spin_lock_irq(¤t
->sigmask_lock
);
78 current
->blocked
= set
;
79 recalc_sigpending(current
);
80 spin_unlock_irq(¤t
->sigmask_lock
);
84 err
|= __get_user(regs
->y
, &((*grp
)[MC_Y
]));
85 err
|= __get_user(tstate
, &((*grp
)[MC_TSTATE
]));
86 regs
->tstate
&= ~(TSTATE_ICC
| TSTATE_XCC
);
87 regs
->tstate
|= (tstate
& (TSTATE_ICC
| TSTATE_XCC
));
88 err
|= __get_user(regs
->u_regs
[UREG_G1
], (&(*grp
)[MC_G1
]));
89 err
|= __get_user(regs
->u_regs
[UREG_G2
], (&(*grp
)[MC_G2
]));
90 err
|= __get_user(regs
->u_regs
[UREG_G3
], (&(*grp
)[MC_G3
]));
91 err
|= __get_user(regs
->u_regs
[UREG_G4
], (&(*grp
)[MC_G4
]));
92 err
|= __get_user(regs
->u_regs
[UREG_G5
], (&(*grp
)[MC_G5
]));
93 err
|= __get_user(regs
->u_regs
[UREG_G6
], (&(*grp
)[MC_G6
]));
94 err
|= __get_user(regs
->u_regs
[UREG_G7
], (&(*grp
)[MC_G7
]));
95 err
|= __get_user(regs
->u_regs
[UREG_I0
], (&(*grp
)[MC_O0
]));
96 err
|= __get_user(regs
->u_regs
[UREG_I1
], (&(*grp
)[MC_O1
]));
97 err
|= __get_user(regs
->u_regs
[UREG_I2
], (&(*grp
)[MC_O2
]));
98 err
|= __get_user(regs
->u_regs
[UREG_I3
], (&(*grp
)[MC_O3
]));
99 err
|= __get_user(regs
->u_regs
[UREG_I4
], (&(*grp
)[MC_O4
]));
100 err
|= __get_user(regs
->u_regs
[UREG_I5
], (&(*grp
)[MC_O5
]));
101 err
|= __get_user(regs
->u_regs
[UREG_I6
], (&(*grp
)[MC_O6
]));
102 err
|= __get_user(regs
->u_regs
[UREG_I7
], (&(*grp
)[MC_O7
]));
104 err
|= __get_user(fp
, &(ucp
->uc_mcontext
.mc_fp
));
105 err
|= __get_user(i7
, &(ucp
->uc_mcontext
.mc_i7
));
106 err
|= __put_user(fp
,
107 (&(((struct reg_window
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[6])));
108 err
|= __put_user(i7
,
109 (&(((struct reg_window
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[7])));
111 err
|= __get_user(fenab
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_enab
));
113 unsigned long *fpregs
= (unsigned long *)(((char *)current
) + AOFF_task_fpregs
);
117 err
|= __get_user(fprs
, &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fprs
));
119 err
|= copy_from_user(fpregs
,
120 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
),
121 (sizeof(unsigned int) * 32));
123 err
|= copy_from_user(fpregs
+16,
124 ((unsigned long *)&(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fregs
))+16,
125 (sizeof(unsigned int) * 32));
126 err
|= __get_user(current
->thread
.xfsr
[0],
127 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_fsr
));
128 err
|= __get_user(current
->thread
.gsr
[0],
129 &(ucp
->uc_mcontext
.mc_fpregs
.mcfpu_gsr
));
130 regs
->tstate
&= ~TSTATE_PEF
;
141 asmlinkage
void sparc64_get_context(struct pt_regs
*regs
)
143 struct ucontext
*ucp
= (struct ucontext
*) regs
->u_regs
[UREG_I0
];
144 struct thread_struct
*tp
= ¤t
->thread
;
147 unsigned long fp
, i7
;
151 synchronize_user_stack();
152 if(tp
->w_saved
|| clear_user(ucp
, sizeof(*ucp
)))
156 fenab
= 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
158 fenab
= (current
->thread
.fpsaved
[0] & FPRS_FEF
);
161 mcp
= &ucp
->uc_mcontext
;
162 grp
= &mcp
->mc_gregs
;
164 /* Skip over the trap instruction, first. */
165 regs
->tpc
= regs
->tnpc
;
169 if (_NSIG_WORDS
== 1)
170 err
|= __put_user(current
->blocked
.sig
[0],
171 (unsigned long *)&ucp
->uc_sigmask
);
173 err
|= __copy_to_user(&ucp
->uc_sigmask
, ¤t
->blocked
,
176 err
|= __put_user(regs
->tstate
, &((*grp
)[MC_TSTATE
]));
177 err
|= __put_user(regs
->tpc
, &((*grp
)[MC_PC
]));
178 err
|= __put_user(regs
->tnpc
, &((*grp
)[MC_NPC
]));
179 err
|= __put_user(regs
->y
, &((*grp
)[MC_Y
]));
180 err
|= __put_user(regs
->u_regs
[UREG_G1
], &((*grp
)[MC_G1
]));
181 err
|= __put_user(regs
->u_regs
[UREG_G2
], &((*grp
)[MC_G2
]));
182 err
|= __put_user(regs
->u_regs
[UREG_G3
], &((*grp
)[MC_G3
]));
183 err
|= __put_user(regs
->u_regs
[UREG_G4
], &((*grp
)[MC_G4
]));
184 err
|= __put_user(regs
->u_regs
[UREG_G5
], &((*grp
)[MC_G5
]));
185 err
|= __put_user(regs
->u_regs
[UREG_G6
], &((*grp
)[MC_G6
]));
186 err
|= __put_user(regs
->u_regs
[UREG_G6
], &((*grp
)[MC_G7
]));
187 err
|= __put_user(regs
->u_regs
[UREG_I0
], &((*grp
)[MC_O0
]));
188 err
|= __put_user(regs
->u_regs
[UREG_I1
], &((*grp
)[MC_O1
]));
189 err
|= __put_user(regs
->u_regs
[UREG_I2
], &((*grp
)[MC_O2
]));
190 err
|= __put_user(regs
->u_regs
[UREG_I3
], &((*grp
)[MC_O3
]));
191 err
|= __put_user(regs
->u_regs
[UREG_I4
], &((*grp
)[MC_O4
]));
192 err
|= __put_user(regs
->u_regs
[UREG_I5
], &((*grp
)[MC_O5
]));
193 err
|= __put_user(regs
->u_regs
[UREG_I6
], &((*grp
)[MC_O6
]));
194 err
|= __put_user(regs
->u_regs
[UREG_I7
], &((*grp
)[MC_O7
]));
196 err
|= __get_user(fp
,
197 (&(((struct reg_window
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[6])));
198 err
|= __get_user(i7
,
199 (&(((struct reg_window
*)(STACK_BIAS
+regs
->u_regs
[UREG_I6
]))->ins
[7])));
200 err
|= __put_user(fp
, &(mcp
->mc_fp
));
201 err
|= __put_user(i7
, &(mcp
->mc_i7
));
203 err
|= __put_user(fenab
, &(mcp
->mc_fpregs
.mcfpu_enab
));
205 unsigned long *fpregs
= (unsigned long *)(((char *)current
) + AOFF_task_fpregs
);
208 fprs
= current
->thread
.fpsaved
[0];
210 err
|= copy_to_user(&(mcp
->mc_fpregs
.mcfpu_fregs
), fpregs
,
211 (sizeof(unsigned int) * 32));
214 ((unsigned long *)&(mcp
->mc_fpregs
.mcfpu_fregs
))+16, fpregs
+16,
215 (sizeof(unsigned int) * 32));
216 err
|= __put_user(current
->thread
.xfsr
[0], &(mcp
->mc_fpregs
.mcfpu_fsr
));
217 err
|= __put_user(current
->thread
.gsr
[0], &(mcp
->mc_fpregs
.mcfpu_gsr
));
218 err
|= __put_user(fprs
, &(mcp
->mc_fpregs
.mcfpu_fprs
));
229 struct rt_signal_frame
{
230 struct sparc_stackf ss
;
233 __siginfo_fpu_t
* fpu_save
;
236 __siginfo_fpu_t fpu_state
;
240 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
243 * atomically swap in the new signal mask, and wait for a signal.
244 * This is really tricky on the Sparc, watch out...
246 asmlinkage
void _sigpause_common(old_sigset_t set
, struct pt_regs
*regs
)
250 #ifdef CONFIG_SPARC32_COMPAT
251 if (current
->thread
.flags
& SPARC_FLAG_32BIT
) {
252 extern asmlinkage
void _sigpause32_common(old_sigset_t32
,
254 _sigpause32_common(set
, regs
);
259 spin_lock_irq(¤t
->sigmask_lock
);
260 saveset
= current
->blocked
;
261 siginitset(¤t
->blocked
, set
);
262 recalc_sigpending(current
);
263 spin_unlock_irq(¤t
->sigmask_lock
);
265 regs
->tpc
= regs
->tnpc
;
268 /* Condition codes and return value where set here for sigpause,
269 * and so got used by setup_frame, which again causes sigreturn()
273 current
->state
= TASK_INTERRUPTIBLE
;
276 * Return -EINTR and set condition code here,
277 * so the interrupted system call actually returns
280 regs
->tstate
|= (TSTATE_ICARRY
|TSTATE_XCARRY
);
281 regs
->u_regs
[UREG_I0
] = EINTR
;
282 if (do_signal(&saveset
, regs
, 0, 0))
287 asmlinkage
void do_sigpause(unsigned int set
, struct pt_regs
*regs
)
289 _sigpause_common(set
, regs
);
292 asmlinkage
void do_sigsuspend(struct pt_regs
*regs
)
294 _sigpause_common(regs
->u_regs
[UREG_I0
], regs
);
297 asmlinkage
void do_rt_sigsuspend(sigset_t
*uset
, size_t sigsetsize
, struct pt_regs
*regs
)
299 sigset_t oldset
, set
;
301 /* XXX: Don't preclude handling different sized sigset_t's. */
302 if (sigsetsize
!= sizeof(sigset_t
)) {
303 regs
->tstate
|= (TSTATE_ICARRY
|TSTATE_XCARRY
);
304 regs
->u_regs
[UREG_I0
] = EINVAL
;
307 if (copy_from_user(&set
, uset
, sizeof(set
))) {
308 regs
->tstate
|= (TSTATE_ICARRY
|TSTATE_XCARRY
);
309 regs
->u_regs
[UREG_I0
] = EFAULT
;
313 sigdelsetmask(&set
, ~_BLOCKABLE
);
314 spin_lock_irq(¤t
->sigmask_lock
);
315 oldset
= current
->blocked
;
316 current
->blocked
= set
;
317 recalc_sigpending(current
);
318 spin_unlock_irq(¤t
->sigmask_lock
);
320 regs
->tpc
= regs
->tnpc
;
323 /* Condition codes and return value where set here for sigpause,
324 * and so got used by setup_frame, which again causes sigreturn()
328 current
->state
= TASK_INTERRUPTIBLE
;
331 * Return -EINTR and set condition code here,
332 * so the interrupted system call actually returns
335 regs
->tstate
|= (TSTATE_ICARRY
|TSTATE_XCARRY
);
336 regs
->u_regs
[UREG_I0
] = EINTR
;
337 if (do_signal(&oldset
, regs
, 0, 0))
343 restore_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
345 unsigned long *fpregs
= (unsigned long *)(((char *)current
) + AOFF_task_fpregs
);
349 err
= __get_user(fprs
, &fpu
->si_fprs
);
351 regs
->tstate
&= ~TSTATE_PEF
;
353 err
|= copy_from_user(fpregs
, &fpu
->si_float_regs
[0],
354 (sizeof(unsigned int) * 32));
356 err
|= copy_from_user(fpregs
+16, &fpu
->si_float_regs
[32],
357 (sizeof(unsigned int) * 32));
358 err
|= __get_user(current
->thread
.xfsr
[0], &fpu
->si_fsr
);
359 err
|= __get_user(current
->thread
.gsr
[0], &fpu
->si_gsr
);
360 current
->thread
.fpsaved
[0] |= fprs
;
364 void do_rt_sigreturn(struct pt_regs
*regs
)
366 struct rt_signal_frame
*sf
;
367 unsigned long tpc
, tnpc
, tstate
;
368 __siginfo_fpu_t
*fpu_save
;
373 synchronize_user_stack ();
374 sf
= (struct rt_signal_frame
*)
375 (regs
->u_regs
[UREG_FP
] + STACK_BIAS
);
377 /* 1. Make sure we are not getting garbage from the user */
378 if (((unsigned long) sf
) & 3)
381 err
= get_user(tpc
, &sf
->regs
.tpc
);
382 err
|= __get_user(tnpc
, &sf
->regs
.tnpc
);
383 err
|= ((tpc
| tnpc
) & 3);
385 /* 2. Restore the state */
386 err
|= __get_user(regs
->y
, &sf
->regs
.y
);
387 err
|= __get_user(tstate
, &sf
->regs
.tstate
);
388 err
|= copy_from_user(regs
->u_regs
, sf
->regs
.u_regs
, sizeof(regs
->u_regs
));
390 /* User can only change condition codes in %tstate. */
391 regs
->tstate
&= ~(TSTATE_ICC
);
392 regs
->tstate
|= (tstate
& TSTATE_ICC
);
394 err
|= __get_user(fpu_save
, &sf
->fpu_save
);
396 err
|= restore_fpu_state(regs
, &sf
->fpu_state
);
398 err
|= __copy_from_user(&set
, &sf
->mask
, sizeof(sigset_t
));
399 err
|= __copy_from_user(&st
, &sf
->stack
, sizeof(stack_t
));
407 /* It is more difficult to avoid calling this function than to
408 call it and ignore errors. */
409 do_sigaltstack(&st
, NULL
, (unsigned long)sf
);
411 sigdelsetmask(&set
, ~_BLOCKABLE
);
412 spin_lock_irq(¤t
->sigmask_lock
);
413 current
->blocked
= set
;
414 recalc_sigpending(current
);
415 spin_unlock_irq(¤t
->sigmask_lock
);
418 send_sig(SIGSEGV
, current
, 1);
421 /* Checks if the fp is valid */
422 static int invalid_frame_pointer(void *fp
, int fplen
)
424 if (((unsigned long) fp
) & 7)
430 save_fpu_state(struct pt_regs
*regs
, __siginfo_fpu_t
*fpu
)
432 unsigned long *fpregs
= (unsigned long *)(regs
+1);
436 fprs
= current
->thread
.fpsaved
[0];
438 err
|= copy_to_user(&fpu
->si_float_regs
[0], fpregs
,
439 (sizeof(unsigned int) * 32));
441 err
|= copy_to_user(&fpu
->si_float_regs
[32], fpregs
+16,
442 (sizeof(unsigned int) * 32));
443 err
|= __put_user(current
->thread
.xfsr
[0], &fpu
->si_fsr
);
444 err
|= __put_user(current
->thread
.gsr
[0], &fpu
->si_gsr
);
445 err
|= __put_user(fprs
, &fpu
->si_fprs
);
450 static inline void *get_sigframe(struct k_sigaction
*ka
, struct pt_regs
*regs
, unsigned long framesize
)
454 sp
= regs
->u_regs
[UREG_FP
] + STACK_BIAS
;
456 /* This is the X/Open sanctioned signal stack switching. */
457 if (ka
->sa
.sa_flags
& SA_ONSTACK
) {
458 if (!on_sig_stack(sp
) &&
459 !((current
->sas_ss_sp
+ current
->sas_ss_size
) & 7))
460 sp
= current
->sas_ss_sp
+ current
->sas_ss_size
;
462 return (void *)(sp
- framesize
);
466 setup_rt_frame(struct k_sigaction
*ka
, struct pt_regs
*regs
,
467 int signo
, sigset_t
*oldset
, siginfo_t
*info
)
469 struct rt_signal_frame
*sf
;
470 int sigframe_size
, err
;
472 /* 1. Make sure everything is clean */
473 synchronize_user_stack();
474 save_and_clear_fpu();
476 sigframe_size
= RT_ALIGNEDSZ
;
477 if (!(current
->thread
.fpsaved
[0] & FPRS_FEF
))
478 sigframe_size
-= sizeof(__siginfo_fpu_t
);
480 sf
= (struct rt_signal_frame
*)get_sigframe(ka
, regs
, sigframe_size
);
482 if (invalid_frame_pointer (sf
, sigframe_size
))
485 if (current
->thread
.w_saved
!= 0) {
487 printk ("%s[%d]: Invalid user stack frame for "
488 "signal delivery.\n", current
->comm
, current
->pid
);
493 /* 2. Save the current process state */
494 err
= copy_to_user(&sf
->regs
, regs
, sizeof (*regs
));
496 if (current
->thread
.fpsaved
[0] & FPRS_FEF
) {
497 err
|= save_fpu_state(regs
, &sf
->fpu_state
);
498 err
|= __put_user((u64
)&sf
->fpu_state
, &sf
->fpu_save
);
500 err
|= __put_user(0, &sf
->fpu_save
);
503 /* Setup sigaltstack */
504 err
|= __put_user(current
->sas_ss_sp
, &sf
->stack
.ss_sp
);
505 err
|= __put_user(sas_ss_flags(regs
->u_regs
[UREG_FP
]), &sf
->stack
.ss_flags
);
506 err
|= __put_user(current
->sas_ss_size
, &sf
->stack
.ss_size
);
508 err
|= copy_to_user(&sf
->mask
, oldset
, sizeof(sigset_t
));
510 err
|= copy_in_user((u64
*)sf
,
511 (u64
*)(regs
->u_regs
[UREG_FP
]+STACK_BIAS
),
512 sizeof(struct reg_window
));
515 err
|= copy_to_user(&sf
->info
, info
, sizeof(siginfo_t
));
517 err
|= __put_user(signo
, &sf
->info
.si_signo
);
518 err
|= __put_user(SI_NOINFO
, &sf
->info
.si_code
);
523 /* 3. signal handler back-trampoline and parameters */
524 regs
->u_regs
[UREG_FP
] = ((unsigned long) sf
) - STACK_BIAS
;
525 regs
->u_regs
[UREG_I0
] = signo
;
526 regs
->u_regs
[UREG_I1
] = (unsigned long) &sf
->info
;
528 /* 5. signal handler */
529 regs
->tpc
= (unsigned long) ka
->sa
.sa_handler
;
530 regs
->tnpc
= (regs
->tpc
+ 4);
532 /* 4. return to kernel instructions */
533 regs
->u_regs
[UREG_I7
] = (unsigned long)ka
->ka_restorer
;
544 static inline void handle_signal(unsigned long signr
, struct k_sigaction
*ka
,
546 sigset_t
*oldset
, struct pt_regs
*regs
)
548 setup_rt_frame(ka
, regs
, signr
, oldset
, (ka
->sa
.sa_flags
& SA_SIGINFO
) ? info
: NULL
);
549 if(ka
->sa
.sa_flags
& SA_ONESHOT
)
550 ka
->sa
.sa_handler
= SIG_DFL
;
551 if(!(ka
->sa
.sa_flags
& SA_NOMASK
)) {
552 spin_lock_irq(¤t
->sigmask_lock
);
553 sigorsets(¤t
->blocked
,¤t
->blocked
,&ka
->sa
.sa_mask
);
554 sigaddset(¤t
->blocked
,signr
);
555 recalc_sigpending(current
);
556 spin_unlock_irq(¤t
->sigmask_lock
);
560 static inline void syscall_restart(unsigned long orig_i0
, struct pt_regs
*regs
,
561 struct sigaction
*sa
)
563 switch(regs
->u_regs
[UREG_I0
]) {
565 no_system_call_restart
:
566 regs
->u_regs
[UREG_I0
] = EINTR
;
567 regs
->tstate
|= (TSTATE_ICARRY
|TSTATE_XCARRY
);
570 if(!(sa
->sa_flags
& SA_RESTART
))
571 goto no_system_call_restart
;
574 regs
->u_regs
[UREG_I0
] = orig_i0
;
580 #ifdef DEBUG_SIGNALS_MAPS
582 #define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %s %lu "
584 static inline void read_maps (void)
586 struct vm_area_struct
* map
, * next
;
590 buffer
= (char*)__get_free_page(GFP_KERNEL
);
594 for (map
= current
->mm
->mmap
; map
; map
= next
) {
595 /* produce the next line */
597 char str
[5], *cp
= str
;
603 * Get the next vma now (but it won't be used if we sleep).
606 flags
= map
->vm_flags
;
608 *cp
++ = flags
& VM_READ
? 'r' : '-';
609 *cp
++ = flags
& VM_WRITE
? 'w' : '-';
610 *cp
++ = flags
& VM_EXEC
? 'x' : '-';
611 *cp
++ = flags
& VM_MAYSHARE
? 's' : 'p';
616 if (map
->vm_file
!= NULL
) {
617 dev
= map
->vm_file
->f_dentry
->d_inode
->i_dev
;
618 ino
= map
->vm_file
->f_dentry
->d_inode
->i_ino
;
619 line
= d_path(map
->vm_file
->f_dentry
, buffer
, PAGE_SIZE
);
621 printk(MAPS_LINE_FORMAT
, map
->vm_start
, map
->vm_end
, str
, map
->vm_offset
,
623 if (map
->vm_file
!= NULL
)
624 printk("%s\n", line
);
628 free_page((unsigned long)buffer
);
634 /* Note that 'init' is a special process: it doesn't get signals it doesn't
635 * want to handle. Thus you cannot kill init even with a SIGKILL even by
638 asmlinkage
int do_signal(sigset_t
*oldset
, struct pt_regs
* regs
,
639 unsigned long orig_i0
, int restart_syscall
)
643 struct k_sigaction
*ka
;
646 oldset
= ¤t
->blocked
;
648 #ifdef CONFIG_SPARC32_COMPAT
649 if (current
->thread
.flags
& SPARC_FLAG_32BIT
) {
650 extern asmlinkage
int do_signal32(sigset_t
*, struct pt_regs
*,
652 return do_signal32(oldset
, regs
, orig_i0
, restart_syscall
);
656 spin_lock_irq(¤t
->sigmask_lock
);
657 signr
= dequeue_signal(¤t
->blocked
, &info
);
658 spin_unlock_irq(¤t
->sigmask_lock
);
662 if ((current
->flags
& PF_PTRACED
) && signr
!= SIGKILL
) {
663 current
->exit_code
= signr
;
664 current
->state
= TASK_STOPPED
;
665 notify_parent(current
, SIGCHLD
);
667 if (!(signr
= current
->exit_code
))
669 current
->exit_code
= 0;
670 if (signr
== SIGSTOP
)
673 /* Update the siginfo structure. Is this good? */
674 if (signr
!= info
.si_signo
) {
675 info
.si_signo
= signr
;
677 info
.si_code
= SI_USER
;
678 info
.si_pid
= current
->p_pptr
->pid
;
679 info
.si_uid
= current
->p_pptr
->uid
;
682 /* If the (new) signal is now blocked, requeue it. */
683 if (sigismember(¤t
->blocked
, signr
)) {
684 send_sig_info(signr
, &info
, current
);
689 ka
= ¤t
->sig
->action
[signr
-1];
691 if(ka
->sa
.sa_handler
== SIG_IGN
) {
695 /* sys_wait4() grabs the master kernel lock, so
696 * we need not do so, that sucker should be
697 * threaded and would not be that difficult to
700 while(sys_wait4(-1, NULL
, WNOHANG
, NULL
) > 0)
704 if(ka
->sa
.sa_handler
== SIG_DFL
) {
705 unsigned long exit_code
= signr
;
707 if(current
->pid
== 1)
710 case SIGCONT
: case SIGCHLD
: case SIGWINCH
:
713 case SIGTSTP
: case SIGTTIN
: case SIGTTOU
:
714 if (is_orphaned_pgrp(current
->pgrp
))
718 if (current
->flags
& PF_PTRACED
)
720 current
->state
= TASK_STOPPED
;
721 current
->exit_code
= signr
;
722 if(!(current
->p_pptr
->sig
->action
[SIGCHLD
-1].sa
.sa_flags
&
724 notify_parent(current
, SIGCHLD
);
728 case SIGQUIT
: case SIGILL
: case SIGTRAP
:
729 case SIGABRT
: case SIGFPE
: case SIGSEGV
: case SIGBUS
:
730 if (do_coredump(signr
, regs
))
733 /* Very useful to debug the dynamic linker */
734 printk ("Sig %d going...\n", (int)signr
);
736 #ifdef DEBUG_SIGNALS_TRACE
738 struct reg_window
*rw
= (struct reg_window
*)(regs
->u_regs
[UREG_FP
] + STACK_BIAS
);
739 unsigned long ins
[8];
742 !(((unsigned long) rw
) & 0x3)) {
743 copy_from_user(ins
, &rw
->ins
[0], sizeof(ins
));
744 printk("Caller[%016lx](%016lx,%016lx,%016lx,%016lx,%016lx,%016lx)\n", ins
[7], ins
[0], ins
[1], ins
[2], ins
[3], ins
[4], ins
[5]);
745 rw
= (struct reg_window
*)(unsigned long)(ins
[6] + STACK_BIAS
);
749 #ifdef DEBUG_SIGNALS_MAPS
757 sigaddset(¤t
->signal
, signr
);
758 recalc_sigpending(current
);
759 current
->flags
|= PF_SIGNALED
;
765 syscall_restart(orig_i0
, regs
, &ka
->sa
);
766 handle_signal(signr
, ka
, &info
, oldset
, regs
);
769 if(restart_syscall
&&
770 (regs
->u_regs
[UREG_I0
] == ERESTARTNOHAND
||
771 regs
->u_regs
[UREG_I0
] == ERESTARTSYS
||
772 regs
->u_regs
[UREG_I0
] == ERESTARTNOINTR
)) {
773 /* replay the system call when we are done */
774 regs
->u_regs
[UREG_I0
] = orig_i0
;