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