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