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