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