arch/ppc64/kernel/signal.c

   1 /*
   2  *  linux/arch/ppc64/kernel/signal.c
   3  *
   4  *  PowerPC version
   5  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
   6  *
   7  *  Derived from "arch/i386/kernel/signal.c"
   8  *    Copyright (C) 1991, 1992 Linus Torvalds
   9  *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  10  *
  11  *  This program is free software; you can redistribute it and/or
  12  *  modify it under the terms of the GNU General Public License
  13  *  as published by the Free Software Foundation; either version
  14  *  2 of the License, or (at your option) any later version.
  15  */
  16
  17 #include <linux/sched.h>
  18 #include <linux/mm.h>
  19 #include <linux/smp.h>
  20 #include <linux/smp_lock.h>
  21 #include <linux/kernel.h>
  22 #include <linux/signal.h>
  23 #include <linux/errno.h>
  24 #include <linux/wait.h>
  25 #include <linux/ptrace.h>
  26 #include <linux/unistd.h>
  27 #include <linux/stddef.h>
  28 #include <linux/elf.h>
  29 #include <asm/ppc32.h>
  30 #include <asm/sigcontext.h>
  31 #include <asm/ucontext.h>
  32 #include <asm/uaccess.h>
  33 #include <asm/pgtable.h>
  34 #include <asm/ppcdebug.h>
  35 #include <asm/unistd.h>
  36
  37 #define DEBUG_SIG 0
  38
  39 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  40
  41 #ifndef MIN
  42 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
  43 #endif
  44
  45 #define GP_REGS_SIZE    MIN(sizeof(elf_gregset_t), sizeof(struct pt_regs))
  46 #define FP_REGS_SIZE    sizeof(elf_fpregset_t)
  47
  48 #define TRAMP_TRACEBACK 2
  49 #define TRAMP_SIZE      6
  50
  51 /*
  52  * When we have signals to deliver, we set up on the user stack,
  53  * going down from the original stack pointer:
  54  *      1) a sigframe/rt_sigframe struct which contains the sigcontext/ucontext
  55  *      2) a gap of __SIGNAL_FRAMESIZE bytes which acts as a dummy caller
  56  *         frame for the signal handler.
  57  */
  58
  59 struct sigframe {
  60         struct sigcontext sc;
  61         unsigned int tramp[TRAMP_SIZE];
  62         /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
  63         char abigap[288];
  64 };
  65
  66 struct rt_sigframe {
  67         unsigned long _unused[2];
  68         unsigned int tramp[TRAMP_SIZE];
  69         struct siginfo *pinfo;
  70         void *puc;
  71         struct siginfo info;
  72         struct ucontext uc;
  73         /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
  74         char abigap[288];
  75 };
  76
  77 extern long sys_wait4(pid_t pid, unsigned int *stat_addr,
  78                      int options, /*unsigned long*/ struct rusage *ru);
  79
  80 int
  81 copy_siginfo_to_user(siginfo_t *to, siginfo_t *from)
  82 {
  83         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
  84                 return -EFAULT;
  85         if (from->si_code < 0)
  86                 return __copy_to_user(to, from, sizeof(siginfo_t));
  87         else {
  88                 int err;
  89
  90                 /* If you change siginfo_t structure, please be sure
  91                    this code is fixed accordingly.
  92                    It should never copy any pad contained in the structure
  93                    to avoid security leaks, but must copy the generic
  94                    3 ints plus the relevant union member.  */
  95                 err = __put_user(from->si_signo, &to->si_signo);
  96                 err |= __put_user(from->si_errno, &to->si_errno);
  97                 err |= __put_user((short)from->si_code, &to->si_code);
  98                 /* First 32bits of unions are always present.  */
  99                 err |= __put_user(from->si_pid, &to->si_pid);
 100                 switch (from->si_code >> 16) {
 101                 case __SI_FAULT >> 16:
 102                         break;
 103                 case __SI_CHLD >> 16:
 104                         err |= __put_user(from->si_utime, &to->si_utime);
 105                         err |= __put_user(from->si_stime, &to->si_stime);
 106                         err |= __put_user(from->si_status, &to->si_status);
 107                 default:
 108                         err |= __put_user(from->si_uid, &to->si_uid);
 109                         break;
 110                 /* case __SI_RT: This is not generated by the kernel as of now.  */
 111                 }
 112                 return err;
 113         }
 114 }
 115
 116 int do_signal(sigset_t *oldset, struct pt_regs *regs);
 117
 118 /*
 119  * Atomically swap in the new signal mask, and wait for a signal.
 120  */
 121 asmlinkage long
 122 sys_sigsuspend(old_sigset_t mask, int p2, int p3, int p4, int p6, int p7,
 123                struct pt_regs *regs)
 124 {
 125         sigset_t saveset;
 126
 127         mask &= _BLOCKABLE;
 128         spin_lock_irq(&current->sigmask_lock);
 129         saveset = current->blocked;
 130         siginitset(&current->blocked, mask);
 131         recalc_sigpending(current);
 132         spin_unlock_irq(&current->sigmask_lock);
 133
 134         regs->result = -EINTR;
 135         regs->gpr[3] = EINTR;
 136         regs->ccr |= 0x10000000;
 137         while (1) {
 138                 current->state = TASK_INTERRUPTIBLE;
 139                 schedule();
 140                 if (do_signal(&saveset, regs))
 141                         /*
 142                          * If a signal handler needs to be called,
 143                          * do_signal() has set R3 to the signal number (the
 144                          * first argument of the signal handler), so don't
 145                          * overwrite that with EINTR !
 146                          * In the other cases, do_signal() doesn't touch
 147                          * R3, so it's still set to -EINTR (see above).
 148                          */
 149                         return regs->gpr[3];
 150         }
 151 }
 152
 153 asmlinkage long
 154 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, int p3, int p4, int p6,
 155                   int p7, struct pt_regs *regs)
 156 {
 157         sigset_t saveset, newset;
 158
 159         /* XXX: Don't preclude handling different sized sigset_t's.  */
 160         if (sigsetsize != sizeof(sigset_t))
 161                 return -EINVAL;
 162
 163         if (copy_from_user(&newset, unewset, sizeof(newset)))
 164                 return -EFAULT;
 165         sigdelsetmask(&newset, ~_BLOCKABLE);
 166
 167         spin_lock_irq(&current->sigmask_lock);
 168         saveset = current->blocked;
 169         current->blocked = newset;
 170         recalc_sigpending(current);
 171         spin_unlock_irq(&current->sigmask_lock);
 172
 173         regs->result = -EINTR;
 174         regs->gpr[3] = EINTR;
 175         regs->ccr |= 0x10000000;
 176         while (1) {
 177                 current->state = TASK_INTERRUPTIBLE;
 178                 schedule();
 179                 if (do_signal(&saveset, regs))
 180                         return regs->gpr[3];
 181         }
 182 }
 183
 184 asmlinkage long
 185 sys_sigaltstack(const stack_t *uss, stack_t *uoss, unsigned long r5,
 186                 unsigned long r6, unsigned long r7, unsigned long r8,
 187                 struct pt_regs *regs)
 188 {
 189         return do_sigaltstack(uss, uoss, regs->gpr[1]);
 190 }
 191
 192 asmlinkage long
 193 sys_sigaction(int sig, const struct old_sigaction *act,
 194               struct old_sigaction *oact)
 195 {
 196         struct k_sigaction new_ka, old_ka;
 197         int ret;
 198
 199         if (act) {
 200                 old_sigset_t mask;
 201
 202                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 203                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 204                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 205                         return -EFAULT;
 206                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 207                 __get_user(mask, &act->sa_mask);
 208                 siginitset(&new_ka.sa.sa_mask, mask);
 209         }
 210
 211         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 212         if (!ret && oact) {
 213                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 214                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 215                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 216                         return -EFAULT;
 217                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 218                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 219         }
 220
 221         return ret;
 222 }
 223
 224 /*
 225  * Set up the sigcontext for the signal frame.
 226  */
 227
 228 static int
 229 setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
 230                  int signr, sigset_t *set, unsigned long handler)
 231 {
 232         int err = 0;
 233
 234         if (regs->msr & MSR_FP)
 235                 giveup_fpu(current);
 236
 237         current->thread.saved_msr = regs->msr & ~(MSR_FP | MSR_FE0 | MSR_FE1);
 238         regs->msr = current->thread.saved_msr | current->thread.fpexc_mode;
 239         current->thread.saved_softe = regs->softe;
 240
 241         err |= __put_user(&sc->gp_regs, &sc->regs);
 242         err |= __copy_to_user(&sc->gp_regs, regs, GP_REGS_SIZE);
 243         err |= __copy_to_user(&sc->fp_regs, &current->thread.fpr, FP_REGS_SIZE);
 244         err |= __put_user(signr, &sc->signal);
 245         err |= __put_user(handler, &sc->handler);
 246         if (set != NULL)
 247                 err |=  __put_user(set->sig[0], &sc->oldmask);
 248
 249         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 250         current->thread.fpscr = 0;
 251
 252         return err;
 253 }
 254
 255 /*
 256  * Restore the sigcontext from the signal frame.
 257  */
 258
 259 static int
 260 restore_sigcontext(struct pt_regs *regs, sigset_t *set, struct sigcontext *sc)
 261 {
 262         unsigned int err = 0;
 263
 264         if (regs->msr & MSR_FP)
 265                 giveup_fpu(current);
 266
 267         err |= __copy_from_user(regs, &sc->gp_regs, GP_REGS_SIZE);
 268         err |= __copy_from_user(&current->thread.fpr, &sc->fp_regs, FP_REGS_SIZE);
 269         current->thread.fpexc_mode = regs->msr & (MSR_FE0 | MSR_FE1);
 270         if (set != NULL)
 271                 err |=  __get_user(set->sig[0], &sc->oldmask);
 272
 273         /* Don't allow the signal handler to change these modulo FE{0,1} */
 274         regs->msr = current->thread.saved_msr & ~(MSR_FP | MSR_FE0 | MSR_FE1);
 275         regs->softe = current->thread.saved_softe;
 276
 277         return err;
 278 }
 279
 280 /*
 281  * Allocate space for the signal frame
 282  */
 283 static inline void *
 284 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 285 {
 286         unsigned long newsp;
 287
 288         /* Default to using normal stack */
 289         newsp = regs->gpr[1];
 290
 291         if (ka->sa.sa_flags & SA_ONSTACK) {
 292                 if (! on_sig_stack(regs->gpr[1]))
 293                         newsp = (current->sas_ss_sp + current->sas_ss_size);
 294         }
 295
 296         return (void *)((newsp - frame_size) & -8ul);
 297 }
 298
 299 asmlinkage int
 300 sys_rt_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
 301                  unsigned long r6, unsigned long r7, unsigned long r8,
 302                  struct pt_regs *regs)
 303 {
 304         struct rt_sigframe *frame;
 305         sigset_t set;
 306         stack_t st;
 307
 308         frame = (struct rt_sigframe *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
 309
 310         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 311                 goto badframe;
 312
 313         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 314                 goto badframe;
 315
 316         sigdelsetmask(&set, ~_BLOCKABLE);
 317         spin_lock_irq(&current->sigmask_lock);
 318         current->blocked = set;
 319         recalc_sigpending(current);
 320         spin_unlock_irq(&current->sigmask_lock);
 321
 322         if (restore_sigcontext(regs, NULL, &frame->uc.uc_mcontext))
 323                 goto badframe;
 324
 325         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 326                 goto badframe;
 327
 328         /* This function sets back the stack flags into
 329            the current task structure.  */
 330         sys_sigaltstack(&st, NULL, 0, 0, 0, 0, regs);
 331
 332         return regs->result;
 333
 334 badframe:
 335         do_exit(SIGSEGV);
 336 }
 337
 338 static void
 339 setup_rt_frame(int signr, struct k_sigaction *ka, siginfo_t *info,
 340                 sigset_t *set, struct pt_regs *regs)
 341 {
 342         /* Handler is *really* a pointer to the function descriptor for
 343          * the signal routine.  The first entry in the function
 344          * descriptor is the entry address of signal and the second
 345          * entry is the TOC value we need to use.
 346          */
 347         func_descr_t *funct_desc_ptr;
 348         struct rt_sigframe *frame;
 349         unsigned long newsp;
 350         int i, err = 0;
 351
 352         frame = get_sigframe(ka, regs, sizeof(*frame));
 353
 354         if (verify_area(VERIFY_WRITE, frame, sizeof(*frame)))
 355                 goto give_sigsegv;
 356
 357         err |= __put_user(&frame->info, &frame->pinfo);
 358         err |= __put_user(&frame->uc, &frame->puc);
 359         err |= copy_siginfo_to_user(&frame->info, info);
 360         if (err)
 361                 goto give_sigsegv;
 362
 363         /* Create the ucontext.  */
 364         err |= __put_user(0, &frame->uc.uc_flags);
 365         err |= __put_user(0, &frame->uc.uc_link);
 366         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 367         err |= __put_user(sas_ss_flags(regs->gpr[1]),
 368                           &frame->uc.uc_stack.ss_flags);
 369         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 370         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, signr, NULL,
 371                                 (unsigned long)ka->sa.sa_handler);
 372         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 373         if (err)
 374                 goto give_sigsegv;
 375
 376         /* Set up to return from userspace. */
 377         /* li r0, __NR_rt_sigreturn */
 378         err |= __put_user(0x38000000UL + __NR_rt_sigreturn, &frame->tramp[0]);
 379         /* sc */
 380         err |= __put_user(0x44000002UL, &frame->tramp[1]);
 381         /* Minimal traceback info */
 382         for (i=TRAMP_TRACEBACK; i < TRAMP_SIZE ;i++)
 383                 err |= __put_user(0, &frame->tramp[i]);
 384         if (err)
 385                 goto give_sigsegv;
 386
 387         flush_icache_range((unsigned long) &frame->tramp[0],
 388                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
 389
 390         funct_desc_ptr = (func_descr_t *) ka->sa.sa_handler;
 391
 392         /* Allocate a dummy caller frame for the signal handler. */
 393         newsp = (unsigned long)frame - __SIGNAL_FRAMESIZE;
 394         err |= put_user(0, (unsigned long *)newsp);
 395
 396         /* Set up "regs" so we "return" to the signal handler. */
 397         err |= get_user(regs->nip, &funct_desc_ptr->entry);
 398         regs->link = (unsigned long) &frame->tramp[0];
 399         regs->gpr[1] = newsp;
 400         err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
 401         regs->gpr[3] = signr;
 402         err |= get_user(regs->gpr[4], (unsigned long *)&frame->pinfo);
 403         err |= get_user(regs->gpr[5], (unsigned long *)&frame->puc);
 404         regs->gpr[6] = (unsigned long) frame;
 405         if (err)
 406                 goto give_sigsegv;
 407
 408         return;
 409
 410 give_sigsegv:
 411 #if DEBUG_SIG
 412         printk("badframe in setup_rt_frame, regs=%p frame=%p, newsp=0x%lx\n",
 413                 regs, frame, newsp);
 414 #endif
 415         do_exit(SIGSEGV);
 416 }
 417
 418 /*
 419  * Do a signal return; undo the signal stack.
 420  */
 421 asmlinkage long
 422 sys_sigreturn(unsigned long r3, unsigned long r4, unsigned long r5,
 423               unsigned long r6, unsigned long r7, unsigned long r8,
 424               struct pt_regs *regs)
 425 {
 426         struct sigframe *frame;
 427         sigset_t set;
 428
 429         frame = (struct sigframe *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
 430
 431         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 432                 goto badframe;
 433
 434         if (restore_sigcontext(regs, &set, &frame->sc))
 435                 goto badframe;
 436
 437         sigdelsetmask(&set, ~_BLOCKABLE);
 438         spin_lock_irq(&current->sigmask_lock);
 439         current->blocked = set;
 440         recalc_sigpending(current);
 441         spin_unlock_irq(&current->sigmask_lock);
 442
 443         return regs->result;
 444
 445 badframe:
 446         do_exit(SIGSEGV);
 447 }
 448
 449
 450 static void
 451 setup_frame(int signr, struct k_sigaction *ka, sigset_t *set,
 452             struct pt_regs *regs)
 453 {
 454         /* Handler is *really* a pointer to the function descriptor for
 455          * the signal routine.  The first entry in the function
 456          * descriptor is the entry address of signal and the second
 457          * entry is the TOC value we need to use.
 458          */
 459         func_descr_t *funct_desc_ptr;
 460         struct sigframe *frame;
 461         unsigned long newsp;
 462         int i, err = 0;
 463
 464         frame = get_sigframe(ka, regs, sizeof(*frame));
 465
 466         if (verify_area(VERIFY_WRITE, frame, sizeof(*frame)))
 467                 goto badframe;
 468
 469         err |= setup_sigcontext(&frame->sc, regs, signr, set,
 470                                 (unsigned long)ka->sa.sa_handler);
 471
 472         /* Set up to return from userspace. */
 473         /* li r0, __NR_rt_sigreturn */
 474         err |= __put_user(0x38000000UL + __NR_sigreturn, &frame->tramp[0]);
 475         /* sc */
 476         err |= __put_user(0x44000002UL, &frame->tramp[1]);
 477         /* Minimal traceback info */
 478         for (i=TRAMP_TRACEBACK; i < TRAMP_SIZE ;i++)
 479                 err |= __put_user(0, &frame->tramp[i]);
 480         if (err)
 481                 goto badframe;
 482
 483         flush_icache_range((unsigned long) &frame->tramp[0],
 484                            (unsigned long) &frame->tramp[TRAMP_SIZE]);
 485
 486         funct_desc_ptr = (func_descr_t *) ka->sa.sa_handler;
 487
 488         /* Allocate a dummy caller frame for the signal handler. */
 489         newsp = (unsigned long)frame - __SIGNAL_FRAMESIZE;
 490         err |= put_user(0, (unsigned long *)newsp);
 491
 492         /* Set up "regs" so we "return" to the signal handler. */
 493         err |= get_user(regs->nip, &funct_desc_ptr->entry);
 494         regs->link = (unsigned long) &frame->tramp[0];
 495         regs->gpr[1] = newsp;
 496         err |= get_user(regs->gpr[2], &funct_desc_ptr->toc);
 497         regs->gpr[3] = signr;
 498         regs->gpr[4] = (unsigned long) &frame->sc;
 499         if (err)
 500                 goto badframe;
 501
 502         return;
 503
 504 badframe:
 505 #if DEBUG_SIG
 506         printk("badframe in setup_frame, regs=%p frame=%p newsp=%lx\n",
 507                regs, frame, newsp);
 508 #endif
 509         do_exit(SIGSEGV);
 510 }
 511
 512 /*
 513  * OK, we're invoking a handler
 514  */
 515 static void
 516 handle_signal(unsigned long sig, struct k_sigaction *ka,
 517               siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
 518 {
 519         /* Are we from a system call? */
 520         if (regs->trap == 0x0C00
 521             && ((int)regs->result == -ERESTARTNOHAND ||
 522                 ((int)regs->result == -ERESTARTSYS &&
 523                  !(ka->sa.sa_flags & SA_RESTART))))
 524                 regs->result = -EINTR;
 525
 526         /* Set up Signal Frame */
 527         if (ka->sa.sa_flags & SA_SIGINFO)
 528                 setup_rt_frame(sig, ka, info, oldset, regs);
 529         else
 530                 setup_frame(sig, ka, oldset, regs);
 531
 532         if (ka->sa.sa_flags & SA_ONESHOT)
 533                 ka->sa.sa_handler = SIG_DFL;
 534
 535         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 536                 spin_lock_irq(&current->sigmask_lock);
 537                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 538                 sigaddset(&current->blocked,sig);
 539                 recalc_sigpending(current);
 540                 spin_unlock_irq(&current->sigmask_lock);
 541         }
 542 }
 543
 544 static int
 545 get_signal_to_deliver(siginfo_t *info, struct pt_regs *regs)
 546 {
 547         for (;;) {
 548                 unsigned long signr;
 549                 struct k_sigaction *ka;
 550
 551                 spin_lock_irq(&current->sigmask_lock);
 552                 signr = dequeue_signal(&current->blocked, info);
 553                 spin_unlock_irq(&current->sigmask_lock);
 554
 555                 if (!signr)
 556                         break;
 557
 558                 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
 559                         /* Let the debugger run.  */
 560                         current->exit_code = signr;
 561                         current->state = TASK_STOPPED;
 562                         notify_parent(current, SIGCHLD);
 563                         schedule();
 564
 565                         /* We're back.  Did the debugger cancel the sig?  */
 566                         signr = current->exit_code;
 567                         if (signr == 0)
 568                                 continue;
 569                         current->exit_code = 0;
 570
 571                         /* The debugger continued.  Ignore SIGSTOP.  */
 572                         if (signr == SIGSTOP)
 573                                 continue;
 574
 575                         /* Update the siginfo structure.  Is this good?  */
 576                         if (signr != info->si_signo) {
 577                                 info->si_signo = signr;
 578                                 info->si_errno = 0;
 579                                 info->si_code = SI_USER;
 580                                 info->si_pid = current->p_pptr->pid;
 581                                 info->si_uid = current->p_pptr->uid;
 582                         }
 583
 584                         /* If the (new) signal is now blocked, requeue it.  */
 585                         if (sigismember(&current->blocked, signr)) {
 586                                 send_sig_info(signr, info, current);
 587                                 continue;
 588                         }
 589                 }
 590
 591                 ka = &current->sig->action[signr-1];
 592
 593                 if (ka->sa.sa_handler == SIG_IGN) {
 594                         if (signr != SIGCHLD)
 595                                 continue;
 596                         /* Check for SIGCHLD: it's special.  */
 597                         while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0)
 598                                 /* nothing */;
 599                         continue;
 600                 }
 601
 602                 if (ka->sa.sa_handler == SIG_DFL) {
 603                         int exit_code = signr;
 604
 605                         /* Init gets no signals it doesn't want.  */
 606                         if (current->pid == 1)
 607                                 continue;
 608
 609                         switch (signr) {
 610                         case SIGCONT: case SIGCHLD: case SIGWINCH: case SIGURG:
 611                                 continue;
 612
 613                         case SIGTSTP: case SIGTTIN: case SIGTTOU:
 614                                 if (is_orphaned_pgrp(current->pgrp))
 615                                         continue;
 616                                 /* FALLTHRU */
 617
 618                         case SIGSTOP: {
 619                                 struct signal_struct *sig;
 620                                 current->state = TASK_STOPPED;
 621                                 current->exit_code = signr;
 622                                 sig = current->p_pptr->sig;
 623                                 if (sig && !(sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
 624                                         notify_parent(current, SIGCHLD);
 625                                 schedule();
 626                                 continue;
 627                         }
 628
 629                         case SIGQUIT: case SIGILL: case SIGTRAP:
 630                         case SIGABRT: case SIGFPE: case SIGSEGV:
 631                         case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ:
 632                                 if (do_coredump(signr, regs))
 633                                         exit_code |= 0x80;
 634                                 /* FALLTHRU */
 635
 636                         default:
 637                                 sig_exit(signr, exit_code, info);
 638                                 /* NOTREACHED */
 639                         }
 640                 }
 641                 return signr;
 642         }
 643         return 0;
 644 }
 645
 646 /*
 647  * Note that 'init' is a special process: it doesn't get signals it doesn't
 648  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 649  * mistake.
 650  */
 651 extern int do_signal32(sigset_t *oldset, struct pt_regs *regs);
 652
 653 int
 654 do_signal(sigset_t *oldset, struct pt_regs *regs)
 655 {
 656         siginfo_t info;
 657         int signr;
 658
 659         /*
 660          * If the current thread is 32 bit - invoke the
 661          * 32 bit signal handling code
 662          */
 663         if (current->thread.flags & PPC_FLAG_32BIT)
 664                 return do_signal32(oldset, regs);
 665
 666         if (!oldset)
 667                 oldset = &current->blocked;
 668
 669         signr = get_signal_to_deliver(&info, regs);
 670         if (signr > 0) {
 671                 struct k_sigaction *ka = &current->sig->action[signr-1];
 672
 673                 /* Whee!  Actually deliver the signal.  */
 674                 handle_signal(signr, ka, &info, oldset, regs);
 675                 return 1;
 676         }
 677
 678         if (regs->trap == 0x0C00 /* System Call! */ &&
 679             ((int)regs->result == -ERESTARTNOHAND ||
 680              (int)regs->result == -ERESTARTSYS ||
 681              (int)regs->result == -ERESTARTNOINTR)) {
 682                 regs->gpr[3] = regs->orig_gpr3;
 683                 regs->nip -= 4;         /* Back up & retry system call */
 684                 regs->result = 0;
 685         }
 686
 687         return 0;
 688 }
 689
 690
 691