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