f82544225e8e8b43b8ca76664101a849d1e8a7f7
[linux-2.6.git] / arch / parisc / kernel / signal.c
1 /*
2  *  linux/arch/parisc/kernel/signal.c: Architecture-specific signal
3  *  handling support.
4  *
5  *  Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
6  *  Copyright (C) 2000 Linuxcare, Inc.
7  *
8  *  Based on the ia64, i386, and alpha versions.
9  *
10  *  Like the IA-64, we are a recent enough port (we are *starting*
11  *  with glibc2.2) that we do not need to support the old non-realtime
12  *  Linux signals.  Therefore we don't.  HP/UX signals will go in
13  *  arch/parisc/hpux/signal.c when we figure out how to do them.
14  */
15
16 #include <linux/sched.h>
17 #include <linux/mm.h>
18 #include <linux/smp.h>
19 #include <linux/kernel.h>
20 #include <linux/signal.h>
21 #include <linux/errno.h>
22 #include <linux/wait.h>
23 #include <linux/ptrace.h>
24 #include <linux/unistd.h>
25 #include <linux/stddef.h>
26 #include <linux/compat.h>
27 #include <linux/elf.h>
28 #include <asm/ucontext.h>
29 #include <asm/rt_sigframe.h>
30 #include <asm/uaccess.h>
31 #include <asm/pgalloc.h>
32 #include <asm/cacheflush.h>
33 #include <asm/asm-offsets.h>
34
35 #ifdef CONFIG_COMPAT
36 #include <linux/compat.h>
37 #include "signal32.h"
38 #endif
39
40 #define DEBUG_SIG 0 
41 #define DEBUG_SIG_LEVEL 2
42
43 #if DEBUG_SIG
44 #define DBG(LEVEL, ...) \
45         ((DEBUG_SIG_LEVEL >= LEVEL) \
46         ? printk(__VA_ARGS__) : (void) 0)
47 #else
48 #define DBG(LEVEL, ...)
49 #endif
50         
51
52 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
53
54 /* gcc will complain if a pointer is cast to an integer of different
55  * size.  If you really need to do this (and we do for an ELF32 user
56  * application in an ELF64 kernel) then you have to do a cast to an
57  * integer of the same size first.  The A() macro accomplishes
58  * this. */
59 #define A(__x)  ((unsigned long)(__x))
60
61 /*
62  * Atomically swap in the new signal mask, and wait for a signal.
63  */
64 #ifdef CONFIG_64BIT
65 #include "sys32.h"
66 #endif
67
68 /*
69  * Do a signal return - restore sigcontext.
70  */
71
72 /* Trampoline for calling rt_sigreturn() */
73 #define INSN_LDI_R25_0   0x34190000 /* ldi  0,%r25 (in_syscall=0) */
74 #define INSN_LDI_R25_1   0x34190002 /* ldi  1,%r25 (in_syscall=1) */
75 #define INSN_LDI_R20     0x3414015a /* ldi  __NR_rt_sigreturn,%r20 */
76 #define INSN_BLE_SR2_R0  0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
77 #define INSN_NOP         0x08000240 /* nop */
78 /* For debugging */
79 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
80
81 static long
82 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
83 {
84         long err = 0;
85
86         err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
87         err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
88         err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
89         err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
90         err |= __get_user(regs->sar, &sc->sc_sar);
91         DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n", 
92                         regs->iaoq[0],regs->iaoq[1]);
93         DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
94         return err;
95 }
96
97 void
98 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
99 {
100         struct rt_sigframe __user *frame;
101         struct siginfo si;
102         sigset_t set;
103         unsigned long usp = (regs->gr[30] & ~(0x01UL));
104         unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
105 #ifdef CONFIG_64BIT
106         compat_sigset_t compat_set;
107         struct compat_rt_sigframe __user * compat_frame;
108         
109         if (is_compat_task())
110                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
111 #endif
112
113
114         /* Unwind the user stack to get the rt_sigframe structure. */
115         frame = (struct rt_sigframe __user *)
116                 (usp - sigframe_size);
117         DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
118
119 #ifdef CONFIG_64BIT
120         compat_frame = (struct compat_rt_sigframe __user *)frame;
121         
122         if (is_compat_task()) {
123                 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
124                 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
125                         goto give_sigsegv;
126                 sigset_32to64(&set,&compat_set);
127         } else
128 #endif
129         {
130                 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
131                         goto give_sigsegv;
132         }
133                 
134         sigdelsetmask(&set, ~_BLOCKABLE);
135         spin_lock_irq(&current->sighand->siglock);
136         current->blocked = set;
137         recalc_sigpending();
138         spin_unlock_irq(&current->sighand->siglock);
139
140         /* Good thing we saved the old gr[30], eh? */
141 #ifdef CONFIG_64BIT
142         if (is_compat_task()) {
143                 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
144                                 &compat_frame->uc.uc_mcontext);
145 // FIXME: Load upper half from register file
146                 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext, 
147                                         &compat_frame->regs, regs))
148                         goto give_sigsegv;
149                 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
150                                 usp, &compat_frame->uc.uc_stack);
151                 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT)
152                         goto give_sigsegv;
153         } else
154 #endif
155         {
156                 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
157                                 &frame->uc.uc_mcontext);
158                 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
159                         goto give_sigsegv;
160                 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 
161                                 usp, &frame->uc.uc_stack);
162                 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
163                         goto give_sigsegv;
164         }
165                 
166
167
168         /* If we are on the syscall path IAOQ will not be restored, and
169          * if we are on the interrupt path we must not corrupt gr31.
170          */
171         if (in_syscall)
172                 regs->gr[31] = regs->iaoq[0];
173 #if DEBUG_SIG
174         DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
175         show_regs(regs);
176 #endif
177         return;
178
179 give_sigsegv:
180         DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
181         si.si_signo = SIGSEGV;
182         si.si_errno = 0;
183         si.si_code = SI_KERNEL;
184         si.si_pid = task_pid_vnr(current);
185         si.si_uid = current_uid();
186         si.si_addr = &frame->uc;
187         force_sig_info(SIGSEGV, &si, current);
188         return;
189 }
190
191 /*
192  * Set up a signal frame.
193  */
194
195 static inline void __user *
196 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
197 {
198         /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
199           don't use the parameter it doesn't matter */
200
201         DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
202                         (unsigned long)ka, sp, frame_size);
203         
204         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
205                 sp = current->sas_ss_sp; /* Stacks grow up! */
206
207         DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
208         return (void __user *) sp; /* Stacks grow up.  Fun. */
209 }
210
211 static long
212 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
213                  
214 {
215         unsigned long flags = 0;
216         long err = 0;
217
218         if (on_sig_stack((unsigned long) sc))
219                 flags |= PARISC_SC_FLAG_ONSTACK;
220         if (in_syscall) {
221                 flags |= PARISC_SC_FLAG_IN_SYSCALL;
222                 /* regs->iaoq is undefined in the syscall return path */
223                 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
224                 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
225                 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
226                 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
227                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
228                         regs->gr[31], regs->gr[31]+4);
229         } else {
230                 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
231                 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
232                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 
233                         regs->iaoq[0], regs->iaoq[1]);
234         }
235
236         err |= __put_user(flags, &sc->sc_flags);
237         err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
238         err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
239         err |= __put_user(regs->sar, &sc->sc_sar);
240         DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
241
242         return err;
243 }
244
245 static long
246 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
247                sigset_t *set, struct pt_regs *regs, int in_syscall)
248 {
249         struct rt_sigframe __user *frame;
250         unsigned long rp, usp;
251         unsigned long haddr, sigframe_size;
252         int err = 0;
253 #ifdef CONFIG_64BIT
254         compat_int_t compat_val;
255         struct compat_rt_sigframe __user * compat_frame;
256         compat_sigset_t compat_set;
257 #endif
258         
259         usp = (regs->gr[30] & ~(0x01UL));
260         /*FIXME: frame_size parameter is unused, remove it. */
261         frame = get_sigframe(ka, usp, sizeof(*frame));
262
263         DBG(1,"SETUP_RT_FRAME: START\n");
264         DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
265
266         
267 #ifdef CONFIG_64BIT
268
269         compat_frame = (struct compat_rt_sigframe __user *)frame;
270         
271         if (is_compat_task()) {
272                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
273                 err |= copy_siginfo_to_user32(&compat_frame->info, info);
274                 DBG(1,"SETUP_RT_FRAME: 1\n");
275                 compat_val = (compat_int_t)current->sas_ss_sp;
276                 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
277                 DBG(1,"SETUP_RT_FRAME: 2\n");
278                 compat_val = (compat_int_t)current->sas_ss_size;
279                 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
280                 DBG(1,"SETUP_RT_FRAME: 3\n");
281                 compat_val = sas_ss_flags(regs->gr[30]);                
282                 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);             
283                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
284                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
285                 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 
286                                         &compat_frame->regs, regs, in_syscall);
287                 sigset_64to32(&compat_set,set);
288                 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
289         } else
290 #endif
291         {       
292                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
293                 err |= copy_siginfo_to_user(&frame->info, info);
294                 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
295                 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
296                 err |= __put_user(sas_ss_flags(regs->gr[30]),
297                                   &frame->uc.uc_stack.ss_flags);
298                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
299                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
300                 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
301                 /* FIXME: Should probably be converted aswell for the compat case */
302                 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
303         }
304         
305         if (err)
306                 goto give_sigsegv;
307
308         /* Set up to return from userspace.  If provided, use a stub
309            already in userspace. The first words of tramp are used to
310            save the previous sigrestartblock trampoline that might be
311            on the stack. We start the sigreturn trampoline at 
312            SIGRESTARTBLOCK_TRAMP+X. */
313         err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
314                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
315         err |= __put_user(INSN_LDI_R20, 
316                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
317         err |= __put_user(INSN_BLE_SR2_R0, 
318                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
319         err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
320
321 #if DEBUG_SIG
322         /* Assert that we're flushing in the correct space... */
323         {
324                 int sid;
325                 asm ("mfsp %%sr3,%0" : "=r" (sid));
326                 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
327                        sid, frame->tramp);
328         }
329 #endif
330
331         flush_user_dcache_range((unsigned long) &frame->tramp[0],
332                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
333         flush_user_icache_range((unsigned long) &frame->tramp[0],
334                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
335
336         /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
337          * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
338          * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
339          */
340         rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
341
342         if (err)
343                 goto give_sigsegv;
344
345         haddr = A(ka->sa.sa_handler);
346         /* The sa_handler may be a pointer to a function descriptor */
347 #ifdef CONFIG_64BIT
348         if (is_compat_task()) {
349 #endif
350                 if (haddr & PA_PLABEL_FDESC) {
351                         Elf32_Fdesc fdesc;
352                         Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
353
354                         err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
355
356                         if (err)
357                                 goto give_sigsegv;
358
359                         haddr = fdesc.addr;
360                         regs->gr[19] = fdesc.gp;
361                 }
362 #ifdef CONFIG_64BIT
363         } else {
364                 Elf64_Fdesc fdesc;
365                 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
366                 
367                 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
368                 
369                 if (err)
370                         goto give_sigsegv;
371                 
372                 haddr = fdesc.addr;
373                 regs->gr[19] = fdesc.gp;
374                 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
375                      haddr, regs->gr[19], in_syscall);
376         }
377 #endif
378
379         /* The syscall return path will create IAOQ values from r31.
380          */
381         sigframe_size = PARISC_RT_SIGFRAME_SIZE;
382 #ifdef CONFIG_64BIT
383         if (is_compat_task())
384                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
385 #endif
386         if (in_syscall) {
387                 regs->gr[31] = haddr;
388 #ifdef CONFIG_64BIT
389                 if (!test_thread_flag(TIF_32BIT))
390                         sigframe_size |= 1;
391 #endif
392         } else {
393                 unsigned long psw = USER_PSW;
394 #ifdef CONFIG_64BIT
395                 if (!test_thread_flag(TIF_32BIT))
396                         psw |= PSW_W;
397 #endif
398
399                 /* If we are singlestepping, arrange a trap to be delivered
400                    when we return to userspace. Note the semantics -- we
401                    should trap before the first insn in the handler is
402                    executed. Ref:
403                         http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
404                  */
405                 if (pa_psw(current)->r) {
406                         pa_psw(current)->r = 0;
407                         psw |= PSW_R;
408                         mtctl(-1, 0);
409                 }
410
411                 regs->gr[0] = psw;
412                 regs->iaoq[0] = haddr | 3;
413                 regs->iaoq[1] = regs->iaoq[0] + 4;
414         }
415
416         regs->gr[2]  = rp;                /* userland return pointer */
417         regs->gr[26] = sig;               /* signal number */
418         
419 #ifdef CONFIG_64BIT
420         if (is_compat_task()) {
421                 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
422                 regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
423         } else
424 #endif
425         {               
426                 regs->gr[25] = A(&frame->info); /* siginfo pointer */
427                 regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
428         }
429         
430         DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
431                regs->gr[30], sigframe_size,
432                regs->gr[30] + sigframe_size);
433         /* Raise the user stack pointer to make a proper call frame. */
434         regs->gr[30] = (A(frame) + sigframe_size);
435
436
437         DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
438                current->comm, current->pid, frame, regs->gr[30],
439                regs->iaoq[0], regs->iaoq[1], rp);
440
441         return 1;
442
443 give_sigsegv:
444         DBG(1,"setup_rt_frame: sending SIGSEGV\n");
445         force_sigsegv(sig, current);
446         return 0;
447 }
448
449 /*
450  * OK, we're invoking a handler.
451  */     
452
453 static long
454 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
455                 sigset_t *oldset, struct pt_regs *regs, int in_syscall)
456 {
457         DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
458                sig, ka, info, oldset, regs);
459         
460         /* Set up the stack frame */
461         if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
462                 return 0;
463
464         spin_lock_irq(&current->sighand->siglock);
465         sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
466         if (!(ka->sa.sa_flags & SA_NODEFER))
467                 sigaddset(&current->blocked,sig);
468         recalc_sigpending();
469         spin_unlock_irq(&current->sighand->siglock);
470         return 1;
471 }
472
473 static inline void
474 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
475 {
476         /* Check the return code */
477         switch (regs->gr[28]) {
478         case -ERESTART_RESTARTBLOCK:
479                 current_thread_info()->restart_block.fn =
480                         do_no_restart_syscall;
481         case -ERESTARTNOHAND:
482                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
483                 regs->gr[28] = -EINTR;
484                 break;
485
486         case -ERESTARTSYS:
487                 if (!(ka->sa.sa_flags & SA_RESTART)) {
488                         DBG(1,"ERESTARTSYS: putting -EINTR\n");
489                         regs->gr[28] = -EINTR;
490                         break;
491                 }
492                 /* fallthrough */
493         case -ERESTARTNOINTR:
494                 /* A syscall is just a branch, so all
495                  * we have to do is fiddle the return pointer.
496                  */
497                 regs->gr[31] -= 8; /* delayed branching */
498                 /* Preserve original r28. */
499                 regs->gr[28] = regs->orig_r28;
500                 break;
501         }
502 }
503
504 static inline void
505 insert_restart_trampoline(struct pt_regs *regs)
506 {
507         switch(regs->gr[28]) {
508         case -ERESTART_RESTARTBLOCK: {
509                 /* Restart the system call - no handlers present */
510                 unsigned int *usp = (unsigned int *)regs->gr[30];
511
512                 /* Setup a trampoline to restart the syscall
513                  * with __NR_restart_syscall
514                  *
515                  *  0: <return address (orig r31)>
516                  *  4: <2nd half for 64-bit>
517                  *  8: ldw 0(%sp), %r31
518                  * 12: be 0x100(%sr2, %r0)
519                  * 16: ldi __NR_restart_syscall, %r20
520                  */
521 #ifdef CONFIG_64BIT
522                 put_user(regs->gr[31] >> 32, &usp[0]);
523                 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
524                 put_user(0x0fc010df, &usp[2]);
525 #else
526                 put_user(regs->gr[31], &usp[0]);
527                 put_user(0x0fc0109f, &usp[2]);
528 #endif
529                 put_user(0xe0008200, &usp[3]);
530                 put_user(0x34140000, &usp[4]);
531
532                 /* Stack is 64-byte aligned, and we only need
533                  * to flush 1 cache line.
534                  * Flushing one cacheline is cheap.
535                  * "sync" on bigger (> 4 way) boxes is not.
536                  */
537                 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
538                 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
539
540                 regs->gr[31] = regs->gr[30] + 8;
541                 /* Preserve original r28. */
542                 regs->gr[28] = regs->orig_r28;
543
544                 return;
545         }
546         case -ERESTARTNOHAND:
547         case -ERESTARTSYS:
548         case -ERESTARTNOINTR: {
549                 /* Hooray for delayed branching.  We don't
550                  * have to restore %r20 (the system call
551                  * number) because it gets loaded in the delay
552                  * slot of the branch external instruction.
553                  */
554                 regs->gr[31] -= 8;
555                 /* Preserve original r28. */
556                 regs->gr[28] = regs->orig_r28;
557
558                 return;
559         }
560         default:
561                 break;
562         }
563 }
564
565 /*
566  * Note that 'init' is a special process: it doesn't get signals it doesn't
567  * want to handle. Thus you cannot kill init even with a SIGKILL even by
568  * mistake.
569  *
570  * We need to be able to restore the syscall arguments (r21-r26) to
571  * restart syscalls.  Thus, the syscall path should save them in the
572  * pt_regs structure (it's okay to do so since they are caller-save
573  * registers).  As noted below, the syscall number gets restored for
574  * us due to the magic of delayed branching.
575  */
576 asmlinkage void
577 do_signal(struct pt_regs *regs, long in_syscall)
578 {
579         siginfo_t info;
580         struct k_sigaction ka;
581         int signr;
582         sigset_t *oldset;
583
584         DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
585                oldset, regs, regs->sr[7], in_syscall);
586
587         /* Everyone else checks to see if they are in kernel mode at
588            this point and exits if that's the case.  I'm not sure why
589            we would be called in that case, but for some reason we
590            are. */
591
592         if (test_thread_flag(TIF_RESTORE_SIGMASK))
593                 oldset = &current->saved_sigmask;
594         else
595                 oldset = &current->blocked;
596
597         DBG(1,"do_signal: oldset %08lx / %08lx\n", 
598                 oldset->sig[0], oldset->sig[1]);
599
600
601         /* May need to force signal if handle_signal failed to deliver */
602         while (1) {
603           
604                 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
605                 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 
606         
607                 if (signr <= 0)
608                   break;
609                 
610                 /* Restart a system call if necessary. */
611                 if (in_syscall)
612                         syscall_restart(regs, &ka);
613
614                 /* Whee!  Actually deliver the signal.  If the
615                    delivery failed, we need to continue to iterate in
616                    this loop so we can deliver the SIGSEGV... */
617                 if (handle_signal(signr, &info, &ka, oldset,
618                                   regs, in_syscall)) {
619                         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
620                                 regs->gr[28]);
621                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
622                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
623                         return;
624                 }
625         }
626         /* end of while(1) looping forever if we can't force a signal */
627
628         /* Did we come from a system call? */
629         if (in_syscall)
630                 insert_restart_trampoline(regs);
631         
632         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
633                 regs->gr[28]);
634
635         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
636                 clear_thread_flag(TIF_RESTORE_SIGMASK);
637                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
638         }
639
640         return;
641 }
642
643 void do_notify_resume(struct pt_regs *regs, long in_syscall)
644 {
645         if (test_thread_flag(TIF_SIGPENDING) ||
646             test_thread_flag(TIF_RESTORE_SIGMASK))
647                 do_signal(regs, in_syscall);
648 }