crosvm: support kvm's hyper-v cpuid ioctl

Kvm can emulate the hyper-v paravirt interface.  Newer versions of kvm
can advertise the features they support via an ioctl() that reports the
cpuid leafs for this interface.  This change adds some support for the
ioctl() and plumbs it through the plugin interface so that plugins can
determine the level of support available in kvm.

BUG=b:144746965
TEST=Ran build_test on kernel that supports the ioctl.  Added temporary
code to print the cpuid leafs and verified that the output is as
expected.  Instrumented failure as expected from older kernels and
verified that results still passed.

Change-Id: I6cd7dade1793e4edb52b331d5b960685541f7ba3
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/crosvm/+/2037919
Tested-by: Matt Delco <delco@chromium.org>
Tested-by: kokoro <noreply+kokoro@google.com>
Reviewed-by: Daniel Verkamp <dverkamp@chromium.org>
Commit-Queue: Matt Delco <delco@chromium.org>

1 files changed, 68 insertions, 28 deletions

diff --git a/tests/plugin_supported_cpuid.c b/tests/plugin_supported_cpuid.c
index 0acb134..7109ff3 100644
--- a/tests/plugin_supported_cpuid.c
+++ b/tests/plugin_supported_cpuid.c
@@ -12,56 +12,96 @@
 
 #include "crosvm.h"
 
-int main(int argc, char** argv) {
-    struct crosvm *crosvm;
-    int ret = crosvm_connect(&crosvm);
-    if (ret) {
-        fprintf(stderr, "failed to connect to crosvm: %d\n", ret);
-        return 1;
-    }
+typedef int (*crosvm_function)(struct crosvm*, uint32_t,
+                               struct kvm_cpuid_entry2*, uint32_t*);
+typedef int (*vcpu_function)(struct crosvm_vcpu*, uint32_t,
+                             struct kvm_cpuid_entry2*, uint32_t*);
+
+// Members of union should only differ by the pointer type of 1st arg.
+union cpuid_function {
+    crosvm_function crosvm;
+    vcpu_function vcpu;
+};
 
+int test_cpuid(void* crosvm, union cpuid_function funct, const char* name) {
     struct kvm_cpuid_entry2 cpuids[100];
-    int n_entries;
-    ret = crosvm_get_supported_cpuid(crosvm, 1, cpuids, &n_entries);
+    int n_entries = 0;
+    int ret = funct.crosvm(crosvm, 1, cpuids, &n_entries);
     if (ret >= 0) {
         fprintf(stderr,
-                "expected crosvm_get_supported_cpuids to fail with E2BIG\n");
-        return 1;
+                "expected %s to fail with E2BIG\n", name);
+        return ret;
     }
 
-    ret = crosvm_get_supported_cpuid(crosvm, 100, cpuids, &n_entries);
+    ret = funct.crosvm(crosvm, 100, cpuids, &n_entries);
     if (ret < 0) {
-        fprintf(stderr,
-                "unexpected failure of crosvm_get_supported_cpuids: %d\n", ret);
-        return 1;
+        if (ret != -EINVAL) {
+            fprintf(stderr, "unexpected failure of %s: %d\n", name, ret);
+        } else {
+            fprintf(stderr,
+                    "Query of %s failed with EINVAL (may be expected)\n",
+                    name, ret);
+        }
+        return ret;
     }
 
     if (n_entries <= 1) {
         fprintf(stderr,
-                "unexpected number of supported cpuid entries: %d\n",
-                n_entries);
+                "unexpected number of cpuid entries from %s: %d\n",
+                name, n_entries);
         return 1;
     }
+    return 0;
+}
 
-    ret = crosvm_get_emulated_cpuid(crosvm, 1, cpuids, &n_entries);
-    if (ret >= 0) {
-        fprintf(stderr,
-                "expected crosvm_get_emulated_cpuids to fail with E2BIG\n");
+int main(int argc, char** argv) {
+    struct crosvm* crosvm = NULL;
+    int ret = crosvm_connect(&crosvm);
+    if (ret) {
+        fprintf(stderr, "failed to connect to crosvm: %d\n", ret);
         return 1;
     }
 
-    ret = crosvm_get_emulated_cpuid(crosvm, 100, cpuids, &n_entries);
-    if (ret < 0) {
-        fprintf(stderr,
-                "unexpected failure of crosvm_get_emulated_cpuid: %d\n", ret);
+    struct crosvm_vcpu* vcpu = NULL;
+    ret = crosvm_get_vcpu(crosvm, 0, &vcpu);
+    if (ret) {
+        fprintf(stderr, "failed to get vcpu #0: %d\n", ret);
         return 1;
     }
 
-    if (n_entries < 1) {
-        fprintf(stderr,
-                "unexpected number of emulated cpuid entries: %d\n", n_entries);
+    union cpuid_function funct;
+    funct.crosvm = crosvm_get_supported_cpuid;
+    if (test_cpuid(crosvm, funct, "crosvm_get_supported_cpuid")) {
+        return 1;
+    }
+    funct.crosvm = crosvm_get_emulated_cpuid;
+    if (test_cpuid(crosvm, funct, "crosvm_get_emulated_cpuid")) {
+        return 1;
+    }
+
+    ret = crosvm_start(crosvm);
+    if (ret) {
+        fprintf(stderr, "failed to start vm: %d\n", ret);
         return 1;
     }
 
+    struct crosvm_vcpu_event evt = {0};
+    ret = crosvm_vcpu_wait(vcpu, &evt);
+    if (ret) {
+        fprintf(stderr, "failed to wait for vm start: %d\n", ret);
+        return 1;
+    }
+    if (evt.kind != CROSVM_VCPU_EVENT_KIND_INIT) {
+        fprintf(stderr, "Got unexpected exit type: %d\n", evt.kind);
+        return 1;
+    }
+
+    funct.vcpu = crosvm_get_hyperv_cpuid;
+    ret = test_cpuid(vcpu, funct, "crosvm_get_hyperv_cpuid");
+    // Older kernels don't support and return EINVAL, so allow this for now.
+    if (ret && ret != -EINVAL) {
+        fprintf(stderr, "Ignoring failure of crosvm_get_hyperv_cpuid\n");
+        return 1;
+    }
     return 0;
 }