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