arch/nios2nommu/kernel/signal.c

   1 /*
   2  * linux/arch/nios2nommu/kernel/signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  * Copyright (C) 2004   Microtronix Datacom Ltd
   6  *
   7  * This file is subject to the terms and conditions of the GNU General Public
   8  * License.  See the file COPYING in the main directory of this archive
   9  * for more details.
  10  *
  11  * Linux/m68k support by Hamish Macdonald
  12  *
  13  * 68060 fixes by Jesper Skov
  14  *
  15  * 1997-12-01  Modified for POSIX.1b signals by Andreas Schwab
  16  *
  17  * mathemu support by Roman Zippel
  18  *  (Note: fpstate in the signal context is completely ignored for the emulator
  19  *         and the internal floating point format is put on stack)
  20  *
  21  * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
  22  * Atari :-) Current limitation: Only one sigstack can be active at one time.
  23  * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
  24  * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
  25  * signal handlers!
  26  *
  27  * Jan/20/2004          dgt         NiosII
  28  *
  29  */
  30
  31 #include <linux/sched.h>
  32 #include <linux/mm.h>
  33 #include <linux/kernel.h>
  34 #include <linux/signal.h>
  35 #include <linux/errno.h>
  36 #include <linux/wait.h>
  37 #include <linux/ptrace.h>
  38 #include <linux/unistd.h>
  39 #include <linux/stddef.h>
  40 #include <linux/highuid.h>
  41 #include <linux/tty.h>
  42 #include <linux/personality.h>
  43 #include <linux/binfmts.h>
  44
  45 #include <asm/setup.h>
  46 #include <asm/uaccess.h>
  47 #include <asm/pgtable.h>
  48 #include <asm/traps.h>
  49 #include <asm/ucontext.h>
  50
  51 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  52
  53 asmlinkage long sys_wait4(pid_t pid, unsigned int * stat_addr, int options,
  54                         struct rusage * ru);
  55 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
  56
  57 /*
  58  * Atomically swap in the new signal mask, and wait for a signal.
  59  */
  60 asmlinkage int do_sigsuspend(struct pt_regs *regs)
  61 {
  62         old_sigset_t mask = regs->r4;  // Verify correct syscall reg
  63         sigset_t saveset;
  64
  65         mask &= _BLOCKABLE;
  66         spin_lock_irq(&current->sighand->siglock);
  67         saveset = current->blocked;
  68         siginitset(&current->blocked, mask);
  69         recalc_sigpending();
  70         spin_unlock_irq(&current->sighand->siglock);
  71
  72         regs->r2 = -EINTR;
  73         while (1) {
  74                 current->state = TASK_INTERRUPTIBLE;
  75                 schedule();
  76                 if (do_signal(&saveset, regs))
  77                         return -EINTR;
  78         }
  79 }
  80
  81 asmlinkage int
  82 do_rt_sigsuspend(struct pt_regs *regs)
  83 {
  84         sigset_t *unewset = (sigset_t *)regs->r4;
  85         size_t sigsetsize = (size_t)regs->r5;
  86         sigset_t saveset, newset;
  87
  88         /* XXX: Don't preclude handling different sized sigset_t's.  */
  89         if (sigsetsize != sizeof(sigset_t))
  90                 return -EINVAL;
  91
  92         if (copy_from_user(&newset, unewset, sizeof(newset)))
  93                 return -EFAULT;
  94         sigdelsetmask(&newset, ~_BLOCKABLE);
  95
  96         spin_lock_irq(&current->sighand->siglock);
  97         saveset = current->blocked;
  98         current->blocked = newset;
  99         recalc_sigpending();
 100         spin_unlock_irq(&current->sighand->siglock);
 101
 102         regs->r2 = -EINTR;
 103         while (1) {
 104                 current->state = TASK_INTERRUPTIBLE;
 105                 schedule();
 106                 if (do_signal(&saveset, regs))
 107                         return -EINTR;
 108         }
 109 }
 110
 111 asmlinkage int
 112 sys_sigaction(int sig, const struct old_sigaction *act,
 113               struct old_sigaction *oact)
 114 {
 115         struct k_sigaction new_ka, old_ka;
 116         int ret;
 117
 118         if (act) {
 119                 old_sigset_t mask;
 120                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 121                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 122                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 123                         return -EFAULT;
 124                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 125                 __get_user(mask, &act->sa_mask);
 126                 siginitset(&new_ka.sa.sa_mask, mask);
 127         }
 128
 129         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 130
 131         if (!ret && oact) {
 132                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 133                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 134                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 135                         return -EFAULT;
 136                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 137                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 138         }
 139
 140         return ret;
 141 }
 142
 143 /*
 144  * Do a signal return; undo the signal stack.
 145  *
 146  * Keep the return code on the stack quadword aligned!
 147  * That makes the cache flush below easier.
 148  */
 149
 150
 151 struct sigframe
 152 {
 153         char retcode[12];
 154         unsigned long extramask[_NSIG_WORDS-1];
 155         struct sigcontext sc;
 156 };
 157
 158 struct rt_sigframe
 159 {
 160         char retcode[12];
 161         struct siginfo info;
 162         struct ucontext uc;
 163 };
 164
 165 #ifdef CONFIG_FPU
 166
 167 static unsigned char fpu_version = 0;   /* version number of fpu, set by setup_frame */
 168
 169 static inline int restore_fpu_state(struct sigcontext *sc)
 170 {
 171         int err = 1;
 172
 173         if (FPU_IS_EMU) {
 174             /* restore registers */
 175             memcpy(current->thread.fpcntl, sc->sc_fpcntl, 12);
 176             memcpy(current->thread.fp, sc->sc_fpregs, 24);
 177             return 0;
 178         }
 179
 180         if (sc->sc_fpstate[0]) {
 181             /* Verify the frame format.  */
 182             if (sc->sc_fpstate[0] != fpu_version)
 183                 goto out;
 184
 185             __asm__ volatile ("Nios II FPU"
 186                               : /* no outputs */
 187                               : );
 188         }
 189         __asm__ volatile ("Nios II FPU"
 190                           : : );
 191         err = 0;
 192
 193 out:
 194         return err;
 195 }
 196
 197 #define FPCONTEXT_SIZE  216
 198 #define uc_fpstate      uc_filler[0]
 199 #define uc_formatvec    uc_filler[FPCONTEXT_SIZE/4]
 200 #define uc_extra        uc_filler[FPCONTEXT_SIZE/4+1]
 201
 202 static inline int rt_restore_fpu_state(struct ucontext *uc)
 203 {
 204         unsigned char fpstate[FPCONTEXT_SIZE];
 205         int context_size = 0;
 206         fpregset_t fpregs;
 207         int err = 1;
 208
 209         if (FPU_IS_EMU) {
 210                 /* restore fpu control register */
 211                 if (__copy_from_user(current->thread.fpcntl,
 212                                 &uc->uc_mcontext.fpregs.f_pcr, 12))
 213                         goto out;
 214                 /* restore all other fpu register */
 215                 if (__copy_from_user(current->thread.fp,
 216                                 uc->uc_mcontext.fpregs.f_fpregs, 96))
 217                         goto out;
 218                 return 0;
 219         }
 220
 221         if (__get_user(*(long *)fpstate, (long *)&uc->uc_fpstate))
 222                 goto out;
 223         if (fpstate[0]) {
 224                 context_size = fpstate[1];
 225
 226                 /* Verify the frame format.  */
 227                 if (fpstate[0] != fpu_version)
 228                         goto out;
 229                 if (__copy_from_user(&fpregs, &uc->uc_mcontext.fpregs,
 230                      sizeof(fpregs)))
 231                         goto out;
 232                 __asm__ volatile ("Nios II FPU"
 233                                   : /* no outputs */
 234                                   : );
 235         }
 236         if (context_size &&
 237             __copy_from_user(fpstate + 4, (long *)&uc->uc_fpstate + 1,
 238                              context_size))
 239                 goto out;
 240         __asm__ volatile ("Nios II FPU"
 241                            : : );
 242         err = 0;
 243
 244 out:
 245         return err;
 246 }
 247
 248 #endif
 249
 250 static inline int
 251 restore_sigcontext(struct pt_regs *regs, struct sigcontext *usc, void *fp,
 252                    int *pr2)
 253 {
 254         int err = 0;
 255         int estatus;
 256
 257         estatus = regs->estatus;
 258
 259         /* get previous pt_regs */
 260         if (copy_from_user(regs, &usc->regs, sizeof(*regs)))
 261                 goto badframe;
 262
 263         /* Prevent user from being able to change
 264          * certain processor status bits. Currently nothing.
 265          */
 266         regs->estatus = (estatus & 0xffffffff) | (regs->estatus & 0);
 267
 268         *pr2 = regs->r2;
 269         regs->orig_r2 = -1;             /* disable syscall checks */
 270
 271 #ifdef CONFIG_FPU
 272         err |= restore_fpu_state(&context);
 273 #endif
 274
 275         return err;
 276
 277 badframe:
 278         return 1;
 279 }
 280
 281 static inline int
 282 rt_restore_ucontext(struct pt_regs *regs, struct switch_stack *sw,
 283                     struct ucontext *uc, int *pr2)
 284 {
 285         int temp;
 286         greg_t *gregs = uc->uc_mcontext.gregs;
 287         unsigned long usp;
 288         int err;
 289
 290         err = __get_user(temp, &uc->uc_mcontext.version);
 291         if (temp != MCONTEXT_VERSION)
 292                 goto badframe;
 293         /* restore passed registers */
 294         err |= __get_user(regs->r1, &gregs[0]);
 295         err |= __get_user(regs->r2, &gregs[1]);
 296         err |= __get_user(regs->r3, &gregs[2]);
 297         err |= __get_user(regs->r4, &gregs[3]);
 298         err |= __get_user(regs->r5, &gregs[4]);
 299         err |= __get_user(regs->r6, &gregs[5]);
 300         err |= __get_user(regs->r7, &gregs[6]);
 301         err |= __get_user(regs->r8, &gregs[7]);
 302         err |= __get_user(regs->r9, &gregs[8]);
 303         err |= __get_user(regs->r10, &gregs[9]);
 304         err |= __get_user(regs->r11, &gregs[10]);
 305         err |= __get_user(regs->r12, &gregs[11]);
 306         err |= __get_user(regs->r13, &gregs[12]);
 307         err |= __get_user(regs->r14, &gregs[13]);
 308         err |= __get_user(regs->r15, &gregs[14]);
 309         err |= __get_user(sw->r16, &gregs[15]);
 310         err |= __get_user(sw->r17, &gregs[16]);
 311         err |= __get_user(sw->r18, &gregs[17]);
 312         err |= __get_user(sw->r19, &gregs[18]);
 313         err |= __get_user(sw->r20, &gregs[19]);
 314         err |= __get_user(sw->r21, &gregs[20]);
 315         err |= __get_user(sw->r22, &gregs[21]);
 316         err |= __get_user(sw->r23, &gregs[22]);
 317         err |= __get_user(usp, &gregs[23]);
 318         err |= __get_user(sw->fp, &gregs[24]);  // Verify, should this be settable
 319         err |= __get_user(sw->gp, &gregs[25]);  // Verify, should this be settable
 320
 321         err |= __get_user(temp, &gregs[26]);  // Not really necessary no user settable bits
 322         regs->estatus = (regs->estatus & 0xffffffff) | (temp & 0x0);
 323         err |= __get_user(regs->status_extension,
 324                           &uc->uc_mcontext.status_extension);
 325         regs->orig_r2 = -1;             /* disable syscall checks */
 326
 327         if (do_sigaltstack(&uc->uc_stack, NULL, usp) == -EFAULT)
 328                 goto badframe;
 329
 330         *pr2 = regs->r2;
 331         return err;
 332
 333 badframe:
 334         return 1;
 335 }
 336
 337 asmlinkage int do_sigreturn(struct pt_regs *regs)
 338 {
 339         struct sigframe *frame = (struct sigframe *) regs->sp;
 340         sigset_t set;
 341         int rval;
 342
 343         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 344                 goto badframe;
 345         if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
 346             (_NSIG_WORDS > 1 &&
 347              __copy_from_user(&set.sig[1], &frame->extramask,
 348                               sizeof(frame->extramask))))
 349                 goto badframe;
 350
 351         sigdelsetmask(&set, ~_BLOCKABLE);
 352         spin_lock_irq(&current->sighand->siglock);
 353         current->blocked = set;
 354         recalc_sigpending();
 355         spin_unlock_irq(&current->sighand->siglock);
 356
 357         if (restore_sigcontext(regs, &frame->sc, frame + 1, &rval))
 358                 goto badframe;
 359         return rval;
 360
 361 badframe:
 362         force_sig(SIGSEGV, current);
 363         return 0;
 364 }
 365
 366 asmlinkage int do_rt_sigreturn(struct switch_stack *sw)
 367 {
 368         struct pt_regs *regs = (struct pt_regs *) sw + 1;
 369         struct rt_sigframe *frame = (struct rt_sigframe *) regs->sp;  // Verify, can we follow the stack back
 370         sigset_t set;
 371         int rval;
 372
 373         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 374                 goto badframe;
 375         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 376                 goto badframe;
 377
 378         sigdelsetmask(&set, ~_BLOCKABLE);
 379         spin_lock_irq(&current->sighand->siglock);
 380         current->blocked = set;
 381         recalc_sigpending();
 382         spin_unlock_irq(&current->sighand->siglock);
 383
 384         if (rt_restore_ucontext(regs, sw, &frame->uc, &rval))
 385                 goto badframe;
 386         return rval;
 387
 388 badframe:
 389         force_sig(SIGSEGV, current);
 390         return 0;
 391 }
 392
 393 #ifdef CONFIG_FPU
 394 /*
 395  * Set up a signal frame.
 396  *
 397  * Not converted, no FPU support at moment.
 398  */
 399
 400 static inline int save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
 401 {
 402         int err = 0;
 403
 404         if (FPU_IS_EMU) {
 405                 /* save registers */
 406                 err |= copy_to_user(&sc->sc_fpcntl, current->thread.fpcntl, 12);
 407                 err |= copy_to_user(&sc->sc_fpregs, current->thread.fp, 24);
 408                 return err;
 409         }
 410
 411         __asm__ volatile ("Nios II FPUt"
 412                           : : );
 413
 414         if (sc->sc_fpstate[0]) {
 415                 fpu_version = sc->sc_fpstate[0];
 416                 __asm__ volatile ("Nios II FPU"
 417                                   : /* no outputs */
 418                                   :
 419                                   : );
 420         }
 421         return err;
 422 }
 423
 424 static inline int rt_save_fpu_state(struct ucontext *uc, struct pt_regs *regs)
 425 {
 426         unsigned char fpstate[FPCONTEXT_SIZE];
 427         int context_size = 0;
 428         int err = 0;
 429
 430         if (FPU_IS_EMU) {
 431                 /* save fpu control register */
 432                 err |= copy_to_user(&uc->uc_mcontext.fpregs.f_pcr,
 433                                 current->thread.fpcntl, 12);
 434                 /* save all other fpu register */
 435                 err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpregs,
 436                                 current->thread.fp, 96);
 437                 return err;
 438         }
 439
 440         __asm__ volatile ("Nios II FPU"
 441                           : : : );
 442
 443         err |= __put_user(*(long *)fpstate, (long *)&uc->uc_fpstate);
 444         if (fpstate[0]) {
 445                 fpregset_t fpregs;
 446                 context_size = fpstate[1];
 447                 fpu_version = fpstate[0];
 448                 __asm__ volatile ("Nios II FPU"
 449                                   : /* no outputs */
 450                                   :
 451                                   : );
 452                 err |= copy_to_user(&uc->uc_mcontext.fpregs, &fpregs,
 453                                     sizeof(fpregs));
 454         }
 455         if (context_size)
 456                 err |= copy_to_user((long *)&uc->uc_fpstate + 1, fpstate + 4,
 457                                     context_size);
 458         return err;
 459 }
 460
 461 #endif
 462
 463 static int setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
 464                              unsigned long mask)
 465 {
 466         int err = 0;
 467
 468         err |= __put_user(mask, &sc->sc_mask);
 469         err |= copy_to_user(&sc->regs, regs, sizeof(*regs));
 470 #ifdef CONFIG_FPU
 471         err |= save_fpu_state(sc, regs);
 472 #endif
 473         return err;
 474 }
 475
 476 static inline int rt_setup_ucontext(struct ucontext *uc, struct pt_regs *regs)
 477 {
 478         struct switch_stack *sw = (struct switch_stack *)regs - 1;
 479         greg_t *gregs = uc->uc_mcontext.gregs;
 480         int err = 0;
 481
 482         err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
 483         err |= __put_user(regs->status_extension,
 484                           &uc->uc_mcontext.status_extension);
 485         err |= __put_user(regs->r1, &gregs[0]);
 486         err |= __put_user(regs->r2, &gregs[1]);
 487         err |= __put_user(regs->r3, &gregs[2]);
 488         err |= __put_user(regs->r4, &gregs[3]);
 489         err |= __put_user(regs->r5, &gregs[4]);
 490         err |= __put_user(regs->r6, &gregs[5]);
 491         err |= __put_user(regs->r7, &gregs[6]);
 492         err |= __put_user(regs->r8, &gregs[7]);
 493         err |= __put_user(regs->r9, &gregs[8]);
 494         err |= __put_user(regs->r10, &gregs[9]);
 495         err |= __put_user(regs->r11, &gregs[10]);
 496         err |= __put_user(regs->r12, &gregs[11]);
 497         err |= __put_user(regs->r13, &gregs[12]);
 498         err |= __put_user(regs->r14, &gregs[13]);
 499         err |= __put_user(regs->r15, &gregs[14]);
 500         err |= __put_user(sw->r16, &gregs[15]);
 501         err |= __put_user(sw->r17, &gregs[16]);
 502         err |= __put_user(sw->r18, &gregs[17]);
 503         err |= __put_user(sw->r19, &gregs[18]);
 504         err |= __put_user(sw->r20, &gregs[19]);
 505         err |= __put_user(sw->r21, &gregs[20]);
 506         err |= __put_user(sw->r22, &gregs[21]);
 507         err |= __put_user(sw->r23, &gregs[22]);
 508         err |= __put_user(regs->sp, &gregs[23]);
 509         err |= __put_user(sw->fp, &gregs[24]);
 510         err |= __put_user(sw->gp, &gregs[25]);
 511 #ifdef CONFIG_FPU
 512         err |= rt_save_fpu_state(uc, regs);
 513 #endif
 514         return err;
 515 }
 516
 517 extern void cache_push_v (unsigned long vaddr, int len);
 518
 519 static inline void push_cache (unsigned long vaddr)
 520 {
 521         cache_push_v(vaddr,12);
 522 }
 523
 524 static inline void *
 525 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 526 {
 527         unsigned long usp;
 528
 529         /* Default to using normal stack.  */
 530         usp = regs->sp;
 531
 532         /* This is the X/Open sanctioned signal stack switching.  */
 533         if (ka->sa.sa_flags & SA_ONSTACK) {
 534                 if (!on_sig_stack(usp))
 535                         usp = current->sas_ss_sp + current->sas_ss_size;
 536         }
 537         return (void *)((usp - frame_size) & -8UL);  // Verify, is it 32 or 64 bit aligned
 538 }
 539
 540 static void setup_frame (int sig, struct k_sigaction *ka,
 541                          sigset_t *set, struct pt_regs *regs)
 542 {
 543         struct sigframe *frame;
 544         int err = 0;
 545
 546         frame = get_sigframe(ka, regs, sizeof(*frame));
 547
 548         if (_NSIG_WORDS > 1)
 549                 err |= copy_to_user(frame->extramask, &set->sig[1],
 550                                     sizeof(frame->extramask));
 551
 552         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 553
 554         /* Set up to return from userspace.  */
 555         regs->ra = (unsigned long) &frame->retcode[0];
 556         /* movi r3,__NR_sigreturn */
 557         err |= __put_user(0x00c00004 + (__NR_sigreturn << 6), (long *)(frame->retcode));
 558         /* mov r2,r0 */
 559         err |= __put_user(0x0005883a, (long *)(frame->retcode + 4));
 560         /* trap */
 561         err |= __put_user(0x003b683a, (long *)(frame->retcode + 8));
 562
 563         if (err)
 564                 goto give_sigsegv;
 565
 566         push_cache ((unsigned long) &frame->retcode);
 567
 568         /* Set up registers for signal handler */
 569         regs->sp = (unsigned long) frame;
 570         regs->r4 = (unsigned long) (current_thread_info()->exec_domain
 571                                     && current_thread_info()->exec_domain->signal_invmap
 572                                     && sig < 32
 573                                     ? current_thread_info()->exec_domain->signal_invmap[sig]
 574                                     : sig);
 575         regs->ea = (unsigned long) ka->sa.sa_handler;
 576         return;
 577
 578 give_sigsegv:
 579         if (sig == SIGSEGV)
 580                 ka->sa.sa_handler = SIG_DFL;
 581         force_sig(SIGSEGV, current);
 582 }
 583
 584 static void setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
 585                             sigset_t *set, struct pt_regs *regs)
 586 {
 587         struct rt_sigframe *frame;
 588         int err = 0;
 589
 590         frame = get_sigframe(ka, regs, sizeof(*frame));
 591
 592         err |= copy_siginfo_to_user(&frame->info, info);
 593
 594         /* Create the ucontext.  */
 595         err |= __put_user(0, &frame->uc.uc_flags);
 596         err |= __put_user(0, &frame->uc.uc_link);
 597         err |= __put_user((void *)current->sas_ss_sp,
 598                           &frame->uc.uc_stack.ss_sp);
 599         err |= __put_user(sas_ss_flags(regs->sp),
 600                           &frame->uc.uc_stack.ss_flags);
 601         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 602         err |= rt_setup_ucontext(&frame->uc, regs);
 603         err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
 604
 605         /* Set up to return from userspace.  */
 606         regs->ra = (unsigned long) &frame->retcode[0];
 607         /* movi r3,__NR_rt_sigreturn */
 608         err |= __put_user(0x00c00004 + (__NR_rt_sigreturn << 6), (long *)(frame->retcode));
 609         /* mov r2,r0 */
 610         err |= __put_user(0x0005883a, (long *)(frame->retcode + 4));
 611         /* trap */
 612         err |= __put_user(0x003b683a, (long *)(frame->retcode + 8));
 613
 614         if (err)
 615                 goto give_sigsegv;
 616
 617         push_cache ((unsigned long) &frame->retcode);
 618
 619         /* Set up registers for signal handler */
 620         regs->sp = (unsigned long) frame;
 621         regs->r4 = (unsigned long) (current_thread_info()->exec_domain
 622                                     && current_thread_info()->exec_domain->signal_invmap
 623                                     && sig < 32
 624                                     ? current_thread_info()->exec_domain->signal_invmap[sig]
 625                                     : sig);
 626         regs->r5 = (unsigned long) &frame->info;
 627         regs->r6 = (unsigned long) &frame->uc;
 628         regs->ea = (unsigned long) ka->sa.sa_handler;
 629         return;
 630
 631 give_sigsegv:
 632         if (sig == SIGSEGV)
 633                 ka->sa.sa_handler = SIG_DFL;
 634         force_sig(SIGSEGV, current);
 635 }
 636
 637 static inline void
 638 handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
 639 {
 640         switch (regs->r2) {
 641         case -ERESTARTNOHAND:
 642                 if (!has_handler)
 643                         goto do_restart;
 644                 regs->r2 = -EINTR;
 645                 break;
 646
 647         case -ERESTARTSYS:
 648                 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
 649                         regs->r2 = -EINTR;
 650                         break;
 651                 }
 652         /* fallthrough */
 653         case -ERESTARTNOINTR:
 654         do_restart:
 655                 regs->r2 = regs->orig_r2;
 656                 regs->ea -= 4;
 657                 break;
 658         }
 659 }
 660
 661 /*
 662  * OK, we're invoking a handler
 663  */
 664 static void
 665 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
 666               sigset_t *oldset, struct pt_regs *regs)
 667 {
 668         /* are we from a system call? */
 669         if (regs->orig_r2 >= 0)
 670                 /* If so, check system call restarting.. */
 671                 handle_restart(regs, ka, 1);
 672
 673         /* set up the stack frame */
 674         if (ka->sa.sa_flags & SA_SIGINFO)
 675                 setup_rt_frame(sig, ka, info, oldset, regs);
 676         else
 677                 setup_frame(sig, ka, oldset, regs);
 678
 679         if (ka->sa.sa_flags & SA_ONESHOT)
 680                 ka->sa.sa_handler = SIG_DFL;
 681
 682         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 683                 spin_lock_irq(&current->sighand->siglock);
 684                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 685                 sigaddset(&current->blocked,sig);
 686                 recalc_sigpending();
 687                 spin_unlock_irq(&current->sighand->siglock);
 688         }
 689 }
 690
 691 /*
 692  * Note that 'init' is a special process: it doesn't get signals it doesn't
 693  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 694  * mistake.
 695  */
 696 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
 697 {
 698         struct k_sigaction ka;
 699         siginfo_t info;
 700         int signr;
 701
 702         /*
 703          * We want the common case to go fast, which
 704          * is why we may in certain cases get here from
 705          * kernel mode. Just return without doing anything
 706          * if so.
 707          */
 708         if (!user_mode(regs))
 709                 return 1;
 710
 711         /* FIXME - Do we still need to do this ? */
 712         current->thread.kregs = regs;
 713
 714         if (!oldset)
 715                 oldset = &current->blocked;
 716
 717         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 718         if (signr > 0) {
 719                 /* Whee!  Actually deliver the signal.  */
 720                 handle_signal(signr, &ka, &info, oldset, regs);
 721                 return 1;
 722         }
 723
 724         /* Did we come from a system call? */
 725         if (regs->orig_r2 >= 0){
 726                 /* Restart the system call - no handlers present */
 727                 if (regs->r2 == -ERESTARTNOHAND
 728                     || regs->r2 == -ERESTARTSYS
 729                     || regs->r2 == -ERESTARTNOINTR) {
 730                         regs->r2 = regs->orig_r2;
 731                         regs->ea -= 4;
 732                 } else if (regs->r2 == -ERESTART_RESTARTBLOCK) {
 733                         regs->r2 = __NR_restart_syscall;
 734                         regs->ea -= 4;
 735                 }
 736         }
 737         return 0;
 738 }