arch/x86/kernel/process_64.c

   1 /*
   2  *  Copyright (C) 1995  Linus Torvalds
   3  *
   4  *  Pentium III FXSR, SSE support
   5  *      Gareth Hughes <[email protected]>, May 2000
   6  *
   7  *  X86-64 port
   8  *      Andi Kleen.
   9  *
  10  *      CPU hotplug support - [email protected]
  11  */
  12
  13 /*
  14  * This file handles the architecture-dependent parts of process handling..
  15  */
  16
  17 #include <linux/cpu.h>
  18 #include <linux/errno.h>
  19 #include <linux/sched.h>
  20 #include <linux/fs.h>
  21 #include <linux/kernel.h>
  22 #include <linux/mm.h>
  23 #include <linux/elfcore.h>
  24 #include <linux/smp.h>
  25 #include <linux/slab.h>
  26 #include <linux/user.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/delay.h>
  29 #include <linux/export.h>
  30 #include <linux/ptrace.h>
  31 #include <linux/notifier.h>
  32 #include <linux/kprobes.h>
  33 #include <linux/kdebug.h>
  34 #include <linux/prctl.h>
  35 #include <linux/uaccess.h>
  36 #include <linux/io.h>
  37 #include <linux/ftrace.h>
  38
  39 #include <asm/pgtable.h>
  40 #include <asm/processor.h>
  41 #include <asm/fpu/internal.h>
  42 #include <asm/mmu_context.h>
  43 #include <asm/prctl.h>
  44 #include <asm/desc.h>
  45 #include <asm/proto.h>
  46 #include <asm/ia32.h>
  47 #include <asm/idle.h>
  48 #include <asm/syscalls.h>
  49 #include <asm/debugreg.h>
  50 #include <asm/switch_to.h>
  51 #include <asm/xen/hypervisor.h>
  52 #include <asm/vdso.h>
  53
  54 __visible DEFINE_PER_CPU(unsigned long, rsp_scratch);
  55
  56 /* Prints also some state that isn't saved in the pt_regs */
  57 void __show_regs(struct pt_regs *regs, int all)
  58 {
  59         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
  60         unsigned long d0, d1, d2, d3, d6, d7;
  61         unsigned int fsindex, gsindex;
  62         unsigned int ds, cs, es;
  63
  64         printk(KERN_DEFAULT "RIP: %04lx:%pS\n", regs->cs & 0xffff,
  65                 (void *)regs->ip);
  66         printk(KERN_DEFAULT "RSP: %04lx:%016lx EFLAGS: %08lx", regs->ss,
  67                 regs->sp, regs->flags);
  68         if (regs->orig_ax != -1)
  69                 pr_cont(" ORIG_RAX: %016lx\n", regs->orig_ax);
  70         else
  71                 pr_cont("\n");
  72
  73         printk(KERN_DEFAULT "RAX: %016lx RBX: %016lx RCX: %016lx\n",
  74                regs->ax, regs->bx, regs->cx);
  75         printk(KERN_DEFAULT "RDX: %016lx RSI: %016lx RDI: %016lx\n",
  76                regs->dx, regs->si, regs->di);
  77         printk(KERN_DEFAULT "RBP: %016lx R08: %016lx R09: %016lx\n",
  78                regs->bp, regs->r8, regs->r9);
  79         printk(KERN_DEFAULT "R10: %016lx R11: %016lx R12: %016lx\n",
  80                regs->r10, regs->r11, regs->r12);
  81         printk(KERN_DEFAULT "R13: %016lx R14: %016lx R15: %016lx\n",
  82                regs->r13, regs->r14, regs->r15);
  83
  84         asm("movl %%ds,%0" : "=r" (ds));
  85         asm("movl %%cs,%0" : "=r" (cs));
  86         asm("movl %%es,%0" : "=r" (es));
  87         asm("movl %%fs,%0" : "=r" (fsindex));
  88         asm("movl %%gs,%0" : "=r" (gsindex));
  89
  90         rdmsrl(MSR_FS_BASE, fs);
  91         rdmsrl(MSR_GS_BASE, gs);
  92         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
  93
  94         if (!all)
  95                 return;
  96
  97         cr0 = read_cr0();
  98         cr2 = read_cr2();
  99         cr3 = read_cr3();
 100         cr4 = __read_cr4();
 101
 102         printk(KERN_DEFAULT "FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
 103                fs, fsindex, gs, gsindex, shadowgs);
 104         printk(KERN_DEFAULT "CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds,
 105                         es, cr0);
 106         printk(KERN_DEFAULT "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
 107                         cr4);
 108
 109         get_debugreg(d0, 0);
 110         get_debugreg(d1, 1);
 111         get_debugreg(d2, 2);
 112         get_debugreg(d3, 3);
 113         get_debugreg(d6, 6);
 114         get_debugreg(d7, 7);
 115
 116         /* Only print out debug registers if they are in their non-default state. */
 117         if (!((d0 == 0) && (d1 == 0) && (d2 == 0) && (d3 == 0) &&
 118             (d6 == DR6_RESERVED) && (d7 == 0x400))) {
 119                 printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n",
 120                        d0, d1, d2);
 121                 printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n",
 122                        d3, d6, d7);
 123         }
 124
 125         if (boot_cpu_has(X86_FEATURE_OSPKE))
 126                 printk(KERN_DEFAULT "PKRU: %08x\n", read_pkru());
 127 }
 128
 129 void release_thread(struct task_struct *dead_task)
 130 {
 131         if (dead_task->mm) {
 132 #ifdef CONFIG_MODIFY_LDT_SYSCALL
 133                 if (dead_task->mm->context.ldt) {
 134                         pr_warn("WARNING: dead process %s still has LDT? <%p/%d>\n",
 135                                 dead_task->comm,
 136                                 dead_task->mm->context.ldt->entries,
 137                                 dead_task->mm->context.ldt->size);
 138                         BUG();
 139                 }
 140 #endif
 141         }
 142 }
 143
 144 int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
 145                 unsigned long arg, struct task_struct *p, unsigned long tls)
 146 {
 147         int err;
 148         struct pt_regs *childregs;
 149         struct fork_frame *fork_frame;
 150         struct inactive_task_frame *frame;
 151         struct task_struct *me = current;
 152
 153         p->thread.sp0 = (unsigned long)task_stack_page(p) + THREAD_SIZE;
 154         childregs = task_pt_regs(p);
 155         fork_frame = container_of(childregs, struct fork_frame, regs);
 156         frame = &fork_frame->frame;
 157         frame->bp = 0;
 158         frame->ret_addr = (unsigned long) ret_from_fork;
 159         p->thread.sp = (unsigned long) fork_frame;
 160         p->thread.io_bitmap_ptr = NULL;
 161
 162         savesegment(gs, p->thread.gsindex);
 163         p->thread.gsbase = p->thread.gsindex ? 0 : me->thread.gsbase;
 164         savesegment(fs, p->thread.fsindex);
 165         p->thread.fsbase = p->thread.fsindex ? 0 : me->thread.fsbase;
 166         savesegment(es, p->thread.es);
 167         savesegment(ds, p->thread.ds);
 168         memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
 169
 170         if (unlikely(p->flags & PF_KTHREAD)) {
 171                 /* kernel thread */
 172                 memset(childregs, 0, sizeof(struct pt_regs));
 173                 frame->bx = sp;         /* function */
 174                 frame->r12 = arg;
 175                 return 0;
 176         }
 177         frame->bx = 0;
 178         *childregs = *current_pt_regs();
 179
 180         childregs->ax = 0;
 181         if (sp)
 182                 childregs->sp = sp;
 183
 184         err = -ENOMEM;
 185         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
 186                 p->thread.io_bitmap_ptr = kmemdup(me->thread.io_bitmap_ptr,
 187                                                   IO_BITMAP_BYTES, GFP_KERNEL);
 188                 if (!p->thread.io_bitmap_ptr) {
 189                         p->thread.io_bitmap_max = 0;
 190                         return -ENOMEM;
 191                 }
 192                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
 193         }
 194
 195         /*
 196          * Set a new TLS for the child thread?
 197          */
 198         if (clone_flags & CLONE_SETTLS) {
 199 #ifdef CONFIG_IA32_EMULATION
 200                 if (in_ia32_syscall())
 201                         err = do_set_thread_area(p, -1,
 202                                 (struct user_desc __user *)tls, 0);
 203                 else
 204 #endif
 205                         err = do_arch_prctl(p, ARCH_SET_FS, tls);
 206                 if (err)
 207                         goto out;
 208         }
 209         err = 0;
 210 out:
 211         if (err && p->thread.io_bitmap_ptr) {
 212                 kfree(p->thread.io_bitmap_ptr);
 213                 p->thread.io_bitmap_max = 0;
 214         }
 215
 216         return err;
 217 }
 218
 219 static void
 220 start_thread_common(struct pt_regs *regs, unsigned long new_ip,
 221                     unsigned long new_sp,
 222                     unsigned int _cs, unsigned int _ss, unsigned int _ds)
 223 {
 224         loadsegment(fs, 0);
 225         loadsegment(es, _ds);
 226         loadsegment(ds, _ds);
 227         load_gs_index(0);
 228         regs->ip                = new_ip;
 229         regs->sp                = new_sp;
 230         regs->cs                = _cs;
 231         regs->ss                = _ss;
 232         regs->flags             = X86_EFLAGS_IF;
 233         force_iret();
 234 }
 235
 236 void
 237 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
 238 {
 239         start_thread_common(regs, new_ip, new_sp,
 240                             __USER_CS, __USER_DS, 0);
 241 }
 242
 243 #ifdef CONFIG_COMPAT
 244 void compat_start_thread(struct pt_regs *regs, u32 new_ip, u32 new_sp)
 245 {
 246         start_thread_common(regs, new_ip, new_sp,
 247                             test_thread_flag(TIF_X32)
 248                             ? __USER_CS : __USER32_CS,
 249                             __USER_DS, __USER_DS);
 250 }
 251 #endif
 252
 253 /*
 254  *      switch_to(x,y) should switch tasks from x to y.
 255  *
 256  * This could still be optimized:
 257  * - fold all the options into a flag word and test it with a single test.
 258  * - could test fs/gs bitsliced
 259  *
 260  * Kprobes not supported here. Set the probe on schedule instead.
 261  * Function graph tracer not supported too.
 262  */
 263 __visible __notrace_funcgraph struct task_struct *
 264 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 265 {
 266         struct thread_struct *prev = &prev_p->thread;
 267         struct thread_struct *next = &next_p->thread;
 268         struct fpu *prev_fpu = &prev->fpu;
 269         struct fpu *next_fpu = &next->fpu;
 270         int cpu = smp_processor_id();
 271         struct tss_struct *tss = &per_cpu(cpu_tss, cpu);
 272         unsigned prev_fsindex, prev_gsindex;
 273         fpu_switch_t fpu_switch;
 274
 275         fpu_switch = switch_fpu_prepare(prev_fpu, next_fpu, cpu);
 276
 277         /* We must save %fs and %gs before load_TLS() because
 278          * %fs and %gs may be cleared by load_TLS().
 279          *
 280          * (e.g. xen_load_tls())
 281          */
 282         savesegment(fs, prev_fsindex);
 283         savesegment(gs, prev_gsindex);
 284
 285         /*
 286          * Load TLS before restoring any segments so that segment loads
 287          * reference the correct GDT entries.
 288          */
 289         load_TLS(next, cpu);
 290
 291         /*
 292          * Leave lazy mode, flushing any hypercalls made here.  This
 293          * must be done after loading TLS entries in the GDT but before
 294          * loading segments that might reference them, and and it must
 295          * be done before fpu__restore(), so the TS bit is up to
 296          * date.
 297          */
 298         arch_end_context_switch(next_p);
 299
 300         /* Switch DS and ES.
 301          *
 302          * Reading them only returns the selectors, but writing them (if
 303          * nonzero) loads the full descriptor from the GDT or LDT.  The
 304          * LDT for next is loaded in switch_mm, and the GDT is loaded
 305          * above.
 306          *
 307          * We therefore need to write new values to the segment
 308          * registers on every context switch unless both the new and old
 309          * values are zero.
 310          *
 311          * Note that we don't need to do anything for CS and SS, as
 312          * those are saved and restored as part of pt_regs.
 313          */
 314         savesegment(es, prev->es);
 315         if (unlikely(next->es | prev->es))
 316                 loadsegment(es, next->es);
 317
 318         savesegment(ds, prev->ds);
 319         if (unlikely(next->ds | prev->ds))
 320                 loadsegment(ds, next->ds);
 321
 322         /*
 323          * Switch FS and GS.
 324          *
 325          * These are even more complicated than DS and ES: they have
 326          * 64-bit bases are that controlled by arch_prctl.  The bases
 327          * don't necessarily match the selectors, as user code can do
 328          * any number of things to cause them to be inconsistent.
 329          *
 330          * We don't promise to preserve the bases if the selectors are
 331          * nonzero.  We also don't promise to preserve the base if the
 332          * selector is zero and the base doesn't match whatever was
 333          * most recently passed to ARCH_SET_FS/GS.  (If/when the
 334          * FSGSBASE instructions are enabled, we'll need to offer
 335          * stronger guarantees.)
 336          *
 337          * As an invariant,
 338          * (fsbase != 0 && fsindex != 0) || (gsbase != 0 && gsindex != 0) is
 339          * impossible.
 340          */
 341         if (next->fsindex) {
 342                 /* Loading a nonzero value into FS sets the index and base. */
 343                 loadsegment(fs, next->fsindex);
 344         } else {
 345                 if (next->fsbase) {
 346                         /* Next index is zero but next base is nonzero. */
 347                         if (prev_fsindex)
 348                                 loadsegment(fs, 0);
 349                         wrmsrl(MSR_FS_BASE, next->fsbase);
 350                 } else {
 351                         /* Next base and index are both zero. */
 352                         if (static_cpu_has_bug(X86_BUG_NULL_SEG)) {
 353                                 /*
 354                                  * We don't know the previous base and can't
 355                                  * find out without RDMSR.  Forcibly clear it.
 356                                  */
 357                                 loadsegment(fs, __USER_DS);
 358                                 loadsegment(fs, 0);
 359                         } else {
 360                                 /*
 361                                  * If the previous index is zero and ARCH_SET_FS
 362                                  * didn't change the base, then the base is
 363                                  * also zero and we don't need to do anything.
 364                                  */
 365                                 if (prev->fsbase || prev_fsindex)
 366                                         loadsegment(fs, 0);
 367                         }
 368                 }
 369         }
 370         /*
 371          * Save the old state and preserve the invariant.
 372          * NB: if prev_fsindex == 0, then we can't reliably learn the base
 373          * without RDMSR because Intel user code can zero it without telling
 374          * us and AMD user code can program any 32-bit value without telling
 375          * us.
 376          */
 377         if (prev_fsindex)
 378                 prev->fsbase = 0;
 379         prev->fsindex = prev_fsindex;
 380
 381         if (next->gsindex) {
 382                 /* Loading a nonzero value into GS sets the index and base. */
 383                 load_gs_index(next->gsindex);
 384         } else {
 385                 if (next->gsbase) {
 386                         /* Next index is zero but next base is nonzero. */
 387                         if (prev_gsindex)
 388                                 load_gs_index(0);
 389                         wrmsrl(MSR_KERNEL_GS_BASE, next->gsbase);
 390                 } else {
 391                         /* Next base and index are both zero. */
 392                         if (static_cpu_has_bug(X86_BUG_NULL_SEG)) {
 393                                 /*
 394                                  * We don't know the previous base and can't
 395                                  * find out without RDMSR.  Forcibly clear it.
 396                                  *
 397                                  * This contains a pointless SWAPGS pair.
 398                                  * Fixing it would involve an explicit check
 399                                  * for Xen or a new pvop.
 400                                  */
 401                                 load_gs_index(__USER_DS);
 402                                 load_gs_index(0);
 403                         } else {
 404                                 /*
 405                                  * If the previous index is zero and ARCH_SET_GS
 406                                  * didn't change the base, then the base is
 407                                  * also zero and we don't need to do anything.
 408                                  */
 409                                 if (prev->gsbase || prev_gsindex)
 410                                         load_gs_index(0);
 411                         }
 412                 }
 413         }
 414         /*
 415          * Save the old state and preserve the invariant.
 416          * NB: if prev_gsindex == 0, then we can't reliably learn the base
 417          * without RDMSR because Intel user code can zero it without telling
 418          * us and AMD user code can program any 32-bit value without telling
 419          * us.
 420          */
 421         if (prev_gsindex)
 422                 prev->gsbase = 0;
 423         prev->gsindex = prev_gsindex;
 424
 425         switch_fpu_finish(next_fpu, fpu_switch);
 426
 427         /*
 428          * Switch the PDA and FPU contexts.
 429          */
 430         this_cpu_write(current_task, next_p);
 431
 432         /* Reload esp0 and ss1.  This changes current_thread_info(). */
 433         load_sp0(tss, next);
 434
 435         /*
 436          * Now maybe reload the debug registers and handle I/O bitmaps
 437          */
 438         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
 439                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
 440                 __switch_to_xtra(prev_p, next_p, tss);
 441
 442 #ifdef CONFIG_XEN
 443         /*
 444          * On Xen PV, IOPL bits in pt_regs->flags have no effect, and
 445          * current_pt_regs()->flags may not match the current task's
 446          * intended IOPL.  We need to switch it manually.
 447          */
 448         if (unlikely(static_cpu_has(X86_FEATURE_XENPV) &&
 449                      prev->iopl != next->iopl))
 450                 xen_set_iopl_mask(next->iopl);
 451 #endif
 452
 453         if (static_cpu_has_bug(X86_BUG_SYSRET_SS_ATTRS)) {
 454                 /*
 455                  * AMD CPUs have a misfeature: SYSRET sets the SS selector but
 456                  * does not update the cached descriptor.  As a result, if we
 457                  * do SYSRET while SS is NULL, we'll end up in user mode with
 458                  * SS apparently equal to __USER_DS but actually unusable.
 459                  *
 460                  * The straightforward workaround would be to fix it up just
 461                  * before SYSRET, but that would slow down the system call
 462                  * fast paths.  Instead, we ensure that SS is never NULL in
 463                  * system call context.  We do this by replacing NULL SS
 464                  * selectors at every context switch.  SYSCALL sets up a valid
 465                  * SS, so the only way to get NULL is to re-enter the kernel
 466                  * from CPL 3 through an interrupt.  Since that can't happen
 467                  * in the same task as a running syscall, we are guaranteed to
 468                  * context switch between every interrupt vector entry and a
 469                  * subsequent SYSRET.
 470                  *
 471                  * We read SS first because SS reads are much faster than
 472                  * writes.  Out of caution, we force SS to __KERNEL_DS even if
 473                  * it previously had a different non-NULL value.
 474                  */
 475                 unsigned short ss_sel;
 476                 savesegment(ss, ss_sel);
 477                 if (ss_sel != __KERNEL_DS)
 478                         loadsegment(ss, __KERNEL_DS);
 479         }
 480
 481         return prev_p;
 482 }
 483
 484 void set_personality_64bit(void)
 485 {
 486         /* inherit personality from parent */
 487
 488         /* Make sure to be in 64bit mode */
 489         clear_thread_flag(TIF_IA32);
 490         clear_thread_flag(TIF_ADDR32);
 491         clear_thread_flag(TIF_X32);
 492
 493         /* Ensure the corresponding mm is not marked. */
 494         if (current->mm)
 495                 current->mm->context.ia32_compat = 0;
 496
 497         /* TBD: overwrites user setup. Should have two bits.
 498            But 64bit processes have always behaved this way,
 499            so it's not too bad. The main problem is just that
 500            32bit childs are affected again. */
 501         current->personality &= ~READ_IMPLIES_EXEC;
 502 }
 503
 504 void set_personality_ia32(bool x32)
 505 {
 506         /* inherit personality from parent */
 507
 508         /* Make sure to be in 32bit mode */
 509         set_thread_flag(TIF_ADDR32);
 510
 511         /* Mark the associated mm as containing 32-bit tasks. */
 512         if (x32) {
 513                 clear_thread_flag(TIF_IA32);
 514                 set_thread_flag(TIF_X32);
 515                 if (current->mm)
 516                         current->mm->context.ia32_compat = TIF_X32;
 517                 current->personality &= ~READ_IMPLIES_EXEC;
 518                 /* in_compat_syscall() uses the presence of the x32
 519                    syscall bit flag to determine compat status */
 520                 current->thread.status &= ~TS_COMPAT;
 521         } else {
 522                 set_thread_flag(TIF_IA32);
 523                 clear_thread_flag(TIF_X32);
 524                 if (current->mm)
 525                         current->mm->context.ia32_compat = TIF_IA32;
 526                 current->personality |= force_personality32;
 527                 /* Prepare the first "return" to user space */
 528                 current->thread.status |= TS_COMPAT;
 529         }
 530 }
 531 EXPORT_SYMBOL_GPL(set_personality_ia32);
 532
 533 #ifdef CONFIG_CHECKPOINT_RESTORE
 534 static long prctl_map_vdso(const struct vdso_image *image, unsigned long addr)
 535 {
 536         int ret;
 537
 538         ret = map_vdso_once(image, addr);
 539         if (ret)
 540                 return ret;
 541
 542         return (long)image->size;
 543 }
 544 #endif
 545
 546 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 547 {
 548         int ret = 0;
 549         int doit = task == current;
 550         int cpu;
 551
 552         switch (code) {
 553         case ARCH_SET_GS:
 554                 if (addr >= TASK_SIZE_MAX)
 555                         return -EPERM;
 556                 cpu = get_cpu();
 557                 task->thread.gsindex = 0;
 558                 task->thread.gsbase = addr;
 559                 if (doit) {
 560                         load_gs_index(0);
 561                         ret = wrmsrl_safe(MSR_KERNEL_GS_BASE, addr);
 562                 }
 563                 put_cpu();
 564                 break;
 565         case ARCH_SET_FS:
 566                 /* Not strictly needed for fs, but do it for symmetry
 567                    with gs */
 568                 if (addr >= TASK_SIZE_MAX)
 569                         return -EPERM;
 570                 cpu = get_cpu();
 571                 task->thread.fsindex = 0;
 572                 task->thread.fsbase = addr;
 573                 if (doit) {
 574                         /* set the selector to 0 to not confuse __switch_to */
 575                         loadsegment(fs, 0);
 576                         ret = wrmsrl_safe(MSR_FS_BASE, addr);
 577                 }
 578                 put_cpu();
 579                 break;
 580         case ARCH_GET_FS: {
 581                 unsigned long base;
 582                 if (doit)
 583                         rdmsrl(MSR_FS_BASE, base);
 584                 else
 585                         base = task->thread.fsbase;
 586                 ret = put_user(base, (unsigned long __user *)addr);
 587                 break;
 588         }
 589         case ARCH_GET_GS: {
 590                 unsigned long base;
 591                 if (doit)
 592                         rdmsrl(MSR_KERNEL_GS_BASE, base);
 593                 else
 594                         base = task->thread.gsbase;
 595                 ret = put_user(base, (unsigned long __user *)addr);
 596                 break;
 597         }
 598
 599 #ifdef CONFIG_CHECKPOINT_RESTORE
 600 # ifdef CONFIG_X86_X32_ABI
 601         case ARCH_MAP_VDSO_X32:
 602                 return prctl_map_vdso(&vdso_image_x32, addr);
 603 # endif
 604 # if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
 605         case ARCH_MAP_VDSO_32:
 606                 return prctl_map_vdso(&vdso_image_32, addr);
 607 # endif
 608         case ARCH_MAP_VDSO_64:
 609                 return prctl_map_vdso(&vdso_image_64, addr);
 610 #endif
 611
 612         default:
 613                 ret = -EINVAL;
 614                 break;
 615         }
 616
 617         return ret;
 618 }
 619
 620 long sys_arch_prctl(int code, unsigned long addr)
 621 {
 622         return do_arch_prctl(current, code, addr);
 623 }
 624
 625 unsigned long KSTK_ESP(struct task_struct *task)
 626 {
 627         return task_pt_regs(task)->sp;
 628 }