File: /usr/src/linux/arch/i386/kernel/signal.c
1 /*
2 * linux/arch/i386/kernel/signal.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
7 * 2000-06-20 Pentium III FXSR, SSE support by Gareth Hughes
8 */
9
10 #include <linux/sched.h>
11 #include <linux/mm.h>
12 #include <linux/smp.h>
13 #include <linux/smp_lock.h>
14 #include <linux/kernel.h>
15 #include <linux/signal.h>
16 #include <linux/errno.h>
17 #include <linux/wait.h>
18 #include <linux/ptrace.h>
19 #include <linux/unistd.h>
20 #include <linux/stddef.h>
21 #include <linux/tty.h>
22 #include <linux/personality.h>
23 #include <asm/ucontext.h>
24 #include <asm/uaccess.h>
25 #include <asm/i387.h>
26
27 #define DEBUG_SIG 0
28
29 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
30
31 asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
32
33 int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
34 {
35 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
36 return -EFAULT;
37 if (from->si_code < 0)
38 return __copy_to_user(to, from, sizeof(siginfo_t));
39 else {
40 int err;
41
42 /* If you change siginfo_t structure, please be sure
43 this code is fixed accordingly.
44 It should never copy any pad contained in the structure
45 to avoid security leaks, but must copy the generic
46 3 ints plus the relevant union member. */
47 err = __put_user(from->si_signo, &to->si_signo);
48 err |= __put_user(from->si_errno, &to->si_errno);
49 err |= __put_user((short)from->si_code, &to->si_code);
50 /* First 32bits of unions are always present. */
51 err |= __put_user(from->si_pid, &to->si_pid);
52 switch (from->si_code >> 16) {
53 case __SI_FAULT >> 16:
54 break;
55 case __SI_CHLD >> 16:
56 err |= __put_user(from->si_utime, &to->si_utime);
57 err |= __put_user(from->si_stime, &to->si_stime);
58 err |= __put_user(from->si_status, &to->si_status);
59 default:
60 err |= __put_user(from->si_uid, &to->si_uid);
61 break;
62 /* case __SI_RT: This is not generated by the kernel as of now. */
63 }
64 return err;
65 }
66 }
67
68 /*
69 * Atomically swap in the new signal mask, and wait for a signal.
70 */
71 asmlinkage int
72 sys_sigsuspend(int history0, int history1, old_sigset_t mask)
73 {
74 struct pt_regs * regs = (struct pt_regs *) &history0;
75 sigset_t saveset;
76
77 mask &= _BLOCKABLE;
78 spin_lock_irq(¤t->sigmask_lock);
79 saveset = current->blocked;
80 siginitset(¤t->blocked, mask);
81 recalc_sigpending(current);
82 spin_unlock_irq(¤t->sigmask_lock);
83
84 regs->eax = -EINTR;
85 while (1) {
86 current->state = TASK_INTERRUPTIBLE;
87 schedule();
88 if (do_signal(regs, &saveset))
89 return -EINTR;
90 }
91 }
92
93 asmlinkage int
94 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize)
95 {
96 struct pt_regs * regs = (struct pt_regs *) &unewset;
97 sigset_t saveset, newset;
98
99 /* XXX: Don't preclude handling different sized sigset_t's. */
100 if (sigsetsize != sizeof(sigset_t))
101 return -EINVAL;
102
103 if (copy_from_user(&newset, unewset, sizeof(newset)))
104 return -EFAULT;
105 sigdelsetmask(&newset, ~_BLOCKABLE);
106
107 spin_lock_irq(¤t->sigmask_lock);
108 saveset = current->blocked;
109 current->blocked = newset;
110 recalc_sigpending(current);
111 spin_unlock_irq(¤t->sigmask_lock);
112
113 regs->eax = -EINTR;
114 while (1) {
115 current->state = TASK_INTERRUPTIBLE;
116 schedule();
117 if (do_signal(regs, &saveset))
118 return -EINTR;
119 }
120 }
121
122 asmlinkage int
123 sys_sigaction(int sig, const struct old_sigaction *act,
124 struct old_sigaction *oact)
125 {
126 struct k_sigaction new_ka, old_ka;
127 int ret;
128
129 if (act) {
130 old_sigset_t mask;
131 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
132 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
133 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
134 return -EFAULT;
135 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
136 __get_user(mask, &act->sa_mask);
137 siginitset(&new_ka.sa.sa_mask, mask);
138 }
139
140 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
141
142 if (!ret && oact) {
143 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
144 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
145 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
146 return -EFAULT;
147 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
148 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
149 }
150
151 return ret;
152 }
153
154 asmlinkage int
155 sys_sigaltstack(const stack_t *uss, stack_t *uoss)
156 {
157 struct pt_regs *regs = (struct pt_regs *) &uss;
158 return do_sigaltstack(uss, uoss, regs->esp);
159 }
160
161
162 /*
163 * Do a signal return; undo the signal stack.
164 */
165
166 struct sigframe
167 {
168 char *pretcode;
169 int sig;
170 struct sigcontext sc;
171 struct _fpstate fpstate;
172 unsigned long extramask[_NSIG_WORDS-1];
173 char retcode[8];
174 };
175
176 struct rt_sigframe
177 {
178 char *pretcode;
179 int sig;
180 struct siginfo *pinfo;
181 void *puc;
182 struct siginfo info;
183 struct ucontext uc;
184 struct _fpstate fpstate;
185 char retcode[8];
186 };
187
188 static int
189 restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc, int *peax)
190 {
191 unsigned int err = 0;
192
193 #define COPY(x) err |= __get_user(regs->x, &sc->x)
194
195 #define COPY_SEG(seg) \
196 { unsigned short tmp; \
197 err |= __get_user(tmp, &sc->seg); \
198 regs->x##seg = tmp; }
199
200 #define COPY_SEG_STRICT(seg) \
201 { unsigned short tmp; \
202 err |= __get_user(tmp, &sc->seg); \
203 regs->x##seg = tmp|3; }
204
205 #define GET_SEG(seg) \
206 { unsigned short tmp; \
207 err |= __get_user(tmp, &sc->seg); \
208 loadsegment(seg,tmp); }
209
210 GET_SEG(gs);
211 GET_SEG(fs);
212 COPY_SEG(es);
213 COPY_SEG(ds);
214 COPY(edi);
215 COPY(esi);
216 COPY(ebp);
217 COPY(esp);
218 COPY(ebx);
219 COPY(edx);
220 COPY(ecx);
221 COPY(eip);
222 COPY_SEG_STRICT(cs);
223 COPY_SEG_STRICT(ss);
224
225 {
226 unsigned int tmpflags;
227 err |= __get_user(tmpflags, &sc->eflags);
228 regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
229 regs->orig_eax = -1; /* disable syscall checks */
230 }
231
232 {
233 struct _fpstate * buf;
234 err |= __get_user(buf, &sc->fpstate);
235 if (buf) {
236 if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
237 goto badframe;
238 err |= restore_i387(buf);
239 }
240 }
241
242 err |= __get_user(*peax, &sc->eax);
243 return err;
244
245 badframe:
246 return 1;
247 }
248
249 asmlinkage int sys_sigreturn(unsigned long __unused)
250 {
251 struct pt_regs *regs = (struct pt_regs *) &__unused;
252 struct sigframe *frame = (struct sigframe *)(regs->esp - 8);
253 sigset_t set;
254 int eax;
255
256 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
257 goto badframe;
258 if (__get_user(set.sig[0], &frame->sc.oldmask)
259 || (_NSIG_WORDS > 1
260 && __copy_from_user(&set.sig[1], &frame->extramask,
261 sizeof(frame->extramask))))
262 goto badframe;
263
264 sigdelsetmask(&set, ~_BLOCKABLE);
265 spin_lock_irq(¤t->sigmask_lock);
266 current->blocked = set;
267 recalc_sigpending(current);
268 spin_unlock_irq(¤t->sigmask_lock);
269
270 if (restore_sigcontext(regs, &frame->sc, &eax))
271 goto badframe;
272 return eax;
273
274 badframe:
275 force_sig(SIGSEGV, current);
276 return 0;
277 }
278
279 asmlinkage int sys_rt_sigreturn(unsigned long __unused)
280 {
281 struct pt_regs *regs = (struct pt_regs *) &__unused;
282 struct rt_sigframe *frame = (struct rt_sigframe *)(regs->esp - 4);
283 sigset_t set;
284 stack_t st;
285 int eax;
286
287 if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
288 goto badframe;
289 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
290 goto badframe;
291
292 sigdelsetmask(&set, ~_BLOCKABLE);
293 spin_lock_irq(¤t->sigmask_lock);
294 current->blocked = set;
295 recalc_sigpending(current);
296 spin_unlock_irq(¤t->sigmask_lock);
297
298 if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &eax))
299 goto badframe;
300
301 if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
302 goto badframe;
303 /* It is more difficult to avoid calling this function than to
304 call it and ignore errors. */
305 do_sigaltstack(&st, NULL, regs->esp);
306
307 return eax;
308
309 badframe:
310 force_sig(SIGSEGV, current);
311 return 0;
312 }
313
314 /*
315 * Set up a signal frame.
316 */
317
318 static int
319 setup_sigcontext(struct sigcontext *sc, struct _fpstate *fpstate,
320 struct pt_regs *regs, unsigned long mask)
321 {
322 int tmp, err = 0;
323
324 tmp = 0;
325 __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
326 err |= __put_user(tmp, (unsigned int *)&sc->gs);
327 __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
328 err |= __put_user(tmp, (unsigned int *)&sc->fs);
329
330 err |= __put_user(regs->xes, (unsigned int *)&sc->es);
331 err |= __put_user(regs->xds, (unsigned int *)&sc->ds);
332 err |= __put_user(regs->edi, &sc->edi);
333 err |= __put_user(regs->esi, &sc->esi);
334 err |= __put_user(regs->ebp, &sc->ebp);
335 err |= __put_user(regs->esp, &sc->esp);
336 err |= __put_user(regs->ebx, &sc->ebx);
337 err |= __put_user(regs->edx, &sc->edx);
338 err |= __put_user(regs->ecx, &sc->ecx);
339 err |= __put_user(regs->eax, &sc->eax);
340 err |= __put_user(current->thread.trap_no, &sc->trapno);
341 err |= __put_user(current->thread.error_code, &sc->err);
342 err |= __put_user(regs->eip, &sc->eip);
343 err |= __put_user(regs->xcs, (unsigned int *)&sc->cs);
344 err |= __put_user(regs->eflags, &sc->eflags);
345 err |= __put_user(regs->esp, &sc->esp_at_signal);
346 err |= __put_user(regs->xss, (unsigned int *)&sc->ss);
347
348 tmp = save_i387(fpstate);
349 if (tmp < 0)
350 err = 1;
351 else
352 err |= __put_user(tmp ? fpstate : NULL, &sc->fpstate);
353
354 /* non-iBCS2 extensions.. */
355 err |= __put_user(mask, &sc->oldmask);
356 err |= __put_user(current->thread.cr2, &sc->cr2);
357
358 return err;
359 }
360
361 /*
362 * Determine which stack to use..
363 */
364 static inline void *
365 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
366 {
367 unsigned long esp;
368
369 /* Default to using normal stack */
370 esp = regs->esp;
371
372 /* This is the X/Open sanctioned signal stack switching. */
373 if (ka->sa.sa_flags & SA_ONSTACK) {
374 if (sas_ss_flags(esp) == 0)
375 esp = current->sas_ss_sp + current->sas_ss_size;
376 }
377
378 /* This is the legacy signal stack switching. */
379 else if ((regs->xss & 0xffff) != __USER_DS &&
380 !(ka->sa.sa_flags & SA_RESTORER) &&
381 ka->sa.sa_restorer) {
382 esp = (unsigned long) ka->sa.sa_restorer;
383 }
384
385 return (void *)((esp - frame_size) & -8ul);
386 }
387
388 static void setup_frame(int sig, struct k_sigaction *ka,
389 sigset_t *set, struct pt_regs * regs)
390 {
391 struct sigframe *frame;
392 int err = 0;
393
394 frame = get_sigframe(ka, regs, sizeof(*frame));
395
396 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
397 goto give_sigsegv;
398
399 err |= __put_user((current->exec_domain
400 && current->exec_domain->signal_invmap
401 && sig < 32
402 ? current->exec_domain->signal_invmap[sig]
403 : sig),
404 &frame->sig);
405 if (err)
406 goto give_sigsegv;
407
408 err |= setup_sigcontext(&frame->sc, &frame->fpstate, regs, set->sig[0]);
409 if (err)
410 goto give_sigsegv;
411
412 if (_NSIG_WORDS > 1) {
413 err |= __copy_to_user(frame->extramask, &set->sig[1],
414 sizeof(frame->extramask));
415 }
416 if (err)
417 goto give_sigsegv;
418
419 /* Set up to return from userspace. If provided, use a stub
420 already in userspace. */
421 if (ka->sa.sa_flags & SA_RESTORER) {
422 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
423 } else {
424 err |= __put_user(frame->retcode, &frame->pretcode);
425 /* This is popl %eax ; movl $,%eax ; int $0x80 */
426 err |= __put_user(0xb858, (short *)(frame->retcode+0));
427 err |= __put_user(__NR_sigreturn, (int *)(frame->retcode+2));
428 err |= __put_user(0x80cd, (short *)(frame->retcode+6));
429 }
430
431 if (err)
432 goto give_sigsegv;
433
434 /* Set up registers for signal handler */
435 regs->esp = (unsigned long) frame;
436 regs->eip = (unsigned long) ka->sa.sa_handler;
437
438 set_fs(USER_DS);
439 regs->xds = __USER_DS;
440 regs->xes = __USER_DS;
441 regs->xss = __USER_DS;
442 regs->xcs = __USER_CS;
443 regs->eflags &= ~TF_MASK;
444
445 #if DEBUG_SIG
446 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
447 current->comm, current->pid, frame, regs->eip, frame->pretcode);
448 #endif
449
450 return;
451
452 give_sigsegv:
453 if (sig == SIGSEGV)
454 ka->sa.sa_handler = SIG_DFL;
455 force_sig(SIGSEGV, current);
456 }
457
458 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
459 sigset_t *set, struct pt_regs * regs)
460 {
461 struct rt_sigframe *frame;
462 int err = 0;
463
464 frame = get_sigframe(ka, regs, sizeof(*frame));
465
466 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
467 goto give_sigsegv;
468
469 err |= __put_user((current->exec_domain
470 && current->exec_domain->signal_invmap
471 && sig < 32
472 ? current->exec_domain->signal_invmap[sig]
473 : sig),
474 &frame->sig);
475 err |= __put_user(&frame->info, &frame->pinfo);
476 err |= __put_user(&frame->uc, &frame->puc);
477 err |= copy_siginfo_to_user(&frame->info, info);
478 if (err)
479 goto give_sigsegv;
480
481 /* Create the ucontext. */
482 err |= __put_user(0, &frame->uc.uc_flags);
483 err |= __put_user(0, &frame->uc.uc_link);
484 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
485 err |= __put_user(sas_ss_flags(regs->esp),
486 &frame->uc.uc_stack.ss_flags);
487 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
488 err |= setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
489 regs, set->sig[0]);
490 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
491 if (err)
492 goto give_sigsegv;
493
494 /* Set up to return from userspace. If provided, use a stub
495 already in userspace. */
496 if (ka->sa.sa_flags & SA_RESTORER) {
497 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
498 } else {
499 err |= __put_user(frame->retcode, &frame->pretcode);
500 /* This is movl $,%eax ; int $0x80 */
501 err |= __put_user(0xb8, (char *)(frame->retcode+0));
502 err |= __put_user(__NR_rt_sigreturn, (int *)(frame->retcode+1));
503 err |= __put_user(0x80cd, (short *)(frame->retcode+5));
504 }
505
506 if (err)
507 goto give_sigsegv;
508
509 /* Set up registers for signal handler */
510 regs->esp = (unsigned long) frame;
511 regs->eip = (unsigned long) ka->sa.sa_handler;
512
513 set_fs(USER_DS);
514 regs->xds = __USER_DS;
515 regs->xes = __USER_DS;
516 regs->xss = __USER_DS;
517 regs->xcs = __USER_CS;
518 regs->eflags &= ~TF_MASK;
519
520 #if DEBUG_SIG
521 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
522 current->comm, current->pid, frame, regs->eip, frame->pretcode);
523 #endif
524
525 return;
526
527 give_sigsegv:
528 if (sig == SIGSEGV)
529 ka->sa.sa_handler = SIG_DFL;
530 force_sig(SIGSEGV, current);
531 }
532
533 /*
534 * OK, we're invoking a handler
535 */
536
537 static void
538 handle_signal(unsigned long sig, struct k_sigaction *ka,
539 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
540 {
541 /* Are we from a system call? */
542 if (regs->orig_eax >= 0) {
543 /* If so, check system call restarting.. */
544 switch (regs->eax) {
545 case -ERESTARTNOHAND:
546 regs->eax = -EINTR;
547 break;
548
549 case -ERESTARTSYS:
550 if (!(ka->sa.sa_flags & SA_RESTART)) {
551 regs->eax = -EINTR;
552 break;
553 }
554 /* fallthrough */
555 case -ERESTARTNOINTR:
556 regs->eax = regs->orig_eax;
557 regs->eip -= 2;
558 }
559 }
560
561 /* Set up the stack frame */
562 if (ka->sa.sa_flags & SA_SIGINFO)
563 setup_rt_frame(sig, ka, info, oldset, regs);
564 else
565 setup_frame(sig, ka, oldset, regs);
566
567 if (ka->sa.sa_flags & SA_ONESHOT)
568 ka->sa.sa_handler = SIG_DFL;
569
570 if (!(ka->sa.sa_flags & SA_NODEFER)) {
571 spin_lock_irq(¤t->sigmask_lock);
572 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
573 sigaddset(¤t->blocked,sig);
574 recalc_sigpending(current);
575 spin_unlock_irq(¤t->sigmask_lock);
576 }
577 }
578
579 /*
580 * Note that 'init' is a special process: it doesn't get signals it doesn't
581 * want to handle. Thus you cannot kill init even with a SIGKILL even by
582 * mistake.
583 */
584 int do_signal(struct pt_regs *regs, sigset_t *oldset)
585 {
586 siginfo_t info;
587 struct k_sigaction *ka;
588
589 /*
590 * We want the common case to go fast, which
591 * is why we may in certain cases get here from
592 * kernel mode. Just return without doing anything
593 * if so.
594 */
595 if ((regs->xcs & 3) != 3)
596 return 1;
597
598 if (!oldset)
599 oldset = ¤t->blocked;
600
601 for (;;) {
602 unsigned long signr;
603
604 spin_lock_irq(¤t->sigmask_lock);
605 signr = dequeue_signal(¤t->blocked, &info);
606 spin_unlock_irq(¤t->sigmask_lock);
607
608 if (!signr)
609 break;
610
611 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
612 /* Let the debugger run. */
613 current->exit_code = signr;
614 current->state = TASK_STOPPED;
615 notify_parent(current, SIGCHLD);
616 schedule();
617
618 /* We're back. Did the debugger cancel the sig? */
619 if (!(signr = current->exit_code))
620 continue;
621 current->exit_code = 0;
622
623 /* The debugger continued. Ignore SIGSTOP. */
624 if (signr == SIGSTOP)
625 continue;
626
627 /* Update the siginfo structure. Is this good? */
628 if (signr != info.si_signo) {
629 info.si_signo = signr;
630 info.si_errno = 0;
631 info.si_code = SI_USER;
632 info.si_pid = current->p_pptr->pid;
633 info.si_uid = current->p_pptr->uid;
634 }
635
636 /* If the (new) signal is now blocked, requeue it. */
637 if (sigismember(¤t->blocked, signr)) {
638 send_sig_info(signr, &info, current);
639 continue;
640 }
641 }
642
643 ka = ¤t->sig->action[signr-1];
644 if (ka->sa.sa_handler == SIG_IGN) {
645 if (signr != SIGCHLD)
646 continue;
647 /* Check for SIGCHLD: it's special. */
648 while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
649 /* nothing */;
650 continue;
651 }
652
653 if (ka->sa.sa_handler == SIG_DFL) {
654 int exit_code = signr;
655
656 /* Init gets no signals it doesn't want. */
657 if (current->pid == 1)
658 continue;
659
660 switch (signr) {
661 case SIGCONT: case SIGCHLD: case SIGWINCH:
662 continue;
663
664 case SIGTSTP: case SIGTTIN: case SIGTTOU:
665 if (is_orphaned_pgrp(current->pgrp))
666 continue;
667 /* FALLTHRU */
668
669 case SIGSTOP: {
670 struct signal_struct *sig;
671 current->state = TASK_STOPPED;
672 current->exit_code = signr;
673 sig = current->p_pptr->sig;
674 if (sig && !(sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
675 notify_parent(current, SIGCHLD);
676 schedule();
677 continue;
678 }
679
680 case SIGQUIT: case SIGILL: case SIGTRAP:
681 case SIGABRT: case SIGFPE: case SIGSEGV:
682 case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
683 if (do_coredump(signr, regs))
684 exit_code |= 0x80;
685 /* FALLTHRU */
686
687 default:
688 sigaddset(¤t->pending.signal, signr);
689 recalc_sigpending(current);
690 current->flags |= PF_SIGNALED;
691 do_exit(exit_code);
692 /* NOTREACHED */
693 }
694 }
695
696 /* Reenable any watchpoints before delivering the
697 * signal to user space. The processor register will
698 * have been cleared if the watchpoint triggered
699 * inside the kernel.
700 */
701 __asm__("movl %0,%%db7" : : "r" (current->thread.debugreg[7]));
702
703 /* Whee! Actually deliver the signal. */
704 handle_signal(signr, ka, &info, oldset, regs);
705 return 1;
706 }
707
708 /* Did we come from a system call? */
709 if (regs->orig_eax >= 0) {
710 /* Restart the system call - no handlers present */
711 if (regs->eax == -ERESTARTNOHAND ||
712 regs->eax == -ERESTARTSYS ||
713 regs->eax == -ERESTARTNOINTR) {
714 regs->eax = regs->orig_eax;
715 regs->eip -= 2;
716 }
717 }
718 return 0;
719 }
720