53799695599872565f1ad8c387cbf0e1b91ceb3d
[~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         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
194                 sp = current->sas_ss_sp; /* Stacks grow up! */
195
196         DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
197         return (void __user *) sp; /* Stacks grow up.  Fun. */
198 }
199
200 static long
201 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
202                  
203 {
204         unsigned long flags = 0;
205         long err = 0;
206
207         if (on_sig_stack((unsigned long) sc))
208                 flags |= PARISC_SC_FLAG_ONSTACK;
209         if (in_syscall) {
210                 flags |= PARISC_SC_FLAG_IN_SYSCALL;
211                 /* regs->iaoq is undefined in the syscall return path */
212                 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
213                 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
214                 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
215                 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
216                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
217                         regs->gr[31], regs->gr[31]+4);
218         } else {
219                 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
220                 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
221                 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 
222                         regs->iaoq[0], regs->iaoq[1]);
223         }
224
225         err |= __put_user(flags, &sc->sc_flags);
226         err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
227         err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
228         err |= __put_user(regs->sar, &sc->sc_sar);
229         DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
230
231         return err;
232 }
233
234 static long
235 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
236                sigset_t *set, struct pt_regs *regs, int in_syscall)
237 {
238         struct rt_sigframe __user *frame;
239         unsigned long rp, usp;
240         unsigned long haddr, sigframe_size;
241         int err = 0;
242 #ifdef CONFIG_64BIT
243         compat_int_t compat_val;
244         struct compat_rt_sigframe __user * compat_frame;
245         compat_sigset_t compat_set;
246 #endif
247         
248         usp = (regs->gr[30] & ~(0x01UL));
249         /*FIXME: frame_size parameter is unused, remove it. */
250         frame = get_sigframe(ka, usp, sizeof(*frame));
251
252         DBG(1,"SETUP_RT_FRAME: START\n");
253         DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
254
255         
256 #ifdef CONFIG_64BIT
257
258         compat_frame = (struct compat_rt_sigframe __user *)frame;
259         
260         if (is_compat_task()) {
261                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
262                 err |= copy_siginfo_to_user32(&compat_frame->info, info);
263                 DBG(1,"SETUP_RT_FRAME: 1\n");
264                 compat_val = (compat_int_t)current->sas_ss_sp;
265                 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
266                 DBG(1,"SETUP_RT_FRAME: 2\n");
267                 compat_val = (compat_int_t)current->sas_ss_size;
268                 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
269                 DBG(1,"SETUP_RT_FRAME: 3\n");
270                 compat_val = sas_ss_flags(regs->gr[30]);                
271                 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);             
272                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
273                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
274                 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 
275                                         &compat_frame->regs, regs, in_syscall);
276                 sigset_64to32(&compat_set,set);
277                 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
278         } else
279 #endif
280         {       
281                 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
282                 err |= copy_siginfo_to_user(&frame->info, info);
283                 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
284                 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
285                 err |= __put_user(sas_ss_flags(regs->gr[30]),
286                                   &frame->uc.uc_stack.ss_flags);
287                 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
288                 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
289                 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
290                 /* FIXME: Should probably be converted as well for the compat case */
291                 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
292         }
293         
294         if (err)
295                 goto give_sigsegv;
296
297         /* Set up to return from userspace.  If provided, use a stub
298            already in userspace. The first words of tramp are used to
299            save the previous sigrestartblock trampoline that might be
300            on the stack. We start the sigreturn trampoline at 
301            SIGRESTARTBLOCK_TRAMP+X. */
302         err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
303                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
304         err |= __put_user(INSN_LDI_R20, 
305                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
306         err |= __put_user(INSN_BLE_SR2_R0, 
307                         &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
308         err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
309
310 #if DEBUG_SIG
311         /* Assert that we're flushing in the correct space... */
312         {
313                 int sid;
314                 asm ("mfsp %%sr3,%0" : "=r" (sid));
315                 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
316                        sid, frame->tramp);
317         }
318 #endif
319
320         flush_user_dcache_range((unsigned long) &frame->tramp[0],
321                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
322         flush_user_icache_range((unsigned long) &frame->tramp[0],
323                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
324
325         /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
326          * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
327          * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
328          */
329         rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
330
331         if (err)
332                 goto give_sigsegv;
333
334         haddr = A(ka->sa.sa_handler);
335         /* The sa_handler may be a pointer to a function descriptor */
336 #ifdef CONFIG_64BIT
337         if (is_compat_task()) {
338 #endif
339                 if (haddr & PA_PLABEL_FDESC) {
340                         Elf32_Fdesc fdesc;
341                         Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
342
343                         err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
344
345                         if (err)
346                                 goto give_sigsegv;
347
348                         haddr = fdesc.addr;
349                         regs->gr[19] = fdesc.gp;
350                 }
351 #ifdef CONFIG_64BIT
352         } else {
353                 Elf64_Fdesc fdesc;
354                 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
355                 
356                 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
357                 
358                 if (err)
359                         goto give_sigsegv;
360                 
361                 haddr = fdesc.addr;
362                 regs->gr[19] = fdesc.gp;
363                 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
364                      haddr, regs->gr[19], in_syscall);
365         }
366 #endif
367
368         /* The syscall return path will create IAOQ values from r31.
369          */
370         sigframe_size = PARISC_RT_SIGFRAME_SIZE;
371 #ifdef CONFIG_64BIT
372         if (is_compat_task())
373                 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
374 #endif
375         if (in_syscall) {
376                 regs->gr[31] = haddr;
377 #ifdef CONFIG_64BIT
378                 if (!test_thread_flag(TIF_32BIT))
379                         sigframe_size |= 1;
380 #endif
381         } else {
382                 unsigned long psw = USER_PSW;
383 #ifdef CONFIG_64BIT
384                 if (!test_thread_flag(TIF_32BIT))
385                         psw |= PSW_W;
386 #endif
387
388                 /* If we are singlestepping, arrange a trap to be delivered
389                    when we return to userspace. Note the semantics -- we
390                    should trap before the first insn in the handler is
391                    executed. Ref:
392                         http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
393                  */
394                 if (pa_psw(current)->r) {
395                         pa_psw(current)->r = 0;
396                         psw |= PSW_R;
397                         mtctl(-1, 0);
398                 }
399
400                 regs->gr[0] = psw;
401                 regs->iaoq[0] = haddr | 3;
402                 regs->iaoq[1] = regs->iaoq[0] + 4;
403         }
404
405         regs->gr[2]  = rp;                /* userland return pointer */
406         regs->gr[26] = sig;               /* signal number */
407         
408 #ifdef CONFIG_64BIT
409         if (is_compat_task()) {
410                 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
411                 regs->gr[24] = A(&compat_frame->uc);   /* ucontext pointer */
412         } else
413 #endif
414         {               
415                 regs->gr[25] = A(&frame->info); /* siginfo pointer */
416                 regs->gr[24] = A(&frame->uc);   /* ucontext pointer */
417         }
418         
419         DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
420                regs->gr[30], sigframe_size,
421                regs->gr[30] + sigframe_size);
422         /* Raise the user stack pointer to make a proper call frame. */
423         regs->gr[30] = (A(frame) + sigframe_size);
424
425
426         DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
427                current->comm, current->pid, frame, regs->gr[30],
428                regs->iaoq[0], regs->iaoq[1], rp);
429
430         return 1;
431
432 give_sigsegv:
433         DBG(1,"setup_rt_frame: sending SIGSEGV\n");
434         force_sigsegv(sig, current);
435         return 0;
436 }
437
438 /*
439  * OK, we're invoking a handler.
440  */     
441
442 static void
443 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
444                 struct pt_regs *regs, int in_syscall)
445 {
446         sigset_t *oldset = sigmask_to_save();
447         DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
448                sig, ka, info, oldset, regs);
449         
450         /* Set up the stack frame */
451         if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
452                 return;
453
454         signal_delivered(sig, info, ka, regs, 
455                 test_thread_flag(TIF_SINGLESTEP) ||
456                 test_thread_flag(TIF_BLOCKSTEP));
457
458         DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
459                 regs->gr[28]);
460 }
461
462 static inline void
463 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
464 {
465         if (regs->orig_r28)
466                 return;
467         regs->orig_r28 = 1; /* no more restarts */
468         /* Check the return code */
469         switch (regs->gr[28]) {
470         case -ERESTART_RESTARTBLOCK:
471         case -ERESTARTNOHAND:
472                 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
473                 regs->gr[28] = -EINTR;
474                 break;
475
476         case -ERESTARTSYS:
477                 if (!(ka->sa.sa_flags & SA_RESTART)) {
478                         DBG(1,"ERESTARTSYS: putting -EINTR\n");
479                         regs->gr[28] = -EINTR;
480                         break;
481                 }
482                 /* fallthrough */
483         case -ERESTARTNOINTR:
484                 /* A syscall is just a branch, so all
485                  * we have to do is fiddle the return pointer.
486                  */
487                 regs->gr[31] -= 8; /* delayed branching */
488                 break;
489         }
490 }
491
492 static inline void
493 insert_restart_trampoline(struct pt_regs *regs)
494 {
495         if (regs->orig_r28)
496                 return;
497         regs->orig_r28 = 1; /* no more restarts */
498         switch(regs->gr[28]) {
499         case -ERESTART_RESTARTBLOCK: {
500                 /* Restart the system call - no handlers present */
501                 unsigned int *usp = (unsigned int *)regs->gr[30];
502
503                 /* Setup a trampoline to restart the syscall
504                  * with __NR_restart_syscall
505                  *
506                  *  0: <return address (orig r31)>
507                  *  4: <2nd half for 64-bit>
508                  *  8: ldw 0(%sp), %r31
509                  * 12: be 0x100(%sr2, %r0)
510                  * 16: ldi __NR_restart_syscall, %r20
511                  */
512 #ifdef CONFIG_64BIT
513                 put_user(regs->gr[31] >> 32, &usp[0]);
514                 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
515                 put_user(0x0fc010df, &usp[2]);
516 #else
517                 put_user(regs->gr[31], &usp[0]);
518                 put_user(0x0fc0109f, &usp[2]);
519 #endif
520                 put_user(0xe0008200, &usp[3]);
521                 put_user(0x34140000, &usp[4]);
522
523                 /* Stack is 64-byte aligned, and we only need
524                  * to flush 1 cache line.
525                  * Flushing one cacheline is cheap.
526                  * "sync" on bigger (> 4 way) boxes is not.
527                  */
528                 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
529                 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
530
531                 regs->gr[31] = regs->gr[30] + 8;
532                 return;
533         }
534         case -ERESTARTNOHAND:
535         case -ERESTARTSYS:
536         case -ERESTARTNOINTR: {
537                 /* Hooray for delayed branching.  We don't
538                  * have to restore %r20 (the system call
539                  * number) because it gets loaded in the delay
540                  * slot of the branch external instruction.
541                  */
542                 regs->gr[31] -= 8;
543                 return;
544         }
545         default:
546                 break;
547         }
548 }
549
550 /*
551  * Note that 'init' is a special process: it doesn't get signals it doesn't
552  * want to handle. Thus you cannot kill init even with a SIGKILL even by
553  * mistake.
554  *
555  * We need to be able to restore the syscall arguments (r21-r26) to
556  * restart syscalls.  Thus, the syscall path should save them in the
557  * pt_regs structure (it's okay to do so since they are caller-save
558  * registers).  As noted below, the syscall number gets restored for
559  * us due to the magic of delayed branching.
560  */
561 asmlinkage void
562 do_signal(struct pt_regs *regs, long in_syscall)
563 {
564         siginfo_t info;
565         struct k_sigaction ka;
566         int signr;
567
568         DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
569                regs, regs->sr[7], in_syscall);
570
571         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
572         DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 
573         
574         if (signr > 0) {
575                 /* Restart a system call if necessary. */
576                 if (in_syscall)
577                         syscall_restart(regs, &ka);
578
579                 handle_signal(signr, &info, &ka, regs, in_syscall);
580                 return;
581         }
582
583         /* Did we come from a system call? */
584         if (in_syscall)
585                 insert_restart_trampoline(regs);
586         
587         DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 
588                 regs->gr[28]);
589
590         restore_saved_sigmask();
591 }
592
593 void do_notify_resume(struct pt_regs *regs, long in_syscall)
594 {
595         if (test_thread_flag(TIF_SIGPENDING))
596                 do_signal(regs, in_syscall);
597
598         if (test_thread_flag(TIF_NOTIFY_RESUME)) {
599                 clear_thread_flag(TIF_NOTIFY_RESUME);
600                 tracehook_notify_resume(regs);
601         }
602 }