1 files changed, 171 insertions, 21 deletions

diff --git a/arch/x86/kvm/hyperv.c b/arch/x86/kvm/hyperv.c
index dc97f2544b6f..98618e397342 100644
--- a/arch/x86/kvm/hyperv.c
+++ b/arch/x86/kvm/hyperv.c
@@ -29,6 +29,7 @@
 #include <linux/kvm_host.h>
 #include <linux/highmem.h>
 #include <linux/sched/cputime.h>
+#include <linux/eventfd.h>
 
 #include <asm/apicdef.h>
 #include <trace/events/kvm.h>
@@ -74,13 +75,38 @@ static bool synic_has_vector_auto_eoi(struct kvm_vcpu_hv_synic *synic,
         return false;
 }
 
+static void synic_update_vector(struct kvm_vcpu_hv_synic *synic,
+                                int vector)
+{
+        if (vector < HV_SYNIC_FIRST_VALID_VECTOR)
+                return;
+
+        if (synic_has_vector_connected(synic, vector))
+                __set_bit(vector, synic->vec_bitmap);
+        else
+                __clear_bit(vector, synic->vec_bitmap);
+
+        if (synic_has_vector_auto_eoi(synic, vector))
+                __set_bit(vector, synic->auto_eoi_bitmap);
+        else
+                __clear_bit(vector, synic->auto_eoi_bitmap);
+}
+
 static int synic_set_sint(struct kvm_vcpu_hv_synic *synic, int sint,
                           u64 data, bool host)
 {
-        int vector;
+        int vector, old_vector;
+        bool masked;
 
         vector = data & HV_SYNIC_SINT_VECTOR_MASK;
-        if (vector < 16 && !host)
+        masked = data & HV_SYNIC_SINT_MASKED;
+
+        /*
+         * Valid vectors are 16-255, however, nested Hyper-V attempts to write
+         * default '0x10000' value on boot and this should not #GP. We need to
+         * allow zero-initing the register from host as well.
+         */
+        if (vector < HV_SYNIC_FIRST_VALID_VECTOR && !host && !masked)
                 return 1;
         /*
          * Guest may configure multiple SINTs to use the same vector, so
@@ -88,18 +114,13 @@ static int synic_set_sint(struct kvm_vcpu_hv_synic *synic, int sint,
          * bitmap of vectors with auto-eoi behavior.  The bitmaps are
          * updated here, and atomically queried on fast paths.
          */
+        old_vector = synic_read_sint(synic, sint) & HV_SYNIC_SINT_VECTOR_MASK;
 
         atomic64_set(&synic->sint[sint], data);
 
-        if (synic_has_vector_connected(synic, vector))
-                __set_bit(vector, synic->vec_bitmap);
-        else
-                __clear_bit(vector, synic->vec_bitmap);
+        synic_update_vector(synic, old_vector);
 
-        if (synic_has_vector_auto_eoi(synic, vector))
-                __set_bit(vector, synic->auto_eoi_bitmap);
-        else
-                __clear_bit(vector, synic->auto_eoi_bitmap);
+        synic_update_vector(synic, vector);
 
         /* Load SynIC vectors into EOI exit bitmap */
         kvm_make_request(KVM_REQ_SCAN_IOAPIC, synic_to_vcpu(synic));
@@ -736,6 +757,9 @@ static bool kvm_hv_msr_partition_wide(u32 msr)
         case HV_X64_MSR_CRASH_CTL:
         case HV_X64_MSR_CRASH_P0 ... HV_X64_MSR_CRASH_P4:
         case HV_X64_MSR_RESET:
+        case HV_X64_MSR_REENLIGHTENMENT_CONTROL:
+        case HV_X64_MSR_TSC_EMULATION_CONTROL:
+        case HV_X64_MSR_TSC_EMULATION_STATUS:
                 r = true;
                 break;
         }
@@ -981,6 +1005,15 @@ static int kvm_hv_set_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 data,
                         kvm_make_request(KVM_REQ_HV_RESET, vcpu);
                 }
                 break;
+        case HV_X64_MSR_REENLIGHTENMENT_CONTROL:
+                hv->hv_reenlightenment_control = data;
+                break;
+        case HV_X64_MSR_TSC_EMULATION_CONTROL:
+                hv->hv_tsc_emulation_control = data;
+                break;
+        case HV_X64_MSR_TSC_EMULATION_STATUS:
+                hv->hv_tsc_emulation_status = data;
+                break;
         default:
                 vcpu_unimpl(vcpu, "Hyper-V uhandled wrmsr: 0x%x data 0x%llx\n",
                             msr, data);
@@ -1009,17 +1042,17 @@ static int kvm_hv_set_msr(struct kvm_vcpu *vcpu, u32 msr, u64 data, bool host)
                         return 1;
                 hv->vp_index = (u32)data;
                 break;
-        case HV_X64_MSR_APIC_ASSIST_PAGE: {
+        case HV_X64_MSR_VP_ASSIST_PAGE: {
                 u64 gfn;
                 unsigned long addr;
 
-                if (!(data & HV_X64_MSR_APIC_ASSIST_PAGE_ENABLE)) {
+                if (!(data & HV_X64_MSR_VP_ASSIST_PAGE_ENABLE)) {
                         hv->hv_vapic = data;
                         if (kvm_lapic_enable_pv_eoi(vcpu, 0))
                                 return 1;
                         break;
                 }
-                gfn = data >> HV_X64_MSR_APIC_ASSIST_PAGE_ADDRESS_SHIFT;
+                gfn = data >> HV_X64_MSR_VP_ASSIST_PAGE_ADDRESS_SHIFT;
                 addr = kvm_vcpu_gfn_to_hva(vcpu, gfn);
                 if (kvm_is_error_hva(addr))
                         return 1;
@@ -1105,6 +1138,15 @@ static int kvm_hv_get_msr_pw(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
         case HV_X64_MSR_RESET:
                 data = 0;
                 break;
+        case HV_X64_MSR_REENLIGHTENMENT_CONTROL:
+                data = hv->hv_reenlightenment_control;
+                break;
+        case HV_X64_MSR_TSC_EMULATION_CONTROL:
+                data = hv->hv_tsc_emulation_control;
+                break;
+        case HV_X64_MSR_TSC_EMULATION_STATUS:
+                data = hv->hv_tsc_emulation_status;
+                break;
         default:
                 vcpu_unimpl(vcpu, "Hyper-V unhandled rdmsr: 0x%x\n", msr);
                 return 1;
@@ -1129,7 +1171,7 @@ static int kvm_hv_get_msr(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
                 return kvm_hv_vapic_msr_read(vcpu, APIC_ICR, pdata);
         case HV_X64_MSR_TPR:
                 return kvm_hv_vapic_msr_read(vcpu, APIC_TASKPRI, pdata);
-        case HV_X64_MSR_APIC_ASSIST_PAGE:
+        case HV_X64_MSR_VP_ASSIST_PAGE:
                 data = hv->hv_vapic;
                 break;
         case HV_X64_MSR_VP_RUNTIME:
@@ -1226,10 +1268,47 @@ static int kvm_hv_hypercall_complete_userspace(struct kvm_vcpu *vcpu)
         return 1;
 }
 
+static u16 kvm_hvcall_signal_event(struct kvm_vcpu *vcpu, bool fast, u64 param)
+{
+        struct eventfd_ctx *eventfd;
+
+        if (unlikely(!fast)) {
+                int ret;
+                gpa_t gpa = param;
+
+                if ((gpa & (__alignof__(param) - 1)) ||
+                    offset_in_page(gpa) + sizeof(param) > PAGE_SIZE)
+                        return HV_STATUS_INVALID_ALIGNMENT;
+
+                ret = kvm_vcpu_read_guest(vcpu, gpa, &param, sizeof(param));
+                if (ret < 0)
+                        return HV_STATUS_INVALID_ALIGNMENT;
+        }
+
+        /*
+         * Per spec, bits 32-47 contain the extra "flag number".  However, we
+         * have no use for it, and in all known usecases it is zero, so just
+         * report lookup failure if it isn't.
+         */
+        if (param & 0xffff00000000ULL)
+                return HV_STATUS_INVALID_PORT_ID;
+        /* remaining bits are reserved-zero */
+        if (param & ~KVM_HYPERV_CONN_ID_MASK)
+                return HV_STATUS_INVALID_HYPERCALL_INPUT;
+
+        /* conn_to_evt is protected by vcpu->kvm->srcu */
+        eventfd = idr_find(&vcpu->kvm->arch.hyperv.conn_to_evt, param);
+        if (!eventfd)
+                return HV_STATUS_INVALID_PORT_ID;
+
+        eventfd_signal(eventfd, 1);
+        return HV_STATUS_SUCCESS;
+}
+
 int kvm_hv_hypercall(struct kvm_vcpu *vcpu)
 {
-        u64 param, ingpa, outgpa, ret;
-        uint16_t code, rep_idx, rep_cnt, res = HV_STATUS_SUCCESS, rep_done = 0;
+        u64 param, ingpa, outgpa, ret = HV_STATUS_SUCCESS;
+        uint16_t code, rep_idx, rep_cnt;
         bool fast, longmode;
 
         /*
@@ -1268,7 +1347,7 @@ int kvm_hv_hypercall(struct kvm_vcpu *vcpu)
 
         /* Hypercall continuation is not supported yet */
         if (rep_cnt || rep_idx) {
-                res = HV_STATUS_INVALID_HYPERCALL_CODE;
+                ret = HV_STATUS_INVALID_HYPERCALL_CODE;
                 goto set_result;
         }
 
@@ -1276,11 +1355,15 @@ int kvm_hv_hypercall(struct kvm_vcpu *vcpu)
         case HVCALL_NOTIFY_LONG_SPIN_WAIT:
                 kvm_vcpu_on_spin(vcpu, true);
                 break;
-        case HVCALL_POST_MESSAGE:
         case HVCALL_SIGNAL_EVENT:
+                ret = kvm_hvcall_signal_event(vcpu, fast, ingpa);
+                if (ret != HV_STATUS_INVALID_PORT_ID)
+                        break;
+                /* maybe userspace knows this conn_id: fall through */
+        case HVCALL_POST_MESSAGE:
                 /* don't bother userspace if it has no way to handle it */
                 if (!vcpu_to_synic(vcpu)->active) {
-                        res = HV_STATUS_INVALID_HYPERCALL_CODE;
+                        ret = HV_STATUS_INVALID_HYPERCALL_CODE;
                         break;
                 }
                 vcpu->run->exit_reason = KVM_EXIT_HYPERV;
@@ -1292,12 +1375,79 @@ int kvm_hv_hypercall(struct kvm_vcpu *vcpu)
                                 kvm_hv_hypercall_complete_userspace;
                 return 0;
         default:
-                res = HV_STATUS_INVALID_HYPERCALL_CODE;
+                ret = HV_STATUS_INVALID_HYPERCALL_CODE;
                 break;
         }
 
 set_result:
-        ret = res | (((u64)rep_done & 0xfff) << 32);
         kvm_hv_hypercall_set_result(vcpu, ret);
         return 1;
 }
+
+void kvm_hv_init_vm(struct kvm *kvm)
+{
+        mutex_init(&kvm->arch.hyperv.hv_lock);
+        idr_init(&kvm->arch.hyperv.conn_to_evt);
+}
+
+void kvm_hv_destroy_vm(struct kvm *kvm)
+{
+        struct eventfd_ctx *eventfd;
+        int i;
+
+        idr_for_each_entry(&kvm->arch.hyperv.conn_to_evt, eventfd, i)
+                eventfd_ctx_put(eventfd);
+        idr_destroy(&kvm->arch.hyperv.conn_to_evt);
+}
+
+static int kvm_hv_eventfd_assign(struct kvm *kvm, u32 conn_id, int fd)
+{
+        struct kvm_hv *hv = &kvm->arch.hyperv;
+        struct eventfd_ctx *eventfd;
+        int ret;
+
+        eventfd = eventfd_ctx_fdget(fd);
+        if (IS_ERR(eventfd))
+                return PTR_ERR(eventfd);
+
+        mutex_lock(&hv->hv_lock);
+        ret = idr_alloc(&hv->conn_to_evt, eventfd, conn_id, conn_id + 1,
+                        GFP_KERNEL);
+        mutex_unlock(&hv->hv_lock);
+
+        if (ret >= 0)
+                return 0;
+
+        if (ret == -ENOSPC)
+                ret = -EEXIST;
+        eventfd_ctx_put(eventfd);
+        return ret;
+}
+
+static int kvm_hv_eventfd_deassign(struct kvm *kvm, u32 conn_id)
+{
+        struct kvm_hv *hv = &kvm->arch.hyperv;
+        struct eventfd_ctx *eventfd;
+
+        mutex_lock(&hv->hv_lock);
+        eventfd = idr_remove(&hv->conn_to_evt, conn_id);
+        mutex_unlock(&hv->hv_lock);
+
+        if (!eventfd)
+                return -ENOENT;
+
+        synchronize_srcu(&kvm->srcu);
+        eventfd_ctx_put(eventfd);
+        return 0;
+}
+
+int kvm_vm_ioctl_hv_eventfd(struct kvm *kvm, struct kvm_hyperv_eventfd *args)
+{
+        if ((args->flags & ~KVM_HYPERV_EVENTFD_DEASSIGN) ||
+            (args->conn_id & ~KVM_HYPERV_CONN_ID_MASK))
+                return -EINVAL;
+
+        if (args->flags == KVM_HYPERV_EVENTFD_DEASSIGN)
+                return kvm_hv_eventfd_deassign(kvm, args->conn_id);
+        return kvm_hv_eventfd_assign(kvm, args->conn_id, args->fd);
+}