PPC32: This changeset adds preemptible kernel support for ppc32
[opensuse:kernel.git] / arch / ppc / kernel / signal.c
1 /*
2  * BK Id: %F% %I% %G% %U% %#%
3  */
4 /*
5  *  linux/arch/ppc/kernel/signal.c
6  *
7  *  PowerPC version 
8  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
9  *
10  *  Derived from "arch/i386/kernel/signal.c"
11  *    Copyright (C) 1991, 1992 Linus Torvalds
12  *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson
13  *
14  *  This program is free software; you can redistribute it and/or
15  *  modify it under the terms of the GNU General Public License
16  *  as published by the Free Software Foundation; either version
17  *  2 of the License, or (at your option) any later version.
18  */
19
20 #include <linux/sched.h>
21 #include <linux/mm.h>
22 #include <linux/smp.h>
23 #include <linux/smp_lock.h>
24 #include <linux/kernel.h>
25 #include <linux/signal.h>
26 #include <linux/errno.h>
27 #include <linux/wait.h>
28 #include <linux/ptrace.h>
29 #include <linux/unistd.h>
30 #include <linux/stddef.h>
31 #include <linux/elf.h>
32 #include <linux/tty.h>
33 #include <linux/binfmts.h>
34 #include <asm/ucontext.h>
35 #include <asm/uaccess.h>
36 #include <asm/pgtable.h>
37 #include <asm/cacheflush.h>
38
39 #define DEBUG_SIG 0
40
41 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
42
43 #ifndef MIN
44 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
45 #endif
46
47 extern void sigreturn_exit(struct pt_regs *);
48
49 #define GP_REGS_SIZE    MIN(sizeof(elf_gregset_t), sizeof(struct pt_regs))
50
51 /* 
52  * These are the flags in the MSR that the user is allowed to change
53  * by modifying the saved value of the MSR on the stack.  SE and BE
54  * should not be in this list since gdb may want to change these.  I.e,
55  * you should be able to step out of a signal handler to see what
56  * instruction executes next after the signal handler completes.
57  * Alternately, if you stepped into a signal handler, you should be
58  * able to continue 'til the next breakpoint from within the signal
59  * handler, even if the handler returns.
60  */
61 #define MSR_USERCHANGE  (MSR_FE0 | MSR_FE1)
62
63 int do_signal(sigset_t *oldset, struct pt_regs *regs);
64
65 int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
66 {
67         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
68                 return -EFAULT;
69         if (from->si_code < 0)
70                 return __copy_to_user(to, from, sizeof(siginfo_t));
71         else {
72                 int err;
73
74                 /* If you change siginfo_t structure, please be sure
75                    this code is fixed accordingly.
76                    It should never copy any pad contained in the structure
77                    to avoid security leaks, but must copy the generic
78                    3 ints plus the relevant union member.  */
79                 err = __put_user(from->si_signo, &to->si_signo);
80                 err |= __put_user(from->si_errno, &to->si_errno);
81                 err |= __put_user((short)from->si_code, &to->si_code);
82                 /* First 32bits of unions are always present.  */
83                 err |= __put_user(from->si_pid, &to->si_pid);
84                 switch (from->si_code >> 16) {
85                 case __SI_FAULT >> 16:
86                         break;
87                 case __SI_CHLD >> 16:
88                         err |= __put_user(from->si_utime, &to->si_utime);
89                         err |= __put_user(from->si_stime, &to->si_stime);
90                         err |= __put_user(from->si_status, &to->si_status);
91                 default:
92                         err |= __put_user(from->si_uid, &to->si_uid);
93                         break;
94                 /* case __SI_RT: This is not generated by the kernel as of now.  */
95                 }
96                 return err;
97         }
98 }
99
100 /*
101  * Atomically swap in the new signal mask, and wait for a signal.
102  */
103 int
104 sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
105                struct pt_regs *regs)
106 {
107         sigset_t saveset;
108
109         mask &= _BLOCKABLE;
110         spin_lock_irq(&current->sigmask_lock);
111         saveset = current->blocked;
112         siginitset(&current->blocked, mask);
113         recalc_sigpending();
114         spin_unlock_irq(&current->sigmask_lock);
115
116         regs->result = -EINTR;
117         regs->ccr |= 0x10000000;
118         regs->gpr[3] = EINTR;
119         while (1) {
120                 current->state = TASK_INTERRUPTIBLE;
121                 schedule();
122                 if (do_signal(&saveset, regs))
123                         sigreturn_exit(regs);
124         }
125 }
126
127 int
128 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, int p3, int p4, int p6,
129                   int p7, struct pt_regs *regs)
130 {
131         sigset_t saveset, newset;
132
133         /* XXX: Don't preclude handling different sized sigset_t's.  */
134         if (sigsetsize != sizeof(sigset_t))
135                 return -EINVAL;
136
137         if (copy_from_user(&newset, unewset, sizeof(newset)))
138                 return -EFAULT;
139         sigdelsetmask(&newset, ~_BLOCKABLE);
140
141         spin_lock_irq(&current->sigmask_lock);
142         saveset = current->blocked;
143         current->blocked = newset;
144         recalc_sigpending();
145         spin_unlock_irq(&current->sigmask_lock);
146
147         regs->result = -EINTR;
148         regs->ccr |= 0x10000000;
149         regs->gpr[3] = EINTR;
150         while (1) {
151                 current->state = TASK_INTERRUPTIBLE;
152                 schedule();
153                 if (do_signal(&saveset, regs))
154                         sigreturn_exit(regs);
155         }
156 }
157
158
159 int
160 sys_sigaltstack(const stack_t *uss, stack_t *uoss, int r5, int r6,
161                 int r7, int r8, struct pt_regs *regs)
162 {
163         return do_sigaltstack(uss, uoss, regs->gpr[1]);
164 }
165
166 int 
167 sys_sigaction(int sig, const struct old_sigaction *act,
168               struct old_sigaction *oact)
169 {
170         struct k_sigaction new_ka, old_ka;
171         int ret;
172
173         if (act) {
174                 old_sigset_t mask;
175                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
176                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
177                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
178                         return -EFAULT;
179                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
180                 __get_user(mask, &act->sa_mask);
181                 siginitset(&new_ka.sa.sa_mask, mask);
182         }
183
184         ret = do_sigaction(sig, (act? &new_ka: NULL), (oact? &old_ka: NULL));
185
186         if (!ret && oact) {
187                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
188                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
189                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
190                         return -EFAULT;
191                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
192                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
193         }
194
195         return ret;
196 }
197
198 /*
199  * When we have signals to deliver, we set up on the
200  * user stack, going down from the original stack pointer:
201  *      a sigregs struct
202  *      one or more sigcontext structs with
203  *      a gap of __SIGNAL_FRAMESIZE bytes
204  *
205  * Each of these things must be a multiple of 16 bytes in size.
206  *
207  */
208 struct sigregs {
209         elf_gregset_t   gp_regs;
210         double          fp_regs[ELF_NFPREG];
211         unsigned long   tramp[2];
212         /* Programs using the rs6000/xcoff abi can save up to 19 gp regs
213            and 18 fp regs below sp before decrementing it. */
214         int             abigap[56];
215 };
216
217 struct rt_sigframe
218 {
219         unsigned long   _unused[2];
220         struct siginfo *pinfo;
221         void *puc;
222         struct siginfo info;
223         struct ucontext uc;
224 };
225
226
227 /*
228  *  When we have rt signals to deliver, we set up on the
229  *  user stack, going down from the original stack pointer:
230  *         a sigregs struct
231  *         one rt_sigframe struct (siginfo + ucontext)
232  *         a gap of __SIGNAL_FRAMESIZE bytes
233  *
234  *  Each of these things must be a multiple of 16 bytes in size.
235  *
236  */
237 int sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
238                      struct pt_regs *regs)
239 {
240         struct rt_sigframe *rt_sf;
241         struct sigcontext_struct sigctx;
242         struct sigregs *sr;
243         elf_gregset_t saved_regs;  /* an array of ELF_NGREG unsigned longs */
244         sigset_t set;
245         stack_t st;
246
247         rt_sf = (struct rt_sigframe *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
248         if (copy_from_user(&sigctx, &rt_sf->uc.uc_mcontext, sizeof(sigctx))
249             || copy_from_user(&set, &rt_sf->uc.uc_sigmask, sizeof(set))
250             || copy_from_user(&st, &rt_sf->uc.uc_stack, sizeof(st)))
251                 goto badframe;
252         sigdelsetmask(&set, ~_BLOCKABLE);
253         spin_lock_irq(&current->sigmask_lock);
254         current->blocked = set;
255         recalc_sigpending();
256         spin_unlock_irq(&current->sigmask_lock);
257         if (regs->msr & MSR_FP)
258                 giveup_fpu(current);
259
260         /* restore registers -
261          * sigctx is initialized to point to the 
262          * preamble frame (where registers are stored) 
263          * see handle_signal()
264          */
265         sr = (struct sigregs *) sigctx.regs;
266         if (copy_from_user(saved_regs, &sr->gp_regs, sizeof(sr->gp_regs)))
267                 goto badframe;
268         saved_regs[PT_MSR] = (regs->msr & ~MSR_USERCHANGE)
269                 | (saved_regs[PT_MSR] & MSR_USERCHANGE);
270         memcpy(regs, saved_regs, GP_REGS_SIZE);
271         if (copy_from_user(current->thread.fpr, &sr->fp_regs,
272                            sizeof(sr->fp_regs)))
273                 goto badframe;
274         /* This function sets back the stack flags into
275            the current task structure.  */
276         sys_sigaltstack(&st, NULL, 0, 0, 0, 0, regs);
277
278         sigreturn_exit(regs);           /* doesn't return here */
279         return 0;
280
281 badframe:
282         do_exit(SIGSEGV);
283 }
284
285 static void
286 setup_rt_frame(struct pt_regs *regs, struct sigregs *frame,
287                signed long newsp)
288 {
289         struct rt_sigframe *rt_sf = (struct rt_sigframe *) newsp;
290
291         /* Set up preamble frame */
292         if (verify_area(VERIFY_WRITE, frame, sizeof(*frame)))
293                 goto badframe;
294         CHECK_FULL_REGS(regs);
295         if (regs->msr & MSR_FP)
296                 giveup_fpu(current);
297         if (__copy_to_user(&frame->gp_regs, regs, GP_REGS_SIZE)
298             || __copy_to_user(&frame->fp_regs, current->thread.fpr,
299                               ELF_NFPREG * sizeof(double))
300         /* Set up to return from user space.
301            It calls the sc exception at offset 0x9999 
302            for sys_rt_sigreturn().
303         */
304             || __put_user(0x38000000UL + __NR_rt_sigreturn, &frame->tramp[0])
305             || __put_user(0x44000002UL, &frame->tramp[1]))      /* sc */
306                 goto badframe;
307         flush_icache_range((unsigned long) &frame->tramp[0],
308                            (unsigned long) &frame->tramp[2]);
309         current->thread.fpscr = 0;      /* turn off all fp exceptions */
310
311         /* Retrieve rt_sigframe from stack and
312            set up registers for signal handler
313         */
314         newsp -= __SIGNAL_FRAMESIZE;
315         if (put_user(regs->gpr[1], (unsigned long *)newsp)
316             || get_user(regs->nip, &rt_sf->uc.uc_mcontext.handler)
317             || get_user(regs->gpr[3], &rt_sf->uc.uc_mcontext.signal)
318             || get_user(regs->gpr[4], (unsigned long *)&rt_sf->pinfo)
319             || get_user(regs->gpr[5], (unsigned long *)&rt_sf->puc))
320                 goto badframe;
321
322         regs->gpr[1] = newsp;
323         regs->gpr[6] = (unsigned long) rt_sf;
324         regs->link = (unsigned long) frame->tramp;
325
326         return;
327
328 badframe:
329 #if DEBUG_SIG
330         printk("badframe in setup_rt_frame, regs=%p frame=%p newsp=%lx\n",
331                regs, frame, newsp);
332 #endif
333         do_exit(SIGSEGV);
334 }
335
336 /*
337  * Do a signal return; undo the signal stack.
338  */
339 int sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
340                   struct pt_regs *regs)
341 {
342         struct sigcontext_struct *sc, sigctx;
343         struct sigregs *sr;
344         elf_gregset_t saved_regs;  /* an array of ELF_NGREG unsigned longs */
345         sigset_t set;
346
347         sc = (struct sigcontext_struct *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
348         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
349                 goto badframe;
350
351         set.sig[0] = sigctx.oldmask;
352 #if _NSIG_WORDS > 1
353         set.sig[1] = sigctx._unused[3];
354 #endif
355         sigdelsetmask(&set, ~_BLOCKABLE);
356         spin_lock_irq(&current->sigmask_lock);
357         current->blocked = set;
358         recalc_sigpending();
359         spin_unlock_irq(&current->sigmask_lock);
360         if (regs->msr & MSR_FP )
361                 giveup_fpu(current);
362
363         /* restore registers */
364         sr = (struct sigregs *) sigctx.regs;
365         if (copy_from_user(saved_regs, &sr->gp_regs, sizeof(sr->gp_regs)))
366                 goto badframe;
367         saved_regs[PT_MSR] = (regs->msr & ~MSR_USERCHANGE)
368                 | (saved_regs[PT_MSR] & MSR_USERCHANGE);
369         memcpy(regs, saved_regs, GP_REGS_SIZE);
370
371         if (copy_from_user(current->thread.fpr, &sr->fp_regs,
372                            sizeof(sr->fp_regs)))
373                 goto badframe;
374
375         sigreturn_exit(regs);           /* doesn't return here */
376         return 0;
377
378 badframe:
379         do_exit(SIGSEGV);
380 }       
381
382 /*
383  * Set up a signal frame.
384  */
385 static void
386 setup_frame(struct pt_regs *regs, struct sigregs *frame,
387             unsigned long newsp)
388 {
389         struct sigcontext_struct *sc = (struct sigcontext_struct *) newsp;
390
391         if (verify_area(VERIFY_WRITE, frame, sizeof(*frame)))
392                 goto badframe;
393         CHECK_FULL_REGS(regs);
394         if (regs->msr & MSR_FP)
395                 giveup_fpu(current);
396         if (__copy_to_user(&frame->gp_regs, regs, GP_REGS_SIZE)
397             || __copy_to_user(&frame->fp_regs, current->thread.fpr,
398                               ELF_NFPREG * sizeof(double))
399             || __put_user(0x38000000UL + __NR_sigreturn, &frame->tramp[0])
400             || __put_user(0x44000002UL, &frame->tramp[1]))   /* sc */
401                 goto badframe;
402         flush_icache_range((unsigned long) &frame->tramp[0],
403                            (unsigned long) &frame->tramp[2]);
404         current->thread.fpscr = 0;      /* turn off all fp exceptions */
405
406         newsp -= __SIGNAL_FRAMESIZE;
407         if (put_user(regs->gpr[1], (unsigned long *)newsp)
408             || get_user(regs->nip, &sc->handler)
409             || get_user(regs->gpr[3], &sc->signal))
410                 goto badframe;
411         regs->gpr[1] = newsp;
412         regs->gpr[4] = (unsigned long) sc;
413         regs->link = (unsigned long) frame->tramp;
414
415         return;
416
417 badframe:
418 #if DEBUG_SIG
419         printk("badframe in setup_frame, regs=%p frame=%p newsp=%lx\n",
420                regs, frame, newsp);
421 #endif
422         do_exit(SIGSEGV);
423 }
424
425 /*
426  * OK, we're invoking a handler
427  */
428 static void
429 handle_signal(unsigned long sig, struct k_sigaction *ka,
430               siginfo_t *info, sigset_t *oldset, struct pt_regs * regs,
431               unsigned long *newspp, unsigned long frame)
432 {
433         struct sigcontext_struct *sc;
434         struct rt_sigframe *rt_sf;
435
436         if (TRAP(regs) == 0x0C00 /* System Call! */
437             && ((int)regs->result == -ERESTARTNOHAND ||
438                 ((int)regs->result == -ERESTARTSYS &&
439                  !(ka->sa.sa_flags & SA_RESTART)))) {
440                 regs->result = -EINTR;
441                 regs->gpr[3] = EINTR;
442                 regs->ccr |= 0x10000000;
443         }
444
445         /* Set up Signal Frame */
446         if (ka->sa.sa_flags & SA_SIGINFO) {
447                 /* Put a Real Time Context onto stack */
448                 *newspp -= sizeof(*rt_sf);
449                 rt_sf = (struct rt_sigframe *) *newspp;
450                 if (verify_area(VERIFY_WRITE, rt_sf, sizeof(*rt_sf)))
451                         goto badframe;
452
453                 if (__put_user((unsigned long) ka->sa.sa_handler, &rt_sf->uc.uc_mcontext.handler)
454                     || __put_user(&rt_sf->info, &rt_sf->pinfo)
455                     || __put_user(&rt_sf->uc, &rt_sf->puc)
456                     /* Put the siginfo */
457                     || __copy_to_user(&rt_sf->info, info, sizeof(*info))
458                     /* Create the ucontext */
459                     || __put_user(0, &rt_sf->uc.uc_flags)
460                     || __put_user(0, &rt_sf->uc.uc_link)
461                     || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
462                     || __put_user(sas_ss_flags(regs->gpr[1]), 
463                                   &rt_sf->uc.uc_stack.ss_flags)
464                     || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
465                     || __copy_to_user(&rt_sf->uc.uc_sigmask, oldset, sizeof(*oldset))
466                     /* mcontext.regs points to preamble register frame */
467                     || __put_user((struct pt_regs *)frame, &rt_sf->uc.uc_mcontext.regs)
468                     || __put_user(sig, &rt_sf->uc.uc_mcontext.signal))
469                         goto badframe;
470         } else {
471                 /* Put a sigcontext on the stack */
472                 *newspp -= sizeof(*sc);
473                 sc = (struct sigcontext_struct *) *newspp;
474                 if (verify_area(VERIFY_WRITE, sc, sizeof(*sc)))
475                         goto badframe;
476                 
477                 if (__put_user((unsigned long) ka->sa.sa_handler, &sc->handler)
478                     || __put_user(oldset->sig[0], &sc->oldmask)
479 #if _NSIG_WORDS > 1
480                     || __put_user(oldset->sig[1], &sc->_unused[3])
481 #endif
482                     || __put_user((struct pt_regs *)frame, &sc->regs)
483                     || __put_user(sig, &sc->signal))
484                         goto badframe;
485         }
486
487         if (ka->sa.sa_flags & SA_ONESHOT)
488                 ka->sa.sa_handler = SIG_DFL;
489
490         if (!(ka->sa.sa_flags & SA_NODEFER)) {
491                 spin_lock_irq(&current->sigmask_lock);
492                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
493                 sigaddset(&current->blocked,sig);
494                 recalc_sigpending();
495                 spin_unlock_irq(&current->sigmask_lock);
496         }
497         return;
498
499 badframe:
500 #if DEBUG_SIG
501         printk("badframe in handle_signal, regs=%p frame=%lx newsp=%lx\n",
502                regs, frame, *newspp);
503         printk("sc=%p sig=%d ka=%p info=%p oldset=%p\n", sc, sig, ka, info, oldset);
504 #endif
505         do_exit(SIGSEGV);
506 }
507
508 /*
509  * Note that 'init' is a special process: it doesn't get signals it doesn't
510  * want to handle. Thus you cannot kill init even with a SIGKILL even by
511  * mistake.
512  */
513 int do_signal(sigset_t *oldset, struct pt_regs *regs)
514 {
515         siginfo_t info;
516         struct k_sigaction *ka;
517         unsigned long frame, newsp;
518
519         if (!oldset)
520                 oldset = &current->blocked;
521
522         newsp = frame = 0;
523
524         for (;;) {
525                 unsigned long signr;
526
527                 spin_lock_irq(&current->sigmask_lock);
528                 signr = dequeue_signal(&current->blocked, &info);
529                 spin_unlock_irq(&current->sigmask_lock);
530
531                 if (!signr)
532                         break;
533
534                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
535                         /* Let the debugger run.  */
536                         current->exit_code = signr;
537                         current->state = TASK_STOPPED;
538                         notify_parent(current, SIGCHLD);
539                         schedule();
540
541                         /* We're back.  Did the debugger cancel the sig?  */
542                         if (!(signr = current->exit_code))
543                                 continue;
544                         current->exit_code = 0;
545
546                         /* The debugger continued.  Ignore SIGSTOP.  */
547                         if (signr == SIGSTOP)
548                                 continue;
549
550                         /* Update the siginfo structure.  Is this good?  */
551                         if (signr != info.si_signo) {
552                                 info.si_signo = signr;
553                                 info.si_errno = 0;
554                                 info.si_code = SI_USER;
555                                 info.si_pid = current->parent->pid;
556                                 info.si_uid = current->parent->uid;
557                         }
558
559                         /* If the (new) signal is now blocked, requeue it.  */
560                         if (sigismember(&current->blocked, signr)) {
561                                 send_sig_info(signr, &info, current);
562                                 continue;
563                         }
564                 }
565
566                 ka = &current->sig->action[signr-1];
567                 if (ka->sa.sa_handler == SIG_IGN) {
568                         if (signr != SIGCHLD)
569                                 continue;
570                         /* Check for SIGCHLD: it's special.  */
571                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
572                                 /* nothing */;
573                         continue;
574                 }
575
576                 if (ka->sa.sa_handler == SIG_DFL) {
577                         int exit_code = signr;
578
579                         /* Init gets no signals it doesn't want.  */
580                         if (current->pid == 1)
581                                 continue;
582
583                         switch (signr) {
584                         case SIGCONT: case SIGCHLD: case SIGWINCH:
585                                 continue;
586
587                         case SIGTSTP: case SIGTTIN: case SIGTTOU:
588                                 if (is_orphaned_pgrp(current->pgrp))
589                                         continue;
590                                 /* FALLTHRU */
591
592                         case SIGSTOP:
593                                 current->state = TASK_STOPPED;
594                                 current->exit_code = signr;
595                                 if (!(current->parent->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
596                                         notify_parent(current, SIGCHLD);
597                                 schedule();
598                                 continue;
599
600                         case SIGQUIT: case SIGILL: case SIGTRAP:
601                         case SIGABRT: case SIGFPE: case SIGSEGV:
602                         case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
603                                 if (do_coredump(signr, regs))
604                                         exit_code |= 0x80;
605                                 /* FALLTHRU */
606
607                         default:
608                                 sig_exit(signr, exit_code, &info);
609                                 /* NOTREACHED */
610                         }
611                 }
612
613                 if ( (ka->sa.sa_flags & SA_ONSTACK)
614                      && (! on_sig_stack(regs->gpr[1])))
615                         newsp = (current->sas_ss_sp + current->sas_ss_size);
616                 else
617                         newsp = regs->gpr[1];
618                 newsp = frame = newsp - sizeof(struct sigregs);
619
620                 /* Whee!  Actually deliver the signal.  */
621                 handle_signal(signr, ka, &info, oldset, regs, &newsp, frame);
622                 break;
623         }
624
625         if (TRAP(regs) == 0x0C00 /* System Call! */ &&
626             ((int)regs->result == -ERESTARTNOHAND ||
627              (int)regs->result == -ERESTARTSYS ||
628              (int)regs->result == -ERESTARTNOINTR)) {
629                 regs->gpr[3] = regs->orig_gpr3;
630                 regs->nip -= 4;         /* Back up & retry system call */
631                 regs->result = 0;
632         }
633
634         if (newsp == frame)
635                 return 0;               /* no signals delivered */
636
637         if (ka->sa.sa_flags & SA_SIGINFO)
638                 setup_rt_frame(regs, (struct sigregs *) frame, newsp);
639         else
640                 setup_frame(regs, (struct sigregs *) frame, newsp);
641         return 1;
642 }
643