Added support for Linux hosts

Author: AlexAltea

.gitignore

@@ -18,3 +18,13 @@ Win8.1Release/
 # macOS
 /darwin/hax_driver/com_intel_hax/build/
 .DS_Store
+
+# Linux
+*.o
+*.cmd
+*.ko
+*.mod.c
+.tmp_versions
+.cache.mk
+modules.order
+Module.symvers

core/cpu.c

@@ -47,15 +47,15 @@ static void cpu_vmentry_failed(struct vcpu_t *vcpu, vmx_result_t result);
 static int cpu_vmexit_handler(struct vcpu_t *vcpu, exit_reason_t exit_reason,
                               struct hax_tunnel *htun);
 
-static int cpu_emt64_enable()
+static int cpu_emt64_enable(void)
 {
     uint32 effer;
 
     effer = ia32_rdmsr(IA32_EFER);
     return effer & 0x400;
 }
 
-static int cpu_nx_enable()
+static int cpu_nx_enable(void)
 {
     uint32 effer;
 
@@ -71,7 +71,7 @@ bool cpu_has_feature(uint32_t feature)
     return cpuid_host_has_feature(&cache, feature);
 }
 
-void cpu_init_feature_cache()
+void cpu_init_feature_cache(void)
 {
     cpuid_host_init(&cache);
 }
@@ -572,7 +572,7 @@ uint32 load_vmcs(struct vcpu_t *vcpu, preempt_flag *flags)
     /* when wake up from sleep, we need the barrier, as vm operation
      * are not serialized instructions.
      */
-    smp_mb();
+    hax_smp_mb();
 
     cpu_data = current_cpu_data();
 

core/emulate.c

@@ -288,7 +288,7 @@ static bool is_translation_required(struct em_context_t *ctxt)
 static uint64_t get_canonical_address(struct em_context_t *ctxt,
                                       uint64_t addr, uint vaddr_bits)
 {
-    return ((int64)addr << (64 - vaddr_bits)) >> (64 - vaddr_bits);
+    return ((int64_t)addr << (64 - vaddr_bits)) >> (64 - vaddr_bits);
 }
 
 static em_status_t get_linear_address(struct em_context_t *ctxt,
@@ -475,24 +475,24 @@ static uint64_t insn_fetch_u64(struct em_context_t *ctxt)
     return result;
 }
 
-static int8 insn_fetch_s8(struct em_context_t *ctxt)
+static int8_t insn_fetch_s8(struct em_context_t *ctxt)
 {
-    return (int8)insn_fetch_u8(ctxt);
+    return (int8_t)insn_fetch_u8(ctxt);
 }
 
-static int16 insn_fetch_s16(struct em_context_t *ctxt)
+static int16_t insn_fetch_s16(struct em_context_t *ctxt)
 {
-    return (int16)insn_fetch_u16(ctxt);
+    return (int16_t)insn_fetch_u16(ctxt);
 }
 
-static int32 insn_fetch_s32(struct em_context_t *ctxt)
+static int32_t insn_fetch_s32(struct em_context_t *ctxt)
 {
-    return (int32)insn_fetch_u32(ctxt);
+    return (int32_t)insn_fetch_u32(ctxt);
 }
 
-static int64 insn_fetch_s64(struct em_context_t *ctxt)
+static int64_t insn_fetch_s64(struct em_context_t *ctxt)
 {
-    return (int64)insn_fetch_u64(ctxt);
+    return (int64_t)insn_fetch_u64(ctxt);
 }
 
 static void decode_prefixes(struct em_context_t *ctxt)
@@ -774,7 +774,7 @@ static em_status_t decode_op_simm8(em_context_t *ctxt,
 {
     op->type = OP_IMM;
     op->size = 1;
-    op->value = (int64)(insn_fetch_s8(ctxt));
+    op->value = (int64_t)(insn_fetch_s8(ctxt));
     return EM_CONTINUE;
 }
 

core/ept.c

@@ -62,15 +62,15 @@ bool ept_set_caps(uint64 caps)
     }
 
     caps &= ~EPT_UNSUPPORTED_FEATURES;
-    ASSERT(!ept_capabilities || caps == ept_capabilities);
+    assert(!ept_capabilities || caps == ept_capabilities);
     // FIXME: This assignment is done by all logical processors simultaneously
     ept_capabilities = caps;
     return 1;
 }
 
 static bool ept_has_cap(uint64 cap)
 {
-    ASSERT(ept_capabilities != 0);
+    assert(ept_capabilities != 0);
     // Avoid implicit conversion from uint64 to bool, because the latter may be
     // typedef'ed as uint8 (see hax_types_windows.h)
     return (ept_capabilities & cap) != 0;
@@ -185,7 +185,7 @@ static bool ept_lookup(struct vcpu_t *vcpu, paddr_t gpa, paddr_t *hpa)
     struct hax_ept *ept = vcpu->vm->ept;
     uint which_g = gpa >> 30;
 
-    ASSERT(ept->ept_root_page);
+    assert(ept->ept_root_page);
     if (which_g >= EPT_MAX_MEM_G) {
         hax_debug("ept_lookup error!\n");
         return 0;
@@ -224,7 +224,7 @@ static bool ept_lookup(struct vcpu_t *vcpu, paddr_t gpa, paddr_t *hpa)
 // TODO: Do we need to consider cross-page case ??
 bool ept_translate(struct vcpu_t *vcpu, paddr_t gpa, uint order, paddr_t *hpa)
 {
-    ASSERT(order == PG_ORDER_4K);
+    assert(order == PG_ORDER_4K);
     return ept_lookup(vcpu, gpa, hpa);
 }
 
@@ -301,7 +301,7 @@ void ept_free (hax_vm_t *hax_vm)
     struct hax_page *page, *n;
     struct hax_ept *ept = hax_vm->ept;
 
-    ASSERT(ept);
+    assert(ept);
 
     if (!ept->ept_root_page)
         return;
@@ -328,7 +328,7 @@ static void invept_smpfunc(struct invept_bundle *bundle)
 {
     struct per_cpu_data *cpu_data;
 
-    smp_mb();
+    hax_smp_mb();
     cpu_data = current_cpu_data();
     cpu_data->invept_res = VMX_SUCCEED;
 
@@ -373,7 +373,7 @@ void invept(hax_vm_t *hax_vm, uint type)
 
     bundle.type = type;
     bundle.desc = &desc;
-    smp_call_function(&cpu_online_map, (void (*)(void *))invept_smpfunc,
+    hax_smp_call_function(&cpu_online_map, (void (*)(void *))invept_smpfunc,
                       &bundle);
 
     /*

core/hax.c

@@ -62,12 +62,12 @@ struct hax_t *hax;
 extern hax_atomic_t vmx_cpu_num, vmx_enabled_num;
 static void hax_enable_vmx(void)
 {
-    smp_call_function(&cpu_online_map, cpu_init_vmx, NULL);
+    hax_smp_call_function(&cpu_online_map, cpu_init_vmx, NULL);
 }
 
 static void hax_disable_vmx(void)
 {
-    smp_call_function(&cpu_online_map, cpu_exit_vmx, NULL);
+    hax_smp_call_function(&cpu_online_map, cpu_exit_vmx, NULL);
 }
 
 static void free_cpu_vmxon_region(void)
@@ -415,7 +415,7 @@ static void hax_pmu_init(void)
     int ref_cpu_id = -1;
 
     // Execute cpu_pmu_init() on each logical processor of the host CPU
-    smp_call_function(&cpu_online_map, cpu_pmu_init, NULL);
+    hax_smp_call_function(&cpu_online_map, cpu_pmu_init, NULL);
 
     // Find the common APM version supported by all host logical processors
     // TODO: Theoretically we should do the same for other APM parameters

core/ia32.c

@@ -42,7 +42,7 @@ extern void ASMCALL asm_rdtsc(struct qword_val *qv);
 #else  // !_M_IX86
 extern uint64 ASMCALL asm_rdmsr(uint32 reg);
 extern void ASMCALL asm_wrmsr(uint32 reg, uint64_t val);
-extern uint64 ASMCALL asm_rdtsc();
+extern uint64 ASMCALL asm_rdtsc(void);
 #endif  // _M_IX86
 
 uint64 ia32_rdmsr(uint32 reg)

core/ia32_ops.asm

@@ -161,7 +161,7 @@ function __nmi, 0
     int 2h
     ret
 
-function __fls, 1
+function asm_fls, 1
     xor reg_ret_32, reg_ret_32
     bsr reg_ret_32, reg_arg1_32
     ret

core/include/cpu.h

@@ -107,12 +107,12 @@ struct per_cpu_data {
 
     /*
      * These fields are used to record the result of certain VMX instructions
-     * when they are used in a function wrapped by smp_call_function(). This is
+     * when they are used in a function wrapped by hax_smp_call_function(). This is
      * because it is not safe to call hax_error(), etc. (whose underlying
      * implementation may use a lock) from the wrapped function to log a
      * failure; doing so may cause a deadlock and thus a host reboot, especially
      * on macOS, where mp_rendezvous_no_intrs() (the legacy Darwin API used by
-     * HAXM to implement smp_call_function()) is known to be prone to deadlocks:
+     * HAXM to implement hax_smp_call_function()) is known to be prone to deadlocks:
      * https://lists.apple.com/archives/darwin-kernel/2006/Dec/msg00006.html
      */
     vmx_result_t    vmxon_res;
@@ -174,7 +174,7 @@ void cpu_exit_vmx(void *arg);
 
 void cpu_pmu_init(void *arg);
 
-void cpu_init_feature_cache();
+void cpu_init_feature_cache(void);
 bool cpu_has_feature(uint32_t feature);
 
 void hax_panic_log(struct vcpu_t *vcpu);

core/include/ia32.h

@@ -78,7 +78,7 @@ void ASMCALL asm_fxrstor(mword *addr);
 void ASMCALL asm_cpuid(union cpuid_args_t *state);
 
 void ASMCALL __nmi(void);
-uint32 ASMCALL __fls(uint32 bit32);
+uint32 ASMCALL asm_fls(uint32 bit32);
 
 uint64 ia32_rdmsr(uint32 reg);
 void ia32_wrmsr(uint32 reg, uint64 val);

core/include/vmx.h

@@ -527,6 +527,17 @@ void vmx_vmwrite(struct vcpu_t *vcpu, const char *name,
             vmwrite(vcpu, GUEST_##seg##_AR, tmp_ar);               \
         }
 
+#elif defined(__linux__)
+#define VMWRITE_SEG(vcpu, seg, val) ({                             \
+            uint32_t tmp_ar = val.ar;                              \
+            if (tmp_ar == 0)                                       \
+                tmp_ar = 0x10000;                                  \
+            vmwrite(vcpu, GUEST_##seg##_SELECTOR, (val).selector); \
+            vmwrite(vcpu, GUEST_##seg##_BASE, (val).base);         \
+            vmwrite(vcpu, GUEST_##seg##_LIMIT, (val).limit);       \
+            vmwrite(vcpu, GUEST_##seg##_AR, tmp_ar);               \
+        })
+
 #elif defined(__MACH__)
 #define VMWRITE_SEG(vcpu, seg, val) ({                             \
             uint32_t tmp_ar = val.ar;                              \