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