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