GNU Linux-libre 4.14.266-gnu1
[releases.git] / arch / x86 / kernel / process_64.c
1 /*
2  *  Copyright (C) 1995  Linus Torvalds
3  *
4  *  Pentium III FXSR, SSE support
5  *      Gareth Hughes <gareth@valinux.com>, May 2000
6  *
7  *  X86-64 port
8  *      Andi Kleen.
9  *
10  *      CPU hotplug support - ashok.raj@intel.com
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/sched/task.h>
21 #include <linux/sched/task_stack.h>
22 #include <linux/fs.h>
23 #include <linux/kernel.h>
24 #include <linux/mm.h>
25 #include <linux/elfcore.h>
26 #include <linux/smp.h>
27 #include <linux/slab.h>
28 #include <linux/user.h>
29 #include <linux/interrupt.h>
30 #include <linux/delay.h>
31 #include <linux/export.h>
32 #include <linux/ptrace.h>
33 #include <linux/notifier.h>
34 #include <linux/kprobes.h>
35 #include <linux/kdebug.h>
36 #include <linux/prctl.h>
37 #include <linux/uaccess.h>
38 #include <linux/io.h>
39 #include <linux/ftrace.h>
40 #include <linux/syscalls.h>
41
42 #include <asm/pgtable.h>
43 #include <asm/processor.h>
44 #include <asm/fpu/internal.h>
45 #include <asm/mmu_context.h>
46 #include <asm/prctl.h>
47 #include <asm/desc.h>
48 #include <asm/proto.h>
49 #include <asm/ia32.h>
50 #include <asm/syscalls.h>
51 #include <asm/debugreg.h>
52 #include <asm/switch_to.h>
53 #include <asm/xen/hypervisor.h>
54 #include <asm/vdso.h>
55 #include <asm/intel_rdt_sched.h>
56 #include <asm/unistd.h>
57 #ifdef CONFIG_IA32_EMULATION
58 /* Not included via unistd.h */
59 #include <asm/unistd_32_ia32.h>
60 #endif
61
62 #include "process.h"
63
64 __visible DEFINE_PER_CPU(unsigned long, rsp_scratch);
65
66 /* Prints also some state that isn't saved in the pt_regs */
67 void __show_regs(struct pt_regs *regs, int all)
68 {
69         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
70         unsigned long d0, d1, d2, d3, d6, d7;
71         unsigned int fsindex, gsindex;
72         unsigned int ds, cs, es;
73
74         show_iret_regs(regs);
75
76         if (regs->orig_ax != -1)
77                 pr_cont(" ORIG_RAX: %016lx\n", regs->orig_ax);
78         else
79                 pr_cont("\n");
80
81         printk(KERN_DEFAULT "RAX: %016lx RBX: %016lx RCX: %016lx\n",
82                regs->ax, regs->bx, regs->cx);
83         printk(KERN_DEFAULT "RDX: %016lx RSI: %016lx RDI: %016lx\n",
84                regs->dx, regs->si, regs->di);
85         printk(KERN_DEFAULT "RBP: %016lx R08: %016lx R09: %016lx\n",
86                regs->bp, regs->r8, regs->r9);
87         printk(KERN_DEFAULT "R10: %016lx R11: %016lx R12: %016lx\n",
88                regs->r10, regs->r11, regs->r12);
89         printk(KERN_DEFAULT "R13: %016lx R14: %016lx R15: %016lx\n",
90                regs->r13, regs->r14, regs->r15);
91
92         if (!all)
93                 return;
94
95         asm("movl %%ds,%0" : "=r" (ds));
96         asm("movl %%cs,%0" : "=r" (cs));
97         asm("movl %%es,%0" : "=r" (es));
98         asm("movl %%fs,%0" : "=r" (fsindex));
99         asm("movl %%gs,%0" : "=r" (gsindex));
100
101         rdmsrl(MSR_FS_BASE, fs);
102         rdmsrl(MSR_GS_BASE, gs);
103         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
104
105         cr0 = read_cr0();
106         cr2 = read_cr2();
107         cr3 = __read_cr3();
108         cr4 = __read_cr4();
109
110         printk(KERN_DEFAULT "FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
111                fs, fsindex, gs, gsindex, shadowgs);
112         printk(KERN_DEFAULT "CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds,
113                         es, cr0);
114         printk(KERN_DEFAULT "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
115                         cr4);
116
117         get_debugreg(d0, 0);
118         get_debugreg(d1, 1);
119         get_debugreg(d2, 2);
120         get_debugreg(d3, 3);
121         get_debugreg(d6, 6);
122         get_debugreg(d7, 7);
123
124         /* Only print out debug registers if they are in their non-default state. */
125         if (!((d0 == 0) && (d1 == 0) && (d2 == 0) && (d3 == 0) &&
126             (d6 == DR6_RESERVED) && (d7 == 0x400))) {
127                 printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n",
128                        d0, d1, d2);
129                 printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n",
130                        d3, d6, d7);
131         }
132
133         if (boot_cpu_has(X86_FEATURE_OSPKE))
134                 printk(KERN_DEFAULT "PKRU: %08x\n", read_pkru());
135 }
136
137 void release_thread(struct task_struct *dead_task)
138 {
139         if (dead_task->mm) {
140 #ifdef CONFIG_MODIFY_LDT_SYSCALL
141                 if (dead_task->mm->context.ldt) {
142                         pr_warn("WARNING: dead process %s still has LDT? <%p/%d>\n",
143                                 dead_task->comm,
144                                 dead_task->mm->context.ldt->entries,
145                                 dead_task->mm->context.ldt->nr_entries);
146                         BUG();
147                 }
148 #endif
149         }
150 }
151
152 enum which_selector {
153         FS,
154         GS
155 };
156
157 /*
158  * Saves the FS or GS base for an outgoing thread if FSGSBASE extensions are
159  * not available.  The goal is to be reasonably fast on non-FSGSBASE systems.
160  * It's forcibly inlined because it'll generate better code and this function
161  * is hot.
162  */
163 static __always_inline void save_base_legacy(struct task_struct *prev_p,
164                                              unsigned short selector,
165                                              enum which_selector which)
166 {
167         if (likely(selector == 0)) {
168                 /*
169                  * On Intel (without X86_BUG_NULL_SEG), the segment base could
170                  * be the pre-existing saved base or it could be zero.  On AMD
171                  * (with X86_BUG_NULL_SEG), the segment base could be almost
172                  * anything.
173                  *
174                  * This branch is very hot (it's hit twice on almost every
175                  * context switch between 64-bit programs), and avoiding
176                  * the RDMSR helps a lot, so we just assume that whatever
177                  * value is already saved is correct.  This matches historical
178                  * Linux behavior, so it won't break existing applications.
179                  *
180                  * To avoid leaking state, on non-X86_BUG_NULL_SEG CPUs, if we
181                  * report that the base is zero, it needs to actually be zero:
182                  * see the corresponding logic in load_seg_legacy.
183                  */
184         } else {
185                 /*
186                  * If the selector is 1, 2, or 3, then the base is zero on
187                  * !X86_BUG_NULL_SEG CPUs and could be anything on
188                  * X86_BUG_NULL_SEG CPUs.  In the latter case, Linux
189                  * has never attempted to preserve the base across context
190                  * switches.
191                  *
192                  * If selector > 3, then it refers to a real segment, and
193                  * saving the base isn't necessary.
194                  */
195                 if (which == FS)
196                         prev_p->thread.fsbase = 0;
197                 else
198                         prev_p->thread.gsbase = 0;
199         }
200 }
201
202 static __always_inline void save_fsgs(struct task_struct *task)
203 {
204         savesegment(fs, task->thread.fsindex);
205         savesegment(gs, task->thread.gsindex);
206         save_base_legacy(task, task->thread.fsindex, FS);
207         save_base_legacy(task, task->thread.gsindex, GS);
208 }
209
210 static __always_inline void loadseg(enum which_selector which,
211                                     unsigned short sel)
212 {
213         if (which == FS)
214                 loadsegment(fs, sel);
215         else
216                 load_gs_index(sel);
217 }
218
219 static __always_inline void load_seg_legacy(unsigned short prev_index,
220                                             unsigned long prev_base,
221                                             unsigned short next_index,
222                                             unsigned long next_base,
223                                             enum which_selector which)
224 {
225         if (likely(next_index <= 3)) {
226                 /*
227                  * The next task is using 64-bit TLS, is not using this
228                  * segment at all, or is having fun with arcane CPU features.
229                  */
230                 if (next_base == 0) {
231                         /*
232                          * Nasty case: on AMD CPUs, we need to forcibly zero
233                          * the base.
234                          */
235                         if (static_cpu_has_bug(X86_BUG_NULL_SEG)) {
236                                 loadseg(which, __USER_DS);
237                                 loadseg(which, next_index);
238                         } else {
239                                 /*
240                                  * We could try to exhaustively detect cases
241                                  * under which we can skip the segment load,
242                                  * but there's really only one case that matters
243                                  * for performance: if both the previous and
244                                  * next states are fully zeroed, we can skip
245                                  * the load.
246                                  *
247                                  * (This assumes that prev_base == 0 has no
248                                  * false positives.  This is the case on
249                                  * Intel-style CPUs.)
250                                  */
251                                 if (likely(prev_index | next_index | prev_base))
252                                         loadseg(which, next_index);
253                         }
254                 } else {
255                         if (prev_index != next_index)
256                                 loadseg(which, next_index);
257                         wrmsrl(which == FS ? MSR_FS_BASE : MSR_KERNEL_GS_BASE,
258                                next_base);
259                 }
260         } else {
261                 /*
262                  * The next task is using a real segment.  Loading the selector
263                  * is sufficient.
264                  */
265                 loadseg(which, next_index);
266         }
267 }
268
269 int copy_thread_tls(unsigned long clone_flags, unsigned long sp,
270                 unsigned long arg, struct task_struct *p, unsigned long tls)
271 {
272         int err;
273         struct pt_regs *childregs;
274         struct fork_frame *fork_frame;
275         struct inactive_task_frame *frame;
276         struct task_struct *me = current;
277
278         childregs = task_pt_regs(p);
279         fork_frame = container_of(childregs, struct fork_frame, regs);
280         frame = &fork_frame->frame;
281
282         /*
283          * For a new task use the RESET flags value since there is no before.
284          * All the status flags are zero; DF and all the system flags must also
285          * be 0, specifically IF must be 0 because we context switch to the new
286          * task with interrupts disabled.
287          */
288         frame->flags = X86_EFLAGS_FIXED;
289         frame->bp = 0;
290         frame->ret_addr = (unsigned long) ret_from_fork;
291         p->thread.sp = (unsigned long) fork_frame;
292         p->thread.io_bitmap_ptr = NULL;
293
294         savesegment(gs, p->thread.gsindex);
295         p->thread.gsbase = p->thread.gsindex ? 0 : me->thread.gsbase;
296         savesegment(fs, p->thread.fsindex);
297         p->thread.fsbase = p->thread.fsindex ? 0 : me->thread.fsbase;
298         savesegment(es, p->thread.es);
299         savesegment(ds, p->thread.ds);
300         memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
301
302         if (unlikely(p->flags & PF_KTHREAD)) {
303                 /* kernel thread */
304                 memset(childregs, 0, sizeof(struct pt_regs));
305                 frame->bx = sp;         /* function */
306                 frame->r12 = arg;
307                 return 0;
308         }
309         frame->bx = 0;
310         *childregs = *current_pt_regs();
311
312         childregs->ax = 0;
313         if (sp)
314                 childregs->sp = sp;
315
316         err = -ENOMEM;
317         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
318                 p->thread.io_bitmap_ptr = kmemdup(me->thread.io_bitmap_ptr,
319                                                   IO_BITMAP_BYTES, GFP_KERNEL);
320                 if (!p->thread.io_bitmap_ptr) {
321                         p->thread.io_bitmap_max = 0;
322                         return -ENOMEM;
323                 }
324                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
325         }
326
327         /*
328          * Set a new TLS for the child thread?
329          */
330         if (clone_flags & CLONE_SETTLS) {
331 #ifdef CONFIG_IA32_EMULATION
332                 if (in_ia32_syscall())
333                         err = do_set_thread_area(p, -1,
334                                 (struct user_desc __user *)tls, 0);
335                 else
336 #endif
337                         err = do_arch_prctl_64(p, ARCH_SET_FS, tls);
338                 if (err)
339                         goto out;
340         }
341         err = 0;
342 out:
343         if (err && p->thread.io_bitmap_ptr) {
344                 kfree(p->thread.io_bitmap_ptr);
345                 p->thread.io_bitmap_max = 0;
346         }
347
348         return err;
349 }
350
351 static void
352 start_thread_common(struct pt_regs *regs, unsigned long new_ip,
353                     unsigned long new_sp,
354                     unsigned int _cs, unsigned int _ss, unsigned int _ds)
355 {
356         WARN_ON_ONCE(regs != current_pt_regs());
357
358         if (static_cpu_has(X86_BUG_NULL_SEG)) {
359                 /* Loading zero below won't clear the base. */
360                 loadsegment(fs, __USER_DS);
361                 load_gs_index(__USER_DS);
362         }
363
364         loadsegment(fs, 0);
365         loadsegment(es, _ds);
366         loadsegment(ds, _ds);
367         load_gs_index(0);
368
369         regs->ip                = new_ip;
370         regs->sp                = new_sp;
371         regs->cs                = _cs;
372         regs->ss                = _ss;
373         regs->flags             = X86_EFLAGS_IF;
374         force_iret();
375 }
376
377 void
378 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
379 {
380         start_thread_common(regs, new_ip, new_sp,
381                             __USER_CS, __USER_DS, 0);
382 }
383 EXPORT_SYMBOL_GPL(start_thread);
384
385 #ifdef CONFIG_COMPAT
386 void compat_start_thread(struct pt_regs *regs, u32 new_ip, u32 new_sp)
387 {
388         start_thread_common(regs, new_ip, new_sp,
389                             test_thread_flag(TIF_X32)
390                             ? __USER_CS : __USER32_CS,
391                             __USER_DS, __USER_DS);
392 }
393 #endif
394
395 /*
396  *      switch_to(x,y) should switch tasks from x to y.
397  *
398  * This could still be optimized:
399  * - fold all the options into a flag word and test it with a single test.
400  * - could test fs/gs bitsliced
401  *
402  * Kprobes not supported here. Set the probe on schedule instead.
403  * Function graph tracer not supported too.
404  */
405 __visible __notrace_funcgraph struct task_struct *
406 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
407 {
408         struct thread_struct *prev = &prev_p->thread;
409         struct thread_struct *next = &next_p->thread;
410         struct fpu *prev_fpu = &prev->fpu;
411         struct fpu *next_fpu = &next->fpu;
412         int cpu = smp_processor_id();
413
414         WARN_ON_ONCE(IS_ENABLED(CONFIG_DEBUG_ENTRY) &&
415                      this_cpu_read(irq_count) != -1);
416
417         switch_fpu_prepare(prev_fpu, cpu);
418
419         /* We must save %fs and %gs before load_TLS() because
420          * %fs and %gs may be cleared by load_TLS().
421          *
422          * (e.g. xen_load_tls())
423          */
424         save_fsgs(prev_p);
425
426         /*
427          * Load TLS before restoring any segments so that segment loads
428          * reference the correct GDT entries.
429          */
430         load_TLS(next, cpu);
431
432         /*
433          * Leave lazy mode, flushing any hypercalls made here.  This
434          * must be done after loading TLS entries in the GDT but before
435          * loading segments that might reference them, and and it must
436          * be done before fpu__restore(), so the TS bit is up to
437          * date.
438          */
439         arch_end_context_switch(next_p);
440
441         /* Switch DS and ES.
442          *
443          * Reading them only returns the selectors, but writing them (if
444          * nonzero) loads the full descriptor from the GDT or LDT.  The
445          * LDT for next is loaded in switch_mm, and the GDT is loaded
446          * above.
447          *
448          * We therefore need to write new values to the segment
449          * registers on every context switch unless both the new and old
450          * values are zero.
451          *
452          * Note that we don't need to do anything for CS and SS, as
453          * those are saved and restored as part of pt_regs.
454          */
455         savesegment(es, prev->es);
456         if (unlikely(next->es | prev->es))
457                 loadsegment(es, next->es);
458
459         savesegment(ds, prev->ds);
460         if (unlikely(next->ds | prev->ds))
461                 loadsegment(ds, next->ds);
462
463         load_seg_legacy(prev->fsindex, prev->fsbase,
464                         next->fsindex, next->fsbase, FS);
465         load_seg_legacy(prev->gsindex, prev->gsbase,
466                         next->gsindex, next->gsbase, GS);
467
468         switch_fpu_finish(next_fpu, cpu);
469
470         /*
471          * Switch the PDA and FPU contexts.
472          */
473         this_cpu_write(current_task, next_p);
474         this_cpu_write(cpu_current_top_of_stack, task_top_of_stack(next_p));
475
476         /* Reload sp0. */
477         update_sp0(next_p);
478
479         __switch_to_xtra(prev_p, next_p);
480
481 #ifdef CONFIG_XEN_PV
482         /*
483          * On Xen PV, IOPL bits in pt_regs->flags have no effect, and
484          * current_pt_regs()->flags may not match the current task's
485          * intended IOPL.  We need to switch it manually.
486          */
487         if (unlikely(static_cpu_has(X86_FEATURE_XENPV) &&
488                      prev->iopl != next->iopl))
489                 xen_set_iopl_mask(next->iopl);
490 #endif
491
492         if (static_cpu_has_bug(X86_BUG_SYSRET_SS_ATTRS)) {
493                 /*
494                  * AMD CPUs have a misfeature: SYSRET sets the SS selector but
495                  * does not update the cached descriptor.  As a result, if we
496                  * do SYSRET while SS is NULL, we'll end up in user mode with
497                  * SS apparently equal to __USER_DS but actually unusable.
498                  *
499                  * The straightforward workaround would be to fix it up just
500                  * before SYSRET, but that would slow down the system call
501                  * fast paths.  Instead, we ensure that SS is never NULL in
502                  * system call context.  We do this by replacing NULL SS
503                  * selectors at every context switch.  SYSCALL sets up a valid
504                  * SS, so the only way to get NULL is to re-enter the kernel
505                  * from CPL 3 through an interrupt.  Since that can't happen
506                  * in the same task as a running syscall, we are guaranteed to
507                  * context switch between every interrupt vector entry and a
508                  * subsequent SYSRET.
509                  *
510                  * We read SS first because SS reads are much faster than
511                  * writes.  Out of caution, we force SS to __KERNEL_DS even if
512                  * it previously had a different non-NULL value.
513                  */
514                 unsigned short ss_sel;
515                 savesegment(ss, ss_sel);
516                 if (ss_sel != __KERNEL_DS)
517                         loadsegment(ss, __KERNEL_DS);
518         }
519
520         /* Load the Intel cache allocation PQR MSR. */
521         intel_rdt_sched_in();
522
523         return prev_p;
524 }
525
526 void set_personality_64bit(void)
527 {
528         /* inherit personality from parent */
529
530         /* Make sure to be in 64bit mode */
531         clear_thread_flag(TIF_IA32);
532         clear_thread_flag(TIF_ADDR32);
533         clear_thread_flag(TIF_X32);
534         /* Pretend that this comes from a 64bit execve */
535         task_pt_regs(current)->orig_ax = __NR_execve;
536         current_thread_info()->status &= ~TS_COMPAT;
537
538         /* Ensure the corresponding mm is not marked. */
539         if (current->mm)
540                 current->mm->context.ia32_compat = 0;
541
542         /* TBD: overwrites user setup. Should have two bits.
543            But 64bit processes have always behaved this way,
544            so it's not too bad. The main problem is just that
545            32bit childs are affected again. */
546         current->personality &= ~READ_IMPLIES_EXEC;
547 }
548
549 static void __set_personality_x32(void)
550 {
551 #ifdef CONFIG_X86_X32
552         clear_thread_flag(TIF_IA32);
553         set_thread_flag(TIF_X32);
554         if (current->mm)
555                 current->mm->context.ia32_compat = TIF_X32;
556         current->personality &= ~READ_IMPLIES_EXEC;
557         /*
558          * in_compat_syscall() uses the presence of the x32 syscall bit
559          * flag to determine compat status.  The x86 mmap() code relies on
560          * the syscall bitness so set x32 syscall bit right here to make
561          * in_compat_syscall() work during exec().
562          *
563          * Pretend to come from a x32 execve.
564          */
565         task_pt_regs(current)->orig_ax = __NR_x32_execve | __X32_SYSCALL_BIT;
566         current_thread_info()->status &= ~TS_COMPAT;
567 #endif
568 }
569
570 static void __set_personality_ia32(void)
571 {
572 #ifdef CONFIG_IA32_EMULATION
573         set_thread_flag(TIF_IA32);
574         clear_thread_flag(TIF_X32);
575         if (current->mm)
576                 current->mm->context.ia32_compat = TIF_IA32;
577         current->personality |= force_personality32;
578         /* Prepare the first "return" to user space */
579         task_pt_regs(current)->orig_ax = __NR_ia32_execve;
580         current_thread_info()->status |= TS_COMPAT;
581 #endif
582 }
583
584 void set_personality_ia32(bool x32)
585 {
586         /* Make sure to be in 32bit mode */
587         set_thread_flag(TIF_ADDR32);
588
589         if (x32)
590                 __set_personality_x32();
591         else
592                 __set_personality_ia32();
593 }
594 EXPORT_SYMBOL_GPL(set_personality_ia32);
595
596 #ifdef CONFIG_CHECKPOINT_RESTORE
597 static long prctl_map_vdso(const struct vdso_image *image, unsigned long addr)
598 {
599         int ret;
600
601         ret = map_vdso_once(image, addr);
602         if (ret)
603                 return ret;
604
605         return (long)image->size;
606 }
607 #endif
608
609 long do_arch_prctl_64(struct task_struct *task, int option, unsigned long arg2)
610 {
611         int ret = 0;
612         int doit = task == current;
613         int cpu;
614
615         switch (option) {
616         case ARCH_SET_GS:
617                 if (arg2 >= TASK_SIZE_MAX)
618                         return -EPERM;
619                 cpu = get_cpu();
620                 task->thread.gsindex = 0;
621                 task->thread.gsbase = arg2;
622                 if (doit) {
623                         load_gs_index(0);
624                         ret = wrmsrl_safe(MSR_KERNEL_GS_BASE, arg2);
625                 }
626                 put_cpu();
627                 break;
628         case ARCH_SET_FS:
629                 /* Not strictly needed for fs, but do it for symmetry
630                    with gs */
631                 if (arg2 >= TASK_SIZE_MAX)
632                         return -EPERM;
633                 cpu = get_cpu();
634                 task->thread.fsindex = 0;
635                 task->thread.fsbase = arg2;
636                 if (doit) {
637                         /* set the selector to 0 to not confuse __switch_to */
638                         loadsegment(fs, 0);
639                         ret = wrmsrl_safe(MSR_FS_BASE, arg2);
640                 }
641                 put_cpu();
642                 break;
643         case ARCH_GET_FS: {
644                 unsigned long base;
645
646                 if (doit)
647                         rdmsrl(MSR_FS_BASE, base);
648                 else
649                         base = task->thread.fsbase;
650                 ret = put_user(base, (unsigned long __user *)arg2);
651                 break;
652         }
653         case ARCH_GET_GS: {
654                 unsigned long base;
655
656                 if (doit)
657                         rdmsrl(MSR_KERNEL_GS_BASE, base);
658                 else
659                         base = task->thread.gsbase;
660                 ret = put_user(base, (unsigned long __user *)arg2);
661                 break;
662         }
663
664 #ifdef CONFIG_CHECKPOINT_RESTORE
665 # ifdef CONFIG_X86_X32_ABI
666         case ARCH_MAP_VDSO_X32:
667                 return prctl_map_vdso(&vdso_image_x32, arg2);
668 # endif
669 # if defined CONFIG_X86_32 || defined CONFIG_IA32_EMULATION
670         case ARCH_MAP_VDSO_32:
671                 return prctl_map_vdso(&vdso_image_32, arg2);
672 # endif
673         case ARCH_MAP_VDSO_64:
674                 return prctl_map_vdso(&vdso_image_64, arg2);
675 #endif
676
677         default:
678                 ret = -EINVAL;
679                 break;
680         }
681
682         return ret;
683 }
684
685 SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2)
686 {
687         long ret;
688
689         ret = do_arch_prctl_64(current, option, arg2);
690         if (ret == -EINVAL)
691                 ret = do_arch_prctl_common(current, option, arg2);
692
693         return ret;
694 }
695
696 #ifdef CONFIG_IA32_EMULATION
697 COMPAT_SYSCALL_DEFINE2(arch_prctl, int, option, unsigned long, arg2)
698 {
699         return do_arch_prctl_common(current, option, arg2);
700 }
701 #endif
702
703 unsigned long KSTK_ESP(struct task_struct *task)
704 {
705         return task_pt_regs(task)->sp;
706 }