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

Pull KVM updates from Paolo Bonzini:
 "First round of KVM updates for 3.14; PPC parts will come next week.

  Nothing major here, just bugfixes all over the place.  The most
  interesting part is the ARM guys' virtualized interrupt controller
  overhaul, which lets userspace get/set the state and thus enables
  migration of ARM VMs"

* tag 'for-linus' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (67 commits)
  kvm: make KVM_MMU_AUDIT help text more readable
  KVM: s390: Fix memory access error detection
  KVM: nVMX: Update guest activity state field on L2 exits
  KVM: nVMX: Fix nested_run_pending on activity state HLT
  KVM: nVMX: Clean up handling of VMX-related MSRs
  KVM: nVMX: Add tracepoints for nested_vmexit and nested_vmexit_inject
  KVM: nVMX: Pass vmexit parameters to nested_vmx_vmexit
  KVM: nVMX: Leave VMX mode on clearing of feature control MSR
  KVM: VMX: Fix DR6 update on #DB exception
  KVM: SVM: Fix reading of DR6
  KVM: x86: Sync DR7 on KVM_SET_DEBUGREGS
  add support for Hyper-V reference time counter
  KVM: remove useless write to vcpu->hv_clock.tsc_timestamp
  KVM: x86: fix tsc catchup issue with tsc scaling
  KVM: x86: limit PIT timer frequency
  KVM: x86: handle invalid root_hpa everywhere
  kvm: Provide kvm_vcpu_eligible_for_directed_yield() stub
  kvm: vfio: silence GCC warning
  KVM: ARM: Remove duplicate include
  arm/arm64: KVM: relax the requirements of VMA alignment for THP
  ...

7 files changed, 137 insertions, 59 deletions

diff --git a/arch/s390/include/asm/sigp.h b/arch/s390/include/asm/sigp.h
index 5a87d16d3e7c..d091aa1aaf11 100644
--- a/arch/s390/include/asm/sigp.h
+++ b/arch/s390/include/asm/sigp.h
@@ -5,6 +5,7 @@
 #define SIGP_SENSE                    1
 #define SIGP_EXTERNAL_CALL            2
 #define SIGP_EMERGENCY_SIGNAL         3
+#define SIGP_START                    4
 #define SIGP_STOP                     5
 #define SIGP_RESTART                  6
 #define SIGP_STOP_AND_STORE_STATUS    9
@@ -12,6 +13,7 @@
 #define SIGP_SET_PREFIX              13
 #define SIGP_STORE_STATUS_AT_ADDRESS 14
 #define SIGP_SET_ARCHITECTURE        18
+#define SIGP_COND_EMERGENCY_SIGNAL   19
 #define SIGP_SENSE_RUNNING           21
 
 /* SIGP condition codes */
diff --git a/arch/s390/kvm/diag.c b/arch/s390/kvm/diag.c
index 78d967f180f4..8216c0e0b2e2 100644
--- a/arch/s390/kvm/diag.c
+++ b/arch/s390/kvm/diag.c
@@ -121,7 +121,7 @@ static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu)
          * - gpr 4 contains the index on the bus (optionally)
          */
         ret = kvm_io_bus_write_cookie(vcpu->kvm, KVM_VIRTIO_CCW_NOTIFY_BUS,
-                                      vcpu->run->s.regs.gprs[2],
+                                      vcpu->run->s.regs.gprs[2] & 0xffffffff,
                                       8, &vcpu->run->s.regs.gprs[3],
                                       vcpu->run->s.regs.gprs[4]);
 
@@ -137,7 +137,7 @@ static int __diag_virtio_hypercall(struct kvm_vcpu *vcpu)
 
 int kvm_s390_handle_diag(struct kvm_vcpu *vcpu)
 {
-        int code = (vcpu->arch.sie_block->ipb & 0xfff0000) >> 16;
+        int code = kvm_s390_get_base_disp_rs(vcpu) & 0xffff;
 
         if (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PSTATE)
                 return kvm_s390_inject_program_int(vcpu, PGM_PRIVILEGED_OP);
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index 569494e01ec6..7635c00a1479 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -732,14 +732,16 @@ static int vcpu_post_run(struct kvm_vcpu *vcpu, int exit_reason)
 
         if (exit_reason >= 0) {
                 rc = 0;
+        } else if (kvm_is_ucontrol(vcpu->kvm)) {
+                vcpu->run->exit_reason = KVM_EXIT_S390_UCONTROL;
+                vcpu->run->s390_ucontrol.trans_exc_code =
+                                                current->thread.gmap_addr;
+                vcpu->run->s390_ucontrol.pgm_code = 0x10;
+                rc = -EREMOTE;
         } else {
-                if (kvm_is_ucontrol(vcpu->kvm)) {
-                        rc = SIE_INTERCEPT_UCONTROL;
-                } else {
-                        VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
-                        trace_kvm_s390_sie_fault(vcpu);
-                        rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
-                }
+                VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
+                trace_kvm_s390_sie_fault(vcpu);
+                rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
         }
 
         memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
@@ -833,16 +835,6 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 rc = -EINTR;
         }
 
-#ifdef CONFIG_KVM_S390_UCONTROL
-        if (rc == SIE_INTERCEPT_UCONTROL) {
-                kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
-                kvm_run->s390_ucontrol.trans_exc_code =
-                        current->thread.gmap_addr;
-                kvm_run->s390_ucontrol.pgm_code = 0x10;
-                rc = 0;
-        }
-#endif
-
         if (rc == -EOPNOTSUPP) {
                 /* intercept cannot be handled in-kernel, prepare kvm-run */
                 kvm_run->exit_reason         = KVM_EXIT_S390_SIEIC;
@@ -885,10 +877,11 @@ static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
  * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
  * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
  */
-int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
+int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr)
 {
         unsigned char archmode = 1;
         int prefix;
+        u64 clkcomp;
 
         if (addr == KVM_S390_STORE_STATUS_NOADDR) {
                 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
@@ -903,15 +896,6 @@ int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
         } else
                 prefix = 0;
 
-        /*
-         * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
-         * copying in vcpu load/put. Lets update our copies before we save
-         * it into the save area
-         */
-        save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
-        save_fp_regs(vcpu->arch.guest_fpregs.fprs);
-        save_access_regs(vcpu->run->s.regs.acrs);
-
         if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
                         vcpu->arch.guest_fpregs.fprs, 128, prefix))
                 return -EFAULT;
@@ -941,8 +925,9 @@ int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
                         &vcpu->arch.sie_block->cputm, 8, prefix))
                 return -EFAULT;
 
+        clkcomp = vcpu->arch.sie_block->ckc >> 8;
         if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
-                        &vcpu->arch.sie_block->ckc, 8, prefix))
+                        &clkcomp, 8, prefix))
                 return -EFAULT;
 
         if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
@@ -956,6 +941,20 @@ int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
         return 0;
 }
 
+int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
+{
+        /*
+         * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
+         * copying in vcpu load/put. Lets update our copies before we save
+         * it into the save area
+         */
+        save_fp_ctl(&vcpu->arch.guest_fpregs.fpc);
+        save_fp_regs(vcpu->arch.guest_fpregs.fprs);
+        save_access_regs(vcpu->run->s.regs.acrs);
+
+        return kvm_s390_store_status_unloaded(vcpu, addr);
+}
+
 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
                                      struct kvm_enable_cap *cap)
 {
diff --git a/arch/s390/kvm/kvm-s390.h b/arch/s390/kvm/kvm-s390.h
index b44912a32949..095cf51b16ec 100644
--- a/arch/s390/kvm/kvm-s390.h
+++ b/arch/s390/kvm/kvm-s390.h
@@ -19,16 +19,11 @@
 #include <linux/kvm.h>
 #include <linux/kvm_host.h>
 
-/* The current code can have up to 256 pages for virtio */
-#define VIRTIODESCSPACE (256ul * 4096ul)
-
 typedef int (*intercept_handler_t)(struct kvm_vcpu *vcpu);
 
 /* declare vfacilities extern */
 extern unsigned long *vfacilities;
 
-/* negativ values are error codes, positive values for internal conditions */
-#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...)\
@@ -133,7 +128,6 @@ int __must_check kvm_s390_inject_vm(struct kvm *kvm,
 int __must_check kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu,
                                       struct kvm_s390_interrupt *s390int);
 int __must_check kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code);
-int __must_check kvm_s390_inject_sigp_stop(struct kvm_vcpu *vcpu, int action);
 struct kvm_s390_interrupt_info *kvm_s390_get_io_int(struct kvm *kvm,
                                                     u64 cr6, u64 schid);
 
@@ -150,8 +144,8 @@ int kvm_s390_handle_eb(struct kvm_vcpu *vcpu);
 int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu);
 
 /* implemented in kvm-s390.c */
-int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu,
-                                 unsigned long addr);
+int kvm_s390_store_status_unloaded(struct kvm_vcpu *vcpu, unsigned long addr);
+int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr);
 void s390_vcpu_block(struct kvm_vcpu *vcpu);
 void s390_vcpu_unblock(struct kvm_vcpu *vcpu);
 void exit_sie(struct kvm_vcpu *vcpu);
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c
index d101dae62771..75beea632a10 100644
--- a/arch/s390/kvm/priv.c
+++ b/arch/s390/kvm/priv.c
@@ -197,7 +197,7 @@ static int handle_tpi(struct kvm_vcpu *vcpu)
         if (addr & 3)
                 return kvm_s390_inject_program_int(vcpu, PGM_SPECIFICATION);
         cc = 0;
-        inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->run->s.regs.crs[6], 0);
+        inti = kvm_s390_get_io_int(vcpu->kvm, vcpu->arch.sie_block->gcr[6], 0);
         if (!inti)
                 goto no_interrupt;
         cc = 1;
@@ -638,7 +638,6 @@ static int handle_pfmf(struct kvm_vcpu *vcpu)
 
 static const intercept_handler_t b9_handlers[256] = {
         [0x8d] = handle_epsw,
-        [0x9c] = handle_io_inst,
         [0xaf] = handle_pfmf,
 };
 
@@ -731,7 +730,6 @@ static int handle_lctlg(struct kvm_vcpu *vcpu)
 
 static const intercept_handler_t eb_handlers[256] = {
         [0x2f] = handle_lctlg,
-        [0x8a] = handle_io_inst,
 };
 
 int kvm_s390_handle_eb(struct kvm_vcpu *vcpu)
diff --git a/arch/s390/kvm/sigp.c b/arch/s390/kvm/sigp.c
index bec398c57acf..87c2b3a3bd3e 100644
--- a/arch/s390/kvm/sigp.c
+++ b/arch/s390/kvm/sigp.c
@@ -1,7 +1,7 @@
 /*
  * handling interprocessor communication
  *
- * Copyright IBM Corp. 2008, 2009
+ * Copyright IBM Corp. 2008, 2013
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License (version 2 only)
@@ -89,6 +89,37 @@ unlock:
         return rc;
 }
 
+static int __sigp_conditional_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr,
+                                        u16 asn, u64 *reg)
+{
+        struct kvm_vcpu *dst_vcpu = NULL;
+        const u64 psw_int_mask = PSW_MASK_IO | PSW_MASK_EXT;
+        u16 p_asn, s_asn;
+        psw_t *psw;
+        u32 flags;
+
+        if (cpu_addr < KVM_MAX_VCPUS)
+                dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
+        if (!dst_vcpu)
+                return SIGP_CC_NOT_OPERATIONAL;
+        flags = atomic_read(&dst_vcpu->arch.sie_block->cpuflags);
+        psw = &dst_vcpu->arch.sie_block->gpsw;
+        p_asn = dst_vcpu->arch.sie_block->gcr[4] & 0xffff;  /* Primary ASN */
+        s_asn = dst_vcpu->arch.sie_block->gcr[3] & 0xffff;  /* Secondary ASN */
+
+        /* Deliver the emergency signal? */
+        if (!(flags & CPUSTAT_STOPPED)
+            || (psw->mask & psw_int_mask) != psw_int_mask
+            || ((flags & CPUSTAT_WAIT) && psw->addr != 0)
+            || (!(flags & CPUSTAT_WAIT) && (asn == p_asn || asn == s_asn))) {
+                return __sigp_emergency(vcpu, cpu_addr);
+        } else {
+                *reg &= 0xffffffff00000000UL;
+                *reg |= SIGP_STATUS_INCORRECT_STATE;
+                return SIGP_CC_STATUS_STORED;
+        }
+}
+
 static int __sigp_external_call(struct kvm_vcpu *vcpu, u16 cpu_addr)
 {
         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
@@ -130,6 +161,7 @@ unlock:
 static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
 {
         struct kvm_s390_interrupt_info *inti;
+        int rc = SIGP_CC_ORDER_CODE_ACCEPTED;
 
         inti = kzalloc(sizeof(*inti), GFP_ATOMIC);
         if (!inti)
@@ -139,6 +171,8 @@ static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
         spin_lock_bh(&li->lock);
         if ((atomic_read(li->cpuflags) & CPUSTAT_STOPPED)) {
                 kfree(inti);
+                if ((action & ACTION_STORE_ON_STOP) != 0)
+                        rc = -ESHUTDOWN;
                 goto out;
         }
         list_add_tail(&inti->list, &li->list);
@@ -150,7 +184,7 @@ static int __inject_sigp_stop(struct kvm_s390_local_interrupt *li, int action)
 out:
         spin_unlock_bh(&li->lock);
 
-        return SIGP_CC_ORDER_CODE_ACCEPTED;
+        return rc;
 }
 
 static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
@@ -174,13 +208,17 @@ static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int action)
 unlock:
         spin_unlock(&fi->lock);
         VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
-        return rc;
-}
 
-int kvm_s390_inject_sigp_stop(struct kvm_vcpu *vcpu, int action)
-{
-        struct kvm_s390_local_interrupt *li = &vcpu->arch.local_int;
-        return __inject_sigp_stop(li, action);
+        if ((action & ACTION_STORE_ON_STOP) != 0 && rc == -ESHUTDOWN) {
+                /* If the CPU has already been stopped, we still have
+                 * to save the status when doing stop-and-store. This
+                 * has to be done after unlocking all spinlocks. */
+                struct kvm_vcpu *dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_addr);
+                rc = kvm_s390_store_status_unloaded(dst_vcpu,
+                                                KVM_S390_STORE_STATUS_NOADDR);
+        }
+
+        return rc;
 }
 
 static int __sigp_set_arch(struct kvm_vcpu *vcpu, u32 parameter)
@@ -262,6 +300,37 @@ out_fi:
         return rc;
 }
 
+static int __sigp_store_status_at_addr(struct kvm_vcpu *vcpu, u16 cpu_id,
+                                        u32 addr, u64 *reg)
+{
+        struct kvm_vcpu *dst_vcpu = NULL;
+        int flags;
+        int rc;
+
+        if (cpu_id < KVM_MAX_VCPUS)
+                dst_vcpu = kvm_get_vcpu(vcpu->kvm, cpu_id);
+        if (!dst_vcpu)
+                return SIGP_CC_NOT_OPERATIONAL;
+
+        spin_lock_bh(&dst_vcpu->arch.local_int.lock);
+        flags = atomic_read(dst_vcpu->arch.local_int.cpuflags);
+        spin_unlock_bh(&dst_vcpu->arch.local_int.lock);
+        if (!(flags & CPUSTAT_STOPPED)) {
+                *reg &= 0xffffffff00000000UL;
+                *reg |= SIGP_STATUS_INCORRECT_STATE;
+                return SIGP_CC_STATUS_STORED;
+        }
+
+        addr &= 0x7ffffe00;
+        rc = kvm_s390_store_status_unloaded(dst_vcpu, addr);
+        if (rc == -EFAULT) {
+                *reg &= 0xffffffff00000000UL;
+                *reg |= SIGP_STATUS_INVALID_PARAMETER;
+                rc = SIGP_CC_STATUS_STORED;
+        }
+        return rc;
+}
+
 static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
                                 u64 *reg)
 {
@@ -294,7 +363,8 @@ static int __sigp_sense_running(struct kvm_vcpu *vcpu, u16 cpu_addr,
         return rc;
 }
 
-static int __sigp_restart(struct kvm_vcpu *vcpu, u16 cpu_addr)
+/* Test whether the destination CPU is available and not busy */
+static int sigp_check_callable(struct kvm_vcpu *vcpu, u16 cpu_addr)
 {
         struct kvm_s390_float_interrupt *fi = &vcpu->kvm->arch.float_int;
         struct kvm_s390_local_interrupt *li;
@@ -313,9 +383,6 @@ static int __sigp_restart(struct kvm_vcpu *vcpu, u16 cpu_addr)
         spin_lock_bh(&li->lock);
         if (li->action_bits & ACTION_STOP_ON_STOP)
                 rc = SIGP_CC_BUSY;
-        else
-                VCPU_EVENT(vcpu, 4, "sigp restart %x to handle userspace",
-                        cpu_addr);
         spin_unlock_bh(&li->lock);
 out:
         spin_unlock(&fi->lock);
@@ -366,6 +433,10 @@ int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
                 rc = __sigp_stop(vcpu, cpu_addr, ACTION_STORE_ON_STOP |
                                                  ACTION_STOP_ON_STOP);
                 break;
+        case SIGP_STORE_STATUS_AT_ADDRESS:
+                rc = __sigp_store_status_at_addr(vcpu, cpu_addr, parameter,
+                                                 &vcpu->run->s.regs.gprs[r1]);
+                break;
         case SIGP_SET_ARCHITECTURE:
                 vcpu->stat.instruction_sigp_arch++;
                 rc = __sigp_set_arch(vcpu, parameter);
@@ -375,17 +446,31 @@ int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
                 rc = __sigp_set_prefix(vcpu, cpu_addr, parameter,
                                        &vcpu->run->s.regs.gprs[r1]);
                 break;
+        case SIGP_COND_EMERGENCY_SIGNAL:
+                rc = __sigp_conditional_emergency(vcpu, cpu_addr, parameter,
+                                                  &vcpu->run->s.regs.gprs[r1]);
+                break;
         case SIGP_SENSE_RUNNING:
                 vcpu->stat.instruction_sigp_sense_running++;
                 rc = __sigp_sense_running(vcpu, cpu_addr,
                                           &vcpu->run->s.regs.gprs[r1]);
                 break;
+        case SIGP_START:
+                rc = sigp_check_callable(vcpu, cpu_addr);
+                if (rc == SIGP_CC_ORDER_CODE_ACCEPTED)
+                        rc = -EOPNOTSUPP;    /* Handle START in user space */
+                break;
         case SIGP_RESTART:
                 vcpu->stat.instruction_sigp_restart++;
-                rc = __sigp_restart(vcpu, cpu_addr);
-                if (rc == SIGP_CC_BUSY)
-                        break;
-                /* user space must know about restart */
+                rc = sigp_check_callable(vcpu, cpu_addr);
+                if (rc == SIGP_CC_ORDER_CODE_ACCEPTED) {
+                        VCPU_EVENT(vcpu, 4,
+                                   "sigp restart %x to handle userspace",
+                                   cpu_addr);
+                        /* user space must know about restart */
+                        rc = -EOPNOTSUPP;
+                }
+                break;
         default:
                 return -EOPNOTSUPP;
         }
@@ -393,7 +478,6 @@ int kvm_s390_handle_sigp(struct kvm_vcpu *vcpu)
         if (rc < 0)
                 return rc;
 
-        vcpu->arch.sie_block->gpsw.mask &= ~(3ul << 44);
-        vcpu->arch.sie_block->gpsw.mask |= (rc & 3ul) << 44;
+        kvm_s390_set_psw_cc(vcpu, rc);
         return 0;
 }
diff --git a/arch/s390/kvm/trace.h b/arch/s390/kvm/trace.h
index 0c991c6748ab..3db76b2daed7 100644
--- a/arch/s390/kvm/trace.h
+++ b/arch/s390/kvm/trace.h
@@ -175,6 +175,7 @@ TRACE_EVENT(kvm_s390_intercept_validity,
         {SIGP_STOP_AND_STORE_STATUS, "stop and store status"},  \
         {SIGP_SET_ARCHITECTURE, "set architecture"},            \
         {SIGP_SET_PREFIX, "set prefix"},                        \
+        {SIGP_STORE_STATUS_AT_ADDRESS, "store status at addr"}, \
         {SIGP_SENSE_RUNNING, "sense running"},                  \
         {SIGP_RESTART, "restart"}