SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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/utsname.h>
  30 #include <linux/delay.h>
  31 #include <linux/module.h>
  32 #include <linux/ptrace.h>
  33 #include <linux/notifier.h>
  34 #include <linux/kprobes.h>
  35 #include <linux/kdebug.h>
  36 #include <linux/tick.h>
  37 #include <linux/prctl.h>
  38 #include <linux/uaccess.h>
  39 #include <linux/io.h>
  40 #include <linux/ftrace.h>
  41 #include <linux/dmi.h>
  42
  43 #include <asm/pgtable.h>
  44 #include <asm/system.h>
  45 #include <asm/processor.h>
  46 #include <asm/i387.h>
  47 #include <asm/mmu_context.h>
  48 #include <asm/prctl.h>
  49 #include <asm/desc.h>
  50 #include <asm/proto.h>
  51 #include <asm/ia32.h>
  52 #include <asm/idle.h>
  53 #include <asm/syscalls.h>
  54 #include <asm/ds.h>
  55 #include <asm/debugreg.h>
  56
  57 asmlinkage extern void ret_from_fork(void);
  58
  59 DEFINE_PER_CPU(unsigned long, old_rsp);
  60 static DEFINE_PER_CPU(unsigned char, is_idle);
  61
  62 unsigned long kernel_thread_flags = CLONE_VM | CLONE_UNTRACED;
  63
  64 static ATOMIC_NOTIFIER_HEAD(idle_notifier);
  65
  66 void idle_notifier_register(struct notifier_block *n)
  67 {
  68         atomic_notifier_chain_register(&idle_notifier, n);
  69 }
  70 EXPORT_SYMBOL_GPL(idle_notifier_register);
  71
  72 void idle_notifier_unregister(struct notifier_block *n)
  73 {
  74         atomic_notifier_chain_unregister(&idle_notifier, n);
  75 }
  76 EXPORT_SYMBOL_GPL(idle_notifier_unregister);
  77
  78 void enter_idle(void)
  79 {
  80         percpu_write(is_idle, 1);
  81         atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
  82 }
  83
  84 static void __exit_idle(void)
  85 {
  86         if (x86_test_and_clear_bit_percpu(0, is_idle) == 0)
  87                 return;
  88         atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
  89 }
  90
  91 /* Called from interrupts to signify idle end */
  92 void exit_idle(void)
  93 {
  94         /* idle loop has pid 0 */
  95         if (current->pid)
  96                 return;
  97         __exit_idle();
  98 }
  99
 100 #ifndef CONFIG_SMP
 101 static inline void play_dead(void)
 102 {
 103         BUG();
 104 }
 105 #endif
 106
 107 /*
 108  * The idle thread. There's no useful work to be
 109  * done, so just try to conserve power and have a
 110  * low exit latency (ie sit in a loop waiting for
 111  * somebody to say that they'd like to reschedule)
 112  */
 113 void cpu_idle(void)
 114 {
 115         current_thread_info()->status |= TS_POLLING;
 116
 117         /*
 118          * If we're the non-boot CPU, nothing set the stack canary up
 119          * for us.  CPU0 already has it initialized but no harm in
 120          * doing it again.  This is a good place for updating it, as
 121          * we wont ever return from this function (so the invalid
 122          * canaries already on the stack wont ever trigger).
 123          */
 124         boot_init_stack_canary();
 125
 126         /* endless idle loop with no priority at all */
 127         while (1) {
 128                 tick_nohz_stop_sched_tick(1);
 129                 while (!need_resched()) {
 130
 131                         rmb();
 132
 133                         if (cpu_is_offline(smp_processor_id()))
 134                                 play_dead();
 135                         /*
 136                          * Idle routines should keep interrupts disabled
 137                          * from here on, until they go to idle.
 138                          * Otherwise, idle callbacks can misfire.
 139                          */
 140                         local_irq_disable();
 141                         enter_idle();
 142                         /* Don't trace irqs off for idle */
 143                         stop_critical_timings();
 144                         pm_idle();
 145                         start_critical_timings();
 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         const char *board;
 167
 168         printk("\n");
 169         print_modules();
 170         board = dmi_get_system_info(DMI_PRODUCT_NAME);
 171         if (!board)
 172                 board = "";
 173         printk(KERN_INFO "Pid: %d, comm: %.20s %s %s %.*s %s\n",
 174                 current->pid, current->comm, print_tainted(),
 175                 init_utsname()->release,
 176                 (int)strcspn(init_utsname()->version, " "),
 177                 init_utsname()->version, board);
 178         printk(KERN_INFO "RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->ip);
 179         printk_address(regs->ip, 1);
 180         printk(KERN_INFO "RSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss,
 181                         regs->sp, regs->flags);
 182         printk(KERN_INFO "RAX: %016lx RBX: %016lx RCX: %016lx\n",
 183                regs->ax, regs->bx, regs->cx);
 184         printk(KERN_INFO "RDX: %016lx RSI: %016lx RDI: %016lx\n",
 185                regs->dx, regs->si, regs->di);
 186         printk(KERN_INFO "RBP: %016lx R08: %016lx R09: %016lx\n",
 187                regs->bp, regs->r8, regs->r9);
 188         printk(KERN_INFO "R10: %016lx R11: %016lx R12: %016lx\n",
 189                regs->r10, regs->r11, regs->r12);
 190         printk(KERN_INFO "R13: %016lx R14: %016lx R15: %016lx\n",
 191                regs->r13, regs->r14, regs->r15);
 192
 193         asm("movl %%ds,%0" : "=r" (ds));
 194         asm("movl %%cs,%0" : "=r" (cs));
 195         asm("movl %%es,%0" : "=r" (es));
 196         asm("movl %%fs,%0" : "=r" (fsindex));
 197         asm("movl %%gs,%0" : "=r" (gsindex));
 198
 199         rdmsrl(MSR_FS_BASE, fs);
 200         rdmsrl(MSR_GS_BASE, gs);
 201         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
 202
 203         if (!all)
 204                 return;
 205
 206         cr0 = read_cr0();
 207         cr2 = read_cr2();
 208         cr3 = read_cr3();
 209         cr4 = read_cr4();
 210
 211         printk(KERN_INFO "FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
 212                fs, fsindex, gs, gsindex, shadowgs);
 213         printk(KERN_INFO "CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds,
 214                         es, cr0);
 215         printk(KERN_INFO "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
 216                         cr4);
 217
 218         get_debugreg(d0, 0);
 219         get_debugreg(d1, 1);
 220         get_debugreg(d2, 2);
 221         printk(KERN_INFO "DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2);
 222         get_debugreg(d3, 3);
 223         get_debugreg(d6, 6);
 224         get_debugreg(d7, 7);
 225         printk(KERN_INFO "DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7);
 226 }
 227
 228 void show_regs(struct pt_regs *regs)
 229 {
 230         show_registers(regs);
 231         show_trace(NULL, regs, (void *)(regs + 1), regs->bp);
 232 }
 233
 234 void release_thread(struct task_struct *dead_task)
 235 {
 236         if (dead_task->mm) {
 237                 if (dead_task->mm->context.size) {
 238                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
 239                                         dead_task->comm,
 240                                         dead_task->mm->context.ldt,
 241                                         dead_task->mm->context.size);
 242                         BUG();
 243                 }
 244         }
 245 }
 246
 247 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
 248 {
 249         struct user_desc ud = {
 250                 .base_addr = addr,
 251                 .limit = 0xfffff,
 252                 .seg_32bit = 1,
 253                 .limit_in_pages = 1,
 254                 .useable = 1,
 255         };
 256         struct desc_struct *desc = t->thread.tls_array;
 257         desc += tls;
 258         fill_ldt(desc, &ud);
 259 }
 260
 261 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
 262 {
 263         return get_desc_base(&t->thread.tls_array[tls]);
 264 }
 265
 266 /*
 267  * This gets called before we allocate a new thread and copy
 268  * the current task into it.
 269  */
 270 void prepare_to_copy(struct task_struct *tsk)
 271 {
 272         unlazy_fpu(tsk);
 273 }
 274
 275 int copy_thread(unsigned long clone_flags, unsigned long sp,
 276                 unsigned long unused,
 277         struct task_struct *p, struct pt_regs *regs)
 278 {
 279         int err;
 280         struct pt_regs *childregs;
 281         struct task_struct *me = current;
 282
 283         childregs = ((struct pt_regs *)
 284                         (THREAD_SIZE + task_stack_page(p))) - 1;
 285         *childregs = *regs;
 286
 287         childregs->ax = 0;
 288         childregs->sp = sp;
 289         if (sp == ~0UL)
 290                 childregs->sp = (unsigned long)childregs;
 291
 292         p->thread.sp = (unsigned long) childregs;
 293         p->thread.sp0 = (unsigned long) (childregs+1);
 294         p->thread.usersp = me->thread.usersp;
 295
 296         set_tsk_thread_flag(p, TIF_FORK);
 297
 298         p->thread.fs = me->thread.fs;
 299         p->thread.gs = me->thread.gs;
 300         p->thread.io_bitmap_ptr = NULL;
 301
 302         savesegment(gs, p->thread.gsindex);
 303         savesegment(fs, p->thread.fsindex);
 304         savesegment(es, p->thread.es);
 305         savesegment(ds, p->thread.ds);
 306
 307         err = -ENOMEM;
 308         memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
 309
 310         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
 311                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
 312                 if (!p->thread.io_bitmap_ptr) {
 313                         p->thread.io_bitmap_max = 0;
 314                         return -ENOMEM;
 315                 }
 316                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr,
 317                                 IO_BITMAP_BYTES);
 318                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
 319         }
 320
 321         /*
 322          * Set a new TLS for the child thread?
 323          */
 324         if (clone_flags & CLONE_SETTLS) {
 325 #ifdef CONFIG_IA32_EMULATION
 326                 if (test_thread_flag(TIF_IA32))
 327                         err = do_set_thread_area(p, -1,
 328                                 (struct user_desc __user *)childregs->si, 0);
 329                 else
 330 #endif
 331                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
 332                 if (err)
 333                         goto out;
 334         }
 335
 336         clear_tsk_thread_flag(p, TIF_DS_AREA_MSR);
 337         p->thread.ds_ctx = NULL;
 338
 339         clear_tsk_thread_flag(p, TIF_DEBUGCTLMSR);
 340         p->thread.debugctlmsr = 0;
 341
 342         err = 0;
 343 out:
 344         if (err && p->thread.io_bitmap_ptr) {
 345                 kfree(p->thread.io_bitmap_ptr);
 346                 p->thread.io_bitmap_max = 0;
 347         }
 348
 349         return err;
 350 }
 351
 352 static void
 353 start_thread_common(struct pt_regs *regs, unsigned long new_ip,
 354                     unsigned long new_sp,
 355                     unsigned int _cs, unsigned int _ss, unsigned int _ds)
 356 {
 357         loadsegment(fs, 0);
 358         loadsegment(es, _ds);
 359         loadsegment(ds, _ds);
 360         load_gs_index(0);
 361         regs->ip                = new_ip;
 362         regs->sp                = new_sp;
 363         percpu_write(old_rsp, new_sp);
 364         regs->cs                = _cs;
 365         regs->ss                = _ss;
 366         regs->flags             = X86_EFLAGS_IF;
 367         set_fs(USER_DS);
 368         /*
 369          * Free the old FP and other extended state
 370          */
 371         free_thread_xstate(current);
 372 }
 373
 374 void
 375 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
 376 {
 377         start_thread_common(regs, new_ip, new_sp,
 378                             __USER_CS, __USER_DS, 0);
 379 }
 380
 381 #ifdef CONFIG_IA32_EMULATION
 382 void start_thread_ia32(struct pt_regs *regs, u32 new_ip, u32 new_sp)
 383 {
 384         start_thread_common(regs, new_ip, new_sp,
 385                             __USER32_CS, __USER32_DS, __USER32_DS);
 386 }
 387 #endif
 388
 389 /*
 390  *      switch_to(x,y) should switch tasks from x to y.
 391  *
 392  * This could still be optimized:
 393  * - fold all the options into a flag word and test it with a single test.
 394  * - could test fs/gs bitsliced
 395  *
 396  * Kprobes not supported here. Set the probe on schedule instead.
 397  * Function graph tracer not supported too.
 398  */
 399 __notrace_funcgraph struct task_struct *
 400 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 401 {
 402         struct thread_struct *prev = &prev_p->thread;
 403         struct thread_struct *next = &next_p->thread;
 404         int cpu = smp_processor_id();
 405         struct tss_struct *tss = &per_cpu(init_tss, cpu);
 406         unsigned fsindex, gsindex;
 407         bool preload_fpu;
 408
 409         /*
 410          * If the task has used fpu the last 5 timeslices, just do a full
 411          * restore of the math state immediately to avoid the trap; the
 412          * chances of needing FPU soon are obviously high now
 413          */
 414         preload_fpu = tsk_used_math(next_p) && next_p->fpu_counter > 5;
 415
 416         /* we're going to use this soon, after a few expensive things */
 417         if (preload_fpu)
 418                 prefetch(next->xstate);
 419
 420         /*
 421          * Reload esp0, LDT and the page table pointer:
 422          */
 423         load_sp0(tss, next);
 424
 425         /*
 426          * Switch DS and ES.
 427          * This won't pick up thread selector changes, but I guess that is ok.
 428          */
 429         savesegment(es, prev->es);
 430         if (unlikely(next->es | prev->es))
 431                 loadsegment(es, next->es);
 432
 433         savesegment(ds, prev->ds);
 434         if (unlikely(next->ds | prev->ds))
 435                 loadsegment(ds, next->ds);
 436
 437
 438         /* We must save %fs and %gs before load_TLS() because
 439          * %fs and %gs may be cleared by load_TLS().
 440          *
 441          * (e.g. xen_load_tls())
 442          */
 443         savesegment(fs, fsindex);
 444         savesegment(gs, gsindex);
 445
 446         load_TLS(next, cpu);
 447
 448         /* Must be after DS reload */
 449         unlazy_fpu(prev_p);
 450
 451         /* Make sure cpu is ready for new context */
 452         if (preload_fpu)
 453                 clts();
 454
 455         /*
 456          * Leave lazy mode, flushing any hypercalls made here.
 457          * This must be done before restoring TLS segments so
 458          * the GDT and LDT are properly updated, and must be
 459          * done before math_state_restore, so the TS bit is up
 460          * to date.
 461          */
 462         arch_end_context_switch(next_p);
 463
 464         /*
 465          * Switch FS and GS.
 466          *
 467          * Segment register != 0 always requires a reload.  Also
 468          * reload when it has changed.  When prev process used 64bit
 469          * base always reload to avoid an information leak.
 470          */
 471         if (unlikely(fsindex | next->fsindex | prev->fs)) {
 472                 loadsegment(fs, next->fsindex);
 473                 /*
 474                  * Check if the user used a selector != 0; if yes
 475                  *  clear 64bit base, since overloaded base is always
 476                  *  mapped to the Null selector
 477                  */
 478                 if (fsindex)
 479                         prev->fs = 0;
 480         }
 481         /* when next process has a 64bit base use it */
 482         if (next->fs)
 483                 wrmsrl(MSR_FS_BASE, next->fs);
 484         prev->fsindex = fsindex;
 485
 486         if (unlikely(gsindex | next->gsindex | prev->gs)) {
 487                 load_gs_index(next->gsindex);
 488                 if (gsindex)
 489                         prev->gs = 0;
 490         }
 491         if (next->gs)
 492                 wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 493         prev->gsindex = gsindex;
 494
 495         /*
 496          * Switch the PDA and FPU contexts.
 497          */
 498         prev->usersp = percpu_read(old_rsp);
 499         percpu_write(old_rsp, next->usersp);
 500         percpu_write(current_task, next_p);
 501
 502         percpu_write(kernel_stack,
 503                   (unsigned long)task_stack_page(next_p) +
 504                   THREAD_SIZE - KERNEL_STACK_OFFSET);
 505
 506         /*
 507          * Now maybe reload the debug registers and handle I/O bitmaps
 508          */
 509         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
 510                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
 511                 __switch_to_xtra(prev_p, next_p, tss);
 512
 513         /*
 514          * Preload the FPU context, now that we've determined that the
 515          * task is likely to be using it.
 516          */
 517         if (preload_fpu)
 518                 __math_state_restore();
 519
 520         return prev_p;
 521 }
 522
 523 /*
 524  * sys_execve() executes a new program.
 525  */
 526 asmlinkage
 527 long sys_execve(char __user *name, char __user * __user *argv,
 528                 char __user * __user *envp, struct pt_regs *regs)
 529 {
 530         long error;
 531         char *filename;
 532
 533         filename = getname(name);
 534         error = PTR_ERR(filename);
 535         if (IS_ERR(filename))
 536                 return error;
 537         error = do_execve(filename, argv, envp, regs);
 538         putname(filename);
 539         return error;
 540 }
 541
 542 void set_personality_64bit(void)
 543 {
 544         /* inherit personality from parent */
 545
 546         /* Make sure to be in 64bit mode */
 547         clear_thread_flag(TIF_IA32);
 548
 549         /* TBD: overwrites user setup. Should have two bits.
 550            But 64bit processes have always behaved this way,
 551            so it's not too bad. The main problem is just that
 552            32bit childs are affected again. */
 553         current->personality &= ~READ_IMPLIES_EXEC;
 554 }
 555
 556 asmlinkage long
 557 sys_clone(unsigned long clone_flags, unsigned long newsp,
 558           void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
 559 {
 560         if (!newsp)
 561                 newsp = regs->sp;
 562         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
 563 }
 564
 565 unsigned long get_wchan(struct task_struct *p)
 566 {
 567         unsigned long stack;
 568         u64 fp, ip;
 569         int count = 0;
 570
 571         if (!p || p == current || p->state == TASK_RUNNING)
 572                 return 0;
 573         stack = (unsigned long)task_stack_page(p);
 574         if (p->thread.sp < stack || p->thread.sp >= stack+THREAD_SIZE)
 575                 return 0;
 576         fp = *(u64 *)(p->thread.sp);
 577         do {
 578                 if (fp < (unsigned long)stack ||
 579                     fp >= (unsigned long)stack+THREAD_SIZE)
 580                         return 0;
 581                 ip = *(u64 *)(fp+8);
 582                 if (!in_sched_functions(ip))
 583                         return ip;
 584                 fp = *(u64 *)fp;
 585         } while (count++ < 16);
 586         return 0;
 587 }
 588
 589 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 590 {
 591         int ret = 0;
 592         int doit = task == current;
 593         int cpu;
 594
 595         switch (code) {
 596         case ARCH_SET_GS:
 597                 if (addr >= TASK_SIZE_OF(task))
 598                         return -EPERM;
 599                 cpu = get_cpu();
 600                 /* handle small bases via the GDT because that's faster to
 601                    switch. */
 602                 if (addr <= 0xffffffff) {
 603                         set_32bit_tls(task, GS_TLS, addr);
 604                         if (doit) {
 605                                 load_TLS(&task->thread, cpu);
 606                                 load_gs_index(GS_TLS_SEL);
 607                         }
 608                         task->thread.gsindex = GS_TLS_SEL;
 609                         task->thread.gs = 0;
 610                 } else {
 611                         task->thread.gsindex = 0;
 612                         task->thread.gs = addr;
 613                         if (doit) {
 614                                 load_gs_index(0);
 615                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 616                         }
 617                 }
 618                 put_cpu();
 619                 break;
 620         case ARCH_SET_FS:
 621                 /* Not strictly needed for fs, but do it for symmetry
 622                    with gs */
 623                 if (addr >= TASK_SIZE_OF(task))
 624                         return -EPERM;
 625                 cpu = get_cpu();
 626                 /* handle small bases via the GDT because that's faster to
 627                    switch. */
 628                 if (addr <= 0xffffffff) {
 629                         set_32bit_tls(task, FS_TLS, addr);
 630                         if (doit) {
 631                                 load_TLS(&task->thread, cpu);
 632                                 loadsegment(fs, FS_TLS_SEL);
 633                         }
 634                         task->thread.fsindex = FS_TLS_SEL;
 635                         task->thread.fs = 0;
 636                 } else {
 637                         task->thread.fsindex = 0;
 638                         task->thread.fs = addr;
 639                         if (doit) {
 640                                 /* set the selector to 0 to not confuse
 641                                    __switch_to */
 642                                 loadsegment(fs, 0);
 643                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 644                         }
 645                 }
 646                 put_cpu();
 647                 break;
 648         case ARCH_GET_FS: {
 649                 unsigned long base;
 650                 if (task->thread.fsindex == FS_TLS_SEL)
 651                         base = read_32bit_tls(task, FS_TLS);
 652                 else if (doit)
 653                         rdmsrl(MSR_FS_BASE, base);
 654                 else
 655                         base = task->thread.fs;
 656                 ret = put_user(base, (unsigned long __user *)addr);
 657                 break;
 658         }
 659         case ARCH_GET_GS: {
 660                 unsigned long base;
 661                 unsigned gsindex;
 662                 if (task->thread.gsindex == GS_TLS_SEL)
 663                         base = read_32bit_tls(task, GS_TLS);
 664                 else if (doit) {
 665                         savesegment(gs, gsindex);
 666                         if (gsindex)
 667                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
 668                         else
 669                                 base = task->thread.gs;
 670                 } else
 671                         base = task->thread.gs;
 672                 ret = put_user(base, (unsigned long __user *)addr);
 673                 break;
 674         }
 675
 676         default:
 677                 ret = -EINVAL;
 678                 break;
 679         }
 680
 681         return ret;
 682 }
 683
 684 long sys_arch_prctl(int code, unsigned long addr)
 685 {
 686         return do_arch_prctl(current, code, addr);
 687 }
 688
 689 unsigned long KSTK_ESP(struct task_struct *task)
 690 {
 691         return (test_tsk_thread_flag(task, TIF_IA32)) ?
 692                         (task_pt_regs(task)->sp) : ((task)->thread.usersp);
 693 }