Normalized prefixes of functions/types

AlexAltea · AlexAltea · commit 119dea0dfb6c · 2018-11-08T08:50:37.000+01:00
Some platform-specific functions such as `smp_mb` or `__fls` had no hax_/asm_-prefix, clashing against functions declared in kernel headers.

Signed-off-by: Alexandro Sanchez Bach &lt;asanchez@kryptoslogic.com&gt;
diff --git a/core/cpu.c b/core/cpu.c
@@ -520,7 +520,7 @@ uint32_t 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();
 
diff --git a/core/ept.c b/core/ept.c
@@ -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);
 
     /*
diff --git a/core/hax.c b/core/hax.c
@@ -61,12 +61,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)
@@ -410,7 +410,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
diff --git a/core/ia32.c b/core/ia32.c
@@ -70,7 +70,7 @@ void ia32_wrmsr(uint32_t reg, uint64_t val)
 #endif
 }
 
-uint64_t rdtsc(void)
+uint64_t ia32_rdtsc(void)
 {
 #ifdef HAX_ARCH_X86_32
     struct qword_val val = { 0 };
diff --git a/core/ia32_ops.asm b/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
diff --git a/core/include/cpu.h b/core/include/cpu.h
@@ -108,12 +108,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;
diff --git a/core/include/ia32.h b/core/include/ia32.h
@@ -78,12 +78,12 @@ void ASMCALL asm_fxrstor(mword *addr);
 void ASMCALL asm_cpuid(union cpuid_args_t *state);
 
 void ASMCALL __nmi(void);
-uint32_t ASMCALL __fls(uint32_t bit32);
+uint32_t ASMCALL asm_fls(uint32_t bit32);
 
 uint64_t ia32_rdmsr(uint32_t reg);
 void ia32_wrmsr(uint32_t reg, uint64_t val);
 
-uint64_t rdtsc(void);
+uint64_t ia32_rdtsc(void);
 
 void fxinit(void);
 void fxsave(mword *addr);
diff --git a/core/intr_exc.c b/core/intr_exc.c
@@ -48,7 +48,7 @@ uint32_t vcpu_get_pending_intrs(struct vcpu_t *vcpu)
 
     for (i = 7; i >= 0; i--) {
         if (intr_pending[i]) {
-            offset = __fls(intr_pending[i]);
+            offset = asm_fls(intr_pending[i]);
             break;
         }
     }
diff --git a/core/memory.c b/core/memory.c
@@ -342,7 +342,7 @@ int hax_vm_set_ram(struct vm_t *vm, struct hax_set_ram_info *info)
             hva = 0;
 #endif
 #endif
-            cur_va += page_size;
+            cur_va += HAX_PAGE_SIZE;
         }
 
         if (!hax_core_set_p2m(vm, gpfn, hpfn, hva, info->flags)) {
diff --git a/core/vcpu.c b/core/vcpu.c
@@ -565,7 +565,7 @@ static void vcpu_init(struct vcpu_t *vcpu)
 
     vcpu->ref_count = 1;
 
-    vcpu->tsc_offset = 0ULL - rdtsc();
+    vcpu->tsc_offset = 0ULL - ia32_rdtsc();
 
     // Prepare the vcpu state to Power-up
     state->_rflags = 2;
@@ -3247,7 +3247,7 @@ static int handle_msr_read(struct vcpu_t *vcpu, uint32_t msr, uint64_t *val)
 
     switch (msr) {
         case IA32_TSC: {
-            *val = vcpu->tsc_offset + rdtsc();
+            *val = vcpu->tsc_offset + ia32_rdtsc();
             break;
         }
         case IA32_FEATURE_CONTROL: {
@@ -3503,7 +3503,7 @@ static int handle_msr_write(struct vcpu_t *vcpu, uint32_t msr, uint64_t val)
 
     switch (msr) {
         case IA32_TSC: {
-            vcpu->tsc_offset = val - rdtsc();
+            vcpu->tsc_offset = val - ia32_rdtsc();
             if (vmx(vcpu, pcpu_ctls) & USE_TSC_OFFSETTING) {
                 vmwrite(vcpu, VMX_TSC_OFFSET, vcpu->tsc_offset);
             }
@@ -4160,9 +4160,9 @@ int vcpu_pause(struct vcpu_t *vcpu)
         return -1;
 
     vcpu->paused = 1;
-    smp_mb();
+    hax_smp_mb();
     if (vcpu->is_running) {
-        smp_call_function(&cpu_online_map, _vcpu_take_off, NULL);
+        hax_smp_call_function(&cpu_online_map, _vcpu_take_off, NULL);
     }
 
     return 0;
@@ -4171,15 +4171,15 @@ int vcpu_pause(struct vcpu_t *vcpu)
 int vcpu_takeoff(struct vcpu_t *vcpu)
 {
     int cpu_id;
-    cpumap_t targets;
+    hax_cpumap_t targets;
 
     // Don't change the sequence unless you are sure
     if (vcpu->is_running) {
         cpu_id = vcpu->cpu_id;
         assert(cpu_id != hax_cpuid());
         targets = cpu2cpumap(cpu_id);
         // If not considering Windows XP, definitely we don't need this
-        smp_call_function(&targets, _vcpu_take_off, NULL);
+        hax_smp_call_function(&targets, _vcpu_take_off, NULL);
     }
 
     return 0;
diff --git a/include/darwin/hax_mac.h b/include/darwin/hax_mac.h
@@ -205,4 +205,14 @@ static inline bool cpu_is_online(int cpu)
     return !!(((uint64_t)1 << cpu) & cpu_online_map);
 }
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int cpu_number(void);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif  // HAX_DARWIN_HAX_MAC_H_
diff --git a/include/darwin/hax_types_mac.h b/include/darwin/hax_types_mac.h
@@ -82,10 +82,10 @@ static hax_atomic_t hax_atomic_dec(hax_atomic_t *address)
 
 /*
  * According to kernel programming, the Atomic function is barrier
- * Although we can write a smp_mb from scrach, this simple one can resolve our
+ * Although we can write a hax_smp_mb from scrach, this simple one can resolve our
  * issue
  */
-static inline void smp_mb(void)
+static inline void hax_smp_mb(void)
 {
     SInt32 atom;
     OSAddAtomic(1, &atom);
@@ -132,10 +132,10 @@ typedef struct hax_kmap_phys {
 
 typedef ulong mword;
 typedef mword preempt_flag;
-typedef uint64_t cpumap_t;
+typedef uint64_t hax_cpumap_t;
 typedef uint64_t HAX_VADDR_T;
 
-static inline cpumap_t cpu2cpumap(int cpu)
+static inline hax_cpumap_t cpu2cpumap(int cpu)
 {
     return (0x1UL << cpu);
 }
diff --git a/include/hax.h b/include/hax.h
@@ -39,8 +39,6 @@
 // declaration
 struct vcpu_t;
 
-extern int hax_page_size;
-
 #define HAX_CUR_VERSION    0x0004
 #define HAX_COMPAT_VERSION 0x0001
 
@@ -207,7 +205,7 @@ void hax_set_page(phax_page page);
 
 static inline uint64_t hax_page2pa(phax_page page)
 {
-    return hax_page2pfn(page) << PAGE_SHIFT;
+    return hax_page2pfn(page) << HAX_PAGE_SHIFT;
 }
 
 #define hax_page_pa hax_page2pa
@@ -232,15 +230,15 @@ static inline unsigned char *hax_page_va(struct hax_page *page)
 #define HAX_MAX_CPUS (sizeof(uint64_t) * 8)
 
 /* Host SMP */
-extern cpumap_t cpu_online_map;
+extern hax_cpumap_t cpu_online_map;
 extern int max_cpus;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int smp_call_function(cpumap_t *cpus, void(*scfunc)(void *param), void *param);
-extern int cpu_number(void);
+int hax_smp_call_function(hax_cpumap_t *cpus, void(*scfunc)(void *param),
+                          void *param);
 
 uint32_t hax_cpuid(void);
 int proc_event_pending(struct vcpu_t *vcpu);
diff --git a/include/windows/hax_types_windows.h b/include/windows/hax_types_windows.h
@@ -45,8 +45,8 @@ typedef unsigned char bool;
 #define is_leaf(x)  1
 #endif
 
-typedef KAFFINITY cpumap_t;
-inline cpumap_t cpu2cpumap(int cpu)
+typedef KAFFINITY hax_cpumap_t;
+inline hax_cpumap_t cpu2cpumap(int cpu)
 {
     return ((KAFFINITY)0x1 << cpu);
 }
@@ -134,7 +134,7 @@ typedef uint64_t mword;
 
 typedef mword HAX_VADDR_T;
 
-static inline void smp_mb(void)
+static inline void hax_smp_mb(void)
 {
     KeMemoryBarrier();
 }
diff --git a/include/windows/hax_windows.h b/include/windows/hax_windows.h
@@ -38,7 +38,7 @@
 
 /*
  * According to DDK, the IoAllocateMdl can support at mos
- * 64M - page_size * (sizeof(MDL)) / sizeof(ULONG_PTR), so
+ * 64M - PAGE_SIZE * (sizeof(MDL)) / sizeof(ULONG_PTR), so
  * take 32M here
  */
 #if (NTDDI_VERSION <= NTDDI_WS03)
diff --git a/platforms/darwin/com_intel_hax.c b/platforms/darwin/com_intel_hax.c
@@ -99,7 +99,7 @@ static int lock_prim_init(void)
     return -1;
 }
 
-cpumap_t cpu_online_map;
+hax_cpumap_t cpu_online_map;
 int max_cpus;
 
 void get_online_map(void *param)
@@ -125,7 +125,7 @@ static void init_cpu_info(void)
     uint64_t possible_map, omap = 0;
 
     possible_map = ~0ULL;
-    smp_call_function(&possible_map, get_online_map, &omap);
+    hax_smp_call_function(&possible_map, get_online_map, &omap);
     printf("possible map %llx cpu_online_map %llx\n", possible_map, omap);
     cpu_online_map = omap;
     max_cpus = real_ncpus;
diff --git a/platforms/darwin/hax_wrapper.cpp b/platforms/darwin/hax_wrapper.cpp
@@ -66,18 +66,16 @@ extern "C" int hax_log_level(int level, const char *fmt, ...)
 struct smp_call_parameter {
     void (*func)(void *);
     void *param;
-    cpumap_t *cpus;
+    hax_cpumap_t *cpus;
 };
 
 extern "C" void mp_rendezvous_no_intrs(void (*action_func)(void *), void *arg);
 
-extern "C" int cpu_number(void);
-
 void smp_cfunction(void *param)
 {
     int cpu_id;
     void (*action)(void *parap);
-    cpumap_t *hax_cpus;
+    hax_cpumap_t *hax_cpus;
     struct smp_call_parameter *p;
 
     p = (struct smp_call_parameter *)param;
@@ -89,7 +87,7 @@ void smp_cfunction(void *param)
         action(p->param);
 }
 
-extern "C" int smp_call_function(cpumap_t *cpus, void (*scfunc)(void *),
+extern "C" int hax_smp_call_function(hax_cpumap_t *cpus, void (*scfunc)(void *),
                                  void *param)
 {
     struct smp_call_parameter sp;
diff --git a/platforms/windows/hax_entry.h b/platforms/windows/hax_entry.h
@@ -89,7 +89,7 @@ static inline smpc_dpc_exit(void) { return 1; }
 #endif
 
 /* According to DDK, the IoAllocateMdl can support at most
- * 64M - page_size * (sizeof(MDL))/sizeof(ULONG_PTR), so take 32M here
+ * 64M - PAGE_SIZE * (sizeof(MDL))/sizeof(ULONG_PTR), so take 32M here
  */
 #if (NTDDI_VERSION <= NTDDI_WS03)
 #define HAX_RAM_ENTRY_SIZE 0x2000000
diff --git a/platforms/windows/hax_wrapper.c b/platforms/windows/hax_wrapper.c

Original file line number	Diff line number	Diff line change
`@@ -61,12 +61,12 @@ struct hax_t *hax;`
`61`	`61`	`extern hax_atomic_t vmx_cpu_num, vmx_enabled_num;`
`62`	`62`	`static void hax_enable_vmx(void)`
`63`	`63`	`{`
`64`		`- smp_call_function(&cpu_online_map, cpu_init_vmx, NULL);`
	`64`	`+ hax_smp_call_function(&cpu_online_map, cpu_init_vmx, NULL);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`static void hax_disable_vmx(void)`
`68`	`68`	`{`
`69`		`- smp_call_function(&cpu_online_map, cpu_exit_vmx, NULL);`
	`69`	`+ hax_smp_call_function(&cpu_online_map, cpu_exit_vmx, NULL);`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`static void free_cpu_vmxon_region(void)`
`@@ -410,7 +410,7 @@ static void hax_pmu_init(void)`
`410`	`410`	`int ref_cpu_id = -1;`
`411`	`411`
`412`	`412`	`// Execute cpu_pmu_init() on each logical processor of the host CPU`
`413`		`- smp_call_function(&cpu_online_map, cpu_pmu_init, NULL);`
	`413`	`+ hax_smp_call_function(&cpu_online_map, cpu_pmu_init, NULL);`
`414`	`414`
`415`	`415`	`// Find the common APM version supported by all host logical processors`
`416`	`416`	`// TODO: Theoretically we should do the same for other APM parameters`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ void ia32_wrmsr(uint32_t reg, uint64_t val)`
`70`	`70`	`#endif`
`71`	`71`	`}`
`72`	`72`
`73`		`-uint64_t rdtsc(void)`
	`73`	`+uint64_t ia32_rdtsc(void)`
`74`	`74`	`{`
`75`	`75`	`#ifdef HAX_ARCH_X86_32`
`76`	`76`	`struct qword_val val = { 0 };`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ uint32_t vcpu_get_pending_intrs(struct vcpu_t *vcpu)`
`48`	`48`
`49`	`49`	`for (i = 7; i >= 0; i--) {`
`50`	`50`	`if (intr_pending[i]) {`
`51`		`- offset = __fls(intr_pending[i]);`
	`51`	`+ offset = asm_fls(intr_pending[i]);`
`52`	`52`	`break;`
`53`	`53`	`}`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -342,7 +342,7 @@ int hax_vm_set_ram(struct vm_t vm, struct hax_set_ram_info info)`
`342`	`342`	`hva = 0;`
`343`	`343`	`#endif`
`344`	`344`	`#endif`
`345`		`- cur_va += page_size;`
	`345`	`+ cur_va += HAX_PAGE_SIZE;`
`346`	`346`	`}`
`347`	`347`
`348`	`348`	`if (!hax_core_set_p2m(vm, gpfn, hpfn, hva, info->flags)) {`