arch/mips/kernel/signal.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1991, 1992  Linus Torvalds
   7  * Copyright (C) 1994 - 1999  Ralf Baechle
   8  * Copyright (C) 1999 Silicon Graphics, Inc.
   9  */
  10 #include <linux/config.h>
  11 #include <linux/sched.h>
  12 #include <linux/mm.h>
  13 #include <linux/smp.h>
  14 #include <linux/smp_lock.h>
  15 #include <linux/kernel.h>
  16 #include <linux/signal.h>
  17 #include <linux/errno.h>
  18 #include <linux/wait.h>
  19 #include <linux/ptrace.h>
  20 #include <linux/unistd.h>
  21
  22 #include <asm/asm.h>
  23 #include <asm/bitops.h>
  24 #include <asm/pgalloc.h>
  25 #include <asm/stackframe.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/ucontext.h>
  28
  29 #define DEBUG_SIG 0
  30
  31 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  32
  33 extern asmlinkage int sys_wait4(pid_t pid, unsigned long *stat_addr,
  34                          int options, unsigned long *ru);
  35 extern asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
  36 extern asmlinkage int save_fp_context(struct sigcontext *sc);
  37 extern asmlinkage int restore_fp_context(struct sigcontext *sc);
  38
  39 extern asmlinkage void syscall_trace(void);
  40
  41 int copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  42 {
  43         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  44                 return -EFAULT;
  45         if (from->si_code < 0)
  46                 return __copy_to_user(to, from, sizeof(siginfo_t));
  47         else {
  48                 int err;
  49
  50                 /* If you change siginfo_t structure, please be sure
  51                    this code is fixed accordingly.
  52                    It should never copy any pad contained in the structure
  53                    to avoid security leaks, but must copy the generic
  54                    3 ints plus the relevant union member.  */
  55                 err = __put_user(from->si_signo, &to->si_signo);
  56                 err |= __put_user(from->si_errno, &to->si_errno);
  57                 err |= __put_user((short)from->si_code, &to->si_code);
  58                 /* First 32bits of unions are always present.  */
  59                 err |= __put_user(from->si_pid, &to->si_pid);
  60                 switch (from->si_code >> 16) {
  61                 case __SI_FAULT >> 16:
  62                         break;
  63                 case __SI_CHLD >> 16:
  64                         err |= __put_user(from->si_utime, &to->si_utime);
  65                         err |= __put_user(from->si_stime, &to->si_stime);
  66                         err |= __put_user(from->si_status, &to->si_status);
  67                 default:
  68                         err |= __put_user(from->si_uid, &to->si_uid);
  69                         break;
  70                 /* case __SI_RT: This is not generated by the kernel as of now.  */
  71                 }
  72                 return err;
  73         }
  74 }
  75
  76 /*
  77  * Atomically swap in the new signal mask, and wait for a signal.
  78  */
  79 asmlinkage inline int
  80 sys_sigsuspend(struct pt_regs regs)
  81 {
  82         sigset_t *uset, saveset, newset;
  83
  84         save_static(&regs);
  85         uset = (sigset_t *) regs.regs[4];
  86         if (copy_from_user(&newset, uset, sizeof(sigset_t)))
  87                 return -EFAULT;
  88         sigdelsetmask(&newset, ~_BLOCKABLE);
  89
  90         spin_lock_irq(&current->sigmask_lock);
  91         saveset = current->blocked;
  92         current->blocked = newset;
  93         recalc_sigpending(current);
  94         spin_unlock_irq(&current->sigmask_lock);
  95
  96         regs.regs[2] = EINTR;
  97         regs.regs[7] = 1;
  98         while (1) {
  99                 current->state = TASK_INTERRUPTIBLE;
 100                 schedule();
 101                 if (do_signal(&saveset, &regs))
 102                         return -EINTR;
 103         }
 104 }
 105
 106 asmlinkage int
 107 sys_rt_sigsuspend(struct pt_regs regs)
 108 {
 109         sigset_t *unewset, saveset, newset;
 110         size_t sigsetsize;
 111
 112         save_static(&regs);
 113
 114         /* XXX Don't preclude handling different sized sigset_t's.  */
 115         sigsetsize = regs.regs[5];
 116         if (sigsetsize != sizeof(sigset_t))
 117                 return -EINVAL;
 118
 119         unewset = (sigset_t *) regs.regs[4];
 120         if (copy_from_user(&newset, unewset, sizeof(newset)))
 121                 return -EFAULT;
 122         sigdelsetmask(&newset, ~_BLOCKABLE);
 123
 124         spin_lock_irq(&current->sigmask_lock);
 125         saveset = current->blocked;
 126         current->blocked = newset;
 127         recalc_sigpending(current);
 128         spin_unlock_irq(&current->sigmask_lock);
 129
 130         regs.regs[2] = EINTR;
 131         regs.regs[7] = 1;
 132         while (1) {
 133                 current->state = TASK_INTERRUPTIBLE;
 134                 schedule();
 135                 if (do_signal(&saveset, &regs))
 136                         return -EINTR;
 137         }
 138 }
 139
 140 asmlinkage int
 141 sys_sigaction(int sig, const struct sigaction *act, struct sigaction *oact)
 142 {
 143         struct k_sigaction new_ka, old_ka;
 144         int ret;
 145         int err = 0;
 146
 147         if (act) {
 148                 old_sigset_t mask;
 149
 150                 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
 151                         return -EFAULT;
 152                 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
 153                 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 154                 err |= __get_user(mask, &act->sa_mask.sig[0]);
 155                 err |= __get_user(new_ka.sa.sa_restorer, &act->sa_restorer);
 156                 if (err)
 157                         return -EFAULT;
 158
 159                 siginitset(&new_ka.sa.sa_mask, mask);
 160         }
 161
 162         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 163
 164         if (!ret && oact) {
 165                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
 166                         return -EFAULT;
 167                 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 168                 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
 169                 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
 170                 err |= __put_user(0, &oact->sa_mask.sig[1]);
 171                 err |= __put_user(0, &oact->sa_mask.sig[2]);
 172                 err |= __put_user(0, &oact->sa_mask.sig[3]);
 173                 err |= __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer);
 174                 if (err)
 175                         return -EFAULT;
 176         }
 177
 178         return ret;
 179 }
 180
 181 asmlinkage int
 182 sys_sigaltstack(struct pt_regs regs)
 183 {
 184         const stack_t *uss = (const stack_t *) regs.regs[4];
 185         stack_t *uoss = (stack_t *) regs.regs[5];
 186         unsigned long usp = regs.regs[29];
 187
 188         return do_sigaltstack(uss, uoss, usp);
 189 }
 190
 191 asmlinkage int
 192 restore_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
 193 {
 194         int owned_fp;
 195         int err = 0;
 196         u64 reg;
 197
 198         err |= __get_user(regs->cp0_epc, &sc->sc_pc);
 199
 200         err |= __get_user(reg, &sc->sc_mdhi);
 201         regs->hi = (int) reg;
 202         err |= __get_user(reg, &sc->sc_mdlo);
 203         regs->lo = (int) reg;
 204
 205 #define restore_gp_reg(i) do {                                          \
 206         err |= __get_user(reg, &sc->sc_regs[i]);                        \
 207         regs->regs[i] = reg;                                            \
 208 } while(0);
 209         restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
 210         restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
 211         restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
 212         restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
 213         restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
 214         restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
 215         restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
 216         restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
 217         restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
 218         restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
 219         restore_gp_reg(31);
 220 #undef restore_gp_reg
 221
 222         err |= __get_user(owned_fp, &sc->sc_ownedfp);
 223         if (owned_fp) {
 224                 err |= restore_fp_context(sc);
 225                 last_task_used_math = current;
 226         }
 227
 228         return err;
 229 }
 230
 231 struct sigframe {
 232         u32 sf_ass[4];                  /* argument save space for o32 */
 233         u32 sf_code[2];                 /* signal trampoline */
 234         struct sigcontext sf_sc;
 235         sigset_t sf_mask;
 236 };
 237
 238 struct rt_sigframe {
 239         u32 rs_ass[4];                  /* argument save space for o32 */
 240         u32 rs_code[2];                 /* signal trampoline */
 241         struct siginfo rs_info;
 242         struct ucontext rs_uc;
 243 };
 244
 245 asmlinkage void
 246 sys_sigreturn(struct pt_regs regs)
 247 {
 248         struct sigframe *frame;
 249         sigset_t blocked;
 250
 251         frame = (struct sigframe *) regs.regs[29];
 252         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 253                 goto badframe;
 254         if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
 255                 goto badframe;
 256
 257         sigdelsetmask(&blocked, ~_BLOCKABLE);
 258         spin_lock_irq(&current->sigmask_lock);
 259         current->blocked = blocked;
 260         recalc_sigpending(current);
 261         spin_unlock_irq(&current->sigmask_lock);
 262
 263         if (restore_sigcontext(&regs, &frame->sf_sc))
 264                 goto badframe;
 265
 266         /*
 267          * Don't let your children do this ...
 268          */
 269         if (current->ptrace & PT_TRACESYS)
 270                 syscall_trace();
 271         __asm__ __volatile__(
 272                 "move\t$29, %0\n\t"
 273                 "j\tret_from_sys_call"
 274                 :/* no outputs */
 275                 :"r" (&regs));
 276         /* Unreached */
 277
 278 badframe:
 279         force_sig(SIGSEGV, current);
 280 }
 281
 282 asmlinkage void
 283 sys_rt_sigreturn(struct pt_regs regs)
 284 {
 285         struct rt_sigframe *frame;
 286         sigset_t set;
 287         stack_t st;
 288
 289         frame = (struct rt_sigframe *) regs.regs[29];
 290         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 291                 goto badframe;
 292         if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
 293                 goto badframe;
 294
 295         sigdelsetmask(&set, ~_BLOCKABLE);
 296         spin_lock_irq(&current->sigmask_lock);
 297         current->blocked = set;
 298         recalc_sigpending(current);
 299         spin_unlock_irq(&current->sigmask_lock);
 300
 301         if (restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext))
 302                 goto badframe;
 303
 304         if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
 305                 goto badframe;
 306         /* It is more difficult to avoid calling this function than to
 307            call it and ignore errors.  */
 308         do_sigaltstack(&st, NULL, regs.regs[29]);
 309
 310         /*
 311          * Don't let your children do this ...
 312          */
 313         __asm__ __volatile__(
 314                 "move\t$29, %0\n\t"
 315                 "j\tret_from_sys_call"
 316                 :/* no outputs */
 317                 :"r" (&regs));
 318         /* Unreached */
 319
 320 badframe:
 321         force_sig(SIGSEGV, current);
 322 }
 323
 324 static int inline
 325 setup_sigcontext(struct pt_regs *regs, struct sigcontext *sc)
 326 {
 327         int owned_fp;
 328         int err = 0;
 329         u64 reg;
 330
 331         err |= __put_user(regs->cp0_epc, &sc->sc_pc);
 332         err |= __put_user(regs->cp0_status, &sc->sc_status);
 333
 334 #define save_gp_reg(i) {                                                \
 335         reg = regs->regs[i];                                            \
 336         err |= __put_user(reg, &sc->sc_regs[i]);                        \
 337 } while(0)
 338         __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
 339         save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
 340         save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
 341         save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
 342         save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
 343         save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
 344         save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
 345         save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
 346         save_gp_reg(31);
 347 #undef save_gp_reg
 348
 349         err |= __put_user(regs->hi, &sc->sc_mdhi);
 350         err |= __put_user(regs->lo, &sc->sc_mdlo);
 351         err |= __put_user(regs->cp0_cause, &sc->sc_cause);
 352         err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
 353
 354         owned_fp = (current == last_task_used_math);
 355         err |= __put_user(owned_fp, &sc->sc_ownedfp);
 356
 357         if (current->used_math) {       /* fp is active.  */
 358                 set_cp0_status(ST0_CU1, ST0_CU1);
 359                 err |= save_fp_context(sc);
 360                 last_task_used_math = NULL;
 361                 regs->cp0_status &= ~ST0_CU1;
 362                 current->used_math = 0;
 363         }
 364
 365         return err;
 366 }
 367
 368 /*
 369  * Determine which stack to use..
 370  */
 371 static inline void *
 372 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 373 {
 374         unsigned long sp;
 375
 376         /* Default to using normal stack */
 377         sp = regs->regs[29];
 378
 379         /* This is the X/Open sanctioned signal stack switching.  */
 380         if ((ka->sa.sa_flags & SA_ONSTACK) && ! on_sig_stack(sp))
 381                 sp = current->sas_ss_sp + current->sas_ss_size;
 382
 383         return (void *)((sp - frame_size) & ALMASK);
 384 }
 385
 386 static void inline
 387 setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
 388             int signr, sigset_t *set)
 389 {
 390         struct sigframe *frame;
 391         int err = 0;
 392
 393         frame = get_sigframe(ka, regs, sizeof(*frame));
 394         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 395                 goto give_sigsegv;
 396
 397         /* Set up to return from userspace.  If provided, use a stub already
 398            in userspace.  */
 399         if (ka->sa.sa_flags & SA_RESTORER)
 400                 regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
 401         else {
 402                 /*
 403                  * Set up the return code ...
 404                  *
 405                  *         li      v0, __NR_sigreturn
 406                  *         syscall
 407                  */
 408                 err |= __put_user(0x24020000 + __NR_sigreturn,
 409                                   frame->sf_code + 0);
 410                 err |= __put_user(0x0000000c                 ,
 411                                   frame->sf_code + 1);
 412                 flush_cache_sigtramp((unsigned long) frame->sf_code);
 413         }
 414
 415         err |= setup_sigcontext(regs, &frame->sf_sc);
 416         err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
 417         if (err)
 418                 goto give_sigsegv;
 419
 420         /*
 421          * Arguments to signal handler:
 422          *
 423          *   a0 = signal number
 424          *   a1 = 0 (should be cause)
 425          *   a2 = pointer to struct sigcontext
 426          *
 427          * $25 and c0_epc point to the signal handler, $29 points to the
 428          * struct sigframe.
 429          */
 430         regs->regs[ 4] = signr;
 431         regs->regs[ 5] = 0;
 432         regs->regs[ 6] = (unsigned long) &frame->sf_sc;
 433         regs->regs[29] = (unsigned long) frame;
 434         regs->regs[31] = (unsigned long) frame->sf_code;
 435         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 436
 437 #if DEBUG_SIG
 438         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%p\n",
 439                current->comm, current->pid, frame, regs->cp0_epc, frame->code);
 440 #endif
 441         return;
 442
 443 give_sigsegv:
 444         if (signr == SIGSEGV)
 445                 ka->sa.sa_handler = SIG_DFL;
 446         force_sig(SIGSEGV, current);
 447 }
 448
 449 static void inline
 450 setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
 451                int signr, sigset_t *set, siginfo_t *info)
 452 {
 453         struct rt_sigframe *frame;
 454         int err = 0;
 455
 456         frame = get_sigframe(ka, regs, sizeof(*frame));
 457         if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 458                 goto give_sigsegv;
 459
 460         /* Set up to return from userspace.  If provided, use a stub already
 461            in userspace.  */
 462         if (ka->sa.sa_flags & SA_RESTORER)
 463                 regs->regs[31] = (unsigned long) ka->sa.sa_restorer;
 464         else {
 465                 /*
 466                  * Set up the return code ...
 467                  *
 468                  *         li      v0, __NR_sigreturn
 469                  *         syscall
 470                  */
 471                 err |= __put_user(0x24020000 + __NR_sigreturn,
 472                                   frame->rs_code + 0);
 473                 err |= __put_user(0x0000000c                 ,
 474                                   frame->rs_code + 1);
 475                 flush_cache_sigtramp((unsigned long) frame->rs_code);
 476         }
 477
 478         /* Create siginfo.  */
 479         err |= copy_siginfo_to_user(&frame->rs_info, info);
 480
 481         /* Create the ucontext.  */
 482         err |= __put_user(0, &frame->rs_uc.uc_flags);
 483         err |= __put_user(0, &frame->rs_uc.uc_link);
 484         err |= __put_user((void *)current->sas_ss_sp,
 485                           &frame->rs_uc.uc_stack.ss_sp);
 486         err |= __put_user(sas_ss_flags(regs->regs[29]),
 487                           &frame->rs_uc.uc_stack.ss_flags);
 488         err |= __put_user(current->sas_ss_size,
 489                           &frame->rs_uc.uc_stack.ss_size);
 490         err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
 491         err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
 492
 493         if (err)
 494                 goto give_sigsegv;
 495
 496         /*
 497          * Arguments to signal handler:
 498          *
 499          *   a0 = signal number
 500          *   a1 = 0 (should be cause)
 501          *   a2 = pointer to ucontext
 502          *
 503          * $25 and c0_epc point to the signal handler, $29 points to
 504          * the struct rt_sigframe.
 505          */
 506         regs->regs[ 4] = signr;
 507         regs->regs[ 5] = (unsigned long) &frame->rs_info;
 508         regs->regs[ 6] = (unsigned long) &frame->rs_uc;
 509         regs->regs[29] = (unsigned long) frame;
 510         regs->regs[31] = (unsigned long) frame->rs_code;
 511         regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
 512
 513 #if DEBUG_SIG
 514         printk("SIG deliver (%s:%d): sp=0x%p pc=0x%p ra=0x%p\n",
 515                current->comm, current->pid, frame, regs->cp0_epc, frame->code);
 516 #endif
 517         return;
 518
 519 give_sigsegv:
 520         if (signr == SIGSEGV)
 521                 ka->sa.sa_handler = SIG_DFL;
 522         force_sig(SIGSEGV, current);
 523 }
 524
 525 static inline void
 526 handle_signal(unsigned long sig, struct k_sigaction *ka,
 527         siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 528 {
 529         if (ka->sa.sa_flags & SA_SIGINFO)
 530                 setup_rt_frame(ka, regs, sig, oldset, info);
 531         else
 532                 setup_frame(ka, regs, sig, oldset);
 533
 534         if (ka->sa.sa_flags & SA_ONESHOT)
 535                 ka->sa.sa_handler = SIG_DFL;
 536         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 537                 spin_lock_irq(&current->sigmask_lock);
 538                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 539                 sigaddset(&current->blocked,sig);
 540                 recalc_sigpending(current);
 541                 spin_unlock_irq(&current->sigmask_lock);
 542         }
 543 }
 544
 545 static inline void
 546 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
 547 {
 548         switch(regs->regs[0]) {
 549         case ERESTARTNOHAND:
 550                 regs->regs[2] = EINTR;
 551                 break;
 552         case ERESTARTSYS:
 553                 if(!(ka->sa.sa_flags & SA_RESTART)) {
 554                         regs->regs[2] = EINTR;
 555                         break;
 556                 }
 557         /* fallthrough */
 558         case ERESTARTNOINTR:            /* Userland will reload $v0.  */
 559                 regs->regs[7] = regs->regs[26];
 560                 regs->cp0_epc -= 8;
 561         }
 562
 563         regs->regs[0] = 0;              /* Don't deal with this again.  */
 564 }
 565
 566 extern int do_irix_signal(sigset_t *oldset, struct pt_regs *regs);
 567
 568 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
 569 {
 570         struct k_sigaction *ka;
 571         siginfo_t info;
 572
 573 #ifdef CONFIG_BINFMT_IRIX
 574         if (current->personality != PER_LINUX)
 575                 return do_irix_signal(oldset, regs);
 576 #endif
 577
 578         if (!oldset)
 579                 oldset = &current->blocked;
 580
 581         for (;;) {
 582                 unsigned long signr;
 583
 584                 spin_lock_irq(&current->sigmask_lock);
 585                 signr = dequeue_signal(&current->blocked, &info);
 586                 spin_unlock_irq(&current->sigmask_lock);
 587
 588                 if (!signr)
 589                         break;
 590
 591                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
 592                         /* Let the debugger run.  */
 593                         current->exit_code = signr;
 594                         current->state = TASK_STOPPED;
 595                         notify_parent(current, SIGCHLD);
 596                         schedule();
 597
 598                         /* We're back.  Did the debugger cancel the sig?  */
 599                         if (!(signr = current->exit_code))
 600                                 continue;
 601                         current->exit_code = 0;
 602
 603                         /* The debugger continued.  Ignore SIGSTOP.  */
 604                         if (signr == SIGSTOP)
 605                                 continue;
 606
 607                         /* Update the siginfo structure.  Is this good?  */
 608                         if (signr != info.si_signo) {
 609                                 info.si_signo = signr;
 610                                 info.si_errno = 0;
 611                                 info.si_code = SI_USER;
 612                                 info.si_pid = current->p_pptr->pid;
 613                                 info.si_uid = current->p_pptr->uid;
 614                         }
 615
 616                         /* If the (new) signal is now blocked, requeue it.  */
 617                         if (sigismember(&current->blocked, signr)) {
 618                                 send_sig_info(signr, &info, current);
 619                                 continue;
 620                         }
 621                 }
 622
 623                 ka = &current->sig->action[signr-1];
 624                 if (ka->sa.sa_handler == SIG_IGN) {
 625                         if (signr != SIGCHLD)
 626                                 continue;
 627                         /* Check for SIGCHLD: it's special.  */
 628                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
 629                                 /* nothing */;
 630                         continue;
 631                 }
 632
 633                 if (ka->sa.sa_handler == SIG_DFL) {
 634                         int exit_code = signr;
 635
 636                         /* Init gets no signals it doesn't want.  */
 637                         if (current->pid == 1)
 638                                 continue;
 639
 640                         switch (signr) {
 641                         case SIGCONT: case SIGCHLD: case SIGWINCH:
 642                                 continue;
 643
 644                         case SIGTSTP: case SIGTTIN: case SIGTTOU:
 645                                 if (is_orphaned_pgrp(current->pgrp))
 646                                         continue;
 647                                 /* FALLTHRU */
 648
 649                         case SIGSTOP:
 650                                 current->state = TASK_STOPPED;
 651                                 current->exit_code = signr;
 652                                 if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
 653                                         notify_parent(current, SIGCHLD);
 654                                 schedule();
 655                                 continue;
 656
 657                         case SIGQUIT: case SIGILL: case SIGTRAP:
 658                         case SIGABRT: case SIGFPE: case SIGSEGV:
 659                         case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
 660                                 if (do_coredump(signr, regs))
 661                                         exit_code |= 0x80;
 662                                 /* FALLTHRU */
 663
 664                         default:
 665                                 sigaddset(&current->pending.signal, signr);
 666                                 recalc_sigpending(current);
 667                                 current->flags |= PF_SIGNALED;
 668                                 do_exit(exit_code);
 669                                 /* NOTREACHED */
 670                         }
 671                 }
 672
 673                 if (regs->regs[0])
 674                         syscall_restart(regs, ka);
 675                 /* Whee!  Actually deliver the signal.  */
 676                 handle_signal(signr, ka, &info, oldset, regs);
 677                 return 1;
 678         }
 679
 680         /*
 681          * Who's code doesn't conform to the restartable syscall convention
 682          * dies here!!!  The li instruction, a single machine instruction,
 683          * must directly be followed by the syscall instruction.
 684          */
 685         if (regs->regs[0]) {
 686                 if (regs->regs[2] == ERESTARTNOHAND ||
 687                     regs->regs[2] == ERESTARTSYS ||
 688                     regs->regs[2] == ERESTARTNOINTR) {
 689                         regs->regs[7] = regs->regs[26];
 690                         regs->cp0_epc -= 8;
 691                 }
 692         }
 693         return 0;
 694 }