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