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