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