?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mm-only debug patch...
[mmotm.git] / arch / alpha / kernel / signal.c
blob0932dbb1ef8eff444943645e15b0802b1d4cf5d5
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 }
mm of the moment repository