diff --git a/Cargo.toml b/Cargo.toml index 524487083..4db0d14aa 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -388,6 +388,9 @@ winefs = [] winevt = [] wingdi = [] winhttp = [] +winhvemulation = [] +winhvplatform = [] +winhvplatformdefs = [] wininet = [] winineti = [] winioctl = [] diff --git a/build.rs b/build.rs index 622050495..d910c769a 100644 --- a/build.rs +++ b/build.rs @@ -368,6 +368,9 @@ const DATA: &'static [(&'static str, &'static [&'static str], &'static [&'static ("winevt", &["basetsd", "guiddef", "minwinbase", "minwindef", "vcruntime", "winnt"], &["wevtapi"]), ("wingdi", &["basetsd", "minwindef", "windef", "winnt"], &["gdi32", "msimg32", "opengl32", "winspool"]), ("winhttp", &["basetsd", "minwinbase", "minwindef", "winnt"], &["winhttp"]), + ("winhvemulation", &["basetsd", "minwindef", "ntdef", "winhvplatformdefs"], &["winhvemulation"]), + ("winhvplatform", &["basetsd", "minwindef", "ntdef", "winhvplatformdefs"], &["winhvplatform"]), + ("winhvplatformdefs", &["basetsd", "minwindef"], &[]), ("wininet", &["basetsd", "minwinbase", "minwindef", "ntdef", "windef", "winineti", "winnt"], &["wininet"]), ("winineti", &["minwindef"], &[]), ("winioctl", &["basetsd", "devpropdef", "guiddef", "minwindef", "winnt"], &[]), @@ -416,7 +419,7 @@ struct Header { dependencies: &'static [&'static str], libraries: &'static [&'static str], } -struct Graph(HashMap<&'static str, Header>); +struct Graph(HashMap<&'static str, Header>, bool); impl Graph { fn generate() -> Graph { Graph(DATA.iter().map(|&(name, dependencies, libraries)| { @@ -427,7 +430,7 @@ impl Graph { libraries: libraries, }; (name, header) - }).collect()) + }).collect(), probe_align16()) } fn identify_required(&mut self) { for (name, header) in &mut self.0 { @@ -439,7 +442,12 @@ impl Graph { } fn check_everything(&self) { if let Ok(_) = var("CARGO_FEATURE_EVERYTHING") { - for (_, header) in &self.0 { + for (name, header) in &self.0 { + if name == &"winhvplatform" || name == &"winhvplatformdefs" || name == &"winhvemulation"{ + if !self.1{ + continue; + } + } header.included.set(true); } } @@ -463,6 +471,13 @@ impl Graph { } fn emit_features(&self) { for (name, header) in &self.0 { + if header.included.get(){ + if name == &"winhvplatform" || name == &"winhvplatformdefs" || name == &"winhvemulation"{ + if !self.1{ + panic!("WinHV requires #[repr(C, align(16))] which is incompatible with this rustc version."); + } + } + } if header.included.get() && !header.required { println!("cargo:rustc-cfg=feature=\"{}\"", name); } @@ -484,6 +499,13 @@ impl Graph { }, _ => true, }); + libs.retain(|&&lib| match &*var("TARGET").unwrap() { + "i586-pc-windows-msvc" | "i686-pc-windows-msvc" | "aarch64-pc-windows-msvc" | "i586-pc-windows-gnu" | "i686-pc-windows-gnu" | "aarch64-pc-windows-gnu" => { + if lib == "winhvemulation" || lib == "winhvplatform" { false } + else { true } + }, + _ => true, + }); let prefix = library_prefix(); let kind = library_kind(); for lib in libs { @@ -509,12 +531,38 @@ fn library_kind() -> &'static str { } fn try_everything() { let mut graph = Graph::generate(); + graph.identify_required(); graph.check_everything(); graph.resolve_dependencies(); graph.emit_features(); graph.emit_libraries(); } +fn probe>(code: T)->bool{ + use std::process::{Command, Stdio}; + use std::io::Write; + let mut command = Command::new(&var("RUSTC").unwrap_or_else(|_| "rustc".into())); + let mut child=command.arg("--crate-name") + .arg("rustc_probe") + .arg("--crate-type=lib") + .arg("--out-dir") + .arg(&var("OUT_DIR").unwrap()) + .arg("--emit=llvm-ir") + .arg("-").stdin(Stdio::piped()).spawn().unwrap(); + let mut stdin = child.stdin.take().unwrap(); + stdin.write_all(code.as_ref()).unwrap(); + drop(stdin); + let status=child.wait().unwrap(); + return status.success(); +} +fn probe_align16()->bool{ + let code = " + #[repr(C, align(16))] + struct Aligned(u64,u64); + "; + let ret=probe(&code); + ret +} fn main() { println!("cargo:rerun-if-changed=build.rs"); println!("cargo:rerun-if-env-changed=WINAPI_NO_BUNDLED_LIBRARIES"); diff --git a/src/shared/winerror.rs b/src/shared/winerror.rs index 2c2982100..193cbd4ff 100644 --- a/src/shared/winerror.rs +++ b/src/shared/winerror.rs @@ -6148,3 +6148,14 @@ pub const WININET_E_NOT_REDIRECTED: HRESULT = 0x80072F80; pub const WININET_E_COOKIE_NEEDS_CONFIRMATION: HRESULT = 0x80072F81; pub const WININET_E_COOKIE_DECLINED: HRESULT = 0x80072F82; pub const WININET_E_REDIRECT_NEEDS_CONFIRMATION: HRESULT = 0x80072F88; +pub const WHV_E_UNKNOWN_CAPABILITY: HRESULT = 0x80370300; +pub const WHV_E_INSUFFICIENT_BUFFER: HRESULT = 0x80370301; +pub const WHV_E_UNKNOWN_PROPERTY: HRESULT = 0x80370302; +pub const WHV_E_UNSUPPORTED_HYPERVISOR_CONFIG: HRESULT = 0x80370303; +pub const WHV_E_INVALID_PARTITION_CONFIG: HRESULT = 0x80370304; +pub const WHV_E_GPA_RANGE_NOT_FOUND: HRESULT = 0x80370305; +pub const WHV_E_VP_ALREADY_EXISTS: HRESULT = 0x80370306; +pub const WHV_E_VP_DOES_NOT_EXIST: HRESULT = 0x80370307; +pub const WHV_E_INVALID_VP_STATE: HRESULT = 0x80370308; +pub const WHV_E_INVALID_VP_REGISTER_NAME: HRESULT = 0x80370309; +pub const WHV_E_UNSUPPORTED_PROCESSOR_CONFIG: HRESULT = 0x80370310; diff --git a/src/um/mod.rs b/src/um/mod.rs index b7f0bca4e..cc157d16e 100644 --- a/src/um/mod.rs +++ b/src/um/mod.rs @@ -272,6 +272,9 @@ pub mod gl; #[cfg(feature = "winevt")] pub mod winevt; #[cfg(feature = "wingdi")] pub mod wingdi; #[cfg(feature = "winhttp")] pub mod winhttp; +#[cfg(feature = "winhvemulation")] pub mod winhvemulation; +#[cfg(feature = "winhvplatform")] pub mod winhvplatform; +#[cfg(feature = "winhvplatformdefs")] pub mod winhvplatformdefs; #[cfg(feature = "wininet")] pub mod wininet; #[cfg(feature = "winineti")] pub mod winineti; #[cfg(feature = "winioctl")] pub mod winioctl; diff --git a/src/um/winhvemulation.rs b/src/um/winhvemulation.rs new file mode 100644 index 000000000..565aebb15 --- /dev/null +++ b/src/um/winhvemulation.rs @@ -0,0 +1,100 @@ +use shared::basetsd::{UINT16, UINT32, UINT8}; +use shared::minwindef::LPVOID; +use shared::ntdef::{BOOLEAN, HRESULT}; +use um::winhvplatformdefs::*; +STRUCT!{struct WHV_EMULATOR_STATUS { + AsUINT32: UINT32, +}} +BITFIELD!{WHV_EMULATOR_STATUS AsUINT32: UINT32 [ + EmulationSuccessful set_EmulationSuccessful [0..1], + InternalEmulationFailure set_InternalEmulationFailure [1..2], + IoPortCallbackFailed set_IoPortCallbackFailed [2..3], + MemoryCallbackFailed set_MemoryCallbackFailed [3..4], + TranslateGvaPageCallbackFailed set_TranslateGvaPageCallbackFailed [4..5], + TranslateGvaPageCallbackGpaIsNotAligned + set_TranslateGvaPageCallbackGpaIsNotAligned [5..6], + GetVirtualProcessorRegistersCallbackFailed + set_GetVirtualProcessorRegistersCallbackFailed [6..7], + SetVirtualProcessorRegistersCallbackFailed + set_SetVirtualProcessorRegistersCallbackFailed [7..8], + InterruptCausedIntercept set_InterruptCausedIntercept [8..9], + GuestCannotBeFaultedGuestCannotBeFaulted + set_GuestCannotBeFaultedGuestCannotBeFaulted [9..10], + Reserved set_Reserved [10..32], +]} +STRUCT!{struct WHV_EMULATOR_MEMORY_ACCESS_INFO{ + GpaAddress: WHV_GUEST_PHYSICAL_ADDRESS, + Direction: UINT8, + AccessSize: UINT8, + Data: [UINT8; 5], +}} +STRUCT!{struct WHV_EMULATOR_IO_ACCESS_INFO{ + Direction: UINT8, + Port: UINT16, + AccessSize: UINT16, + Data: UINT32, +}} +FN!{stdcall WHV_EMULATOR_IO_PORT_CALLBACK( + Context: LPVOID, + IOAccess: *mut WHV_EMULATOR_IO_ACCESS_INFO, +) -> HRESULT} +FN!{stdcall WHV_EMULATOR_MEMORY_CALLBACK( + Context: LPVOID, + MemoryAccess: *mut WHV_EMULATOR_MEMORY_ACCESS_INFO, +) -> HRESULT} +FN!{stdcall WHV_EMULATOR_GET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK( + Context: LPVOID, + RegisterNames: *const WHV_REGISTER_NAME, + RegisterCount: UINT32, + RegisterValues: *mut WHV_REGISTER_VALUE, +) -> HRESULT} +FN!{stdcall WHV_EMULATOR_SET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK( + Context: LPVOID, + RegisterNames: *const WHV_REGISTER_NAME, + RegisterCount: UINT32, + RegisterValues: *const WHV_REGISTER_VALUE, +) -> HRESULT} +FN!{stdcall WHV_EMULATOR_TRANSLATE_GVA_PAGE_CALLBACK( + Context: LPVOID, + Gva: WHV_GUEST_VIRTUAL_ADDRESS, + TranslateFlags: WHV_TRANSLATE_GVA_FLAGS, + TranslationResult: *mut WHV_TRANSLATE_GVA_RESULT_CODE, + Gpa: *mut WHV_GUEST_PHYSICAL_ADDRESS, +) -> HRESULT} +STRUCT!{struct WHV_EMULATOR_CALLBACKS{ + Size: UINT32, + Reserved: UINT32, + WHvEmulatorIoPortCallback: WHV_EMULATOR_IO_PORT_CALLBACK, + WHvEmulatorMemoryCallback: WHV_EMULATOR_MEMORY_CALLBACK, + WHvEmulatorGetVirtualProcessorRegisters: WHV_EMULATOR_GET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK, + WHvEmulatorSetVirtualProcessorRegisters: WHV_EMULATOR_SET_VIRTUAL_PROCESSOR_REGISTERS_CALLBACK, + WHvEmulatorTranslateGvaPage: WHV_EMULATOR_TRANSLATE_GVA_PAGE_CALLBACK, +}} +pub type WHV_EMULATOR_HANDLE = LPVOID; +extern "system" { + pub fn WHvEmulatorCreateEmulator( + Callbacks: *const WHV_EMULATOR_CALLBACKS, + Emulator: *mut WHV_EMULATOR_HANDLE, + )->HRESULT; + pub fn WHvEmulatorDestroyEmulator( + Emulator: *mut WHV_EMULATOR_HANDLE, + )->HRESULT; + pub fn WHvEmulatorTryIoEmulation( + Emulator: *mut WHV_EMULATOR_HANDLE, + Context: LPVOID, + VpContext: *const WHV_VP_EXIT_CONTEXT, + IoInstructionContext: *const WHV_X64_IO_PORT_ACCESS_CONTEXT, + EmulatorReturnStatus: *mut WHV_EMULATOR_STATUS, + )->HRESULT; + pub fn WHvEmulatorTryMmioEmulation( + Emulator: WHV_EMULATOR_HANDLE, + Context: LPVOID, + VpContext: *const WHV_VP_EXIT_CONTEXT, + MmioInstructionContext: *const WHV_MEMORY_ACCESS_CONTEXT, + EmulatorReturnStatus: *mut WHV_EMULATOR_STATUS, + )->HRESULT; + pub fn IsWHvEmulatorCreateEmulatorPresent()->BOOLEAN; + pub fn IsWHvEmulatorDestroyEmulatorPresent()->BOOLEAN; + pub fn IsWHvEmulatorTryIoEmulationPresent()->BOOLEAN; + pub fn IsWHvEmulatorTryMmioEmulationPresent()->BOOLEAN; +} diff --git a/src/um/winhvplatform.rs b/src/um/winhvplatform.rs new file mode 100644 index 000000000..fce7659fe --- /dev/null +++ b/src/um/winhvplatform.rs @@ -0,0 +1,192 @@ +use shared::basetsd::{UINT32, UINT64}; +use shared::minwindef::{LPCVOID, LPVOID}; +use shared::ntdef::{BOOLEAN, HANDLE, HRESULT}; +use um::winhvplatformdefs::*; +extern "system"{ + pub fn WHvGetCapability( + CapabilityCode: WHV_CAPABILITY_CODE, + CapabilityBuffer: LPVOID, + CapabilityBufferSizeInBytes: UINT32, + WrittenSizeInBytes: *mut UINT32, + ) -> HRESULT; + pub fn WHvCreatePartition( + Partition: *mut WHV_PARTITION_HANDLE, + ) -> HRESULT; + pub fn WHvSetupPartition( + Partition: WHV_PARTITION_HANDLE, + ) -> HRESULT; + pub fn WHvDeletePartition( + Partition: WHV_PARTITION_HANDLE, + ) -> HRESULT; + pub fn WHvGetPartitionProperty( + Partition: WHV_PARTITION_HANDLE, + PropertyCode: WHV_PARTITION_PROPERTY_CODE, + PropertyBuffer: LPCVOID, + PropertyBufferSizeInBytes: UINT32, + ) -> HRESULT; + pub fn WHvSuspendPartitionTime( + Partition: WHV_PARTITION_HANDLE, + ) -> HRESULT; + pub fn WHvResumePartitionTime( + Partition: WHV_PARTITION_HANDLE, + ) -> HRESULT; + pub fn WHvMapGpaRange( + Partition: WHV_PARTITION_HANDLE, + SourceAddress: LPVOID, + GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS, + SizeInBytes: UINT64, + Flags: WHV_MAP_GPA_RANGE_FLAGS, + ) -> HRESULT; + pub fn WHvUnmapGpaRange( + Partition: WHV_PARTITION_HANDLE, + GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS, + SizeInBytes: UINT64, + ) -> HRESULT; + pub fn WHvTranslateGva( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + Gva: WHV_GUEST_VIRTUAL_ADDRESS, + TranslateFlags: WHV_TRANSLATE_GVA_FLAGS, + TranslationResult: *mut WHV_TRANSLATE_GVA_RESULT, + Gpa: WHV_GUEST_PHYSICAL_ADDRESS, + ) -> HRESULT; + pub fn WHvCreateVirtualProcessor( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + Flags: UINT32, + ) -> HRESULT; + pub fn WHvDeleteVirtualProcessor( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + ) -> HRESULT; + pub fn WHvRunVirtualProcessor( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + ExitContext: LPVOID, + ExitContextSizeInBytes: UINT32, + ) -> HRESULT; + pub fn WHvCancelRunVirtualProcessor( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + Flags: UINT32, + ) -> HRESULT; + pub fn WHvGetVirtualProcessorRegisters( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + RegisterNames: *const WHV_REGISTER_NAME, + RegisterCount: UINT32, + RegisterValues: *mut WHV_REGISTER_VALUE, + ) -> HRESULT; + pub fn WHvSetVirtualProcessorRegisters( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + RegisterNames: *const WHV_REGISTER_NAME, + RegisterCount: UINT32, + RegisterValues: *const WHV_REGISTER_VALUE, + ) -> HRESULT; + #[deprecated(note="WHvGetVirtualProcessorInterruptControllerState is deprecated; use WHvGetVirtualProcessorInterruptControllerState2")] + pub fn WHvGetVirtualProcessorInterruptControllerState( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + State: LPVOID, + StateSize: UINT32, + WrittenSize: *mut UINT32, + ) -> HRESULT; + #[deprecated(note="WHvSetVirtualProcessorInterruptControllerState is deprecated; use WHvSetVirtualProcessorInterruptControllerState2")] + pub fn WHvSetVirtualProcessorInterruptControllerState( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + State: LPCVOID, + StateSize: UINT32, + ) -> HRESULT; + pub fn WHvRequestInterrupt( + Partition: WHV_PARTITION_HANDLE, + Interrupt: *const WHV_INTERRUPT_CONTROL, + InterruptControlSize: UINT32, + ) -> HRESULT; + pub fn WHvGetVirtualProcessorXsaveState( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + Buffer: LPVOID, + BufferSizeInBytes: UINT32, + BytesWritten: *mut UINT32, + ) -> HRESULT; + pub fn WHvSetVirtualProcessorXsaveState( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + Buffer: LPVOID, + BufferSizeInBytes: UINT32, + ) -> HRESULT; + pub fn WHvQueryGpaRangeDirtyBirmap( + Partition: WHV_PARTITION_HANDLE, + GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS, + Bitmap: *mut UINT64, + BitmapSizeInBytes: UINT32, + ) -> HRESULT; + pub fn WHvGetPartitionCounters( + Partition: WHV_PARTITION_HANDLE, + CounterSet: WHV_PARTITION_COUNTER_SET, + Buffer: LPVOID, + BufferSizeInBytes: UINT32, + BytesWritten: *mut UINT32, + ) -> HRESULT; + pub fn WHvGetVirtualPartitionCounters( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + CounterSet: WHV_PARTITION_COUNTER_SET, + Buffer: LPVOID, + BufferSizeInBytes: UINT32, + BytesWritten: *mut UINT32, + ) -> HRESULT; + pub fn WHvGetVirtualProcessorInterruptControllerState2( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + State: LPVOID, + StateSize: UINT32, + WrittenSize: *mut UINT32, + ) -> HRESULT; + pub fn WHvSetVirtualProcessorInterruptControllerState2( + Partition: WHV_PARTITION_HANDLE, + VpIndex: UINT32, + State: LPCVOID, + StateSize: UINT32, + ) -> HRESULT; + pub fn WHvRegisterPartitionDoorbellEvent( + Partition: WHV_PARTITION_HANDLE, + MatchData: *const WHV_DOORBELL_MATCH_DATA, + EventHandle: HANDLE, + ) -> HRESULT; + pub fn WHvUnregisterPartitionDoorbellEvent( + Partition: WHV_PARTITION_HANDLE, + MatchData: *const WHV_DOORBELL_MATCH_DATA, + ) -> HRESULT; + pub fn IsWHvGetCapabilityPresent()->BOOLEAN; + pub fn IsWHvCreatePartitionPresent()->BOOLEAN; + pub fn IsWHvSetupPartitionPresent()->BOOLEAN; + pub fn IsWHvDeletePartitionPresent()->BOOLEAN; + pub fn IsWHvGetPartitionPropertyPresent()->BOOLEAN; + pub fn IsWHvSetPartitionPropertyPresent()->BOOLEAN; + pub fn IsWHvSuspendPartitionTimePresent()->BOOLEAN; + pub fn IsWHvResumePartitionTimePresent()->BOOLEAN; + pub fn IsWHvMapGpaRangePresent()->BOOLEAN; + pub fn IsWHvUnmapGpaRangePresent()->BOOLEAN; + pub fn IsWHvTranslateGvaPresent()->BOOLEAN; + pub fn IsWHvCreateVirtualProcessorPresent()->BOOLEAN; + pub fn IsWHvDeleteVirtualProcessorPresent()->BOOLEAN; + pub fn IsWHvRunVirtualProcessorPresent()->BOOLEAN; + pub fn IsWHvCancelRunVirtualProcessorPresent()->BOOLEAN; + pub fn IsWHvGetVirtualProcessorRegistersPresent()->BOOLEAN; + pub fn IsWHvSetVirtualProcessorRegistersPresent()->BOOLEAN; + pub fn IsWHvGetVirtualProcessorInterruptControllerStatePresent()->BOOLEAN; + pub fn IsWHvSetVirtualProcessorInterruptControllerStatePresent()->BOOLEAN; + pub fn IsWHvRequestInterruptPresent()->BOOLEAN; + pub fn IsWHvGetVirtualProcessorXsaveStatePresent()->BOOLEAN; + pub fn IsWHvSetVirtualProcessorXsaveStatePresent()->BOOLEAN; + pub fn IsWHvQueryGpaRangeDirtyBitmapPresent()->BOOLEAN; + pub fn IsWHvGetPartitionCountersPresent()->BOOLEAN; + pub fn IsWHvGetVirtualProcessorCountersPresent()->BOOLEAN; + pub fn IsWHvGetVirtualProcessorInterruptControllerState2Present()->BOOLEAN; + pub fn IsWHvSetVirtualProcessorInterruptControllerState2Present()->BOOLEAN; + pub fn IsWHvRegisterPartitionDoorbellEventPresent()->BOOLEAN; + pub fn IsWHvUnregisterPartitionDoorbellEventPresent()->BOOLEAN; +} diff --git a/src/um/winhvplatformdefs.rs b/src/um/winhvplatformdefs.rs new file mode 100644 index 000000000..d553f6b45 --- /dev/null +++ b/src/um/winhvplatformdefs.rs @@ -0,0 +1,1038 @@ +use shared::basetsd::{UINT16, UINT32, UINT64, UINT8}; +use shared::minwindef::{ + BOOL, LPVOID +}; +ENUM!{enum WHV_CAPABILITY_CODE { + WHvCapabilityCodeHypervisorPresent = 0x00000000, + WHvCapabilityCodeFeatures = 0x00000001, + WHvCapabilityCodeExtendedVmExits = 0x00000002, + WHvCapabilityCodeExceptionExitBitmap = 0x00000003, + WHvCapabilityCodeX64MsrExitBitmap = 0x00000004, + WHvCapabilityCodeProcessorVendor = 0x00001000, + WHvCapabilityCodeProcessorFeatures = 0x00001001, + WHvCapabilityCodeProcessorClFlushSize = 0x00001002, + WHvCapabilityCodeProcessorXsaveFeatures = 0x00001003, + WHvCapabilityCodeProcessorClockFrequency = 0x00001004, + WHvCapabilityCodeInterruptClockFrequency = 0x00001005, + WHvCapabilityCodeProcessorFeaturesBanks = 0x00001006, +}} +STRUCT!{struct WHV_CAPABILITY_FEATURES { + AsUINT64: UINT64, +}} +BITFIELD!{WHV_CAPABILITY_FEATURES AsUINT64: UINT64 [ + PartialUnmap set_PartialUnmap [0..1], + LocalApicEmulation set_LocalApicEmulation [1..2], + Xsave set_Xsave [2..3], + DirtyPageTracking set_DirtyPageTracking [3..4], + SpeculationControl set_SpeculationControl [4..5], + ApicRemoteRead set_ApicRemoteRead [5..6], + IdleSuspend set_IdleSuspend [6..7], + Reserved set_Reserved [7..64], +]} +STRUCT!{struct WHV_EXTENDED_VM_EXITS { + AsUINT64: UINT64, +}} +BITFIELD!{WHV_EXTENDED_VM_EXITS AsUINT64: UINT64 [ + X64CpuidExit set_X64CpuidExit [0..1], + X64MsrExit set_X64MsrExit [1..2], + ExceptionExit set_ExceptionExit [2..3], + X64RdtscExit set_X64RdtscExit [3..4], + X64ApicSmiExitTrap set_X64ApicSmiExitTrap [4..5], + HypercallExit set_HypercallExit [5..6], + X64ApicInitSipiExitTrap set_X64ApicInitSipiExitTrap [6..7], + X64ApicWriteLint0ExitTrap set_X64ApicWriteLint0ExitTrap [7..8], + X64ApicWriteLint1ExitTrap set_X64ApicWriteLint1ExitTrap [8..9], + X64ApicWriteSvrExitTrap set_X64ApicWriteSvrExitTrap [9..10], + Reserved set_Reserved [10..64], +]} +ENUM!{enum WHV_PROCESSOR_VENDOR { + WHvProcessorVendorAmd = 0x0000, + WHvProcessorVendorIntel = 0x0001, + WHvProcessorVendorHygon = 0x0002, +}} +STRUCT!{struct WHV_PROCESSOR_FEATURES { + AsUINT64: UINT64, +}} +BITFIELD!{WHV_PROCESSOR_FEATURES AsUINT64: UINT64 [ + Sse3Support set_Sse3Support [0..1], + LahfSahfSupport set_LahfSahfSupport [1..2], + Ssse3Support set_Ssse3Support [2..3], + Sse4_1Support set_Sse4_1Support [3..4], + Sse4_2Support set_Sse4_2Support [4..5], + Sse4aSupport set_Sse4aSupport [5..6], + XopSupport set_XopSupport [6..7], + PopCntSupport set_PopCntSupport [7..8], + Cmpxchg16bSupport set_Cmpxchg16bSupport [8..9], + Altmovcr8Support set_Altmovcr8Support [9..10], + LzcntSupport set_LzcntSupport [10..11], + MisAlignSseSupport set_MisAlignSseSupport [11..12], + MmxExtSupport set_MmxExtSupport [12..13], + Amd3DNowSupport set_Amd3DNowSupport [13..14], + ExtendedAmd3DNowSupport set_ExtendedAmd3DNowSupport [14..15], + Page1GbSupport set_Page1GbSupport [15..16], + AesSupport set_AesSupport [16..17], + PclmulqdqSupport set_PclmulqdqSupport [17..18], + PcidSupport set_PcidSupport [18..19], + Fma4Support set_Fma4Support [19..20], + F16CSupport set_F16CSupport [20..21], + RdRandSupport set_RdRandSupport [21..22], + RdWrFsGsSupport set_RdWrFsGsSupport [22..23], + SmepSupport set_SmepSupport [23..24], + EnhancedFastStringSupport set_EnhancedFastStringSupport [24..25], + Bmi1Support set_Bmi1Support [25..26], + Bmi2Support set_Bmi2Support [26..27], + Reserved1 set_Reserved1 [27..29], + MovbeSupport set_MovbeSupport [29..30], + Npiep1Support set_Npiep1Support [30..31], + DepX87FPUSaveSupport set_DepX87FPUSaveSupport [31..32], + RdSeedSupport set_RdSeedSupport [32..33], + AdxSupport set_AdxSupport [33..34], + IntelPrefetchSupport set_IntelPrefetchSupport [34..35], + SmapSupport set_SmapSupport [35..36], + HleSupport set_HleSupport [36..37], + RtmSupport set_RtmSupport [37..38], + RdtscpSupport set_RdtscpSupport [38..39], + ClflushoptSupport set_ClflushoptSupport [39..40], + ClwbSupport set_ClwbSupport [40..41], + ShaSupport set_ShaSupport [41..42], + X87PointersSavedSupport set_X87PointersSavedSupport [42..43], + InvpcidSupport set_InvpcidSupport [43..44], + IbrsSupport set_IbrsSupport [44..45], + StibpSupport set_StibpSupport [45..46], + IbpbSupport set_IbpbSupport [46..47], + Reserved2 set_Reserved2 [47..48], + SsbdSupport set_SsbdSupport [48..49], + FastShortRepMovSupport set_FastShortRepMovSupport [49..50], + Reserved3 set_Reserved3 [50..51], + RdclNo set_RdclNo [51..52], + IbrsAllSupport set_IbrsAllSupport [52..53], + Reserved4 set_Reserved4 [53..54], + SsbNo set_SsbNo [54..55], + RsbANo set_RsbANo [55..56], + Reserved5 set_Reserved5 [56..57], + RdPidSupport set_RdPidSupport [57..58], + UmipSupport set_UmipSupport [58..59], + MdsNoSupport set_MdsNoSupport [59..60], + MdClearSupport set_MdClearSupport [60..61], + Reserved6 set_Reserved6 [61..64], +]} +STRUCT!{struct WHV_PROCESSOR_FEATURES1 { + AsUINT64: UINT64, +}} +BITFIELD!{WHV_PROCESSOR_FEATURES1 AsUINT64: UINT64 [ + Reserved1 set_Reserved1 [0..2], + ClZeroSupport set_ClZeroSupport [2..3], + Reserved2 set_Reserved2 [3..64], +]} +STRUCT!{struct WHV_PROCESSOR_XSAVE_FEATURES { + AsUINT64: UINT64, +}} +pub const WHV_PROCESSOR_FEATURES_BANKS_COUNT: usize = 2; +STRUCT!{struct WHV_PROCESSOR_FEATURES_BANKS_u_s{ + Bank0: WHV_PROCESSOR_FEATURES, + Bank1: WHV_PROCESSOR_FEATURES1, +}} +UNION!{union WHV_PROCESSOR_FEATURES_BANKS_u{ + [u64; 2], + s s_mut: WHV_PROCESSOR_FEATURES_BANKS_u_s, + AsUINT64 AsUINT64_mut: [UINT64; 2], +}} +STRUCT!{struct WHV_PROCESSOR_FEATURES_BANKS{ + BanksCount: UINT32, + Reserved0: UINT32, + u: WHV_PROCESSOR_FEATURES_BANKS_u, +}} +BITFIELD!{WHV_PROCESSOR_FEATURES AsUINT64: UINT64 [ + XsaveSupport set_XsaveSupport [0..1], + XsaveoptSupport set_XsaveoptSupport [1..2], + AvxSupport set_AvxSupport [2..3], + Avx2Support set_Avx2Support [3..4], + FmaSupport set_FmaSupport [4..5], + MpxSupport set_MpxSupport [5..6], + Avx512Support set_Avx512Support [6..7], + Avx512DQSupport set_Avx512DQSupport [7..8], + Avx512CDSupport set_Avx512CDSupport [8..9], + Avx512BWSupport set_Avx512BWSupport [9..10], + Avx512VLSupport set_Avx512VLSupport [10..11], + XsaveCompSupport set_XsaveCompSupport [11..12], + XsaveSupervisorSupport set_XsaveSupervisorSupport [12..13], + Xcr1Support set_Xcr1Support [13..14], + Avx512BitalgSupport set_Avx512BitalgSupport [14..15], + Avx512IfmaSupport set_Avx512IfmaSupport [15..16], + Avx512VBmiSupport set_Avx512VBmiSupport [16..17], + Avx512VBmi2Support set_Avx512VBmi2Support [17..18], + Avx512VnniSupport set_Avx512VnniSupport [18..19], + GfniSupport set_GfniSupport [19..20], + VaesSupport set_VaesSupport [20..21], + Avx512VPopcntdqSupport set_Avx512VPopcntdqSupport [21..22], + VpclmulqdqSupport set_VpclmulqdqSupport [22..23], + Avx512Bf16Support set_Avx512Bf16Support [23..24], + Avx512Vp2IntersectSupport set_Avx512Vp2IntersectSupport [24..25], + Reserved set_Reserved [25..64], +]} +pub type PWHV_PROCESSOR_XSAVE_FEATURES = *mut WHV_PROCESSOR_XSAVE_FEATURES; +STRUCT!{struct WHV_X64_MSR_EXIT_BITMAP { + AsUINT64: UINT64, +}} +BITFIELD!{WHV_X64_MSR_EXIT_BITMAP AsUINT64: UINT64 [ + UnhandledMsrs set_UnhandledMsrs [0..1], + TscMsrWrite set_TscMsrWrite [1..2], + TscMsrRead set_TscMsrRead [2..3], + ApicBaseMsrWrite set_ApicBaseMsrWrite [3..4], + MiscEnableMsrRead set_MiscEnableMsrRead [4..5], + McUpdatePatchLevelMsrRead set_McUpdatePatchLevelMsrRead [5..6], + Reserved set_Reserved [6..64], +]} +UNION!{union WHV_CAPABILITY +{ + [u64; 3], + HypervisorPresent HypervisorPresent_mut: BOOL, + Features Features_mut: WHV_CAPABILITY_FEATURES, + ExtendedVmExits ExtendedVmExits_mut: WHV_EXTENDED_VM_EXITS, + ProcessorVendor ProcessorVendor_mut: WHV_PROCESSOR_VENDOR, + ProcessorFeatures ProcessorFeatures_mut: WHV_PROCESSOR_FEATURES, + ProcessorXsaveFeatures ProcessorXsaveFeatures_mut: WHV_PROCESSOR_XSAVE_FEATURES, + ProcessorClFlushSize ProcessorClFlushSize_mut: UINT8, + ExceptionExitBitmap ExceptionExitBitmap_mut: UINT64, + X64MsrExitBitmap X64MsrExitBitmap_mut: WHV_X64_MSR_EXIT_BITMAP, + ProcessorClockFrequency ProcessorClockFrequency_mut: UINT64, + InterruptClockFrequency InterruptClockFrequency_mut: UINT64, + ProcessorFeaturesBanks ProcessorFeaturesBanks_mut: WHV_PROCESSOR_FEATURES_BANKS, +}} +pub type WHV_PARTITION_HANDLE = LPVOID; +ENUM!{enum WHV_PARTITION_PROPERTY_CODE +{ + WHvPartitionPropertyCodeExtendedVmExits = 0x00000001, + WHvPartitionPropertyCodeExceptionExitBitmap = 0x00000002, + WHvPartitionPropertyCodeSeparateSecurityDomain = 0x00000003, + WHvPartitionPropertyCodeNestedVirtualization = 0x00000004, + WHvPartitionPropertyCodeX64MsrExitBitmap = 0x00000005, + WHvPartitionPropertyCodeProcessorFeatures = 0x00001001, + WHvPartitionPropertyCodeProcessorClFlushSize = 0x00001002, + WHvPartitionPropertyCodeCpuidExitList = 0x00001003, + WHvPartitionPropertyCodeCpuidResultList = 0x00001004, + WHvPartitionPropertyCodeLocalApicEmulationMode = 0x00001005, + WHvPartitionPropertyCodeProcessorXsaveFeatures = 0x00001006, + WHvPartitionPropertyCodeProcessorClockFrequency = 0x00001007, + WHvPartitionPropertyCodeInterruptClockFrequency = 0x00001008, + WHvPartitionPropertyCodeApicRemoteReadSupport = 0x00001009, + WHvPartitionPropertyCodeProcessorFeaturesBanks = 0x0000100A, + WHvPartitionPropertyCodeReferenceTime = 0x0000100B, + WHvPartitionPropertyCodeProcessorCount = 0x00001fff, +}} +STRUCT!{struct WHV_X64_CPUID_RESULT +{ + Function: UINT32, + Reserved: [UINT32; 3], + Eax: UINT32, + Ebx: UINT32, + Ecx: UINT32, + Edx: UINT32, +}} +ENUM!{enum WHV_EXCEPTION_TYPE +{ + WHvX64ExceptionTypeDivideErrorFault = 0x0, + WHvX64ExceptionTypeDebugTrapOrFault = 0x1, + WHvX64ExceptionTypeBreakpointTrap = 0x3, + WHvX64ExceptionTypeOverflowTrap = 0x4, + WHvX64ExceptionTypeBoundRangeFault = 0x5, + WHvX64ExceptionTypeInvalidOpcodeFault = 0x6, + WHvX64ExceptionTypeDeviceNotAvailableFault = 0x7, + WHvX64ExceptionTypeDoubleFaultAbort = 0x8, + WHvX64ExceptionTypeInvalidTaskStateSegmentFault = 0x0A, + WHvX64ExceptionTypeSegmentNotPresentFault = 0x0B, + WHvX64ExceptionTypeStackFault = 0x0C, + WHvX64ExceptionTypeGeneralProtectionFault = 0x0D, + WHvX64ExceptionTypePageFault = 0x0E, + WHvX64ExceptionTypeFloatingPointErrorFault = 0x10, + WHvX64ExceptionTypeAlignmentCheckFault = 0x11, + WHvX64ExceptionTypeMachineCheckAbort = 0x12, + WHvX64ExceptionTypeSimdFloatingPointFault = 0x13, +}} +ENUM!{enum WHV_X64_LOCAL_APIC_EMULATION_MODE +{ + WHvX64LocalApicEmulationModeNone, + WHvX64LocalApicEmulationModeXApic, + WHvX64LocalApicEmulationModeX2Apic, +}} +UNION!{union WHV_PARTITION_PROPERTY +{ + [u64; 4], + ExtendedVmExits ExtendedVmExits_mut: WHV_EXTENDED_VM_EXITS, + ProcessorFeatures ProcessorFeatures_mut: WHV_PROCESSOR_FEATURES, + ProcessorXsaveFeatures ProcessorXsaveFeatures_mut: WHV_PROCESSOR_XSAVE_FEATURES, + ProcessorClFlushSize ProcessorClFlushSize_mut: UINT8, + ProcessorCount ProcessorCount_mut: UINT32, + CpuidExitList CpuidExitList_mut: [UINT32; 1], + CpuidResultList CpuidResultList_mut: [WHV_X64_CPUID_RESULT; 1], + LocalApicEmulationMode LocalApicEmulationMode_mut: WHV_X64_LOCAL_APIC_EMULATION_MODE, + SeparateSecurityDomain SeparateSecurityDomain_mut: BOOL, + NestedVirtualization NestedVirtualization_mut: BOOL, + X64MsrExitBitmap X64MsrExitBitmap_mut: WHV_X64_MSR_EXIT_BITMAP, + ProcessorClockFrequency ProcessorClockFrequency_mut: UINT64, + InterruptClockFrequency InterruptClockFrequency_mut: UINT64, + ApicRemoteRead ApicRemoteRead_mut: BOOL, + ProcessorFeaturesBanks ProcessorFeaturesBanks_mut: WHV_PROCESSOR_FEATURES_BANKS, + ReferenceTime ReferenceTime_mut: UINT64, +}} +pub type WHV_GUEST_PHYSICAL_ADDRESS = UINT64; +pub type WHV_GUEST_VIRTUAL_ADDRESS = UINT64; +ENUM!{enum WHV_MAP_GPA_RANGE_FLAGS +{ + WHvMapGpaRangeFlagNone = 0x00000000, + WHvMapGpaRangeFlagRead = 0x00000001, + WHvMapGpaRangeFlagWrite = 0x00000002, + WHvMapGpaRangeFlagExecute = 0x00000004, + WHvMapGpaRangeFlagTrackDirtyPages = 0x00000008, +}} +ENUM!{enum WHV_TRANSLATE_GVA_FLAGS { + WHvTranslateGvaFlagNone = 0x00000000, + WHvTranslateGvaFlagValidateRead = 0x00000001, + WHvTranslateGvaFlagValidateWrite = 0x00000002, + WHvTranslateGvaFlagValidateExecute = 0x00000004, + WHvTranslateGvaFlagPrivilegeExempt = 0x00000008, + WHvTranslateGvaFlagSetPageTableBits = 0x00000010, +}} +ENUM!{enum WHV_TRANSLATE_GVA_RESULT_CODE { + WHvTranslateGvaResultSuccess = 0, + WHvTranslateGvaResultPageNotPresent = 1, + WHvTranslateGvaResultPrivilegeViolation = 2, + WHvTranslateGvaResultInvalidPageTableFlags = 3, + WHvTranslateGvaResultGpaUnmapped = 4, + WHvTranslateGvaResultGpaNoReadAccess = 5, + WHvTranslateGvaResultGpaNoWriteAccess = 6, + WHvTranslateGvaResultGpaIllegalOverlayAccess = 7, + WHvTranslateGvaResultIntercept = 8, +}} +STRUCT!{struct WHV_TRANSLATE_GVA_RESULT { + ResultCode: WHV_TRANSLATE_GVA_RESULT_CODE, + Reserved: UINT32, +}} +ENUM!{enum WHV_REGISTER_NAME { + WHvX64RegisterRax = 0x00000000, + WHvX64RegisterRcx = 0x00000001, + WHvX64RegisterRdx = 0x00000002, + WHvX64RegisterRbx = 0x00000003, + WHvX64RegisterRsp = 0x00000004, + WHvX64RegisterRbp = 0x00000005, + WHvX64RegisterRsi = 0x00000006, + WHvX64RegisterRdi = 0x00000007, + WHvX64RegisterR8 = 0x00000008, + WHvX64RegisterR9 = 0x00000009, + WHvX64RegisterR10 = 0x0000000A, + WHvX64RegisterR11 = 0x0000000B, + WHvX64RegisterR12 = 0x0000000C, + WHvX64RegisterR13 = 0x0000000D, + WHvX64RegisterR14 = 0x0000000E, + WHvX64RegisterR15 = 0x0000000F, + WHvX64RegisterRip = 0x00000010, + WHvX64RegisterRflags = 0x00000011, + WHvX64RegisterEs = 0x00000012, + WHvX64RegisterCs = 0x00000013, + WHvX64RegisterSs = 0x00000014, + WHvX64RegisterDs = 0x00000015, + WHvX64RegisterFs = 0x00000016, + WHvX64RegisterGs = 0x00000017, + WHvX64RegisterLdtr = 0x00000018, + WHvX64RegisterTr = 0x00000019, + WHvX64RegisterIdtr = 0x0000001A, + WHvX64RegisterGdtr = 0x0000001B, + WHvX64RegisterCr0 = 0x0000001C, + WHvX64RegisterCr2 = 0x0000001D, + WHvX64RegisterCr3 = 0x0000001E, + WHvX64RegisterCr4 = 0x0000001F, + WHvX64RegisterCr8 = 0x00000020, + WHvX64RegisterDr0 = 0x00000021, + WHvX64RegisterDr1 = 0x00000022, + WHvX64RegisterDr2 = 0x00000023, + WHvX64RegisterDr3 = 0x00000024, + WHvX64RegisterDr6 = 0x00000025, + WHvX64RegisterDr7 = 0x00000026, + WHvX64RegisterXCr0 = 0x00000027, + WHvX64RegisterXmm0 = 0x00001000, + WHvX64RegisterXmm1 = 0x00001001, + WHvX64RegisterXmm2 = 0x00001002, + WHvX64RegisterXmm3 = 0x00001003, + WHvX64RegisterXmm4 = 0x00001004, + WHvX64RegisterXmm5 = 0x00001005, + WHvX64RegisterXmm6 = 0x00001006, + WHvX64RegisterXmm7 = 0x00001007, + WHvX64RegisterXmm8 = 0x00001008, + WHvX64RegisterXmm9 = 0x00001009, + WHvX64RegisterXmm10 = 0x0000100A, + WHvX64RegisterXmm11 = 0x0000100B, + WHvX64RegisterXmm12 = 0x0000100C, + WHvX64RegisterXmm13 = 0x0000100D, + WHvX64RegisterXmm14 = 0x0000100E, + WHvX64RegisterXmm15 = 0x0000100F, + WHvX64RegisterFpMmx0 = 0x00001010, + WHvX64RegisterFpMmx1 = 0x00001011, + WHvX64RegisterFpMmx2 = 0x00001012, + WHvX64RegisterFpMmx3 = 0x00001013, + WHvX64RegisterFpMmx4 = 0x00001014, + WHvX64RegisterFpMmx5 = 0x00001015, + WHvX64RegisterFpMmx6 = 0x00001016, + WHvX64RegisterFpMmx7 = 0x00001017, + WHvX64RegisterFpControlStatus = 0x00001018, + WHvX64RegisterXmmControlStatus = 0x00001019, + WHvX64RegisterTsc = 0x00002000, + WHvX64RegisterEfer = 0x00002001, + WHvX64RegisterKernelGsBase = 0x00002002, + WHvX64RegisterApicBase = 0x00002003, + WHvX64RegisterPat = 0x00002004, + WHvX64RegisterSysenterCs = 0x00002005, + WHvX64RegisterSysenterEip = 0x00002006, + WHvX64RegisterSysenterEsp = 0x00002007, + WHvX64RegisterStar = 0x00002008, + WHvX64RegisterLstar = 0x00002009, + WHvX64RegisterCstar = 0x0000200A, + WHvX64RegisterSfmask = 0x0000200B, + WHvX64RegisterInitialApicId = 0x0000200C, + WHvX64RegisterMsrMtrrCap = 0x0000200D, + WHvX64RegisterMsrMtrrDefType = 0x0000200E, + WHvX64RegisterMsrMtrrPhysBase0 = 0x00002010, + WHvX64RegisterMsrMtrrPhysBase1 = 0x00002011, + WHvX64RegisterMsrMtrrPhysBase2 = 0x00002012, + WHvX64RegisterMsrMtrrPhysBase3 = 0x00002013, + WHvX64RegisterMsrMtrrPhysBase4 = 0x00002014, + WHvX64RegisterMsrMtrrPhysBase5 = 0x00002015, + WHvX64RegisterMsrMtrrPhysBase6 = 0x00002016, + WHvX64RegisterMsrMtrrPhysBase7 = 0x00002017, + WHvX64RegisterMsrMtrrPhysBase8 = 0x00002018, + WHvX64RegisterMsrMtrrPhysBase9 = 0x00002019, + WHvX64RegisterMsrMtrrPhysBaseA = 0x0000201A, + WHvX64RegisterMsrMtrrPhysBaseB = 0x0000201B, + WHvX64RegisterMsrMtrrPhysBaseC = 0x0000201C, + WHvX64RegisterMsrMtrrPhysBaseD = 0x0000201D, + WHvX64RegisterMsrMtrrPhysBaseE = 0x0000201E, + WHvX64RegisterMsrMtrrPhysBaseF = 0x0000201F, + WHvX64RegisterMsrMtrrPhysMask0 = 0x00002040, + WHvX64RegisterMsrMtrrPhysMask1 = 0x00002041, + WHvX64RegisterMsrMtrrPhysMask2 = 0x00002042, + WHvX64RegisterMsrMtrrPhysMask3 = 0x00002043, + WHvX64RegisterMsrMtrrPhysMask4 = 0x00002044, + WHvX64RegisterMsrMtrrPhysMask5 = 0x00002045, + WHvX64RegisterMsrMtrrPhysMask6 = 0x00002046, + WHvX64RegisterMsrMtrrPhysMask7 = 0x00002047, + WHvX64RegisterMsrMtrrPhysMask8 = 0x00002048, + WHvX64RegisterMsrMtrrPhysMask9 = 0x00002049, + WHvX64RegisterMsrMtrrPhysMaskA = 0x0000204A, + WHvX64RegisterMsrMtrrPhysMaskB = 0x0000204B, + WHvX64RegisterMsrMtrrPhysMaskC = 0x0000204C, + WHvX64RegisterMsrMtrrPhysMaskD = 0x0000204D, + WHvX64RegisterMsrMtrrPhysMaskE = 0x0000204E, + WHvX64RegisterMsrMtrrPhysMaskF = 0x0000204F, + WHvX64RegisterMsrMtrrFix64k00000 = 0x00002070, + WHvX64RegisterMsrMtrrFix16k80000 = 0x00002071, + WHvX64RegisterMsrMtrrFix16kA0000 = 0x00002072, + WHvX64RegisterMsrMtrrFix4kC0000 = 0x00002073, + WHvX64RegisterMsrMtrrFix4kC8000 = 0x00002074, + WHvX64RegisterMsrMtrrFix4kD0000 = 0x00002075, + WHvX64RegisterMsrMtrrFix4kD8000 = 0x00002076, + WHvX64RegisterMsrMtrrFix4kE0000 = 0x00002077, + WHvX64RegisterMsrMtrrFix4kE8000 = 0x00002078, + WHvX64RegisterMsrMtrrFix4kF0000 = 0x00002079, + WHvX64RegisterMsrMtrrFix4kF8000 = 0x0000207A, + WHvX64RegisterTscAux = 0x0000207B, + WHvX64RegisterBndcfgs = 0x0000207C, + WHvX64RegisterSpecCtrl = 0x00002084, + WHvX64RegisterPredCmd = 0x00002085, + WHvX64RegisterTscVirtualOffset = 0x00002087, + WHvX64RegisterApicId = 0x00003002, + WHvX64RegisterApicVersion = 0x00003003, + WHvRegisterPendingInterruption = 0x80000000, + WHvRegisterInterruptState = 0x80000001, + WHvRegisterPendingEvent = 0x80000002, + WHvX64RegisterDeliverabilityNotifications = 0x80000004, + WHvRegisterInternalActivityState = 0x80000005, + WHvX64RegisterPendingDebugException = 0x80000006, +}} +#[cfg(feature = "winhvplatformdefs")] +macro_rules! UINT128_DEF { + () => { + #[repr(C, align(16))] + #[derive(Copy, Clone, Debug)] + pub struct UINT128(pub [u64; 2]); + }; +} +#[cfg(not(feature = "winhvplatformdefs"))] +macro_rules! UINT128_DEF { + () => { + #[repr(C, align(BAD_ALIGN))] + #[derive(Copy, Clone, Debug)] + #[deprecated(note = "Struct just required to trick the compiler.")] + pub struct UINT128(pub [u64; 2]); + }; +} +UINT128_DEF!{} +impl UINT128{ + #[inline] + pub fn from_u128(x: u128)->Self{ + UINT128(unsafe{core::mem::transmute(x)}) + } + #[inline] + pub fn to_u128(self)->u128{ + unsafe{core::mem::transmute(self.0)} + } +} +STRUCT!{struct WHV_UINT128_s{ + Low64: UINT64, + High64: UINT64, +}} +UNION!{union WHV_UINT128{ + [UINT128; 1], + s s_mut: WHV_UINT128_s, + Dword Dword_mut: [UINT32; 4], +}} +// Dirty patches to make WHV_UINT128 work. +impl core::ops::Shl for UINT128{ + type Output = Self; + fn shl(self, rhs: usize) -> Self::Output { + Self::from_u128(self.to_u128() << rhs) + } +} +impl core::ops::Shr for UINT128{ + type Output = Self; + fn shr(self, rhs: usize) -> Self::Output { + Self::from_u128(self.to_u128() >> rhs) + } +} +impl core::ops::BitAnd for UINT128{ + type Output = Self; + fn bitand(self, rhs: u128) -> Self::Output { + Self::from_u128(self.to_u128() & rhs) + } +} +impl core::ops::BitOr for UINT128{ + type Output = Self; + fn bitor(self, rhs: u128) -> Self::Output { + Self::from_u128(self.to_u128() | rhs) + } +} +impl core::ops::BitOr for UINT128{ + type Output = Self; + fn bitor(self, rhs: UINT128) -> Self::Output { + Self::from_u128(self.to_u128() | rhs.to_u128()) + } +} +impl core::ops::Shl for WHV_UINT128{ + type Output = Self; + fn shl(self, rhs: usize) -> Self::Output { + WHV_UINT128([self.0[0]< for WHV_UINT128{ + type Output = Self; + fn shr(self, rhs: usize) -> Self::Output { + WHV_UINT128([self.0[0]>>rhs]) + } +} +impl core::ops::BitAnd for WHV_UINT128{ + type Output = Self; + fn bitand(self, rhs: u128) -> Self::Output { + WHV_UINT128([self.0[0] & rhs]) + } +} +impl core::ops::BitAndAssign for WHV_UINT128{ + fn bitand_assign(&mut self, rhs: u128) { + self.0[0] = self.0[0] & rhs; + } +} +impl core::ops::BitOr for WHV_UINT128{ + type Output = Self; + fn bitor(self, rhs: u128) -> Self::Output { + WHV_UINT128([self.0[0] | rhs]) + } +} +impl core::ops::BitOrAssign for WHV_UINT128{ + fn bitor_assign(&mut self, rhs: WHV_UINT128) { + self.0[0] = self.0[0] | rhs.0[0]; + } +} +STRUCT!{struct WHV_X64_FP_REGISTER{ + AsUINT128: WHV_UINT128, +}} +BITFIELD!{WHV_X64_FP_REGISTER AsUINT128: WHV_UINT128 [ + Mantissa set_Mantissa [0..64], + BiasedExponent set_BiasedExponent [64..79], + Sign set_Sign [79..80], + Reserved set_Reserved [80..128], +]} +STRUCT!{struct WHV_X64_FP_CONTROL_STATUS_REGISTER_s_u_s{ + LastFpEip: UINT32, + LastFpCs: UINT16, + Reserved2: UINT16, +}} +UNION!{union WHV_X64_FP_CONTROL_STATUS_REGISTER_s_u{ + [u64; 1], + LastFpRip LastFpRip_mut: UINT64, + s s_mut: WHV_X64_FP_CONTROL_STATUS_REGISTER_s_u_s, +}} +STRUCT!{struct WHV_X64_FP_CONTROL_STATUS_REGISTER_s{ + FpControl: UINT16, + FpStatus: UINT16, + FpTag: UINT8, + Reserved: UINT8, + LastFpOp: UINT16, + u: WHV_X64_FP_CONTROL_STATUS_REGISTER_s_u, +}} +UNION!{union WHV_X64_FP_CONTROL_STATUS_REGISTER { + [UINT128; 1], + s s_mut: WHV_X64_FP_CONTROL_STATUS_REGISTER_s, + AsUINT128 AsUINT128_mut: WHV_UINT128, +}} +STRUCT!{struct WHV_X64_XMM_CONTROL_STATUS_REGISTER_s_u_s{ + LastFpDp: UINT32, + LastFpDs: UINT16, + Reserved: UINT16, +}} +UNION!{union WHV_X64_XMM_CONTROL_STATUS_REGISTER_s_u{ + [u64; 1], + LastFpRdp LastFpRdp_mut: UINT64, + s s_mut: WHV_X64_XMM_CONTROL_STATUS_REGISTER_s_u_s, +}} +STRUCT!{struct WHV_X64_XMM_CONTROL_STATUS_REGISTER_s{ + u: WHV_X64_XMM_CONTROL_STATUS_REGISTER_s_u, + XmmStatusControl: UINT32, + XmmStatusControlMask: UINT32, +}} +UNION!{union WHV_X64_XMM_CONTROL_STATUS_REGISTER{ + [UINT128; 1], + s s_mut: WHV_X64_XMM_CONTROL_STATUS_REGISTER_s, + AsUINT128 AsUINT128_mut: WHV_UINT128, +}} +STRUCT!{struct WHV_X64_SEGMENT_REGISTER{ + Base: UINT64, + Limit: UINT32, + Selector: UINT16, + Attributes: UINT16, +}} +BITFIELD!{WHV_X64_SEGMENT_REGISTER Attributes: UINT16[ + SegmentType set_SegmentType [0..4], + NonSystemSegment set_NonSystemSegment [4..5], + DescriptorPrivilegeLevel set_DescriptorPrivilegeLevel [5..7], + Present set_Present [7..8], + Reserved set_Reserved [8..12], + Available set_Available [12..13], + Long set_Long [13..14], + Default set_Default [14..15], + Granularity set_Granularity [15..16], +]} +STRUCT!{struct WHV_X64_TABLE_REGISTER { + Pad: [UINT16; 3], + Limit: UINT16, + Base: UINT64, +}} +STRUCT!{struct WHV_X64_INTERRUPT_STATE_REGISTER{ + AsUINT64: UINT64, +}} +BITFIELD!{WHV_X64_INTERRUPT_STATE_REGISTER AsUINT64: UINT64[ + InterruptShadow set_InterruptShadow [0..1], + NmiMasked set_NmiMasked [1..2], + Reserved set_Reserved [2..64], +]} +STRUCT!{struct WHV_X64_PENDING_INTERRUPTION_REGISTER{ + AsUINT64: UINT64, +}} +BITFIELD!{WHV_X64_PENDING_INTERRUPTION_REGISTER AsUINT64: UINT64[ + InterruptionPending set_InterruptionPending [0..1], + InterruptionType set_InterruptionType [1..4], + DeliverErrorCode set_DeliverErrorCode [4..5], + InstructionLength set_InstructionLength [5..9], + NestedEvent set_NestedEvent [9..10], + Reserved set_Reserved [10..16], + InterruptionVector set_InterruptionVector [16..32], + ErrorCode set_ErrorCode [32..64], +]} +STRUCT!{struct WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER{ + AsUINT64: UINT64, +}} +BITFIELD!{WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER AsUINT64: UINT64[ + NmiNotification set_NmiNotification [0..1], + InterruptNotification set_InterruptNotification [1..2], + InterruptPriority set_InterruptPriority [2..6], + Reserved set_Reserved [6..64], +]} +ENUM!{enum WHV_X64_PENDING_EVENT_TYPE { + WHvX64PendingEventException = 0, + WHvX64PendingEventExtInt = 5, +}} +STRUCT!{struct WHV_X64_PENDING_EXCEPTION_EVENT{ + AsUINT128: WHV_UINT128, +}} +BITFIELD!{WHV_X64_PENDING_EXCEPTION_EVENT AsUINT128: WHV_UINT128[ + EventPending set_EventPending [0..1], + EventType set_EventType [1..4], + Reserved0 set_Reserved0 [4..8], + DeliverErrorCode set_DeliverErrorCode [8..9], + Reserved1 set_Reserved1 [9..16], + Vector set_Vector [16..32], + ErrorCode set_ErrorCode [32..64], + ExceptionParameter set_ExceptionParameter [64..128], +]} +STRUCT!{struct WHV_X64_PENDING_EXT_INT_EVENT{ + AsUINT128: WHV_UINT128, +}} +BITFIELD!{WHV_X64_PENDING_EXT_INT_EVENT AsUINT128: WHV_UINT128[ + EventPending set_EventPending [0..1], + EventType set_EventType [1..4], + Reserved0 set_Reserved0 [4..8], + Vector set_Vector [8..16], + Reserved1 set_Reserved1 [16..64], + Reserved2 set_Reserved2 [64..128], +]} +STRUCT!{struct WHV_INTERNAL_ACTIVITY_REGISTER{ + AsUINT64: UINT64, +}} +BITFIELD!{WHV_INTERNAL_ACTIVITY_REGISTER AsUINT64: UINT64[ + StartupSuspend set_StartupSuspend [0..1], + HaltSuspend set_HaltSuspend [1..2], + IdleSuspend set_IdleSuspend [2..3], + Reserved set_Reserved [3..64], +]} +STRUCT!{struct WHV_X64_PENDING_DEBUG_EXCEPTION{ + AsUINT64: UINT64, +}} +BITFIELD!{WHV_X64_PENDING_DEBUG_EXCEPTION AsUINT64: UINT64[ + Breakpoint0 set_Breakpoint0 [0..1], + Breakpoint1 set_Breakpoint1 [1..2], + Breakpoint2 set_Breakpoint2 [2..3], + Breakpoint3 set_Breakpoint3 [3..4], + SingleStep set_SingleStep [4..5], + Reserved0 set_Reserved0 [5..64], +]} +UNION!{union WHV_REGISTER_VALUE { + [UINT128; 1], + Reg128 Reg128_mut: WHV_UINT128, + Reg64 Reg64_mut: UINT64, + Reg32 Reg32_mut: UINT32, + Reg16 Reg16_mut: UINT16, + Reg8 Reg8_mut: UINT8, + Fp Fp_mut: WHV_X64_FP_REGISTER, + FpControlStatus FpControlStatus_mut: WHV_X64_FP_CONTROL_STATUS_REGISTER, + XmmControlStatus XmmControlStatus_mut: WHV_X64_XMM_CONTROL_STATUS_REGISTER, + Segment Segment_mut: WHV_X64_SEGMENT_REGISTER, + Table Table_mut: WHV_X64_TABLE_REGISTER, + InterruptState InterruptState_mut: WHV_X64_INTERRUPT_STATE_REGISTER, + DeliverabilityNotifications DeliverabilityNotifications_mut: + WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER, + ExceptionEvent ExceptionEvent_mut: WHV_X64_PENDING_EXCEPTION_EVENT, + ExtIntEvent ExtIntEvent_mut: WHV_X64_PENDING_EXT_INT_EVENT, + InternalActivity InternalActivity_mut: WHV_INTERNAL_ACTIVITY_REGISTER, + PendingDebugException PendingDebugException_mut: WHV_X64_PENDING_DEBUG_EXCEPTION, +}} +ENUM!{enum WHV_RUN_VP_EXIT_REASON { + WHvRunVpExitReasonNone = 0x00000000, + WHvRunVpExitReasonMemoryAccess = 0x00000001, + WHvRunVpExitReasonX64IoPortAccess = 0x00000002, + WHvRunVpExitReasonUnrecoverableException = 0x00000004, + WHvRunVpExitReasonInvalidVpRegisterValue = 0x00000005, + WHvRunVpExitReasonUnsupportedFeature = 0x00000006, + WHvRunVpExitReasonX64InterruptWindow = 0x00000007, + WHvRunVpExitReasonX64Halt = 0x00000008, + WHvRunVpExitReasonX64ApicEoi = 0x00000009, + WHvRunVpExitReasonX64MsrAccess = 0x00001000, + WHvRunVpExitReasonX64Cpuid = 0x00001001, + WHvRunVpExitReasonException = 0x00001002, + WHvRunVpExitReasonX64Rdtsc = 0x00001003, + WHvRunVpExitReasonX64ApicSmiTrap = 0x00001004, + WHvRunVpExitReasonHypercall = 0x00001005, + WHvRunVpExitReasonX64ApicInitSipiTrap = 0x00001006, + WHvRunVpExitReasonX64ApicWriteTrap = 0x00001007, + WHvRunVpExitReasonCanceled = 0x00002001, +}} +STRUCT!{struct WHV_X64_VP_EXECUTION_STATE{ + AsUINT16: UINT16, +}} +BITFIELD!{WHV_X64_VP_EXECUTION_STATE AsUINT16: UINT16[ + Cpl set_Cpl [0..2], + Cr0Pe set_Cr0Pe [2..3], + Cr0Am set_Cr0Am [3..4], + EferLma set_EferLma [4..5], + DebugActive set_DebugActive [5..6], + InterruptionPending set_InterruptionPending [6..7], + Reserved0 set_Reserved0 [7..12], + InterruptShadow set_InterruptShadow [12..13], + Reserved1 set_Reserved1 [13..16], +]} +STRUCT!{struct WHV_VP_EXIT_CONTEXT { + ExecutionState: WHV_X64_VP_EXECUTION_STATE, + InstructionLengthAndCr8: UINT8, // TODO: What if bitfields appear in a struct? + Reserved: UINT8, + Reserved2: UINT32, + Cs: WHV_X64_SEGMENT_REGISTER, + Rip: UINT64, + Rflags: UINT64, +}} +BITFIELD!{WHV_VP_EXIT_CONTEXT InstructionLengthAndCr8: UINT8[ + InstructionLength set_InstructionLength [0..3], + Cr8 set_Cr8 [4..7], +]} +ENUM!{enum WHV_MEMORY_ACCESS_TYPE { + WHvMemoryAccessRead = 0, + WHvMemoryAccessWrite = 1, + WHvMemoryAccessExecute = 2, +}} +STRUCT!{struct WHV_MEMORY_ACCESS_INFO{ + AsUINT32: UINT32, +}} +BITFIELD!{WHV_MEMORY_ACCESS_INFO AsUINT32: UINT32[ + AccessType set_AccessType [0..2], + GpaUnmapped set_GpaUnmapped [2..3], + GvaValid set_GvaValid [3..4], + Reserved set_Reserved [4..32], +]} +STRUCT!{struct WHV_MEMORY_ACCESS_CONTEXT { + InstructionByteCount: UINT8, + Reserved: [UINT8; 3], + InstructionBytes: [UINT8; 16], + AccessInfo: WHV_MEMORY_ACCESS_INFO, + Gpa: WHV_GUEST_PHYSICAL_ADDRESS, + Gva: WHV_GUEST_VIRTUAL_ADDRESS, +}} +STRUCT!{struct WHV_X64_IO_PORT_ACCESS_INFO{ + AsUINT32: UINT32, +}} +BITFIELD!{WHV_X64_IO_PORT_ACCESS_INFO AsUINT32: UINT32[ + IsWrite set_IsWrite [0..1], + AccessSize set_AccessSize [1..4], + StringOp set_StringOp [4..5], + RepPrefix set_RepPrefix [5..6], + Reserved set_Reserved [6..32], +]} +STRUCT!{struct WHV_X64_IO_PORT_ACCESS_CONTEXT { + InstructionByteCount: UINT8, + Reserved: [UINT8; 3], + InstructionBytes: [UINT8; 16], + AccessInfo: WHV_X64_IO_PORT_ACCESS_INFO, + PortNumber: UINT16, + Reserved2: [UINT16; 3], + Rax: UINT64, + Rcx: UINT64, + Rsi: UINT64, + Rdi: UINT64, + Ds: WHV_X64_SEGMENT_REGISTER, + Es: WHV_X64_SEGMENT_REGISTER, +}} +STRUCT!{struct WHV_X64_MSR_ACCESS_INFO{ + AsUINT32: UINT32, +}} +BITFIELD!{WHV_X64_MSR_ACCESS_INFO AsUINT32: UINT32[ + IsWrite set_IsWrite [0..1], + Reserved set_Reserved [1..32], +]} +STRUCT!{struct WHV_X64_MSR_ACCESS_CONTEXT { + AccessInfo: WHV_X64_MSR_ACCESS_INFO, + MsrNumber: UINT32, + Rax: UINT64, + Rdx: UINT64, +}} +STRUCT!{struct WHV_X64_CPUID_ACCESS_CONTEXT { + Rax: UINT64, + Rcx: UINT64, + Rdx: UINT64, + Rbx: UINT64, + DefaultResultRax: UINT64, + DefaultResultRcx: UINT64, + DefaultResultRdx: UINT64, + DefaultResultRbx: UINT64, +}} +STRUCT!{struct WHV_VP_EXCEPTION_INFO{ + AsUINT32: UINT32, +}} +BITFIELD!{WHV_VP_EXCEPTION_INFO AsUINT32: UINT32[ + ErrorCodeValid set_ErrorCodeValid [0..1], + SoftwareException set_SoftwareException [1..2], + Reserved set_Reserved [2..32], +]} +STRUCT!{struct WHV_VP_EXCEPTION_CONTEXT { + InstructionByteCount: UINT8, + Reserved: [UINT8; 3], + InstructionBytes: [UINT8; 16], + ExceptionInfo: WHV_VP_EXCEPTION_INFO, + ExceptionType: UINT8, + Reserved2: [UINT8; 3], + ErrorCode: UINT32, + ExceptionParameter: UINT64, +}} +ENUM!{enum WHV_X64_UNSUPPORTED_FEATURE_CODE { + WHvUnsupportedFeatureIntercept = 1, + WHvUnsupportedFeatureTaskSwitchTss = 2, +}} +STRUCT!{struct WHV_X64_UNSUPPORTED_FEATURE_CONTEXT { + FeatureCode: WHV_X64_UNSUPPORTED_FEATURE_CODE, + Reserved: UINT32, + FeatureParameter: UINT64, +}} +ENUM!{enum WHV_RUN_VP_CANCEL_REASON { + WHvRunVpCancelReasonUser = 0, +}} +pub const WhvRunVpCancelReasonUser: WHV_RUN_VP_CANCEL_REASON = WHvRunVpCancelReasonUser; +STRUCT!{struct WHV_RUN_VP_CANCELED_CONTEXT { + CancelReason: WHV_RUN_VP_CANCEL_REASON, +}} +ENUM!{enum WHV_X64_PENDING_INTERRUPTION_TYPE { + WHvX64PendingInterrupt = 0, + WHvX64PendingNmi = 2, + WHvX64PendingException = 3, +}} +pub type PWHV_X64_PENDING_INTERRUPTION_TYPE = *mut WHV_X64_PENDING_INTERRUPTION_TYPE; +STRUCT!{struct WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT { + DeliverableType: WHV_X64_PENDING_INTERRUPTION_TYPE, +}} +pub type PWHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT = *mut WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT; +STRUCT!{struct WHV_X64_APIC_EOI_CONTEXT { + InterruptVector: UINT32, +}} +STRUCT!{struct WHV_X64_RDTSC_INFO{ + AsUINT64: UINT64, +}} +BITFIELD!{WHV_X64_RDTSC_INFO AsUINT64: UINT64[ + IsRdtscp set_IsRdtscp [0..1], + Reserved set_Reserved [1..64], +]} +STRUCT!{struct WHV_X64_RDTSC_CONTEXT{ + TscAux: UINT64, + VirtualOffset: UINT64, + Tsc: UINT64, + ReferenceTime: UINT64, + RdtscInfo: WHV_X64_RDTSC_INFO, +}} +STRUCT!{struct WHV_X64_APIC_SMI_CONTEXT{ + ApicIcr: UINT64, +}} +pub const WHV_HYPERCALL_CONTEXT_MAX_XMM_REGISTERS: usize = 6; +STRUCT!{struct WHV_HYPERCALL_CONTEXT{ + Rax: UINT64, + Rbx: UINT64, + Rcx: UINT64, + Rdx: UINT64, + R8: UINT64, + Rsi: UINT64, + Rdi: UINT64, + Reserved0: UINT64, + XmmRegisters: [WHV_UINT128; WHV_HYPERCALL_CONTEXT_MAX_XMM_REGISTERS], + Reserved1: [UINT64; 2], +}} +pub type PWHV_HYPERCALL_CONTEXT = *mut WHV_HYPERCALL_CONTEXT; +STRUCT!{struct WHV_X64_APIC_INIT_SIPI_CONTEXT{ + ApicIcr: UINT64, +}} +ENUM!{enum WHV_X64_APIC_WRITE_TYPE{ + WHvX64ApicWriteTypeSvr = 0xF0, + WHvX64ApicWriteTypeLint0 = 0x350, + WHvX64ApicWriteTypeLint1 = 0x360, +}} +STRUCT!{struct WHV_X64_APIC_WRITE_CONTEXT{ + Type: WHV_X64_APIC_WRITE_TYPE, + Reserved: UINT32, + WriteValue: UINT64, +}} +UNION!{union WHV_RUN_VP_EXIT_CONTEXT_u{ + [WHV_UINT128; 11], + MemoryAccess MemoryAccess_mut: WHV_MEMORY_ACCESS_CONTEXT, + IoPortAccess IoPortAccess_mut: WHV_X64_IO_PORT_ACCESS_CONTEXT, + MsrAccess MsrAccess_mut: WHV_X64_MSR_ACCESS_CONTEXT, + CpuidAccess CpuidAccess_mut: WHV_X64_CPUID_ACCESS_CONTEXT, + VpException VpException_mut: WHV_VP_EXCEPTION_CONTEXT, + InterruptWindow InterruptWindow_mut: WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT, + UnsupportedFeature UnsupportedFeature_mut: WHV_X64_UNSUPPORTED_FEATURE_CONTEXT, + CancelReason CancelReason_mut: WHV_RUN_VP_CANCELED_CONTEXT, + ApicEoi ApicEoi_mut: WHV_X64_APIC_EOI_CONTEXT, + ReadTsc ReadTsc_mut: WHV_X64_RDTSC_CONTEXT, + ApicSmi ApicSmi_mut: WHV_X64_APIC_SMI_CONTEXT, + Hypercall Hypercall_mut: WHV_HYPERCALL_CONTEXT, + ApicInitSipi ApicInitSipi_mut: WHV_X64_APIC_INIT_SIPI_CONTEXT, + ApicWrite ApicWrite_mut: WHV_X64_APIC_WRITE_CONTEXT, +}} +STRUCT!{struct WHV_RUN_VP_EXIT_CONTEXT{ + ExitReason: WHV_RUN_VP_EXIT_REASON, + Reserved: UINT32, + VpContext: WHV_VP_EXIT_CONTEXT, + u: WHV_RUN_VP_EXIT_CONTEXT_u, +}} +ENUM!{enum WHV_INTERRUPT_TYPE { + WHvX64InterruptTypeFixed = 0, + WHvX64InterruptTypeLowestPriority = 1, + WHvX64InterruptTypeNmi = 4, + WHvX64InterruptTypeInit = 5, + WHvX64InterruptTypeSipi = 6, + WHvX64InterruptTypeLocalInt1 = 9, +}} +ENUM!{enum WHV_INTERRUPT_DESTINATION_MODE { + WHvX64InterruptDestinationModePhysical, + WHvX64InterruptDestinationModeLogical, +}} +ENUM!{enum WHV_INTERRUPT_TRIGGER_MODE { + WHvX64InterruptTriggerModeEdge, + WHvX64InterruptTriggerModeLevel, +}} +STRUCT!{struct WHV_INTERRUPT_CONTROL{ + TypeAndDestinationModeAndTriggerModeAndReserved: UINT64, + Destination: UINT32, + Vector: UINT32, +}} +BITFIELD!{WHV_INTERRUPT_CONTROL TypeAndDestinationModeAndTriggerModeAndReserved: UINT64[ + Type set_Type [0..8], + DestinationMode set_DestinationMode [8..12], + TriggerMode set_TriggerMode [12..16], + Reserved set_Reserved [16..64], +]} +STRUCT!{struct WHV_DOORBELL_MATCH_DATA{ + GuestAddress: WHV_GUEST_PHYSICAL_ADDRESS, + Value: UINT32, + Length: UINT32, + MatchOnValueAndMatchOnLengthAndReserved: UINT32, +}} +BITFIELD!{WHV_DOORBELL_MATCH_DATA MatchOnValueAndMatchOnLengthAndReserved: UINT32[ + MatchOnValue set_MatchOnValue [0..1], + MatchOnLength set_MatchOnLength [1..2], + Reserved set_Reserved [2..32], +]} +ENUM!{enum WHV_PARTITION_COUNTER_SET { + WHvPartitionCounterSetMemory, +}} +STRUCT!{struct WHV_PARTITION_MEMORY_COUNTERS { + Mapped4KPageCount: UINT64, + Mapped2MPageCount: UINT64, + Mapped1GPageCount: UINT64, +}} +ENUM!{enum WHV_PROCESSOR_COUNTER_SET { + WHvProcessorCounterSetRuntime, + WHvProcessorCounterSetIntercepts, + WHvProcessorCounterSetEvents, + WHvProcessorCounterSetApic, +}} +STRUCT!{struct WHV_PROCESSOR_RUNTIME_COUNTERS { + TotalRuntime100ns: UINT64, + HypervisorRuntime100ns: UINT64, +}} +STRUCT!{struct WHV_PROCESSOR_INTERCEPT_COUNTER { + Count: UINT64, + Time100ns: UINT64, +}} +STRUCT!{struct WHV_PROCESSOR_INTERCEPT_COUNTERS { + PageInvalidations: WHV_PROCESSOR_INTERCEPT_COUNTER, + ControlRegisterAccesses: WHV_PROCESSOR_INTERCEPT_COUNTER, + IoInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER, + HaltInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER, + CpuidInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER, + MsrAccesses: WHV_PROCESSOR_INTERCEPT_COUNTER, + OtherIntercepts: WHV_PROCESSOR_INTERCEPT_COUNTER, + PendingInterrupts: WHV_PROCESSOR_INTERCEPT_COUNTER, + EmulatedInstructions: WHV_PROCESSOR_INTERCEPT_COUNTER, + DebugRegisterAccesses: WHV_PROCESSOR_INTERCEPT_COUNTER, + PageFaultIntercepts: WHV_PROCESSOR_INTERCEPT_COUNTER, +}} +STRUCT!{struct WHV_PROCESSOR_EVENT_COUNTERS { + PageFaultCount: UINT64, + ExceptionCount: UINT64, + InterruptCount: UINT64, +}} +STRUCT!{struct WHV_PROCESSOR_APIC_COUNTERS { + MmioAccessCount: UINT64, + EoiAccessCount: UINT64, + TprAccessCount: UINT64, + SentIpiCount: UINT64, + SelfIpiCount: UINT64, +}} diff --git a/tests/structs_x86_64.rs b/tests/structs_x86_64.rs index f267b2855..e310854e6 100644 --- a/tests/structs_x86_64.rs +++ b/tests/structs_x86_64.rs @@ -7935,6 +7935,162 @@ fn um_winhttp() { assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); } +#[cfg(feature = "winhvplatformdefs")] #[test] +fn um_winhvplatformdefs() { + use winapi::um::winhvplatformdefs::*; + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 32); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 2); + assert_eq!(align_of::(), 2); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 96); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 64); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 8); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 224); + assert_eq!(align_of::(), 16); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 4); + assert_eq!(align_of::(), 4); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 16); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 176); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 24); + assert_eq!(align_of::(), 8); + assert_eq!(size_of::(), 40); + assert_eq!(align_of::(), 8); +} #[cfg(feature = "wininet")] #[test] fn um_wininet() { use winapi::um::wininet::*;