arch/x86_64/kernel/process.c

   1 /*
   2  *  linux/arch/x86-64/kernel/process.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  *
   6  *  Pentium III FXSR, SSE support
   7  *      Gareth Hughes <gareth@valinux.com>, May 2000
   8  *
   9  *  X86-64 port
  10  *      Andi Kleen.
  11  *
  12  *  $Id: process.c,v 1.38 2002/01/15 10:08:03 ak Exp $
  13  */
  14
  15 /*
  16  * This file handles the architecture-dependent parts of process handling..
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include <linux/errno.h>
  22 #include <linux/sched.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/module.h>
  30 #include <linux/a.out.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/delay.h>
  33 #include <linux/irq.h>
  34 #include <linux/ptrace.h>
  35 #include <linux/version.h>
  36
  37 #include <asm/uaccess.h>
  38 #include <asm/pgtable.h>
  39 #include <asm/system.h>
  40 #include <asm/io.h>
  41 #include <asm/processor.h>
  42 #include <asm/i387.h>
  43 #include <asm/mmu_context.h>
  44 #include <asm/pda.h>
  45 #include <asm/prctl.h>
  46 #include <asm/kdebug.h>
  47 #include <asm/desc.h>
  48 #include <asm/proto.h>
  49 #include <asm/ia32.h>
  50
  51 asmlinkage extern void ret_from_fork(void);
  52
  53 unsigned long kernel_thread_flags = CLONE_VM | CLONE_UNTRACED;
  54
  55 atomic_t hlt_counter = ATOMIC_INIT(0);
  56
  57 /*
  58  * Powermanagement idle function, if any..
  59  */
  60 void (*pm_idle)(void);
  61
  62 void disable_hlt(void)
  63 {
  64         atomic_inc(&hlt_counter);
  65 }
  66
  67 EXPORT_SYMBOL(disable_hlt);
  68
  69 void enable_hlt(void)
  70 {
  71         atomic_dec(&hlt_counter);
  72 }
  73
  74 EXPORT_SYMBOL(enable_hlt);
  75
  76 /*
  77  * We use this if we don't have any better
  78  * idle routine..
  79  */
  80 void default_idle(void)
  81 {
  82         if (!atomic_read(&hlt_counter)) {
  83                 local_irq_disable();
  84                 if (!need_resched())
  85                         safe_halt();
  86                 else
  87                         local_irq_enable();
  88         }
  89 }
  90
  91 /*
  92  * On SMP it's slightly faster (but much more power-consuming!)
  93  * to poll the ->need_resched flag instead of waiting for the
  94  * cross-CPU IPI to arrive. Use this option with caution.
  95  */
  96 static void poll_idle (void)
  97 {
  98         int oldval;
  99
 100         local_irq_enable();
 101
 102         /*
 103          * Deal with another CPU just having chosen a thread to
 104          * run here:
 105          */
 106         oldval = test_and_clear_thread_flag(TIF_NEED_RESCHED);
 107
 108         if (!oldval) {
 109                 set_thread_flag(TIF_POLLING_NRFLAG);
 110                 asm volatile(
 111                         "2:"
 112                         "testl %0,%1;"
 113                         "rep; nop;"
 114                         "je 2b;"
 115                         : :
 116                         "i" (_TIF_NEED_RESCHED),
 117                         "m" (current_thread_info()->flags));
 118         } else {
 119                 set_need_resched();
 120         }
 121 }
 122
 123 /*
 124  * The idle thread. There's no useful work to be
 125  * done, so just try to conserve power and have a
 126  * low exit latency (ie sit in a loop waiting for
 127  * somebody to say that they'd like to reschedule)
 128  */
 129 void cpu_idle (void)
 130 {
 131         /* endless idle loop with no priority at all */
 132         while (1) {
 133                 void (*idle)(void) = pm_idle;
 134                 if (!idle)
 135                         idle = default_idle;
 136                 while (!need_resched())
 137                         idle();
 138                 schedule();
 139         }
 140 }
 141
 142 /*
 143  * This uses new MONITOR/MWAIT instructions on P4 processors with PNI,
 144  * which can obviate IPI to trigger checking of need_resched.
 145  * We execute MONITOR against need_resched and enter optimized wait state
 146  * through MWAIT. Whenever someone changes need_resched, we would be woken
 147  * up from MWAIT (without an IPI).
 148  */
 149 static void mwait_idle(void)
 150 {
 151         local_irq_enable();
 152
 153         if (!need_resched()) {
 154                 set_thread_flag(TIF_POLLING_NRFLAG);
 155                 do {
 156                         __monitor((void *)&current_thread_info()->flags, 0, 0);
 157                         if (need_resched())
 158                                 break;
 159                         __mwait(0, 0);
 160                 } while (!need_resched());
 161                 clear_thread_flag(TIF_POLLING_NRFLAG);
 162         }
 163 }
 164
 165 void __init select_idle_routine(const struct cpuinfo_x86 *c)
 166 {
 167         static int printed;
 168         if (cpu_has(c, X86_FEATURE_MWAIT)) {
 169                 /*
 170                  * Skip, if setup has overridden idle.
 171                  * Also, take care of system with asymmetric CPUs.
 172                  * Use, mwait_idle only if all cpus support it.
 173                  * If not, we fallback to default_idle()
 174                  */
 175                 if (!pm_idle) {
 176                         if (!printed) {
 177                                 printk("using mwait in idle threads.\n");
 178                                 printed = 1;
 179                         }
 180                         pm_idle = mwait_idle;
 181                 }
 182                 return;
 183         }
 184         pm_idle = default_idle;
 185         return;
 186 }
 187
 188 static int __init idle_setup (char *str)
 189 {
 190         if (!strncmp(str, "poll", 4)) {
 191                 printk("using polling idle threads.\n");
 192                 pm_idle = poll_idle;
 193         }
 194
 195         return 1;
 196 }
 197
 198 __setup("idle=", idle_setup);
 199
 200 /* Prints also some state that isn't saved in the pt_regs */
 201 void __show_regs(struct pt_regs * regs)
 202 {
 203         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
 204         unsigned int fsindex,gsindex;
 205         unsigned int ds,cs,es;
 206
 207         printk("\n");
 208         print_modules();
 209         printk("Pid: %d, comm: %.20s %s %s\n",
 210                current->pid, current->comm, print_tainted(), UTS_RELEASE);
 211         printk("RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->rip);
 212         printk_address(regs->rip);
 213         printk("\nRSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss, regs->rsp, regs->eflags);
 214         printk("RAX: %016lx RBX: %016lx RCX: %016lx\n",
 215                regs->rax, regs->rbx, regs->rcx);
 216         printk("RDX: %016lx RSI: %016lx RDI: %016lx\n",
 217                regs->rdx, regs->rsi, regs->rdi);
 218         printk("RBP: %016lx R08: %016lx R09: %016lx\n",
 219                regs->rbp, regs->r8, regs->r9);
 220         printk("R10: %016lx R11: %016lx R12: %016lx\n",
 221                regs->r10, regs->r11, regs->r12);
 222         printk("R13: %016lx R14: %016lx R15: %016lx\n",
 223                regs->r13, regs->r14, regs->r15);
 224
 225         asm("movl %%ds,%0" : "=r" (ds));
 226         asm("movl %%cs,%0" : "=r" (cs));
 227         asm("movl %%es,%0" : "=r" (es));
 228         asm("movl %%fs,%0" : "=r" (fsindex));
 229         asm("movl %%gs,%0" : "=r" (gsindex));
 230
 231         rdmsrl(MSR_FS_BASE, fs);
 232         rdmsrl(MSR_GS_BASE, gs);
 233         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
 234
 235         asm("movq %%cr0, %0": "=r" (cr0));
 236         asm("movq %%cr2, %0": "=r" (cr2));
 237         asm("movq %%cr3, %0": "=r" (cr3));
 238         asm("movq %%cr4, %0": "=r" (cr4));
 239
 240         printk("FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
 241                fs,fsindex,gs,gsindex,shadowgs);
 242         printk("CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds, es, cr0);
 243         printk("CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3, cr4);
 244 }
 245
 246 void show_regs(struct pt_regs *regs)
 247 {
 248         __show_regs(regs);
 249         show_trace(&regs->rsp);
 250 }
 251
 252 /*
 253  * Free current thread data structures etc..
 254  */
 255 void exit_thread(void)
 256 {
 257         struct task_struct *me = current;
 258         if (me->thread.io_bitmap_ptr) {
 259                 struct tss_struct *tss = init_tss + get_cpu();
 260                 kfree(me->thread.io_bitmap_ptr);
 261                 me->thread.io_bitmap_ptr = NULL;
 262                 tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET;
 263                 put_cpu();
 264         }
 265 }
 266
 267 void flush_thread(void)
 268 {
 269         struct task_struct *tsk = current;
 270         struct thread_info *t = current_thread_info();
 271
 272         if (t->flags & _TIF_ABI_PENDING)
 273                 t->flags ^= (_TIF_ABI_PENDING | _TIF_IA32);
 274
 275         tsk->thread.debugreg0 = 0;
 276         tsk->thread.debugreg1 = 0;
 277         tsk->thread.debugreg2 = 0;
 278         tsk->thread.debugreg3 = 0;
 279         tsk->thread.debugreg6 = 0;
 280         tsk->thread.debugreg7 = 0;
 281         memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
 282         /*
 283          * Forget coprocessor state..
 284          */
 285         clear_fpu(tsk);
 286         tsk->used_math = 0;
 287 }
 288
 289 void release_thread(struct task_struct *dead_task)
 290 {
 291         if (dead_task->mm) {
 292                 if (dead_task->mm->context.size) {
 293                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
 294                                         dead_task->comm,
 295                                         dead_task->mm->context.ldt,
 296                                         dead_task->mm->context.size);
 297                         BUG();
 298                 }
 299         }
 300 }
 301
 302 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
 303 {
 304         struct user_desc ud = {
 305                 .base_addr = addr,
 306                 .limit = 0xfffff,
 307                 .seg_32bit = 1,
 308                 .limit_in_pages = 1,
 309                 .useable = 1,
 310         };
 311         struct n_desc_struct *desc = (void *)t->thread.tls_array;
 312         desc += tls;
 313         desc->a = LDT_entry_a(&ud);
 314         desc->b = LDT_entry_b(&ud);
 315 }
 316
 317 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
 318 {
 319         struct desc_struct *desc = (void *)t->thread.tls_array;
 320         desc += tls;
 321         return desc->base0 |
 322                 (((u32)desc->base1) << 16) |
 323                 (((u32)desc->base2) << 24);
 324 }
 325
 326 /*
 327  * This gets called before we allocate a new thread and copy
 328  * the current task into it.
 329  */
 330 void prepare_to_copy(struct task_struct *tsk)
 331 {
 332         unlazy_fpu(tsk);
 333 }
 334
 335 int copy_thread(int nr, unsigned long clone_flags, unsigned long rsp,
 336                 unsigned long unused,
 337         struct task_struct * p, struct pt_regs * regs)
 338 {
 339         int err;
 340         struct pt_regs * childregs;
 341         struct task_struct *me = current;
 342
 343         childregs = ((struct pt_regs *) (THREAD_SIZE + (unsigned long) p->thread_info)) - 1;
 344
 345         *childregs = *regs;
 346
 347         childregs->rax = 0;
 348         childregs->rsp = rsp;
 349         if (rsp == ~0UL) {
 350                 childregs->rsp = (unsigned long)childregs;
 351         }
 352         p->set_child_tid = p->clear_child_tid = NULL;
 353
 354         p->thread.rsp = (unsigned long) childregs;
 355         p->thread.rsp0 = (unsigned long) (childregs+1);
 356         p->thread.userrsp = me->thread.userrsp;
 357
 358         set_ti_thread_flag(p->thread_info, TIF_FORK);
 359
 360         p->thread.fs = me->thread.fs;
 361         p->thread.gs = me->thread.gs;
 362
 363         asm("movl %%gs,%0" : "=m" (p->thread.gsindex));
 364         asm("movl %%fs,%0" : "=m" (p->thread.fsindex));
 365         asm("movl %%es,%0" : "=m" (p->thread.es));
 366         asm("movl %%ds,%0" : "=m" (p->thread.ds));
 367
 368         if (unlikely(me->thread.io_bitmap_ptr != NULL)) {
 369                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
 370                 if (!p->thread.io_bitmap_ptr)
 371                         return -ENOMEM;
 372                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr, IO_BITMAP_BYTES);
 373         }
 374
 375         /*
 376          * Set a new TLS for the child thread?
 377          */
 378         if (clone_flags & CLONE_SETTLS) {
 379 #ifdef CONFIG_IA32_EMULATION
 380                 if (test_thread_flag(TIF_IA32))
 381                         err = ia32_child_tls(p, childregs);
 382                 else
 383 #endif
 384                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
 385                 if (err)
 386                         goto out;
 387         }
 388         err = 0;
 389 out:
 390         if (err && p->thread.io_bitmap_ptr)
 391                 kfree(p->thread.io_bitmap_ptr);
 392         return err;
 393 }
 394
 395 /*
 396  * This special macro can be used to load a debugging register
 397  */
 398 #define loaddebug(thread,r) set_debug(thread->debugreg ## r, r)
 399
 400 /*
 401  *      switch_to(x,y) should switch tasks from x to y.
 402  *
 403  * This could still be optimized:
 404  * - fold all the options into a flag word and test it with a single test.
 405  * - could test fs/gs bitsliced
 406  */
 407 struct task_struct *__switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 408 {
 409         struct thread_struct *prev = &prev_p->thread,
 410                                  *next = &next_p->thread;
 411         int cpu = smp_processor_id();
 412         struct tss_struct *tss = init_tss + cpu;
 413
 414         unlazy_fpu(prev_p);
 415
 416         /*
 417          * Reload esp0, LDT and the page table pointer:
 418          */
 419         tss->rsp0 = next->rsp0;
 420
 421         /*
 422          * Switch DS and ES.
 423          * This won't pick up thread selector changes, but I guess that is ok.
 424          */
 425         asm volatile("movl %%es,%0" : "=m" (prev->es));
 426         if (unlikely(next->es | prev->es))
 427                 loadsegment(es, next->es);
 428
 429         asm volatile ("movl %%ds,%0" : "=m" (prev->ds));
 430         if (unlikely(next->ds | prev->ds))
 431                 loadsegment(ds, next->ds);
 432
 433         load_TLS(next, cpu);
 434
 435         /*
 436          * Switch FS and GS.
 437          */
 438         {
 439                 unsigned fsindex;
 440                 asm volatile("movl %%fs,%0" : "=g" (fsindex));
 441                 /* segment register != 0 always requires a reload.
 442                    also reload when it has changed.
 443                    when prev process used 64bit base always reload
 444                    to avoid an information leak. */
 445                 if (unlikely(fsindex | next->fsindex | prev->fs)) {
 446                         loadsegment(fs, next->fsindex);
 447                         /* check if the user used a selector != 0
 448                          * if yes clear 64bit base, since overloaded base
 449                          * is always mapped to the Null selector
 450                          */
 451                         if (fsindex)
 452                         prev->fs = 0;
 453                 }
 454                 /* when next process has a 64bit base use it */
 455                 if (next->fs)
 456                         wrmsrl(MSR_FS_BASE, next->fs);
 457                 prev->fsindex = fsindex;
 458         }
 459         {
 460                 unsigned gsindex;
 461                 asm volatile("movl %%gs,%0" : "=g" (gsindex));
 462                 if (unlikely(gsindex | next->gsindex | prev->gs)) {
 463                         load_gs_index(next->gsindex);
 464                         if (gsindex)
 465                         prev->gs = 0;
 466                 }
 467                 if (next->gs)
 468                         wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 469                 prev->gsindex = gsindex;
 470         }
 471
 472         /*
 473          * Switch the PDA context.
 474          */
 475         prev->userrsp = read_pda(oldrsp);
 476         write_pda(oldrsp, next->userrsp);
 477         write_pda(pcurrent, next_p);
 478         write_pda(kernelstack, (unsigned long)next_p->thread_info + THREAD_SIZE - PDA_STACKOFFSET);
 479
 480         /*
 481          * Now maybe reload the debug registers
 482          */
 483         if (unlikely(next->debugreg7)) {
 484                 loaddebug(next, 0);
 485                 loaddebug(next, 1);
 486                 loaddebug(next, 2);
 487                 loaddebug(next, 3);
 488                 /* no 4 and 5 */
 489                 loaddebug(next, 6);
 490                 loaddebug(next, 7);
 491         }
 492
 493
 494         /*
 495          * Handle the IO bitmap
 496          */
 497         if (unlikely(prev->io_bitmap_ptr || next->io_bitmap_ptr)) {
 498                 if (next->io_bitmap_ptr) {
 499                         /*
 500                          * 2 cachelines copy ... not good, but not that
 501                          * bad either. Anyone got something better?
 502                          * This only affects processes which use ioperm().
 503                          */
 504                         memcpy(tss->io_bitmap, next->io_bitmap_ptr, IO_BITMAP_BYTES);
 505                         tss->io_bitmap_base = IO_BITMAP_OFFSET;
 506                 } else {
 507                         /*
 508                          * a bitmap offset pointing outside of the TSS limit
 509                          * causes a nicely controllable SIGSEGV if a process
 510                          * tries to use a port IO instruction. The first
 511                          * sys_ioperm() call sets up the bitmap properly.
 512                          */
 513                         tss->io_bitmap_base = INVALID_IO_BITMAP_OFFSET;
 514                 }
 515         }
 516
 517         return prev_p;
 518 }
 519
 520 /*
 521  * sys_execve() executes a new program.
 522  */
 523 asmlinkage
 524 long sys_execve(char *name, char **argv,char **envp, struct pt_regs regs)
 525 {
 526         long error;
 527         char * filename;
 528
 529         filename = getname(name);
 530         error = PTR_ERR(filename);
 531         if (IS_ERR(filename))
 532                 return error;
 533         error = do_execve(filename, argv, envp, &regs);
 534         if (error == 0)
 535                 current->ptrace &= ~PT_DTRACE;
 536         putname(filename);
 537         return error;
 538 }
 539
 540 void set_personality_64bit(void)
 541 {
 542         /* inherit personality from parent */
 543
 544         /* Make sure to be in 64bit mode */
 545         clear_thread_flag(TIF_IA32);
 546 }
 547
 548 asmlinkage long sys_fork(struct pt_regs regs)
 549 {
 550         return do_fork(SIGCHLD, regs.rsp, &regs, 0, NULL, NULL);
 551 }
 552
 553 asmlinkage long sys_clone(unsigned long clone_flags, unsigned long newsp, void *parent_tid, void *child_tid, struct pt_regs regs)
 554 {
 555         if (!newsp)
 556                 newsp = regs.rsp;
 557         return do_fork(clone_flags & ~CLONE_IDLETASK, newsp, &regs, 0,
 558                     parent_tid, child_tid);
 559 }
 560
 561 /*
 562  * This is trivial, and on the face of it looks like it
 563  * could equally well be done in user mode.
 564  *
 565  * Not so, for quite unobvious reasons - register pressure.
 566  * In user mode vfork() cannot have a stack frame, and if
 567  * done by calling the "clone()" system call directly, you
 568  * do not have enough call-clobbered registers to hold all
 569  * the information you need.
 570  */
 571 asmlinkage long sys_vfork(struct pt_regs regs)
 572 {
 573         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs.rsp, &regs, 0,
 574                     NULL, NULL);
 575 }
 576
 577 /*
 578  * These bracket the sleeping functions..
 579  */
 580 #define first_sched     ((unsigned long) scheduling_functions_start_here)
 581 #define last_sched      ((unsigned long) scheduling_functions_end_here)
 582
 583 unsigned long get_wchan(struct task_struct *p)
 584 {
 585         unsigned long stack;
 586         u64 fp,rip;
 587         int count = 0;
 588
 589         if (!p || p == current || p->state==TASK_RUNNING)
 590                 return 0;
 591         stack = (unsigned long)p->thread_info;
 592         if (p->thread.rsp < stack || p->thread.rsp > stack+THREAD_SIZE)
 593                 return 0;
 594         fp = *(u64 *)(p->thread.rsp);
 595         do {
 596                 if (fp < (unsigned long)stack || fp > (unsigned long)stack+THREAD_SIZE)
 597                         return 0;
 598                 rip = *(u64 *)(fp+8);
 599                 if (rip < first_sched || rip >= last_sched)
 600                         return rip;
 601                 fp = *(u64 *)fp;
 602         } while (count++ < 16);
 603         return 0;
 604 }
 605 #undef last_sched
 606 #undef first_sched
 607
 608 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 609 {
 610         int ret = 0;
 611         int doit = task == current;
 612         int cpu;
 613
 614         switch (code) {
 615         case ARCH_SET_GS:
 616                 if (addr >= TASK_SIZE)
 617                         return -EPERM;
 618                 cpu = get_cpu();
 619                 /* handle small bases via the GDT because that's faster to
 620                    switch. */
 621                 if (addr <= 0xffffffff) {
 622                         set_32bit_tls(task, GS_TLS, addr);
 623                         if (doit) {
 624                                 load_TLS(&task->thread, cpu);
 625                                 load_gs_index(GS_TLS_SEL);
 626                         }
 627                         task->thread.gsindex = GS_TLS_SEL;
 628                         task->thread.gs = 0;
 629                 } else {
 630                         task->thread.gsindex = 0;
 631                         task->thread.gs = addr;
 632                         if (doit) {
 633                 load_gs_index(0);
 634                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 635                         }
 636                 }
 637                 put_cpu();
 638                 break;
 639         case ARCH_SET_FS:
 640                 /* Not strictly needed for fs, but do it for symmetry
 641                    with gs */
 642                 if (addr >= TASK_SIZE)
 643                         return -EPERM;
 644                 cpu = get_cpu();
 645                 /* handle small bases via the GDT because that's faster to
 646                    switch. */
 647                 if (addr <= 0xffffffff) {
 648                         set_32bit_tls(task, FS_TLS, addr);
 649                         if (doit) {
 650                                 load_TLS(&task->thread, cpu);
 651                                 asm volatile("movl %0,%%fs" :: "r" (FS_TLS_SEL));
 652                         }
 653                         task->thread.fsindex = FS_TLS_SEL;
 654                         task->thread.fs = 0;
 655                 } else {
 656                         task->thread.fsindex = 0;
 657                         task->thread.fs = addr;
 658                         if (doit) {
 659                                 /* set the selector to 0 to not confuse
 660                                    __switch_to */
 661                 asm volatile("movl %0,%%fs" :: "r" (0));
 662                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 663                         }
 664                 }
 665                 put_cpu();
 666                 break;
 667         case ARCH_GET_FS: {
 668                 unsigned long base;
 669                 if (task->thread.fsindex == FS_TLS_SEL)
 670                         base = read_32bit_tls(task, FS_TLS);
 671                 else if (doit) {
 672                         rdmsrl(MSR_FS_BASE, base);
 673                 } else
 674                         base = task->thread.fs;
 675                 ret = put_user(base, (unsigned long *)addr);
 676                 break;
 677         }
 678         case ARCH_GET_GS: {
 679                 unsigned long base;
 680                 if (task->thread.gsindex == GS_TLS_SEL)
 681                         base = read_32bit_tls(task, GS_TLS);
 682                 else if (doit) {
 683                         rdmsrl(MSR_KERNEL_GS_BASE, base);
 684                 } else
 685                         base = task->thread.gs;
 686                 ret = put_user(base, (unsigned long *)addr);
 687                 break;
 688         }
 689
 690         default:
 691                 ret = -EINVAL;
 692                 break;
 693         }
 694
 695         return ret;
 696 }
 697
 698 long sys_arch_prctl(int code, unsigned long addr)
 699 {
 700         return do_arch_prctl(current, code, addr);
 701 }
 702
 703 /*
 704  * Capture the user space registers if the task is not running (in user space)
 705  */
 706 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
 707 {
 708         struct pt_regs *pp, ptregs;
 709
 710         pp = (struct pt_regs *)(tsk->thread.rsp0);
 711         --pp;
 712
 713         ptregs = *pp;
 714         ptregs.cs &= 0xffff;
 715         ptregs.ss &= 0xffff;
 716
 717         elf_core_copy_regs(regs, &ptregs);
 718
 719         return 1;
 720 }