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/stackprotector.h>
  18 #include <linux/cpu.h>
  19 #include <linux/errno.h>
  20 #include <linux/sched.h>
  21 #include <linux/fs.h>
  22 #include <linux/kernel.h>
  23 #include <linux/mm.h>
  24 #include <linux/elfcore.h>
  25 #include <linux/smp.h>
  26 #include <linux/slab.h>
  27 #include <linux/user.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/delay.h>
  30 #include <linux/module.h>
  31 #include <linux/ptrace.h>
  32 #include <linux/notifier.h>
  33 #include <linux/kprobes.h>
  34 #include <linux/kdebug.h>
  35 #include <linux/tick.h>
  36 #include <linux/prctl.h>
  37 #include <linux/uaccess.h>
  38 #include <linux/io.h>
  39 #include <linux/ftrace.h>
  40 #include <linux/cpuidle.h>
  41
  42 #include <asm/pgtable.h>
  43 #include <asm/system.h>
  44 #include <asm/processor.h>
  45 #include <asm/i387.h>
  46 #include <asm/mmu_context.h>
  47 #include <asm/prctl.h>
  48 #include <asm/desc.h>
  49 #include <asm/proto.h>
  50 #include <asm/ia32.h>
  51 #include <asm/idle.h>
  52 #include <asm/syscalls.h>
  53 #include <asm/debugreg.h>
  54 #include <asm/nmi.h>
  55
  56 asmlinkage extern void ret_from_fork(void);
  57
  58 DEFINE_PER_CPU(unsigned long, old_rsp);
  59 static DEFINE_PER_CPU(unsigned char, is_idle);
  60
  61 static ATOMIC_NOTIFIER_HEAD(idle_notifier);
  62
  63 void idle_notifier_register(struct notifier_block *n)
  64 {
  65         atomic_notifier_chain_register(&idle_notifier, n);
  66 }
  67 EXPORT_SYMBOL_GPL(idle_notifier_register);
  68
  69 void idle_notifier_unregister(struct notifier_block *n)
  70 {
  71         atomic_notifier_chain_unregister(&idle_notifier, n);
  72 }
  73 EXPORT_SYMBOL_GPL(idle_notifier_unregister);
  74
  75 void enter_idle(void)
  76 {
  77         percpu_write(is_idle, 1);
  78         atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
  79 }
  80
  81 static void __exit_idle(void)
  82 {
  83         if (x86_test_and_clear_bit_percpu(0, is_idle) == 0)
  84                 return;
  85         atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
  86 }
  87
  88 /* Called from interrupts to signify idle end */
  89 void exit_idle(void)
  90 {
  91         /* idle loop has pid 0 */
  92         if (current->pid)
  93                 return;
  94         __exit_idle();
  95 }
  96
  97 #ifndef CONFIG_SMP
  98 static inline void play_dead(void)
  99 {
 100         BUG();
 101 }
 102 #endif
 103
 104 /*
 105  * The idle thread. There's no useful work to be
 106  * done, so just try to conserve power and have a
 107  * low exit latency (ie sit in a loop waiting for
 108  * somebody to say that they'd like to reschedule)
 109  */
 110 void cpu_idle(void)
 111 {
 112         current_thread_info()->status |= TS_POLLING;
 113
 114         /*
 115          * If we're the non-boot CPU, nothing set the stack canary up
 116          * for us.  CPU0 already has it initialized but no harm in
 117          * doing it again.  This is a good place for updating it, as
 118          * we wont ever return from this function (so the invalid
 119          * canaries already on the stack wont ever trigger).
 120          */
 121         boot_init_stack_canary();
 122
 123         /* endless idle loop with no priority at all */
 124         while (1) {
 125                 tick_nohz_stop_sched_tick(1);
 126                 while (!need_resched()) {
 127
 128                         rmb();
 129
 130                         if (cpu_is_offline(smp_processor_id()))
 131                                 play_dead();
 132                         /*
 133                          * Idle routines should keep interrupts disabled
 134                          * from here on, until they go to idle.
 135                          * Otherwise, idle callbacks can misfire.
 136                          */
 137                         local_touch_nmi();
 138                         local_irq_disable();
 139                         enter_idle();
 140                         /* Don't trace irqs off for idle */
 141                         stop_critical_timings();
 142                         if (cpuidle_idle_call())
 143                                 pm_idle();
 144                         start_critical_timings();
 145
 146                         /* In many cases the interrupt that ended idle
 147                            has already called exit_idle. But some idle
 148                            loops can be woken up without interrupt. */
 149                         __exit_idle();
 150                 }
 151
 152                 tick_nohz_restart_sched_tick();
 153                 preempt_enable_no_resched();
 154                 schedule();
 155                 preempt_disable();
 156         }
 157 }
 158
 159 /* Prints also some state that isn't saved in the pt_regs */
 160 void __show_regs(struct pt_regs *regs, int all)
 161 {
 162         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
 163         unsigned long d0, d1, d2, d3, d6, d7;
 164         unsigned int fsindex, gsindex;
 165         unsigned int ds, cs, es;
 166
 167         show_regs_common();
 168         printk(KERN_DEFAULT "RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->ip);
 169         printk_address(regs->ip, 1);
 170         printk(KERN_DEFAULT "RSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss,
 171                         regs->sp, regs->flags);
 172         printk(KERN_DEFAULT "RAX: %016lx RBX: %016lx RCX: %016lx\n",
 173                regs->ax, regs->bx, regs->cx);
 174         printk(KERN_DEFAULT "RDX: %016lx RSI: %016lx RDI: %016lx\n",
 175                regs->dx, regs->si, regs->di);
 176         printk(KERN_DEFAULT "RBP: %016lx R08: %016lx R09: %016lx\n",
 177                regs->bp, regs->r8, regs->r9);
 178         printk(KERN_DEFAULT "R10: %016lx R11: %016lx R12: %016lx\n",
 179                regs->r10, regs->r11, regs->r12);
 180         printk(KERN_DEFAULT "R13: %016lx R14: %016lx R15: %016lx\n",
 181                regs->r13, regs->r14, regs->r15);
 182
 183         asm("movl %%ds,%0" : "=r" (ds));
 184         asm("movl %%cs,%0" : "=r" (cs));
 185         asm("movl %%es,%0" : "=r" (es));
 186         asm("movl %%fs,%0" : "=r" (fsindex));
 187         asm("movl %%gs,%0" : "=r" (gsindex));
 188
 189         rdmsrl(MSR_FS_BASE, fs);
 190         rdmsrl(MSR_GS_BASE, gs);
 191         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
 192
 193         if (!all)
 194                 return;
 195
 196         cr0 = read_cr0();
 197         cr2 = read_cr2();
 198         cr3 = read_cr3();
 199         cr4 = read_cr4();
 200
 201         printk(KERN_DEFAULT "FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
 202                fs, fsindex, gs, gsindex, shadowgs);
 203         printk(KERN_DEFAULT "CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds,
 204                         es, cr0);
 205         printk(KERN_DEFAULT "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
 206                         cr4);
 207
 208         get_debugreg(d0, 0);
 209         get_debugreg(d1, 1);
 210         get_debugreg(d2, 2);
 211         printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2);
 212         get_debugreg(d3, 3);
 213         get_debugreg(d6, 6);
 214         get_debugreg(d7, 7);
 215         printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7);
 216 }
 217
 218 void release_thread(struct task_struct *dead_task)
 219 {
 220         if (dead_task->mm) {
 221                 if (dead_task->mm->context.ldt) {
 222                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
 223                                         dead_task->comm,
 224                                         dead_task->mm->context.ldt,
 225                                         dead_task->mm->context.ldt->size);
 226                         BUG();
 227                 }
 228         }
 229 }
 230
 231 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
 232 {
 233         struct user_desc ud = {
 234                 .base_addr = addr,
 235                 .limit = 0xfffff,
 236                 .seg_32bit = 1,
 237                 .limit_in_pages = 1,
 238                 .useable = 1,
 239         };
 240         struct desc_struct *desc = t->thread.tls_array;
 241         desc += tls;
 242         fill_ldt(desc, &ud);
 243 }
 244
 245 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
 246 {
 247         return get_desc_base(&t->thread.tls_array[tls]);
 248 }
 249
 250 /*
 251  * This gets called before we allocate a new thread and copy
 252  * the current task into it.
 253  */
 254 void prepare_to_copy(struct task_struct *tsk)
 255 {
 256         unlazy_fpu(tsk);
 257 }
 258
 259 int copy_thread(unsigned long clone_flags, unsigned long sp,
 260                 unsigned long unused,
 261         struct task_struct *p, struct pt_regs *regs)
 262 {
 263         int err;
 264         struct pt_regs *childregs;
 265         struct task_struct *me = current;
 266
 267         childregs = ((struct pt_regs *)
 268                         (THREAD_SIZE + task_stack_page(p))) - 1;
 269         *childregs = *regs;
 270
 271         childregs->ax = 0;
 272         if (user_mode(regs))
 273                 childregs->sp = sp;
 274         else
 275                 childregs->sp = (unsigned long)childregs;
 276
 277         p->thread.sp = (unsigned long) childregs;
 278         p->thread.sp0 = (unsigned long) (childregs+1);
 279         p->thread.usersp = me->thread.usersp;
 280
 281         set_tsk_thread_flag(p, TIF_FORK);
 282
 283         p->thread.io_bitmap_ptr = NULL;
 284
 285         savesegment(gs, p->thread.gsindex);
 286         p->thread.gs = p->thread.gsindex ? 0 : me->thread.gs;
 287         savesegment(fs, p->thread.fsindex);
 288         p->thread.fs = p->thread.fsindex ? 0 : me->thread.fs;
 289         savesegment(es, p->thread.es);
 290         savesegment(ds, p->thread.ds);
 291
 292         err = -ENOMEM;
 293         memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
 294
 295         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
 296                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
 297                 if (!p->thread.io_bitmap_ptr) {
 298                         p->thread.io_bitmap_max = 0;
 299                         return -ENOMEM;
 300                 }
 301                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr,
 302                                 IO_BITMAP_BYTES);
 303                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
 304         }
 305
 306         /*
 307          * Set a new TLS for the child thread?
 308          */
 309         if (clone_flags & CLONE_SETTLS) {
 310 #ifdef CONFIG_IA32_EMULATION
 311                 if (test_thread_flag(TIF_IA32))
 312                         err = do_set_thread_area(p, -1,
 313                                 (struct user_desc __user *)childregs->si, 0);
 314                 else
 315 #endif
 316                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
 317                 if (err)
 318                         goto out;
 319         }
 320         err = 0;
 321 out:
 322         if (err && p->thread.io_bitmap_ptr) {
 323                 kfree(p->thread.io_bitmap_ptr);
 324                 p->thread.io_bitmap_max = 0;
 325         }
 326
 327         return err;
 328 }
 329
 330 static void
 331 start_thread_common(struct pt_regs *regs, unsigned long new_ip,
 332                     unsigned long new_sp,
 333                     unsigned int _cs, unsigned int _ss, unsigned int _ds)
 334 {
 335         loadsegment(fs, 0);
 336         loadsegment(es, _ds);
 337         loadsegment(ds, _ds);
 338         load_gs_index(0);
 339         regs->ip                = new_ip;
 340         regs->sp                = new_sp;
 341         percpu_write(old_rsp, new_sp);
 342         regs->cs                = _cs;
 343         regs->ss                = _ss;
 344         regs->flags             = X86_EFLAGS_IF;
 345         /*
 346          * Free the old FP and other extended state
 347          */
 348         free_thread_xstate(current);
 349 }
 350
 351 void
 352 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
 353 {
 354         start_thread_common(regs, new_ip, new_sp,
 355                             __USER_CS, __USER_DS, 0);
 356 }
 357
 358 #ifdef CONFIG_IA32_EMULATION
 359 void start_thread_ia32(struct pt_regs *regs, u32 new_ip, u32 new_sp)
 360 {
 361         start_thread_common(regs, new_ip, new_sp,
 362                             __USER32_CS, __USER32_DS, __USER32_DS);
 363 }
 364 #endif
 365
 366 /*
 367  *      switch_to(x,y) should switch tasks from x to y.
 368  *
 369  * This could still be optimized:
 370  * - fold all the options into a flag word and test it with a single test.
 371  * - could test fs/gs bitsliced
 372  *
 373  * Kprobes not supported here. Set the probe on schedule instead.
 374  * Function graph tracer not supported too.
 375  */
 376 __notrace_funcgraph struct task_struct *
 377 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 378 {
 379         struct thread_struct *prev = &prev_p->thread;
 380         struct thread_struct *next = &next_p->thread;
 381         int cpu = smp_processor_id();
 382         struct tss_struct *tss = &per_cpu(init_tss, cpu);
 383         unsigned fsindex, gsindex;
 384         fpu_switch_t fpu;
 385
 386         fpu = switch_fpu_prepare(prev_p, next_p);
 387
 388         /* Reload esp0 and ss1. */
 389         load_sp0(tss, next);
 390
 391         /* We must save %fs and %gs before load_TLS() because
 392          * %fs and %gs may be cleared by load_TLS().
 393          *
 394          * (e.g. xen_load_tls())
 395          */
 396         savesegment(fs, fsindex);
 397         savesegment(gs, gsindex);
 398
 399         /*
 400          * Load TLS before restoring any segments so that segment loads
 401          * reference the correct GDT entries.
 402          */
 403         load_TLS(next, cpu);
 404
 405         /*
 406          * Leave lazy mode, flushing any hypercalls made here.  This
 407          * must be done after loading TLS entries in the GDT but before
 408          * loading segments that might reference them, and and it must
 409          * be done before math_state_restore, so the TS bit is up to
 410          * date.
 411          */
 412         arch_end_context_switch(next_p);
 413
 414         /* Switch DS and ES.
 415          *
 416          * Reading them only returns the selectors, but writing them (if
 417          * nonzero) loads the full descriptor from the GDT or LDT.  The
 418          * LDT for next is loaded in switch_mm, and the GDT is loaded
 419          * above.
 420          *
 421          * We therefore need to write new values to the segment
 422          * registers on every context switch unless both the new and old
 423          * values are zero.
 424          *
 425          * Note that we don't need to do anything for CS and SS, as
 426          * those are saved and restored as part of pt_regs.
 427          */
 428         savesegment(es, prev->es);
 429         if (unlikely(next->es | prev->es))
 430                 loadsegment(es, next->es);
 431
 432         savesegment(ds, prev->ds);
 433         if (unlikely(next->ds | prev->ds))
 434                 loadsegment(ds, next->ds);
 435
 436         /*
 437          * Switch FS and GS.
 438          *
 439          * These are even more complicated than FS and GS: they have
 440          * 64-bit bases are that controlled by arch_prctl.  Those bases
 441          * only differ from the values in the GDT or LDT if the selector
 442          * is 0.
 443          *
 444          * Loading the segment register resets the hidden base part of
 445          * the register to 0 or the value from the GDT / LDT.  If the
 446          * next base address zero, writing 0 to the segment register is
 447          * much faster than using wrmsr to explicitly zero the base.
 448          *
 449          * The thread_struct.fs and thread_struct.gs values are 0
 450          * if the fs and gs bases respectively are not overridden
 451          * from the values implied by fsindex and gsindex.  They
 452          * are nonzero, and store the nonzero base addresses, if
 453          * the bases are overridden.
 454          *
 455          * (fs != 0 && fsindex != 0) || (gs != 0 && gsindex != 0) should
 456          * be impossible.
 457          *
 458          * Therefore we need to reload the segment registers if either
 459          * the old or new selector is nonzero, and we need to override
 460          * the base address if next thread expects it to be overridden.
 461          *
 462          * This code is unnecessarily slow in the case where the old and
 463          * new indexes are zero and the new base is nonzero -- it will
 464          * unnecessarily write 0 to the selector before writing the new
 465          * base address.
 466          *
 467          * Note: This all depends on arch_prctl being the only way that
 468          * user code can override the segment base.  Once wrfsbase and
 469          * wrgsbase are enabled, most of this code will need to change.
 470          */
 471         if (unlikely(fsindex | next->fsindex | prev->fs)) {
 472                 loadsegment(fs, next->fsindex);
 473
 474                 /*
 475                  * If user code wrote a nonzero value to FS, then it also
 476                  * cleared the overridden base address.
 477                  *
 478                  * XXX: if user code wrote 0 to FS and cleared the base
 479                  * address itself, we won't notice and we'll incorrectly
 480                  * restore the prior base address next time we reschdule
 481                  * the process.
 482                  */
 483                 if (fsindex)
 484                         prev->fs = 0;
 485         }
 486         if (next->fs)
 487                 wrmsrl(MSR_FS_BASE, next->fs);
 488         prev->fsindex = fsindex;
 489
 490         if (unlikely(gsindex | next->gsindex | prev->gs)) {
 491                 load_gs_index(next->gsindex);
 492
 493                 /* This works (and fails) the same way as fsindex above. */
 494                 if (gsindex)
 495                         prev->gs = 0;
 496         }
 497         if (next->gs)
 498                 wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 499         prev->gsindex = gsindex;
 500
 501         switch_fpu_finish(next_p, fpu);
 502
 503         /*
 504          * Switch the PDA and FPU contexts.
 505          */
 506         prev->usersp = percpu_read(old_rsp);
 507         percpu_write(old_rsp, next->usersp);
 508         percpu_write(current_task, next_p);
 509
 510         percpu_write(kernel_stack,
 511                   (unsigned long)task_stack_page(next_p) +
 512                   THREAD_SIZE - KERNEL_STACK_OFFSET);
 513
 514         /*
 515          * Now maybe reload the debug registers and handle I/O bitmaps
 516          */
 517         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
 518                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
 519                 __switch_to_xtra(prev_p, next_p, tss);
 520
 521         return prev_p;
 522 }
 523
 524 void set_personality_64bit(void)
 525 {
 526         /* inherit personality from parent */
 527
 528         /* Make sure to be in 64bit mode */
 529         clear_thread_flag(TIF_IA32);
 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 void set_personality_ia32(void)
 543 {
 544         /* inherit personality from parent */
 545
 546         /* Make sure to be in 32bit mode */
 547         set_thread_flag(TIF_IA32);
 548         current->personality |= force_personality32;
 549
 550         /* Mark the associated mm as containing 32-bit tasks. */
 551         if (current->mm)
 552                 current->mm->context.ia32_compat = 1;
 553
 554         /* Prepare the first "return" to user space */
 555         current_thread_info()->status |= TS_COMPAT;
 556 }
 557
 558 /*
 559  * Called from fs/proc with a reference on @p to find the function
 560  * which called into schedule(). This needs to be done carefully
 561  * because the task might wake up and we might look at a stack
 562  * changing under us.
 563  */
 564 unsigned long get_wchan(struct task_struct *p)
 565 {
 566         unsigned long start, bottom, top, sp, fp, ip;
 567         int count = 0;
 568
 569         if (!p || p == current || p->state == TASK_RUNNING)
 570                 return 0;
 571
 572         start = (unsigned long)task_stack_page(p);
 573         if (!start)
 574                 return 0;
 575
 576         /*
 577          * Layout of the stack page:
 578          *
 579          * ----------- topmax = start + THREAD_SIZE - sizeof(unsigned long)
 580          * PADDING
 581          * ----------- top = topmax - TOP_OF_KERNEL_STACK_PADDING
 582          * stack
 583          * ----------- bottom = start + sizeof(thread_info)
 584          * thread_info
 585          * ----------- start
 586          *
 587          * The tasks stack pointer points at the location where the
 588          * framepointer is stored. The data on the stack is:
 589          * ... IP FP ... IP FP
 590          *
 591          * We need to read FP and IP, so we need to adjust the upper
 592          * bound by another unsigned long.
 593          */
 594         top = start + THREAD_SIZE;
 595         top -= 2 * sizeof(unsigned long);
 596         bottom = start + sizeof(struct thread_info);
 597
 598         sp = ACCESS_ONCE(p->thread.sp);
 599         if (sp < bottom || sp > top)
 600                 return 0;
 601
 602         fp = ACCESS_ONCE(*(unsigned long *)sp);
 603         do {
 604                 if (fp < bottom || fp > top)
 605                         return 0;
 606                 ip = ACCESS_ONCE(*(unsigned long *)(fp + sizeof(unsigned long)));
 607                 if (!in_sched_functions(ip))
 608                         return ip;
 609                 fp = ACCESS_ONCE(*(unsigned long *)fp);
 610         } while (count++ < 16 && p->state != TASK_RUNNING);
 611         return 0;
 612 }
 613
 614 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 615 {
 616         int ret = 0;
 617         int doit = task == current;
 618         int cpu;
 619
 620         switch (code) {
 621         case ARCH_SET_GS:
 622                 if (addr >= TASK_SIZE_OF(task))
 623                         return -EPERM;
 624                 cpu = get_cpu();
 625                 /* handle small bases via the GDT because that's faster to
 626                    switch. */
 627                 if (addr <= 0xffffffff) {
 628                         set_32bit_tls(task, GS_TLS, addr);
 629                         if (doit) {
 630                                 load_TLS(&task->thread, cpu);
 631                                 load_gs_index(GS_TLS_SEL);
 632                         }
 633                         task->thread.gsindex = GS_TLS_SEL;
 634                         task->thread.gs = 0;
 635                 } else {
 636                         task->thread.gsindex = 0;
 637                         task->thread.gs = addr;
 638                         if (doit) {
 639                                 load_gs_index(0);
 640                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 641                         }
 642                 }
 643                 put_cpu();
 644                 break;
 645         case ARCH_SET_FS:
 646                 /* Not strictly needed for fs, but do it for symmetry
 647                    with gs */
 648                 if (addr >= TASK_SIZE_OF(task))
 649                         return -EPERM;
 650                 cpu = get_cpu();
 651                 /* handle small bases via the GDT because that's faster to
 652                    switch. */
 653                 if (addr <= 0xffffffff) {
 654                         set_32bit_tls(task, FS_TLS, addr);
 655                         if (doit) {
 656                                 load_TLS(&task->thread, cpu);
 657                                 loadsegment(fs, FS_TLS_SEL);
 658                         }
 659                         task->thread.fsindex = FS_TLS_SEL;
 660                         task->thread.fs = 0;
 661                 } else {
 662                         task->thread.fsindex = 0;
 663                         task->thread.fs = addr;
 664                         if (doit) {
 665                                 /* set the selector to 0 to not confuse
 666                                    __switch_to */
 667                                 loadsegment(fs, 0);
 668                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 669                         }
 670                 }
 671                 put_cpu();
 672                 break;
 673         case ARCH_GET_FS: {
 674                 unsigned long base;
 675                 if (task->thread.fsindex == FS_TLS_SEL)
 676                         base = read_32bit_tls(task, FS_TLS);
 677                 else if (doit)
 678                         rdmsrl(MSR_FS_BASE, base);
 679                 else
 680                         base = task->thread.fs;
 681                 ret = put_user(base, (unsigned long __user *)addr);
 682                 break;
 683         }
 684         case ARCH_GET_GS: {
 685                 unsigned long base;
 686                 unsigned gsindex;
 687                 if (task->thread.gsindex == GS_TLS_SEL)
 688                         base = read_32bit_tls(task, GS_TLS);
 689                 else if (doit) {
 690                         savesegment(gs, gsindex);
 691                         if (gsindex)
 692                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
 693                         else
 694                                 base = task->thread.gs;
 695                 } else
 696                         base = task->thread.gs;
 697                 ret = put_user(base, (unsigned long __user *)addr);
 698                 break;
 699         }
 700
 701         default:
 702                 ret = -EINVAL;
 703                 break;
 704         }
 705
 706         return ret;
 707 }
 708
 709 long sys_arch_prctl(int code, unsigned long addr)
 710 {
 711         return do_arch_prctl(current, code, addr);
 712 }
 713
 714 unsigned long KSTK_ESP(struct task_struct *task)
 715 {
 716         return (test_tsk_thread_flag(task, TIF_IA32)) ?
 717                         (task_pt_regs(task)->sp) : ((task)->thread.usersp);
 718 }