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  *      CPU hotplug support - ashok.raj@intel.com
  13  */
  14
  15 /*
  16  * This file handles the architecture-dependent parts of process handling..
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include <linux/cpu.h>
  22 #include <linux/errno.h>
  23 #include <linux/sched.h>
  24 #include <linux/kernel.h>
  25 #include <linux/mm.h>
  26 #include <linux/elfcore.h>
  27 #include <linux/smp.h>
  28 #include <linux/slab.h>
  29 #include <linux/user.h>
  30 #include <linux/module.h>
  31 #include <linux/a.out.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/delay.h>
  34 #include <linux/ptrace.h>
  35 #include <linux/utsname.h>
  36 #include <linux/random.h>
  37 #include <linux/notifier.h>
  38 #include <linux/kprobes.h>
  39
  40 #include <asm/uaccess.h>
  41 #include <asm/pgtable.h>
  42 #include <asm/system.h>
  43 #include <asm/io.h>
  44 #include <asm/processor.h>
  45 #include <asm/i387.h>
  46 #include <asm/mmu_context.h>
  47 #include <asm/pda.h>
  48 #include <asm/prctl.h>
  49 #include <asm/kdebug.h>
  50 #include <asm/desc.h>
  51 #include <asm/proto.h>
  52 #include <asm/ia32.h>
  53 #include <asm/idle.h>
  54
  55 asmlinkage extern void ret_from_fork(void);
  56
  57 unsigned long kernel_thread_flags = CLONE_VM | CLONE_UNTRACED;
  58
  59 unsigned long boot_option_idle_override = 0;
  60 EXPORT_SYMBOL(boot_option_idle_override);
  61
  62 /*
  63  * Powermanagement idle function, if any..
  64  */
  65 void (*pm_idle)(void);
  66 EXPORT_SYMBOL(pm_idle);
  67 static DEFINE_PER_CPU(unsigned int, cpu_idle_state);
  68
  69 static ATOMIC_NOTIFIER_HEAD(idle_notifier);
  70
  71 void idle_notifier_register(struct notifier_block *n)
  72 {
  73         atomic_notifier_chain_register(&idle_notifier, n);
  74 }
  75 EXPORT_SYMBOL_GPL(idle_notifier_register);
  76
  77 void idle_notifier_unregister(struct notifier_block *n)
  78 {
  79         atomic_notifier_chain_unregister(&idle_notifier, n);
  80 }
  81 EXPORT_SYMBOL(idle_notifier_unregister);
  82
  83 void enter_idle(void)
  84 {
  85         write_pda(isidle, 1);
  86         atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
  87 }
  88
  89 static void __exit_idle(void)
  90 {
  91         if (test_and_clear_bit_pda(0, isidle) == 0)
  92                 return;
  93         atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
  94 }
  95
  96 /* Called from interrupts to signify idle end */
  97 void exit_idle(void)
  98 {
  99         /* idle loop has pid 0 */
 100         if (current->pid)
 101                 return;
 102         __exit_idle();
 103 }
 104
 105 /*
 106  * We use this if we don't have any better
 107  * idle routine..
 108  */
 109 static void default_idle(void)
 110 {
 111         current_thread_info()->status &= ~TS_POLLING;
 112         /*
 113          * TS_POLLING-cleared state must be visible before we
 114          * test NEED_RESCHED:
 115          */
 116         smp_mb();
 117         local_irq_disable();
 118         if (!need_resched()) {
 119                 /* Enables interrupts one instruction before HLT.
 120                    x86 special cases this so there is no race. */
 121                 safe_halt();
 122         } else
 123                 local_irq_enable();
 124         current_thread_info()->status |= TS_POLLING;
 125 }
 126
 127 /*
 128  * On SMP it's slightly faster (but much more power-consuming!)
 129  * to poll the ->need_resched flag instead of waiting for the
 130  * cross-CPU IPI to arrive. Use this option with caution.
 131  */
 132 static void poll_idle (void)
 133 {
 134         local_irq_enable();
 135         cpu_relax();
 136 }
 137
 138 void cpu_idle_wait(void)
 139 {
 140         unsigned int cpu, this_cpu = get_cpu();
 141         cpumask_t map, tmp = current->cpus_allowed;
 142
 143         set_cpus_allowed(current, cpumask_of_cpu(this_cpu));
 144         put_cpu();
 145
 146         cpus_clear(map);
 147         for_each_online_cpu(cpu) {
 148                 per_cpu(cpu_idle_state, cpu) = 1;
 149                 cpu_set(cpu, map);
 150         }
 151
 152         __get_cpu_var(cpu_idle_state) = 0;
 153
 154         wmb();
 155         do {
 156                 ssleep(1);
 157                 for_each_online_cpu(cpu) {
 158                         if (cpu_isset(cpu, map) &&
 159                                         !per_cpu(cpu_idle_state, cpu))
 160                                 cpu_clear(cpu, map);
 161                 }
 162                 cpus_and(map, map, cpu_online_map);
 163         } while (!cpus_empty(map));
 164
 165         set_cpus_allowed(current, tmp);
 166 }
 167 EXPORT_SYMBOL_GPL(cpu_idle_wait);
 168
 169 #ifdef CONFIG_HOTPLUG_CPU
 170 DECLARE_PER_CPU(int, cpu_state);
 171
 172 #include <asm/nmi.h>
 173 /* We halt the CPU with physical CPU hotplug */
 174 static inline void play_dead(void)
 175 {
 176         idle_task_exit();
 177         wbinvd();
 178         mb();
 179         /* Ack it */
 180         __get_cpu_var(cpu_state) = CPU_DEAD;
 181
 182         local_irq_disable();
 183         while (1)
 184                 halt();
 185 }
 186 #else
 187 static inline void play_dead(void)
 188 {
 189         BUG();
 190 }
 191 #endif /* CONFIG_HOTPLUG_CPU */
 192
 193 /*
 194  * The idle thread. There's no useful work to be
 195  * done, so just try to conserve power and have a
 196  * low exit latency (ie sit in a loop waiting for
 197  * somebody to say that they'd like to reschedule)
 198  */
 199 void cpu_idle (void)
 200 {
 201         current_thread_info()->status |= TS_POLLING;
 202         /* endless idle loop with no priority at all */
 203         while (1) {
 204                 while (!need_resched()) {
 205                         void (*idle)(void);
 206
 207                         if (__get_cpu_var(cpu_idle_state))
 208                                 __get_cpu_var(cpu_idle_state) = 0;
 209
 210                         rmb();
 211                         idle = pm_idle;
 212                         if (!idle)
 213                                 idle = default_idle;
 214                         if (cpu_is_offline(smp_processor_id()))
 215                                 play_dead();
 216                         /*
 217                          * Idle routines should keep interrupts disabled
 218                          * from here on, until they go to idle.
 219                          * Otherwise, idle callbacks can misfire.
 220                          */
 221                         local_irq_disable();
 222                         enter_idle();
 223                         idle();
 224                         /* In many cases the interrupt that ended idle
 225                            has already called exit_idle. But some idle
 226                            loops can be woken up without interrupt. */
 227                         __exit_idle();
 228                 }
 229
 230                 preempt_enable_no_resched();
 231                 schedule();
 232                 preempt_disable();
 233         }
 234 }
 235
 236 /*
 237  * This uses new MONITOR/MWAIT instructions on P4 processors with PNI,
 238  * which can obviate IPI to trigger checking of need_resched.
 239  * We execute MONITOR against need_resched and enter optimized wait state
 240  * through MWAIT. Whenever someone changes need_resched, we would be woken
 241  * up from MWAIT (without an IPI).
 242  *
 243  * New with Core Duo processors, MWAIT can take some hints based on CPU
 244  * capability.
 245  */
 246 void mwait_idle_with_hints(unsigned long eax, unsigned long ecx)
 247 {
 248         if (!need_resched()) {
 249                 __monitor((void *)&current_thread_info()->flags, 0, 0);
 250                 smp_mb();
 251                 if (!need_resched())
 252                         __mwait(eax, ecx);
 253         }
 254 }
 255
 256 /* Default MONITOR/MWAIT with no hints, used for default C1 state */
 257 static void mwait_idle(void)
 258 {
 259         if (!need_resched()) {
 260                 __monitor((void *)&current_thread_info()->flags, 0, 0);
 261                 smp_mb();
 262                 if (!need_resched())
 263                         __sti_mwait(0, 0);
 264                 else
 265                         local_irq_enable();
 266         } else {
 267                 local_irq_enable();
 268         }
 269 }
 270
 271 void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c)
 272 {
 273         static int printed;
 274         if (cpu_has(c, X86_FEATURE_MWAIT)) {
 275                 /*
 276                  * Skip, if setup has overridden idle.
 277                  * One CPU supports mwait => All CPUs supports mwait
 278                  */
 279                 if (!pm_idle) {
 280                         if (!printed) {
 281                                 printk("using mwait in idle threads.\n");
 282                                 printed = 1;
 283                         }
 284                         pm_idle = mwait_idle;
 285                 }
 286         }
 287 }
 288
 289 static int __init idle_setup (char *str)
 290 {
 291         if (!strncmp(str, "poll", 4)) {
 292                 printk("using polling idle threads.\n");
 293                 pm_idle = poll_idle;
 294         }
 295
 296         boot_option_idle_override = 1;
 297         return 1;
 298 }
 299
 300 __setup("idle=", idle_setup);
 301
 302 /* Prints also some state that isn't saved in the pt_regs */
 303 void __show_regs(struct pt_regs * regs)
 304 {
 305         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
 306         unsigned int fsindex,gsindex;
 307         unsigned int ds,cs,es;
 308
 309         printk("\n");
 310         print_modules();
 311         printk("Pid: %d, comm: %.20s %s %s %.*s\n",
 312                 current->pid, current->comm, print_tainted(),
 313                 init_utsname()->release,
 314                 (int)strcspn(init_utsname()->version, " "),
 315                 init_utsname()->version);
 316         printk("RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->rip);
 317         printk_address(regs->rip);
 318         printk("RSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss, regs->rsp,
 319                 regs->eflags);
 320         printk("RAX: %016lx RBX: %016lx RCX: %016lx\n",
 321                regs->rax, regs->rbx, regs->rcx);
 322         printk("RDX: %016lx RSI: %016lx RDI: %016lx\n",
 323                regs->rdx, regs->rsi, regs->rdi);
 324         printk("RBP: %016lx R08: %016lx R09: %016lx\n",
 325                regs->rbp, regs->r8, regs->r9);
 326         printk("R10: %016lx R11: %016lx R12: %016lx\n",
 327                regs->r10, regs->r11, regs->r12);
 328         printk("R13: %016lx R14: %016lx R15: %016lx\n",
 329                regs->r13, regs->r14, regs->r15);
 330
 331         asm("movl %%ds,%0" : "=r" (ds));
 332         asm("movl %%cs,%0" : "=r" (cs));
 333         asm("movl %%es,%0" : "=r" (es));
 334         asm("movl %%fs,%0" : "=r" (fsindex));
 335         asm("movl %%gs,%0" : "=r" (gsindex));
 336
 337         rdmsrl(MSR_FS_BASE, fs);
 338         rdmsrl(MSR_GS_BASE, gs);
 339         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
 340
 341         asm("movq %%cr0, %0": "=r" (cr0));
 342         asm("movq %%cr2, %0": "=r" (cr2));
 343         asm("movq %%cr3, %0": "=r" (cr3));
 344         asm("movq %%cr4, %0": "=r" (cr4));
 345
 346         printk("FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
 347                fs,fsindex,gs,gsindex,shadowgs);
 348         printk("CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds, es, cr0);
 349         printk("CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3, cr4);
 350 }
 351
 352 void show_regs(struct pt_regs *regs)
 353 {
 354         printk("CPU %d:", smp_processor_id());
 355         __show_regs(regs);
 356         show_trace(NULL, regs, (void *)(regs + 1));
 357 }
 358
 359 /*
 360  * Free current thread data structures etc..
 361  */
 362 void exit_thread(void)
 363 {
 364         struct task_struct *me = current;
 365         struct thread_struct *t = &me->thread;
 366
 367         if (me->thread.io_bitmap_ptr) {
 368                 struct tss_struct *tss = &per_cpu(init_tss, get_cpu());
 369
 370                 kfree(t->io_bitmap_ptr);
 371                 t->io_bitmap_ptr = NULL;
 372                 clear_thread_flag(TIF_IO_BITMAP);
 373                 /*
 374                  * Careful, clear this in the TSS too:
 375                  */
 376                 memset(tss->io_bitmap, 0xff, t->io_bitmap_max);
 377                 t->io_bitmap_max = 0;
 378                 put_cpu();
 379         }
 380 }
 381
 382 void flush_thread(void)
 383 {
 384         struct task_struct *tsk = current;
 385         struct thread_info *t = current_thread_info();
 386
 387         if (t->flags & _TIF_ABI_PENDING) {
 388                 t->flags ^= (_TIF_ABI_PENDING | _TIF_IA32);
 389                 if (t->flags & _TIF_IA32)
 390                         current_thread_info()->status |= TS_COMPAT;
 391         }
 392         t->flags &= ~_TIF_DEBUG;
 393
 394         tsk->thread.debugreg0 = 0;
 395         tsk->thread.debugreg1 = 0;
 396         tsk->thread.debugreg2 = 0;
 397         tsk->thread.debugreg3 = 0;
 398         tsk->thread.debugreg6 = 0;
 399         tsk->thread.debugreg7 = 0;
 400         memset(tsk->thread.tls_array, 0, sizeof(tsk->thread.tls_array));
 401         /*
 402          * Forget coprocessor state..
 403          */
 404         clear_fpu(tsk);
 405         clear_used_math();
 406 }
 407
 408 void release_thread(struct task_struct *dead_task)
 409 {
 410         if (dead_task->mm) {
 411                 if (dead_task->mm->context.size) {
 412                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
 413                                         dead_task->comm,
 414                                         dead_task->mm->context.ldt,
 415                                         dead_task->mm->context.size);
 416                         BUG();
 417                 }
 418         }
 419 }
 420
 421 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
 422 {
 423         struct user_desc ud = {
 424                 .base_addr = addr,
 425                 .limit = 0xfffff,
 426                 .seg_32bit = 1,
 427                 .limit_in_pages = 1,
 428                 .useable = 1,
 429         };
 430         struct n_desc_struct *desc = (void *)t->thread.tls_array;
 431         desc += tls;
 432         desc->a = LDT_entry_a(&ud);
 433         desc->b = LDT_entry_b(&ud);
 434 }
 435
 436 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
 437 {
 438         struct desc_struct *desc = (void *)t->thread.tls_array;
 439         desc += tls;
 440         return desc->base0 |
 441                 (((u32)desc->base1) << 16) |
 442                 (((u32)desc->base2) << 24);
 443 }
 444
 445 /*
 446  * This gets called before we allocate a new thread and copy
 447  * the current task into it.
 448  */
 449 void prepare_to_copy(struct task_struct *tsk)
 450 {
 451         unlazy_fpu(tsk);
 452 }
 453
 454 int copy_thread(int nr, unsigned long clone_flags, unsigned long rsp,
 455                 unsigned long unused,
 456         struct task_struct * p, struct pt_regs * regs)
 457 {
 458         int err;
 459         struct pt_regs * childregs;
 460         struct task_struct *me = current;
 461
 462         childregs = ((struct pt_regs *)
 463                         (THREAD_SIZE + task_stack_page(p))) - 1;
 464         *childregs = *regs;
 465
 466         childregs->rax = 0;
 467         childregs->rsp = rsp;
 468         if (rsp == ~0UL)
 469                 childregs->rsp = (unsigned long)childregs;
 470
 471         p->thread.rsp = (unsigned long) childregs;
 472         p->thread.rsp0 = (unsigned long) (childregs+1);
 473         p->thread.userrsp = me->thread.userrsp;
 474
 475         set_tsk_thread_flag(p, TIF_FORK);
 476
 477         p->thread.fs = me->thread.fs;
 478         p->thread.gs = me->thread.gs;
 479
 480         asm("mov %%gs,%0" : "=m" (p->thread.gsindex));
 481         asm("mov %%fs,%0" : "=m" (p->thread.fsindex));
 482         asm("mov %%es,%0" : "=m" (p->thread.es));
 483         asm("mov %%ds,%0" : "=m" (p->thread.ds));
 484
 485         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
 486                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
 487                 if (!p->thread.io_bitmap_ptr) {
 488                         p->thread.io_bitmap_max = 0;
 489                         return -ENOMEM;
 490                 }
 491                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr,
 492                                 IO_BITMAP_BYTES);
 493                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
 494         }
 495
 496         /*
 497          * Set a new TLS for the child thread?
 498          */
 499         if (clone_flags & CLONE_SETTLS) {
 500 #ifdef CONFIG_IA32_EMULATION
 501                 if (test_thread_flag(TIF_IA32))
 502                         err = ia32_child_tls(p, childregs);
 503                 else
 504 #endif
 505                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
 506                 if (err)
 507                         goto out;
 508         }
 509         err = 0;
 510 out:
 511         if (err && p->thread.io_bitmap_ptr) {
 512                 kfree(p->thread.io_bitmap_ptr);
 513                 p->thread.io_bitmap_max = 0;
 514         }
 515         return err;
 516 }
 517
 518 /*
 519  * This special macro can be used to load a debugging register
 520  */
 521 #define loaddebug(thread,r) set_debugreg(thread->debugreg ## r, r)
 522
 523 static inline void __switch_to_xtra(struct task_struct *prev_p,
 524                                     struct task_struct *next_p,
 525                                     struct tss_struct *tss)
 526 {
 527         struct thread_struct *prev, *next;
 528
 529         prev = &prev_p->thread,
 530         next = &next_p->thread;
 531
 532         if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
 533                 loaddebug(next, 0);
 534                 loaddebug(next, 1);
 535                 loaddebug(next, 2);
 536                 loaddebug(next, 3);
 537                 /* no 4 and 5 */
 538                 loaddebug(next, 6);
 539                 loaddebug(next, 7);
 540         }
 541
 542         if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) {
 543                 /*
 544                  * Copy the relevant range of the IO bitmap.
 545                  * Normally this is 128 bytes or less:
 546                  */
 547                 memcpy(tss->io_bitmap, next->io_bitmap_ptr,
 548                        max(prev->io_bitmap_max, next->io_bitmap_max));
 549         } else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) {
 550                 /*
 551                  * Clear any possible leftover bits:
 552                  */
 553                 memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
 554         }
 555 }
 556
 557 /*
 558  *      switch_to(x,y) should switch tasks from x to y.
 559  *
 560  * This could still be optimized:
 561  * - fold all the options into a flag word and test it with a single test.
 562  * - could test fs/gs bitsliced
 563  *
 564  * Kprobes not supported here. Set the probe on schedule instead.
 565  */
 566 __kprobes struct task_struct *
 567 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 568 {
 569         struct thread_struct *prev = &prev_p->thread,
 570                                  *next = &next_p->thread;
 571         int cpu = smp_processor_id();
 572         struct tss_struct *tss = &per_cpu(init_tss, cpu);
 573
 574         /* we're going to use this soon, after a few expensive things */
 575         if (next_p->fpu_counter>5)
 576                 prefetch(&next->i387.fxsave);
 577
 578         /*
 579          * Reload esp0, LDT and the page table pointer:
 580          */
 581         tss->rsp0 = next->rsp0;
 582
 583         /*
 584          * Switch DS and ES.
 585          * This won't pick up thread selector changes, but I guess that is ok.
 586          */
 587         asm volatile("mov %%es,%0" : "=m" (prev->es));
 588         if (unlikely(next->es | prev->es))
 589                 loadsegment(es, next->es);
 590
 591         asm volatile ("mov %%ds,%0" : "=m" (prev->ds));
 592         if (unlikely(next->ds | prev->ds))
 593                 loadsegment(ds, next->ds);
 594
 595         load_TLS(next, cpu);
 596
 597         /*
 598          * Switch FS and GS.
 599          */
 600         {
 601                 unsigned fsindex;
 602                 asm volatile("movl %%fs,%0" : "=r" (fsindex));
 603                 /* segment register != 0 always requires a reload.
 604                    also reload when it has changed.
 605                    when prev process used 64bit base always reload
 606                    to avoid an information leak. */
 607                 if (unlikely(fsindex | next->fsindex | prev->fs)) {
 608                         loadsegment(fs, next->fsindex);
 609                         /* check if the user used a selector != 0
 610                          * if yes clear 64bit base, since overloaded base
 611                          * is always mapped to the Null selector
 612                          */
 613                         if (fsindex)
 614                         prev->fs = 0;
 615                 }
 616                 /* when next process has a 64bit base use it */
 617                 if (next->fs)
 618                         wrmsrl(MSR_FS_BASE, next->fs);
 619                 prev->fsindex = fsindex;
 620         }
 621         {
 622                 unsigned gsindex;
 623                 asm volatile("movl %%gs,%0" : "=r" (gsindex));
 624                 if (unlikely(gsindex | next->gsindex | prev->gs)) {
 625                         load_gs_index(next->gsindex);
 626                         if (gsindex)
 627                         prev->gs = 0;
 628                 }
 629                 if (next->gs)
 630                         wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 631                 prev->gsindex = gsindex;
 632         }
 633
 634         /* Must be after DS reload */
 635         unlazy_fpu(prev_p);
 636
 637         /*
 638          * Switch the PDA and FPU contexts.
 639          */
 640         prev->userrsp = read_pda(oldrsp);
 641         write_pda(oldrsp, next->userrsp);
 642         write_pda(pcurrent, next_p);
 643
 644         write_pda(kernelstack,
 645         (unsigned long)task_stack_page(next_p) + THREAD_SIZE - PDA_STACKOFFSET);
 646 #ifdef CONFIG_CC_STACKPROTECTOR
 647         write_pda(stack_canary, next_p->stack_canary);
 648         /*
 649          * Build time only check to make sure the stack_canary is at
 650          * offset 40 in the pda; this is a gcc ABI requirement
 651          */
 652         BUILD_BUG_ON(offsetof(struct x8664_pda, stack_canary) != 40);
 653 #endif
 654
 655         /*
 656          * Now maybe reload the debug registers and handle I/O bitmaps
 657          */
 658         if (unlikely((task_thread_info(next_p)->flags & _TIF_WORK_CTXSW))
 659             || test_tsk_thread_flag(prev_p, TIF_IO_BITMAP))
 660                 __switch_to_xtra(prev_p, next_p, tss);
 661
 662         /* If the task has used fpu the last 5 timeslices, just do a full
 663          * restore of the math state immediately to avoid the trap; the
 664          * chances of needing FPU soon are obviously high now
 665          */
 666         if (next_p->fpu_counter>5)
 667                 math_state_restore();
 668         return prev_p;
 669 }
 670
 671 /*
 672  * sys_execve() executes a new program.
 673  */
 674 asmlinkage
 675 long sys_execve(char __user *name, char __user * __user *argv,
 676                 char __user * __user *envp, struct pt_regs regs)
 677 {
 678         long error;
 679         char * filename;
 680
 681         filename = getname(name);
 682         error = PTR_ERR(filename);
 683         if (IS_ERR(filename))
 684                 return error;
 685         error = do_execve(filename, argv, envp, &regs);
 686         if (error == 0) {
 687                 task_lock(current);
 688                 current->ptrace &= ~PT_DTRACE;
 689                 task_unlock(current);
 690         }
 691         putname(filename);
 692         return error;
 693 }
 694
 695 void set_personality_64bit(void)
 696 {
 697         /* inherit personality from parent */
 698
 699         /* Make sure to be in 64bit mode */
 700         clear_thread_flag(TIF_IA32);
 701
 702         /* TBD: overwrites user setup. Should have two bits.
 703            But 64bit processes have always behaved this way,
 704            so it's not too bad. The main problem is just that
 705            32bit childs are affected again. */
 706         current->personality &= ~READ_IMPLIES_EXEC;
 707 }
 708
 709 asmlinkage long sys_fork(struct pt_regs *regs)
 710 {
 711         return do_fork(SIGCHLD, regs->rsp, regs, 0, NULL, NULL);
 712 }
 713
 714 asmlinkage long
 715 sys_clone(unsigned long clone_flags, unsigned long newsp,
 716           void __user *parent_tid, void __user *child_tid, struct pt_regs *regs)
 717 {
 718         if (!newsp)
 719                 newsp = regs->rsp;
 720         return do_fork(clone_flags, newsp, regs, 0, parent_tid, child_tid);
 721 }
 722
 723 /*
 724  * This is trivial, and on the face of it looks like it
 725  * could equally well be done in user mode.
 726  *
 727  * Not so, for quite unobvious reasons - register pressure.
 728  * In user mode vfork() cannot have a stack frame, and if
 729  * done by calling the "clone()" system call directly, you
 730  * do not have enough call-clobbered registers to hold all
 731  * the information you need.
 732  */
 733 asmlinkage long sys_vfork(struct pt_regs *regs)
 734 {
 735         return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->rsp, regs, 0,
 736                     NULL, NULL);
 737 }
 738
 739 unsigned long get_wchan(struct task_struct *p)
 740 {
 741         unsigned long stack;
 742         u64 fp,rip;
 743         int count = 0;
 744
 745         if (!p || p == current || p->state==TASK_RUNNING)
 746                 return 0;
 747         stack = (unsigned long)task_stack_page(p);
 748         if (p->thread.rsp < stack || p->thread.rsp > stack+THREAD_SIZE)
 749                 return 0;
 750         fp = *(u64 *)(p->thread.rsp);
 751         do {
 752                 if (fp < (unsigned long)stack ||
 753                     fp > (unsigned long)stack+THREAD_SIZE)
 754                         return 0;
 755                 rip = *(u64 *)(fp+8);
 756                 if (!in_sched_functions(rip))
 757                         return rip;
 758                 fp = *(u64 *)fp;
 759         } while (count++ < 16);
 760         return 0;
 761 }
 762
 763 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 764 {
 765         int ret = 0;
 766         int doit = task == current;
 767         int cpu;
 768
 769         switch (code) {
 770         case ARCH_SET_GS:
 771                 if (addr >= TASK_SIZE_OF(task))
 772                         return -EPERM;
 773                 cpu = get_cpu();
 774                 /* handle small bases via the GDT because that's faster to
 775                    switch. */
 776                 if (addr <= 0xffffffff) {
 777                         set_32bit_tls(task, GS_TLS, addr);
 778                         if (doit) {
 779                                 load_TLS(&task->thread, cpu);
 780                                 load_gs_index(GS_TLS_SEL);
 781                         }
 782                         task->thread.gsindex = GS_TLS_SEL;
 783                         task->thread.gs = 0;
 784                 } else {
 785                         task->thread.gsindex = 0;
 786                         task->thread.gs = addr;
 787                         if (doit) {
 788                                 load_gs_index(0);
 789                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 790                         }
 791                 }
 792                 put_cpu();
 793                 break;
 794         case ARCH_SET_FS:
 795                 /* Not strictly needed for fs, but do it for symmetry
 796                    with gs */
 797                 if (addr >= TASK_SIZE_OF(task))
 798                         return -EPERM;
 799                 cpu = get_cpu();
 800                 /* handle small bases via the GDT because that's faster to
 801                    switch. */
 802                 if (addr <= 0xffffffff) {
 803                         set_32bit_tls(task, FS_TLS, addr);
 804                         if (doit) {
 805                                 load_TLS(&task->thread, cpu);
 806                                 asm volatile("movl %0,%%fs" :: "r"(FS_TLS_SEL));
 807                         }
 808                         task->thread.fsindex = FS_TLS_SEL;
 809                         task->thread.fs = 0;
 810                 } else {
 811                         task->thread.fsindex = 0;
 812                         task->thread.fs = addr;
 813                         if (doit) {
 814                                 /* set the selector to 0 to not confuse
 815                                    __switch_to */
 816                                 asm volatile("movl %0,%%fs" :: "r" (0));
 817                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 818                         }
 819                 }
 820                 put_cpu();
 821                 break;
 822         case ARCH_GET_FS: {
 823                 unsigned long base;
 824                 if (task->thread.fsindex == FS_TLS_SEL)
 825                         base = read_32bit_tls(task, FS_TLS);
 826                 else if (doit)
 827                         rdmsrl(MSR_FS_BASE, base);
 828                 else
 829                         base = task->thread.fs;
 830                 ret = put_user(base, (unsigned long __user *)addr);
 831                 break;
 832         }
 833         case ARCH_GET_GS: {
 834                 unsigned long base;
 835                 unsigned gsindex;
 836                 if (task->thread.gsindex == GS_TLS_SEL)
 837                         base = read_32bit_tls(task, GS_TLS);
 838                 else if (doit) {
 839                         asm("movl %%gs,%0" : "=r" (gsindex));
 840                         if (gsindex)
 841                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
 842                         else
 843                                 base = task->thread.gs;
 844                 }
 845                 else
 846                         base = task->thread.gs;
 847                 ret = put_user(base, (unsigned long __user *)addr);
 848                 break;
 849         }
 850
 851         default:
 852                 ret = -EINVAL;
 853                 break;
 854         }
 855
 856         return ret;
 857 }
 858
 859 long sys_arch_prctl(int code, unsigned long addr)
 860 {
 861         return do_arch_prctl(current, code, addr);
 862 }
 863
 864 /*
 865  * Capture the user space registers if the task is not running (in user space)
 866  */
 867 int dump_task_regs(struct task_struct *tsk, elf_gregset_t *regs)
 868 {
 869         struct pt_regs *pp, ptregs;
 870
 871         pp = task_pt_regs(tsk);
 872
 873         ptregs = *pp;
 874         ptregs.cs &= 0xffff;
 875         ptregs.ss &= 0xffff;
 876
 877         elf_core_copy_regs(regs, &ptregs);
 878
 879         return 1;
 880 }
 881
 882 unsigned long arch_align_stack(unsigned long sp)
 883 {
 884         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 885                 sp -= get_random_int() % 8192;
 886         return sp & ~0xf;
 887 }