KEYS: Add missing linux/tracehook.h #inclusions
[linux-2.6.git] / arch / alpha / kernel / signal.c
1 /*
2  *  linux/arch/alpha/kernel/signal.c
3  *
4  *  Copyright (C) 1995  Linus Torvalds
5  *
6  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
7  */
8
9 #include <linux/sched.h>
10 #include <linux/kernel.h>
11 #include <linux/signal.h>
12 #include <linux/errno.h>
13 #include <linux/wait.h>
14 #include <linux/ptrace.h>
15 #include <linux/unistd.h>
16 #include <linux/mm.h>
17 #include <linux/smp.h>
18 #include <linux/stddef.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/bitops.h>
22 #include <linux/syscalls.h>
23 #include <linux/tracehook.h>
24
25 #include <asm/uaccess.h>
26 #include <asm/sigcontext.h>
27 #include <asm/ucontext.h>
28
29 #include "proto.h"
30
31
32 #define DEBUG_SIG 0
33
34 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
35
36 asmlinkage void ret_from_sys_call(void);
37 static void do_signal(struct pt_regs *, struct switch_stack *,
38                       unsigned long, unsigned long);
39
40
41 /*
42  * The OSF/1 sigprocmask calling sequence is different from the
43  * C sigprocmask() sequence..
44  *
45  * how:
46  * 1 - SIG_BLOCK
47  * 2 - SIG_UNBLOCK
48  * 3 - SIG_SETMASK
49  *
50  * We change the range to -1 .. 1 in order to let gcc easily
51  * use the conditional move instructions.
52  *
53  * Note that we don't need to acquire the kernel lock for SMP
54  * operation, as all of this is local to this thread.
55  */
56 SYSCALL_DEFINE3(osf_sigprocmask, int, how, unsigned long, newmask,
57                 struct pt_regs *, regs)
58 {
59         unsigned long oldmask = -EINVAL;
60
61         if ((unsigned long)how-1 <= 2) {
62                 long sign = how-2;              /* -1 .. 1 */
63                 unsigned long block, unblock;
64
65                 newmask &= _BLOCKABLE;
66                 spin_lock_irq(&current->sighand->siglock);
67                 oldmask = current->blocked.sig[0];
68
69                 unblock = oldmask & ~newmask;
70                 block = oldmask | newmask;
71                 if (!sign)
72                         block = unblock;
73                 if (sign <= 0)
74                         newmask = block;
75                 if (_NSIG_WORDS > 1 && sign > 0)
76                         sigemptyset(&current->blocked);
77                 current->blocked.sig[0] = newmask;
78                 recalc_sigpending();
79                 spin_unlock_irq(&current->sighand->siglock);
80
81                 regs->r0 = 0;           /* special no error return */
82         }
83         return oldmask;
84 }
85
86 SYSCALL_DEFINE3(osf_sigaction, int, sig,
87                 const struct osf_sigaction __user *, act,
88                 struct osf_sigaction __user *, oact)
89 {
90         struct k_sigaction new_ka, old_ka;
91         int ret;
92
93         if (act) {
94                 old_sigset_t mask;
95                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
96                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
97                     __get_user(new_ka.sa.sa_flags, &act->sa_flags))
98                         return -EFAULT;
99                 __get_user(mask, &act->sa_mask);
100                 siginitset(&new_ka.sa.sa_mask, mask);
101                 new_ka.ka_restorer = NULL;
102         }
103
104         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
105
106         if (!ret && oact) {
107                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
108                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
109                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags))
110                         return -EFAULT;
111                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
112         }
113
114         return ret;
115 }
116
117 SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
118                 struct sigaction __user *, oact,
119                 size_t, sigsetsize, void __user *, restorer)
120 {
121         struct k_sigaction new_ka, old_ka;
122         int ret;
123
124         /* XXX: Don't preclude handling different sized sigset_t's.  */
125         if (sigsetsize != sizeof(sigset_t))
126                 return -EINVAL;
127
128         if (act) {
129                 new_ka.ka_restorer = restorer;
130                 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
131                         return -EFAULT;
132         }
133
134         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
135
136         if (!ret && oact) {
137                 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
138                         return -EFAULT;
139         }
140
141         return ret;
142 }
143
144 /*
145  * Atomically swap in the new signal mask, and wait for a signal.
146  */
147 asmlinkage int
148 do_sigsuspend(old_sigset_t mask, struct pt_regs *regs, struct switch_stack *sw)
149 {
150         mask &= _BLOCKABLE;
151         spin_lock_irq(&current->sighand->siglock);
152         current->saved_sigmask = current->blocked;
153         siginitset(&current->blocked, mask);
154         recalc_sigpending();
155         spin_unlock_irq(&current->sighand->siglock);
156
157         /* Indicate EINTR on return from any possible signal handler,
158            which will not come back through here, but via sigreturn.  */
159         regs->r0 = EINTR;
160         regs->r19 = 1;
161
162         current->state = TASK_INTERRUPTIBLE;
163         schedule();
164         set_thread_flag(TIF_RESTORE_SIGMASK);
165         return -ERESTARTNOHAND;
166 }
167
168 asmlinkage int
169 do_rt_sigsuspend(sigset_t __user *uset, size_t sigsetsize,
170                  struct pt_regs *regs, struct switch_stack *sw)
171 {
172         sigset_t set;
173
174         /* XXX: Don't preclude handling different sized sigset_t's.  */
175         if (sigsetsize != sizeof(sigset_t))
176                 return -EINVAL;
177         if (copy_from_user(&set, uset, sizeof(set)))
178                 return -EFAULT;
179
180         sigdelsetmask(&set, ~_BLOCKABLE);
181         spin_lock_irq(&current->sighand->siglock);
182         current->saved_sigmask = current->blocked;
183         current->blocked = set;
184         recalc_sigpending();
185         spin_unlock_irq(&current->sighand->siglock);
186
187         /* Indicate EINTR on return from any possible signal handler,
188            which will not come back through here, but via sigreturn.  */
189         regs->r0 = EINTR;
190         regs->r19 = 1;
191
192         current->state = TASK_INTERRUPTIBLE;
193         schedule();
194         set_thread_flag(TIF_RESTORE_SIGMASK);
195         return -ERESTARTNOHAND;
196 }
197
198 asmlinkage int
199 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
200 {
201         return do_sigaltstack(uss, uoss, rdusp());
202 }
203
204 /*
205  * Do a signal return; undo the signal stack.
206  */
207
208 #if _NSIG_WORDS > 1
209 # error "Non SA_SIGINFO frame needs rearranging"
210 #endif
211
212 struct sigframe
213 {
214         struct sigcontext sc;
215         unsigned int retcode[3];
216 };
217
218 struct rt_sigframe
219 {
220         struct siginfo info;
221         struct ucontext uc;
222         unsigned int retcode[3];
223 };
224
225 /* If this changes, userland unwinders that Know Things about our signal
226    frame will break.  Do not undertake lightly.  It also implies an ABI
227    change wrt the size of siginfo_t, which may cause some pain.  */
228 extern char compile_time_assert
229         [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
230
231 #define INSN_MOV_R30_R16        0x47fe0410
232 #define INSN_LDI_R0             0x201f0000
233 #define INSN_CALLSYS            0x00000083
234
235 static long
236 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
237                    struct switch_stack *sw)
238 {
239         unsigned long usp;
240         long i, err = __get_user(regs->pc, &sc->sc_pc);
241
242         sw->r26 = (unsigned long) ret_from_sys_call;
243
244         err |= __get_user(regs->r0, sc->sc_regs+0);
245         err |= __get_user(regs->r1, sc->sc_regs+1);
246         err |= __get_user(regs->r2, sc->sc_regs+2);
247         err |= __get_user(regs->r3, sc->sc_regs+3);
248         err |= __get_user(regs->r4, sc->sc_regs+4);
249         err |= __get_user(regs->r5, sc->sc_regs+5);
250         err |= __get_user(regs->r6, sc->sc_regs+6);
251         err |= __get_user(regs->r7, sc->sc_regs+7);
252         err |= __get_user(regs->r8, sc->sc_regs+8);
253         err |= __get_user(sw->r9, sc->sc_regs+9);
254         err |= __get_user(sw->r10, sc->sc_regs+10);
255         err |= __get_user(sw->r11, sc->sc_regs+11);
256         err |= __get_user(sw->r12, sc->sc_regs+12);
257         err |= __get_user(sw->r13, sc->sc_regs+13);
258         err |= __get_user(sw->r14, sc->sc_regs+14);
259         err |= __get_user(sw->r15, sc->sc_regs+15);
260         err |= __get_user(regs->r16, sc->sc_regs+16);
261         err |= __get_user(regs->r17, sc->sc_regs+17);
262         err |= __get_user(regs->r18, sc->sc_regs+18);
263         err |= __get_user(regs->r19, sc->sc_regs+19);
264         err |= __get_user(regs->r20, sc->sc_regs+20);
265         err |= __get_user(regs->r21, sc->sc_regs+21);
266         err |= __get_user(regs->r22, sc->sc_regs+22);
267         err |= __get_user(regs->r23, sc->sc_regs+23);
268         err |= __get_user(regs->r24, sc->sc_regs+24);
269         err |= __get_user(regs->r25, sc->sc_regs+25);
270         err |= __get_user(regs->r26, sc->sc_regs+26);
271         err |= __get_user(regs->r27, sc->sc_regs+27);
272         err |= __get_user(regs->r28, sc->sc_regs+28);
273         err |= __get_user(regs->gp, sc->sc_regs+29);
274         err |= __get_user(usp, sc->sc_regs+30);
275         wrusp(usp);
276
277         for (i = 0; i < 31; i++)
278                 err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
279         err |= __get_user(sw->fp[31], &sc->sc_fpcr);
280
281         return err;
282 }
283
284 /* Note that this syscall is also used by setcontext(3) to install
285    a given sigcontext.  This because it's impossible to set *all*
286    registers and transfer control from userland.  */
287
288 asmlinkage void
289 do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
290              struct switch_stack *sw)
291 {
292         sigset_t set;
293
294         /* Verify that it's a good sigcontext before using it */
295         if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
296                 goto give_sigsegv;
297         if (__get_user(set.sig[0], &sc->sc_mask))
298                 goto give_sigsegv;
299
300         sigdelsetmask(&set, ~_BLOCKABLE);
301         spin_lock_irq(&current->sighand->siglock);
302         current->blocked = set;
303         recalc_sigpending();
304         spin_unlock_irq(&current->sighand->siglock);
305
306         if (restore_sigcontext(sc, regs, sw))
307                 goto give_sigsegv;
308
309         /* Send SIGTRAP if we're single-stepping: */
310         if (ptrace_cancel_bpt (current)) {
311                 siginfo_t info;
312
313                 info.si_signo = SIGTRAP;
314                 info.si_errno = 0;
315                 info.si_code = TRAP_BRKPT;
316                 info.si_addr = (void __user *) regs->pc;
317                 info.si_trapno = 0;
318                 send_sig_info(SIGTRAP, &info, current);
319         }
320         return;
321
322 give_sigsegv:
323         force_sig(SIGSEGV, current);
324 }
325
326 asmlinkage void
327 do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
328                 struct switch_stack *sw)
329 {
330         sigset_t set;
331
332         /* Verify that it's a good ucontext_t before using it */
333         if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
334                 goto give_sigsegv;
335         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
336                 goto give_sigsegv;
337
338         sigdelsetmask(&set, ~_BLOCKABLE);
339         spin_lock_irq(&current->sighand->siglock);
340         current->blocked = set;
341         recalc_sigpending();
342         spin_unlock_irq(&current->sighand->siglock);
343
344         if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
345                 goto give_sigsegv;
346
347         /* Send SIGTRAP if we're single-stepping: */
348         if (ptrace_cancel_bpt (current)) {
349                 siginfo_t info;
350
351                 info.si_signo = SIGTRAP;
352                 info.si_errno = 0;
353                 info.si_code = TRAP_BRKPT;
354                 info.si_addr = (void __user *) regs->pc;
355                 info.si_trapno = 0;
356                 send_sig_info(SIGTRAP, &info, current);
357         }
358         return;
359
360 give_sigsegv:
361         force_sig(SIGSEGV, current);
362 }
363
364
365 /*
366  * Set up a signal frame.
367  */
368
369 static inline void __user *
370 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
371 {
372         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
373                 sp = current->sas_ss_sp + current->sas_ss_size;
374
375         return (void __user *)((sp - frame_size) & -32ul);
376 }
377
378 static long
379 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 
380                  struct switch_stack *sw, unsigned long mask, unsigned long sp)
381 {
382         long i, err = 0;
383
384         err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
385         err |= __put_user(mask, &sc->sc_mask);
386         err |= __put_user(regs->pc, &sc->sc_pc);
387         err |= __put_user(8, &sc->sc_ps);
388
389         err |= __put_user(regs->r0 , sc->sc_regs+0);
390         err |= __put_user(regs->r1 , sc->sc_regs+1);
391         err |= __put_user(regs->r2 , sc->sc_regs+2);
392         err |= __put_user(regs->r3 , sc->sc_regs+3);
393         err |= __put_user(regs->r4 , sc->sc_regs+4);
394         err |= __put_user(regs->r5 , sc->sc_regs+5);
395         err |= __put_user(regs->r6 , sc->sc_regs+6);
396         err |= __put_user(regs->r7 , sc->sc_regs+7);
397         err |= __put_user(regs->r8 , sc->sc_regs+8);
398         err |= __put_user(sw->r9   , sc->sc_regs+9);
399         err |= __put_user(sw->r10  , sc->sc_regs+10);
400         err |= __put_user(sw->r11  , sc->sc_regs+11);
401         err |= __put_user(sw->r12  , sc->sc_regs+12);
402         err |= __put_user(sw->r13  , sc->sc_regs+13);
403         err |= __put_user(sw->r14  , sc->sc_regs+14);
404         err |= __put_user(sw->r15  , sc->sc_regs+15);
405         err |= __put_user(regs->r16, sc->sc_regs+16);
406         err |= __put_user(regs->r17, sc->sc_regs+17);
407         err |= __put_user(regs->r18, sc->sc_regs+18);
408         err |= __put_user(regs->r19, sc->sc_regs+19);
409         err |= __put_user(regs->r20, sc->sc_regs+20);
410         err |= __put_user(regs->r21, sc->sc_regs+21);
411         err |= __put_user(regs->r22, sc->sc_regs+22);
412         err |= __put_user(regs->r23, sc->sc_regs+23);
413         err |= __put_user(regs->r24, sc->sc_regs+24);
414         err |= __put_user(regs->r25, sc->sc_regs+25);
415         err |= __put_user(regs->r26, sc->sc_regs+26);
416         err |= __put_user(regs->r27, sc->sc_regs+27);
417         err |= __put_user(regs->r28, sc->sc_regs+28);
418         err |= __put_user(regs->gp , sc->sc_regs+29);
419         err |= __put_user(sp, sc->sc_regs+30);
420         err |= __put_user(0, sc->sc_regs+31);
421
422         for (i = 0; i < 31; i++)
423                 err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
424         err |= __put_user(0, sc->sc_fpregs+31);
425         err |= __put_user(sw->fp[31], &sc->sc_fpcr);
426
427         err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
428         err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
429         err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
430
431         return err;
432 }
433
434 static int
435 setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
436             struct pt_regs *regs, struct switch_stack * sw)
437 {
438         unsigned long oldsp, r26, err = 0;
439         struct sigframe __user *frame;
440
441         oldsp = rdusp();
442         frame = get_sigframe(ka, oldsp, sizeof(*frame));
443         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
444                 goto give_sigsegv;
445
446         err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
447         if (err)
448                 goto give_sigsegv;
449
450         /* Set up to return from userspace.  If provided, use a stub
451            already in userspace.  */
452         if (ka->ka_restorer) {
453                 r26 = (unsigned long) ka->ka_restorer;
454         } else {
455                 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
456                 err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
457                 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
458                 imb();
459                 r26 = (unsigned long) frame->retcode;
460         }
461
462         /* Check that everything was written properly.  */
463         if (err)
464                 goto give_sigsegv;
465
466         /* "Return" to the handler */
467         regs->r26 = r26;
468         regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
469         regs->r16 = sig;                        /* a0: signal number */
470         regs->r17 = 0;                          /* a1: exception code */
471         regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
472         wrusp((unsigned long) frame);
473         
474 #if DEBUG_SIG
475         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
476                 current->comm, current->pid, frame, regs->pc, regs->r26);
477 #endif
478
479         return 0;
480
481 give_sigsegv:
482         force_sigsegv(sig, current);
483         return -EFAULT;
484 }
485
486 static int
487 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
488                sigset_t *set, struct pt_regs *regs, struct switch_stack * sw)
489 {
490         unsigned long oldsp, r26, err = 0;
491         struct rt_sigframe __user *frame;
492
493         oldsp = rdusp();
494         frame = get_sigframe(ka, oldsp, sizeof(*frame));
495         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
496                 goto give_sigsegv;
497
498         err |= copy_siginfo_to_user(&frame->info, info);
499
500         /* Create the ucontext.  */
501         err |= __put_user(0, &frame->uc.uc_flags);
502         err |= __put_user(0, &frame->uc.uc_link);
503         err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
504         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
505         err |= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags);
506         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
507         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw,
508                                 set->sig[0], oldsp);
509         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
510         if (err)
511                 goto give_sigsegv;
512
513         /* Set up to return from userspace.  If provided, use a stub
514            already in userspace.  */
515         if (ka->ka_restorer) {
516                 r26 = (unsigned long) ka->ka_restorer;
517         } else {
518                 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
519                 err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
520                                   frame->retcode+1);
521                 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
522                 imb();
523                 r26 = (unsigned long) frame->retcode;
524         }
525
526         if (err)
527                 goto give_sigsegv;
528
529         /* "Return" to the handler */
530         regs->r26 = r26;
531         regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
532         regs->r16 = sig;                          /* a0: signal number */
533         regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
534         regs->r18 = (unsigned long) &frame->uc;   /* a2: ucontext pointer */
535         wrusp((unsigned long) frame);
536
537 #if DEBUG_SIG
538         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
539                 current->comm, current->pid, frame, regs->pc, regs->r26);
540 #endif
541
542         return 0;
543
544 give_sigsegv:
545         force_sigsegv(sig, current);
546         return -EFAULT;
547 }
548
549
550 /*
551  * OK, we're invoking a handler.
552  */
553 static inline int
554 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
555               sigset_t *oldset, struct pt_regs * regs, struct switch_stack *sw)
556 {
557         int ret;
558
559         if (ka->sa.sa_flags & SA_SIGINFO)
560                 ret = setup_rt_frame(sig, ka, info, oldset, regs, sw);
561         else
562                 ret = setup_frame(sig, ka, oldset, regs, sw);
563
564         if (ret == 0) {
565                 spin_lock_irq(&current->sighand->siglock);
566                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
567                 if (!(ka->sa.sa_flags & SA_NODEFER)) 
568                         sigaddset(&current->blocked,sig);
569                 recalc_sigpending();
570                 spin_unlock_irq(&current->sighand->siglock);
571         }
572
573         return ret;
574 }
575
576 static inline void
577 syscall_restart(unsigned long r0, unsigned long r19,
578                 struct pt_regs *regs, struct k_sigaction *ka)
579 {
580         switch (regs->r0) {
581         case ERESTARTSYS:
582                 if (!(ka->sa.sa_flags & SA_RESTART)) {
583                 case ERESTARTNOHAND:
584                         regs->r0 = EINTR;
585                         break;
586                 }
587                 /* fallthrough */
588         case ERESTARTNOINTR:
589                 regs->r0 = r0;  /* reset v0 and a3 and replay syscall */
590                 regs->r19 = r19;
591                 regs->pc -= 4;
592                 break;
593         case ERESTART_RESTARTBLOCK:
594                 current_thread_info()->restart_block.fn = do_no_restart_syscall;
595                 regs->r0 = EINTR;
596                 break;
597         }
598 }
599
600
601 /*
602  * Note that 'init' is a special process: it doesn't get signals it doesn't
603  * want to handle. Thus you cannot kill init even with a SIGKILL even by
604  * mistake.
605  *
606  * Note that we go through the signals twice: once to check the signals that
607  * the kernel can handle, and then we build all the user-level signal handling
608  * stack-frames in one go after that.
609  *
610  * "r0" and "r19" are the registers we need to restore for system call
611  * restart. "r0" is also used as an indicator whether we can restart at
612  * all (if we get here from anything but a syscall return, it will be 0)
613  */
614 static void
615 do_signal(struct pt_regs * regs, struct switch_stack * sw,
616           unsigned long r0, unsigned long r19)
617 {
618         siginfo_t info;
619         int signr;
620         unsigned long single_stepping = ptrace_cancel_bpt(current);
621         struct k_sigaction ka;
622         sigset_t *oldset;
623
624         if (test_thread_flag(TIF_RESTORE_SIGMASK))
625                 oldset = &current->saved_sigmask;
626         else
627                 oldset = &current->blocked;
628
629         /* This lets the debugger run, ... */
630         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
631
632         /* ... so re-check the single stepping. */
633         single_stepping |= ptrace_cancel_bpt(current);
634
635         if (signr > 0) {
636                 /* Whee!  Actually deliver the signal.  */
637                 if (r0)
638                         syscall_restart(r0, r19, regs, &ka);
639                 if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {
640                         /* A signal was successfully delivered, and the
641                            saved sigmask was stored on the signal frame,
642                            and will be restored by sigreturn.  So we can
643                            simply clear the restore sigmask flag.  */
644                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
645                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
646                 }
647                 if (single_stepping) 
648                         ptrace_set_bpt(current); /* re-set bpt */
649                 return;
650         }
651
652         if (r0) {
653                 switch (regs->r0) {
654                 case ERESTARTNOHAND:
655                 case ERESTARTSYS:
656                 case ERESTARTNOINTR:
657                         /* Reset v0 and a3 and replay syscall.  */
658                         regs->r0 = r0;
659                         regs->r19 = r19;
660                         regs->pc -= 4;
661                         break;
662                 case ERESTART_RESTARTBLOCK:
663                         /* Force v0 to the restart syscall and reply.  */
664                         regs->r0 = __NR_restart_syscall;
665                         regs->pc -= 4;
666                         break;
667                 }
668         }
669
670         /* If there's no signal to deliver, we just restore the saved mask.  */
671         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
672                 clear_thread_flag(TIF_RESTORE_SIGMASK);
673                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
674         }
675
676         if (single_stepping)
677                 ptrace_set_bpt(current);        /* re-set breakpoint */
678 }
679
680 void
681 do_notify_resume(struct pt_regs *regs, struct switch_stack *sw,
682                  unsigned long thread_info_flags,
683                  unsigned long r0, unsigned long r19)
684 {
685         if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
686                 do_signal(regs, sw, r0, r19);
687
688         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
689                 clear_thread_flag(TIF_NOTIFY_RESUME);
690                 tracehook_notify_resume(regs);
691                 if (current->replacement_session_keyring)
692                         key_replace_session_keyring();
693         }
694 }