Merge tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm

Pull KVM changes from Paolo Bonzini:
 "Here are the 3.13 KVM changes.  There was a lot of work on the PPC
  side: the HV and emulation flavors can now coexist in a single kernel
  is probably the most interesting change from a user point of view.

  On the x86 side there are nested virtualization improvements and a few
  bugfixes.

  ARM got transparent huge page support, improved overcommit, and
  support for big endian guests.

  Finally, there is a new interface to connect KVM with VFIO.  This
  helps with devices that use NoSnoop PCI transactions, letting the
  driver in the guest execute WBINVD instructions.  This includes some
  nVidia cards on Windows, that fail to start without these patches and
  the corresponding userspace changes"

* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (146 commits)
  kvm, vmx: Fix lazy FPU on nested guest
  arm/arm64: KVM: PSCI: propagate caller endianness to the incoming vcpu
  arm/arm64: KVM: MMIO support for BE guest
  kvm, cpuid: Fix sparse warning
  kvm: Delete prototype for non-existent function kvm_check_iopl
  kvm: Delete prototype for non-existent function complete_pio
  hung_task: add method to reset detector
  pvclock: detect watchdog reset at pvclock read
  kvm: optimize out smp_mb after srcu_read_unlock
  srcu: API for barrier after srcu read unlock
  KVM: remove vm mmap method
  KVM: IOMMU: hva align mapping page size
  KVM: x86: trace cpuid emulation when called from emulator
  KVM: emulator: cleanup decode_register_operand() a bit
  KVM: emulator: check rex prefix inside decode_register()
  KVM: x86: fix emulation of "movzbl %bpl, %eax"
  kvm_host: typo fix
  KVM: x86: emulate SAHF instruction
  MAINTAINERS: add tree for kvm.git
  Documentation/kvm: add a 00-INDEX file
  ...

7 files changed, 147 insertions, 53 deletions

diff --git a/arch/s390/kvm/diag.c b/arch/s390/kvm/diag.c
index 3a74d8af0d69..78d967f180f4 100644
--- a/arch/s390/kvm/diag.c
+++ b/arch/s390/kvm/diag.c
@@ -107,14 +107,13 @@ static int __diag_ipl_functions(struct kvm_vcpu *vcpu)
 
 static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu)
 {
-        int ret, idx;
+        int ret;
 
         /* No virtio-ccw notification? Get out quickly. */
         if (!vcpu->kvm->arch.css_support ||
             (vcpu->run->s.regs.gprs[1] != KVM_S390_VIRTIO_CCW_NOTIFY))
                 return -EOPNOTSUPP;
 
-        idx = srcu_read_lock(&vcpu->kvm->srcu);
         /*
          * The layout is as follows:
          * - gpr 2 contains the subchannel id (passed as addr)
@@ -125,7 +124,6 @@ static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu)
                                       vcpu->run->s.regs.gprs[2],
                                       8, &vcpu->run->s.regs.gprs[3],
                                       vcpu->run->s.regs.gprs[4]);
-        srcu_read_unlock(&vcpu->kvm->srcu, idx);
 
         /*
          * Return cookie in gpr 2, but don't overwrite the register if the
diff --git a/arch/s390/kvm/gaccess.h b/arch/s390/kvm/gaccess.h
index 99d789e8a018..374a439ccc60 100644
--- a/arch/s390/kvm/gaccess.h
+++ b/arch/s390/kvm/gaccess.h
@@ -18,20 +18,27 @@
 #include <asm/uaccess.h>
 #include "kvm-s390.h"
 
+/* Convert real to absolute address by applying the prefix of the CPU */
+static inline unsigned long kvm_s390_real_to_abs(struct kvm_vcpu *vcpu,
+                                                 unsigned long gaddr)
+{
+        unsigned long prefix  = vcpu->arch.sie_block->prefix;
+        if (gaddr < 2 * PAGE_SIZE)
+                gaddr += prefix;
+        else if (gaddr >= prefix && gaddr < prefix + 2 * PAGE_SIZE)
+                gaddr -= prefix;
+        return gaddr;
+}
+
 static inline void __user *__gptr_to_uptr(struct kvm_vcpu *vcpu,
                                           void __user *gptr,
                                           int prefixing)
 {
-        unsigned long prefix  = vcpu->arch.sie_block->prefix;
         unsigned long gaddr = (unsigned long) gptr;
         unsigned long uaddr;
 
-        if (prefixing) {
-                if (gaddr < 2 * PAGE_SIZE)
-                        gaddr += prefix;
-                else if ((gaddr >= prefix) && (gaddr < prefix + 2 * PAGE_SIZE))
-                        gaddr -= prefix;
-        }
+        if (prefixing)
+                gaddr = kvm_s390_real_to_abs(vcpu, gaddr);
         uaddr = gmap_fault(gaddr, vcpu->arch.gmap);
         if (IS_ERR_VALUE(uaddr))
                 uaddr = -EFAULT;
diff --git a/arch/s390/kvm/intercept.c b/arch/s390/kvm/intercept.c
index 5ee56e5acc23..5ddbbde6f65c 100644
--- a/arch/s390/kvm/intercept.c
+++ b/arch/s390/kvm/intercept.c
@@ -62,12 +62,6 @@ static int handle_stop(struct kvm_vcpu *vcpu)
 
         trace_kvm_s390_stop_request(vcpu->arch.local_int.action_bits);
 
-        if (vcpu->arch.local_int.action_bits & ACTION_RELOADVCPU_ON_STOP) {
-                vcpu->arch.local_int.action_bits &= ~ACTION_RELOADVCPU_ON_STOP;
-                rc = SIE_INTERCEPT_RERUNVCPU;
-                vcpu->run->exit_reason = KVM_EXIT_INTR;
-        }
-
         if (vcpu->arch.local_int.action_bits & ACTION_STOP_ON_STOP) {
                 atomic_set_mask(CPUSTAT_STOPPED,
                                 &vcpu->arch.sie_block->cpuflags);
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index 7f1f7ac5cf7f..5f79d2d79ca7 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -436,6 +436,7 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)
         hrtimer_start(&vcpu->arch.ckc_timer, ktime_set (0, sltime) , HRTIMER_MODE_REL);
         VCPU_EVENT(vcpu, 5, "enabled wait via clock comparator: %llx ns", sltime);
 no_timer:
+        srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
         spin_lock(&vcpu->arch.local_int.float_int->lock);
         spin_lock_bh(&vcpu->arch.local_int.lock);
         add_wait_queue(&vcpu->wq, &wait);
@@ -455,6 +456,8 @@ no_timer:
         remove_wait_queue(&vcpu->wq, &wait);
         spin_unlock_bh(&vcpu->arch.local_int.lock);
         spin_unlock(&vcpu->arch.local_int.float_int->lock);
+        vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
+
         hrtimer_try_to_cancel(&vcpu->arch.ckc_timer);
         return 0;
 }
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index ed8064cb5c49..569494e01ec6 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -695,9 +695,9 @@ static int kvm_s390_handle_requests(struct kvm_vcpu *vcpu)
         return 0;
 }
 
-static int __vcpu_run(struct kvm_vcpu *vcpu)
+static int vcpu_pre_run(struct kvm_vcpu *vcpu)
 {
-        int rc;
+        int rc, cpuflags;
 
         memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
 
@@ -715,28 +715,24 @@ static int __vcpu_run(struct kvm_vcpu *vcpu)
                 return rc;
 
         vcpu->arch.sie_block->icptcode = 0;
-        VCPU_EVENT(vcpu, 6, "entering sie flags %x",
-                   atomic_read(&vcpu->arch.sie_block->cpuflags));
-        trace_kvm_s390_sie_enter(vcpu,
-                                 atomic_read(&vcpu->arch.sie_block->cpuflags));
+        cpuflags = atomic_read(&vcpu->arch.sie_block->cpuflags);
+        VCPU_EVENT(vcpu, 6, "entering sie flags %x", cpuflags);
+        trace_kvm_s390_sie_enter(vcpu, cpuflags);
 
-        /*
-         * As PF_VCPU will be used in fault handler, between guest_enter
-         * and guest_exit should be no uaccess.
-         */
-        preempt_disable();
-        kvm_guest_enter();
-        preempt_enable();
-        rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
-        kvm_guest_exit();
+        return 0;
+}
+
+static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
+{
+        int rc;
 
         VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
                    vcpu->arch.sie_block->icptcode);
         trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
 
-        if (rc > 0)
+        if (exit_reason >= 0) {
                 rc = 0;
-        if (rc < 0) {
+        } else {
                 if (kvm_is_ucontrol(vcpu->kvm)) {
                         rc = SIE_INTERCEPT_UCONTROL;
                 } else {
@@ -747,6 +743,49 @@ static int __vcpu_run(struct kvm_vcpu *vcpu)
         }
 
         memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
+
+        if (rc == 0) {
+                if (kvm_is_ucontrol(vcpu->kvm))
+                        rc = -EOPNOTSUPP;
+                else
+                        rc = kvm_handle_sie_intercept(vcpu);
+        }
+
+        return rc;
+}
+
+static int __vcpu_run(struct kvm_vcpu *vcpu)
+{
+        int rc, exit_reason;
+
+        /*
+         * We try to hold kvm->srcu during most of vcpu_run (except when run-
+         * ning the guest), so that memslots (and other stuff) are protected
+         */
+        vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
+
+        do {
+                rc = vcpu_pre_run(vcpu);
+                if (rc)
+                        break;
+
+                srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
+                /*
+                 * As PF_VCPU will be used in fault handler, between
+                 * guest_enter and guest_exit should be no uaccess.
+                 */
+                preempt_disable();
+                kvm_guest_enter();
+                preempt_enable();
+                exit_reason = sie64a(vcpu->arch.sie_block,
+                                     vcpu->run->s.regs.gprs);
+                kvm_guest_exit();
+                vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
+
+                rc = vcpu_post_run(vcpu, exit_reason);
+        } while (!signal_pending(current) && !rc);
+
+        srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
         return rc;
 }
 
@@ -755,7 +794,6 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         int rc;
         sigset_t sigsaved;
 
-rerun_vcpu:
         if (vcpu->sigset_active)
                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
 
@@ -788,19 +826,7 @@ rerun_vcpu:
         }
 
         might_fault();
-
-        do {
-                rc = __vcpu_run(vcpu);
-                if (rc)
-                        break;
-                if (kvm_is_ucontrol(vcpu->kvm))
-                        rc = -EOPNOTSUPP;
-                else
-                        rc = kvm_handle_sie_intercept(vcpu);
-        } while (!signal_pending(current) && !rc);
-
-        if (rc == SIE_INTERCEPT_RERUNVCPU)
-                goto rerun_vcpu;
+        rc = __vcpu_run(vcpu);
 
         if (signal_pending(current) && !rc) {
                 kvm_run->exit_reason = KVM_EXIT_INTR;
@@ -958,6 +984,7 @@ long kvm_arch_vcpu_ioctl(struct file *filp,
 {
         struct kvm_vcpu *vcpu = filp->private_data;
         void __user *argp = (void __user *)arg;
+        int idx;
         long r;
 
         switch (ioctl) {
@@ -971,7 +998,9 @@ long kvm_arch_vcpu_ioctl(struct file *filp,
                 break;
         }
         case KVM_S390_STORE_STATUS:
+                idx = srcu_read_lock(&vcpu->kvm->srcu);
                 r = kvm_s390_vcpu_store_status(vcpu, arg);
+                srcu_read_unlock(&vcpu->kvm->srcu, idx);
                 break;
         case KVM_S390_SET_INITIAL_PSW: {
                 psw_t psw;
@@ -1067,12 +1096,13 @@ int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
         return VM_FAULT_SIGBUS;
 }
 
-void kvm_arch_free_memslot(struct kvm_memory_slot *free,
+void kvm_arch_free_memslot(struct kvm *kvm, struct kvm_memory_slot *free,
                            struct kvm_memory_slot *dont)
 {
 }
 
-int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
+int kvm_arch_create_memslot(struct kvm *kvm, struct kvm_memory_slot *slot,
+                            unsigned long npages)
 {
         return 0;
 }
diff --git a/arch/s390/kvm/kvm-s390.h b/arch/s390/kvm/kvm-s390.h
index dc99f1ca4267..b44912a32949 100644
--- a/arch/s390/kvm/kvm-s390.h
+++ b/arch/s390/kvm/kvm-s390.h
@@ -28,8 +28,7 @@ typedef int (*intercept_handler_t)(struct kvm_vcpu *vcpu);
 extern unsigned long *vfacilities;
 
 /* negativ values are error codes, positive values for internal conditions */
-#define SIE_INTERCEPT_RERUNVCPU         (1<<0)
-#define SIE_INTERCEPT_UCONTROL          (1<<1)
+#define SIE_INTERCEPT_UCONTROL          (1<<0)
 int kvm_handle_sie_intercept(struct kvm_vcpu *vcpu);
 
 #define VM_EVENT(d_kvm, d_loglevel, d_string, d_args...)\
@@ -91,8 +90,10 @@ static inline void kvm_s390_get_base_disp_sse(struct kvm_vcpu *vcpu,
 
 static inline void kvm_s390_get_regs_rre(struct kvm_vcpu *vcpu, int *r1, int *r2)
 {
-        *r1 = (vcpu->arch.sie_block->ipb & 0x00f00000) >> 20;
-        *r2 = (vcpu->arch.sie_block->ipb & 0x000f0000) >> 16;
+        if (r1)
+                *r1 = (vcpu->arch.sie_block->ipb & 0x00f00000) >> 20;
+        if (r2)
+                *r2 = (vcpu->arch.sie_block->ipb & 0x000f0000) >> 16;
 }
 
 static inline u64 kvm_s390_get_base_disp_rsy(struct kvm_vcpu *vcpu)
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c
index 59200ee275e5..2440602e6df1 100644
--- a/arch/s390/kvm/priv.c
+++ b/arch/s390/kvm/priv.c
@@ -30,6 +30,38 @@
 #include "kvm-s390.h"
 #include "trace.h"
 
+/* Handle SCK (SET CLOCK) interception */
+static int handle_set_clock(struct kvm_vcpu *vcpu)
+{
+        struct kvm_vcpu *cpup;
+        s64 hostclk, val;
+        u64 op2;
+        int i;
+
+        if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
+                return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
+
+        op2 = kvm_s390_get_base_disp_s(vcpu);
+        if (op2 & 7)    /* Operand must be on a doubleword boundary */
+                return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
+        if (get_guest(vcpu, val, (u64 __user *) op2))
+                return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
+
+        if (store_tod_clock(&hostclk)) {
+                kvm_s390_set_psw_cc(vcpu, 3);
+                return 0;
+        }
+        val = (val - hostclk) & ~0x3fUL;
+
+        mutex_lock(&vcpu->kvm->lock);
+        kvm_for_each_vcpu(i, cpup, vcpu->kvm)
+                cpup->arch.sie_block->epoch = val;
+        mutex_unlock(&vcpu->kvm->lock);
+
+        kvm_s390_set_psw_cc(vcpu, 0);
+        return 0;
+}
+
 static int handle_set_prefix(struct kvm_vcpu *vcpu)
 {
         u64 operand2;
@@ -128,6 +160,33 @@ static int handle_skey(struct kvm_vcpu *vcpu)
         return 0;
 }
 
+static int handle_test_block(struct kvm_vcpu *vcpu)
+{
+        unsigned long hva;
+        gpa_t addr;
+        int reg2;
+
+        if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
+                return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
+
+        kvm_s390_get_regs_rre(vcpu, NULL, &reg2);
+        addr = vcpu->run->s.regs.gprs[reg2] & PAGE_MASK;
+        addr = kvm_s390_real_to_abs(vcpu, addr);
+
+        hva = gfn_to_hva(vcpu->kvm, gpa_to_gfn(addr));
+        if (kvm_is_error_hva(hva))
+                return kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
+        /*
+         * We don't expect errors on modern systems, and do not care
+         * about storage keys (yet), so let's just clear the page.
+         */
+        if (clear_user((void __user *)hva, PAGE_SIZE) != 0)
+                return -EFAULT;
+        kvm_s390_set_psw_cc(vcpu, 0);
+        vcpu->run->s.regs.gprs[0] = 0;
+        return 0;
+}
+
 static int handle_tpi(struct kvm_vcpu *vcpu)
 {
         struct kvm_s390_interrupt_info *inti;
@@ -438,12 +497,14 @@ out_exception:
 
 static const intercept_handler_t b2_handlers[256] = {
         [0x02] = handle_stidp,
+        [0x04] = handle_set_clock,
         [0x10] = handle_set_prefix,
         [0x11] = handle_store_prefix,
         [0x12] = handle_store_cpu_address,
         [0x29] = handle_skey,
         [0x2a] = handle_skey,
         [0x2b] = handle_skey,
+        [0x2c] = handle_test_block,
         [0x30] = handle_io_inst,
         [0x31] = handle_io_inst,
         [0x32] = handle_io_inst,