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