Add HAX support

Move the generic cpu_synchronize_ functions to the common hw_accel.h header, in order to prepare for the addition of a second hardware accelerator.

Signed-off-by Vincent Palatin <[email protected]>

---
 cpus.c                    |  1 +
 gdbstub.c                 |  1 +
 hw/i386/kvm/apic.c        |  1 +
 hw/i386/kvmvapic.c        |  1 +
 hw/misc/vmport.c          |  2 +-
 include/sysemu/hw_accel.h | 39 +++++++++++++++++++++++++++++++++++++++
 include/sysemu/kvm.h      | 23 -----------------------
 monitor.c                 |  2 +-
 qom/cpu.c                 |  2 +-
 target-arm/cpu.c          |  2 +-
 target-i386/helper.c      |  1 +
 target-i386/kvm.c         |  1 +
 12 files changed, 49 insertions(+), 27 deletions(-)
 create mode 100644 include/sysemu/hw_accel.h

cpus.c +1 -0

index 5213351..fc78502 100644
@@ -33,6 +33,7 @@
 #include "sysemu/block-backend.h"
 #include "exec/gdbstub.h"
 #include "sysemu/dma.h"
+#include "sysemu/hw_accel.h"
 #include "sysemu/kvm.h"
 #include "qmp-commands.h"
 #include "exec/exec-all.h"

gdbstub.c +1 -0

index de62d26..de9b62b 100644
@@ -32,6 +32,7 @@
 #define MAX_PACKET_LENGTH 4096
 
 #include "qemu/sockets.h"
+#include "sysemu/hw_accel.h"
 #include "sysemu/kvm.h"
 #include "exec/semihost.h"
 #include "exec/exec-all.h"

hw/i386/kvm/apic.c +1 -0

index 01cbaa8..328f80c 100644
@@ -14,6 +14,7 @@
 #include "cpu.h"
 #include "hw/i386/apic_internal.h"
 #include "hw/pci/msi.h"
+#include "sysemu/hw_accel.h"
 #include "sysemu/kvm.h"
 #include "target-i386/kvm_i386.h"
 

hw/i386/kvmvapic.c +1 -0

index b30d1b9..2f767b6 100644
@@ -14,6 +14,7 @@
 #include "exec/exec-all.h"
 #include "sysemu/sysemu.h"
 #include "sysemu/cpus.h"
+#include "sysemu/hw_accel.h"
 #include "sysemu/kvm.h"
 #include "hw/i386/apic_internal.h"
 #include "hw/sysbus.h"

hw/misc/vmport.c +1 -1

index c763811..be40930 100644
@@ -25,7 +25,7 @@
 #include "hw/hw.h"
 #include "hw/isa/isa.h"
 #include "hw/i386/pc.h"
-#include "sysemu/kvm.h"
+#include "sysemu/hw_accel.h"
 #include "hw/qdev.h"
 
 //#define VMPORT_DEBUG

include/sysemu/hw_accel.h new file +39 -0

new file mode 100644
index 0000000..03812cf
@@ -0,0 +1,39 @@
+/*
+ * QEMU Hardware accelertors support
+ *
+ * Copyright 2016 Google, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ *
+ */
+
+#ifndef QEMU_HW_ACCEL_H
+#define QEMU_HW_ACCEL_H
+
+#include "qom/cpu.h"
+#include "sysemu/hax.h"
+#include "sysemu/kvm.h"
+
+static inline void cpu_synchronize_state(CPUState *cpu)
+{
+    if (kvm_enabled()) {
+        kvm_cpu_synchronize_state(cpu);
+    }
+}
+
+static inline void cpu_synchronize_post_reset(CPUState *cpu)
+{
+    if (kvm_enabled()) {
+        kvm_cpu_synchronize_post_reset(cpu);
+    }
+}
+
+static inline void cpu_synchronize_post_init(CPUState *cpu)
+{
+    if (kvm_enabled()) {
+        kvm_cpu_synchronize_post_init(cpu);
+    }
+}
+
+#endif /* QEMU_HW_ACCEL_H */

include/sysemu/kvm.h +0 -23

index df67cc0..3045ee7 100644
@@ -461,29 +461,6 @@ void kvm_cpu_synchronize_state(CPUState *cpu);
 void kvm_cpu_synchronize_post_reset(CPUState *cpu);
 void kvm_cpu_synchronize_post_init(CPUState *cpu);
 
-/* generic hooks - to be moved/refactored once there are more users */
-
-static inline void cpu_synchronize_state(CPUState *cpu)
-{
-    if (kvm_enabled()) {
-        kvm_cpu_synchronize_state(cpu);
-    }
-}
-
-static inline void cpu_synchronize_post_reset(CPUState *cpu)
-{
-    if (kvm_enabled()) {
-        kvm_cpu_synchronize_post_reset(cpu);
-    }
-}
-
-static inline void cpu_synchronize_post_init(CPUState *cpu)
-{
-    if (kvm_enabled()) {
-        kvm_cpu_synchronize_post_init(cpu);
-    }
-}
-
 /**
  * kvm_irqchip_add_msi_route - Add MSI route for specific vector
  * @s:      KVM state

monitor.c +1 -1

index 0841d43..d38956f 100644
@@ -50,7 +50,7 @@
 #include "sysemu/balloon.h"
 #include "qemu/timer.h"
 #include "migration/migration.h"
-#include "sysemu/kvm.h"
+#include "sysemu/hw_accel.h"
 #include "qemu/acl.h"
 #include "sysemu/tpm.h"
 #include "qapi/qmp/qerror.h"

qom/cpu.c +1 -1

index 03d9190..2c5274f 100644
@@ -22,7 +22,7 @@
 #include "qapi/error.h"
 #include "qemu-common.h"
 #include "qom/cpu.h"
-#include "sysemu/kvm.h"
+#include "sysemu/hw_accel.h"
 #include "qemu/notify.h"
 #include "qemu/log.h"
 #include "exec/log.h"

target-arm/cpu.c +1 -1

index 99f0dbe..744cc11 100644
@@ -31,7 +31,7 @@
 #endif
 #include "hw/arm/arm.h"
 #include "sysemu/sysemu.h"
-#include "sysemu/kvm.h"
+#include "sysemu/hw_accel.h"
 #include "kvm_arm.h"
 
 static void arm_cpu_set_pc(CPUState *cs, vaddr value)

target-i386/helper.c +1 -0

index 4ecc091..7530280 100644
@@ -24,6 +24,7 @@
 #include "kvm_i386.h"
 #ifndef CONFIG_USER_ONLY
 #include "sysemu/sysemu.h"
+#include "sysemu/hw_accel.h"
 #include "monitor/monitor.h"
 #include "hw/i386/apic_internal.h"
 #endif

target-i386/kvm.c +0 -0

index 1c0864e..d9ad69e 100644

target-i386/hax-all.c line 607

Quoted 4 lines · Vincent Palatin

target-i386/hax-all.c new file +4 -0

+        /* need tcg for non-UG platform in real mode */
+        if (!hax_ug_platform())
+           tcg_exec_init(tcg_tb_size * 1024 * 1024);
+

Oh, it does support unrestricted guest, and in fact without unrestricted guest you don't even have SMP!

Would you post a v2 that removes (after this patch 2) as much code as possible related to non-UG platforms?

target-i386/hax-all.c line 607

Quoted 4 lines · Vincent Palatin

target-i386/hax-all.c new file +4 -0

+        /* need tcg for non-UG platform in real mode */
+        if (!hax_ug_platform())
+           tcg_exec_init(tcg_tb_size * 1024 * 1024);
+

Oh, it does support unrestricted guest, and in fact without unrestricted guest you don't even have SMP!

Would you post a v2 that removes (after this patch 2) as much code as possible related to non-UG platforms?

On Tue, Nov 08, 2016 at 04:39:28PM +0100, Vincent Palatin wrote:

Please run scripts/checkpatch.pl to verify that the code follows the QEMU coding style.

Quoted 10 lines

target-i386/hax-darwin.c new file +9 -0

+hax_fd hax_host_open_vcpu(int vmid, int vcpuid)
+{
+    char *devfs_path = NULL;
+    hax_fd fd;
+
+    devfs_path = hax_vcpu_devfs_string(vmid, vcpuid);
+    if (!devfs_path) {
+        fprintf(stderr, "Failed to get the devfs\n");
+        return -EINVAL;

target-i386/hax-darwin.c line 224

Quoted 4 lines

target-i386/hax-darwin.c new file +4 -0

+    }
+
+    fd = open(devfs_path, O_RDWR);
+    qemu_vfree(devfs_path);

g_malloc(), g_new(), g_strdup(), etc must be matched with g_free(), not qemu_vfree(). There are probably other instances of this issue in the patches.

target-i386/hax-slot.c line 32

Quoted 10 lines

target-i386/hax-slot.c new file +9 -0

+//#define DEBUG_HAX_SLOT
+
+#ifdef DEBUG_HAX_SLOT
+#define DPRINTF(fmt, ...) \
+    do { fprintf(stdout, fmt, ## __VA_ARGS__); } while (0)
+#else
+#define DPRINTF(fmt, ...) \
+    do { } while (0)
+#endif

Please consider using tracing instead of debug printfs. See docs/tracing.txt.

If you really want to keep macros, please use:

#define DEBUG_HAX_SLOT 0

#define DPRINTF(fmt, ...) \
    do { \
        if (DEBUG_HAX_SLOT) { \
            fprintf(stdout, fmt, ## __VA_ARGS__); \
        } \
    } while (0)

This approach prevents bitrot because it allows the compiler to syntax check the format string and arguments even when the printf is compiled out.

cpus.c +47 -9

index fc78502..6e0f572 100644
@@ -35,6 +35,7 @@
 #include "sysemu/dma.h"
 #include "sysemu/hw_accel.h"
 #include "sysemu/kvm.h"
+#include "sysemu/hax.h"
 #include "qmp-commands.h"
 #include "exec/exec-all.h"
 

@@ -1221,6 +1222,52 @@ static void *qemu_tcg_cpu_thread_fn(void *arg)
     return NULL;
 }
 
+static void *qemu_hax_cpu_thread_fn(void *arg)
+{
+    CPUState *cpu = arg;
+    int r;
+    qemu_thread_get_self(cpu->thread);
+    qemu_mutex_lock(&qemu_global_mutex);
+
+    cpu->thread_id = qemu_get_thread_id();
+    cpu->created = true;
+    cpu->halted = 0;
+    current_cpu = cpu;
+
+    hax_init_vcpu(cpu);
+    qemu_cond_signal(&qemu_cpu_cond);
+
+    while (1) {
+        if (cpu_can_run(cpu)) {
+            r = hax_smp_cpu_exec(cpu);
+            if (r == EXCP_DEBUG) {
+                cpu_handle_guest_debug(cpu);
+            }
+        }
+
+        while (cpu_thread_is_idle(cpu)) {
+            qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
+        }
+
+        qemu_wait_io_event_common(cpu);
+    }
+    return NULL;
+}
+
+
+static void qemu_cpu_kick_no_halt(void)
+{
+    CPUState *cpu;
+    /* Ensure whatever caused the exit has reached the CPU threads before
+     * writing exit_request.
+     */
+    atomic_mb_set(&exit_request, 1);
+    cpu = atomic_mb_read(&tcg_current_cpu);
+    if (cpu) {
+        cpu_exit(cpu);
+    }
+}
+
 static void qemu_cpu_kick_thread(CPUState *cpu)
 {
 #ifndef _WIN32

@@ -1235,28 +1282,52 @@ static void qemu_cpu_kick_thread(CPUState *cpu)
         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
         exit(1);
     }
-#else /* _WIN32 */
-    abort();
-#endif
-}
 
-static void qemu_cpu_kick_no_halt(void)
-{
-    CPUState *cpu;
-    /* Ensure whatever caused the exit has reached the CPU threads before
-     * writing exit_request.

cpus.c +20 -0

+    if (hax_enabled() && hax_ug_platform())
+        cpu->exit_request = 1;
+#endif
+#else /* _WIN32 */
+    if (!qemu_cpu_is_self(cpu)) {
+        CONTEXT tcgContext;
+
+        if (SuspendThread(cpu->hThread) == (DWORD)-1) {
+            fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
+                    GetLastError());
+            exit(1);
+        }
+
+        /* On multi-core systems, we are not sure that the thread is actually
+         * suspended until we can get the context.
+         */
+        tcgContext.ContextFlags = CONTEXT_CONTROL;
+        while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
+            continue;
+        }

cpus.c +4 -0

@@ -1617,6 +1618,21 @@ static void ram_block_add(RAMBlock *new_block, Error **errp)
         } else {
             new_block->host = phys_mem_alloc(new_block->max_length,
                                              &new_block->mr->align);
+            /*
+             * In Hax, the qemu allocate the virtual address, and HAX kernel
+             * populate the memory with physical memory. Currently we have no
+             * paging, so user should make sure enough free memory in advance

hw/intc/apic_common.c +1 -0

         vapic = sysbus_create_simple("kvmvapic", -1, NULL);
     }
+
     s->vapic = vapic;
     if (apic_report_tpr_access && info->enable_tpr_reporting) {
         info->enable_tpr_reporting(s, true);

target-i386/seg_helper.c +1 -0

index fb79f31..25b6003 100644
@@ -25,6 +25,7 @@
 #include "exec/exec-all.h"
 #include "exec/cpu_ldst.h"
 #include "exec/log.h"
+#include "sysemu/hax.h"
 
 //#define DEBUG_PCALL
 

target-i386/translate.c +4 -0

             exit(1);
         }
         configure_icount(icount_opts, &error_abort);

@@ -4555,6 +4562,10 @@ int main(int argc, char **argv, char **envp)
 
     numa_post_machine_init();
 
+    if (hax_enabled()) {
+        hax_sync_vcpus();
+    }
+
     if (qemu_opts_foreach(qemu_find_opts("fw_cfg"),
                           parse_fw_cfg, fw_cfg_find(), NULL) != 0) {
         exit(1);

cpu-exec.c

Quoted 5 lines

cpu-exec.c +0 -0

index 4188fed..4bd238b 100644

All this should not be needed anymore with unrestricted guest support.

Quoted 85 lines

cpus.c +50 -10

index fc78502..6e0f572 100644
@@ -35,6 +35,7 @@
 #include "sysemu/dma.h"
 #include "sysemu/hw_accel.h"
 #include "sysemu/kvm.h"
+#include "sysemu/hax.h"
 #include "qmp-commands.h"
 #include "exec/exec-all.h"
 

@@ -1221,6 +1222,52 @@ static void *qemu_tcg_cpu_thread_fn(void *arg)
     return NULL;
 }
 
+static void *qemu_hax_cpu_thread_fn(void *arg)
+{
+    CPUState *cpu = arg;
+    int r;
+    qemu_thread_get_self(cpu->thread);
+    qemu_mutex_lock(&qemu_global_mutex);
+
+    cpu->thread_id = qemu_get_thread_id();
+    cpu->created = true;
+    cpu->halted = 0;
+    current_cpu = cpu;
+
+    hax_init_vcpu(cpu);
+    qemu_cond_signal(&qemu_cpu_cond);
+
+    while (1) {
+        if (cpu_can_run(cpu)) {
+            r = hax_smp_cpu_exec(cpu);
+            if (r == EXCP_DEBUG) {
+                cpu_handle_guest_debug(cpu);
+            }
+        }
+
+        while (cpu_thread_is_idle(cpu)) {
+            qemu_cond_wait(cpu->halt_cond, &qemu_global_mutex);
+        }
+
+        qemu_wait_io_event_common(cpu);
+    }
+    return NULL;
+}
+
+
+static void qemu_cpu_kick_no_halt(void)
+{
+    CPUState *cpu;
+    /* Ensure whatever caused the exit has reached the CPU threads before
+     * writing exit_request.
+     */
+    atomic_mb_set(&exit_request, 1);
+    cpu = atomic_mb_read(&tcg_current_cpu);
+    if (cpu) {
+        cpu_exit(cpu);
+    }
+}
+
 static void qemu_cpu_kick_thread(CPUState *cpu)
 {
 #ifndef _WIN32

@@ -1235,28 +1282,52 @@ static void qemu_cpu_kick_thread(CPUState *cpu)
         fprintf(stderr, "qemu:%s: %s", __func__, strerror(err));
         exit(1);
     }
-#else /* _WIN32 */
-    abort();
-#endif
-}
 
-static void qemu_cpu_kick_no_halt(void)
-{
-    CPUState *cpu;
-    /* Ensure whatever caused the exit has reached the CPU threads before
-     * writing exit_request.
+#ifdef CONFIG_DARWIN
+    /* The cpu thread cannot catch it reliably when shutdown the guest on Mac.
+     * We can double check it and resend it
      */
-    atomic_mb_set(&exit_request, 1);

cpus.c static void qemu_cpu_kick_thread(CPUState *cpu) · line 1291

Quoted 5 lines

cpus.c +2 -3

-    cpu = atomic_mb_read(&tcg_current_cpu);
-    if (cpu) {
-        cpu_exit(cpu);
+    if (!exit_request)
+        qemu_cpu_kick_no_halt();

This must be a conflict resolved wrong. exit_request is never read by the HAX code.

Quoted 26 lines

cpus.c +25 -0

+    if (hax_enabled() && hax_ug_platform())
+        cpu->exit_request = 1;
+#endif
+#else /* _WIN32 */
+    if (!qemu_cpu_is_self(cpu)) {
+        CONTEXT tcgContext;
+
+        if (SuspendThread(cpu->hThread) == (DWORD)-1) {
+            fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
+                    GetLastError());
+            exit(1);
+        }
+
+        /* On multi-core systems, we are not sure that the thread is actually
+         * suspended until we can get the context.
+         */
+        tcgContext.ContextFlags = CONTEXT_CONTROL;
+        while (GetThreadContext(cpu->hThread, &tcgContext) != 0) {
+            continue;
+        }
+
+        qemu_cpu_kick_no_halt();
+        if (hax_enabled() && hax_ug_platform())
+            cpu->exit_request = 1;
+

cpus.c static void qemu_cpu_kick_thread(CPUState *cpu) · line 1322

Quoted 5 lines

cpus.c +5 -0

+        if (ResumeThread(cpu->hThread) == (DWORD)-1) {
+            fprintf(stderr, "qemu:%s: GetLastError:%lu\n", __func__,
+                    GetLastError());
+            exit(1);
+        }

This is weird too. The SuspendThread/ResumeThread dance comes from an old version of QEMU. It is not needed anymore and,

again,
qemu_cpu_kick_no_halt would only be useful if hax_ug_platform() is false.

Here, Linux/KVM uses a signal and pthread_kill. It's probably good for HAX on Darwin too, but not on Windows. It's possible that SuspendThread/ResumeThread just does the right thing (sort of by chance), in which case you can just keep it (removing qemu_cpu_kick_no_halt). However, there is a hax_raise_event in patch 2 that is unused. If you can figure out how to use it it would be better.

Quoted 16 lines

cpus.c +10 -0

@@ -1617,6 +1618,21 @@ static void ram_block_add(RAMBlock *new_block, Error **errp)
         } else {
             new_block->host = phys_mem_alloc(new_block->max_length,
                                              &new_block->mr->align);
+            /*
+             * In Hax, the qemu allocate the virtual address, and HAX kernel
+             * populate the memory with physical memory. Currently we have no
+             * paging, so user should make sure enough free memory in advance
+             */
+            if (hax_enabled()) {
+                int ret;
+                ret = hax_populate_ram((uint64_t)(uintptr_t)new_block->host,
+                                       new_block->max_length);
+                if (ret < 0) {

cpus.c static void ram_block_add(RAMBlock *new_block, Error **errp) · line 1634

Quoted 4 lines

cpus.c +4 -0

+                    error_setg(errp, "Hax failed to populate ram");
+                    return;
+                }
+            }

Please try removing this block and instead starting QEMU with -mem-prealloc. If it works, remove hax_populate_ram and just set mem_prealloc to 1 in hax_accel_init.

Quoted 10 lines

cpus.c +0 -0

             if (!new_block->host) {
                 error_setg_errno(errp, errno,
                                  "cannot set up guest memory '%s'",

hw/intc/apic_common.c +0 -0

index d78c885..dd4cdc8 100644
@@ -316,9 +316,10 @@ static void apic_common_realize(DeviceState *dev, Error **errp)
 

hw/intc/apic_common.c static void apic_common_realize(DeviceState *dev, Error **errp) · line 319

Quoted 4 lines

hw/intc/apic_common.c +1 -1

     /* Note: We need at least 1M to map the VAPIC option ROM */
     if (!vapic && s->vapic_control & VAPIC_ENABLE_MASK &&
-        ram_size >= 1024 * 1024) {
+        kvm_enabled() && ram_size >= 1024 * 1024) {

This should rather be !hax_enabled(), despite the historical name mentions KVM.

Quoted 19 lines

hw/intc/apic_common.c +1 -0

         vapic = sysbus_create_simple("kvmvapic", -1, NULL);
     }
+
     s->vapic = vapic;
     if (apic_report_tpr_access && info->enable_tpr_reporting) {
         info->enable_tpr_reporting(s, true);

target-i386/seg_helper.c +1 -0

index fb79f31..25b6003 100644
@@ -25,6 +25,7 @@
 #include "exec/exec-all.h"
 #include "exec/cpu_ldst.h"
 #include "exec/log.h"
+#include "sysemu/hax.h"
 
 //#define DEBUG_PCALL
 

target-i386/seg_helper.c bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request) · line 1343

Quoted 8 lines

target-i386/seg_helper.c +4 -0

@@ -1336,6 +1337,10 @@ bool x86_cpu_exec_interrupt(CPUState *cs, int interrupt_request)
             !(env->hflags & HF_SMM_MASK)) {
             cpu_svm_check_intercept_param(env, SVM_EXIT_SMI, 0);
             cs->interrupt_request &= ~CPU_INTERRUPT_SMI;
+#ifdef CONFIG_HAX
+            if (hax_enabled())
+                cs->hax_vcpu->resync = 1;
+#endif

Not needed for UG mode.

target-i386/translate.c

Quoted 8 lines

target-i386/seg_helper.c +0 -0

             do_smm_enter(cpu);
             ret = true;
         } else if ((interrupt_request & CPU_INTERRUPT_NMI) &&

target-i386/translate.c +0 -0

index 324103c..e027896 100644

Same.

target-i386/translate.c int main(int argc, char **argv, char **envp) · line 4069

Quoted 5 lines

target-i386/translate.c +1 -0

@@ -4060,6 +4066,7 @@ int main(int argc, char **argv, char **envp)
     machine_class = select_machine();
 
     set_memory_options(&ram_slots, &maxram_size, machine_class);
+    hax_pre_init(ram_size);

It should be possible to merge this with hax_accel_init.

Quoted 5 lines

target-i386/translate.c +0 -0

     os_daemonize();
 

@@ -4418,8 +4425,8 @@ int main(int argc, char **argv, char **envp)
 

target-i386/translate.c int main(int argc, char **argv, char **envp) · line 4429

Quoted 6 lines

target-i386/translate.c +2 -2

     cpu_ticks_init();
     if (icount_opts) {
-        if (kvm_enabled() || xen_enabled()) {
-            error_report("-icount is not allowed with kvm or xen");
+        if (kvm_enabled() || xen_enabled() || hax_enabled()) {
+            error_report("-icount is not allowed with kvm or xen or hax");

Let's say it's only allowed with TCG. :) Again, thanks to UG mode if hax_enabled() you'll have !tcg_enabled().

Paolo

Quoted 15 lines

target-i386/translate.c +4 -0

             exit(1);
         }
         configure_icount(icount_opts, &error_abort);

@@ -4555,6 +4562,10 @@ int main(int argc, char **argv, char **envp)
 
     numa_post_machine_init();
 
+    if (hax_enabled()) {
+        hax_sync_vcpus();
+    }
+
     if (qemu_opts_foreach(qemu_find_opts("fw_cfg"),
                           parse_fw_cfg, fw_cfg_find(), NULL) != 0) {
         exit(1);

Quoted 3 lines

Quoted 3 lines

Please try removing this block and instead starting QEMU with -mem-prealloc. If it works, remove hax_populate_ram and just set mem_prealloc to 1 in hax_accel_init.

it's not working, later hax_set_ram() is unhappy about what it is finding the mappings.
By the way, even if it had worked at startup, under memory pressure, Windows might have evicted the physical pages (which is not supported by the HAXM kernel module)

I can try to move this in os_mem_prealloc() if you feel it's cleaner.

Quoted 9 lines · Vincent Palatin

Quoted 3 lines

Quoted 3 lines

Please try removing this block and instead starting QEMU with -mem-prealloc. If it works, remove hax_populate_ram and just set mem_prealloc to 1 in hax_accel_init.

it's not working, later hax_set_ram() is unhappy about what it is finding the mappings.
By the way, even if it had worked at startup, under memory pressure, Windows might have evicted the physical pages (which is not supported by the HAXM kernel module)

Quoted 1 line

I can try to move this in os_mem_prealloc() if you feel it's cleaner.

Yes, that would work!

Quoted 12 lines · Paolo Bonzini

Quoted 9 lines · Vincent Palatin

Quoted 3 lines

Quoted 3 lines

Please try removing this block and instead starting QEMU with -mem-prealloc. If it works, remove hax_populate_ram and just set mem_prealloc to 1 in hax_accel_init.

it's not working, later hax_set_ram() is unhappy about what it is finding the mappings.
By the way, even if it had worked at startup, under memory pressure, Windows might have evicted the physical pages (which is not supported by the HAXM kernel module)

Quoted 3 lines

Quoted 1 line

I can try to move this in os_mem_prealloc() if you feel it's cleaner.

Yes, that would work!

Actually, os_mem_prealloc seems mostly no-op in the win32 version, I have postponed this change for after my v2 patchset.

I took a stab at trying to rebase/upstream the support for Intel HAXM. (Hardware Accelerated Execution Manager).
Intel HAX is kernel-based hardware acceleration module for Windows and MacOSX.

I have based my work on the last version of the source code I found:
the emu-2.2-release branch in the external/qemu-android repository as used by the Android emulator.
In patch 2/3, I have forward-ported the core HAX code mostly unmodified from there, I just did some minor touch up to make it build and run properly. So it might contain some outdated constructs and probably requires more attention (thus the 'RFC' for this patchset).

Quoted 11 lines · Vincent Palatin

I took a stab at trying to rebase/upstream the support for Intel HAXM. (Hardware Accelerated Execution Manager).
Intel HAX is kernel-based hardware acceleration module for Windows and MacOSX.

I have based my work on the last version of the source code I found:
the emu-2.2-release branch in the external/qemu-android repository as used by the Android emulator.
In patch 2/3, I have forward-ported the core HAX code mostly unmodified from there, I just did some minor touch up to make it build and run properly. So it might contain some outdated constructs and probably requires more attention (thus the 'RFC' for this patchset).

Does HAXM support the "unrestricted guest" feature in Westmere and more recent processors?

If so, I think we should only support those
processors and slash all the part related to HAX_EMULATE_STATE_INITIAL and HAX_EMULATE_STATE_REAL. This would probably let us make patch 3 much less intrusive.

That said, patch 3's cpu-exec.c surgery is much nicer on the surface than if you look in depth, :) and since you don't look in depth if you steer clear of target-i386/hax*, I think it's okay to start with your patches and clean up progressively. Others may disagree... Also, we're now in soft freeze so the patches wouldn't be merged anyway for a few weeks.

Paolo

Quoted 4 lines

If so, I think we should only support those
processors and slash all the part related to HAX_EMULATE_STATE_INITIAL and HAX_EMULATE_STATE_REAL. This would probably let us make patch 3 much less intrusive.

Sure the whole patchset would be lighter, not sure which proportion of user have VT machines without UG support though.