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