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