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 b3f6f283..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 @@ -664,7 +647,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..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_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) -#define HAX_VCPU_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_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..7683640f 100644 --- a/include/hax_interface.h +++ b/include/hax_interface.h @@ -49,6 +49,120 @@ #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_GET_API_VERSION \ + HAX_IOCTL(HAX_IOR, 0x00, struct hax_module_version) +#define HAX_IOCTL_CREATE_VM \ + 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_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_IOW, 0x02, struct hax_set_ram_info) +#define HAX_VM_IOCTL_ADD_RAMBLOCK \ + HAX_IOCTL(HAX_IOW, 0x03, struct hax_ramblock_info) +#define HAX_VM_IOCTL_SET_RAM2 \ + HAX_IOCTL(HAX_IOW, 0x04, struct hax_set_ram_info2) +#define HAX_VM_IOCTL_PROTECT_RAM \ + 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_IOR, 0x01, struct hax_tunnel_info) +#define HAX_VCPU_IOCTL_GET_REGS \ + HAX_IOCTL(HAX_IOR, 0x02, struct vcpu_state_t) +#define HAX_VCPU_IOCTL_SET_REGS \ + 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 \ + 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_IOW, 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 +376,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 ecb13fd0..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_SET_REGS _IOWR(0, 0xc7, struct vcpu_state_t) -#define HAX_VCPU_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_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..2419f6d8 100644 --- a/include/windows/hax_interface_windows.h +++ b/include/windows/hax_interface_windows.h @@ -31,6 +31,22 @@ #ifndef HAX_WINDOWS_HAX_INTERFACE_WINDOWS_H_ #define HAX_WINDOWS_HAX_INTERFACE_WINDOWS_H_ +#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_windows, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define HAX_IOCTL(access, code, type) \ + CTL_CODE(HAX_DEVICE_TYPE, (0x800 | code), METHOD_BUFFERED, 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 dc43032e..3457d6da 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,37 +205,43 @@ 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_SET_REGS: { + 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_GET_REGS: { + 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_IOCTL_VCPU_DEBUG: { + case HAX_VCPU_IOCTL_DEBUG__LEGACY: + 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 +255,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; } @@ -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_CREATE_VCPU: { uint32_t vcpu_id, vm_id; struct vcpu_t *cvcpu; @@ -383,7 +393,7 @@ static int hax_vm_ioctl(dev_t dev, ulong cmd, caddr_t data, int flag, } break; } - 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," @@ -392,6 +402,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 +418,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 +439,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 +453,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,26 +528,29 @@ static int hax_ioctl(dev_t dev, u_long cmd, caddr_t data, int flag, int ret = 0; switch (cmd) { - case HAX_IOCTL_VERSION: { + case HAX_IOCTL_VERSION__LEGACY: + case HAX_IOCTL_GET_API_VERSION: { struct hax_module_version *version; version = (struct hax_module_version *)data; version->cur_version = HAX_CUR_VERSION; 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: { + 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), 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 c6bf7ba8..a808c8d7 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; @@ -360,8 +363,13 @@ 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: case HAX_VCPU_IOCTL_GET_MSRS: { struct hax_msr_data msrs; struct vmx_msr *msr; @@ -390,6 +398,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 +408,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,7 +418,8 @@ static long hax_vcpu_ioctl(struct file *filp, unsigned int cmd, } break; } - case HAX_VCPU_SET_REGS: { + 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))) { ret = -EFAULT; @@ -417,7 +428,8 @@ 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__LEGACY: + 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))) { @@ -426,6 +438,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,7 +448,8 @@ 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__LEGACY: + case HAX_VCPU_IOCTL_DEBUG: { struct hax_debug_t hax_debug; if (copy_from_user(&hax_debug, argp, sizeof(hax_debug))) { ret = -EFAULT; @@ -510,8 +524,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_CREATE_VCPU: { uint32_t vcpu_id, vm_id; struct vcpu_t *cvcpu; @@ -528,7 +542,7 @@ static long hax_vm_ioctl(struct file *filp, unsigned int cmd, } break; } - 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; @@ -539,6 +553,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 +571,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 +582,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 +598,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 +615,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..433e12f4 100644 --- a/platforms/linux/hax_entry.c +++ b/platforms/linux/hax_entry.c @@ -69,7 +69,8 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, void *argp = (void *)arg; switch (cmd) { - case HAX_IOCTL_VERSION: { + case HAX_IOCTL_VERSION__LEGACY: + case HAX_IOCTL_GET_API_VERSION: { struct hax_module_version version = {}; version.cur_version = HAX_CUR_VERSION; version.compat_version = HAX_COMPAT_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,13 +86,14 @@ static long hax_dev_ioctl(struct file *filp, unsigned int cmd, return -EFAULT; break; } - 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; 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 952a7773..af4b840c 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,7 +389,8 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, infret = sizeof(struct fx_layout); break; } - case HAX_VCPU_SET_REGS: { + 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)) { ret = STATUS_INVALID_PARAMETER; @@ -395,7 +401,8 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, ret = STATUS_UNSUCCESSFUL; break; } - case HAX_VCPU_GET_REGS: { + 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)) { ret = STATUS_INVALID_PARAMETER; @@ -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,11 +426,8 @@ NTSTATUS HaxVcpuControl(PDEVICE_OBJECT DeviceObject, vcpu_interrupt(cvcpu, vector); break; } - case HAX_VCPU_IOCTL_KICKOFF: { - vcpu_takeoff(cvcpu); - break; - } - case HAX_IOCTL_VCPU_DEBUG: { + case HAX_VCPU_IOCTL_DEBUG__LEGACY: + case HAX_VCPU_IOCTL_DEBUG: { if (inBufLength < sizeof(struct hax_debug_t)) { ret = STATUS_INVALID_PARAMETER; goto done; @@ -433,8 +438,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; } @@ -478,7 +483,8 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, } switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { - case HAX_VM_IOCTL_VCPU_CREATE: { + case HAX_VM_IOCTL_VCPU_CREATE__LEGACY: + case HAX_VM_IOCTL_CREATE_VCPU: { if (inBufLength < sizeof(uint32_t)) { ret = STATUS_INVALID_PARAMETER; goto done; @@ -494,7 +500,7 @@ NTSTATUS HaxVmControl(PDEVICE_OBJECT DeviceObject, struct hax_vm_windows *ext, ret = STATUS_SUCCESS; break; } - 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; @@ -508,6 +514,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 +537,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 +559,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 +587,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 +610,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,7 +649,8 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, outBuf = Irp->AssociatedIrp.SystemBuffer; switch (irpSp->Parameters.DeviceIoControl.IoControlCode) { - case HAX_IOCTL_VERSION: + case HAX_IOCTL_VERSION__LEGACY: + case HAX_IOCTL_GET_API_VERSION: if (outBufLength < sizeof(struct hax_module_version)) { ret = STATUS_INVALID_PARAMETER; goto done; @@ -657,6 +659,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,7 +677,7 @@ NTSTATUS HaxDeviceControl(PDEVICE_OBJECT DeviceObject, ret = STATUS_SUCCESS; break; - case HAX_IOCTL_SET_MEMLIMIT: + case HAX_IOCTL_SET_MEMLIMIT__LEGACY: if (inBufLength < sizeof(struct hax_set_memlimit)) { ret = STATUS_INVALID_PARAMETER; goto done; @@ -685,6 +688,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 52613f7d..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_SET_REGS \ - CTL_CODE(HAX_DEVICE_TYPE, 0x90d, METHOD_BUFFERED, FILE_ANY_ACCESS) -#define HAX_VCPU_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_IOCTL_VCPU_DEBUG \ - CTL_CODE(HAX_DEVICE_TYPE, 0x916, METHOD_BUFFERED, FILE_ANY_ACCESS) - #endif // HAX_WINDOWS_HAX_ENTRY_H_