~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/sparc/kernel/signal.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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(&current->sigmask_lock);
142         saveset = current->blocked;
143         siginitset(&current->blocked, set);
144         recalc_sigpending(current);
145         spin_unlock_irq(&current->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(&current->sigmask_lock);
199         oldset = current->blocked;
200         current->blocked = set;
201         recalc_sigpending(current);
202         spin_unlock_irq(&current->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(&current->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(&current->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(&current->sigmask_lock);
305         current->blocked = set;
306         recalc_sigpending(current);
307         spin_unlock_irq(&current->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(&current->sigmask_lock);
352         current->blocked = set;
353         recalc_sigpending(current);
354         spin_unlock_irq(&current->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(&regs->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(&current->sigmask_lock);
422         current->blocked = set;
423         recalc_sigpending(current);
424         spin_unlock_irq(&current->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                                               &current->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(&current->thread.float_regs[0], &current->thread.fsr,
591                        &current->thread.fpqueue[0], &current->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(&current->thread.float_regs[0], &current->thread.fsr,
599                        &current->thread.fpqueue[0], &current->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], &current->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], &current->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         regs->u_regs[UREG_I2] = (unsigned long) &sf->info;
668 
669         /* 4. signal handler */
670         regs->pc = (unsigned long) ka->sa.sa_handler;
671         regs->npc = (regs->pc + 4);
672 
673         /* 5. return to kernel instructions */
674         if (ka->ka_restorer)
675                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
676         else {
677                 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
678 
679                 /* mov __NR_sigreturn, %g1 */
680                 err |= __put_user(0x821020d8, &sf->insns[0]);
681 
682                 /* t 0x10 */
683                 err |= __put_user(0x91d02010, &sf->insns[1]);
684                 if (err)
685                         goto sigsegv;
686 
687                 /* Flush instruction space. */
688                 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
689         }
690         return;
691 
692 sigill_and_return:
693         do_exit(SIGILL);
694 sigsegv:
695         do_exit(SIGSEGV);
696 }
697 
698 static inline void
699 new_setup_rt_frame(struct k_sigaction *ka, struct pt_regs *regs,
700                    int signo, sigset_t *oldset, siginfo_t *info)
701 {
702         struct rt_signal_frame *sf;
703         int sigframe_size;
704         unsigned int psr;
705         int err;
706 
707         synchronize_user_stack();
708         sigframe_size = RT_ALIGNEDSZ;
709         if(!current->used_math)
710                 sigframe_size -= sizeof(__siginfo_fpu_t);
711         sf = (struct rt_signal_frame *)get_sigframe(&ka->sa, regs, sigframe_size);
712         if(invalid_frame_pointer(sf, sigframe_size))
713                 goto sigill;
714         if(current->thread.w_saved != 0)
715                 goto sigill;
716 
717         err  = __put_user(regs->pc, &sf->regs.pc);
718         err |= __put_user(regs->npc, &sf->regs.npc);
719         err |= __put_user(regs->y, &sf->regs.y);
720         psr = regs->psr;
721         if(current->used_math)
722                 psr |= PSR_EF;
723         err |= __put_user(psr, &sf->regs.psr);
724         err |= __copy_to_user(&sf->regs.u_regs, regs->u_regs, sizeof(regs->u_regs));
725         err |= __put_user(0, &sf->extra_size);
726 
727         if(psr & PSR_EF) {
728                 err |= save_fpu_state(regs, &sf->fpu_state);
729                 err |= __put_user(&sf->fpu_state, &sf->fpu_save);
730         } else {
731                 err |= __put_user(0, &sf->fpu_save);
732         }
733         err |= __copy_to_user(&sf->mask, &oldset->sig[0], sizeof(sigset_t));
734         
735         /* Setup sigaltstack */
736         err |= __put_user(current->sas_ss_sp, &sf->stack.ss_sp);
737         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &sf->stack.ss_flags);
738         err |= __put_user(current->sas_ss_size, &sf->stack.ss_size);
739         
740         err |= __copy_to_user(sf, (char *) regs->u_regs [UREG_FP],
741                               sizeof (struct reg_window));      
742 
743         err |= copy_siginfo_to_user(&sf->info, info);
744 
745         if (err)
746                 goto sigsegv;
747 
748         regs->u_regs[UREG_FP] = (unsigned long) sf;
749         regs->u_regs[UREG_I0] = signo;
750         regs->u_regs[UREG_I1] = (unsigned long) &sf->info;
751         regs->u_regs[UREG_I2] = (unsigned long) &sf->regs;
752 
753         regs->pc = (unsigned long) ka->sa.sa_handler;
754         regs->npc = (regs->pc + 4);
755 
756         if(ka->ka_restorer)
757                 regs->u_regs[UREG_I7] = (unsigned long)ka->ka_restorer;
758         else {
759                 regs->u_regs[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
760 
761                 /* mov __NR_sigreturn, %g1 */
762                 err |= __put_user(0x821020d8, &sf->insns[0]);
763 
764                 /* t 0x10 */
765                 err |= __put_user(0x91d02010, &sf->insns[1]);
766                 if (err)
767                         goto sigsegv;
768 
769                 /* Flush instruction space. */
770                 flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
771         }
772         return;
773 
774 sigill:
775         do_exit(SIGILL);
776 sigsegv:
777         do_exit(SIGSEGV);
778 }
779 
780 /* Setup a Solaris stack frame */
781 static inline void
782 setup_svr4_frame(struct sigaction *sa, unsigned long pc, unsigned long npc,
783                  struct pt_regs *regs, int signr, sigset_t *oldset)
784 {
785         svr4_signal_frame_t *sfp;
786         svr4_gregset_t  *gr;
787         svr4_siginfo_t  *si;
788         svr4_mcontext_t *mc;
789         svr4_gwindows_t *gw;
790         svr4_ucontext_t *uc;
791         svr4_sigset_t   setv;
792         int window = 0, err;
793 
794         synchronize_user_stack();
795         sfp = (svr4_signal_frame_t *) get_sigframe(sa, regs, SVR4_SF_ALIGNED + sizeof(struct reg_window));
796 
797         if (invalid_frame_pointer (sfp, sizeof (*sfp))){
798 #ifdef DEBUG_SIGNALS
799                 printk ("Invalid stack frame\n");
800 #endif
801                 goto sigill_and_return;
802         }
803 
804         /* Start with a clean frame pointer and fill it */
805         err = __clear_user(sfp, sizeof (*sfp));
806 
807         /* Setup convenience variables */
808         si = &sfp->si;
809         uc = &sfp->uc;
810         gw = &sfp->gw;
811         mc = &uc->mcontext;
812         gr = &mc->greg;
813         
814         /* FIXME: where am I supposed to put this?
815          * sc->sigc_onstack = old_status;
816          * anyways, it does not look like it is used for anything at all.
817          */
818         setv.sigbits[0] = oldset->sig[0];
819         setv.sigbits[1] = oldset->sig[1];
820         if (_NSIG_WORDS >= 4) {
821                 setv.sigbits[2] = oldset->sig[2];
822                 setv.sigbits[3] = oldset->sig[3];
823                 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
824         } else
825                 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned int));
826 
827         /* Store registers */
828         err |= __put_user(regs->pc, &((*gr) [SVR4_PC]));
829         err |= __put_user(regs->npc, &((*gr) [SVR4_NPC]));
830         err |= __put_user(regs->psr, &((*gr) [SVR4_PSR]));
831         err |= __put_user(regs->y, &((*gr) [SVR4_Y]));
832         
833         /* Copy g [1..7] and o [0..7] registers */
834         err |= __copy_to_user(&(*gr)[SVR4_G1], &regs->u_regs [UREG_G1], sizeof (long) * 7);
835         err |= __copy_to_user(&(*gr)[SVR4_O0], &regs->u_regs [UREG_I0], sizeof (long) * 8);
836 
837         /* Setup sigaltstack */
838         err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
839         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
840         err |= __put_user(current->sas_ss_size, &uc->stack.size);
841 
842         /* Save the currently window file: */
843 
844         /* 1. Link sfp->uc->gwins to our windows */
845         err |= __put_user(gw, &mc->gwin);
846             
847         /* 2. Number of windows to restore at setcontext (): */
848         err |= __put_user(current->thread.w_saved, &gw->count);
849 
850         /* 3. Save each valid window
851          *    Currently, it makes a copy of the windows from the kernel copy.
852          *    David's code for SunOS, makes the copy but keeps the pointer to
853          *    the kernel.  My version makes the pointer point to a userland 
854          *    copy of those.  Mhm, I wonder if I shouldn't just ignore those
855          *    on setcontext and use those that are on the kernel, the signal
856          *    handler should not be modyfing those, mhm.
857          *
858          *    These windows are just used in case synchronize_user_stack failed
859          *    to flush the user windows.
860          */
861         for(window = 0; window < current->thread.w_saved; window++) {
862                 err |= __put_user((int *) &(gw->win [window]), &gw->winptr [window]);
863                 err |= __copy_to_user(&gw->win [window],
864                                       &current->thread.reg_window [window],
865                                       sizeof (svr4_rwindow_t));
866                 err |= __put_user(0, gw->winptr [window]);
867         }
868 
869         /* 4. We just pay attention to the gw->count field on setcontext */
870         current->thread.w_saved = 0; /* So process is allowed to execute. */
871 
872         /* Setup the signal information.  Solaris expects a bunch of
873          * information to be passed to the signal handler, we don't provide
874          * that much currently, should use siginfo.
875          */
876         err |= __put_user(signr, &si->siginfo.signo);
877         err |= __put_user(SVR4_SINOINFO, &si->siginfo.code);
878         if (err)
879                 goto sigsegv;
880 
881         regs->u_regs[UREG_FP] = (unsigned long) sfp;
882         regs->pc = (unsigned long) sa->sa_handler;
883         regs->npc = (regs->pc + 4);
884 
885 #ifdef DEBUG_SIGNALS
886         printk ("Solaris-frame: %x %x\n", (int) regs->pc, (int) regs->npc);
887 #endif
888         /* Arguments passed to signal handler */
889         if (regs->u_regs [14]){
890                 struct reg_window *rw = (struct reg_window *) regs->u_regs [14];
891 
892                 err |= __put_user(signr, &rw->ins [0]);
893                 err |= __put_user(si, &rw->ins [1]);
894                 err |= __put_user(uc, &rw->ins [2]);
895                 err |= __put_user(sfp, &rw->ins [6]);   /* frame pointer */
896                 if (err)
897                         goto sigsegv;
898 
899                 regs->u_regs[UREG_I0] = signr;
900                 regs->u_regs[UREG_I1] = (uint) si;
901                 regs->u_regs[UREG_I2] = (uint) uc;
902         }
903         return;
904 
905 sigill_and_return:
906         do_exit(SIGILL);
907 sigsegv:
908         do_exit(SIGSEGV);
909 }
910 
911 asmlinkage int svr4_getcontext (svr4_ucontext_t *uc, struct pt_regs *regs)
912 {
913         svr4_gregset_t  *gr;
914         svr4_mcontext_t *mc;
915         svr4_sigset_t   setv;
916         int err = 0;
917 
918         synchronize_user_stack();
919 
920         if (current->thread.w_saved)
921                 goto sigsegv_and_return;
922 
923         err = clear_user(uc, sizeof (*uc));
924         if (err)
925                 return -EFAULT;
926 
927         /* Setup convenience variables */
928         mc = &uc->mcontext;
929         gr = &mc->greg;
930 
931         setv.sigbits[0] = current->blocked.sig[0];
932         setv.sigbits[1] = current->blocked.sig[1];
933         if (_NSIG_WORDS >= 4) {
934                 setv.sigbits[2] = current->blocked.sig[2];
935                 setv.sigbits[3] = current->blocked.sig[3];
936                 err |= __copy_to_user(&uc->sigmask, &setv, sizeof(svr4_sigset_t));
937         } else
938                 err |= __copy_to_user(&uc->sigmask, &setv, 2 * sizeof(unsigned int));
939 
940         /* Store registers */
941         err |= __put_user(regs->pc, &uc->mcontext.greg [SVR4_PC]);
942         err |= __put_user(regs->npc, &uc->mcontext.greg [SVR4_NPC]);
943         err |= __put_user(regs->psr, &uc->mcontext.greg [SVR4_PSR]);
944         err |= __put_user(regs->y, &uc->mcontext.greg [SVR4_Y]);
945         
946         /* Copy g [1..7] and o [0..7] registers */
947         err |= __copy_to_user(&(*gr)[SVR4_G1], &regs->u_regs [UREG_G1], sizeof (uint) * 7);
948         err |= __copy_to_user(&(*gr)[SVR4_O0], &regs->u_regs [UREG_I0], sizeof (uint) * 8);
949 
950         /* Setup sigaltstack */
951         err |= __put_user(current->sas_ss_sp, &uc->stack.sp);
952         err |= __put_user(sas_ss_flags(regs->u_regs[UREG_FP]), &uc->stack.flags);
953         err |= __put_user(current->sas_ss_size, &uc->stack.size);
954 
955         /* The register file is not saved
956          * we have already stuffed all of it with sync_user_stack
957          */
958         return (err ? -EFAULT : 0);
959 
960 sigsegv_and_return:
961         do_exit(SIGSEGV);
962 }
963 
964 /* Set the context for a svr4 application, this is Solaris way to sigreturn */
965 asmlinkage int svr4_setcontext (svr4_ucontext_t *c, struct pt_regs *regs)
966 {
967         struct thread_struct *tp = &current->thread;
968         svr4_gregset_t  *gr;
969         unsigned long pc, npc, psr;
970         sigset_t set;
971         svr4_sigset_t setv;
972         int err;
973         stack_t st;
974         
975         /* Fixme: restore windows, or is this already taken care of in
976          * svr4_setup_frame when sync_user_windows is done?
977          */
978         flush_user_windows();
979         
980         if (tp->w_saved)
981                 goto sigsegv_and_return;
982 
983         if (((uint) c) & 3)
984                 goto sigsegv_and_return;
985 
986         if(!__access_ok((unsigned long)c, sizeof(*c)))
987                 goto sigsegv_and_return;
988 
989         /* Check for valid PC and nPC */
990         gr = &c->mcontext.greg;
991         err = __get_user(pc, &((*gr)[SVR4_PC]));
992         err |= __get_user(npc, &((*gr)[SVR4_NPC]));
993 
994         if((pc | npc) & 3)
995                 goto sigsegv_and_return;
996 
997         /* Retrieve information from passed ucontext */
998         /* note that nPC is ored a 1, this is used to inform entry.S */
999         /* that we don't want it to mess with our PC and nPC */
1000 
1001         /* This is pretty much atomic, no amount locking would prevent
1002          * the races which exist anyways.
1003          */
1004         err |= __copy_from_user(&setv, &c->sigmask, sizeof(svr4_sigset_t));
1005         
1006         err |= __get_user(st.ss_sp, &c->stack.sp);
1007         err |= __get_user(st.ss_flags, &c->stack.flags);
1008         err |= __get_user(st.ss_size, &c->stack.size);
1009         
1010         if (err)
1011                 goto sigsegv_and_return;
1012                 
1013         /* It is more difficult to avoid calling this function than to
1014            call it and ignore errors.  */
1015         do_sigaltstack(&st, NULL, regs->u_regs[UREG_I6]);
1016         
1017         set.sig[0] = setv.sigbits[0];
1018         set.sig[1] = setv.sigbits[1];
1019         if (_NSIG_WORDS >= 4) {
1020                 set.sig[2] = setv.sigbits[2];
1021                 set.sig[3] = setv.sigbits[3];
1022         }
1023         sigdelsetmask(&set, ~_BLOCKABLE);
1024         spin_lock_irq(&current->sigmask_lock);
1025         current->blocked = set;
1026         recalc_sigpending(current);
1027         spin_unlock_irq(&current->sigmask_lock);
1028         regs->pc = pc;
1029         regs->npc = npc | 1;
1030         err |= __get_user(regs->y, &((*gr) [SVR4_Y]));
1031         err |= __get_user(psr, &((*gr) [SVR4_PSR]));
1032         regs->psr &= ~(PSR_ICC);
1033         regs->psr |= (psr & PSR_ICC);
1034 
1035         /* Restore g[1..7] and o[0..7] registers */
1036         err |= __copy_from_user(&regs->u_regs [UREG_G1], &(*gr)[SVR4_G1],
1037                               sizeof (long) * 7);
1038         err |= __copy_from_user(&regs->u_regs [UREG_I0], &(*gr)[SVR4_O0],
1039                               sizeof (long) * 8);
1040         return (err ? -EFAULT : 0);
1041 
1042 sigsegv_and_return:
1043         do_exit(SIGSEGV);
1044 }
1045 
1046 static inline void
1047 handle_signal(unsigned long signr, struct k_sigaction *ka,
1048               siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1049               int svr4_signal)
1050 {
1051         if (svr4_signal)
1052                 setup_svr4_frame(&ka->sa, regs->pc, regs->npc, regs, signr, oldset);
1053         else {
1054                 if (ka->sa.sa_flags & SA_SIGINFO)
1055                         new_setup_rt_frame(ka, regs, signr, oldset, info);
1056                 else if (current->thread.new_signal)
1057                         new_setup_frame (ka, regs, signr, oldset);
1058                 else
1059                         setup_frame(&ka->sa, regs, signr, oldset, info);
1060         }
1061         if(ka->sa.sa_flags & SA_ONESHOT)
1062                 ka->sa.sa_handler = SIG_DFL;
1063         if(!(ka->sa.sa_flags & SA_NOMASK)) {
1064                 spin_lock_irq(&current->sigmask_lock);
1065                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
1066                 sigaddset(&current->blocked, signr);
1067                 recalc_sigpending(current);
1068                 spin_unlock_irq(&current->sigmask_lock);
1069         }
1070 }
1071 
1072 static inline void syscall_restart(unsigned long orig_i0, struct pt_regs *regs,
1073                                    struct sigaction *sa)
1074 {
1075         switch(regs->u_regs[UREG_I0]) {
1076                 case ERESTARTNOHAND:
1077                 no_system_call_restart:
1078                         regs->u_regs[UREG_I0] = EINTR;
1079                         regs->psr |= PSR_C;
1080                         break;
1081                 case ERESTARTSYS:
1082                         if(!(sa->sa_flags & SA_RESTART))
1083                                 goto no_system_call_restart;
1084                 /* fallthrough */
1085                 case ERESTARTNOINTR:
1086                         regs->u_regs[UREG_I0] = orig_i0;
1087                         regs->pc -= 4;
1088                         regs->npc -= 4;
1089         }
1090 }
1091 
1092 #ifdef DEBUG_SIGNALS_MAPS
1093 
1094 #define MAPS_LINE_FORMAT          "%08lx-%08lx %s %08lx %s %lu "
1095 
1096 static inline void read_maps (void)
1097 {
1098         struct vm_area_struct * map, * next;
1099         char * buffer;
1100         ssize_t i;
1101 
1102         buffer = (char*)__get_free_page(GFP_KERNEL);
1103         if (!buffer)
1104                 return;
1105 
1106         for (map = current->mm->mmap ; map ; map = next ) {
1107                 /* produce the next line */
1108                 char *line;
1109                 char str[5], *cp = str;
1110                 int flags;
1111                 kdev_t dev;
1112                 unsigned long ino;
1113 
1114                 /*
1115                  * Get the next vma now (but it won't be used if we sleep).
1116                  */
1117                 next = map->vm_next;
1118                 flags = map->vm_flags;
1119 
1120                 *cp++ = flags & VM_READ ? 'r' : '-';
1121                 *cp++ = flags & VM_WRITE ? 'w' : '-';
1122                 *cp++ = flags & VM_EXEC ? 'x' : '-';
1123                 *cp++ = flags & VM_MAYSHARE ? 's' : 'p';
1124                 *cp++ = 0;
1125 
1126                 dev = 0;
1127                 ino = 0;
1128                 if (map->vm_file != NULL) {
1129                         dev = map->vm_file->f_dentry->d_inode->i_dev;
1130                         ino = map->vm_file->f_dentry->d_inode->i_ino;
1131                         line = d_path(map->vm_file->f_dentry,
1132                                       map->vm_file->f_vfsmnt,
1133                                       buffer, PAGE_SIZE);
1134                         if (IS_ERR(line))
1135                                 break;
1136                 }
1137                 printk(MAPS_LINE_FORMAT, map->vm_start, map->vm_end, str, map->vm_pgoff << PAGE_SHIFT,
1138                               kdevname(dev), ino);
1139                 if (map->vm_file != NULL)
1140                         printk("%s\n", line);
1141                 else
1142                         printk("\n");
1143         }
1144         free_page((unsigned long)buffer);
1145         return;
1146 }
1147 #endif
1148 
1149 /* Note that 'init' is a special process: it doesn't get signals it doesn't
1150  * want to handle. Thus you cannot kill init even with a SIGKILL even by
1151  * mistake.
1152  */
1153 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs * regs,
1154                          unsigned long orig_i0, int restart_syscall)
1155 {
1156         unsigned long signr;
1157         struct k_sigaction *ka;
1158         siginfo_t info;
1159 
1160         /*
1161          * XXX Disable svr4 signal handling until solaris emulation works.
1162          * It is buggy - Anton
1163          */
1164 #define SVR4_SIGNAL_BROKEN 1
1165 #ifdef SVR4_SIGNAL_BROKEN
1166         int svr4_signal = 0;
1167 #else
1168         int svr4_signal = current->personality == PER_SVR4;
1169 #endif
1170 
1171         if (!oldset)
1172                 oldset = &current->blocked;
1173 
1174         for (;;) {
1175                 spin_lock_irq(&current->sigmask_lock);
1176                 signr = dequeue_signal(&current->blocked, &info);
1177                 spin_unlock_irq(&current->sigmask_lock);
1178 
1179                 if (!signr)
1180                         break;
1181 
1182                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1183                         /* Do the syscall restart before we let the debugger
1184                          * look at the child registers.
1185                          */
1186                         if (restart_syscall &&
1187                             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1188                              regs->u_regs[UREG_I0] == ERESTARTSYS ||
1189                              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1190                                 regs->u_regs[UREG_I0] = orig_i0;
1191                                 regs->pc -= 4;
1192                                 regs->npc -= 4;
1193                                 restart_syscall = 0;
1194                         }
1195                         current->exit_code = signr;
1196                         current->state = TASK_STOPPED;
1197 
1198                         /* This happens to be SMP safe so no need to
1199                          * grab master kernel lock even in this case.
1200                          */
1201                         notify_parent(current, SIGCHLD);
1202                         schedule();
1203                         if (!(signr = current->exit_code))
1204                                 continue;
1205                         current->exit_code = 0;
1206                         if (signr == SIGSTOP)
1207                                 continue;
1208 
1209                         /* Update the siginfo structure.  Is this good?  */
1210                         if (signr != info.si_signo) {
1211                                 info.si_signo = signr;
1212                                 info.si_errno = 0;
1213                                 info.si_code = SI_USER;
1214                                 info.si_pid = current->p_pptr->pid;
1215                                 info.si_uid = current->p_pptr->uid;
1216                         }
1217 
1218                         /* If the (new) signal is now blocked, requeue it.  */
1219                         if (sigismember(&current->blocked, signr)) {
1220                                 send_sig_info(signr, &info, current);
1221                                 continue;
1222                         }
1223                 }
1224 
1225                 ka = &current->sig->action[signr-1];
1226 
1227                 if (ka->sa.sa_handler == SIG_IGN) {
1228                         if (signr != SIGCHLD)
1229                                 continue;
1230 
1231                         /* sys_wait4() grabs the master kernel lock, so
1232                          * we need not do so, that sucker should be
1233                          * threaded and would not be that difficult to
1234                          * do anyways.
1235                          */
1236                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
1237                                 ;
1238                         continue;
1239                 }
1240                 if (ka->sa.sa_handler == SIG_DFL) {
1241                         unsigned long exit_code = signr;
1242 
1243                         if (current->pid == 1)
1244                                 continue;
1245                         switch (signr) {
1246                         case SIGCONT: case SIGCHLD: case SIGWINCH: case SIGURG:
1247                                 continue;
1248 
1249                         case SIGTSTP: case SIGTTIN: case SIGTTOU:
1250                                 /* The operations performed by
1251                                  * is_orphaned_pgrp() are protected by
1252                                  * the tasklist_lock.
1253                                  */
1254                                 if (is_orphaned_pgrp(current->pgrp))
1255                                         continue;
1256 
1257                         case SIGSTOP:
1258                                 if (current->ptrace & PT_PTRACED)
1259                                         continue;
1260                                 current->state = TASK_STOPPED;
1261                                 current->exit_code = signr;
1262 
1263                                 /* notify_parent() is SMP safe */
1264                                 if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags &
1265                                       SA_NOCLDSTOP))
1266                                         notify_parent(current, SIGCHLD);
1267                                 schedule();
1268                                 continue;
1269 
1270                         case SIGQUIT: case SIGILL: case SIGTRAP:
1271                         case SIGABRT: case SIGFPE: case SIGSEGV:
1272                         case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
1273                                 if (do_coredump(signr, regs))
1274                                         exit_code |= 0x80;
1275 #ifdef DEBUG_SIGNALS
1276                                 /* Very useful to debug dynamic linker problems */
1277                                 printk ("Sig %ld going for %s[%d]...\n", signr, current->comm, current->pid);
1278                                 show_regs (regs);
1279 #ifdef DEBUG_SIGNALS_TRACE
1280                                 {
1281                                         struct reg_window *rw = (struct reg_window *)regs->u_regs[UREG_FP];
1282                                         unsigned int ins[8];
1283 
1284                                         while (rw &&
1285                                                !(((unsigned long) rw) & 0x3)) {
1286                                                 copy_from_user(ins, &rw->ins[0], sizeof(ins));
1287                                                 printk("Caller[%08x](%08x,%08x,%08x,%08x,%08x,%08x)\n", ins[7], ins[0], ins[1], ins[2], ins[3], ins[4], ins[5]);
1288                                                 rw = (struct reg_window *)(unsigned long)ins[6];
1289                                         }
1290                                 }
1291 #endif
1292 #ifdef DEBUG_SIGNALS_MAPS
1293                                 printk("Maps:\n");
1294                                 read_maps();
1295 #endif
1296 #endif
1297                                 /* fall through */
1298                         default:
1299                                 sigaddset(&current->pending.signal, signr);
1300                                 recalc_sigpending(current);
1301                                 current->flags |= PF_SIGNALED;
1302                                 do_exit(exit_code);
1303                                 /* NOT REACHED */
1304                         }
1305                 }
1306                 if (restart_syscall)
1307                         syscall_restart(orig_i0, regs, &ka->sa);
1308                 handle_signal(signr, ka, &info, oldset, regs, svr4_signal);
1309                 return 1;
1310         }
1311         if (restart_syscall &&
1312             (regs->u_regs[UREG_I0] == ERESTARTNOHAND ||
1313              regs->u_regs[UREG_I0] == ERESTARTSYS ||
1314              regs->u_regs[UREG_I0] == ERESTARTNOINTR)) {
1315                 /* replay the system call when we are done */
1316                 regs->u_regs[UREG_I0] = orig_i0;
1317                 regs->pc -= 4;
1318                 regs->npc -= 4;
1319         }
1320         return 0;
1321 }
1322 
1323 asmlinkage int
1324 do_sys_sigstack(struct sigstack *ssptr, struct sigstack *ossptr, unsigned long sp)
1325 {
1326         int ret = -EFAULT;
1327 
1328         /* First see if old state is wanted. */
1329         if (ossptr) {
1330                 if (put_user(current->sas_ss_sp + current->sas_ss_size, &ossptr->the_stack) ||
1331                     __put_user(on_sig_stack(sp), &ossptr->cur_status))
1332                         goto out;
1333         }
1334 
1335         /* Now see if we want to update the new state. */
1336         if (ssptr) {
1337                 void *ss_sp;
1338 
1339                 if (get_user(ss_sp, &ssptr->the_stack))
1340                         goto out;
1341                 /* If the current stack was set with sigaltstack, don't
1342                    swap stacks while we are on it.  */
1343                 ret = -EPERM;
1344                 if (current->sas_ss_sp && on_sig_stack(sp))
1345                         goto out;
1346 
1347                 /* Since we don't know the extent of the stack, and we don't
1348                    track onstack-ness, but rather calculate it, we must
1349                    presume a size.  Ho hum this interface is lossy.  */
1350                 current->sas_ss_sp = (unsigned long)ss_sp - SIGSTKSZ;
1351                 current->sas_ss_size = SIGSTKSZ;
1352         }
1353         ret = 0;
1354 out:
1355         return ret;
1356 }
1357 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp