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