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