arch/x86_64/ia32/ia32_signal.c

   1 /*
   2  *  linux/arch/x86_64/ia32/ia32_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  *  2000-12-*   x86-64 compatibility mode signal handling by Andi Kleen
   9  *
  10  *  $Id: ia32_signal.c,v 1.22 2002/07/29 10:34:03 ak Exp $
  11  */
  12
  13 #include <linux/sched.h>
  14 #include <linux/mm.h>
  15 #include <linux/smp.h>
  16 #include <linux/smp_lock.h>
  17 #include <linux/kernel.h>
  18 #include <linux/signal.h>
  19 #include <linux/errno.h>
  20 #include <linux/wait.h>
  21 #include <linux/ptrace.h>
  22 #include <linux/unistd.h>
  23 #include <linux/stddef.h>
  24 #include <linux/personality.h>
  25 #include <linux/compat.h>
  26 #include <asm/ucontext.h>
  27 #include <asm/uaccess.h>
  28 #include <asm/i387.h>
  29 #include <asm/ia32.h>
  30 #include <asm/ptrace.h>
  31 #include <asm/ia32_unistd.h>
  32 #include <asm/user32.h>
  33 #include <asm/sigcontext32.h>
  34 #include <asm/fpu32.h>
  35 #include <asm/proto.h>
  36 #include <asm/vsyscall32.h>
  37
  38 #define DEBUG_SIG 0
  39
  40 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  41
  42 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  43 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
  44
  45 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
  46 {
  47         int err;
  48         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  49                 return -EFAULT;
  50
  51         /* If you change siginfo_t structure, please make sure that
  52                    this code is fixed accordingly.
  53                    It should never copy any pad contained in the structure
  54                    to avoid security leaks, but must copy the generic
  55                    3 ints plus the relevant union member.  */
  56                 err = __put_user(from->si_signo, &to->si_signo);
  57                 err |= __put_user(from->si_errno, &to->si_errno);
  58         err |= __put_user((short)from->si_code, &to->si_code);
  59
  60         if (from->si_code < 0) {
  61                 err |= __put_user(from->si_pid, &to->si_pid);
  62                 err |= __put_user(from->si_uid, &to->si_uid);
  63                 err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
  64         } else {
  65                 /* First 32bits of unions are always present:
  66                  * si_pid === si_band === si_tid === si_addr(LS half) */
  67                 err |= __put_user(from->_sifields._pad[0], &to->_sifields._pad[0]);
  68                 switch (from->si_code >> 16) {
  69                 case __SI_FAULT >> 16:
  70                         break;
  71                 case __SI_CHLD >> 16:
  72                         err |= __put_user(from->si_utime, &to->si_utime);
  73                         err |= __put_user(from->si_stime, &to->si_stime);
  74                         err |= __put_user(from->si_status, &to->si_status);
  75                 default:
  76                 case __SI_KILL >> 16:
  77                         err |= __put_user(from->si_uid, &to->si_uid);
  78                         break;
  79                 case __SI_POLL >> 16:
  80                         err |= __put_user(from->si_fd, &to->si_fd);
  81                         break;
  82                 case __SI_TIMER >> 16:
  83                         err |= __put_user(from->si_overrun, &to->si_overrun);
  84                         err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
  85                         break;
  86                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
  87                 case __SI_MESGQ >> 16:
  88                         err |= __put_user(from->si_uid, &to->si_uid);
  89                         err |= __put_user(from->si_int, &to->si_int);
  90                         break;
  91                 }
  92         }
  93         return err;
  94 }
  95
  96 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
  97 {
  98         int err;
  99         u32 ptr32;
 100         if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
 101                 return -EFAULT;
 102
 103         err = __get_user(to->si_signo, &from->si_signo);
 104         err |= __get_user(to->si_errno, &from->si_errno);
 105         err |= __get_user(to->si_code, &from->si_code);
 106
 107         err |= __get_user(to->si_pid, &from->si_pid);
 108         err |= __get_user(to->si_uid, &from->si_uid);
 109         err |= __get_user(ptr32, &from->si_ptr);
 110         to->si_ptr = compat_ptr(ptr32);
 111
 112         return err;
 113 }
 114
 115 asmlinkage long
 116 sys32_sigsuspend(int history0, int history1, old_sigset_t mask,
 117                  struct pt_regs *regs)
 118 {
 119         sigset_t saveset;
 120
 121         mask &= _BLOCKABLE;
 122         spin_lock_irq(&current->sighand->siglock);
 123         saveset = current->blocked;
 124         siginitset(&current->blocked, mask);
 125         recalc_sigpending();
 126         spin_unlock_irq(&current->sighand->siglock);
 127
 128         regs->rax = -EINTR;
 129         while (1) {
 130                 current->state = TASK_INTERRUPTIBLE;
 131                 schedule();
 132                 if (do_signal(regs, &saveset))
 133                         return -EINTR;
 134         }
 135 }
 136
 137 asmlinkage long
 138 sys32_sigaltstack(const stack_ia32_t __user *uss_ptr,
 139                   stack_ia32_t __user *uoss_ptr,
 140                   struct pt_regs *regs)
 141 {
 142         stack_t uss,uoss;
 143         int ret;
 144         mm_segment_t seg;
 145         if (uss_ptr) {
 146                 u32 ptr;
 147                 memset(&uss,0,sizeof(stack_t));
 148                 if (!access_ok(VERIFY_READ,uss_ptr,sizeof(stack_ia32_t)) ||
 149                             __get_user(ptr, &uss_ptr->ss_sp) ||
 150                             __get_user(uss.ss_flags, &uss_ptr->ss_flags) ||
 151                             __get_user(uss.ss_size, &uss_ptr->ss_size))
 152                         return -EFAULT;
 153                 uss.ss_sp = compat_ptr(ptr);
 154         }
 155         seg = get_fs();
 156         set_fs(KERNEL_DS);
 157         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, regs->rsp);
 158         set_fs(seg);
 159         if (ret >= 0 && uoss_ptr)  {
 160                 if (!access_ok(VERIFY_WRITE,uoss_ptr,sizeof(stack_ia32_t)) ||
 161                     __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
 162                     __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
 163                     __put_user(uoss.ss_size, &uoss_ptr->ss_size))
 164                         ret = -EFAULT;
 165         }
 166         return ret;
 167 }
 168
 169 /*
 170  * Do a signal return; undo the signal stack.
 171  */
 172
 173 struct sigframe
 174 {
 175         u32 pretcode;
 176         int sig;
 177         struct sigcontext_ia32 sc;
 178         struct _fpstate_ia32 fpstate;
 179         unsigned int extramask[_COMPAT_NSIG_WORDS-1];
 180         char retcode[8];
 181 };
 182
 183 struct rt_sigframe
 184 {
 185         u32 pretcode;
 186         int sig;
 187         u32 pinfo;
 188         u32 puc;
 189         compat_siginfo_t info;
 190         struct ucontext_ia32 uc;
 191         struct _fpstate_ia32 fpstate;
 192         char retcode[8];
 193 };
 194
 195 static int
 196 ia32_restore_sigcontext(struct pt_regs *regs, struct sigcontext_ia32 __user *sc, unsigned int *peax)
 197 {
 198         unsigned int err = 0;
 199
 200         /* Always make any pending restarted system calls return -EINTR */
 201         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 202
 203 #if DEBUG_SIG
 204         printk("SIG restore_sigcontext: sc=%p err(%x) eip(%x) cs(%x) flg(%x)\n",
 205                 sc, sc->err, sc->eip, sc->cs, sc->eflags);
 206 #endif
 207 #define COPY(x)         { \
 208         unsigned int reg;       \
 209         err |= __get_user(reg, &sc->e ##x);     \
 210         regs->r ## x = reg;                     \
 211 }
 212
 213 #define RELOAD_SEG(seg,mask)                                            \
 214         { unsigned int cur;                             \
 215           unsigned short pre;                           \
 216           err |= __get_user(pre, &sc->seg);                             \
 217           asm volatile("movl %%" #seg ",%0" : "=r" (cur));              \
 218           pre |= mask;                                                  \
 219           if (pre != cur) loadsegment(seg,pre); }
 220
 221         /* Reload fs and gs if they have changed in the signal handler.
 222            This does not handle long fs/gs base changes in the handler, but
 223            does not clobber them at least in the normal case. */
 224
 225         {
 226                 unsigned gs, oldgs;
 227                 err |= __get_user(gs, &sc->gs);
 228                 gs |= 3;
 229                 asm("movl %%gs,%0" : "=r" (oldgs));
 230                 if (gs != oldgs)
 231                 load_gs_index(gs);
 232         }
 233         RELOAD_SEG(fs,3);
 234         RELOAD_SEG(ds,3);
 235         RELOAD_SEG(es,3);
 236
 237         COPY(di); COPY(si); COPY(bp); COPY(sp); COPY(bx);
 238         COPY(dx); COPY(cx); COPY(ip);
 239         /* Don't touch extended registers */
 240
 241         err |= __get_user(regs->cs, &sc->cs);
 242         regs->cs |= 3;
 243         err |= __get_user(regs->ss, &sc->ss);
 244         regs->ss |= 3;
 245
 246         {
 247                 unsigned int tmpflags;
 248                 err |= __get_user(tmpflags, &sc->eflags);
 249                 regs->eflags = (regs->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
 250                 regs->orig_rax = -1;            /* disable syscall checks */
 251         }
 252
 253         {
 254                 u32 tmp;
 255                 struct _fpstate_ia32 __user * buf;
 256                 err |= __get_user(tmp, &sc->fpstate);
 257                 buf = compat_ptr(tmp);
 258                 if (buf) {
 259                         if (verify_area(VERIFY_READ, buf, sizeof(*buf)))
 260                                 goto badframe;
 261                         err |= restore_i387_ia32(current, buf, 0);
 262                 } else {
 263                         struct task_struct *me = current;
 264                         if (used_math()) {
 265                                 clear_fpu(me);
 266                                 clear_used_math();
 267                         }
 268                 }
 269         }
 270
 271         {
 272                 u32 tmp;
 273                 err |= __get_user(tmp, &sc->eax);
 274                 *peax = tmp;
 275         }
 276         return err;
 277
 278 badframe:
 279         return 1;
 280 }
 281
 282 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 283 {
 284         struct sigframe __user *frame = (struct sigframe __user *)(regs->rsp-8);
 285         sigset_t set;
 286         unsigned int eax;
 287
 288         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 289                 goto badframe;
 290         if (__get_user(set.sig[0], &frame->sc.oldmask)
 291             || (_COMPAT_NSIG_WORDS > 1
 292                 && __copy_from_user((((char *) &set.sig) + 4), &frame->extramask,
 293                                     sizeof(frame->extramask))))
 294                 goto badframe;
 295
 296         sigdelsetmask(&set, ~_BLOCKABLE);
 297         spin_lock_irq(&current->sighand->siglock);
 298         current->blocked = set;
 299         recalc_sigpending();
 300         spin_unlock_irq(&current->sighand->siglock);
 301
 302         if (ia32_restore_sigcontext(regs, &frame->sc, &eax))
 303                 goto badframe;
 304         return eax;
 305
 306 badframe:
 307         signal_fault(regs, frame, "32bit sigreturn");
 308         return 0;
 309 }
 310
 311 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 312 {
 313         struct rt_sigframe __user *frame;
 314         sigset_t set;
 315         unsigned int eax;
 316         struct pt_regs tregs;
 317
 318         frame = (struct rt_sigframe __user *)(regs->rsp - 4);
 319
 320         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 321                 goto badframe;
 322         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 323                 goto badframe;
 324
 325         sigdelsetmask(&set, ~_BLOCKABLE);
 326         spin_lock_irq(&current->sighand->siglock);
 327         current->blocked = set;
 328         recalc_sigpending();
 329         spin_unlock_irq(&current->sighand->siglock);
 330
 331         if (ia32_restore_sigcontext(regs, &frame->uc.uc_mcontext, &eax))
 332                 goto badframe;
 333
 334         tregs = *regs;
 335         if (sys32_sigaltstack(&frame->uc.uc_stack, NULL, &tregs) == -EFAULT)
 336                 goto badframe;
 337
 338         return eax;
 339
 340 badframe:
 341         signal_fault(regs,frame,"32bit rt sigreturn");
 342         return 0;
 343 }
 344
 345 /*
 346  * Set up a signal frame.
 347  */
 348
 349 static int
 350 ia32_setup_sigcontext(struct sigcontext_ia32 __user *sc, struct _fpstate_ia32 __user *fpstate,
 351                  struct pt_regs *regs, unsigned int mask)
 352 {
 353         int tmp, err = 0;
 354         u32 eflags;
 355
 356         tmp = 0;
 357         __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
 358         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
 359         __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
 360         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
 361         __asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp));
 362         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
 363         __asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));
 364         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
 365
 366         err |= __put_user((u32)regs->rdi, &sc->edi);
 367         err |= __put_user((u32)regs->rsi, &sc->esi);
 368         err |= __put_user((u32)regs->rbp, &sc->ebp);
 369         err |= __put_user((u32)regs->rsp, &sc->esp);
 370         err |= __put_user((u32)regs->rbx, &sc->ebx);
 371         err |= __put_user((u32)regs->rdx, &sc->edx);
 372         err |= __put_user((u32)regs->rcx, &sc->ecx);
 373         err |= __put_user((u32)regs->rax, &sc->eax);
 374         err |= __put_user((u32)regs->cs, &sc->cs);
 375         err |= __put_user((u32)regs->ss, &sc->ss);
 376         err |= __put_user(current->thread.trap_no, &sc->trapno);
 377         err |= __put_user(current->thread.error_code, &sc->err);
 378         err |= __put_user((u32)regs->rip, &sc->eip);
 379         eflags = regs->eflags;
 380         if (current->ptrace & PT_PTRACED) {
 381                 eflags &= ~TF_MASK;
 382         }
 383         err |= __put_user((u32)eflags, &sc->eflags);
 384         err |= __put_user((u32)regs->rsp, &sc->esp_at_signal);
 385
 386         tmp = save_i387_ia32(current, fpstate, regs, 0);
 387         if (tmp < 0)
 388           err = -EFAULT;
 389         else {
 390                 clear_used_math();
 391                 stts();
 392           err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL), &sc->fpstate);
 393         }
 394
 395         /* non-iBCS2 extensions.. */
 396         err |= __put_user(mask, &sc->oldmask);
 397         err |= __put_user(current->thread.cr2, &sc->cr2);
 398
 399         return err;
 400 }
 401
 402 /*
 403  * Determine which stack to use..
 404  */
 405 static void __user *
 406 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 407 {
 408         unsigned long rsp;
 409
 410         /* Default to using normal stack */
 411         rsp = regs->rsp;
 412
 413         /* This is the X/Open sanctioned signal stack switching.  */
 414         if (ka->sa.sa_flags & SA_ONSTACK) {
 415                 if (sas_ss_flags(rsp) == 0)
 416                         rsp = current->sas_ss_sp + current->sas_ss_size;
 417         }
 418
 419         /* This is the legacy signal stack switching. */
 420         else if ((regs->ss & 0xffff) != __USER_DS &&
 421                 !(ka->sa.sa_flags & SA_RESTORER) &&
 422                  ka->sa.sa_restorer) {
 423                 rsp = (unsigned long) ka->sa.sa_restorer;
 424         }
 425
 426         return (void __user *)((rsp - frame_size) & -8UL);
 427 }
 428
 429 void ia32_setup_frame(int sig, struct k_sigaction *ka,
 430                         compat_sigset_t *set, struct pt_regs * regs)
 431 {
 432         struct sigframe __user *frame;
 433         int err = 0;
 434
 435         frame = get_sigframe(ka, regs, sizeof(*frame));
 436
 437         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 438                 goto give_sigsegv;
 439
 440         {
 441                 struct exec_domain *ed = current_thread_info()->exec_domain;
 442         err |= __put_user((ed
 443                            && ed->signal_invmap
 444                            && sig < 32
 445                            ? ed->signal_invmap[sig]
 446                            : sig),
 447                           &frame->sig);
 448         }
 449         if (err)
 450                 goto give_sigsegv;
 451
 452         err |= ia32_setup_sigcontext(&frame->sc, &frame->fpstate, regs, set->sig[0]);
 453         if (err)
 454                 goto give_sigsegv;
 455
 456         if (_COMPAT_NSIG_WORDS > 1) {
 457                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 458                                       sizeof(frame->extramask));
 459         }
 460         if (err)
 461                 goto give_sigsegv;
 462
 463         /* Return stub is in 32bit vsyscall page */
 464         {
 465                 void __user *restorer = VSYSCALL32_SIGRETURN;
 466                 if (ka->sa.sa_flags & SA_RESTORER)
 467                         restorer = ka->sa.sa_restorer;
 468                 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 469         }
 470         /* These are actually not used anymore, but left because some
 471            gdb versions depend on them as a marker. */
 472         {
 473                 /* copy_to_user optimizes that into a single 8 byte store */
 474                 static const struct {
 475                         u16 poplmovl;
 476                         u32 val;
 477                         u16 int80;
 478                         u16 pad;
 479                 } __attribute__((packed)) code = {
 480                         0xb858,          /* popl %eax ; movl $...,%eax */
 481                         __NR_ia32_sigreturn,
 482                         0x80cd,         /* int $0x80 */
 483                         0,
 484                 };
 485                 err |= __copy_to_user(frame->retcode, &code, 8);
 486         }
 487         if (err)
 488                 goto give_sigsegv;
 489
 490         /* Set up registers for signal handler */
 491         regs->rsp = (unsigned long) frame;
 492         regs->rip = (unsigned long) ka->sa.sa_handler;
 493
 494         asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
 495         asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
 496
 497         regs->cs = __USER32_CS;
 498         regs->ss = __USER32_DS;
 499
 500         set_fs(USER_DS);
 501         if (regs->eflags & TF_MASK) {
 502                 if (current->ptrace & PT_PTRACED) {
 503                         ptrace_notify(SIGTRAP);
 504                 } else {
 505                         regs->eflags &= ~TF_MASK;
 506                 }
 507         }
 508
 509 #if DEBUG_SIG
 510         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 511                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 512 #endif
 513
 514         return;
 515
 516 give_sigsegv:
 517         force_sigsegv(sig, current);
 518 }
 519
 520 void ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 521                            compat_sigset_t *set, struct pt_regs * regs)
 522 {
 523         struct rt_sigframe __user *frame;
 524         int err = 0;
 525
 526         frame = get_sigframe(ka, regs, sizeof(*frame));
 527
 528         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 529                 goto give_sigsegv;
 530
 531
 532         {
 533                 struct exec_domain *ed = current_thread_info()->exec_domain;
 534         err |= __put_user((ed
 535                            && ed->signal_invmap
 536                            && sig < 32
 537                            ? ed->signal_invmap[sig]
 538                            : sig),
 539                           &frame->sig);
 540         }
 541         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 542         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 543         err |= copy_siginfo_to_user32(&frame->info, info);
 544         if (err)
 545                 goto give_sigsegv;
 546
 547         /* Create the ucontext.  */
 548         err |= __put_user(0, &frame->uc.uc_flags);
 549         err |= __put_user(0, &frame->uc.uc_link);
 550         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 551         err |= __put_user(sas_ss_flags(regs->rsp),
 552                           &frame->uc.uc_stack.ss_flags);
 553         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 554         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
 555                                 regs, set->sig[0]);
 556         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 557         if (err)
 558                 goto give_sigsegv;
 559
 560
 561         {
 562                 void __user *restorer = VSYSCALL32_RTSIGRETURN;
 563                 if (ka->sa.sa_flags & SA_RESTORER)
 564                         restorer = ka->sa.sa_restorer;
 565                 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 566         }
 567
 568         /* This is movl $,%eax ; int $0x80 */
 569         /* Not actually used anymore, but left because some gdb versions
 570            need it. */
 571         {
 572                 /* __copy_to_user optimizes that into a single 8 byte store */
 573                 static const struct {
 574                         u8 movl;
 575                         u32 val;
 576                         u16 int80;
 577                         u16 pad;
 578                         u8  pad2;
 579                 } __attribute__((packed)) code = {
 580                         0xb8,
 581                         __NR_ia32_rt_sigreturn,
 582                         0x80cd,
 583                         0,
 584                 };
 585                 err |= __copy_to_user(frame->retcode, &code, 8);
 586         }
 587         if (err)
 588                 goto give_sigsegv;
 589
 590         /* Set up registers for signal handler */
 591         regs->rsp = (unsigned long) frame;
 592         regs->rip = (unsigned long) ka->sa.sa_handler;
 593
 594         asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
 595         asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
 596
 597         regs->cs = __USER32_CS;
 598         regs->ss = __USER32_DS;
 599
 600         set_fs(USER_DS);
 601         if (regs->eflags & TF_MASK) {
 602                 if (current->ptrace & PT_PTRACED) {
 603                         ptrace_notify(SIGTRAP);
 604                 } else {
 605                         regs->eflags &= ~TF_MASK;
 606                 }
 607         }
 608
 609 #if DEBUG_SIG
 610         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 611                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 612 #endif
 613
 614         return;
 615
 616 give_sigsegv:
 617         force_sigsegv(sig, current);
 618 }
 619