git.oblomov.eu Git - linux-2.6/blob - 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/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;
 453                 if (current->binfmt->hasvdso)
 454                         restorer = VSYSCALL32_SIGRETURN;
 455                 else
 456                         restorer = (void *)&frame->retcode;
 457                 if (ka->sa.sa_flags & SA_RESTORER)
 458                         restorer = ka->sa.sa_restorer;
 459                 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 460         }
 461         /* These are actually not used anymore, but left because some
 462            gdb versions depend on them as a marker. */
 463         {
 464                 /* copy_to_user optimizes that into a single 8 byte store */
 465                 static const struct {
 466                         u16 poplmovl;
 467                         u32 val;
 468                         u16 int80;
 469                         u16 pad;
 470                 } __attribute__((packed)) code = {
 471                         0xb858,          /* popl %eax ; movl $...,%eax */
 472                         __NR_ia32_sigreturn,
 473                         0x80cd,         /* int $0x80 */
 474                         0,
 475                 };
 476                 err |= __copy_to_user(frame->retcode, &code, 8);
 477         }
 478         if (err)
 479                 goto give_sigsegv;
 480
 481         /* Set up registers for signal handler */
 482         regs->rsp = (unsigned long) frame;
 483         regs->rip = (unsigned long) ka->sa.sa_handler;
 484
 485         /* Make -mregparm=3 work */
 486         regs->rax = sig;
 487         regs->rdx = 0;
 488         regs->rcx = 0;
 489
 490         asm volatile("movl %0,%%ds" :: "r" (__USER32_DS));
 491         asm volatile("movl %0,%%es" :: "r" (__USER32_DS));
 492
 493         regs->cs = __USER32_CS;
 494         regs->ss = __USER32_DS;
 495
 496         set_fs(USER_DS);
 497         regs->eflags &= ~TF_MASK;
 498         if (test_thread_flag(TIF_SINGLESTEP))
 499                 ptrace_notify(SIGTRAP);
 500
 501 #if DEBUG_SIG
 502         printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 503                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 504 #endif
 505
 506         return 0;
 507
 508 give_sigsegv:
 509         force_sigsegv(sig, current);
 510         return -EFAULT;
 511 }
 512
 513 int ia32_setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 514                         compat_sigset_t *set, struct pt_regs * regs)
 515 {
 516         struct rt_sigframe __user *frame;
 517         int err = 0;
 518
 519         frame = get_sigframe(ka, regs, sizeof(*frame));
 520
 521         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 522                 goto give_sigsegv;
 523
 524         {
 525                 struct exec_domain *ed = current_thread_info()->exec_domain;
 526                 err |= __put_user((ed
 527                            && ed->signal_invmap
 528                            && sig < 32
 529                            ? ed->signal_invmap[sig]
 530                            : sig),
 531                           &frame->sig);
 532         }
 533         err |= __put_user(ptr_to_compat(&frame->info), &frame->pinfo);
 534         err |= __put_user(ptr_to_compat(&frame->uc), &frame->puc);
 535         err |= copy_siginfo_to_user32(&frame->info, info);
 536         if (err)
 537                 goto give_sigsegv;
 538
 539         /* Create the ucontext.  */
 540         err |= __put_user(0, &frame->uc.uc_flags);
 541         err |= __put_user(0, &frame->uc.uc_link);
 542         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 543         err |= __put_user(sas_ss_flags(regs->rsp),
 544                           &frame->uc.uc_stack.ss_flags);
 545         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 546         err |= ia32_setup_sigcontext(&frame->uc.uc_mcontext, &frame->fpstate,
 547                                 regs, set->sig[0]);
 548         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 549         if (err)
 550                 goto give_sigsegv;
 551
 552
 553         {
 554                 void __user *restorer = VSYSCALL32_RTSIGRETURN;
 555                 if (ka->sa.sa_flags & SA_RESTORER)
 556                         restorer = ka->sa.sa_restorer;
 557                 err |= __put_user(ptr_to_compat(restorer), &frame->pretcode);
 558         }
 559
 560         /* This is movl $,%eax ; int $0x80 */
 561         /* Not actually used anymore, but left because some gdb versions
 562            need it. */
 563         {
 564                 /* __copy_to_user optimizes that into a single 8 byte store */
 565                 static const struct {
 566                         u8 movl;
 567                         u32 val;
 568                         u16 int80;
 569                         u16 pad;
 570                         u8  pad2;
 571                 } __attribute__((packed)) code = {
 572                         0xb8,
 573                         __NR_ia32_rt_sigreturn,
 574                         0x80cd,
 575                         0,
 576                 };
 577                 err |= __copy_to_user(frame->retcode, &code, 8);
 578         }
 579         if (err)
 580                 goto give_sigsegv;
 581
 582         /* Set up registers for signal handler */
 583         regs->rsp = (unsigned long) frame;
 584         regs->rip = (unsigned long) ka->sa.sa_handler;
 585
 586         /* Make -mregparm=3 work */
 587         regs->rax = sig;
 588         regs->rdx = (unsigned long) &frame->info;
 589         regs->rcx = (unsigned long) &frame->uc;
 590
 591         /* Make -mregparm=3 work */
 592         regs->rax = sig;
 593         regs->rdx = (unsigned long) &frame->info;
 594         regs->rcx = (unsigned long) &frame->uc;
 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         regs->eflags &= ~TF_MASK;
 604         if (test_thread_flag(TIF_SINGLESTEP))
 605                 ptrace_notify(SIGTRAP);
 606
 607 #if DEBUG_SIG
 608         printk("SIG deliver (%s:%d): sp=%p pc=%lx ra=%u\n",
 609                 current->comm, current->pid, frame, regs->rip, frame->pretcode);
 610 #endif
 611
 612         return 0;
 613
 614 give_sigsegv:
 615         force_sigsegv(sig, current);
 616         return -EFAULT;
 617 }