File: /usr/src/linux/arch/sparc/kernel/signal.c
1 /* $Id: signal.c,v 1.108 2001/01/24 21:05:12 davem Exp $
2 * linux/arch/sparc/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 */
9
10 #include <linux/config.h>
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>
18 #include <linux/mm.h>
19 #include <linux/smp.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/pgalloc.h>
27 #include <asm/pgtable.h>
28
29 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
30
31 extern void fpsave(unsigned long *fpregs, unsigned long *fsr,
32 void *fpqueue, unsigned long *fpqdepth);
33 extern void fpload(unsigned long *fpregs, unsigned long *fsr);
34
35 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
36 unsigned long orig_o0, int ret_from_syscall);
37
38 /* This turned off for production... */
39 /* #define DEBUG_SIGNALS 1 */
40 /* #define DEBUG_SIGNALS_TRACE 1 */
41 /* #define DEBUG_SIGNALS_MAPS 1 */
42
43 /* Signal frames: the original one (compatible with SunOS):
44 *
45 * Set up a signal frame... Make the stack look the way SunOS
46 * expects it to look which is basically:
47 *
48 * ---------------------------------- <-- %sp at signal time
49 * Struct sigcontext
50 * Signal address
51 * Ptr to sigcontext area above
52 * Signal code
53 * The signal number itself
54 * One register window
55 * ---------------------------------- <-- New %sp
56 */
57 struct signal_sframe {
58 struct reg_window sig_window;
59 int sig_num;
60 int sig_code;
61 struct sigcontext *sig_scptr;
62 int sig_address;
63 struct sigcontext sig_context;
64 unsigned int extramask[_NSIG_WORDS - 1];
65 };
66
67 /*
68 * And the new one, intended to be used for Linux applications only
69 * (we have enough in there to work with clone).
70 * All the interesting bits are in the info field.
71 */
72
73 struct new_signal_frame {
74 struct sparc_stackf ss;
75 __siginfo_t info;
76 __siginfo_fpu_t *fpu_save;
77 unsigned long insns [2] __attribute__ ((aligned (8)));
78 unsigned int extramask[_NSIG_WORDS - 1];
79 unsigned int extra_size; /* Should be 0 */
80 __siginfo_fpu_t fpu_state;
81 };
82
83 struct rt_signal_frame {
84 struct sparc_stackf ss;
85 siginfo_t info;
86 struct pt_regs regs;
87 sigset_t mask;
88 __siginfo_fpu_t *fpu_save;
89 unsigned int insns [2];
90 stack_t stack;
91 unsigned int extra_size; /* Should be 0 */
92 __siginfo_fpu_t fpu_state;
93 };
94
95 int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
96 {
97 if (!access_ok(VERIFY_WRITE, to, sizeof(siginfo_t)))
98 return -EFAULT;
99 if (from->si_code < 0)
100 return __copy_to_user(to, from, sizeof(siginfo_t));
101 else {
102 int err;
103
104 /* If you change siginfo_t structure, please be sure
105 this code is fixed accordingly.
106 It should never copy any pad contained in the structure
107 to avoid security leaks, but must copy the generic
108 3 ints plus the relevant union member. */
109 err = __put_user(from->si_signo, &to->si_signo);
110 err |= __put_user(from->si_errno, &to->si_errno);
111 err |= __put_user((short)from->si_code, &to->si_code);
112 switch (from->si_code >> 16) {
113 case __SI_CHLD >> 16:
114 err |= __put_user(from->si_utime, &to->si_utime);
115 err |= __put_user(from->si_stime, &to->si_stime);
116 /* case __SI_RT: This is not generated by the kernel as of now. */
117 err |= __put_user(from->si_status, &to->si_status);
118 default:
119 err |= __put_user(from->si_uid, &to->si_uid);
120 err |= __put_user(from->si_pid, &to->si_pid);
121 break;
122 }
123 return err;
124 }
125 }
126
127 /* Align macros */
128 #define SF_ALIGNEDSZ (((sizeof(struct signal_sframe) + 7) & (~7)))
129 #define NF_ALIGNEDSZ (((sizeof(struct new_signal_frame) + 7) & (~7)))
130 #define RT_ALIGNEDSZ (((sizeof(struct rt_signal_frame) + 7) & (~7)))
131
132 /*
133 * atomically swap in the new signal mask, and wait for a signal.
134 * This is really tricky on the Sparc, watch out...
135 */
136 asmlinkage void _sigpause_common(old_sigset_t set, struct pt_regs *regs)
137 {
138 sigset_t saveset;
139
140 set &= _BLOCKABLE;
141 spin_lock_irq(¤t->sigmask_lock);
142 saveset = current->blocked;
143 siginitset(¤t->blocked, set);
144 recalc_sigpending(current);
145 spin_unlock_irq(¤t->sigmask_lock);
146
147 regs->pc = regs->npc;
148 regs->npc += 4;
149
150 /* Condition codes and return value where set here for sigpause,
151 * and so got used by setup_frame, which again causes sigreturn()
152 * to return -EINTR.
153 */
154 while (1) {
155 current->state = TASK_INTERRUPTIBLE;
156 schedule();
157 /*
158 * Return -EINTR and set condition code here,
159 * so the interrupted system call actually returns
160 * these.
161 */
162 regs->psr |= PSR_C;
163 regs->u_regs[UREG_I0] = EINTR;
164 if (do_signal(&saveset, regs, 0, 0))
165 return;
166 }
167 }
168
169 asmlinkage void do_sigpause(unsigned int set, struct pt_regs *regs)
170 {
171 _sigpause_common(set, regs);
172 }
173
174 asmlinkage void do_sigsuspend (struct pt_regs *regs)
175 {
176 _sigpause_common(regs->u_regs[UREG_I0], regs);
177 }
178
179 asmlinkage void do_rt_sigsuspend(sigset_t *uset, size_t sigsetsize,
180 struct pt_regs *regs)
181 {
182 sigset_t oldset, set;
183
184 /* XXX: Don't preclude handling different sized sigset_t's. */
185 if (sigsetsize != sizeof(sigset_t)) {
186 regs->psr |= PSR_C;
187 regs->u_regs[UREG_I0] = EINVAL;
188 return;
189 }
190
191 if (copy_from_user(&set, uset, sizeof(set))) {
192 regs->psr |= PSR_C;
193 regs->u_regs[UREG_I0] = EFAULT;
194 return;
195 }
196
197 sigdelsetmask(&set, ~_BLOCKABLE);
198 spin_lock_irq(¤t->sigmask_lock);
199 oldset = current->blocked;
200 current->blocked = set;
201 recalc_sigpending(current);
202 spin_unlock_irq(¤t->sigmask_lock);
203
204 regs->pc = regs->npc;
205 regs->npc += 4;
206
207 /* Condition codes and return value where set here for sigpause,
208 * and so got used by setup_frame, which again causes sigreturn()
209 * to return -EINTR.
210 */
211 while (1) {
212 current->state = TASK_INTERRUPTIBLE;
213 schedule();
214 /*
215 * Return -EINTR and set condition code here,
216 * so the interrupted system call actually returns
217 * these.
218 */
219 regs->psr |= PSR_C;
220 regs->u_regs[UREG_I0] = EINTR;
221 if (do_signal(&oldset, regs, 0, 0))
222 return;
223 }
224 }
225
226 static inline int
227 restore_fpu_state(struct pt_regs *regs, __siginfo_fpu_t *fpu)
228 {
229 int err;
230 #ifdef CONFIG_SMP
231 if (current->flags & PF_USEDFPU)
232 regs->psr &= ~PSR_EF;
233 #else
234 if (current == last_task_used_math) {
235 last_task_used_math = 0;
236 regs->psr &= ~PSR_EF;
237 }
238 #endif
239 current->used_math = 1;
240 current->flags &= ~PF_USEDFPU;
241
242 if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
243 return -EFAULT;
244
245 err = __copy_from_user(¤t->thread.float_regs[0], &fpu->si_float_regs[0],
246 (sizeof(unsigned long) * 32));
247 err |= __get_user(current->thread.fsr, &fpu->si_fsr);
248 err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
249 if (current->thread.fpqdepth != 0)
250 err |= __copy_from_user(¤t->thread.fpqueue[0],
251 &fpu->si_fpqueue[0],
252 ((sizeof(unsigned long) +
253 (sizeof(unsigned long *)))*16));
254 return err;
255 }
256
257 static inline void do_new_sigreturn (struct pt_regs *regs)
258 {
259 struct new_signal_frame *sf;
260 unsigned long up_psr, pc, npc;
261 sigset_t set;
262 __siginfo_fpu_t *fpu_save;
263 int err;
264
265 sf = (struct new_signal_frame *) regs->u_regs [UREG_FP];
266
267 /* 1. Make sure we are not getting garbage from the user */
268 if (verify_area (VERIFY_READ, sf, sizeof (*sf)))
269 goto segv_and_exit;
270
271 if (((uint) sf) & 3)
272 goto segv_and_exit;
273
274 err = __get_user(pc, &sf->info.si_regs.pc);
275 err |= __get_user(npc, &sf->info.si_regs.npc);
276
277 if ((pc | npc) & 3)
278 goto segv_and_exit;
279
280 /* 2. Restore the state */
281 up_psr = regs->psr;
282 err |= __copy_from_user(regs, &sf->info.si_regs, sizeof (struct pt_regs));
283
284 /* User can only change condition codes and FPU enabling in %psr. */
285 regs->psr = (up_psr & ~(PSR_ICC | PSR_EF))
286 | (regs->psr & (PSR_ICC | PSR_EF));
287
288 err |= __get_user(fpu_save, &sf->fpu_save);
289
290 if (fpu_save)
291 err |= restore_fpu_state(regs, fpu_save);
292
293 /* This is pretty much atomic, no amount locking would prevent
294 * the races which exist anyways.
295 */
296 err |= __get_user(set.sig[0], &sf->info.si_mask);
297 err |= __copy_from_user(&set.sig[1], &sf->extramask,
298 (_NSIG_WORDS-1) * sizeof(unsigned int));
299
300 if (err)
301 goto segv_and_exit;
302
303 sigdelsetmask(&set, ~_BLOCKABLE);
304 spin_lock_irq(¤t->sigmask_lock);
305 current->blocked = set;
306 recalc_sigpending(current);
307 spin_unlock_irq(¤t->sigmask_lock);
308 return;
309
310 segv_and_exit:
311 do_exit(SIGSEGV);
312 }
313
314 asmlinkage void do_sigreturn(struct pt_regs *regs)
315 {
316 struct sigcontext *scptr;
317 unsigned long pc, npc, psr;
318 sigset_t set;
319 int err;
320
321 synchronize_user_stack();
322
323 if (current->thread.new_signal)
324 return do_new_sigreturn (regs);
325
326 scptr = (struct sigcontext *) regs->u_regs[UREG_I0];
327
328 /* Check sanity of the user arg. */
329 if(verify_area(VERIFY_READ, scptr, sizeof(struct sigcontext)) ||
330 (((unsigned long) scptr) & 3))
331 goto segv_and_exit;
332
333 err = __get_user(pc, &scptr->sigc_pc);
334 err |= __get_user(npc, &scptr->sigc_npc);
335
336 if((pc | npc) & 3)
337 goto segv_and_exit;
338
339 /* This is pretty much atomic, no amount locking would prevent
340 * the races which exist anyways.
341 */
342 err |= __get_user(set.sig[0], &scptr->sigc_mask);
343 /* Note that scptr + 1 points to extramask */
344 err |= __copy_from_user(&set.sig[1], scptr + 1,
345 (_NSIG_WORDS - 1) * sizeof(unsigned int));
346
347 if (err)
348 goto segv_and_exit;
349
350 sigdelsetmask(&set, ~_BLOCKABLE);
351 spin_lock_irq(¤t->sigmask_lock);
352 current->blocked = set;
353 recalc_sigpending(current);
354 spin_unlock_irq(¤t->sigmask_lock);
355
356 regs->pc = pc;
357 regs->npc = npc;
358
359 err = __get_user(regs->u_regs[UREG_FP], &scptr->sigc_sp);
360 err |= __get_user(regs->u_regs[UREG_I0], &scptr->sigc_o0);
361 err |= __get_user(regs->u_regs[UREG_G1], &scptr->sigc_g1);
362
363 /* User can only change condition codes in %psr. */
364 err |= __get_user(psr, &scptr->sigc_psr);
365 if (err)
366 goto segv_and_exit;
367
368 regs->psr &= ~(PSR_ICC);
369 regs->psr |= (psr & PSR_ICC);
370 return;
371
372 segv_and_exit:
373 send_sig(SIGSEGV, current, 1);
374 }
375
376 asmlinkage void do_rt_sigreturn(struct pt_regs *regs)
377 {
378 struct rt_signal_frame *sf;
379 unsigned int psr, pc, npc;
380 __siginfo_fpu_t *fpu_save;
381 sigset_t set;
382 stack_t st;
383 int err;
384
385 synchronize_user_stack();
386 sf = (struct rt_signal_frame *) regs->u_regs[UREG_FP];
387 if(verify_area(VERIFY_READ, sf, sizeof(*sf)) ||
388 (((unsigned long) sf) & 0x03))
389 goto segv;
390
391 err = __get_user(pc, &sf->regs.pc);
392 err |= __get_user(npc, &sf->regs.npc);
393 err |= ((pc | npc) & 0x03);
394
395 err |= __get_user(regs->y, &sf->regs.y);
396 err |= __get_user(psr, &sf->regs.psr);
397
398 err |= __copy_from_user(®s->u_regs[UREG_G1], &sf->regs.u_regs[UREG_G1], 15*sizeof(u32));
399
400 regs->psr = (regs->psr & ~PSR_ICC) | (psr & PSR_ICC);
401
402 err |= __get_user(fpu_save, &sf->fpu_save);
403
404 if(fpu_save)
405 err |= restore_fpu_state(regs, fpu_save);
406 err |= __copy_from_user(&set, &sf->mask, sizeof(sigset_t));
407
408 err |= __copy_from_user(&st, &sf->stack, sizeof(stack_t));
409
410 if (err)
411 goto segv;
412
413 regs->pc = pc;
414 regs->npc = npc;
415
416 /* It is more difficult to avoid calling this function than to
417 call it and ignore errors. */
418 do_sigaltstack(&st, NULL, (unsigned long)sf);
419
420 sigdelsetmask(&set, ~_BLOCKABLE);
421 spin_lock_irq(¤t->sigmask_lock);
422 current->blocked = set;
423 recalc_sigpending(current);
424 spin_unlock_irq(¤t->sigmask_lock);
425 return;
426 segv:
427 send_sig(SIGSEGV, current, 1);
428 }
429
430 /* Checks if the fp is valid */
431 static inline int invalid_frame_pointer (void *fp, int fplen)
432 {
433 if ((((unsigned long) fp) & 7) ||
434 !__access_ok((unsigned long)fp, fplen) ||
435 ((sparc_cpu_model == sun4 || sparc_cpu_model == sun4c) &&
436 ((unsigned long) fp < 0xe0000000 && (unsigned long) fp >= 0x20000000)))
437 return 1;
438
439 return 0;
440 }
441
442 static inline void *get_sigframe(struct sigaction *sa, struct pt_regs *regs, unsigned long framesize)
443 {
444 unsigned long sp;
445
446 sp = regs->u_regs[UREG_FP];
447
448 /* This is the X/Open sanctioned signal stack switching. */
449 if (sa->sa_flags & SA_ONSTACK) {
450 if (!on_sig_stack(sp) && !((current->sas_ss_sp + current->sas_ss_size) & 7))
451 sp = current->sas_ss_sp + current->sas_ss_size;
452 }
453 return (void *)(sp - framesize);
454 }
455
456 static inline void
457 setup_frame(struct sigaction *sa, struct pt_regs *regs, int signr, sigset_t *oldset, siginfo_t *info)
458 {
459 struct signal_sframe *sframep;
460 struct sigcontext *sc;
461 int window = 0, err;
462 unsigned long pc = regs->pc;
463 unsigned long npc = regs->npc;
464 void *sig_address;
465 int sig_code;
466
467 synchronize_user_stack();
468 sframep = (struct signal_sframe *)get_sigframe(sa, regs, SF_ALIGNEDSZ);
469 if (invalid_frame_pointer (sframep, sizeof(*sframep))){
470 #ifdef DEBUG_SIGNALS /* fills up the console logs during crashme runs, yuck... */
471 printk("%s [%d]: User has trashed signal stack\n",
472 current->comm, current->pid);
473 printk("Sigstack ptr %p handler at pc<%08lx> for sig<%d>\n",
474 sframep, pc, signr);
475 #endif
476 /* Don't change signal code and address, so that
477 * post mortem debuggers can have a look.
478 */
479 goto sigill_and_return;
480 }
481
482 sc = &sframep->sig_context;
483
484 /* We've already made sure frame pointer isn't in kernel space... */
485 err = __put_user((sas_ss_flags(regs->u_regs[UREG_FP]) == SS_ONSTACK),
486 &sc->sigc_onstack);
487 err |= __put_user(oldset->sig[0], &sc->sigc_mask);
488 err |= __copy_to_user(sframep->extramask, &oldset->sig[1],
489 (_NSIG_WORDS - 1) * sizeof(unsigned int));
490 err |= __put_user(regs->u_regs[UREG_FP], &sc->sigc_sp);
491 err |= __put_user(pc, &sc->sigc_pc);
492 err |= __put_user(npc, &sc->sigc_npc);
493 err |= __put_user(regs->psr, &sc->sigc_psr);
494 err |= __put_user(regs->u_regs[UREG_G1], &sc->sigc_g1);
495 err |= __put_user(regs->u_regs[UREG_I0], &sc->sigc_o0);
496 err |= __put_user(current->thread.w_saved, &sc->sigc_oswins);
497 if(current->thread.w_saved)
498 for(window = 0; window < current->thread.w_saved; window++) {
499 sc->sigc_spbuf[window] =
500 (char *)current->thread.rwbuf_stkptrs[window];
501 err |= __copy_to_user(&sc->sigc_wbuf[window],
502 ¤t->thread.reg_window[window],
503 sizeof(struct reg_window));
504 }
505 else
506 err |= __copy_to_user(sframep, (char *)regs->u_regs[UREG_FP],
507 sizeof(struct reg_window));
508
509 current->thread.w_saved = 0; /* So process is allowed to execute. */
510
511 err |= __put_user(signr, &sframep->sig_num);
512 sig_address = NULL;
513 sig_code = 0;
514 if (SI_FROMKERNEL (info) && (info->si_code & __SI_MASK) == __SI_FAULT) {
515 sig_address = info->si_addr;
516 switch (signr) {
517 case SIGSEGV:
518 switch (info->si_code) {
519 case SEGV_MAPERR: sig_code = SUBSIG_NOMAPPING; break;
520 default: sig_code = SUBSIG_PROTECTION; break;
521 }
522 break;
523 case SIGILL:
524 switch (info->si_code) {
525 case ILL_ILLOPC: sig_code = SUBSIG_ILLINST; break;
526 case ILL_PRVOPC: sig_code = SUBSIG_PRIVINST; break;
527 case ILL_ILLTRP: sig_code = SUBSIG_BADTRAP (info->si_trapno); break;
528 default: sig_code = SUBSIG_STACK; break;
529 }
530 break;
531 case SIGFPE:
532 switch (info->si_code) {
533 case FPE_INTDIV: sig_code = SUBSIG_IDIVZERO; break;
534 case FPE_INTOVF: sig_code = SUBSIG_FPINTOVFL; break;
535 case FPE_FLTDIV: sig_code = SUBSIG_FPDIVZERO; break;
536 case FPE_FLTOVF: sig_code = SUBSIG_FPOVFLOW; break;
537 case FPE_FLTUND: sig_code = SUBSIG_FPUNFLOW; break;
538 case FPE_FLTRES: sig_code = SUBSIG_FPINEXACT; break;
539 case FPE_FLTINV: sig_code = SUBSIG_FPOPERROR; break;
540 default: sig_code = SUBSIG_FPERROR; break;
541 }
542 break;
543 case SIGBUS:
544 switch (info->si_code) {
545 case BUS_ADRALN: sig_code = SUBSIG_ALIGNMENT; break;
546 case BUS_ADRERR: sig_code = SUBSIG_MISCERROR; break;
547 default: sig_code = SUBSIG_BUSTIMEOUT; break;
548 }
549 break;
550 case SIGEMT:
551 switch (info->si_code) {
552 case EMT_TAGOVF: sig_code = SUBSIG_TAG; break;
553 }
554 break;
555 case SIGSYS:
556 if (info->si_code == (__SI_FAULT|0x100)) {
557 /* See sys_sunos.c */
558 sig_code = info->si_trapno;
559 break;
560 }
561 default:
562 sig_address = NULL;
563 }
564 }
565 err |= __put_user((long)sig_address, &sframep->sig_address);
566 err |= __put_user(sig_code, &sframep->sig_code);
567 err |= __put_user(sc, &sframep->sig_scptr);
568 if (err)
569 goto sigsegv;
570
571 regs->u_regs[UREG_FP] = (unsigned long) sframep;
572 regs->pc = (unsigned long) sa->sa_handler;
573 regs->npc = (regs->pc + 4);
574 return;
575
576 sigill_and_return:
577 do_exit(SIGILL);
578 sigsegv:
579 do_exit(SIGSEGV);
580 }
581
582
583 static inline int
584 save_fpu_state(struct pt_regs *regs, __siginfo_fpu_t *fpu)
585 {
586 int err = 0;
587 #ifdef CONFIG_SMP
588 if (current->flags & PF_USEDFPU) {
589 put_psr(get_psr() | PSR_EF);
590 fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr,
591 ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth);
592 regs->psr &= ~(PSR_EF);
593 current->flags &= ~(PF_USEDFPU);
594 }
595 #else
596 if (current == last_task_used_math) {
597 put_psr(get_psr() | PSR_EF);
598 fpsave(¤t->thread.float_regs[0], ¤t->thread.fsr,
599 ¤t->thread.fpqueue[0], ¤t->thread.fpqdepth);
600 last_task_used_math = 0;
601 regs->psr &= ~(PSR_EF);
602 }
603 #endif
604 err |= __copy_to_user(&fpu->si_float_regs[0], ¤t->thread.float_regs[0],
605 (sizeof(unsigned long) * 32));
606 err |= __put_user(current->thread.fsr, &fpu->si_fsr);
607 err |= __put_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
608 if (current->thread.fpqdepth != 0)
609 err |= __copy_to_user(&fpu->si_fpqueue[0], ¤t->thread.fpqueue[0],
610 ((sizeof(unsigned long) +
611 (sizeof(unsigned long *)))*16));
612 current->used_math = 0;
613 return err;
614 }
615
616 static inline void
617 new_setup_frame(struct k_sigaction *ka, struct pt_regs *regs,
618 int signo, sigset_t *oldset)
619 {
620 struct new_signal_frame *sf;
621 int sigframe_size, err;
622
623 /* 1. Make sure everything is clean */
624 synchronize_user_stack();
625
626 sigframe_size = NF_ALIGNEDSZ;
627 if (!current->used_math)
628 sigframe_size -= sizeof(__siginfo_fpu_t);
629
630 sf = (struct new_signal_frame *)get_sigframe(&ka->sa, regs, sigframe_size);
631
632 if (invalid_frame_pointer (sf, sigframe_size))
633 goto sigill_and_return;
634
635 if (current->thread.w_saved != 0) {
636 #ifdef DEBUG_SIGNALS
637 printk ("%s [%d]: Invalid user stack frame for "
638 "signal delivery.\n", current->comm, current->pid);
639 #endif
640 goto sigill_and_return;
641 }
642
643 /* 2. Save the current process state */
644 err = __copy_to_user(&sf->info.si_regs, regs, sizeof (struct pt_regs));
645
646 err |= __put_user(0, &sf->extra_size);
647
648 if (current->used_math) {
649 err |= save_fpu_state(regs, &sf->fpu_state);
650 err |= __put_user(&sf->fpu_state, &sf->fpu_save);
651 } else {
652 err |= __put_user(0, &sf->fpu_save);
653 }
654
655 err |= __put_user(oldset->sig[0], &sf->info.si_mask);
656 err |= __copy_to_user(sf->extramask, &oldset->sig[1],
657 (_NSIG_WORDS - 1) * sizeof(unsigned int));
658 err |= __copy_to_user(sf, (char *) regs->u_regs [UREG_FP],
659 sizeof (struct reg_window));
660 if (err)
661 goto sigsegv;
662
663 /* 3. signal handler back-trampoline and parameters */
664 regs->u_regs[UREG_FP] = (unsigned long) sf;
665 regs->u_regs[UREG_I0] = signo;
666 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
667
668 /* 4. signal handler */
669 regs->pc = (unsigned long) ka->sa.sa_handler;
670 regs->npc = (regs->pc + 4);
671
672 /* 5. return to kernel instructions */
673 if (ka->ka_restorer)
674 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
675 else {
676 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
677
678 /* mov __NR_sigreturn, %g1 */
679 err |= __put_user(0x821020d8, &sf->insns[0]);
680
681 /* t 0x10 */
682 err |= __put_user(0x91d02010, &sf->insns[1]);
683 if (err)
684 goto sigsegv;
685
686 /* Flush instruction space. */
687 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
688 }
689 return;
690
691 sigill_and_return:
692 do_exit(SIGILL);
693 sigsegv:
694 do_exit(SIGSEGV);
695 }
696
697 static inline void
698 new_setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
699 int signo, sigset_t *oldset, siginfo_t *info)
700 {
701 struct rt_signal_frame *sf;
702 int sigframe_size;
703 unsigned int psr;
704 int err;
705
706 synchronize_user_stack();
707 sigframe_size = RT_ALIGNEDSZ;
708 if(!current->used_math)
709 sigframe_size -= sizeof(__siginfo_fpu_t);
710 sf = (struct rt_signal_frame *)get_sigframe(&ka->sa, regs, sigframe_size);
711 if(invalid_frame_pointer(sf, sigframe_size))
712 goto sigill;
713 if(current->thread.w_saved != 0)
714 goto sigill;
715
716 err = __put_user(regs->pc, &sf->regs.pc);
717 err |= __put_user(regs->npc, &sf->regs.npc);
718 err |= __put_user(regs->y, &sf->regs.y);
719 psr = regs->psr;
720 if(current->used_math)
721 psr |= PSR_EF;
722 err |= __put_user(psr, &sf->regs.psr);
723 err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
724 err |= __put_user(0, &sf->extra_size);
725
726 if(psr & PSR_EF) {
727 err |= save_fpu_state(regs, &sf->fpu_state);
728 err |= __put_user(&sf->fpu_state, &sf->fpu_save);
729 } else {
730 err |= __put_user(0, &sf->fpu_save);
731 }
732 err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
733
734 /* Setup sigaltstack */
735 err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
736 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
737 err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
738
739 err |= __copy_to_user(sf, (char *) regs->u_regs [UREG_FP],
740 sizeof (struct reg_window));
741
742 err |= copy_siginfo_to_user(&sf->info, info);
743
744 if (err)
745 goto sigsegv;
746
747 regs->u_regs[UREG_FP] = (unsigned long) sf;
748 regs->u_regs[UREG_I0] = signo;
749 regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
750
751 regs->pc = (unsigned long) ka->sa.sa_handler;
752 regs->npc = (regs->pc + 4);
753
754 if(ka->ka_restorer)
755 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
756 else {
757 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
758
759 /* mov __NR_sigreturn, %g1 */
760 err |= __put_user(0x821020d8, &sf->insns[0]);
761
762 /* t 0x10 */
763 err |= __put_user(0x91d02010, &sf->insns[1]);
764 if (err)
765 goto sigsegv;
766
767 /* Flush instruction space. */
768 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
769 }
770 return;
771
772 sigill:
773 do_exit(SIGILL);
774 sigsegv:
775 do_exit(SIGSEGV);
776 }
777
778 /* Setup a Solaris stack frame */
779 static inline void
780 setup_svr4_frame(struct sigaction *sa, unsigned long pc, unsigned long npc,
781 struct pt_regs *regs, int signr, sigset_t *oldset)
782 {
783 svr4_signal_frame_t *sfp;
784 svr4_gregset_t *gr;
785 svr4_siginfo_t *si;
786 svr4_mcontext_t *mc;
787 svr4_gwindows_t *gw;
788 svr4_ucontext_t *uc;
789 svr4_sigset_t setv;
790 int window = 0, err;
791
792 synchronize_user_stack();
793 sfp = (svr4_signal_frame_t *) get_sigframe(sa, regs, SVR4_SF_ALIGNED + REGWIN_SZ);
794
795 if (invalid_frame_pointer (sfp, sizeof (*sfp))){
796 #ifdef DEBUG_SIGNALS
797 printk ("Invalid stack frame\n");
798 #endif
799 goto sigill_and_return;
800 }
801
802 /* Start with a clean frame pointer and fill it */
803 err = __clear_user(sfp, sizeof (*sfp));
804
805 /* Setup convenience variables */
806 si = &sfp->si;
807 uc = &sfp->uc;
808 gw = &sfp->gw;
809 mc = &uc->mcontext;
810 gr = &mc->greg;
811
812 /* FIXME: where am I supposed to put this?
813 * sc->sigc_onstack = old_status;
814 * anyways, it does not look like it is used for anything at all.
815 */
816 setv.sigbits[0] = oldset->sig[0];
817 setv.sigbits[1] = oldset->sig[1];
818 if (_NSIG_WORDS >= 4) {
819 setv.sigbits[2] = oldset->sig[2];
820 setv.sigbits[3] = oldset->sig[3];
821 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
822 } else
823 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned int));
824
825 /* Store registers */
826 err |= __put_user(regs->pc, &((*gr) [SVR4_PC]));
827 err |= __put_user(regs->npc, &((*gr) [SVR4_NPC]));
828 err |= __put_user(regs->psr, &((*gr) [SVR4_PSR]));
829 err |= __put_user(regs->y, &((*gr) [SVR4_Y]));
830
831 /* Copy g [1..7] and o [0..7] registers */
832 err |= __copy_to_user(&(*gr)[SVR4_G1], ®s->u_regs [UREG_G1], sizeof (long) * 7);
833 err |= __copy_to_user(&(*gr)[SVR4_O0], ®s->u_regs [UREG_I0], sizeof (long) * 8);
834
835 /* Setup sigaltstack */
836 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
837 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
838 err |= __put_user(current->sas_ss_size, &uc->stack.size);
839
840 /* Save the currently window file: */
841
842 /* 1. Link sfp->uc->gwins to our windows */
843 err |= __put_user(gw, &mc->gwin);
844
845 /* 2. Number of windows to restore at setcontext (): */
846 err |= __put_user(current->thread.w_saved, &gw->count);
847
848 /* 3. Save each valid window
849 * Currently, it makes a copy of the windows from the kernel copy.
850 * David's code for SunOS, makes the copy but keeps the pointer to
851 * the kernel. My version makes the pointer point to a userland
852 * copy of those. Mhm, I wonder if I shouldn't just ignore those
853 * on setcontext and use those that are on the kernel, the signal
854 * handler should not be modyfing those, mhm.
855 *
856 * These windows are just used in case synchronize_user_stack failed
857 * to flush the user windows.
858 */
859 for(window = 0; window < current->thread.w_saved; window++) {
860 err |= __put_user((int *) &(gw->win [window]), &gw->winptr [window]);
861 err |= __copy_to_user(&gw->win [window],
862 ¤t->thread.reg_window [window],
863 sizeof (svr4_rwindow_t));
864 err |= __put_user(0, gw->winptr [window]);
865 }
866
867 /* 4. We just pay attention to the gw->count field on setcontext */
868 current->thread.w_saved = 0; /* So process is allowed to execute. */
869
870 /* Setup the signal information. Solaris expects a bunch of
871 * information to be passed to the signal handler, we don't provide
872 * that much currently, should use siginfo.
873 */
874 err |= __put_user(signr, &si->siginfo.signo);
875 err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
876 if (err)
877 goto sigsegv;
878
879 regs->u_regs[UREG_FP] = (unsigned long) sfp;
880 regs->pc = (unsigned long) sa->sa_handler;
881 regs->npc = (regs->pc + 4);
882
883 #ifdef DEBUG_SIGNALS
884 printk ("Solaris-frame: %x %x\n", (int) regs->pc, (int) regs->npc);
885 #endif
886 /* Arguments passed to signal handler */
887 if (regs->u_regs [14]){
888 struct reg_window *rw = (struct reg_window *) regs->u_regs [14];
889
890 err |= __put_user(signr, &rw->ins [0]);
891 err |= __put_user(si, &rw->ins [1]);
892 err |= __put_user(uc, &rw->ins [2]);
893 err |= __put_user(sfp, &rw->ins [6]); /* frame pointer */
894 if (err)
895 goto sigsegv;
896
897 regs->u_regs[UREG_I0] = signr;
898 regs->u_regs[UREG_I1] = (uint) si;
899 regs->u_regs[UREG_I2] = (uint) uc;
900 }
901 return;
902
903 sigill_and_return:
904 do_exit(SIGILL);
905 sigsegv:
906 do_exit(SIGSEGV);
907 }
908
909 asmlinkage int svr4_getcontext (svr4_ucontext_t *uc, struct pt_regs *regs)
910 {
911 svr4_gregset_t *gr;
912 svr4_mcontext_t *mc;
913 svr4_sigset_t setv;
914 int err = 0;
915
916 synchronize_user_stack();
917
918 if (current->thread.w_saved)
919 goto sigsegv_and_return;
920
921 err = clear_user(uc, sizeof (*uc));
922 if (err)
923 return -EFAULT;
924
925 /* Setup convenience variables */
926 mc = &uc->mcontext;
927 gr = &mc->greg;
928
929 setv.sigbits[0] = current->blocked.sig[0];
930 setv.sigbits[1] = current->blocked.sig[1];
931 if (_NSIG_WORDS >= 4) {
932 setv.sigbits[2] = current->blocked.sig[2];
933 setv.sigbits[3] = current->blocked.sig[3];
934 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
935 } else
936 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned int));
937
938 /* Store registers */
939 err |= __put_user(regs->pc, &uc->mcontext.greg [SVR4_PC]);
940 err |= __put_user(regs->npc, &uc->mcontext.greg [SVR4_NPC]);
941 err |= __put_user(regs->psr, &uc->mcontext.greg [SVR4_PSR]);
942 err |= __put_user(regs->y, &uc->mcontext.greg [SVR4_Y]);
943
944 /* Copy g [1..7] and o [0..7] registers */
945 err |= __copy_to_user(&(*gr)[SVR4_G1], ®s->u_regs [UREG_G1], sizeof (uint) * 7);
946 err |= __copy_to_user(&(*gr)[SVR4_O0], ®s->u_regs [UREG_I0], sizeof (uint) * 8);
947
948 /* Setup sigaltstack */
949 err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
950 err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
951 err |= __put_user(current->sas_ss_size, &uc->stack.size);
952
953 /* The register file is not saved
954 * we have already stuffed all of it with sync_user_stack
955 */
956 return (err ? -EFAULT : 0);
957
958 sigsegv_and_return:
959 do_exit(SIGSEGV);
960 }
961
962 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
963 asmlinkage int svr4_setcontext (svr4_ucontext_t *c, struct pt_regs *regs)
964 {
965 struct thread_struct *tp = ¤t->thread;
966 svr4_gregset_t *gr;
967 unsigned long pc, npc, psr;
968 sigset_t set;
969 svr4_sigset_t setv;
970 int err;
971 stack_t st;
972
973 /* Fixme: restore windows, or is this already taken care of in
974 * svr4_setup_frame when sync_user_windows is done?
975 */
976 flush_user_windows();
977
978 if (tp->w_saved)
979 goto sigsegv_and_return;
980
981 if (((uint) c) & 3)
982 goto sigsegv_and_return;
983
984 if(!__access_ok((unsigned long)c, sizeof(*c)))
985 goto sigsegv_and_return;
986
987 /* Check for valid PC and nPC */
988 gr = &c->mcontext.greg;
989 err = __get_user(pc, &((*gr)[SVR4_PC]));
990 err |= __get_user(npc, &((*gr)[SVR4_NPC]));
991
992 if((pc | npc) & 3)
993 goto sigsegv_and_return;
994
995 /* Retrieve information from passed ucontext */
996 /* note that nPC is ored a 1, this is used to inform entry.S */
997 /* that we don't want it to mess with our PC and nPC */
998
999 /* This is pretty much atomic, no amount locking would prevent
1000 * the races which exist anyways.
1001 */
1002 err |= __copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1003
1004 err |= __get_user(st.ss_sp, &c->stack.sp);
1005 err |= __get_user(st.ss_flags, &c->stack.flags);
1006 err |= __get_user(st.ss_size, &c->stack.size);
1007
1008 if (err)
1009 goto sigsegv_and_return;
1010
1011 /* It is more difficult to avoid calling this function than to
1012 call it and ignore errors. */
1013 do_sigaltstack(&st, NULL, regs->u_regs[UREG_I6]);
1014
1015 set.sig[0] = setv.sigbits[0];
1016 set.sig[1] = setv.sigbits[1];
1017 if (_NSIG_WORDS >= 4) {
1018 set.sig[2] = setv.sigbits[2];
1019 set.sig[3] = setv.sigbits[3];
1020 }
1021 sigdelsetmask(&set, ~_BLOCKABLE);
1022 spin_lock_irq(¤t->sigmask_lock);
1023 current->blocked = set;
1024 recalc_sigpending(current);
1025 spin_unlock_irq(¤t->sigmask_lock);
1026 regs->pc = pc;
1027 regs->npc = npc | 1;
1028 err |= __get_user(regs->y, &((*gr) [SVR4_Y]));
1029 err |= __get_user(psr, &((*gr) [SVR4_PSR]));
1030 regs->psr &= ~(PSR_ICC);
1031 regs->psr |= (psr & PSR_ICC);
1032
1033 /* Restore g[1..7] and o[0..7] registers */
1034 err |= __copy_from_user(®s->u_regs [UREG_G1], &(*gr)[SVR4_G1],
1035 sizeof (long) * 7);
1036 err |= __copy_from_user(®s->u_regs [UREG_I0], &(*gr)[SVR4_O0],
1037 sizeof (long) * 8);
1038 return (err ? -EFAULT : 0);
1039
1040 sigsegv_and_return:
1041 do_exit(SIGSEGV);
1042 }
1043
1044 static inline void
1045 handle_signal(unsigned long signr, struct k_sigaction *ka,
1046 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1047 int svr4_signal)
1048 {
1049 if (svr4_signal)
1050 setup_svr4_frame(&ka->sa, regs->pc, regs->npc, regs, signr, oldset);
1051 else {
1052 if (ka->sa.sa_flags & SA_SIGINFO)
1053 new_setup_rt_frame(ka, regs, signr, oldset, info);
1054 else if (current->thread.new_signal)
1055 new_setup_frame (ka, regs, signr, oldset);
1056 else
1057 setup_frame(&ka->sa, regs, signr, oldset, info);
1058 }
1059 if(ka->sa.sa_flags & SA_ONESHOT)
1060 ka->sa.sa_handler = SIG_DFL;
1061 if(!(ka->sa.sa_flags & SA_NOMASK)) {
1062 spin_lock_irq(¤t->sigmask_lock);
1063 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
1064 sigaddset(¤t->blocked, signr);
1065 recalc_sigpending(current);
1066 spin_unlock_irq(¤t->sigmask_lock);
1067 }
1068 }
1069
1070 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
1071 struct sigaction *sa)
1072 {
1073 switch(regs->u_regs[UREG_I0]) {
1074 case ERESTARTNOHAND:
1075 no_system_call_restart:
1076 regs->u_regs[UREG_I0] = EINTR;
1077 regs->psr |= PSR_C;
1078 break;
1079 case ERESTARTSYS:
1080 if(!(sa->sa_flags & SA_RESTART))
1081 goto no_system_call_restart;
1082 /* fallthrough */
1083 case ERESTARTNOINTR:
1084 regs->u_regs[UREG_I0] = orig_i0;
1085 regs->pc -= 4;
1086 regs->npc -= 4;
1087 }
1088 }
1089
1090 #ifdef DEBUG_SIGNALS_MAPS
1091
1092 #define MAPS_LINE_FORMAT "%08lx-%08lx %s %08lx %s %lu "
1093
1094 static inline void read_maps (void)
1095 {
1096 struct vm_area_struct * map, * next;
1097 char * buffer;
1098 ssize_t i;
1099
1100 buffer = (char*)__get_free_page(GFP_KERNEL);
1101 if (!buffer)
1102 return;
1103
1104 for (map = current->mm->mmap ; map ; map = next ) {
1105 /* produce the next line */
1106 char *line;
1107 char str[5], *cp = str;
1108 int flags;
1109 kdev_t dev;
1110 unsigned long ino;
1111
1112 /*
1113 * Get the next vma now (but it won't be used if we sleep).
1114 */
1115 next = map->vm_next;
1116 flags = map->vm_flags;
1117
1118 *cp++ = flags & VM_READ ? 'r' : '-';
1119 *cp++ = flags & VM_WRITE ? 'w' : '-';
1120 *cp++ = flags & VM_EXEC ? 'x' : '-';
1121 *cp++ = flags & VM_MAYSHARE ? 's' : 'p';
1122 *cp++ = 0;
1123
1124 dev = 0;
1125 ino = 0;
1126 if (map->vm_file != NULL) {
1127 dev = map->vm_file->f_dentry->d_inode->i_dev;
1128 ino = map->vm_file->f_dentry->d_inode->i_ino;
1129 line = d_path(map->vm_file->f_dentry,
1130 map->vm_file->f_vfsmnt,
1131 buffer, PAGE_SIZE);
1132 }
1133 printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT,
1134 kdevname(dev), ino);
1135 if (map->vm_file != NULL)
1136 printk("%s\n", line);
1137 else
1138 printk("\n");
1139 }
1140 free_page((unsigned long)buffer);
1141 return;
1142 }
1143 #endif
1144
1145 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1146 * want to handle. Thus you cannot kill init even with a SIGKILL even by
1147 * mistake.
1148 */
1149 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
1150 unsigned long orig_i0, int restart_syscall)
1151 {
1152 unsigned long signr;
1153 struct k_sigaction *ka;
1154 siginfo_t info;
1155
1156 /*
1157 * XXX Disable svr4 signal handling until solaris emulation works.
1158 * It is buggy - Anton
1159 */
1160 #define SVR4_SIGNAL_BROKEN 1
1161 #ifdef SVR4_SIGNAL_BROKEN
1162 int svr4_signal = 0;
1163 #else
1164 int svr4_signal = current->personality == PER_SVR4;
1165 #endif
1166
1167 if (!oldset)
1168 oldset = ¤t->blocked;
1169
1170 for (;;) {
1171 spin_lock_irq(¤t->sigmask_lock);
1172 signr = dequeue_signal(¤t->blocked, &info);
1173 spin_unlock_irq(¤t->sigmask_lock);
1174
1175 if (!signr) break;
1176
1177 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1178 current->exit_code = signr;
1179 current->state = TASK_STOPPED;
1180
1181 /* This happens to be SMP safe so no need to
1182 * grab master kernel lock even in this case.
1183 */
1184 notify_parent(current, SIGCHLD);
1185 schedule();
1186 if (!(signr = current->exit_code))
1187 continue;
1188 current->exit_code = 0;
1189 if (signr == SIGSTOP)
1190 continue;
1191
1192 /* Update the siginfo structure. Is this good? */
1193 if (signr != info.si_signo) {
1194 info.si_signo = signr;
1195 info.si_errno = 0;
1196 info.si_code = SI_USER;
1197 info.si_pid = current->p_pptr->pid;
1198 info.si_uid = current->p_pptr->uid;
1199 }
1200
1201 /* If the (new) signal is now blocked, requeue it. */
1202 if (sigismember(¤t->blocked, signr)) {
1203 send_sig_info(signr, &info, current);
1204 continue;
1205 }
1206 }
1207
1208 ka = ¤t->sig->action[signr-1];
1209
1210 if(ka->sa.sa_handler == SIG_IGN) {
1211 if(signr != SIGCHLD)
1212 continue;
1213
1214 /* sys_wait4() grabs the master kernel lock, so
1215 * we need not do so, that sucker should be
1216 * threaded and would not be that difficult to
1217 * do anyways.
1218 */
1219 while(sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
1220 ;
1221 continue;
1222 }
1223 if(ka->sa.sa_handler == SIG_DFL) {
1224 unsigned long exit_code = signr;
1225
1226 if(current->pid == 1)
1227 continue;
1228 switch(signr) {
1229 case SIGCONT: case SIGCHLD: case SIGWINCH:
1230 continue;
1231
1232 case SIGTSTP: case SIGTTIN: case SIGTTOU:
1233 /* The operations performed by
1234 * is_orphaned_pgrp() are protected by
1235 * the tasklist_lock.
1236 */
1237 if (is_orphaned_pgrp(current->pgrp))
1238 continue;
1239
1240 case SIGSTOP:
1241 if (current->ptrace & PT_PTRACED)
1242 continue;
1243 current->state = TASK_STOPPED;
1244 current->exit_code = signr;
1245
1246 /* notify_parent() is SMP safe */
1247 if(!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &
1248 SA_NOCLDSTOP))
1249 notify_parent(current, SIGCHLD);
1250 schedule();
1251 continue;
1252
1253 case SIGQUIT: case SIGILL: case SIGTRAP:
1254 case SIGABRT: case SIGFPE: case SIGSEGV:
1255 case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
1256 if (do_coredump(signr, regs))
1257 exit_code |= 0x80;
1258 #ifdef DEBUG_SIGNALS
1259 /* Very useful to debug dynamic linker problems */
1260 printk ("Sig %ld going for %s[%d]...\n", signr, current->comm, current->pid);
1261 show_regs (regs);
1262 #ifdef DEBUG_SIGNALS_TRACE
1263 {
1264 struct reg_window *rw = (struct reg_window *)regs->u_regs[UREG_FP];
1265 unsigned int ins[8];
1266
1267 while(rw &&
1268 !(((unsigned long) rw) & 0x3)) {
1269 copy_from_user(ins, &rw->ins[0], sizeof(ins));
1270 printk("Caller[%08x](%08x,%08x,%08x,%08x,%08x,%08x)\n", ins[7], ins[0], ins[1], ins[2], ins[3], ins[4], ins[5]);
1271 rw = (struct reg_window *)(unsigned long)ins[6];
1272 }
1273 }
1274 #endif
1275 #ifdef DEBUG_SIGNALS_MAPS
1276 printk("Maps:\n");
1277 read_maps();
1278 #endif
1279 #endif
1280 /* fall through */
1281 default:
1282 sigaddset(¤t->pending.signal, signr);
1283 recalc_sigpending(current);
1284 current->flags |= PF_SIGNALED;
1285 do_exit(exit_code);
1286 /* NOT REACHED */
1287 }
1288 }
1289 if(restart_syscall)
1290 syscall_restart(orig_i0, regs, &ka->sa);
1291 handle_signal(signr, ka, &info, oldset, regs, svr4_signal);
1292 return 1;
1293 }
1294 if(restart_syscall &&
1295 (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1296 regs->u_regs[UREG_I0] == ERESTARTSYS ||
1297 regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1298 /* replay the system call when we are done */
1299 regs->u_regs[UREG_I0] = orig_i0;
1300 regs->pc -= 4;
1301 regs->npc -= 4;
1302 }
1303 return 0;
1304 }
1305
1306 asmlinkage int
1307 do_sys_sigstack(struct sigstack *ssptr, struct sigstack *ossptr, unsigned long sp)
1308 {
1309 int ret = -EFAULT;
1310
1311 /* First see if old state is wanted. */
1312 if (ossptr) {
1313 if (put_user(current->sas_ss_sp + current->sas_ss_size, &ossptr->the_stack) ||
1314 __put_user(on_sig_stack(sp), &ossptr->cur_status))
1315 goto out;
1316 }
1317
1318 /* Now see if we want to update the new state. */
1319 if (ssptr) {
1320 void *ss_sp;
1321
1322 if (get_user((long)ss_sp, &ssptr->the_stack))
1323 goto out;
1324 /* If the current stack was set with sigaltstack, don't
1325 swap stacks while we are on it. */
1326 ret = -EPERM;
1327 if (current->sas_ss_sp && on_sig_stack(sp))
1328 goto out;
1329
1330 /* Since we don't know the extent of the stack, and we don't
1331 track onstack-ness, but rather calculate it, we must
1332 presume a size. Ho hum this interface is lossy. */
1333 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1334 current->sas_ss_size = SIGSTKSZ;
1335 }
1336 ret = 0;
1337 out:
1338 return ret;
1339 }
1340