parisc: remove duplicated #include
[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/tracehook.h>
25 #include <linux/unistd.h>
26 #include <linux/stddef.h>
27 #include <linux/compat.h>
28 #include <linux/elf.h>
29 #include <asm/ucontext.h>
30 #include <asm/rt_sigframe.h>
31 #include <asm/uaccess.h>
32 #include <asm/pgalloc.h>
33 #include <asm/cacheflush.h>
34 #include <asm/asm-offsets.h>
35
36 #ifdef CONFIG_COMPAT
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
471         tracehook_signal_handler(sig, info, ka, regs, 0);
472
473         return 1;
474 }
475
476 static inline void
477 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
478 {
479         /* Check the return code */
480         switch (regs->gr[28]) {
481         case -ERESTART_RESTARTBLOCK:
482                 current_thread_info()->restart_block.fn =
483                         do_no_restart_syscall;
484         case -ERESTARTNOHAND:
485                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
486                 regs->gr[28] = -EINTR;
487                 break;
488
489         case -ERESTARTSYS:
490                 if (!(ka->sa.sa_flags & SA_RESTART)) {
491                         DBG(1,"ERESTARTSYS: putting -EINTR\n");
492                         regs->gr[28] = -EINTR;
493                         break;
494                 }
495                 /* fallthrough */
496         case -ERESTARTNOINTR:
497                 /* A syscall is just a branch, so all
498                  * we have to do is fiddle the return pointer.
499                  */
500                 regs->gr[31] -= 8; /* delayed branching */
501                 /* Preserve original r28. */
502                 regs->gr[28] = regs->orig_r28;
503                 break;
504         }
505 }
506
507 static inline void
508 insert_restart_trampoline(struct pt_regs *regs)
509 {
510         switch(regs->gr[28]) {
511         case -ERESTART_RESTARTBLOCK: {
512                 /* Restart the system call - no handlers present */
513                 unsigned int *usp = (unsigned int *)regs->gr[30];
514
515                 /* Setup a trampoline to restart the syscall
516                  * with __NR_restart_syscall
517                  *
518                  *  0: <return address (orig r31)>
519                  *  4: <2nd half for 64-bit>
520                  *  8: ldw 0(%sp), %r31
521                  * 12: be 0x100(%sr2, %r0)
522                  * 16: ldi __NR_restart_syscall, %r20
523                  */
524 #ifdef CONFIG_64BIT
525                 put_user(regs->gr[31] >> 32, &usp[0]);
526                 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
527                 put_user(0x0fc010df, &usp[2]);
528 #else
529                 put_user(regs->gr[31], &usp[0]);
530                 put_user(0x0fc0109f, &usp[2]);
531 #endif
532                 put_user(0xe0008200, &usp[3]);
533                 put_user(0x34140000, &usp[4]);
534
535                 /* Stack is 64-byte aligned, and we only need
536                  * to flush 1 cache line.
537                  * Flushing one cacheline is cheap.
538                  * "sync" on bigger (> 4 way) boxes is not.
539                  */
540                 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
541                 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
542
543                 regs->gr[31] = regs->gr[30] + 8;
544                 /* Preserve original r28. */
545                 regs->gr[28] = regs->orig_r28;
546
547                 return;
548         }
549         case -ERESTARTNOHAND:
550         case -ERESTARTSYS:
551         case -ERESTARTNOINTR: {
552                 /* Hooray for delayed branching.  We don't
553                  * have to restore %r20 (the system call
554                  * number) because it gets loaded in the delay
555                  * slot of the branch external instruction.
556                  */
557                 regs->gr[31] -= 8;
558                 /* Preserve original r28. */
559                 regs->gr[28] = regs->orig_r28;
560
561                 return;
562         }
563         default:
564                 break;
565         }
566 }
567
568 /*
569  * Note that 'init' is a special process: it doesn't get signals it doesn't
570  * want to handle. Thus you cannot kill init even with a SIGKILL even by
571  * mistake.
572  *
573  * We need to be able to restore the syscall arguments (r21-r26) to
574  * restart syscalls.  Thus, the syscall path should save them in the
575  * pt_regs structure (it's okay to do so since they are caller-save
576  * registers).  As noted below, the syscall number gets restored for
577  * us due to the magic of delayed branching.
578  */
579 asmlinkage void
580 do_signal(struct pt_regs *regs, long in_syscall)
581 {
582         siginfo_t info;
583         struct k_sigaction ka;
584         int signr;
585         sigset_t *oldset;
586
587         DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
588                oldset, regs, regs->sr[7], in_syscall);
589
590         /* Everyone else checks to see if they are in kernel mode at
591            this point and exits if that's the case.  I'm not sure why
592            we would be called in that case, but for some reason we
593            are. */
594
595         if (test_thread_flag(TIF_RESTORE_SIGMASK))
596                 oldset = &current->saved_sigmask;
597         else
598                 oldset = &current->blocked;
599
600         DBG(1,"do_signal: oldset %08lx / %08lx\n", 
601                 oldset->sig[0], oldset->sig[1]);
602
603
604         /* May need to force signal if handle_signal failed to deliver */
605         while (1) {
606           
607                 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
608                 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 
609         
610                 if (signr <= 0)
611                   break;
612                 
613                 /* Restart a system call if necessary. */
614                 if (in_syscall)
615                         syscall_restart(regs, &ka);
616
617                 /* Whee!  Actually deliver the signal.  If the
618                    delivery failed, we need to continue to iterate in
619                    this loop so we can deliver the SIGSEGV... */
620                 if (handle_signal(signr, &info, &ka, oldset,
621                                   regs, in_syscall)) {
622                         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
623                                 regs->gr[28]);
624                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
625                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
626                         return;
627                 }
628         }
629         /* end of while(1) looping forever if we can't force a signal */
630
631         /* Did we come from a system call? */
632         if (in_syscall)
633                 insert_restart_trampoline(regs);
634         
635         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
636                 regs->gr[28]);
637
638         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
639                 clear_thread_flag(TIF_RESTORE_SIGMASK);
640                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
641         }
642
643         return;
644 }
645
646 void do_notify_resume(struct pt_regs *regs, long in_syscall)
647 {
648         if (test_thread_flag(TIF_SIGPENDING) ||
649             test_thread_flag(TIF_RESTORE_SIGMASK))
650                 do_signal(regs, in_syscall);
651
652         if (test_thread_flag(TIF_NOTIFY_RESUME)) {
653                 clear_thread_flag(TIF_NOTIFY_RESUME);
654                 tracehook_notify_resume(regs);
655                 if (current->replacement_session_keyring)
656                         key_replace_session_keyring();
657         }
658 }