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