?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.18pre1
[davej-history.git] / arch / sparc64 / kernel / signal.c
blob672e834930194314caf53478864d4786fbff288c
1 /* $Id: signal.c,v 1.45 1999/09/06 08:21:59 jj Exp $
2 * arch/sparc64/kernel/signal.c
3 *
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)
9 */
10
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>
19 #include <linux/mm.h>
20 #include <linux/smp_lock.h>
21
22 #include <asm/uaccess.h>
23 #include <asm/bitops.h>
24 #include <asm/ptrace.h>
25 #include <asm/svr4.h>
26 #include <asm/pgtable.h>
27 #include <asm/fpumacro.h>
28 #include <asm/uctx.h>
29 #include <asm/siginfo.h>
30 #include <asm/visasm.h>
31
32 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
33
34 asmlinkage int sys_wait4(pid_t pid, unsigned long *stat_addr,
35 int options, unsigned long *ru);
36
37 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
38 unsigned long orig_o0, int ret_from_syscall);
39
40 /* This turned off for production... */
41 /* #define DEBUG_SIGNALS 1 */
42 /* #define DEBUG_SIGNALS_TRACE 1 */
43 /* #define DEBUG_SIGNALS_MAPS 1 */
44
45 /* {set, get}context() needed for 64-bit SparcLinux userland. */
46 asmlinkage void sparc64_set_context(struct pt_regs *regs)
47 {
48 struct ucontext *ucp = (struct ucontext *) regs->u_regs[UREG_I0];
49 struct thread_struct *tp = &current->thread;
50 mc_gregset_t *grp;
51 unsigned long pc, npc, tstate;
52 unsigned long fp, i7;
53 unsigned char fenab;
54 int err;
55
56 flush_user_windows();
57 if(tp->w_saved ||
58 (((unsigned long)ucp) & (sizeof(unsigned long)-1)) ||
59 (!__access_ok((unsigned long)ucp, sizeof(*ucp))))
60 goto do_sigsegv;
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))
65 goto do_sigsegv;
66 if(regs->u_regs[UREG_I1]) {
67 sigset_t set;
68
69 if (_NSIG_WORDS == 1) {
70 if (__get_user(set.sig[0], &ucp->uc_sigmask.sig[0]))
71 goto do_sigsegv;
72 } else {
73 if (__copy_from_user(&set, &ucp->uc_sigmask, sizeof(sigset_t)))
74 goto do_sigsegv;
75 }
76 sigdelsetmask(&set, ~_BLOCKABLE);
77 spin_lock_irq(&current->sigmask_lock);
78 current->blocked = set;
79 recalc_sigpending(current);
80 spin_unlock_irq(&current->sigmask_lock);
81 }
82 regs->tpc = pc;
83 regs->tnpc = npc;
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]));
103
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])));
110
111 err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
112 if(fenab) {
113 unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
114 unsigned long fprs;
115
116 fprs_write(0);
117 err |= __get_user(fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
118 if (fprs & FPRS_DL)
119 err |= copy_from_user(fpregs,
120 &(ucp->uc_mcontext.mc_fpregs.mcfpu_fregs),
121 (sizeof(unsigned int) * 32));
122 if (fprs & FPRS_DU)
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;
131 }
132 if (err)
133 goto do_sigsegv;
134
135 return;
136 do_sigsegv:
137 lock_kernel();
138 do_exit(SIGSEGV);
139 }
140
141 asmlinkage void sparc64_get_context(struct pt_regs *regs)
142 {
143 struct ucontext *ucp = (struct ucontext *) regs->u_regs[UREG_I0];
144 struct thread_struct *tp = &current->thread;
145 mc_gregset_t *grp;
146 mcontext_t *mcp;
147 unsigned long fp, i7;
148 unsigned char fenab;
149 int err;
150
151 synchronize_user_stack();
152 if(tp->w_saved || clear_user(ucp, sizeof(*ucp)))
153 goto do_sigsegv;
154
155 #if 1
156 fenab = 0; /* IMO get_context is like any other system call, thus modifies FPU state -jj */
157 #else
158 fenab = (current->thread.fpsaved[0] & FPRS_FEF);
159 #endif
160
161 mcp = &ucp->uc_mcontext;
162 grp = &mcp->mc_gregs;
163
164 /* Skip over the trap instruction, first. */
165 regs->tpc = regs->tnpc;
166 regs->tnpc += 4;
167
168 err = 0;
169 if (_NSIG_WORDS == 1)
170 err |= __put_user(current->blocked.sig[0],
171 (unsigned long *)&ucp->uc_sigmask);
172 else
173 err |= __copy_to_user(&ucp->uc_sigmask, &current->blocked,
174 sizeof(sigset_t));
175
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]));
195
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));
202
203 err |= __put_user(fenab, &(mcp->mc_fpregs.mcfpu_enab));
204 if(fenab) {
205 unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
206 unsigned long fprs;
207
208 fprs = current->thread.fpsaved[0];
209 if (fprs & FPRS_DL)
210 err |= copy_to_user(&(mcp->mc_fpregs.mcfpu_fregs), fpregs,
211 (sizeof(unsigned int) * 32));
212 if (fprs & FPRS_DU)
213 err |= copy_to_user(
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));
219 }
220 if (err)
221 goto do_sigsegv;
222
223 return;
224 do_sigsegv:
225 lock_kernel();
226 do_exit(SIGSEGV);
227 }
228
229 struct rt_signal_frame {
230 struct sparc_stackf ss;
231 siginfo_t info;
232 struct pt_regs regs;
233 __siginfo_fpu_t * fpu_save;
234 stack_t stack;
235 sigset_t mask;
236 __siginfo_fpu_t fpu_state;
237 };
238
239 /* Align macros */
240 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
241
242 /*
243 * atomically swap in the new signal mask, and wait for a signal.
244 * This is really tricky on the Sparc, watch out...
245 */
246 asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
247 {
248 sigset_t saveset;
249
250 #ifdef CONFIG_SPARC32_COMPAT
251 if (current->thread.flags & SPARC_FLAG_32BIT) {
252 extern asmlinkage void _sigpause32_common(old_sigset_t32,
253 struct pt_regs *);
254 _sigpause32_common(set, regs);
255 return;
256 }
257 #endif
258 set &= _BLOCKABLE;
259 spin_lock_irq(&current->sigmask_lock);
260 saveset = current->blocked;
261 siginitset(&current->blocked, set);
262 recalc_sigpending(current);
263 spin_unlock_irq(&current->sigmask_lock);
264
265 regs->tpc = regs->tnpc;
266 regs->tnpc += 4;
267
268 /* Condition codes and return value where set here for sigpause,
269 * and so got used by setup_frame, which again causes sigreturn()
270 * to return -EINTR.
271 */
272 while (1) {
273 current->state = TASK_INTERRUPTIBLE;
274 schedule();
275 /*
276 * Return -EINTR and set condition code here,
277 * so the interrupted system call actually returns
278 * these.
279 */
280 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
281 regs->u_regs[UREG_I0] = EINTR;
282 if (do_signal(&saveset, regs, 0, 0))
283 return;
284 }
285 }
286
287 asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
288 {
289 _sigpause_common(set, regs);
290 }
291
292 asmlinkage void do_sigsuspend(struct pt_regs *regs)
293 {
294 _sigpause_common(regs->u_regs[UREG_I0], regs);
295 }
296
297 asmlinkage void do_rt_sigsuspend(sigset_t *uset, size_t sigsetsize, struct pt_regs *regs)
298 {
299 sigset_t oldset, set;
300
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;
305 return;
306 }
307 if (copy_from_user(&set, uset, sizeof(set))) {
308 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
309 regs->u_regs[UREG_I0] = EFAULT;
310 return;
311 }
312
313 sigdelsetmask(&set, ~_BLOCKABLE);
314 spin_lock_irq(&current->sigmask_lock);
315 oldset = current->blocked;
316 current->blocked = set;
317 recalc_sigpending(current);
318 spin_unlock_irq(&current->sigmask_lock);
319
320 regs->tpc = regs->tnpc;
321 regs->tnpc += 4;
322
323 /* Condition codes and return value where set here for sigpause,
324 * and so got used by setup_frame, which again causes sigreturn()
325 * to return -EINTR.
326 */
327 while (1) {
328 current->state = TASK_INTERRUPTIBLE;
329 schedule();
330 /*
331 * Return -EINTR and set condition code here,
332 * so the interrupted system call actually returns
333 * these.
334 */
335 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
336 regs->u_regs[UREG_I0] = EINTR;
337 if (do_signal(&oldset, regs, 0, 0))
338 return;
339 }
340 }
341
342 static inline int
343 restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t *fpu)
344 {
345 unsigned long *fpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
346 unsigned long fprs;
347 int err;
348
349 err = __get_user(fprs, &fpu->si_fprs);
350 fprs_write(0);
351 regs->tstate &= ~TSTATE_PEF;
352 if (fprs & FPRS_DL)
353 err |= copy_from_user(fpregs, &fpu->si_float_regs[0],
354 (sizeof(unsigned int) * 32));
355 if (fprs & FPRS_DU)
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;
361 return err;
362 }
363
364 void do_rt_sigreturn(struct pt_regs *regs)
365 {
366 struct rt_signal_frame *sf;
367 unsigned long tpc, tnpc, tstate;
368 __siginfo_fpu_t *fpu_save;
369 sigset_t set;
370 stack_t st;
371 int err;
372
373 synchronize_user_stack ();
374 sf = (struct rt_signal_frame *)
375 (regs->u_regs [UREG_FP] + STACK_BIAS);
376
377 /* 1. Make sure we are not getting garbage from the user */
378 if (((unsigned long) sf) & 3)
379 goto segv;
380
381 err = get_user(tpc, &sf->regs.tpc);
382 err |= __get_user(tnpc, &sf->regs.tnpc);
383 err |= ((tpc | tnpc) & 3);
384
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));
389
390 /* User can only change condition codes in %tstate. */
391 regs->tstate &= ~(TSTATE_ICC);
392 regs->tstate |= (tstate & TSTATE_ICC);
393
394 err |= __get_user(fpu_save, &sf->fpu_save);
395 if (fpu_save)
396 err |= restore_fpu_state(regs, &sf->fpu_state);
397
398 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
399 err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
400
401 if (err)
402 goto segv;
403
404 regs->tpc = tpc;
405 regs->tnpc = tnpc;
406
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);
410
411 sigdelsetmask(&set, ~_BLOCKABLE);
412 spin_lock_irq(&current->sigmask_lock);
413 current->blocked = set;
414 recalc_sigpending(current);
415 spin_unlock_irq(&current->sigmask_lock);
416 return;
417 segv:
418 send_sig(SIGSEGV, current, 1);
419 }
420
421 /* Checks if the fp is valid */
422 static int invalid_frame_pointer(void *fp, int fplen)
423 {
424 if (((unsigned long) fp) & 7)
425 return 1;
426 return 0;
427 }
428
429 static inline int
430 save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t *fpu)
431 {
432 unsigned long *fpregs = (unsigned long *)(regs+1);
433 unsigned long fprs;
434 int err = 0;
435
436 fprs = current->thread.fpsaved[0];
437 if (fprs & FPRS_DL)
438 err |= copy_to_user(&fpu->si_float_regs[0], fpregs,
439 (sizeof(unsigned int) * 32));
440 if (fprs & FPRS_DU)
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);
446
447 return err;
448 }
449
450 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, unsigned long framesize)
451 {
452 unsigned long sp;
453
454 sp = regs->u_regs[UREG_FP] + STACK_BIAS;
455
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;
461 }
462 return (void *)(sp - framesize);
463 }
464
465 static inline void
466 setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
467 int signo, sigset_t *oldset, siginfo_t *info)
468 {
469 struct rt_signal_frame *sf;
470 int sigframe_size, err;
471
472 /* 1. Make sure everything is clean */
473 synchronize_user_stack();
474 save_and_clear_fpu();
475
476 sigframe_size = RT_ALIGNEDSZ;
477 if (!(current->thread.fpsaved[0] & FPRS_FEF))
478 sigframe_size -= sizeof(__siginfo_fpu_t);
479
480 sf = (struct rt_signal_frame *)get_sigframe(ka, regs, sigframe_size);
481
482 if (invalid_frame_pointer (sf, sigframe_size))
483 goto sigill;
484
485 if (current->thread.w_saved != 0) {
486 #ifdef DEBUG_SIGNALS
487 printk ("%s[%d]: Invalid user stack frame for "
488 "signal delivery.\n", current->comm, current->pid);
489 #endif
490 goto sigill;
491 }
492
493 /* 2. Save the current process state */
494 err = copy_to_user(&sf->regs, regs, sizeof (*regs));
495
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);
499 } else {
500 err |= __put_user(0, &sf->fpu_save);
501 }
502
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);
507
508 err |= copy_to_user(&sf->mask, oldset, sizeof(sigset_t));
509
510 err |= copy_in_user((u64 *)sf,
511 (u64 *)(regs->u_regs[UREG_FP]+STACK_BIAS),
512 sizeof(struct reg_window));
513
514 if (info)
515 err |= copy_to_user(&sf->info, info, sizeof(siginfo_t));
516 else {
517 err |= __put_user(signo, &sf->info.si_signo);
518 err |= __put_user(SI_NOINFO, &sf->info.si_code);
519 }
520 if (err)
521 goto sigsegv;
522
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;
527
528 /* 5. signal handler */
529 regs->tpc = (unsigned long) ka->sa.sa_handler;
530 regs->tnpc = (regs->tpc + 4);
531
532 /* 4. return to kernel instructions */
533 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
534 return;
535
536 sigill:
537 lock_kernel();
538 do_exit(SIGILL);
539 sigsegv:
540 lock_kernel();
541 do_exit(SIGSEGV);
542 }
543
544 static inline void handle_signal(unsigned long signr, struct k_sigaction *ka,
545 siginfo_t *info,
546 sigset_t *oldset, struct pt_regs *regs)
547 {
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(&current->sigmask_lock);
553 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
554 sigaddset(&current->blocked,signr);
555 recalc_sigpending(current);
556 spin_unlock_irq(&current->sigmask_lock);
557 }
558 }
559
560 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
561 struct sigaction *sa)
562 {
563 switch(regs->u_regs[UREG_I0]) {
564 case ERESTARTNOHAND:
565 no_system_call_restart:
566 regs->u_regs[UREG_I0] = EINTR;
567 regs->tstate |= (TSTATE_ICARRY|TSTATE_XCARRY);
568 break;
569 case ERESTARTSYS:
570 if(!(sa->sa_flags & SA_RESTART))
571 goto no_system_call_restart;
572 /* fallthrough */
573 case ERESTARTNOINTR:
574 regs->u_regs[UREG_I0] = orig_i0;
575 regs->tpc -= 4;
576 regs->tnpc -= 4;
577 }
578 }
579
580 #ifdef DEBUG_SIGNALS_MAPS
581
582 #define MAPS_LINE_FORMAT "%016lx-%016lx %s %016lx %s %lu "
583
584 static inline void read_maps (void)
585 {
586 struct vm_area_struct * map, * next;
587 char * buffer;
588 ssize_t i;
589
590 buffer = (char*)__get_free_page(GFP_KERNEL);
591 if (!buffer)
592 return;
593
594 for (map = current->mm->mmap ; map ; map = next ) {
595 /* produce the next line */
596 char *line;
597 char str[5], *cp = str;
598 int flags;
599 kdev_t dev;
600 unsigned long ino;
601
602 /*
603 * Get the next vma now (but it won't be used if we sleep).
604 */
605 next = map->vm_next;
606 flags = map->vm_flags;
607
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';
612 *cp++ = 0;
613
614 dev = 0;
615 ino = 0;
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);
620 }
621 printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_offset,
622 kdevname(dev), ino);
623 if (map->vm_file != NULL)
624 printk("%s\n", line);
625 else
626 printk("\n");
627 }
628 free_page((unsigned long)buffer);
629 return;
630 }
631
632 #endif
633
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
636 * mistake.
637 */
638 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
639 unsigned long orig_i0, int restart_syscall)
640 {
641 unsigned long signr;
642 siginfo_t info;
643 struct k_sigaction *ka;
644
645 if (!oldset)
646 oldset = &current->blocked;
647
648 #ifdef CONFIG_SPARC32_COMPAT
649 if (current->thread.flags & SPARC_FLAG_32BIT) {
650 extern asmlinkage int do_signal32(sigset_t *, struct pt_regs *,
651 unsigned long, int);
652 return do_signal32(oldset, regs, orig_i0, restart_syscall);
653 }
654 #endif
655 for (;;) {
656 spin_lock_irq(&current->sigmask_lock);
657 signr = dequeue_signal(&current->blocked, &info);
658 spin_unlock_irq(&current->sigmask_lock);
659
660 if (!signr) break;
661
662 if ((current->flags & PF_PTRACED) && signr != SIGKILL) {
663 current->exit_code = signr;
664 current->state = TASK_STOPPED;
665 notify_parent(current, SIGCHLD);
666 schedule();
667 if (!(signr = current->exit_code))
668 continue;
669 current->exit_code = 0;
670 if (signr == SIGSTOP)
671 continue;
672
673 /* Update the siginfo structure. Is this good? */
674 if (signr != info.si_signo) {
675 info.si_signo = signr;
676 info.si_errno = 0;
677 info.si_code = SI_USER;
678 info.si_pid = current->p_pptr->pid;
679 info.si_uid = current->p_pptr->uid;
680 }
681
682 /* If the (new) signal is now blocked, requeue it. */
683 if (sigismember(&current->blocked, signr)) {
684 send_sig_info(signr, &info, current);
685 continue;
686 }
687 }
688
689 ka = &current->sig->action[signr-1];
690
691 if(ka->sa.sa_handler == SIG_IGN) {
692 if(signr != SIGCHLD)
693 continue;
694
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
698 * do anyways.
699 */
700 while(sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
701 ;
702 continue;
703 }
704 if(ka->sa.sa_handler == SIG_DFL) {
705 unsigned long exit_code = signr;
706
707 if(current->pid == 1)
708 continue;
709 switch(signr) {
710 case SIGCONT: case SIGCHLD: case SIGWINCH:
711 continue;
712
713 case SIGTSTP: case SIGTTIN: case SIGTTOU:
714 if (is_orphaned_pgrp(current->pgrp))
715 continue;
716
717 case SIGSTOP:
718 if (current->flags & PF_PTRACED)
719 continue;
720 current->state = TASK_STOPPED;
721 current->exit_code = signr;
722 if(!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &
723 SA_NOCLDSTOP))
724 notify_parent(current, SIGCHLD);
725 schedule();
726 continue;
727
728 case SIGQUIT: case SIGILL: case SIGTRAP:
729 case SIGABRT: case SIGFPE: case SIGSEGV: case SIGBUS:
730 if (do_coredump(signr, regs))
731 exit_code |= 0x80;
732 #ifdef DEBUG_SIGNALS
733 /* Very useful to debug the dynamic linker */
734 printk ("Sig %d going...\n", (int)signr);
735 show_regs (regs);
736 #ifdef DEBUG_SIGNALS_TRACE
737 {
738 struct reg_window *rw = (struct reg_window *)(regs->u_regs[UREG_FP] + STACK_BIAS);
739 unsigned long ins[8];
740
741 while(rw &&
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);
746 }
747 }
748 #endif
749 #ifdef DEBUG_SIGNALS_MAPS
750 printk("Maps:\n");
751 read_maps();
752 #endif
753 #endif
754 /* fall through */
755 default:
756 lock_kernel();
757 sigaddset(&current->signal, signr);
758 recalc_sigpending(current);
759 current->flags |= PF_SIGNALED;
760 do_exit(exit_code);
761 /* NOT REACHED */
762 }
763 }
764 if(restart_syscall)
765 syscall_restart(orig_i0, regs, &ka->sa);
766 handle_signal(signr, ka, &info, oldset, regs);
767 return 1;
768 }
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;
775 regs->tpc -= 4;
776 regs->tnpc -= 4;
777 }
778 return 0;
779 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux