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