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 <linux/stackprotector.h>
  18 #include <linux/cpu.h>
  19 #include <linux/errno.h>
  20 #include <linux/sched.h>
  21 #include <linux/fs.h>
  22 #include <linux/kernel.h>
  23 #include <linux/mm.h>
  24 #include <linux/elfcore.h>
  25 #include <linux/smp.h>
  26 #include <linux/slab.h>
  27 #include <linux/user.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/delay.h>
  30 #include <linux/module.h>
  31 #include <linux/ptrace.h>
  32 #include <linux/notifier.h>
  33 #include <linux/kprobes.h>
  34 #include <linux/kdebug.h>
  35 #include <linux/tick.h>
  36 #include <linux/prctl.h>
  37 #include <linux/uaccess.h>
  38 #include <linux/io.h>
  39 #include <linux/ftrace.h>
  40 #include <linux/cpuidle.h>
  41
  42 #include <asm/pgtable.h>
  43 #include <asm/system.h>
  44 #include <asm/processor.h>
  45 #include <asm/i387.h>
  46 #include <asm/fpu-internal.h>
  47 #include <asm/mmu_context.h>
  48 #include <asm/prctl.h>
  49 #include <asm/desc.h>
  50 #include <asm/proto.h>
  51 #include <asm/ia32.h>
  52 #include <asm/idle.h>
  53 #include <asm/syscalls.h>
  54 #include <asm/debugreg.h>
  55 #include <asm/nmi.h>
  56
  57 asmlinkage extern void ret_from_fork(void);
  58
  59 DEFINE_PER_CPU(unsigned long, old_rsp);
  60 static DEFINE_PER_CPU(unsigned char, is_idle);
  61
  62 static ATOMIC_NOTIFIER_HEAD(idle_notifier);
  63
  64 void idle_notifier_register(struct notifier_block *n)
  65 {
  66         atomic_notifier_chain_register(&idle_notifier, n);
  67 }
  68 EXPORT_SYMBOL_GPL(idle_notifier_register);
  69
  70 void idle_notifier_unregister(struct notifier_block *n)
  71 {
  72         atomic_notifier_chain_unregister(&idle_notifier, n);
  73 }
  74 EXPORT_SYMBOL_GPL(idle_notifier_unregister);
  75
  76 void enter_idle(void)
  77 {
  78         percpu_write(is_idle, 1);
  79         atomic_notifier_call_chain(&idle_notifier, IDLE_START, NULL);
  80 }
  81
  82 static void __exit_idle(void)
  83 {
  84         if (x86_test_and_clear_bit_percpu(0, is_idle) == 0)
  85                 return;
  86         atomic_notifier_call_chain(&idle_notifier, IDLE_END, NULL);
  87 }
  88
  89 /* Called from interrupts to signify idle end */
  90 void exit_idle(void)
  91 {
  92         /* idle loop has pid 0 */
  93         if (current->pid)
  94                 return;
  95         __exit_idle();
  96 }
  97
  98 #ifndef CONFIG_SMP
  99 static inline void play_dead(void)
 100 {
 101         BUG();
 102 }
 103 #endif
 104
 105 /*
 106  * The idle thread. There's no useful work to be
 107  * done, so just try to conserve power and have a
 108  * low exit latency (ie sit in a loop waiting for
 109  * somebody to say that they'd like to reschedule)
 110  */
 111 void cpu_idle(void)
 112 {
 113         current_thread_info()->status |= TS_POLLING;
 114
 115         /*
 116          * If we're the non-boot CPU, nothing set the stack canary up
 117          * for us.  CPU0 already has it initialized but no harm in
 118          * doing it again.  This is a good place for updating it, as
 119          * we wont ever return from this function (so the invalid
 120          * canaries already on the stack wont ever trigger).
 121          */
 122         boot_init_stack_canary();
 123
 124         /* endless idle loop with no priority at all */
 125         while (1) {
 126                 tick_nohz_idle_enter();
 127                 while (!need_resched()) {
 128
 129                         rmb();
 130
 131                         if (cpu_is_offline(smp_processor_id()))
 132                                 play_dead();
 133                         /*
 134                          * Idle routines should keep interrupts disabled
 135                          * from here on, until they go to idle.
 136                          * Otherwise, idle callbacks can misfire.
 137                          */
 138                         local_touch_nmi();
 139                         local_irq_disable();
 140                         enter_idle();
 141                         /* Don't trace irqs off for idle */
 142                         stop_critical_timings();
 143
 144                         /* enter_idle() needs rcu for notifiers */
 145                         rcu_idle_enter();
 146
 147                         if (cpuidle_idle_call())
 148                                 pm_idle();
 149
 150                         rcu_idle_exit();
 151                         start_critical_timings();
 152
 153                         /* In many cases the interrupt that ended idle
 154                            has already called exit_idle. But some idle
 155                            loops can be woken up without interrupt. */
 156                         __exit_idle();
 157                 }
 158
 159                 tick_nohz_idle_exit();
 160                 preempt_enable_no_resched();
 161                 schedule();
 162                 preempt_disable();
 163         }
 164 }
 165
 166 /* Prints also some state that isn't saved in the pt_regs */
 167 void __show_regs(struct pt_regs *regs, int all)
 168 {
 169         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
 170         unsigned long d0, d1, d2, d3, d6, d7;
 171         unsigned int fsindex, gsindex;
 172         unsigned int ds, cs, es;
 173
 174         show_regs_common();
 175         printk(KERN_DEFAULT "RIP: %04lx:[<%016lx>] ", regs->cs & 0xffff, regs->ip);
 176         printk_address(regs->ip, 1);
 177         printk(KERN_DEFAULT "RSP: %04lx:%016lx  EFLAGS: %08lx\n", regs->ss,
 178                         regs->sp, regs->flags);
 179         printk(KERN_DEFAULT "RAX: %016lx RBX: %016lx RCX: %016lx\n",
 180                regs->ax, regs->bx, regs->cx);
 181         printk(KERN_DEFAULT "RDX: %016lx RSI: %016lx RDI: %016lx\n",
 182                regs->dx, regs->si, regs->di);
 183         printk(KERN_DEFAULT "RBP: %016lx R08: %016lx R09: %016lx\n",
 184                regs->bp, regs->r8, regs->r9);
 185         printk(KERN_DEFAULT "R10: %016lx R11: %016lx R12: %016lx\n",
 186                regs->r10, regs->r11, regs->r12);
 187         printk(KERN_DEFAULT "R13: %016lx R14: %016lx R15: %016lx\n",
 188                regs->r13, regs->r14, regs->r15);
 189
 190         asm("movl %%ds,%0" : "=r" (ds));
 191         asm("movl %%cs,%0" : "=r" (cs));
 192         asm("movl %%es,%0" : "=r" (es));
 193         asm("movl %%fs,%0" : "=r" (fsindex));
 194         asm("movl %%gs,%0" : "=r" (gsindex));
 195
 196         rdmsrl(MSR_FS_BASE, fs);
 197         rdmsrl(MSR_GS_BASE, gs);
 198         rdmsrl(MSR_KERNEL_GS_BASE, shadowgs);
 199
 200         if (!all)
 201                 return;
 202
 203         cr0 = read_cr0();
 204         cr2 = read_cr2();
 205         cr3 = read_cr3();
 206         cr4 = read_cr4();
 207
 208         printk(KERN_DEFAULT "FS:  %016lx(%04x) GS:%016lx(%04x) knlGS:%016lx\n",
 209                fs, fsindex, gs, gsindex, shadowgs);
 210         printk(KERN_DEFAULT "CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds,
 211                         es, cr0);
 212         printk(KERN_DEFAULT "CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3,
 213                         cr4);
 214
 215         get_debugreg(d0, 0);
 216         get_debugreg(d1, 1);
 217         get_debugreg(d2, 2);
 218         printk(KERN_DEFAULT "DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2);
 219         get_debugreg(d3, 3);
 220         get_debugreg(d6, 6);
 221         get_debugreg(d7, 7);
 222         printk(KERN_DEFAULT "DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7);
 223 }
 224
 225 void release_thread(struct task_struct *dead_task)
 226 {
 227         if (dead_task->mm) {
 228                 if (dead_task->mm->context.size) {
 229                         printk("WARNING: dead process %8s still has LDT? <%p/%d>\n",
 230                                         dead_task->comm,
 231                                         dead_task->mm->context.ldt,
 232                                         dead_task->mm->context.size);
 233                         BUG();
 234                 }
 235         }
 236 }
 237
 238 static inline void set_32bit_tls(struct task_struct *t, int tls, u32 addr)
 239 {
 240         struct user_desc ud = {
 241                 .base_addr = addr,
 242                 .limit = 0xfffff,
 243                 .seg_32bit = 1,
 244                 .limit_in_pages = 1,
 245                 .useable = 1,
 246         };
 247         struct desc_struct *desc = t->thread.tls_array;
 248         desc += tls;
 249         fill_ldt(desc, &ud);
 250 }
 251
 252 static inline u32 read_32bit_tls(struct task_struct *t, int tls)
 253 {
 254         return get_desc_base(&t->thread.tls_array[tls]);
 255 }
 256
 257 /*
 258  * This gets called before we allocate a new thread and copy
 259  * the current task into it.
 260  */
 261 void prepare_to_copy(struct task_struct *tsk)
 262 {
 263         unlazy_fpu(tsk);
 264 }
 265
 266 int copy_thread(unsigned long clone_flags, unsigned long sp,
 267                 unsigned long unused,
 268         struct task_struct *p, struct pt_regs *regs)
 269 {
 270         int err;
 271         struct pt_regs *childregs;
 272         struct task_struct *me = current;
 273
 274         childregs = ((struct pt_regs *)
 275                         (THREAD_SIZE + task_stack_page(p))) - 1;
 276         *childregs = *regs;
 277
 278         childregs->ax = 0;
 279         if (user_mode(regs))
 280                 childregs->sp = sp;
 281         else
 282                 childregs->sp = (unsigned long)childregs;
 283
 284         p->thread.sp = (unsigned long) childregs;
 285         p->thread.sp0 = (unsigned long) (childregs+1);
 286         p->thread.usersp = me->thread.usersp;
 287
 288         set_tsk_thread_flag(p, TIF_FORK);
 289
 290         p->fpu_counter = 0;
 291         p->thread.io_bitmap_ptr = NULL;
 292
 293         savesegment(gs, p->thread.gsindex);
 294         p->thread.gs = p->thread.gsindex ? 0 : me->thread.gs;
 295         savesegment(fs, p->thread.fsindex);
 296         p->thread.fs = p->thread.fsindex ? 0 : me->thread.fs;
 297         savesegment(es, p->thread.es);
 298         savesegment(ds, p->thread.ds);
 299
 300         err = -ENOMEM;
 301         memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));
 302
 303         if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
 304                 p->thread.io_bitmap_ptr = kmemdup(me->thread.io_bitmap_ptr,
 305                                                   IO_BITMAP_BYTES, GFP_KERNEL);
 306                 if (!p->thread.io_bitmap_ptr) {
 307                         p->thread.io_bitmap_max = 0;
 308                         return -ENOMEM;
 309                 }
 310                 set_tsk_thread_flag(p, TIF_IO_BITMAP);
 311         }
 312
 313         /*
 314          * Set a new TLS for the child thread?
 315          */
 316         if (clone_flags & CLONE_SETTLS) {
 317 #ifdef CONFIG_IA32_EMULATION
 318                 if (test_thread_flag(TIF_IA32))
 319                         err = do_set_thread_area(p, -1,
 320                                 (struct user_desc __user *)childregs->si, 0);
 321                 else
 322 #endif
 323                         err = do_arch_prctl(p, ARCH_SET_FS, childregs->r8);
 324                 if (err)
 325                         goto out;
 326         }
 327         err = 0;
 328 out:
 329         if (err && p->thread.io_bitmap_ptr) {
 330                 kfree(p->thread.io_bitmap_ptr);
 331                 p->thread.io_bitmap_max = 0;
 332         }
 333
 334         return err;
 335 }
 336
 337 static void
 338 start_thread_common(struct pt_regs *regs, unsigned long new_ip,
 339                     unsigned long new_sp,
 340                     unsigned int _cs, unsigned int _ss, unsigned int _ds)
 341 {
 342         loadsegment(fs, 0);
 343         loadsegment(es, _ds);
 344         loadsegment(ds, _ds);
 345         load_gs_index(0);
 346         regs->ip                = new_ip;
 347         regs->sp                = new_sp;
 348         percpu_write(old_rsp, new_sp);
 349         regs->cs                = _cs;
 350         regs->ss                = _ss;
 351         regs->flags             = X86_EFLAGS_IF;
 352         /*
 353          * Free the old FP and other extended state
 354          */
 355         free_thread_xstate(current);
 356 }
 357
 358 void
 359 start_thread(struct pt_regs *regs, unsigned long new_ip, unsigned long new_sp)
 360 {
 361         start_thread_common(regs, new_ip, new_sp,
 362                             __USER_CS, __USER_DS, 0);
 363 }
 364
 365 #ifdef CONFIG_IA32_EMULATION
 366 void start_thread_ia32(struct pt_regs *regs, u32 new_ip, u32 new_sp)
 367 {
 368         start_thread_common(regs, new_ip, new_sp,
 369                             __USER32_CS, __USER32_DS, __USER32_DS);
 370 }
 371 #endif
 372
 373 /*
 374  *      switch_to(x,y) should switch tasks from x to y.
 375  *
 376  * This could still be optimized:
 377  * - fold all the options into a flag word and test it with a single test.
 378  * - could test fs/gs bitsliced
 379  *
 380  * Kprobes not supported here. Set the probe on schedule instead.
 381  * Function graph tracer not supported too.
 382  */
 383 __notrace_funcgraph struct task_struct *
 384 __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
 385 {
 386         struct thread_struct *prev = &prev_p->thread;
 387         struct thread_struct *next = &next_p->thread;
 388         int cpu = smp_processor_id();
 389         struct tss_struct *tss = &per_cpu(init_tss, cpu);
 390         unsigned fsindex, gsindex;
 391         fpu_switch_t fpu;
 392
 393         fpu = switch_fpu_prepare(prev_p, next_p, cpu);
 394
 395         /*
 396          * Reload esp0, LDT and the page table pointer:
 397          */
 398         load_sp0(tss, next);
 399
 400         /*
 401          * Switch DS and ES.
 402          * This won't pick up thread selector changes, but I guess that is ok.
 403          */
 404         savesegment(es, prev->es);
 405         if (unlikely(next->es | prev->es))
 406                 loadsegment(es, next->es);
 407
 408         savesegment(ds, prev->ds);
 409         if (unlikely(next->ds | prev->ds))
 410                 loadsegment(ds, next->ds);
 411
 412
 413         /* We must save %fs and %gs before load_TLS() because
 414          * %fs and %gs may be cleared by load_TLS().
 415          *
 416          * (e.g. xen_load_tls())
 417          */
 418         savesegment(fs, fsindex);
 419         savesegment(gs, gsindex);
 420
 421         load_TLS(next, cpu);
 422
 423         /*
 424          * Leave lazy mode, flushing any hypercalls made here.
 425          * This must be done before restoring TLS segments so
 426          * the GDT and LDT are properly updated, and must be
 427          * done before math_state_restore, so the TS bit is up
 428          * to date.
 429          */
 430         arch_end_context_switch(next_p);
 431
 432         /*
 433          * Switch FS and GS.
 434          *
 435          * Segment register != 0 always requires a reload.  Also
 436          * reload when it has changed.  When prev process used 64bit
 437          * base always reload to avoid an information leak.
 438          */
 439         if (unlikely(fsindex | next->fsindex | prev->fs)) {
 440                 loadsegment(fs, next->fsindex);
 441                 /*
 442                  * Check if the user used a selector != 0; if yes
 443                  *  clear 64bit base, since overloaded base is always
 444                  *  mapped to the Null selector
 445                  */
 446                 if (fsindex)
 447                         prev->fs = 0;
 448         }
 449         /* when next process has a 64bit base use it */
 450         if (next->fs)
 451                 wrmsrl(MSR_FS_BASE, next->fs);
 452         prev->fsindex = fsindex;
 453
 454         if (unlikely(gsindex | next->gsindex | prev->gs)) {
 455                 load_gs_index(next->gsindex);
 456                 if (gsindex)
 457                         prev->gs = 0;
 458         }
 459         if (next->gs)
 460                 wrmsrl(MSR_KERNEL_GS_BASE, next->gs);
 461         prev->gsindex = gsindex;
 462
 463         switch_fpu_finish(next_p, fpu);
 464
 465         /*
 466          * Switch the PDA and FPU contexts.
 467          */
 468         prev->usersp = percpu_read(old_rsp);
 469         percpu_write(old_rsp, next->usersp);
 470         percpu_write(current_task, next_p);
 471
 472         percpu_write(kernel_stack,
 473                   (unsigned long)task_stack_page(next_p) +
 474                   THREAD_SIZE - KERNEL_STACK_OFFSET);
 475
 476         /*
 477          * Now maybe reload the debug registers and handle I/O bitmaps
 478          */
 479         if (unlikely(task_thread_info(next_p)->flags & _TIF_WORK_CTXSW_NEXT ||
 480                      task_thread_info(prev_p)->flags & _TIF_WORK_CTXSW_PREV))
 481                 __switch_to_xtra(prev_p, next_p, tss);
 482
 483         return prev_p;
 484 }
 485
 486 void set_personality_64bit(void)
 487 {
 488         /* inherit personality from parent */
 489
 490         /* Make sure to be in 64bit mode */
 491         clear_thread_flag(TIF_IA32);
 492
 493         /* Ensure the corresponding mm is not marked. */
 494         if (current->mm)
 495                 current->mm->context.ia32_compat = 0;
 496
 497         /* TBD: overwrites user setup. Should have two bits.
 498            But 64bit processes have always behaved this way,
 499            so it's not too bad. The main problem is just that
 500            32bit childs are affected again. */
 501         current->personality &= ~READ_IMPLIES_EXEC;
 502 }
 503
 504 void set_personality_ia32(void)
 505 {
 506         /* inherit personality from parent */
 507
 508         /* Make sure to be in 32bit mode */
 509         set_thread_flag(TIF_IA32);
 510         current->personality |= force_personality32;
 511
 512         /* Mark the associated mm as containing 32-bit tasks. */
 513         if (current->mm)
 514                 current->mm->context.ia32_compat = 1;
 515
 516         /* Prepare the first "return" to user space */
 517         current_thread_info()->status |= TS_COMPAT;
 518 }
 519
 520 unsigned long get_wchan(struct task_struct *p)
 521 {
 522         unsigned long stack;
 523         u64 fp, ip;
 524         int count = 0;
 525
 526         if (!p || p == current || p->state == TASK_RUNNING)
 527                 return 0;
 528         stack = (unsigned long)task_stack_page(p);
 529         if (p->thread.sp < stack || p->thread.sp >= stack+THREAD_SIZE)
 530                 return 0;
 531         fp = *(u64 *)(p->thread.sp);
 532         do {
 533                 if (fp < (unsigned long)stack ||
 534                     fp >= (unsigned long)stack+THREAD_SIZE)
 535                         return 0;
 536                 ip = *(u64 *)(fp+8);
 537                 if (!in_sched_functions(ip))
 538                         return ip;
 539                 fp = *(u64 *)fp;
 540         } while (count++ < 16);
 541         return 0;
 542 }
 543
 544 long do_arch_prctl(struct task_struct *task, int code, unsigned long addr)
 545 {
 546         int ret = 0;
 547         int doit = task == current;
 548         int cpu;
 549
 550         switch (code) {
 551         case ARCH_SET_GS:
 552                 if (addr >= TASK_SIZE_OF(task))
 553                         return -EPERM;
 554                 cpu = get_cpu();
 555                 /* handle small bases via the GDT because that's faster to
 556                    switch. */
 557                 if (addr <= 0xffffffff) {
 558                         set_32bit_tls(task, GS_TLS, addr);
 559                         if (doit) {
 560                                 load_TLS(&task->thread, cpu);
 561                                 load_gs_index(GS_TLS_SEL);
 562                         }
 563                         task->thread.gsindex = GS_TLS_SEL;
 564                         task->thread.gs = 0;
 565                 } else {
 566                         task->thread.gsindex = 0;
 567                         task->thread.gs = addr;
 568                         if (doit) {
 569                                 load_gs_index(0);
 570                                 ret = checking_wrmsrl(MSR_KERNEL_GS_BASE, addr);
 571                         }
 572                 }
 573                 put_cpu();
 574                 break;
 575         case ARCH_SET_FS:
 576                 /* Not strictly needed for fs, but do it for symmetry
 577                    with gs */
 578                 if (addr >= TASK_SIZE_OF(task))
 579                         return -EPERM;
 580                 cpu = get_cpu();
 581                 /* handle small bases via the GDT because that's faster to
 582                    switch. */
 583                 if (addr <= 0xffffffff) {
 584                         set_32bit_tls(task, FS_TLS, addr);
 585                         if (doit) {
 586                                 load_TLS(&task->thread, cpu);
 587                                 loadsegment(fs, FS_TLS_SEL);
 588                         }
 589                         task->thread.fsindex = FS_TLS_SEL;
 590                         task->thread.fs = 0;
 591                 } else {
 592                         task->thread.fsindex = 0;
 593                         task->thread.fs = addr;
 594                         if (doit) {
 595                                 /* set the selector to 0 to not confuse
 596                                    __switch_to */
 597                                 loadsegment(fs, 0);
 598                                 ret = checking_wrmsrl(MSR_FS_BASE, addr);
 599                         }
 600                 }
 601                 put_cpu();
 602                 break;
 603         case ARCH_GET_FS: {
 604                 unsigned long base;
 605                 if (task->thread.fsindex == FS_TLS_SEL)
 606                         base = read_32bit_tls(task, FS_TLS);
 607                 else if (doit)
 608                         rdmsrl(MSR_FS_BASE, base);
 609                 else
 610                         base = task->thread.fs;
 611                 ret = put_user(base, (unsigned long __user *)addr);
 612                 break;
 613         }
 614         case ARCH_GET_GS: {
 615                 unsigned long base;
 616                 unsigned gsindex;
 617                 if (task->thread.gsindex == GS_TLS_SEL)
 618                         base = read_32bit_tls(task, GS_TLS);
 619                 else if (doit) {
 620                         savesegment(gs, gsindex);
 621                         if (gsindex)
 622                                 rdmsrl(MSR_KERNEL_GS_BASE, base);
 623                         else
 624                                 base = task->thread.gs;
 625                 } else
 626                         base = task->thread.gs;
 627                 ret = put_user(base, (unsigned long __user *)addr);
 628                 break;
 629         }
 630
 631         default:
 632                 ret = -EINVAL;
 633                 break;
 634         }
 635
 636         return ret;
 637 }
 638
 639 long sys_arch_prctl(int code, unsigned long addr)
 640 {
 641         return do_arch_prctl(current, code, addr);
 642 }
 643
 644 unsigned long KSTK_ESP(struct task_struct *task)
 645 {
 646         return (test_tsk_thread_flag(task, TIF_IA32)) ?
 647                         (task_pt_regs(task)->sp) : ((task)->thread.usersp);
 648 }