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