From 60d46f2a3967d80502fde087db49254b248ec2a0 Mon Sep 17 00:00:00 2001 From: Alexandro Sanchez Bach Date: Thu, 8 Nov 2018 15:21:23 +0100 Subject: [PATCH 1/4] Make VCPU ioctl naming consistent - The *DEBUG ioctl of VCPU devices was accidentally declared with a `HAX_IOCTL_VCPU_` prefix, not with the de-facto standard `HAX_VCPU_IOCTL_` prefix. This has been corrected. - The *GET_REGS, *SET_REGS ioctls of VCPU devices were declared with the `HAX_VCPU_`, not `HAX_VCPU_IOCTL_`. This has been corrected. Signed-off-by: Alexandro Sanchez Bach --- docs/api.md | 2 +- include/darwin/hax_interface_mac.h | 6 +++--- include/linux/hax_interface_linux.h | 6 +++--- platforms/darwin/com_intel_hax_ui.c | 10 +++++----- platforms/linux/components.c | 6 +++--- platforms/windows/hax_entry.c | 10 +++++----- platforms/windows/hax_entry.h | 6 +++--- 7 files changed, 23 insertions(+), 23 deletions(-) diff --git a/docs/api.md b/docs/api.md index b3f6f283..fd14ebe3 100644 --- a/docs/api.md +++ b/docs/api.md @@ -664,7 +664,7 @@ caller is smaller than the size of `struct vcpu_state_t`. TODO: Describe * Since: API v1 -* Parameter: `struct vcpu_state_t regs` (q.v. `HAX_VCPU_SET_REGS`) +* Parameter: `struct vcpu_state_t regs` (q.v. `HAX_VCPU_IOCTL_SET_REGS`) * (Output) `regs`: * Error codes: * `STATUS_INVALID_PARAMETER` (Windows): The output buffer provided by the diff --git a/include/darwin/hax_interface_mac.h b/include/darwin/hax_interface_mac.h index 43a9719d..d6b6b692 100644 --- a/include/darwin/hax_interface_mac.h +++ b/include/darwin/hax_interface_mac.h @@ -62,13 +62,13 @@ #define HAX_VCPU_IOCTL_SETUP_TUNNEL _IOWR(0, 0xc5, struct hax_tunnel_info) #define HAX_VCPU_IOCTL_INTERRUPT _IOWR(0, 0xc6, uint32_t) -#define HAX_VCPU_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) -#define HAX_VCPU_GET_REGS _IOWR(0, 0xc8, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_GET_REGS _IOWR(0, 0xc8, struct vcpu_state_t) /* API 2.0 */ #define HAX_VM_IOCTL_NOTIFY_QEMU_VERSION _IOW(0, 0x84, struct hax_qemu_version) -#define HAX_IOCTL_VCPU_DEBUG _IOW(0, 0xc9, struct hax_debug_t) +#define HAX_VCPU_IOCTL_DEBUG _IOW(0, 0xc9, struct hax_debug_t) #define HAX_KERNEL64_CS 0x80 #define HAX_KERNEL32_CS 0x08 diff --git a/include/linux/hax_interface_linux.h b/include/linux/hax_interface_linux.h index ecb13fd0..a41d29e2 100644 --- a/include/linux/hax_interface_linux.h +++ b/include/linux/hax_interface_linux.h @@ -63,13 +63,13 @@ #define HAX_VCPU_IOCTL_SETUP_TUNNEL _IOWR(0, 0xc5, struct hax_tunnel_info) #define HAX_VCPU_IOCTL_INTERRUPT _IOWR(0, 0xc6, uint32_t) -#define HAX_VCPU_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) -#define HAX_VCPU_GET_REGS _IOWR(0, 0xc8, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_GET_REGS _IOWR(0, 0xc8, struct vcpu_state_t) /* API 2.0 */ #define HAX_VM_IOCTL_NOTIFY_QEMU_VERSION _IOW(0, 0x84, struct hax_qemu_version) -#define HAX_IOCTL_VCPU_DEBUG _IOW(0, 0xc9, struct hax_debug_t) +#define HAX_VCPU_IOCTL_DEBUG _IOW(0, 0xc9, struct hax_debug_t) #define HAX_KERNEL64_CS 0x80 #define HAX_KERNEL32_CS 0x08 diff --git a/platforms/darwin/com_intel_hax_ui.c b/platforms/darwin/com_intel_hax_ui.c index dc43032e..12106463 100644 --- a/platforms/darwin/com_intel_hax_ui.c +++ b/platforms/darwin/com_intel_hax_ui.c @@ -213,13 +213,13 @@ static int hax_vcpu_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, ret = vcpu_get_fpu(mvcpu2cvcpu(vcpu), fl); break; } - case HAX_VCPU_SET_REGS: { + case HAX_VCPU_IOCTL_SET_REGS: { struct vcpu_state_t *vc_state; vc_state = (struct vcpu_state_t *)data; ret = vcpu_set_regs(mvcpu2cvcpu(vcpu), vc_state); break; } - case HAX_VCPU_GET_REGS: { + case HAX_VCPU_IOCTL_GET_REGS: { struct vcpu_state_t *vc_state; vc_state = (struct vcpu_state_t *)data; ret = vcpu_get_regs(mvcpu2cvcpu(vcpu), vc_state); @@ -231,7 +231,7 @@ static int hax_vcpu_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, vcpu_interrupt(mvcpu2cvcpu(vcpu), vector); break; } - case HAX_IOCTL_VCPU_DEBUG: { + case HAX_VCPU_IOCTL_DEBUG: { struct hax_debug_t *hax_debug; hax_debug = (struct hax_debug_t *)data; vcpu_debug(cvcpu, hax_debug); @@ -245,8 +245,8 @@ static int hax_vcpu_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, proc_name(pid, task_name, sizeof(task_name)); hax_error("Unknown vcpu ioctl 0x%lx, pid=%d ('%s')\n", cmd, pid, task_name); - //printf("set regs ioctl %lx get regs %lx", HAX_VCPU_SET_REGS, - // HAX_VCPU_GET_REGS); + //printf("set regs ioctl %lx get regs %lx", HAX_VCPU_IOCTL_SET_REGS, + // HAX_VCPU_IOCTL_GET_REGS); ret = -ENOSYS; break; } diff --git a/platforms/linux/components.c b/platforms/linux/components.c index c6bf7ba8..9472bf6a 100644 --- a/platforms/linux/components.c +++ b/platforms/linux/components.c @@ -408,7 +408,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, } break; } - case HAX_VCPU_SET_REGS: { + case HAX_VCPU_IOCTL_SET_REGS: { struct vcpu_state_t vc_state; if (copy_from_user(&vc_state, argp, sizeof(vc_state))) { ret = -EFAULT; @@ -417,7 +417,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, ret = vcpu_set_regs(cvcpu, &vc_state); break; } - case HAX_VCPU_GET_REGS: { + case HAX_VCPU_IOCTL_GET_REGS: { struct vcpu_state_t vc_state; ret = vcpu_get_regs(cvcpu, &vc_state); if (copy_to_user(argp, &vc_state, sizeof(vc_state))) { @@ -435,7 +435,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, vcpu_interrupt(cvcpu, vector); break; } - case HAX_IOCTL_VCPU_DEBUG: { + case HAX_VCPU_IOCTL_DEBUG: { struct hax_debug_t hax_debug; if (copy_from_user(&hax_debug, argp, sizeof(hax_debug))) { ret = -EFAULT; diff --git a/platforms/windows/hax_entry.c b/platforms/windows/hax_entry.c index 952a7773..df471c5a 100644 --- a/platforms/windows/hax_entry.c +++ b/platforms/windows/hax_entry.c @@ -384,7 +384,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, infret = sizeof(struct fx_layout); break; } - case HAX_VCPU_SET_REGS: { + case HAX_VCPU_IOCTL_SET_REGS: { struct vcpu_state_t *vc_state; if(inBufLength < sizeof(struct vcpu_state_t)) { ret = STATUS_INVALID_PARAMETER; @@ -395,7 +395,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, ret = STATUS_UNSUCCESSFUL; break; } - case HAX_VCPU_GET_REGS: { + case HAX_VCPU_IOCTL_GET_REGS: { struct vcpu_state_t *vc_state; if(outBufLength < sizeof(struct vcpu_state_t)) { ret = STATUS_INVALID_PARAMETER; @@ -422,7 +422,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, vcpu_takeoff(cvcpu); break; } - case HAX_IOCTL_VCPU_DEBUG: { + case HAX_VCPU_IOCTL_DEBUG: { if (inBufLength < sizeof(struct hax_debug_t)) { ret = STATUS_INVALID_PARAMETER; goto done; @@ -433,8 +433,8 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, default: hax_error("Unknow vcpu ioctl %lx\n", irpSp->Parameters.DeviceIoControl.IoControlCode); - hax_info("set regs ioctl %lx get regs %lx", HAX_VCPU_SET_REGS, - HAX_VCPU_GET_REGS ); + hax_info("set regs ioctl %lx get regs %lx", HAX_VCPU_IOCTL_SET_REGS, + HAX_VCPU_IOCTL_GET_REGS ); ret = STATUS_INVALID_PARAMETER; break; } diff --git a/platforms/windows/hax_entry.h b/platforms/windows/hax_entry.h index 52613f7d..7e5f44c6 100644 --- a/platforms/windows/hax_entry.h +++ b/platforms/windows/hax_entry.h @@ -152,9 +152,9 @@ extern PDRIVER_OBJECT HaxDriverObject; CTL_CODE(HAX_DEVICE_TYPE, 0x90b, METHOD_BUFFERED, FILE_ANY_ACCESS) #define HAX_VCPU_IOCTL_INTERRUPT \ CTL_CODE(HAX_DEVICE_TYPE, 0x90c, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_SET_REGS \ +#define HAX_VCPU_IOCTL_SET_REGS \ CTL_CODE(HAX_DEVICE_TYPE, 0x90d, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_GET_REGS \ +#define HAX_VCPU_IOCTL_GET_REGS \ CTL_CODE(HAX_DEVICE_TYPE, 0x90e, METHOD_BUFFERED, FILE_ANY_ACCESS) #define HAX_VCPU_IOCTL_KICKOFF \ CTL_CODE(HAX_DEVICE_TYPE, 0x90f, METHOD_BUFFERED, FILE_ANY_ACCESS) @@ -163,7 +163,7 @@ extern PDRIVER_OBJECT HaxDriverObject; #define HAX_VM_IOCTL_NOTIFY_QEMU_VERSION \ CTL_CODE(HAX_DEVICE_TYPE, 0x910, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_IOCTL_VCPU_DEBUG \ +#define HAX_VCPU_IOCTL_DEBUG \ CTL_CODE(HAX_DEVICE_TYPE, 0x916, METHOD_BUFFERED, FILE_ANY_ACCESS) #endif // HAX_WINDOWS_HAX_ENTRY_H_ From 8032855aa1986c1c2d68e24c4aa8bcaddafb442f Mon Sep 17 00:00:00 2001 From: Alexandro Sanchez Bach Date: Thu, 8 Nov 2018 09:18:32 -0800 Subject: [PATCH 2/4] Unified IOCTL definitions - Centralizing ioctl definitions in hax_interface.h, and adding __LEGACY suffix to previous platform-specific definitions. - Removed previously deprecated ioctls: HAX_VM_IOCTL_VCPU_CREATE_ORIG and HAX_VCPU_IOCTL_KICKOFF. Removed underlying functions, if any. - Deprecated HAX_VM_IOCTL_NOTIFY_QEMU_VERSION, and turned into a no-op ioctl. Signed-off-by: Alexandro Sanchez Bach --- core/include/hax_core_interface.h | 1 - core/include/vcpu.h | 1 - core/include/vm.h | 3 - core/vcpu.c | 21 +---- core/vm.c | 11 --- docs/api.md | 19 +--- include/darwin/hax_interface_mac.h | 51 +++------- include/hax_interface.h | 119 ++++++++++++++++++++++++ include/linux/hax_interface_linux.h | 51 +++------- include/windows/hax_interface_windows.h | 7 ++ platforms/darwin/com_intel_hax_ui.c | 42 +++++---- platforms/linux/components.c | 29 ++++-- platforms/linux/hax_entry.c | 4 + platforms/windows/hax_entry.c | 38 ++++---- platforms/windows/hax_entry.h | 56 ----------- 15 files changed, 228 insertions(+), 225 deletions(-) diff --git a/core/include/hax_core_interface.h b/core/include/hax_core_interface.h index aa836d66..f2ca7f91 100644 --- a/core/include/hax_core_interface.h +++ b/core/include/hax_core_interface.h @@ -89,7 +89,6 @@ struct vm_t * hax_get_vm(int vm_id, int refer); int hax_vm_core_open(struct vm_t *vm); /* Corresponding hax_get_vm with refer == 1 */ int hax_put_vm(struct vm_t *vm); -int hax_vm_set_qemuversion(struct vm_t *vm, struct hax_qemu_version *ver); struct vm_t * hax_create_vm(int *vm_id); int hax_teardown_vm(struct vm_t *vm); diff --git a/core/include/vcpu.h b/core/include/vcpu.h index b3ff6bd1..738cee6c 100644 --- a/core/include/vcpu.h +++ b/core/include/vcpu.h @@ -274,7 +274,6 @@ int hax_vm_create_host(struct vm_t *cvm, int vm_id); int vcpu_pause(struct vcpu_t *vcpu); int vcpu_unpause(struct vcpu_t *vcpu); -int vcpu_takeoff(struct vcpu_t *vcpu); void *vcpu_vmcs_va(struct vcpu_t *vcpu); hax_paddr_t vcpu_vmcs_pa(struct vcpu_t *vcpu); diff --git a/core/include/vm.h b/core/include/vm.h index 08e33849..a49e72e0 100644 --- a/core/include/vm.h +++ b/core/include/vm.h @@ -60,9 +60,6 @@ struct vm_t { #define VM_STATE_FLAGS_OPENED 0x1 #define VM_STATE_FLAGS_MEM_ALLOC 0x2 uint64_t flags; -#define VM_FEATURES_FASTMMIO_BASIC 0x1 -#define VM_FEATURES_FASTMMIO_EXTRA 0x2 - uint32_t features; int vm_id; #define VPID_SEED_BITS 64 uint8_t vpid_seed[VPID_SEED_BITS / 8]; diff --git a/core/vcpu.c b/core/vcpu.c index 2b205587..c4f4ba08 100644 --- a/core/vcpu.c +++ b/core/vcpu.c @@ -2053,6 +2053,7 @@ static void vcpu_exit_fpu_state(struct vcpu_t *vcpu) // http://wiki.osdev.org/X86-64_Instruction_Encoding #define INSTR_MAX_LEN 15 +<<<<<<< HEAD static bool qemu_support_fastmmio(struct vcpu_t *vcpu) { struct vm_t *vm = vcpu->vm; @@ -2068,6 +2069,9 @@ static bool qemu_support_fastmmio_extra(struct vcpu_t *vcpu) } static bool is_mmio_address(struct vcpu_t *vcpu, hax_paddr_t gpa) +======= +static bool is_mmio_address(struct vcpu_t *vcpu, paddr_t gpa) +>>>>>>> Unified IOCTL definitions { hax_paddr_t hpa; if (vtlb_active(vcpu)) { @@ -4168,23 +4172,6 @@ int vcpu_pause(struct vcpu_t *vcpu) return 0; } -int vcpu_takeoff(struct vcpu_t *vcpu) -{ - int cpu_id; - hax_cpumap_t targets; - - // Don't change the sequence unless you are sure - if (vcpu->is_running) { - cpu_id = vcpu->cpu_id; - hax_assert(cpu_id != hax_cpuid()); - targets = cpu2cpumap(cpu_id); - // If not considering Windows XP, definitely we don't need this - hax_smp_call_function(&targets, _vcpu_take_off, NULL); - } - - return 0; -} - int vcpu_unpause(struct vcpu_t *vcpu) { vcpu->paused = 0; diff --git a/core/vm.c b/core/vm.c index 184a943d..59c8a371 100644 --- a/core/vm.c +++ b/core/vm.c @@ -67,17 +67,6 @@ static int valid_vm_mid(int vm_id) return (vm_id >= 0) && (vm_id < VM_MID_BIT); } -int hax_vm_set_qemuversion(struct vm_t *vm, struct hax_qemu_version *ver) -{ - if (ver->cur_version >= 0x2) { - vm->features |= VM_FEATURES_FASTMMIO_BASIC; - if (ver->cur_version >= 0x4) { - vm->features |= VM_FEATURES_FASTMMIO_EXTRA; - } - } - return 0; -} - uint64_t vm_get_eptp(struct vm_t *vm) { uint64_t eptp_value; diff --git a/docs/api.md b/docs/api.md index fd14ebe3..09015d99 100644 --- a/docs/api.md +++ b/docs/api.md @@ -345,24 +345,7 @@ and its presence requires `va` to be set to 0. * Error codes: * `STATUS_INVALID_PARAMETER` (Windows): The input buffer provided by the caller is smaller than the size of `struct hax_set_ram_info`, or any of the -input parameters . - -#### HAX\_VM\_IOCTL\_NOTIFY\_QEMU\_VERSION -TODO: Describe - -* Since: API v2 -* Parameter: `struct hax_qemu_version qversion`, where - ``` - struct hax_qemu_version { - uint32_t cur_version; - uint32_t least_version; - } __attribute__ ((__packed__)); - ``` - * (Input) `cur_version`: - * (Input) `least_version`: -* Error codes: - * `STATUS_INVALID_PARAMETER` (Windows): The input buffer provided by the -caller is smaller than the size of `struct hax_qemu_version`. +input parameters. ### VCPU IOCTLs #### HAX\_VCPU\_IOCTL\_SETUP\_TUNNEL diff --git a/include/darwin/hax_interface_mac.h b/include/darwin/hax_interface_mac.h index d6b6b692..92ed940b 100644 --- a/include/darwin/hax_interface_mac.h +++ b/include/darwin/hax_interface_mac.h @@ -33,42 +33,21 @@ #include -/* The mac specific interface to qemu because of mac's - * special handling like hax tunnel allocation etc */ -/* HAX model level ioctl */ -#define HAX_IOCTL_VERSION _IOWR(0, 0x20, struct hax_module_version) -#define HAX_IOCTL_CREATE_VM _IOWR(0, 0x21, uint32_t) -#define HAX_IOCTL_DESTROY_VM _IOW(0, 0x22, uint32_t) -#define HAX_IOCTL_CAPABILITY _IOR(0, 0x23, struct hax_capabilityinfo) -#define HAX_IOCTL_SET_MEMLIMIT _IOWR(0, 0x24, struct hax_set_memlimit) - -// Only for backward compatibility with old Qemu. -#define HAX_VM_IOCTL_VCPU_CREATE_ORIG _IOR(0, 0x80, int) - -#define HAX_VM_IOCTL_VCPU_CREATE _IOWR(0, 0x80, uint32_t) -#define HAX_VM_IOCTL_ALLOC_RAM _IOWR(0, 0x81, struct hax_alloc_ram_info) -#define HAX_VM_IOCTL_SET_RAM _IOWR(0, 0x82, struct hax_set_ram_info) -#define HAX_VM_IOCTL_VCPU_DESTROY _IOR(0, 0x83, uint32_t) -#define HAX_VM_IOCTL_ADD_RAMBLOCK _IOW(0, 0x85, struct hax_ramblock_info) -#define HAX_VM_IOCTL_SET_RAM2 _IOWR(0, 0x86, struct hax_set_ram_info2) -#define HAX_VM_IOCTL_PROTECT_RAM _IOWR(0, 0x87, struct hax_protect_ram_info) - -#define HAX_VCPU_IOCTL_RUN _IO(0, 0xc0) -#define HAX_VCPU_IOCTL_SET_MSRS _IOWR(0, 0xc1, struct hax_msr_data) -#define HAX_VCPU_IOCTL_GET_MSRS _IOWR(0, 0xc2, struct hax_msr_data) - -#define HAX_VCPU_IOCTL_SET_FPU _IOW(0, 0xc3, struct fx_layout) -#define HAX_VCPU_IOCTL_GET_FPU _IOR(0, 0xc4, struct fx_layout) - -#define HAX_VCPU_IOCTL_SETUP_TUNNEL _IOWR(0, 0xc5, struct hax_tunnel_info) -#define HAX_VCPU_IOCTL_INTERRUPT _IOWR(0, 0xc6, uint32_t) -#define HAX_VCPU_IOCTL_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) -#define HAX_VCPU_IOCTL_GET_REGS _IOWR(0, 0xc8, struct vcpu_state_t) - -/* API 2.0 */ -#define HAX_VM_IOCTL_NOTIFY_QEMU_VERSION _IOW(0, 0x84, struct hax_qemu_version) - -#define HAX_VCPU_IOCTL_DEBUG _IOW(0, 0xc9, struct hax_debug_t) +#define HAX_IOCTL_GROUP 'H' + +#define HAX_IOCTL_HAX_IO(code, type) \ + _IO(HAX_IOCTL_GROUP, code) +#define HAX_IOCTL_HAX_IOR(code, type) \ + _IOR(HAX_IOCTL_GROUP, code, type) +#define HAX_IOCTL_HAX_IOW(code, type) \ + _IOW(HAX_IOCTL_GROUP, code, type) +#define HAX_IOCTL_HAX_IOWR(code, type) \ + _IOWR(HAX_IOCTL_GROUP, code, type) + +#define HAX_LEGACY_IOCTL(access, code_posix, code_windows, type) \ + HAX_IOCTL_##access(code_posix, type) +#define HAX_IOCTL(access, code, type) \ + HAX_IOCTL_##access(code, type) #define HAX_KERNEL64_CS 0x80 #define HAX_KERNEL32_CS 0x08 diff --git a/include/hax_interface.h b/include/hax_interface.h index 41efd2ba..e68248c7 100644 --- a/include/hax_interface.h +++ b/include/hax_interface.h @@ -49,6 +49,124 @@ #include "windows/hax_interface_windows.h" #endif +#define HAX_IOCTL_PLATFORM 0x40 +#define HAX_IOCTL_EXTENSION 0x80 + +/* Legacy API + * TODO: Remove all legacy calls after grace period (2020-01-01). + */ +#define HAX_IOCTL_VERSION__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x20, 0x900, struct hax_module_version) +#define HAX_IOCTL_CREATE_VM__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x21, 0x901, uint32_t) +#define HAX_IOCTL_DESTROY_VM__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOW, 0x22, 0x902, uint32_t) +#define HAX_IOCTL_CAPABILITY__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOR, 0x23, 0x910, struct hax_capabilityinfo) +#define HAX_IOCTL_SET_MEMLIMIT__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x24, 0x911, struct hax_set_memlimit) + +#define HAX_VM_IOCTL_VCPU_CREATE__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x80, 0x902, uint32_t) +#define HAX_VM_IOCTL_ALLOC_RAM__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x81, 0x903, struct hax_alloc_ram_info) +#define HAX_VM_IOCTL_SET_RAM__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x82, 0x904, struct hax_set_ram_info) +#define HAX_VM_IOCTL_VCPU_DESTROY__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOR, 0x83, 0x905, uint32_t) +#define HAX_VM_IOCTL_ADD_RAMBLOCK__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOW, 0x85, 0x913, struct hax_ramblock_info) +#define HAX_VM_IOCTL_SET_RAM2__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x86, 0x914, struct hax_set_ram_info2) +#define HAX_VM_IOCTL_PROTECT_RAM__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0x87, 0x915, struct hax_protect_ram_info) + +#define HAX_VCPU_IOCTL_RUN__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IO, 0xc0, 0x906, HAX_UNUSED) +#define HAX_VCPU_IOCTL_SETUP_TUNNEL__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0xc5, 0x90b, struct hax_tunnel_info) +#define HAX_VCPU_IOCTL_GET_REGS__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0xc8, 0x90e, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_SET_REGS__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0xc7, 0x90d, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_GET_FPU__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOR, 0xc4, 0x90a, struct fx_layout) +#define HAX_VCPU_IOCTL_SET_FPU__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOW, 0xc3, 0x909, struct fx_layout) +#define HAX_VCPU_IOCTL_GET_MSRS__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0xc2, 0x908, struct hax_msr_data) +#define HAX_VCPU_IOCTL_SET_MSRS__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0xc1, 0x907, struct hax_msr_data) +#define HAX_VCPU_IOCTL_INTERRUPT__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOWR, 0xc6, 0x90c, uint32_t) + +// API 2.0 +#define HAX_VM_IOCTL_NOTIFY_QEMU_VERSION__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOW, 0x84, 0x910, struct hax_qemu_version) +#define HAX_VCPU_IOCTL_DEBUG__LEGACY \ + HAX_LEGACY_IOCTL(HAX_IOW, 0xc9, 0x916, struct hax_debug_t) + +/* API + * === + * Each platform generates their own IOCTL-value by using the macro + * HAX_IOCTL(access, code, type) with the following arguments: + * - access: Arguments usage from userland perspective. + * - HAX_IO: Driver ignores user arguments. + * - HAX_IOR: Driver writes user arguments (read by user). + * - HAX_IOW: Driver reads user arguments (written by user). + * - HAX_IOWR: Driver reads+writes user arguments (written+read by user). + * - code: Sequential number in range 0x00-0x3F, and maskable via: + * - HAX_IOCTL_PLATFORM (0x40) Platform-specific ioctl. + * - HAX_IOCTL_EXTENSION (0x80) Extension-specific ioctl. + * - type: User argument type. + */ +#define HAX_IOCTL_VERSION \ + HAX_IOCTL(HAX_IOWR, 0x00, struct hax_module_version) +#define HAX_IOCTL_CREATE_VM \ + HAX_IOCTL(HAX_IOWR, 0x01, uint32_t) +#define HAX_IOCTL_DESTROY_VM \ + HAX_IOCTL(HAX_IOW, 0x02, uint32_t) +#define HAX_IOCTL_CAPABILITY \ + HAX_IOCTL(HAX_IOR, 0x03, struct hax_capabilityinfo) +#define HAX_IOCTL_SET_MEMLIMIT \ + HAX_IOCTL(HAX_IOWR, 0x04, struct hax_set_memlimit) + +#define HAX_VM_IOCTL_VCPU_CREATE \ + HAX_IOCTL(HAX_IOWR, 0x00, uint32_t) +#define HAX_VM_IOCTL_ALLOC_RAM \ + HAX_IOCTL(HAX_IOWR, 0x01, struct hax_alloc_ram_info) +#define HAX_VM_IOCTL_SET_RAM \ + HAX_IOCTL(HAX_IOWR, 0x02, struct hax_set_ram_info) +#define HAX_VM_IOCTL_VCPU_DESTROY \ + HAX_IOCTL(HAX_IOR, 0x03, uint32_t) +#define HAX_VM_IOCTL_ADD_RAMBLOCK \ + HAX_IOCTL(HAX_IOW, 0x04, struct hax_ramblock_info) +#define HAX_VM_IOCTL_SET_RAM2 \ + HAX_IOCTL(HAX_IOWR, 0x05, struct hax_set_ram_info2) +#define HAX_VM_IOCTL_PROTECT_RAM \ + HAX_IOCTL(HAX_IOWR, 0x06, struct hax_protect_ram_info) + +#define HAX_VCPU_IOCTL_RUN \ + HAX_IOCTL(HAX_IO, 0x00, HAX_UNUSED) +#define HAX_VCPU_IOCTL_SETUP_TUNNEL \ + HAX_IOCTL(HAX_IOWR, 0x01, struct hax_tunnel_info) +#define HAX_VCPU_IOCTL_GET_REGS \ + HAX_IOCTL(HAX_IOWR, 0x02, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_SET_REGS \ + HAX_IOCTL(HAX_IOWR, 0x03, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_GET_FPU \ + HAX_IOCTL(HAX_IOR, 0x04, struct fx_layout) +#define HAX_VCPU_IOCTL_SET_FPU \ + HAX_IOCTL(HAX_IOW, 0x05, struct fx_layout) +#define HAX_VCPU_IOCTL_GET_MSRS \ + HAX_IOCTL(HAX_IOWR, 0x06, struct hax_msr_data) +#define HAX_VCPU_IOCTL_SET_MSRS \ + HAX_IOCTL(HAX_IOWR, 0x07, struct hax_msr_data) +#define HAX_VCPU_IOCTL_INTERRUPT \ + HAX_IOCTL(HAX_IOWR, 0x08, uint32_t) +#define HAX_VCPU_IOCTL_DEBUG \ + HAX_IOCTL(HAX_IOW, 0x09, struct hax_debug_t) + #include "vcpu_state.h" struct vmx_msr { @@ -262,6 +380,7 @@ struct hax_set_ram_info2 { // All accesses (R/W/X) are allowed #define HAX_RAM_PERM_RWX 0x7 #define HAX_RAM_PERM_MASK 0x7 + struct hax_protect_ram_info { uint64_t pa_start; uint64_t size; diff --git a/include/linux/hax_interface_linux.h b/include/linux/hax_interface_linux.h index a41d29e2..5c93d00d 100644 --- a/include/linux/hax_interface_linux.h +++ b/include/linux/hax_interface_linux.h @@ -34,42 +34,21 @@ #include -/* The mac specific interface to qemu because of mac's - * special handling like hax tunnel allocation etc */ -/* HAX model level ioctl */ -#define HAX_IOCTL_VERSION _IOWR(0, 0x20, struct hax_module_version) -#define HAX_IOCTL_CREATE_VM _IOWR(0, 0x21, uint32_t) -#define HAX_IOCTL_DESTROY_VM _IOW(0, 0x22, uint32_t) -#define HAX_IOCTL_CAPABILITY _IOR(0, 0x23, struct hax_capabilityinfo) -#define HAX_IOCTL_SET_MEMLIMIT _IOWR(0, 0x24, struct hax_set_memlimit) - -// Only for backward compatibility with old Qemu. -#define HAX_VM_IOCTL_VCPU_CREATE_ORIG _IOR(0, 0x80, int) - -#define HAX_VM_IOCTL_VCPU_CREATE _IOWR(0, 0x80, uint32_t) -#define HAX_VM_IOCTL_ALLOC_RAM _IOWR(0, 0x81, struct hax_alloc_ram_info) -#define HAX_VM_IOCTL_SET_RAM _IOWR(0, 0x82, struct hax_set_ram_info) -#define HAX_VM_IOCTL_VCPU_DESTROY _IOR(0, 0x83, uint32_t) -#define HAX_VM_IOCTL_ADD_RAMBLOCK _IOW(0, 0x85, struct hax_ramblock_info) -#define HAX_VM_IOCTL_SET_RAM2 _IOWR(0, 0x86, struct hax_set_ram_info2) -#define HAX_VM_IOCTL_PROTECT_RAM _IOWR(0, 0x87, struct hax_protect_ram_info) - -#define HAX_VCPU_IOCTL_RUN _IO(0, 0xc0) -#define HAX_VCPU_IOCTL_SET_MSRS _IOWR(0, 0xc1, struct hax_msr_data) -#define HAX_VCPU_IOCTL_GET_MSRS _IOWR(0, 0xc2, struct hax_msr_data) - -#define HAX_VCPU_IOCTL_SET_FPU _IOW(0, 0xc3, struct fx_layout) -#define HAX_VCPU_IOCTL_GET_FPU _IOR(0, 0xc4, struct fx_layout) - -#define HAX_VCPU_IOCTL_SETUP_TUNNEL _IOWR(0, 0xc5, struct hax_tunnel_info) -#define HAX_VCPU_IOCTL_INTERRUPT _IOWR(0, 0xc6, uint32_t) -#define HAX_VCPU_IOCTL_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) -#define HAX_VCPU_IOCTL_GET_REGS _IOWR(0, 0xc8, struct vcpu_state_t) - -/* API 2.0 */ -#define HAX_VM_IOCTL_NOTIFY_QEMU_VERSION _IOW(0, 0x84, struct hax_qemu_version) - -#define HAX_VCPU_IOCTL_DEBUG _IOW(0, 0xc9, struct hax_debug_t) +#define HAX_DEVICE_TYPE 'H' + +#define HAX_IOCTL_HAX_IO(code, type) \ + _IO(HAX_DEVICE_TYPE, code) +#define HAX_IOCTL_HAX_IOR(code, type) \ + _IOR(HAX_DEVICE_TYPE, code, type) +#define HAX_IOCTL_HAX_IOW(code, type) \ + _IOW(HAX_DEVICE_TYPE, code, type) +#define HAX_IOCTL_HAX_IOWR(code, type) \ + _IOWR(HAX_DEVICE_TYPE, code, type) + +#define HAX_LEGACY_IOCTL(access, code_posix, code_windows, type) \ + HAX_IOCTL_##access(code_posix, type) +#define HAX_IOCTL(access, code, type) \ + HAX_IOCTL_##access(code, type) #define HAX_KERNEL64_CS 0x80 #define HAX_KERNEL32_CS 0x08 diff --git a/include/windows/hax_interface_windows.h b/include/windows/hax_interface_windows.h index 603aad04..eb251b34 100644 --- a/include/windows/hax_interface_windows.h +++ b/include/windows/hax_interface_windows.h @@ -31,6 +31,13 @@ #ifndef HAX_WINDOWS_HAX_INTERFACE_WINDOWS_H_ #define HAX_WINDOWS_HAX_INTERFACE_WINDOWS_H_ +#define HAX_DEVICE_TYPE 0x8000 + +#define HAX_LEGACY_IOCTL(access, code_posix, code_windows, type) \ + CTL_CODE(0x4000, code, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define HAX_IOCTL(access, code, type) \ + CTL_CODE(HAX_DEVICE_TYPE, (0x800 | code), METHOD_BUFFERED, FILE_ANY_ACCESS) + /* * This is for MAC compatible mode, so should not be used * But how can we make sure it is really not used?? diff --git a/platforms/darwin/com_intel_hax_ui.c b/platforms/darwin/com_intel_hax_ui.c index 12106463..a437c743 100644 --- a/platforms/darwin/com_intel_hax_ui.c +++ b/platforms/darwin/com_intel_hax_ui.c @@ -140,10 +140,12 @@ static int hax_vcpu_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, } switch (cmd) { + case HAX_VCPU_IOCTL_RUN__LEGACY: case HAX_VCPU_IOCTL_RUN: { ret = vcpu_execute(cvcpu); break; } + case HAX_VCPU_IOCTL_SETUP_TUNNEL__LEGACY: case HAX_VCPU_IOCTL_SETUP_TUNNEL: { struct hax_tunnel_info info, *uinfo; uinfo = (struct hax_tunnel_info *)data; @@ -153,6 +155,7 @@ static int hax_vcpu_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, uinfo->size = info.size; break; } + case HAX_VCPU_IOCTL_SET_MSRS__LEGACY: case HAX_VCPU_IOCTL_SET_MSRS: { struct hax_msr_data *msrs; struct vmx_msr *msr; @@ -178,6 +181,7 @@ static int hax_vcpu_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, msrs->done = i; break; } + case HAX_VCPU_IOCTL_GET_MSRS__LEGACY: case HAX_VCPU_IOCTL_GET_MSRS: { struct hax_msr_data *msrs; struct vmx_msr *msr; @@ -201,36 +205,42 @@ static int hax_vcpu_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, msrs->done = i; break; } + case HAX_VCPU_IOCTL_SET_FPU__LEGACY: case HAX_VCPU_IOCTL_SET_FPU: { struct fx_layout *fl; fl = (struct fx_layout *)data; ret = vcpu_put_fpu(mvcpu2cvcpu(vcpu), fl); break; } + case HAX_VCPU_IOCTL_GET_FPU__LEGACY: case HAX_VCPU_IOCTL_GET_FPU: { struct fx_layout *fl; fl = (struct fx_layout *)data; ret = vcpu_get_fpu(mvcpu2cvcpu(vcpu), fl); break; } + case HAX_VCPU_IOCTL_SET_REGS__LEGACY: case HAX_VCPU_IOCTL_SET_REGS: { struct vcpu_state_t *vc_state; vc_state = (struct vcpu_state_t *)data; ret = vcpu_set_regs(mvcpu2cvcpu(vcpu), vc_state); break; } + case HAX_VCPU_IOCTL_GET_REGS__LEGACY: case HAX_VCPU_IOCTL_GET_REGS: { struct vcpu_state_t *vc_state; vc_state = (struct vcpu_state_t *)data; ret = vcpu_get_regs(mvcpu2cvcpu(vcpu), vc_state); break; } + case HAX_VCPU_IOCTL_INTERRUPT__LEGACY: case HAX_VCPU_IOCTL_INTERRUPT: { uint8_t vector; vector = (uint8_t)(*(uint32_t *)data); vcpu_interrupt(mvcpu2cvcpu(vcpu), vector); break; } + case HAX_VCPU_IOCTL_DEBUG__LEGACY: case HAX_VCPU_IOCTL_DEBUG: { struct hax_debug_t *hax_debug; hax_debug = (struct hax_debug_t *)data; @@ -366,8 +376,8 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, } switch (cmd) { - case HAX_VM_IOCTL_VCPU_CREATE: - case HAX_VM_IOCTL_VCPU_CREATE_ORIG: { + case HAX_VM_IOCTL_VCPU_CREATE__LEGACY: + case HAX_VM_IOCTL_VCPU_CREATE: { uint32_t vcpu_id, vm_id; struct vcpu_t *cvcpu; @@ -383,6 +393,7 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, } break; } + case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: case HAX_VM_IOCTL_ALLOC_RAM: { struct hax_alloc_ram_info *info; info = (struct hax_alloc_ram_info *)data; @@ -392,6 +403,7 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, ret = hax_vm_add_ramblock(cvm, info->va, info->size); break; } + case HAX_VM_IOCTL_ADD_RAMBLOCK__LEGACY: case HAX_VM_IOCTL_ADD_RAMBLOCK: { struct hax_ramblock_info *info; info = (struct hax_ramblock_info *)data; @@ -407,6 +419,7 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, ret = hax_vm_add_ramblock(cvm, info->start_va, info->size); break; } + case HAX_VM_IOCTL_SET_RAM__LEGACY: case HAX_VM_IOCTL_SET_RAM: { struct hax_set_ram_info *info; info = (struct hax_set_ram_info *)data; @@ -427,6 +440,7 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, ret = hax_vm_set_ram2(cvm, info); break; } + case HAX_VM_IOCTL_PROTECT_RAM__LEGACY: case HAX_VM_IOCTL_PROTECT_RAM: { struct hax_protect_ram_info *info; info = (struct hax_protect_ram_info *)data; @@ -440,24 +454,8 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, break; } #endif - case HAX_VM_IOCTL_NOTIFY_QEMU_VERSION: { - int pid; - /* MAXCOMLEN + 1 == 17 (see bsd/sys/param.h) */ - char task_name[17]; - struct hax_qemu_version *info; - - pid = proc_pid(p); - proc_name(pid, task_name, sizeof(task_name)); - /* - * This message is informational, but hax_warning() makes sure it is - * printed by default, which helps us identify QEMU PIDs, in case - * we ever receive unknown ioctl()s from other processes. - */ - hax_warning("%s: Got HAX_VM_IOCTL_NOTIFY_QEMU_VERSION, pid=%d" - " ('%s')\n", __func__, pid, task_name); - info = (struct hax_qemu_version *)data; - - ret = hax_vm_set_qemuversion(cvm, info); + case HAX_VM_IOCTL_NOTIFY_QEMU_VERSION__LEGACY: { + // TODO: Currently no-op. Remove after grace period (2020-01-01) break; } default: { @@ -531,6 +529,7 @@ static int hax_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, int ret = 0; switch (cmd) { + case HAX_IOCTL_VERSION__LEGACY: case HAX_IOCTL_VERSION: { struct hax_module_version *version; version = (struct hax_module_version *)data; @@ -538,12 +537,14 @@ static int hax_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, version->compat_version = HAX_COMPAT_VERSION; break; } + case HAX_IOCTL_CAPABILITY__LEGACY: case HAX_IOCTL_CAPABILITY: { struct hax_capabilityinfo *capab; capab = (struct hax_capabilityinfo *)data; hax_get_capability(capab, sizeof(struct hax_capabilityinfo), NULL); break; } + case HAX_IOCTL_SET_MEMLIMIT__LEGACY: case HAX_IOCTL_SET_MEMLIMIT: { struct hax_set_memlimit *memlimit; memlimit = (struct hax_set_memlimit*)data; @@ -551,6 +552,7 @@ static int hax_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, NULL); break; } + case HAX_IOCTL_CREATE_VM__LEGACY: case HAX_IOCTL_CREATE_VM: { int vm_id; struct vm_t *cvm; diff --git a/platforms/linux/components.c b/platforms/linux/components.c index 9472bf6a..65012086 100644 --- a/platforms/linux/components.c +++ b/platforms/linux/components.c @@ -325,9 +325,11 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, return -ENODEV; switch (cmd) { + case HAX_VCPU_IOCTL_RUN__LEGACY: case HAX_VCPU_IOCTL_RUN: ret = vcpu_execute(cvcpu); break; + case HAX_VCPU_IOCTL_SETUP_TUNNEL__LEGACY: case HAX_VCPU_IOCTL_SETUP_TUNNEL: { struct hax_tunnel_info info; ret = hax_vcpu_setup_hax_tunnel(cvcpu, &info); @@ -337,6 +339,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, } break; } + case HAX_VCPU_IOCTL_SET_MSRS__LEGACY: case HAX_VCPU_IOCTL_SET_MSRS: { struct hax_msr_data msrs; struct vmx_msr *msr; @@ -362,6 +365,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, msrs.done = i; break; } + case HAX_VCPU_IOCTL_GET_MSRS__LEGACY: case HAX_VCPU_IOCTL_GET_MSRS: { struct hax_msr_data msrs; struct vmx_msr *msr; @@ -390,6 +394,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, } break; } + case HAX_VCPU_IOCTL_SET_FPU__LEGACY: case HAX_VCPU_IOCTL_SET_FPU: { struct fx_layout fl; if (copy_from_user(&fl, argp, sizeof(fl))) { @@ -399,6 +404,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, ret = vcpu_put_fpu(cvcpu, &fl); break; } + case HAX_VCPU_IOCTL_GET_FPU__LEGACY: case HAX_VCPU_IOCTL_GET_FPU: { struct fx_layout fl; ret = vcpu_get_fpu(cvcpu, &fl); @@ -408,6 +414,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, } break; } + case HAX_VCPU_IOCTL_SET_REGS__LEGACY: case HAX_VCPU_IOCTL_SET_REGS: { struct vcpu_state_t vc_state; if (copy_from_user(&vc_state, argp, sizeof(vc_state))) { @@ -417,6 +424,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, ret = vcpu_set_regs(cvcpu, &vc_state); break; } + case HAX_VCPU_IOCTL_GET_REGS__LEGACY: case HAX_VCPU_IOCTL_GET_REGS: { struct vcpu_state_t vc_state; ret = vcpu_get_regs(cvcpu, &vc_state); @@ -426,6 +434,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, } break; } + case HAX_VCPU_IOCTL_INTERRUPT__LEGACY: case HAX_VCPU_IOCTL_INTERRUPT: { uint8_t vector; if (copy_from_user(&vector, argp, sizeof(vector))) { @@ -435,6 +444,7 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, vcpu_interrupt(cvcpu, vector); break; } + case HAX_VCPU_IOCTL_DEBUG__LEGACY: case HAX_VCPU_IOCTL_DEBUG: { struct hax_debug_t hax_debug; if (copy_from_user(&hax_debug, argp, sizeof(hax_debug))) { @@ -510,8 +520,8 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, return -ENODEV; switch (cmd) { - case HAX_VM_IOCTL_VCPU_CREATE: - case HAX_VM_IOCTL_VCPU_CREATE_ORIG: { + case HAX_VM_IOCTL_VCPU_CREATE__LEGACY: + case HAX_VM_IOCTL_VCPU_CREATE: { uint32_t vcpu_id, vm_id; struct vcpu_t *cvcpu; @@ -528,6 +538,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, } break; } + case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: case HAX_VM_IOCTL_ALLOC_RAM: { struct hax_alloc_ram_info info; if (copy_from_user(&info, argp, sizeof(info))) { @@ -539,6 +550,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, ret = hax_vm_add_ramblock(cvm, info.va, info.size); break; } + case HAX_VM_IOCTL_ADD_RAMBLOCK__LEGACY: case HAX_VM_IOCTL_ADD_RAMBLOCK: { struct hax_ramblock_info info; if (copy_from_user(&info, argp, sizeof(info))) { @@ -556,6 +568,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, ret = hax_vm_add_ramblock(cvm, info.start_va, info.size); break; } + case HAX_VM_IOCTL_SET_RAM__LEGACY: case HAX_VM_IOCTL_SET_RAM: { struct hax_set_ram_info info; if (copy_from_user(&info, argp, sizeof(info))) { @@ -566,6 +579,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, break; } #ifdef CONFIG_HAX_EPT2 + case HAX_VM_IOCTL_SET_RAM2__LEGACY: case HAX_VM_IOCTL_SET_RAM2: { struct hax_set_ram_info2 info; if (copy_from_user(&info, argp, sizeof(info))) { @@ -581,6 +595,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, ret = hax_vm_set_ram2(cvm, &info); break; } + case HAX_VM_IOCTL_PROTECT_RAM__LEGACY: case HAX_VM_IOCTL_PROTECT_RAM: { struct hax_protect_ram_info info; if (copy_from_user(&info, argp, sizeof(info))) { @@ -597,14 +612,8 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, break; } #endif - case HAX_VM_IOCTL_NOTIFY_QEMU_VERSION: { - struct hax_qemu_version info; - if (copy_from_user(&info, argp, sizeof(info))) { - ret = -EFAULT; - break; - } - // TODO: Print information about the process that sent the ioctl. - ret = hax_vm_set_qemuversion(cvm, &info); + case HAX_VM_IOCTL_NOTIFY_QEMU_VERSION__LEGACY: { + // TODO: Currently no-op. Remove after grace period (2020-01-01) break; } default: diff --git a/platforms/linux/hax_entry.c b/platforms/linux/hax_entry.c index 893e64f4..67b36bd9 100644 --- a/platforms/linux/hax_entry.c +++ b/platforms/linux/hax_entry.c @@ -69,6 +69,7 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, void *argp = (void *)arg; switch (cmd) { + case HAX_IOCTL_VERSION__LEGACY: case HAX_IOCTL_VERSION: { struct hax_module_version version = {}; version.cur_version = HAX_CUR_VERSION; @@ -77,6 +78,7 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, return -EFAULT; break; } + case HAX_IOCTL_CAPABILITY__LEGACY: case HAX_IOCTL_CAPABILITY: { struct hax_capabilityinfo capab = {}; hax_get_capability(&capab, sizeof(capab), NULL); @@ -84,6 +86,7 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, return -EFAULT; break; } + case HAX_IOCTL_SET_MEMLIMIT__LEGACY: case HAX_IOCTL_SET_MEMLIMIT: { struct hax_set_memlimit memlimit = {}; if (copy_from_user(&memlimit, argp, sizeof(memlimit))) @@ -91,6 +94,7 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, ret = hax_set_memlimit(&memlimit, sizeof(memlimit), NULL); break; } + case HAX_IOCTL_CREATE_VM__LEGACY: case HAX_IOCTL_CREATE_VM: { int vm_id; struct vm_t *cvm; diff --git a/platforms/windows/hax_entry.c b/platforms/windows/hax_entry.c index df471c5a..96c0267b 100644 --- a/platforms/windows/hax_entry.c +++ b/platforms/windows/hax_entry.c @@ -37,7 +37,6 @@ #include "hax_win.h" // vcpu.h -int vcpu_takeoff(struct vcpu_t *vcpu); void vcpu_debug(struct vcpu_t *vcpu, struct hax_debug_t *debug); #define NT_DEVICE_NAME L"\\Device\\HAX" @@ -278,10 +277,12 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, } switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { + case HAX_VCPU_IOCTL_RUN__LEGACY: case HAX_VCPU_IOCTL_RUN: if (vcpu_execute(cvcpu)) ret = STATUS_UNSUCCESSFUL; break; + case HAX_VCPU_IOCTL_SETUP_TUNNEL__LEGACY: case HAX_VCPU_IOCTL_SETUP_TUNNEL: { struct hax_tunnel_info info, *uinfo; if (outBufLength < sizeof(struct hax_tunnel_info )) { @@ -296,6 +297,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, infret = sizeof(struct hax_tunnel_info); break; } + case HAX_VCPU_IOCTL_SET_MSRS__LEGACY: case HAX_VCPU_IOCTL_SET_MSRS: { struct hax_msr_data *msrs, *outmsrs; struct vmx_msr *msr; @@ -330,6 +332,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, infret = sizeof(struct hax_msr_data); break; } + case HAX_VCPU_IOCTL_GET_MSRS__LEGACY: case HAX_VCPU_IOCTL_GET_MSRS: { struct hax_msr_data *msrs; struct vmx_msr *msr; @@ -361,6 +364,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, infret = sizeof(struct hax_msr_data); break; } + case HAX_VCPU_IOCTL_SET_FPU__LEGACY: case HAX_VCPU_IOCTL_SET_FPU: { struct fx_layout *fl; if (inBufLength < sizeof(struct fx_layout)) { @@ -372,6 +376,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, vcpu_put_fpu(cvcpu, fl); break; } + case HAX_VCPU_IOCTL_GET_FPU__LEGACY: case HAX_VCPU_IOCTL_GET_FPU: { struct fx_layout *fl; if (outBufLength < sizeof(struct fx_layout)) { @@ -384,6 +389,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, infret = sizeof(struct fx_layout); break; } + case HAX_VCPU_IOCTL_SET_REGS__LEGACY: case HAX_VCPU_IOCTL_SET_REGS: { struct vcpu_state_t *vc_state; if(inBufLength < sizeof(struct vcpu_state_t)) { @@ -395,6 +401,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, ret = STATUS_UNSUCCESSFUL; break; } + case HAX_VCPU_IOCTL_GET_REGS__LEGACY: case HAX_VCPU_IOCTL_GET_REGS: { struct vcpu_state_t *vc_state; if(outBufLength < sizeof(struct vcpu_state_t)) { @@ -408,6 +415,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, infret = sizeof(struct vcpu_state_t); break; } + case HAX_VCPU_IOCTL_INTERRUPT__LEGACY: case HAX_VCPU_IOCTL_INTERRUPT: { uint8_t vector; if (inBufLength < sizeof(uint32_t)) { @@ -418,10 +426,7 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, vcpu_interrupt(cvcpu, vector); break; } - case HAX_VCPU_IOCTL_KICKOFF: { - vcpu_takeoff(cvcpu); - break; - } + case HAX_VCPU_IOCTL_DEBUG__LEGACY: case HAX_VCPU_IOCTL_DEBUG: { if (inBufLength < sizeof(struct hax_debug_t)) { ret = STATUS_INVALID_PARAMETER; @@ -478,6 +483,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, } switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { + case HAX_VM_IOCTL_VCPU_CREATE__LEGACY: case HAX_VM_IOCTL_VCPU_CREATE: { if (inBufLength < sizeof(uint32_t)) { ret = STATUS_INVALID_PARAMETER; @@ -494,6 +500,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, ret = STATUS_SUCCESS; break; } + case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: case HAX_VM_IOCTL_ALLOC_RAM: { struct hax_alloc_ram_info *info; if (inBufLength < sizeof(struct hax_alloc_ram_info)) { @@ -508,6 +515,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, } break; } + case HAX_VM_IOCTL_ADD_RAMBLOCK__LEGACY: case HAX_VM_IOCTL_ADD_RAMBLOCK: { struct hax_ramblock_info *info; if (inBufLength < sizeof(struct hax_ramblock_info)) { @@ -530,6 +538,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, } break; } + case HAX_VM_IOCTL_SET_RAM__LEGACY: case HAX_VM_IOCTL_SET_RAM: { struct hax_set_ram_info *info; int res; @@ -551,6 +560,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, break; } #ifdef CONFIG_HAX_EPT2 + case HAX_VM_IOCTL_SET_RAM2__LEGACY: case HAX_VM_IOCTL_SET_RAM2: { struct hax_set_ram_info2 *info; int res; @@ -578,6 +588,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, } break; } + case HAX_VM_IOCTL_PROTECT_RAM__LEGACY: case HAX_VM_IOCTL_PROTECT_RAM: { struct hax_protect_ram_info *info; int res; @@ -600,17 +611,8 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, break; } #endif - case HAX_VM_IOCTL_NOTIFY_QEMU_VERSION: { - struct hax_qemu_version *info; - - if (inBufLength < sizeof(struct hax_qemu_version)) { - ret = STATUS_INVALID_PARAMETER; - goto done; - } - info = (struct hax_qemu_version *)inBuf; - - // hax_vm_set_qemuversion() cannot fail - hax_vm_set_qemuversion(cvm, info); + case HAX_VM_IOCTL_NOTIFY_QEMU_VERSION__LEGACY: { + // TODO: Currently no-op. Remove after grace period (2020-01-01) break; } default: @@ -648,6 +650,7 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, outBuf = Irp->AssociatedIrp.SystemBuffer; switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { + case HAX_IOCTL_VERSION__LEGACY: case HAX_IOCTL_VERSION: if (outBufLength < sizeof(struct hax_module_version)) { ret = STATUS_INVALID_PARAMETER; @@ -657,6 +660,7 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, /* I assume the outbuf and inbuf is same buffer, right? */ infret = sizeof(struct hax_module_version); break; + case HAX_IOCTL_CAPABILITY__LEGACY: case HAX_IOCTL_CAPABILITY: if (outBufLength < sizeof(struct hax_capabilityinfo)) { ret = STATUS_INVALID_PARAMETER; @@ -674,6 +678,7 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, ret = STATUS_SUCCESS; break; + case HAX_IOCTL_SET_MEMLIMIT__LEGACY: case HAX_IOCTL_SET_MEMLIMIT: if (inBufLength < sizeof(struct hax_set_memlimit)) { ret = STATUS_INVALID_PARAMETER; @@ -685,6 +690,7 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, } ret = STATUS_SUCCESS; break; + case HAX_IOCTL_CREATE_VM__LEGACY: case HAX_IOCTL_CREATE_VM: if (outBufLength < sizeof(uint32_t)) { Irp->IoStatus.Information = 0; diff --git a/platforms/windows/hax_entry.h b/platforms/windows/hax_entry.h index 7e5f44c6..291a0240 100644 --- a/platforms/windows/hax_entry.h +++ b/platforms/windows/hax_entry.h @@ -110,60 +110,4 @@ int smpc_dpc_exit(void); extern PDRIVER_OBJECT HaxDriverObject; -#define HAX_DEVICE_TYPE 0x4000 - -#define HAX_IOCTL_VERSION \ - CTL_CODE(HAX_DEVICE_TYPE, 0x900, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_IOCTL_CREATE_VM \ - CTL_CODE(HAX_DEVICE_TYPE, 0x901, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_IOCTL_CAPABILITY \ - CTL_CODE(HAX_DEVICE_TYPE, 0x910, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_IOCTL_SET_MEMLIMIT \ - CTL_CODE(HAX_DEVICE_TYPE, 0x911, METHOD_BUFFERED, FILE_ANY_ACCESS) - -#define HAX_VM_IOCTL_VCPU_CREATE \ - CTL_CODE(HAX_DEVICE_TYPE, 0x902, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VM_IOCTL_ALLOC_RAM \ - CTL_CODE(HAX_DEVICE_TYPE, 0x903, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VM_IOCTL_SET_RAM \ - CTL_CODE(HAX_DEVICE_TYPE, 0x904, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VM_IOCTL_VCPU_DESTROY \ - CTL_CODE(HAX_DEVICE_TYPE, 0x905, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VM_IOCTL_ADD_RAMBLOCK \ - CTL_CODE(HAX_DEVICE_TYPE, 0x913, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VM_IOCTL_SET_RAM2 \ - CTL_CODE(HAX_DEVICE_TYPE, 0x914, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VM_IOCTL_PROTECT_RAM \ - CTL_CODE(HAX_DEVICE_TYPE, 0x915, METHOD_BUFFERED, FILE_ANY_ACCESS) - -#define HAX_VCPU_IOCTL_RUN \ - CTL_CODE(HAX_DEVICE_TYPE, 0x906, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_IOCTL_SET_MSRS \ - CTL_CODE(HAX_DEVICE_TYPE, 0x907, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_IOCTL_GET_MSRS \ - CTL_CODE(HAX_DEVICE_TYPE, 0x908, METHOD_BUFFERED, FILE_ANY_ACCESS) - -#define HAX_VCPU_IOCTL_SET_FPU \ - CTL_CODE(HAX_DEVICE_TYPE, 0x909, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_IOCTL_GET_FPU \ - CTL_CODE(HAX_DEVICE_TYPE, 0x90a, METHOD_BUFFERED, FILE_ANY_ACCESS) - -#define HAX_VCPU_IOCTL_SETUP_TUNNEL \ - CTL_CODE(HAX_DEVICE_TYPE, 0x90b, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_IOCTL_INTERRUPT \ - CTL_CODE(HAX_DEVICE_TYPE, 0x90c, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_IOCTL_SET_REGS \ - CTL_CODE(HAX_DEVICE_TYPE, 0x90d, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_IOCTL_GET_REGS \ - CTL_CODE(HAX_DEVICE_TYPE, 0x90e, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_IOCTL_KICKOFF \ - CTL_CODE(HAX_DEVICE_TYPE, 0x90f, METHOD_BUFFERED, FILE_ANY_ACCESS) - -/* API version 2.0 */ -#define HAX_VM_IOCTL_NOTIFY_QEMU_VERSION \ - CTL_CODE(HAX_DEVICE_TYPE, 0x910, METHOD_BUFFERED, FILE_ANY_ACCESS) - -#define HAX_VCPU_IOCTL_DEBUG \ - CTL_CODE(HAX_DEVICE_TYPE, 0x916, METHOD_BUFFERED, FILE_ANY_ACCESS) - #endif // HAX_WINDOWS_HAX_ENTRY_H_ From 548bd7798c27aa4b3f961ee17e63b88b052c3b9c Mon Sep 17 00:00:00 2001 From: Alexandro Sanchez Bach Date: Tue, 13 Nov 2018 18:02:06 +0100 Subject: [PATCH 3/4] Fixed ioctl access codes Signed-off-by: Alexandro Sanchez Bach --- include/hax_interface.h | 36 +++++++++++-------------- include/windows/hax_interface_windows.h | 13 +++++++-- platforms/darwin/com_intel_hax_ui.c | 10 +++---- platforms/linux/components.c | 5 ++-- platforms/linux/hax_entry.c | 5 ++-- platforms/windows/hax_entry.c | 8 +++--- 6 files changed, 38 insertions(+), 39 deletions(-) diff --git a/include/hax_interface.h b/include/hax_interface.h index e68248c7..9ca15993 100644 --- a/include/hax_interface.h +++ b/include/hax_interface.h @@ -120,40 +120,36 @@ * - HAX_IOCTL_EXTENSION (0x80) Extension-specific ioctl. * - type: User argument type. */ -#define HAX_IOCTL_VERSION \ - HAX_IOCTL(HAX_IOWR, 0x00, struct hax_module_version) +#define HAX_IOCTL_GET_API_VERSION \ + HAX_IOCTL(HAX_IOR, 0x00, struct hax_module_version) #define HAX_IOCTL_CREATE_VM \ - HAX_IOCTL(HAX_IOWR, 0x01, uint32_t) + HAX_IOCTL(HAX_IOR, 0x01, uint32_t) #define HAX_IOCTL_DESTROY_VM \ HAX_IOCTL(HAX_IOW, 0x02, uint32_t) #define HAX_IOCTL_CAPABILITY \ HAX_IOCTL(HAX_IOR, 0x03, struct hax_capabilityinfo) -#define HAX_IOCTL_SET_MEMLIMIT \ - HAX_IOCTL(HAX_IOWR, 0x04, struct hax_set_memlimit) -#define HAX_VM_IOCTL_VCPU_CREATE \ - HAX_IOCTL(HAX_IOWR, 0x00, uint32_t) -#define HAX_VM_IOCTL_ALLOC_RAM \ - HAX_IOCTL(HAX_IOWR, 0x01, struct hax_alloc_ram_info) +#define HAX_VM_IOCTL_CREATE_VCPU \ + HAX_IOCTL(HAX_IOW, 0x00, uint32_t) +#define HAX_VM_IOCTL_DESTROY_VCPU \ + HAX_IOCTL(HAX_IOW, 0x01, uint32_t) #define HAX_VM_IOCTL_SET_RAM \ - HAX_IOCTL(HAX_IOWR, 0x02, struct hax_set_ram_info) -#define HAX_VM_IOCTL_VCPU_DESTROY \ - HAX_IOCTL(HAX_IOR, 0x03, uint32_t) + HAX_IOCTL(HAX_IOW, 0x02, struct hax_set_ram_info) #define HAX_VM_IOCTL_ADD_RAMBLOCK \ - HAX_IOCTL(HAX_IOW, 0x04, struct hax_ramblock_info) + HAX_IOCTL(HAX_IOW, 0x03, struct hax_ramblock_info) #define HAX_VM_IOCTL_SET_RAM2 \ - HAX_IOCTL(HAX_IOWR, 0x05, struct hax_set_ram_info2) + HAX_IOCTL(HAX_IOW, 0x04, struct hax_set_ram_info2) #define HAX_VM_IOCTL_PROTECT_RAM \ - HAX_IOCTL(HAX_IOWR, 0x06, struct hax_protect_ram_info) + HAX_IOCTL(HAX_IOW, 0x05, struct hax_protect_ram_info) #define HAX_VCPU_IOCTL_RUN \ HAX_IOCTL(HAX_IO, 0x00, HAX_UNUSED) #define HAX_VCPU_IOCTL_SETUP_TUNNEL \ - HAX_IOCTL(HAX_IOWR, 0x01, struct hax_tunnel_info) + HAX_IOCTL(HAX_IOR, 0x01, struct hax_tunnel_info) #define HAX_VCPU_IOCTL_GET_REGS \ - HAX_IOCTL(HAX_IOWR, 0x02, struct vcpu_state_t) + HAX_IOCTL(HAX_IOR, 0x02, struct vcpu_state_t) #define HAX_VCPU_IOCTL_SET_REGS \ - HAX_IOCTL(HAX_IOWR, 0x03, struct vcpu_state_t) + HAX_IOCTL(HAX_IOW, 0x03, struct vcpu_state_t) #define HAX_VCPU_IOCTL_GET_FPU \ HAX_IOCTL(HAX_IOR, 0x04, struct fx_layout) #define HAX_VCPU_IOCTL_SET_FPU \ @@ -161,9 +157,9 @@ #define HAX_VCPU_IOCTL_GET_MSRS \ HAX_IOCTL(HAX_IOWR, 0x06, struct hax_msr_data) #define HAX_VCPU_IOCTL_SET_MSRS \ - HAX_IOCTL(HAX_IOWR, 0x07, struct hax_msr_data) + HAX_IOCTL(HAX_IOW, 0x07, struct hax_msr_data) #define HAX_VCPU_IOCTL_INTERRUPT \ - HAX_IOCTL(HAX_IOWR, 0x08, uint32_t) + HAX_IOCTL(HAX_IOW, 0x08, uint32_t) #define HAX_VCPU_IOCTL_DEBUG \ HAX_IOCTL(HAX_IOW, 0x09, struct hax_debug_t) diff --git a/include/windows/hax_interface_windows.h b/include/windows/hax_interface_windows.h index eb251b34..2419f6d8 100644 --- a/include/windows/hax_interface_windows.h +++ b/include/windows/hax_interface_windows.h @@ -33,10 +33,19 @@ #define HAX_DEVICE_TYPE 0x8000 +#define HAX_IO \ + (FILE_ANY_ACCESS) +#define HAX_IOR \ + (FILE_READ_DATA) +#define HAX_IOW \ + (FILE_WRITE_DATA) +#define HAX_IOWR \ + (FILE_WRITE_DATA | FILE_READ_DATA) + #define HAX_LEGACY_IOCTL(access, code_posix, code_windows, type) \ - CTL_CODE(0x4000, code, METHOD_BUFFERED, FILE_ANY_ACCESS) + CTL_CODE(0x4000, code_windows, METHOD_BUFFERED, FILE_ANY_ACCESS) #define HAX_IOCTL(access, code, type) \ - CTL_CODE(HAX_DEVICE_TYPE, (0x800 | code), METHOD_BUFFERED, FILE_ANY_ACCESS) + CTL_CODE(HAX_DEVICE_TYPE, (0x800 | code), METHOD_BUFFERED, access) /* * This is for MAC compatible mode, so should not be used diff --git a/platforms/darwin/com_intel_hax_ui.c b/platforms/darwin/com_intel_hax_ui.c index a437c743..3457d6da 100644 --- a/platforms/darwin/com_intel_hax_ui.c +++ b/platforms/darwin/com_intel_hax_ui.c @@ -377,7 +377,7 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, switch (cmd) { case HAX_VM_IOCTL_VCPU_CREATE__LEGACY: - case HAX_VM_IOCTL_VCPU_CREATE: { + case HAX_VM_IOCTL_CREATE_VCPU: { uint32_t vcpu_id, vm_id; struct vcpu_t *cvcpu; @@ -393,8 +393,7 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, } break; } - case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: - case HAX_VM_IOCTL_ALLOC_RAM: { + case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: { struct hax_alloc_ram_info *info; info = (struct hax_alloc_ram_info *)data; hax_info("IOCTL_ALLOC_RAM: vm_id=%d, va=0x%llx, size=0x%x," @@ -530,7 +529,7 @@ static int hax_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, switch (cmd) { case HAX_IOCTL_VERSION__LEGACY: - case HAX_IOCTL_VERSION: { + case HAX_IOCTL_GET_API_VERSION: { struct hax_module_version *version; version = (struct hax_module_version *)data; version->cur_version = HAX_CUR_VERSION; @@ -544,8 +543,7 @@ static int hax_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, hax_get_capability(capab, sizeof(struct hax_capabilityinfo), NULL); break; } - case HAX_IOCTL_SET_MEMLIMIT__LEGACY: - case HAX_IOCTL_SET_MEMLIMIT: { + case HAX_IOCTL_SET_MEMLIMIT__LEGACY: { struct hax_set_memlimit *memlimit; memlimit = (struct hax_set_memlimit*)data; ret = hax_set_memlimit(memlimit, sizeof(struct hax_set_memlimit), diff --git a/platforms/linux/components.c b/platforms/linux/components.c index 65012086..62812ae9 100644 --- a/platforms/linux/components.c +++ b/platforms/linux/components.c @@ -521,7 +521,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, switch (cmd) { case HAX_VM_IOCTL_VCPU_CREATE__LEGACY: - case HAX_VM_IOCTL_VCPU_CREATE: { + case HAX_VM_IOCTL_CREATE_VCPU: { uint32_t vcpu_id, vm_id; struct vcpu_t *cvcpu; @@ -538,8 +538,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, } break; } - case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: - case HAX_VM_IOCTL_ALLOC_RAM: { + case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: { struct hax_alloc_ram_info info; if (copy_from_user(&info, argp, sizeof(info))) { ret = -EFAULT; diff --git a/platforms/linux/hax_entry.c b/platforms/linux/hax_entry.c index 67b36bd9..433e12f4 100644 --- a/platforms/linux/hax_entry.c +++ b/platforms/linux/hax_entry.c @@ -70,7 +70,7 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, switch (cmd) { case HAX_IOCTL_VERSION__LEGACY: - case HAX_IOCTL_VERSION: { + case HAX_IOCTL_GET_API_VERSION: { struct hax_module_version version = {}; version.cur_version = HAX_CUR_VERSION; version.compat_version = HAX_COMPAT_VERSION; @@ -86,8 +86,7 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, return -EFAULT; break; } - case HAX_IOCTL_SET_MEMLIMIT__LEGACY: - case HAX_IOCTL_SET_MEMLIMIT: { + case HAX_IOCTL_SET_MEMLIMIT__LEGACY: { struct hax_set_memlimit memlimit = {}; if (copy_from_user(&memlimit, argp, sizeof(memlimit))) return -EFAULT; diff --git a/platforms/windows/hax_entry.c b/platforms/windows/hax_entry.c index 96c0267b..af4b840c 100644 --- a/platforms/windows/hax_entry.c +++ b/platforms/windows/hax_entry.c @@ -484,7 +484,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { case HAX_VM_IOCTL_VCPU_CREATE__LEGACY: - case HAX_VM_IOCTL_VCPU_CREATE: { + case HAX_VM_IOCTL_CREATE_VCPU: { if (inBufLength < sizeof(uint32_t)) { ret = STATUS_INVALID_PARAMETER; goto done; @@ -500,8 +500,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, ret = STATUS_SUCCESS; break; } - case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: - case HAX_VM_IOCTL_ALLOC_RAM: { + case HAX_VM_IOCTL_ALLOC_RAM__LEGACY: { struct hax_alloc_ram_info *info; if (inBufLength < sizeof(struct hax_alloc_ram_info)) { ret = STATUS_INVALID_PARAMETER; @@ -651,7 +650,7 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { case HAX_IOCTL_VERSION__LEGACY: - case HAX_IOCTL_VERSION: + case HAX_IOCTL_GET_API_VERSION: if (outBufLength < sizeof(struct hax_module_version)) { ret = STATUS_INVALID_PARAMETER; goto done; @@ -679,7 +678,6 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, break; case HAX_IOCTL_SET_MEMLIMIT__LEGACY: - case HAX_IOCTL_SET_MEMLIMIT: if (inBufLength < sizeof(struct hax_set_memlimit)) { ret = STATUS_INVALID_PARAMETER; goto done; From 49eb94f795596bb269de81e8b4ab83c46f28b0df Mon Sep 17 00:00:00 2001 From: Alexandro Sanchez Bach Date: Thu, 15 Nov 2018 03:25:50 +0100 Subject: [PATCH 4/4] Fixed HAX_VCPU_IOCTL_SET_MSRS access type Signed-off-by: Alexandro Sanchez Bach --- include/hax_interface.h | 2 +- platforms/linux/components.c | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/include/hax_interface.h b/include/hax_interface.h index 9ca15993..7683640f 100644 --- a/include/hax_interface.h +++ b/include/hax_interface.h @@ -157,7 +157,7 @@ #define HAX_VCPU_IOCTL_GET_MSRS \ HAX_IOCTL(HAX_IOWR, 0x06, struct hax_msr_data) #define HAX_VCPU_IOCTL_SET_MSRS \ - HAX_IOCTL(HAX_IOW, 0x07, struct hax_msr_data) + HAX_IOCTL(HAX_IOWR, 0x07, struct hax_msr_data) #define HAX_VCPU_IOCTL_INTERRUPT \ HAX_IOCTL(HAX_IOW, 0x08, uint32_t) #define HAX_VCPU_IOCTL_DEBUG \ diff --git a/platforms/linux/components.c b/platforms/linux/components.c index 62812ae9..a808c8d7 100644 --- a/platforms/linux/components.c +++ b/platforms/linux/components.c @@ -363,6 +363,10 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, } } msrs.done = i; + if (copy_to_user(argp, &msrs, sizeof(msrs))) { + ret = -EFAULT; + break; + } break; } case HAX_VCPU_IOCTL_GET_MSRS__LEGACY: