ia64/linux-2.6.18-xen.hg

view arch/alpha/kernel/signal.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
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 */
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>
24 #include <asm/uaccess.h>
25 #include <asm/sigcontext.h>
26 #include <asm/ucontext.h>
28 #include "proto.h"
31 #define DEBUG_SIG 0
33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
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);
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;
60 if ((unsigned long)how-1 <= 2) {
61 long sign = how-2; /* -1 .. 1 */
62 unsigned long block, unblock;
64 newmask &= _BLOCKABLE;
65 spin_lock_irq(&current->sighand->siglock);
66 oldmask = current->blocked.sig[0];
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);
80 regs->r0 = 0; /* special no error return */
81 }
82 return oldmask;
83 }
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;
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 }
103 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
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 }
113 return ret;
114 }
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;
124 /* XXX: Don't preclude handling different sized sigset_t's. */
125 if (sigsetsize != sizeof(sigset_t))
126 return -EINVAL;
128 if (act) {
129 new_ka.ka_restorer = restorer;
130 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
131 return -EFAULT;
132 }
134 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
136 if (!ret && oact) {
137 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
138 return -EFAULT;
139 }
141 return ret;
142 }
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;
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);
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;
164 while (1) {
165 current->state = TASK_INTERRUPTIBLE;
166 schedule();
167 if (do_signal(&oldset, regs, sw, 0, 0))
168 return -EINTR;
169 }
170 }
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;
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;
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);
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;
196 while (1) {
197 current->state = TASK_INTERRUPTIBLE;
198 schedule();
199 if (do_signal(&oldset, regs, sw, 0, 0))
200 return -EINTR;
201 }
202 }
204 asmlinkage int
205 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
206 {
207 return do_sigaltstack(uss, uoss, rdusp());
208 }
210 /*
211 * Do a signal return; undo the signal stack.
212 */
214 #if _NSIG_WORDS > 1
215 # error "Non SA_SIGINFO frame needs rearranging"
216 #endif
218 struct sigframe
219 {
220 struct sigcontext sc;
221 unsigned int retcode[3];
222 };
224 struct rt_sigframe
225 {
226 struct siginfo info;
227 struct ucontext uc;
228 unsigned int retcode[3];
229 };
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];
237 #define INSN_MOV_R30_R16 0x47fe0410
238 #define INSN_LDI_R0 0x201f0000
239 #define INSN_CALLSYS 0x00000083
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);
248 sw->r26 = (unsigned long) ret_from_sys_call;
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);
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);
287 return err;
288 }
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. */
294 asmlinkage void
295 do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
296 struct switch_stack *sw)
297 {
298 sigset_t set;
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;
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);
312 if (restore_sigcontext(sc, regs, sw))
313 goto give_sigsegv;
315 /* Send SIGTRAP if we're single-stepping: */
316 if (ptrace_cancel_bpt (current)) {
317 siginfo_t info;
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;
328 give_sigsegv:
329 force_sig(SIGSEGV, current);
330 }
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;
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;
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);
350 if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
351 goto give_sigsegv;
353 /* Send SIGTRAP if we're single-stepping: */
354 if (ptrace_cancel_bpt (current)) {
355 siginfo_t info;
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;
366 give_sigsegv:
367 force_sig(SIGSEGV, current);
368 }
371 /*
372 * Set up a signal frame.
373 */
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;
381 return (void __user *)((sp - frame_size) & -32ul);
382 }
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;
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);
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);
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);
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);
437 return err;
438 }
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;
447 oldsp = rdusp();
448 frame = get_sigframe(ka, oldsp, sizeof(*frame));
449 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
450 goto give_sigsegv;
452 err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
453 if (err)
454 goto give_sigsegv;
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 }
468 /* Check that everything was written properly. */
469 if (err)
470 goto give_sigsegv;
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);
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
485 return;
487 give_sigsegv:
488 force_sigsegv(sig, current);
489 }
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;
498 oldsp = rdusp();
499 frame = get_sigframe(ka, oldsp, sizeof(*frame));
500 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
501 goto give_sigsegv;
503 err |= copy_siginfo_to_user(&frame->info, info);
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;
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 }
531 if (err)
532 goto give_sigsegv;
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);
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
547 return;
549 give_sigsegv:
550 force_sigsegv(sig, current);
551 }
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);
566 if (ka->sa.sa_flags & SA_RESETHAND)
567 ka->sa.sa_handler = SIG_DFL;
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 }
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 }
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;
624 if (!oldset)
625 oldset = &current->blocked;
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);
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 }
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 */
661 return 0;
662 }
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 }