Merge branch 'kvm-updates-2.6.26' of git://git.kernel.org/pub/scm/linux/kernel/git/avi/kvm

* 'kvm-updates-2.6.26' of git://git.kernel.org/pub/scm/linux/kernel/git/avi/kvm: (147 commits)
  KVM: kill file->f_count abuse in kvm
  KVM: MMU: kvm_pv_mmu_op should not take mmap_sem
  KVM: SVM: remove selective CR0 comment
  KVM: SVM: remove now obsolete FIXME comment
  KVM: SVM: disable CR8 intercept when tpr is not masking interrupts
  KVM: SVM: sync V_TPR with LAPIC.TPR if CR8 write intercept is disabled
  KVM: export kvm_lapic_set_tpr() to modules
  KVM: SVM: sync TPR value to V_TPR field in the VMCB
  KVM: ppc: PowerPC 440 KVM implementation
  KVM: Add MAINTAINERS entry for PowerPC KVM
  KVM: ppc: Add DCR access information to struct kvm_run
  ppc: Export tlb_44x_hwater for KVM
  KVM: Rename debugfs_dir to kvm_debugfs_dir
  KVM: x86 emulator: fix lea to really get the effective address
  KVM: x86 emulator: fix smsw and lmsw with a memory operand
  KVM: x86 emulator: initialize src.val and dst.val for register operands
  KVM: SVM: force a new asid when initializing the vmcb
  KVM: fix kvm_vcpu_kick vs __vcpu_run race
  KVM: add ioctls to save/store mpstate
  KVM: Rename VCPU_MP_STATE_* to KVM_MP_STATE_*
  ...

7 files changed, 463 insertions, 3 deletions

diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile
index 90e092d0af0c..fa19c3819540 100644
--- a/arch/x86/kernel/Makefile
+++ b/arch/x86/kernel/Makefile
@@ -80,6 +80,8 @@ obj-$(CONFIG_DEBUG_RODATA_TEST)	+= test_rodata.o
 obj-$(CONFIG_DEBUG_NX_TEST)     += test_nx.o
 
 obj-$(CONFIG_VMI)               += vmi_32.o vmiclock_32.o
+obj-$(CONFIG_KVM_GUEST)         += kvm.o
+obj-$(CONFIG_KVM_CLOCK)         += kvmclock.o
 obj-$(CONFIG_PARAVIRT)          += paravirt.o paravirt_patch_$(BITS).o
 
 ifdef CONFIG_INPUT_PCSPKR
diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c
index 2251d0ae9570..268553817909 100644
--- a/arch/x86/kernel/crash.c
+++ b/arch/x86/kernel/crash.c
@@ -25,6 +25,7 @@
 #include <asm/hpet.h>
 #include <linux/kdebug.h>
 #include <asm/smp.h>
+#include <asm/reboot.h>
 
 #include <mach_ipi.h>
 
@@ -117,7 +118,7 @@ static void nmi_shootdown_cpus(void)
 }
 #endif
 
-void machine_crash_shutdown(struct pt_regs *regs)
+void native_machine_crash_shutdown(struct pt_regs *regs)
 {
         /* This function is only called after the system
          * has panicked or is otherwise in a critical state.
diff --git a/arch/x86/kernel/kvm.c b/arch/x86/kernel/kvm.c
new file mode 100644
index 000000000000..8b7a3cf37d2b
--- /dev/null
+++ b/arch/x86/kernel/kvm.c
@@ -0,0 +1,248 @@
+/*
+ * KVM paravirt_ops implementation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * Copyright (C) 2007, Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
+ * Copyright IBM Corporation, 2007
+ *   Authors: Anthony Liguori <aliguori@us.ibm.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/kvm_para.h>
+#include <linux/cpu.h>
+#include <linux/mm.h>
+#include <linux/highmem.h>
+#include <linux/hardirq.h>
+
+#define MMU_QUEUE_SIZE 1024
+
+struct kvm_para_state {
+        u8 mmu_queue[MMU_QUEUE_SIZE];
+        int mmu_queue_len;
+        enum paravirt_lazy_mode mode;
+};
+
+static DEFINE_PER_CPU(struct kvm_para_state, para_state);
+
+static struct kvm_para_state *kvm_para_state(void)
+{
+        return &per_cpu(para_state, raw_smp_processor_id());
+}
+
+/*
+ * No need for any "IO delay" on KVM
+ */
+static void kvm_io_delay(void)
+{
+}
+
+static void kvm_mmu_op(void *buffer, unsigned len)
+{
+        int r;
+        unsigned long a1, a2;
+
+        do {
+                a1 = __pa(buffer);
+                a2 = 0;   /* on i386 __pa() always returns <4G */
+                r = kvm_hypercall3(KVM_HC_MMU_OP, len, a1, a2);
+                buffer += r;
+                len -= r;
+        } while (len);
+}
+
+static void mmu_queue_flush(struct kvm_para_state *state)
+{
+        if (state->mmu_queue_len) {
+                kvm_mmu_op(state->mmu_queue, state->mmu_queue_len);
+                state->mmu_queue_len = 0;
+        }
+}
+
+static void kvm_deferred_mmu_op(void *buffer, int len)
+{
+        struct kvm_para_state *state = kvm_para_state();
+
+        if (state->mode != PARAVIRT_LAZY_MMU) {
+                kvm_mmu_op(buffer, len);
+                return;
+        }
+        if (state->mmu_queue_len + len > sizeof state->mmu_queue)
+                mmu_queue_flush(state);
+        memcpy(state->mmu_queue + state->mmu_queue_len, buffer, len);
+        state->mmu_queue_len += len;
+}
+
+static void kvm_mmu_write(void *dest, u64 val)
+{
+        __u64 pte_phys;
+        struct kvm_mmu_op_write_pte wpte;
+
+#ifdef CONFIG_HIGHPTE
+        struct page *page;
+        unsigned long dst = (unsigned long) dest;
+
+        page = kmap_atomic_to_page(dest);
+        pte_phys = page_to_pfn(page);
+        pte_phys <<= PAGE_SHIFT;
+        pte_phys += (dst & ~(PAGE_MASK));
+#else
+        pte_phys = (unsigned long)__pa(dest);
+#endif
+        wpte.header.op = KVM_MMU_OP_WRITE_PTE;
+        wpte.pte_val = val;
+        wpte.pte_phys = pte_phys;
+
+        kvm_deferred_mmu_op(&wpte, sizeof wpte);
+}
+
+/*
+ * We only need to hook operations that are MMU writes.  We hook these so that
+ * we can use lazy MMU mode to batch these operations.  We could probably
+ * improve the performance of the host code if we used some of the information
+ * here to simplify processing of batched writes.
+ */
+static void kvm_set_pte(pte_t *ptep, pte_t pte)
+{
+        kvm_mmu_write(ptep, pte_val(pte));
+}
+
+static void kvm_set_pte_at(struct mm_struct *mm, unsigned long addr,
+                           pte_t *ptep, pte_t pte)
+{
+        kvm_mmu_write(ptep, pte_val(pte));
+}
+
+static void kvm_set_pmd(pmd_t *pmdp, pmd_t pmd)
+{
+        kvm_mmu_write(pmdp, pmd_val(pmd));
+}
+
+#if PAGETABLE_LEVELS >= 3
+#ifdef CONFIG_X86_PAE
+static void kvm_set_pte_atomic(pte_t *ptep, pte_t pte)
+{
+        kvm_mmu_write(ptep, pte_val(pte));
+}
+
+static void kvm_set_pte_present(struct mm_struct *mm, unsigned long addr,
+                                pte_t *ptep, pte_t pte)
+{
+        kvm_mmu_write(ptep, pte_val(pte));
+}
+
+static void kvm_pte_clear(struct mm_struct *mm,
+                          unsigned long addr, pte_t *ptep)
+{
+        kvm_mmu_write(ptep, 0);
+}
+
+static void kvm_pmd_clear(pmd_t *pmdp)
+{
+        kvm_mmu_write(pmdp, 0);
+}
+#endif
+
+static void kvm_set_pud(pud_t *pudp, pud_t pud)
+{
+        kvm_mmu_write(pudp, pud_val(pud));
+}
+
+#if PAGETABLE_LEVELS == 4
+static void kvm_set_pgd(pgd_t *pgdp, pgd_t pgd)
+{
+        kvm_mmu_write(pgdp, pgd_val(pgd));
+}
+#endif
+#endif /* PAGETABLE_LEVELS >= 3 */
+
+static void kvm_flush_tlb(void)
+{
+        struct kvm_mmu_op_flush_tlb ftlb = {
+                .header.op = KVM_MMU_OP_FLUSH_TLB,
+        };
+
+        kvm_deferred_mmu_op(&ftlb, sizeof ftlb);
+}
+
+static void kvm_release_pt(u32 pfn)
+{
+        struct kvm_mmu_op_release_pt rpt = {
+                .header.op = KVM_MMU_OP_RELEASE_PT,
+                .pt_phys = (u64)pfn << PAGE_SHIFT,
+        };
+
+        kvm_mmu_op(&rpt, sizeof rpt);
+}
+
+static void kvm_enter_lazy_mmu(void)
+{
+        struct kvm_para_state *state = kvm_para_state();
+
+        paravirt_enter_lazy_mmu();
+        state->mode = paravirt_get_lazy_mode();
+}
+
+static void kvm_leave_lazy_mmu(void)
+{
+        struct kvm_para_state *state = kvm_para_state();
+
+        mmu_queue_flush(state);
+        paravirt_leave_lazy(paravirt_get_lazy_mode());
+        state->mode = paravirt_get_lazy_mode();
+}
+
+static void paravirt_ops_setup(void)
+{
+        pv_info.name = "KVM";
+        pv_info.paravirt_enabled = 1;
+
+        if (kvm_para_has_feature(KVM_FEATURE_NOP_IO_DELAY))
+                pv_cpu_ops.io_delay = kvm_io_delay;
+
+        if (kvm_para_has_feature(KVM_FEATURE_MMU_OP)) {
+                pv_mmu_ops.set_pte = kvm_set_pte;
+                pv_mmu_ops.set_pte_at = kvm_set_pte_at;
+                pv_mmu_ops.set_pmd = kvm_set_pmd;
+#if PAGETABLE_LEVELS >= 3
+#ifdef CONFIG_X86_PAE
+                pv_mmu_ops.set_pte_atomic = kvm_set_pte_atomic;
+                pv_mmu_ops.set_pte_present = kvm_set_pte_present;
+                pv_mmu_ops.pte_clear = kvm_pte_clear;
+                pv_mmu_ops.pmd_clear = kvm_pmd_clear;
+#endif
+                pv_mmu_ops.set_pud = kvm_set_pud;
+#if PAGETABLE_LEVELS == 4
+                pv_mmu_ops.set_pgd = kvm_set_pgd;
+#endif
+#endif
+                pv_mmu_ops.flush_tlb_user = kvm_flush_tlb;
+                pv_mmu_ops.release_pte = kvm_release_pt;
+                pv_mmu_ops.release_pmd = kvm_release_pt;
+                pv_mmu_ops.release_pud = kvm_release_pt;
+
+                pv_mmu_ops.lazy_mode.enter = kvm_enter_lazy_mmu;
+                pv_mmu_ops.lazy_mode.leave = kvm_leave_lazy_mmu;
+        }
+}
+
+void __init kvm_guest_init(void)
+{
+        if (!kvm_para_available())
+                return;
+
+        paravirt_ops_setup();
+}
diff --git a/arch/x86/kernel/kvmclock.c b/arch/x86/kernel/kvmclock.c
new file mode 100644
index 000000000000..ddee04043aeb
--- /dev/null
+++ b/arch/x86/kernel/kvmclock.c
@@ -0,0 +1,187 @@
+/*  KVM paravirtual clock driver. A clocksource implementation
+    Copyright (C) 2008 Glauber de Oliveira Costa, Red Hat Inc.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <linux/clocksource.h>
+#include <linux/kvm_para.h>
+#include <asm/arch_hooks.h>
+#include <asm/msr.h>
+#include <asm/apic.h>
+#include <linux/percpu.h>
+#include <asm/reboot.h>
+
+#define KVM_SCALE 22
+
+static int kvmclock = 1;
+
+static int parse_no_kvmclock(char *arg)
+{
+        kvmclock = 0;
+        return 0;
+}
+early_param("no-kvmclock", parse_no_kvmclock);
+
+/* The hypervisor will put information about time periodically here */
+static DEFINE_PER_CPU_SHARED_ALIGNED(struct kvm_vcpu_time_info, hv_clock);
+#define get_clock(cpu, field) per_cpu(hv_clock, cpu).field
+
+static inline u64 kvm_get_delta(u64 last_tsc)
+{
+        int cpu = smp_processor_id();
+        u64 delta = native_read_tsc() - last_tsc;
+        return (delta * get_clock(cpu, tsc_to_system_mul)) >> KVM_SCALE;
+}
+
+static struct kvm_wall_clock wall_clock;
+static cycle_t kvm_clock_read(void);
+/*
+ * The wallclock is the time of day when we booted. Since then, some time may
+ * have elapsed since the hypervisor wrote the data. So we try to account for
+ * that with system time
+ */
+unsigned long kvm_get_wallclock(void)
+{
+        u32 wc_sec, wc_nsec;
+        u64 delta;
+        struct timespec ts;
+        int version, nsec;
+        int low, high;
+
+        low = (int)__pa(&wall_clock);
+        high = ((u64)__pa(&wall_clock) >> 32);
+
+        delta = kvm_clock_read();
+
+        native_write_msr(MSR_KVM_WALL_CLOCK, low, high);
+        do {
+                version = wall_clock.wc_version;
+                rmb();
+                wc_sec = wall_clock.wc_sec;
+                wc_nsec = wall_clock.wc_nsec;
+                rmb();
+        } while ((wall_clock.wc_version != version) || (version & 1));
+
+        delta = kvm_clock_read() - delta;
+        delta += wc_nsec;
+        nsec = do_div(delta, NSEC_PER_SEC);
+        set_normalized_timespec(&ts, wc_sec + delta, nsec);
+        /*
+         * Of all mechanisms of time adjustment I've tested, this one
+         * was the champion!
+         */
+        return ts.tv_sec + 1;
+}
+
+int kvm_set_wallclock(unsigned long now)
+{
+        return 0;
+}
+
+/*
+ * This is our read_clock function. The host puts an tsc timestamp each time
+ * it updates a new time. Without the tsc adjustment, we can have a situation
+ * in which a vcpu starts to run earlier (smaller system_time), but probes
+ * time later (compared to another vcpu), leading to backwards time
+ */
+static cycle_t kvm_clock_read(void)
+{
+        u64 last_tsc, now;
+        int cpu;
+
+        preempt_disable();
+        cpu = smp_processor_id();
+
+        last_tsc = get_clock(cpu, tsc_timestamp);
+        now = get_clock(cpu, system_time);
+
+        now += kvm_get_delta(last_tsc);
+        preempt_enable();
+
+        return now;
+}
+static struct clocksource kvm_clock = {
+        .name = "kvm-clock",
+        .read = kvm_clock_read,
+        .rating = 400,
+        .mask = CLOCKSOURCE_MASK(64),
+        .mult = 1 << KVM_SCALE,
+        .shift = KVM_SCALE,
+        .flags = CLOCK_SOURCE_IS_CONTINUOUS,
+};
+
+static int kvm_register_clock(void)
+{
+        int cpu = smp_processor_id();
+        int low, high;
+        low = (int)__pa(&per_cpu(hv_clock, cpu)) | 1;
+        high = ((u64)__pa(&per_cpu(hv_clock, cpu)) >> 32);
+
+        return native_write_msr_safe(MSR_KVM_SYSTEM_TIME, low, high);
+}
+
+static void kvm_setup_secondary_clock(void)
+{
+        /*
+         * Now that the first cpu already had this clocksource initialized,
+         * we shouldn't fail.
+         */
+        WARN_ON(kvm_register_clock());
+        /* ok, done with our trickery, call native */
+        setup_secondary_APIC_clock();
+}
+
+/*
+ * After the clock is registered, the host will keep writing to the
+ * registered memory location. If the guest happens to shutdown, this memory
+ * won't be valid. In cases like kexec, in which you install a new kernel, this
+ * means a random memory location will be kept being written. So before any
+ * kind of shutdown from our side, we unregister the clock by writting anything
+ * that does not have the 'enable' bit set in the msr
+ */
+#ifdef CONFIG_KEXEC
+static void kvm_crash_shutdown(struct pt_regs *regs)
+{
+        native_write_msr_safe(MSR_KVM_SYSTEM_TIME, 0, 0);
+        native_machine_crash_shutdown(regs);
+}
+#endif
+
+static void kvm_shutdown(void)
+{
+        native_write_msr_safe(MSR_KVM_SYSTEM_TIME, 0, 0);
+        native_machine_shutdown();
+}
+
+void __init kvmclock_init(void)
+{
+        if (!kvm_para_available())
+                return;
+
+        if (kvmclock && kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE)) {
+                if (kvm_register_clock())
+                        return;
+                pv_time_ops.get_wallclock = kvm_get_wallclock;
+                pv_time_ops.set_wallclock = kvm_set_wallclock;
+                pv_time_ops.sched_clock = kvm_clock_read;
+                pv_apic_ops.setup_secondary_clock = kvm_setup_secondary_clock;
+                machine_ops.shutdown  = kvm_shutdown;
+#ifdef CONFIG_KEXEC
+                machine_ops.crash_shutdown  = kvm_crash_shutdown;
+#endif
+                clocksource_register(&kvm_clock);
+        }
+}
diff --git a/arch/x86/kernel/reboot.c b/arch/x86/kernel/reboot.c
index 1791a751a772..a4a838306b2c 100644
--- a/arch/x86/kernel/reboot.c
+++ b/arch/x86/kernel/reboot.c
@@ -399,7 +399,7 @@ static void native_machine_emergency_restart(void)
         }
 }
 
-static void native_machine_shutdown(void)
+void native_machine_shutdown(void)
 {
         /* Stop the cpus and apics */
 #ifdef CONFIG_SMP
@@ -470,7 +470,10 @@ struct machine_ops machine_ops = {
         .shutdown = native_machine_shutdown,
         .emergency_restart = native_machine_emergency_restart,
         .restart = native_machine_restart,
-        .halt = native_machine_halt
+        .halt = native_machine_halt,
+#ifdef CONFIG_KEXEC
+        .crash_shutdown = native_machine_crash_shutdown,
+#endif
 };
 
 void machine_power_off(void)
@@ -498,3 +501,9 @@ void machine_halt(void)
         machine_ops.halt();
 }
 
+#ifdef CONFIG_KEXEC
+void machine_crash_shutdown(struct pt_regs *regs)
+{
+        machine_ops.crash_shutdown(regs);
+}
+#endif
diff --git a/arch/x86/kernel/setup_32.c b/arch/x86/kernel/setup_32.c
index 44cc9b933932..2283422af794 100644
--- a/arch/x86/kernel/setup_32.c
+++ b/arch/x86/kernel/setup_32.c
@@ -47,6 +47,7 @@
 #include <linux/pfn.h>
 #include <linux/pci.h>
 #include <linux/init_ohci1394_dma.h>
+#include <linux/kvm_para.h>
 
 #include <video/edid.h>
 
@@ -820,6 +821,10 @@ void __init setup_arch(char **cmdline_p)
 
         max_low_pfn = setup_memory();
 
+#ifdef CONFIG_KVM_CLOCK
+        kvmclock_init();
+#endif
+
 #ifdef CONFIG_VMI
         /*
          * Must be after max_low_pfn is determined, and before kernel
@@ -827,6 +832,7 @@ void __init setup_arch(char **cmdline_p)
          */
         vmi_init();
 #endif
+        kvm_guest_init();
 
         /*
          * NOTE: before this point _nobody_ is allowed to allocate
diff --git a/arch/x86/kernel/setup_64.c b/arch/x86/kernel/setup_64.c
index 60e64c8eee92..a94fb959a87a 100644
--- a/arch/x86/kernel/setup_64.c
+++ b/arch/x86/kernel/setup_64.c
@@ -42,6 +42,7 @@
 #include <linux/ctype.h>
 #include <linux/uaccess.h>
 #include <linux/init_ohci1394_dma.h>
+#include <linux/kvm_para.h>
 
 #include <asm/mtrr.h>
 #include <asm/uaccess.h>
@@ -384,6 +385,10 @@ void __init setup_arch(char **cmdline_p)
 
         io_delay_init();
 
+#ifdef CONFIG_KVM_CLOCK
+        kvmclock_init();
+#endif
+
 #ifdef CONFIG_SMP
         /* setup to use the early static init tables during kernel startup */
         x86_cpu_to_apicid_early_ptr = (void *)x86_cpu_to_apicid_init;
@@ -488,6 +493,8 @@ void __init setup_arch(char **cmdline_p)
         init_apic_mappings();
         ioapic_init_mappings();
 
+        kvm_guest_init();
+
         /*
          * We trust e820 completely. No explicit ROM probing in memory.
          */