LXR linux-old/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
  31int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
  32
  33int 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 */
  71asmlinkage int
  72sys_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(&current->sigmask_lock);
  79        saveset = current->blocked;
  80        siginitset(&current->blocked, mask);
  81        recalc_sigpending(current);
  82        spin_unlock_irq(&current->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
  93asmlinkage int
  94sys_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(&current->sigmask_lock);
 108        saveset = current->blocked;
 109        current->blocked = newset;
 110        recalc_sigpending(current);
 111        spin_unlock_irq(&current->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
 122asmlinkage int 
 123sys_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
 154asmlinkage int
 155sys_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
 166struct 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
 176struct 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
 188static int
 189restore_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
 245badframe:
 246        return 1;
 247}
 248
 249asmlinkage 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(&current->sigmask_lock);
 266        current->blocked = set;
 267        recalc_sigpending(current);
 268        spin_unlock_irq(&current->sigmask_lock);
 269        
 270        if (restore_sigcontext(regs, &frame->sc, &eax))
 271                goto badframe;
 272        return eax;
 273
 274badframe:
 275        force_sig(SIGSEGV, current);
 276        return 0;
 277}       
 278
 279asmlinkage 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(&current->sigmask_lock);
 294        current->blocked = set;
 295        recalc_sigpending(current);
 296        spin_unlock_irq(&current->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
 309badframe:
 310        force_sig(SIGSEGV, current);
 311        return 0;
 312}       
 313
 314/*
 315 * Set up a signal frame.
 316 */
 317
 318static int
 319setup_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 */
 364static inline void *
 365get_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
 388static 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
 452give_sigsegv:
 453        if (sig == SIGSEGV)
 454                ka->sa.sa_handler = SIG_DFL;
 455        force_sig(SIGSEGV, current);
 456}
 457
 458static 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
 527give_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
 537static void
 538handle_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(&current->sigmask_lock);
 572                sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 573                sigaddset(&current->blocked,sig);
 574                recalc_sigpending(current);
 575                spin_unlock_irq(&current->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 */
 584int 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 = &current->blocked;
 600
 601        for (;;) {
 602                unsigned long signr;
 603
 604                spin_lock_irq(&current->sigmask_lock);
 605                signr = dequeue_signal(&current->blocked, &info);
 606                spin_unlock_irq(&current->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(&current->blocked, signr)) {
 638                                send_sig_info(signr, &info, current);
 639                                continue;
 640                        }
 641                }
 642
 643                ka = &current->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: case SIGURG:
 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                                sig_exit(signr, exit_code, &info);
 689                                /* NOTREACHED */
 690                        }
 691                }
 692
 693                /* Reenable any watchpoints before delivering the
 694                 * signal to user space. The processor register will
 695                 * have been cleared if the watchpoint triggered
 696                 * inside the kernel.
 697                 */
 698                __asm__("movl %0,%%db7" : : "r" (current->thread.debugreg[7]));
 699
 700                /* Whee!  Actually deliver the signal.  */
 701                handle_signal(signr, ka, &info, oldset, regs);
 702                return 1;
 703        }
 704
 705        /* Did we come from a system call? */
 706        if (regs->orig_eax >= 0) {
 707                /* Restart the system call - no handlers present */
 708                if (regs->eax == -ERESTARTNOHAND ||
 709                    regs->eax == -ERESTARTSYS ||
 710                    regs->eax == -ERESTARTNOINTR) {
 711                        regs->eax = regs->orig_eax;
 712                        regs->eip -= 2;
 713                }
 714        }
 715        return 0;
 716}
 717