Pileus Git - ~andy/linux/blob - arch/x86/kernel/process_64.c

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