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