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
  11 #include <linux/sched.h>
  12 #include <linux/mm.h>
  13 #include <linux/smp.h>
  14 #include <linux/smp_lock.h>
  15 #include <linux/kernel.h>
  16 #include <linux/signal.h>
  17 #include <linux/errno.h>
  18 #include <linux/wait.h>
  19 #include <linux/ptrace.h>
  20 #include <linux/unistd.h>
  21 #include <linux/stddef.h>
  22 #include <linux/personality.h>
  23 #include <linux/compat.h>
  24 #include <asm/ucontext.h>
  25 #include <asm/uaccess.h>
  26 #include <asm/i387.h>
  27 #include <asm/ia32.h>
  28 #include <asm/ptrace.h>
  29 #include <asm/ia32_unistd.h>
  30 #include <asm/user32.h>
  31 #include <asm/sigcontext32.h>
  32 #include <asm/fpu32.h>
  33 #include <asm/proto.h>
  34 #include <asm/vsyscall32.h>
  35
  36 #define DEBUG_SIG 0
  37
  38 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  39
  40 asmlinkage int do_signal(struct pt_regs *regs, sigset_t *oldset);
  41 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
  42
  43 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
  44 {
  45         int err;
  46         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  47                 return -EFAULT;
  48
  49         /* If you change siginfo_t structure, please make sure that
  50            this code is fixed accordingly.
  51            It should never copy any pad contained in the structure
  52            to avoid security leaks, but must copy the generic
  53            3 ints plus the relevant union member.  */
  54         err = __put_user(from->si_signo, &to->si_signo);
  55         err |= __put_user(from->si_errno, &to->si_errno);
  56         err |= __put_user((short)from->si_code, &to->si_code);
  57
  58         if (from->si_code < 0) {
  59                 err |= __put_user(from->si_pid, &to->si_pid);
  60                 err |= __put_user(from->si_uid, &to->si_uid);
  61                 err |= __put_user(ptr_to_compat(from->si_ptr), &to->si_ptr);
  62         } else {
  63                 /* First 32bits of unions are always present:
  64                  * si_pid === si_band === si_tid === si_addr(LS half) */
  65                 err |= __put_user(from->_sifields._pad[0], &to->_sifields._pad[0]);
  66                 switch (from->si_code >> 16) {
  67                 case __SI_FAULT >> 16:
  68                         break;
  69                 case __SI_CHLD >> 16:
  70                         err |= __put_user(from->si_utime, &to->si_utime);
  71                         err |= __put_user(from->si_stime, &to->si_stime);
  72                         err |= __put_user(from->si_status, &to->si_status);
  73                         /* FALL THROUGH */
  74                 default:
  75                 case __SI_KILL >> 16:
  76                         err |= __put_user(from->si_uid, &to->si_uid);
  77                         break;
  78                 case __SI_POLL >> 16:
  79                         err |= __put_user(from->si_fd, &to->si_fd);
  80                         break;
  81                 case __SI_TIMER >> 16:
  82                         err |= __put_user(from->si_overrun, &to->si_overrun);
  83                         err |= __put_user(ptr_to_compat(from->si_ptr),
  84                                         &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 (!access_ok(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 (!access_ok(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 (!access_ok(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
 355         tmp = 0;
 356         __asm__("movl %%gs,%0" : "=r"(tmp): "0"(tmp));
 357         err |= __put_user(tmp, (unsigned int __user *)&sc->gs);
 358         __asm__("movl %%fs,%0" : "=r"(tmp): "0"(tmp));
 359         err |= __put_user(tmp, (unsigned int __user *)&sc->fs);
 360         __asm__("movl %%ds,%0" : "=r"(tmp): "0"(tmp));
 361         err |= __put_user(tmp, (unsigned int __user *)&sc->ds);
 362         __asm__("movl %%es,%0" : "=r"(tmp): "0"(tmp));
 363         err |= __put_user(tmp, (unsigned int __user *)&sc->es);
 364
 365         err |= __put_user((u32)regs->rdi, &sc->edi);
 366         err |= __put_user((u32)regs->rsi, &sc->esi);
 367         err |= __put_user((u32)regs->rbp, &sc->ebp);
 368         err |= __put_user((u32)regs->rsp, &sc->esp);
 369         err |= __put_user((u32)regs->rbx, &sc->ebx);
 370         err |= __put_user((u32)regs->rdx, &sc->edx);
 371         err |= __put_user((u32)regs->rcx, &sc->ecx);
 372         err |= __put_user((u32)regs->rax, &sc->eax);
 373         err |= __put_user((u32)regs->cs, &sc->cs);
 374         err |= __put_user((u32)regs->ss, &sc->ss);
 375         err |= __put_user(current->thread.trap_no, &sc->trapno);
 376         err |= __put_user(current->thread.error_code, &sc->err);
 377         err |= __put_user((u32)regs->rip, &sc->eip);
 378         err |= __put_user((u32)regs->eflags, &sc->eflags);
 379         err |= __put_user((u32)regs->rsp, &sc->esp_at_signal);
 380
 381         tmp = save_i387_ia32(current, fpstate, regs, 0);
 382         if (tmp < 0)
 383                 err = -EFAULT;
 384         else {
 385                 clear_used_math();
 386                 stts();
 387                 err |= __put_user(ptr_to_compat(tmp ? fpstate : NULL),
 388                                         &sc->fpstate);
 389         }
 390
 391         /* non-iBCS2 extensions.. */
 392         err |= __put_user(mask, &sc->oldmask);
 393         err |= __put_user(current->thread.cr2, &sc->cr2);
 394
 395         return err;
 396 }
 397
 398 /*
 399  * Determine which stack to use..
 400  */
 401 static void __user *
 402 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 403 {
 404         unsigned long rsp;
 405
 406         /* Default to using normal stack */
 407         rsp = regs->rsp;
 408
 409         /* This is the X/Open sanctioned signal stack switching.  */
 410         if (ka->sa.sa_flags & SA_ONSTACK) {
 411                 if (sas_ss_flags(rsp) == 0)
 412                         rsp = current->sas_ss_sp + current->sas_ss_size;
 413         }
 414
 415         /* This is the legacy signal stack switching. */
 416         else if ((regs->ss & 0xffff) != __USER_DS &&
 417                 !(ka->sa.sa_flags & SA_RESTORER) &&
 418                  ka->sa.sa_restorer) {
 419                 rsp = (unsigned long) ka->sa.sa_restorer;
 420         }
 421
 422         rsp -= frame_size;
 423         /* Align the stack pointer according to the i386 ABI,
 424          * i.e. so that on function entry ((sp + 4) & 15) == 0. */
 425         rsp = ((rsp + 4) & -16ul) - 4;
 426         return (void __user *) rsp;
 427 }
 428
 429 int 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,
 453                                         set->sig[0]);
 454         if (err)
 455                 goto give_sigsegv;
 456
 457         if (_COMPAT_NSIG_WORDS > 1) {
 458                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 459                                       sizeof(frame->extramask));
 460         }
 461         if (err)
 462                 goto give_sigsegv;
 463
 464         /* Return stub is in 32bit vsyscall page */
 465         {
 466                 void __user *restorer = VSYSCALL32_SIGRETURN;
 467                 if (ka->sa.sa_flags & SA_RESTORER)
 468                         restorer = ka->sa.sa_restorer;
 469                 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 470         }
 471         /* These are actually not used anymore, but left because some
 472            gdb versions depend on them as a marker. */
 473         {
 474                 /* copy_to_user optimizes that into a single 8 byte store */
 475                 static const struct {
 476                         u16 poplmovl;
 477                         u32 val;
 478                         u16 int80;
 479                         u16 pad;
 480                 } __attribute__((packed)) code = {
 481                         0xb858,          /* popl %eax ; movl $...,%eax */
 482                         __NR_ia32_sigreturn,
 483                         0x80cd,         /* int $0x80 */
 484                         0,
 485                 };
 486                 err |= __copy_to_user(frame->retcode, &code, 8);
 487         }
 488         if (err)
 489                 goto give_sigsegv;
 490
 491         /* Set up registers for signal handler */
 492         regs->rsp = (unsigned long) frame;
 493         regs->rip = (unsigned long) ka->sa.sa_handler;
 494
 495         asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
 496         asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
 497
 498         regs->cs = __USER32_CS;
 499         regs->ss = __USER32_DS;
 500
 501         set_fs(USER_DS);
 502     regs->eflags &= ~TF_MASK;
 503     if (test_thread_flag(TIF_SINGLESTEP))
 504         ptrace_notify(SIGTRAP);
 505
 506 #if DEBUG_SIG
 507         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 508                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 509 #endif
 510
 511         return 1;
 512
 513 give_sigsegv:
 514         force_sigsegv(sig, current);
 515         return 0;
 516 }
 517
 518 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 519                         compat_sigset_t *set, struct pt_regs * regs)
 520 {
 521         struct rt_sigframe __user *frame;
 522         int err = 0;
 523
 524         frame = get_sigframe(ka, regs, sizeof(*frame));
 525
 526         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 527                 goto give_sigsegv;
 528
 529         {
 530                 struct exec_domain *ed = current_thread_info()->exec_domain;
 531                 err |= __put_user((ed
 532                            && ed->signal_invmap
 533                            && sig < 32
 534                            ? ed->signal_invmap[sig]
 535                            : sig),
 536                           &frame->sig);
 537         }
 538         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 539         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 540         err |= copy_siginfo_to_user32(&frame->info, info);
 541         if (err)
 542                 goto give_sigsegv;
 543
 544         /* Create the ucontext.  */
 545         err |= __put_user(0, &frame->uc.uc_flags);
 546         err |= __put_user(0, &frame->uc.uc_link);
 547         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 548         err |= __put_user(sas_ss_flags(regs->rsp),
 549                           &frame->uc.uc_stack.ss_flags);
 550         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 551         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
 552                                 regs, set->sig[0]);
 553         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 554         if (err)
 555                 goto give_sigsegv;
 556
 557
 558         {
 559                 void __user *restorer = VSYSCALL32_RTSIGRETURN;
 560                 if (ka->sa.sa_flags & SA_RESTORER)
 561                         restorer = ka->sa.sa_restorer;
 562                 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 563         }
 564
 565         /* This is movl $,%eax ; int $0x80 */
 566         /* Not actually used anymore, but left because some gdb versions
 567            need it. */
 568         {
 569                 /* __copy_to_user optimizes that into a single 8 byte store */
 570                 static const struct {
 571                         u8 movl;
 572                         u32 val;
 573                         u16 int80;
 574                         u16 pad;
 575                         u8  pad2;
 576                 } __attribute__((packed)) code = {
 577                         0xb8,
 578                         __NR_ia32_rt_sigreturn,
 579                         0x80cd,
 580                         0,
 581                 };
 582                 err |= __copy_to_user(frame->retcode, &code, 8);
 583         }
 584         if (err)
 585                 goto give_sigsegv;
 586
 587         /* Set up registers for signal handler */
 588         regs->rsp = (unsigned long) frame;
 589         regs->rip = (unsigned long) ka->sa.sa_handler;
 590
 591         asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
 592         asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
 593
 594         regs->cs = __USER32_CS;
 595         regs->ss = __USER32_DS;
 596
 597         set_fs(USER_DS);
 598     regs->eflags &= ~TF_MASK;
 599     if (test_thread_flag(TIF_SINGLESTEP))
 600         ptrace_notify(SIGTRAP);
 601
 602 #if DEBUG_SIG
 603         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 604                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 605 #endif
 606
 607         return 1;
 608
 609 give_sigsegv:
 610         force_sigsegv(sig, current);
 611         return 0;
 612 }