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