From 4d829b31e9fdb50b2e62ccb2e65b9d5127b6e301 Mon Sep 17 00:00:00 2001 From: Biswapriyo Nath <[email protected]> Date: Sun, 8 Aug 2021 23:32:08 +0530 Subject: [PATCH 1/4] headers: Update existing enums and unions in winhvplatformdefs.h
Signed-off-by: Biswapriyo Nath <[email protected]> --- mingw-w64-headers/include/winhvplatformdefs.h | 235 +++++++++++++++++- 1 file changed, 224 insertions(+), 11 deletions(-) diff --git a/mingw-w64-headers/include/winhvplatformdefs.h b/mingw-w64-headers/include/winhvplatformdefs.h index 2b62e7e..0f66c73 100644 --- a/mingw-w64-headers/include/winhvplatformdefs.h +++ b/mingw-w64-headers/include/winhvplatformdefs.h @@ -12,13 +12,18 @@ typedef enum WHV_CAPABILITY_CODE { WHvCapabilityCodeExtendedVmExits = 0x00000002, WHvCapabilityCodeExceptionExitBitmap = 0x00000003, WHvCapabilityCodeX64MsrExitBitmap = 0x00000004, + WHvCapabilityCodeGpaRangePopulateFlags = 0x00000005, + WHvCapabilityCodeSchedulerFeatures = 0x00000006, WHvCapabilityCodeProcessorVendor = 0x00001000, WHvCapabilityCodeProcessorFeatures = 0x00001001, WHvCapabilityCodeProcessorClFlushSize = 0x00001002, WHvCapabilityCodeProcessorXsaveFeatures = 0x00001003, WHvCapabilityCodeProcessorClockFrequency = 0x00001004, WHvCapabilityCodeInterruptClockFrequency = 0x00001005, - WHvCapabilityCodeProcessorFeaturesBanks = 0x00001006 + WHvCapabilityCodeProcessorFeaturesBanks = 0x00001006, + WHvCapabilityCodeProcessorFrequencyCap = 0x00001007, + WHvCapabilityCodeSyntheticProcessorFeaturesBanks = 0x00001008, + WHvCapabilityCodeProcessorPerfmonFeatures = 0x00001009 } WHV_CAPABILITY_CODE; typedef union WHV_CAPABILITY_FEATURES { @@ -30,7 +35,10 @@ typedef union WHV_CAPABILITY_FEATURES { UINT64 SpeculationControl : 1; UINT64 ApicRemoteRead : 1; UINT64 IdleSuspend : 1; - UINT64 Reserved : 57; + UINT64 VirtualPciDeviceSupport : 1; + UINT64 IommuSupport : 1; + UINT64 VpHotAddRemove : 1; + UINT64 Reserved : 54; }; UINT64 AsUINT64; } WHV_CAPABILITY_FEATURES; @@ -46,7 +54,15 @@ typedef union WHV_EXTENDED_VM_EXITS { UINT64 X64ApicSmiExitTrap : 1; UINT64 HypercallExit : 1; UINT64 X64ApicInitSipiExitTrap : 1; - UINT64 Reserved : 57; + UINT64 X64ApicWriteLint0ExitTrap : 1; + UINT64 X64ApicWriteLint1ExitTrap : 1; + UINT64 X64ApicWriteSvrExitTrap : 1; + UINT64 UnknownSynicConnection : 1; + UINT64 RetargetUnknownVpciDevice : 1; + UINT64 X64ApicWriteLdrExitTrap : 1; + UINT64 X64ApicWriteDfrExitTrap : 1; + UINT64 GpaAccessFaultExit : 1; + UINT64 Reserved : 49; }; UINT64 AsUINT64; } WHV_EXTENDED_VM_EXITS; @@ -121,7 +137,9 @@ typedef union WHV_PROCESSOR_FEATURES { UINT64 UmipSupport : 1; UINT64 MdsNoSupport : 1; UINT64 MdClearSupport : 1; - UINT64 Reserved6 : 3; + UINT64 TaaNoSupport : 1; + UINT64 TsxCtrlSupport : 1; + UINT64 Reserved6 : 1; }; UINT64 AsUINT64; } WHV_PROCESSOR_FEATURES; @@ -130,9 +148,28 @@ C_ASSERT(sizeof(WHV_PROCESSOR_FEATURES) == sizeof(UINT64)); typedef union WHV_PROCESSOR_FEATURES1 { __C89_NAMELESS struct { - UINT64 Reserved1 : 2; + UINT64 ACountMCountSupport : 1; + UINT64 TscInvariantSupport : 1; UINT64 ClZeroSupport : 1; - UINT64 Reserved2 : 61; + UINT64 RdpruSupport : 1; + UINT64 Reserved2 : 2; + UINT64 NestedVirtSupport : 1; + UINT64 PsfdSupport: 1; + UINT64 CetSsSupport : 1; + UINT64 CetIbtSupport : 1; + UINT64 VmxExceptionInjectSupport : 1; + UINT64 Reserved4 : 1; + UINT64 UmwaitTpauseSupport : 1; + UINT64 MovdiriSupport : 1; + UINT64 Movdir64bSupport : 1; + UINT64 CldemoteSupport : 1; + UINT64 SerializeSupport : 1; + UINT64 TscDeadlineTmrSupport : 1; + UINT64 TscAdjustSupport : 1; + UINT64 FZLRepMovsb : 1; + UINT64 FSRepStosb : 1; + UINT64 FSRepCmpsb : 1; + UINT64 Reserved5 : 42; }; UINT64 AsUINT64; } WHV_PROCESSOR_FEATURES1; @@ -182,7 +219,13 @@ typedef union _WHV_PROCESSOR_XSAVE_FEATURES { UINT64 VpclmulqdqSupport : 1; UINT64 Avx512Bf16Support : 1; UINT64 Avx512Vp2IntersectSupport : 1; - UINT64 Reserved : 39; + UINT64 Avx512Fp16Support : 1; + UINT64 XfdSupport : 1; + UINT64 AmxTileSupport : 1; + UINT64 AmxBf16Support : 1; + UINT64 AmxInt8Support : 1; + UINT64 AvxVnniSupport : 1; + UINT64 Reserved : 33; }; UINT64 AsUINT64; } WHV_PROCESSOR_XSAVE_FEATURES, *PWHV_PROCESSOR_XSAVE_FEATURES; @@ -196,7 +239,9 @@ typedef union WHV_X64_MSR_EXIT_BITMAP { UINT64 TscMsrWrite : 1; UINT64 TscMsrRead : 1; UINT64 ApicBaseMsrWrite : 1; - UINT64 Reserved : 60; + UINT64 MiscEnableMsrRead:1; + UINT64 McUpdatePatchLevelMsrRead:1; + UINT64 Reserved:58; }; } WHV_X64_MSR_EXIT_BITMAP; @@ -225,6 +270,14 @@ typedef enum WHV_PARTITION_PROPERTY_CODE { WHvPartitionPropertyCodeSeparateSecurityDomain = 0x00000003, WHvPartitionPropertyCodeNestedVirtualization = 0x00000004, WHvPartitionPropertyCodeX64MsrExitBitmap = 0x00000005, + WHvPartitionPropertyCodePrimaryNumaNode = 0x00000006, + WHvPartitionPropertyCodeCpuReserve = 0x00000007, + WHvPartitionPropertyCodeCpuCap = 0x00000008, + WHvPartitionPropertyCodeCpuWeight = 0x00000009, + WHvPartitionPropertyCodeCpuGroupId = 0x0000000A, + WHvPartitionPropertyCodeProcessorFrequencyCap = 0x0000000B, + WHvPartitionPropertyCodeAllowDeviceAssignment = 0x0000000C, + WHvPartitionPropertyCodeDisableSmt = 0x0000000D, WHvPartitionPropertyCodeProcessorFeatures = 0x00001001, WHvPartitionPropertyCodeProcessorClFlushSize = 0x00001002, WHvPartitionPropertyCodeCpuidExitList = 0x00001003, @@ -236,6 +289,11 @@ typedef enum WHV_PARTITION_PROPERTY_CODE { WHvPartitionPropertyCodeApicRemoteReadSupport = 0x00001009, WHvPartitionPropertyCodeProcessorFeaturesBanks = 0x0000100A, WHvPartitionPropertyCodeReferenceTime = 0x0000100B, + WHvPartitionPropertyCodeSyntheticProcessorFeaturesBanks = 0x0000100C, + WHvPartitionPropertyCodeCpuidResultList2 = 0x0000100D, + WHvPartitionPropertyCodeProcessorPerfmonFeatures = 0x0000100E, + WHvPartitionPropertyCodeMsrActionList = 0x0000100F, + WHvPartitionPropertyCodeUnimplementedMsrAction = 0x00001010, WHvPartitionPropertyCodeProcessorCount = 0x00001fff } WHV_PARTITION_PROPERTY_CODE; @@ -313,7 +371,9 @@ typedef enum WHV_TRANSLATE_GVA_FLAGS { WHvTranslateGvaFlagValidateWrite = 0x00000002, WHvTranslateGvaFlagValidateExecute = 0x00000004, WHvTranslateGvaFlagPrivilegeExempt = 0x00000008, - WHvTranslateGvaFlagSetPageTableBits = 0x00000010 + WHvTranslateGvaFlagSetPageTableBits = 0x00000010, + WHvTranslateGvaFlagEnforceSmap = 0x00000100, + WHvTranslateGvaFlagOverrideSmap = 0x00000200 } WHV_TRANSLATE_GVA_FLAGS; DEFINE_ENUM_FLAG_OPERATORS(WHV_TRANSLATE_GVA_FLAGS); @@ -376,6 +436,10 @@ typedef enum WHV_REGISTER_NAME { WHvX64RegisterDr6 = 0x00000025, WHvX64RegisterDr7 = 0x00000026, WHvX64RegisterXCr0 = 0x00000027, + WHvX64RegisterVirtualCr0 = 0x00000028, + WHvX64RegisterVirtualCr3 = 0x00000029, + WHvX64RegisterVirtualCr4 = 0x0000002A, + WHvX64RegisterVirtualCr8 = 0x0000002B, WHvX64RegisterXmm0 = 0x00001000, WHvX64RegisterXmm1 = 0x00001001, WHvX64RegisterXmm2 = 0x00001002, @@ -461,11 +525,97 @@ typedef enum WHV_REGISTER_NAME { WHvX64RegisterMsrMtrrFix4kF0000 = 0x00002079, WHvX64RegisterMsrMtrrFix4kF8000 = 0x0000207A, WHvX64RegisterTscAux = 0x0000207B, + WHvX64RegisterBndcfgs = 0x0000207C, + WHvX64RegisterMCount = 0x0000207E, + WHvX64RegisterACount = 0x0000207F, WHvX64RegisterSpecCtrl = 0x00002084, WHvX64RegisterPredCmd = 0x00002085, WHvX64RegisterTscVirtualOffset = 0x00002087, + WHvX64RegisterTsxCtrl = 0x00002088, + WHvX64RegisterXss = 0x0000208B, + WHvX64RegisterUCet = 0x0000208C, + WHvX64RegisterSCet = 0x0000208D, + WHvX64RegisterSsp = 0x0000208E, + WHvX64RegisterPl0Ssp = 0x0000208F, + WHvX64RegisterPl1Ssp = 0x00002090, + WHvX64RegisterPl2Ssp = 0x00002091, + WHvX64RegisterPl3Ssp = 0x00002092, + WHvX64RegisterInterruptSspTableAddr = 0x00002093, + WHvX64RegisterTscDeadline = 0x00002095, + WHvX64RegisterTscAdjust = 0x00002096, + WHvX64RegisterUmwaitControl = 0x00002098, + WHvX64RegisterXfd = 0x00002099, + WHvX64RegisterXfdErr = 0x0000209A, WHvX64RegisterApicId = 0x00003002, WHvX64RegisterApicVersion = 0x00003003, + WHvX64RegisterApicTpr = 0x00003008, + WHvX64RegisterApicPpr = 0x0000300A, + WHvX64RegisterApicEoi = 0x0000300B, + WHvX64RegisterApicLdr = 0x0000300D, + WHvX64RegisterApicSpurious = 0x0000300F, + WHvX64RegisterApicIsr0 = 0x00003010, + WHvX64RegisterApicIsr1 = 0x00003011, + WHvX64RegisterApicIsr2 = 0x00003012, + WHvX64RegisterApicIsr3 = 0x00003013, + WHvX64RegisterApicIsr4 = 0x00003014, + WHvX64RegisterApicIsr5 = 0x00003015, + WHvX64RegisterApicIsr6 = 0x00003016, + WHvX64RegisterApicIsr7 = 0x00003017, + WHvX64RegisterApicTmr0 = 0x00003018, + WHvX64RegisterApicTmr1 = 0x00003019, + WHvX64RegisterApicTmr2 = 0x0000301A, + WHvX64RegisterApicTmr3 = 0x0000301B, + WHvX64RegisterApicTmr4 = 0x0000301C, + WHvX64RegisterApicTmr5 = 0x0000301D, + WHvX64RegisterApicTmr6 = 0x0000301E, + WHvX64RegisterApicTmr7 = 0x0000301F, + WHvX64RegisterApicIrr0 = 0x00003020, + WHvX64RegisterApicIrr1 = 0x00003021, + WHvX64RegisterApicIrr2 = 0x00003022, + WHvX64RegisterApicIrr3 = 0x00003023, + WHvX64RegisterApicIrr4 = 0x00003024, + WHvX64RegisterApicIrr5 = 0x00003025, + WHvX64RegisterApicIrr6 = 0x00003026, + WHvX64RegisterApicIrr7 = 0x00003027, + WHvX64RegisterApicEse = 0x00003028, + WHvX64RegisterApicIcr = 0x00003030, + WHvX64RegisterApicLvtTimer = 0x00003032, + WHvX64RegisterApicLvtThermal = 0x00003033, + WHvX64RegisterApicLvtPerfmon = 0x00003034, + WHvX64RegisterApicLvtLint0 = 0x00003035, + WHvX64RegisterApicLvtLint1 = 0x00003036, + WHvX64RegisterApicLvtError = 0x00003037, + WHvX64RegisterApicInitCount = 0x00003038, + WHvX64RegisterApicCurrentCount = 0x00003039, + WHvX64RegisterApicDivide = 0x0000303E, + WHvX64RegisterApicSelfIpi = 0x0000303F, + WHvRegisterSint0 = 0x00004000, + WHvRegisterSint1 = 0x00004001, + WHvRegisterSint2 = 0x00004002, + WHvRegisterSint3 = 0x00004003, + WHvRegisterSint4 = 0x00004004, + WHvRegisterSint5 = 0x00004005, + WHvRegisterSint6 = 0x00004006, + WHvRegisterSint7 = 0x00004007, + WHvRegisterSint8 = 0x00004008, + WHvRegisterSint9 = 0x00004009, + WHvRegisterSint10 = 0x0000400A, + WHvRegisterSint11 = 0x0000400B, + WHvRegisterSint12 = 0x0000400C, + WHvRegisterSint13 = 0x0000400D, + WHvRegisterSint14 = 0x0000400E, + WHvRegisterSint15 = 0x0000400F, + WHvRegisterScontrol = 0x00004010, + WHvRegisterSversion = 0x00004011, + WHvRegisterSiefp = 0x00004012, + WHvRegisterSimp = 0x00004013, + WHvRegisterEom = 0x00004014, + WHvRegisterVpRuntime = 0x00005000, + WHvX64RegisterHypercall = 0x00005001, + WHvRegisterGuestOsId = 0x00005002, + WHvRegisterVpAssistPage = 0x00005013, + WHvRegisterReferenceTsc = 0x00005017, + WHvRegisterReferenceTscSequence = 0x0000501A, WHvRegisterPendingInterruption = 0x80000000, WHvRegisterInterruptState = 0x80000001, WHvRegisterPendingEvent = 0x80000002, @@ -482,6 +632,8 @@ typedef union DECLSPEC_ALIGN(16) WHV_UINT128 { UINT32 Dword[4]; } WHV_UINT128; +C_ASSERT(sizeof(WHV_UINT128) == 16); + typedef union WHV_X64_FP_REGISTER { __C89_NAMELESS struct { UINT64 Mantissa; @@ -492,6 +644,8 @@ typedef union WHV_X64_FP_REGISTER { WHV_UINT128 AsUINT128; } WHV_X64_FP_REGISTER; +C_ASSERT(sizeof(WHV_X64_FP_REGISTER) == 16); + typedef union WHV_X64_FP_CONTROL_STATUS_REGISTER { __C89_NAMELESS struct { UINT16 FpControl; @@ -511,6 +665,8 @@ typedef union WHV_X64_FP_CONTROL_STATUS_REGISTER { WHV_UINT128 AsUINT128; } WHV_X64_FP_CONTROL_STATUS_REGISTER; +C_ASSERT(sizeof(WHV_X64_FP_CONTROL_STATUS_REGISTER) == 16); + typedef union WHV_X64_XMM_CONTROL_STATUS_REGISTER { __C89_NAMELESS struct { __C89_NAMELESS union { @@ -527,6 +683,8 @@ typedef union WHV_X64_XMM_CONTROL_STATUS_REGISTER { WHV_UINT128 AsUINT128; } WHV_X64_XMM_CONTROL_STATUS_REGISTER; +C_ASSERT(sizeof(WHV_X64_FP_CONTROL_STATUS_REGISTER) == 16); + typedef struct WHV_X64_SEGMENT_REGISTER { UINT64 Base; UINT32 Limit; @@ -547,12 +705,16 @@ typedef struct WHV_X64_SEGMENT_REGISTER { }; } WHV_X64_SEGMENT_REGISTER; +C_ASSERT(sizeof(WHV_X64_SEGMENT_REGISTER) == 16); + typedef struct WHV_X64_TABLE_REGISTER { UINT16 Pad[3]; UINT16 Limit; UINT64 Base; } WHV_X64_TABLE_REGISTER; +C_ASSERT(sizeof(WHV_X64_TABLE_REGISTER) == 16); + typedef union WHV_X64_INTERRUPT_STATE_REGISTER { __C89_NAMELESS struct { UINT64 InterruptShadow:1; @@ -562,6 +724,8 @@ typedef union WHV_X64_INTERRUPT_STATE_REGISTER { UINT64 AsUINT64; } WHV_X64_INTERRUPT_STATE_REGISTER; +C_ASSERT(sizeof(WHV_X64_INTERRUPT_STATE_REGISTER) == 8); + typedef union WHV_X64_PENDING_INTERRUPTION_REGISTER { __C89_NAMELESS struct { UINT32 InterruptionPending:1; @@ -590,7 +754,6 @@ typedef union WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER { C_ASSERT(sizeof(WHV_X64_DELIVERABILITY_NOTIFICATIONS_REGISTER) == sizeof(UINT64)); - typedef enum WHV_X64_PENDING_EVENT_TYPE { WHvX64PendingEventException = 0, WHvX64PendingEventExtInt = 5 @@ -672,6 +835,8 @@ typedef union WHV_REGISTER_VALUE { WHV_X64_PENDING_DEBUG_EXCEPTION PendingDebugException; } WHV_REGISTER_VALUE; +C_ASSERT(sizeof(WHV_REGISTER_VALUE) == 16); + typedef enum WHV_RUN_VP_EXIT_REASON { WHvRunVpExitReasonNone = 0x00000000, WHvRunVpExitReasonMemoryAccess = 0x00000001, @@ -682,6 +847,7 @@ typedef enum WHV_RUN_VP_EXIT_REASON { WHvRunVpExitReasonX64InterruptWindow = 0x00000007, WHvRunVpExitReasonX64Halt = 0x00000008, WHvRunVpExitReasonX64ApicEoi = 0x00000009, + WHvRunVpExitReasonSynicSintDeliverable = 0x0000000A, WHvRunVpExitReasonX64MsrAccess = 0x00001000, WHvRunVpExitReasonX64Cpuid = 0x00001001, WHvRunVpExitReasonException = 0x00001002, @@ -689,6 +855,7 @@ typedef enum WHV_RUN_VP_EXIT_REASON { WHvRunVpExitReasonX64ApicSmiTrap = 0x00001004, WHvRunVpExitReasonHypercall = 0x00001005, WHvRunVpExitReasonX64ApicInitSipiTrap = 0x00001006, + WHvRunVpExitReasonX64ApicWriteTrap = 0x00001007, WHvRunVpExitReasonCanceled = 0x00002001 } WHV_RUN_VP_EXIT_REASON; @@ -736,6 +903,8 @@ typedef union WHV_MEMORY_ACCESS_INFO { UINT32 AsUINT32; } WHV_MEMORY_ACCESS_INFO; +C_ASSERT(sizeof(WHV_MEMORY_ACCESS_INFO) == 4); + typedef struct WHV_MEMORY_ACCESS_CONTEXT { UINT8 InstructionByteCount; UINT8 Reserved[3]; @@ -745,6 +914,8 @@ typedef struct WHV_MEMORY_ACCESS_CONTEXT { WHV_GUEST_VIRTUAL_ADDRESS Gva; } WHV_MEMORY_ACCESS_CONTEXT; +C_ASSERT(sizeof(WHV_MEMORY_ACCESS_CONTEXT) == 40); + typedef union WHV_X64_IO_PORT_ACCESS_INFO { __C89_NAMELESS struct { UINT32 IsWrite : 1; @@ -773,6 +944,8 @@ typedef struct WHV_X64_IO_PORT_ACCESS_CONTEXT { WHV_X64_SEGMENT_REGISTER Es; } WHV_X64_IO_PORT_ACCESS_CONTEXT; +C_ASSERT(sizeof(WHV_X64_IO_PORT_ACCESS_CONTEXT) == 96); + typedef union WHV_X64_MSR_ACCESS_INFO { __C89_NAMELESS struct { UINT32 IsWrite : 1; @@ -790,6 +963,8 @@ typedef struct WHV_X64_MSR_ACCESS_CONTEXT { UINT64 Rdx; } WHV_X64_MSR_ACCESS_CONTEXT; +C_ASSERT(sizeof(WHV_X64_MSR_ACCESS_CONTEXT) == 24); + typedef struct WHV_X64_CPUID_ACCESS_CONTEXT { UINT64 Rax; UINT64 Rcx; @@ -801,6 +976,8 @@ typedef struct WHV_X64_CPUID_ACCESS_CONTEXT { UINT64 DefaultResultRbx; } WHV_X64_CPUID_ACCESS_CONTEXT; +C_ASSERT(sizeof(WHV_X64_CPUID_ACCESS_CONTEXT) == 64); + typedef union WHV_VP_EXCEPTION_INFO { __C89_NAMELESS struct { UINT32 ErrorCodeValid : 1; @@ -823,6 +1000,8 @@ typedef struct WHV_VP_EXCEPTION_CONTEXT { UINT64 ExceptionParameter; } WHV_VP_EXCEPTION_CONTEXT; +C_ASSERT(sizeof(WHV_VP_EXCEPTION_CONTEXT) == 40); + typedef enum WHV_X64_UNSUPPORTED_FEATURE_CODE { WHvUnsupportedFeatureIntercept = 1, WHvUnsupportedFeatureTaskSwitchTss = 2 @@ -834,6 +1013,8 @@ typedef struct WHV_X64_UNSUPPORTED_FEATURE_CONTEXT { UINT64 FeatureParameter; } WHV_X64_UNSUPPORTED_FEATURE_CONTEXT; +C_ASSERT(sizeof(WHV_X64_UNSUPPORTED_FEATURE_CONTEXT) == 16); + typedef enum WHV_RUN_VP_CANCEL_REASON { WhvRunVpCancelReasonUser = 0 } WHV_RUN_VP_CANCEL_REASON; @@ -842,6 +1023,8 @@ typedef struct WHV_RUN_VP_CANCELED_CONTEXT { WHV_RUN_VP_CANCEL_REASON CancelReason; } WHV_RUN_VP_CANCELED_CONTEXT; +C_ASSERT(sizeof(WHV_RUN_VP_CANCELED_CONTEXT) == 4); + typedef enum WHV_X64_PENDING_INTERRUPTION_TYPE { WHvX64PendingInterrupt = 0, WHvX64PendingNmi = 2, @@ -852,10 +1035,14 @@ typedef struct WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT { WHV_X64_PENDING_INTERRUPTION_TYPE DeliverableType; } WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT, *PWHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT; +C_ASSERT(sizeof(WHV_X64_INTERRUPTION_DELIVERABLE_CONTEXT) == 4); + typedef struct WHV_X64_APIC_EOI_CONTEXT { UINT32 InterruptVector; } WHV_X64_APIC_EOI_CONTEXT; +C_ASSERT(sizeof(WHV_X64_APIC_EOI_CONTEXT) == 4); + typedef union WHV_X64_RDTSC_INFO { __C89_NAMELESS struct { UINT64 IsRdtscp : 1; @@ -864,6 +1051,8 @@ typedef union WHV_X64_RDTSC_INFO { UINT64 AsUINT64; } WHV_X64_RDTSC_INFO; +C_ASSERT(sizeof(WHV_X64_RDTSC_INFO) == 8); + typedef struct WHV_X64_RDTSC_CONTEXT { UINT64 TscAux; UINT64 VirtualOffset; @@ -872,10 +1061,14 @@ typedef struct WHV_X64_RDTSC_CONTEXT { WHV_X64_RDTSC_INFO RdtscInfo; } WHV_X64_RDTSC_CONTEXT; +C_ASSERT(sizeof(WHV_X64_RDTSC_CONTEXT) == 40); + typedef struct WHV_X64_APIC_SMI_CONTEXT { UINT64 ApicIcr; } WHV_X64_APIC_SMI_CONTEXT; +C_ASSERT(sizeof(WHV_X64_APIC_SMI_CONTEXT) == 8); + #define WHV_HYPERCALL_CONTEXT_MAX_XMM_REGISTERS 6 typedef struct _WHV_HYPERCALL_CONTEXT { @@ -891,6 +1084,8 @@ typedef struct _WHV_HYPERCALL_CONTEXT { UINT64 Reserved1[2]; } WHV_HYPERCALL_CONTEXT, *PWHV_HYPERCALL_CONTEXT; +C_ASSERT(sizeof(WHV_HYPERCALL_CONTEXT) == 176); + typedef struct WHV_X64_APIC_INIT_SIPI_CONTEXT { UINT64 ApicIcr; } WHV_X64_APIC_INIT_SIPI_CONTEXT; @@ -944,6 +1139,8 @@ typedef struct WHV_INTERRUPT_CONTROL { UINT32 Vector; } WHV_INTERRUPT_CONTROL; +C_ASSERT(sizeof(WHV_INTERRUPT_CONTROL) == 16); + typedef struct WHV_DOORBELL_MATCH_DATA { WHV_GUEST_PHYSICAL_ADDRESS GuestAddress; UINT64 Value; @@ -953,6 +1150,8 @@ typedef struct WHV_DOORBELL_MATCH_DATA { UINT32 Reserved : 30; } WHV_DOORBELL_MATCH_DATA; +C_ASSERT(sizeof(WHV_DOORBELL_MATCH_DATA) == 24); + typedef enum WHV_PARTITION_COUNTER_SET { WHvPartitionCounterSetMemory } WHV_PARTITION_COUNTER_SET; @@ -963,11 +1162,14 @@ typedef struct WHV_PARTITION_MEMORY_COUNTERS { UINT64 Mapped1GPageCount; } WHV_PARTITION_MEMORY_COUNTERS; +C_ASSERT(sizeof(WHV_PARTITION_MEMORY_COUNTERS) == 24); + typedef enum WHV_PROCESSOR_COUNTER_SET { WHvProcessorCounterSetRuntime, WHvProcessorCounterSetIntercepts, WHvProcessorCounterSetEvents, - WHvProcessorCounterSetApic + WHvProcessorCounterSetApic, + WHvProcessorCounterSetSyntheticFeatures } WHV_PROCESSOR_COUNTER_SET; typedef struct WHV_PROCESSOR_RUNTIME_COUNTERS { @@ -975,11 +1177,15 @@ typedef struct WHV_PROCESSOR_RUNTIME_COUNTERS { UINT64 HypervisorRuntime100ns; } WHV_PROCESSOR_RUNTIME_COUNTERS; +C_ASSERT(sizeof(WHV_PROCESSOR_RUNTIME_COUNTERS) == 16); + typedef struct WHV_PROCESSOR_INTERCEPT_COUNTER { UINT64 Count; UINT64 Time100ns; } WHV_PROCESSOR_INTERCEPT_COUNTER; +C_ASSERT(sizeof(WHV_PROCESSOR_INTERCEPT_COUNTER) == 16); + typedef struct WHV_PROCESSOR_INTERCEPT_COUNTERS { WHV_PROCESSOR_INTERCEPT_COUNTER PageInvalidations; WHV_PROCESSOR_INTERCEPT_COUNTER ControlRegisterAccesses; @@ -992,14 +1198,21 @@ typedef struct WHV_PROCESSOR_INTERCEPT_COUNTERS { WHV_PROCESSOR_INTERCEPT_COUNTER EmulatedInstructions; WHV_PROCESSOR_INTERCEPT_COUNTER DebugRegisterAccesses; WHV_PROCESSOR_INTERCEPT_COUNTER PageFaultIntercepts; + WHV_PROCESSOR_INTERCEPT_COUNTER NestedPageFaultIntercepts; + WHV_PROCESSOR_INTERCEPT_COUNTER Hypercalls; + WHV_PROCESSOR_INTERCEPT_COUNTER RdpmcInstructions; } WHV_PROCESSOR_ACTIVITY_COUNTERS; +C_ASSERT(sizeof(WHV_PROCESSOR_ACTIVITY_COUNTERS) == 224); + typedef struct WHV_PROCESSOR_EVENT_COUNTERS { UINT64 PageFaultCount; UINT64 ExceptionCount; UINT64 InterruptCount; } WHV_PROCESSOR_GUEST_EVENT_COUNTERS; +C_ASSERT(sizeof(WHV_PROCESSOR_GUEST_EVENT_COUNTERS) == 24); + typedef struct WHV_PROCESSOR_APIC_COUNTERS { UINT64 MmioAccessCount; UINT64 EoiAccessCount; -- 2.32.0
From a5a1b8fb35d638a30e9f2f2b6b1fd9298d7e8b1d Mon Sep 17 00:00:00 2001 From: Biswapriyo Nath <[email protected]> Date: Sun, 8 Aug 2021 23:34:05 +0530 Subject: [PATCH 2/4] headers: Add new types in winhvplatformdefs.h Signed-off-by: Biswapriyo Nath <[email protected]> --- mingw-w64-headers/include/winhvplatformdefs.h | 496 +++++++++++++++++- 1 file changed, 491 insertions(+), 5 deletions(-) diff --git a/mingw-w64-headers/include/winhvplatformdefs.h b/mingw-w64-headers/include/winhvplatformdefs.h index 0f66c73..fd66fdd 100644 --- a/mingw-w64-headers/include/winhvplatformdefs.h +++ b/mingw-w64-headers/include/winhvplatformdefs.h @@ -192,6 +192,78 @@ typedef struct WHV_PROCESSOR_FEATURES_BANKS { C_ASSERT(sizeof(WHV_PROCESSOR_FEATURES_BANKS) == sizeof(UINT64) * (WHV_PROCESSOR_FEATURES_BANKS_COUNT + 1)); +typedef union WHV_SYNTHETIC_PROCESSOR_FEATURES { + __C89_NAMELESS struct { + UINT64 HypervisorPresent:1; + UINT64 Hv1:1; + UINT64 AccessVpRunTimeReg:1; + UINT64 AccessPartitionReferenceCounter:1; + UINT64 AccessSynicRegs:1; + UINT64 AccessSyntheticTimerRegs:1; +#ifdef __x86_64__ + UINT64 AccessIntrCtrlRegs:1; +#else + UINT64 ReservedZ6:1; +#endif + UINT64 AccessHypercallRegs:1; + UINT64 AccessVpIndex:1; + UINT64 AccessPartitionReferenceTsc:1; +#ifdef __x86_64__ + UINT64 AccessGuestIdleReg:1; + UINT64 AccessFrequencyRegs:1; +#else + UINT64 ReservedZ10:1; + UINT64 ReservedZ11:1; +#endif + UINT64 ReservedZ12:1; + UINT64 ReservedZ13:1; + UINT64 ReservedZ14:1; +#ifdef __x86_64__ + UINT64 EnableExtendedGvaRangesForFlushVirtualAddressList:1; +#else + UINT64 ReservedZ15:1; +#endif + UINT64 ReservedZ16:1; + UINT64 ReservedZ17:1; + UINT64 FastHypercallOutput:1; + UINT64 ReservedZ19:1; + UINT64 ReservedZ20:1; + UINT64 ReservedZ21:1; + UINT64 DirectSyntheticTimers:1; + UINT64 ReservedZ23:1; + UINT64 ExtendedProcessorMasks:1; +#ifdef __x86_64__ + UINT64 TbFlushHypercalls:1; +#else + UINT64 ReservedZ25:1; +#endif + UINT64 SyntheticClusterIpi:1; + UINT64 NotifyLongSpinWait:1; + UINT64 QueryNumaDistance:1; + UINT64 SignalEvents:1; + UINT64 RetargetDeviceInterrupt:1; + UINT64 Reserved:33; + }; + UINT64 AsUINT64; +} WHV_SYNTHETIC_PROCESSOR_FEATURES; + +C_ASSERT(sizeof(WHV_SYNTHETIC_PROCESSOR_FEATURES) == 8); + +#define WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS_COUNT 1 + +typedef struct WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS { + UINT32 BanksCount; + UINT32 Reserved0; + __C89_NAMELESS union { + __C89_NAMELESS struct { + WHV_SYNTHETIC_PROCESSOR_FEATURES Bank0; + }; + UINT64 AsUINT64[WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS_COUNT]; + }; +} WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS; + +C_ASSERT(sizeof(WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS) == 16); + typedef union _WHV_PROCESSOR_XSAVE_FEATURES { __C89_NAMELESS struct { UINT64 XsaveSupport : 1; @@ -232,6 +304,17 @@ typedef union _WHV_PROCESSOR_XSAVE_FEATURES { C_ASSERT(sizeof(WHV_PROCESSOR_XSAVE_FEATURES) == sizeof(UINT64)); +typedef union WHV_PROCESSOR_PERFMON_FEATURES { + __C89_NAMELESS struct { + UINT64 PmuSupport : 1; + UINT64 LbrSupport : 1; + UINT64 Reserved : 62; + }; + UINT64 AsUINT64; +} WHV_PROCESSOR_PERFMON_FEATURES, *PWHV_PROCESSOR_PERFMON_FEATURES; + +C_ASSERT(sizeof(WHV_PROCESSOR_PERFMON_FEATURES) == 8); + typedef union WHV_X64_MSR_EXIT_BITMAP { UINT64 AsUINT64; __C89_NAMELESS struct { @@ -247,12 +330,69 @@ typedef union WHV_X64_MSR_EXIT_BITMAP { C_ASSERT(sizeof(WHV_X64_MSR_EXIT_BITMAP) == sizeof(UINT64)); +typedef struct WHV_MEMORY_RANGE_ENTRY { + UINT64 GuestAddress; + UINT64 SizeInBytes; +} WHV_MEMORY_RANGE_ENTRY; + +C_ASSERT(sizeof(WHV_MEMORY_RANGE_ENTRY) == 16); + +typedef union WHV_ADVISE_GPA_RANGE_POPULATE_FLAGS { + UINT32 AsUINT32; + __C89_NAMELESS struct { + UINT32 Prefetch:1; + UINT32 AvoidHardFaults:1; + UINT32 Reserved:30; + }; +} WHV_ADVISE_GPA_RANGE_POPULATE_FLAGS; + +C_ASSERT(sizeof(WHV_ADVISE_GPA_RANGE_POPULATE_FLAGS) == 4); + +typedef enum WHV_MEMORY_ACCESS_TYPE { + WHvMemoryAccessRead = 0, + WHvMemoryAccessWrite = 1, + WHvMemoryAccessExecute = 2 +} WHV_MEMORY_ACCESS_TYPE; + +typedef struct WHV_ADVISE_GPA_RANGE_POPULATE { + WHV_ADVISE_GPA_RANGE_POPULATE_FLAGS Flags; + WHV_MEMORY_ACCESS_TYPE AccessType; +} WHV_ADVISE_GPA_RANGE_POPULATE; + +C_ASSERT(sizeof(WHV_ADVISE_GPA_RANGE_POPULATE) == 8); + +typedef struct WHV_CAPABILITY_PROCESSOR_FREQUENCY_CAP { + UINT32 IsSupported:1; + UINT32 Reserved:31; + UINT32 HighestFrequencyMhz; + UINT32 NominalFrequencyMhz; + UINT32 LowestFrequencyMhz; + UINT32 FrequencyStepMhz; +} WHV_CAPABILITY_PROCESSOR_FREQUENCY_CAP; + +C_ASSERT(sizeof(WHV_CAPABILITY_PROCESSOR_FREQUENCY_CAP) == 20); + +typedef union WHV_SCHEDULER_FEATURES { + __C89_NAMELESS struct { + UINT64 CpuReserve: 1; + UINT64 CpuCap: 1; + UINT64 CpuWeight: 1; + UINT64 CpuGroupId: 1; + UINT64 DisableSmt: 1; + UINT64 Reserved: 59; + }; + UINT64 AsUINT64; +} WHV_SCHEDULER_FEATURES; + +C_ASSERT(sizeof(WHV_SCHEDULER_FEATURES) == 8); + typedef union WHV_CAPABILITY { WINBOOL HypervisorPresent; WHV_CAPABILITY_FEATURES Features; WHV_EXTENDED_VM_EXITS ExtendedVmExits; WHV_PROCESSOR_VENDOR ProcessorVendor; WHV_PROCESSOR_FEATURES ProcessorFeatures; + WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS SyntheticProcessorFeaturesBanks; WHV_PROCESSOR_XSAVE_FEATURES ProcessorXsaveFeatures; UINT8 ProcessorClFlushSize; UINT64 ExceptionExitBitmap; @@ -260,6 +400,10 @@ typedef union WHV_CAPABILITY { UINT64 ProcessorClockFrequency; UINT64 InterruptClockFrequency; WHV_PROCESSOR_FEATURES_BANKS ProcessorFeaturesBanks; + WHV_ADVISE_GPA_RANGE_POPULATE_FLAGS GpaRangePopulateFlags; + WHV_CAPABILITY_PROCESSOR_FREQUENCY_CAP ProcessorFrequencyCap; + WHV_PROCESSOR_PERFMON_FEATURES ProcessorPerfmonFeatures; + WHV_SCHEDULER_FEATURES SchedulerFeatures; } WHV_CAPABILITY; typedef VOID* WHV_PARTITION_HANDLE; @@ -306,6 +450,50 @@ typedef struct WHV_X64_CPUID_RESULT { UINT32 Edx; } WHV_X64_CPUID_RESULT; +C_ASSERT(sizeof(WHV_X64_CPUID_RESULT) == 32); + +typedef enum WHV_X64_CPUID_RESULT2_FLAGS { + WHvX64CpuidResult2FlagSubleafSpecific = 0x00000001, + WHvX64CpuidResult2FlagVpSpecific = 0x00000002 +} WHV_X64_CPUID_RESULT2_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(WHV_X64_CPUID_RESULT2_FLAGS); + +typedef struct WHV_CPUID_OUTPUT { + UINT32 Eax; + UINT32 Ebx; + UINT32 Ecx; + UINT32 Edx; +} WHV_CPUID_OUTPUT; + +C_ASSERT(sizeof(WHV_CPUID_OUTPUT) == 16); + +typedef struct WHV_X64_CPUID_RESULT2 { + UINT32 Function; + UINT32 Index; + UINT32 VpIndex; + WHV_X64_CPUID_RESULT2_FLAGS Flags; + WHV_CPUID_OUTPUT Output; + WHV_CPUID_OUTPUT Mask; +} WHV_X64_CPUID_RESULT2; + +C_ASSERT(sizeof(WHV_X64_CPUID_RESULT2) == 48); + +typedef struct WHV_MSR_ACTION_ENTRY { + UINT32 Index; + UINT8 ReadAction; + UINT8 WriteAction; + UINT16 Reserved; +} WHV_MSR_ACTION_ENTRY; + +C_ASSERT(sizeof(WHV_MSR_ACTION_ENTRY) == 8); + +typedef enum WHV_MSR_ACTION { + WHvMsrActionArchitectureDefault = 0, + WHvMsrActionIgnoreWriteReadZero = 1, + WHvMsrActionExit = 2 +} WHV_MSR_ACTION; + typedef enum WHV_EXCEPTION_TYPE { WHvX64ExceptionTypeDivideErrorFault = 0x0, WHvX64ExceptionTypeDebugTrapOrFault = 0x1, @@ -335,11 +523,15 @@ typedef enum WHV_X64_LOCAL_APIC_EMULATION_MODE { typedef union WHV_PARTITION_PROPERTY { WHV_EXTENDED_VM_EXITS ExtendedVmExits; WHV_PROCESSOR_FEATURES ProcessorFeatures; + WHV_SYNTHETIC_PROCESSOR_FEATURES_BANKS SyntheticProcessorFeaturesBanks; WHV_PROCESSOR_XSAVE_FEATURES ProcessorXsaveFeatures; UINT8 ProcessorClFlushSize; UINT32 ProcessorCount; UINT32 CpuidExitList[1]; WHV_X64_CPUID_RESULT CpuidResultList[1]; + WHV_X64_CPUID_RESULT2 CpuidResultList2[1]; + WHV_MSR_ACTION_ENTRY MsrActionList[1]; + WHV_MSR_ACTION UnimplementedMsrAction; UINT64 ExceptionExitBitmap; WHV_X64_LOCAL_APIC_EMULATION_MODE LocalApicEmulationMode; WINBOOL SeparateSecurityDomain; @@ -350,6 +542,15 @@ typedef union WHV_PARTITION_PROPERTY { WINBOOL ApicRemoteRead; WHV_PROCESSOR_FEATURES_BANKS ProcessorFeaturesBanks; UINT64 ReferenceTime; + USHORT PrimaryNumaNode; + UINT32 CpuReserve; + UINT32 CpuCap; + UINT32 CpuWeight; + UINT64 CpuGroupId; + UINT32 ProcessorFrequencyCap; + WINBOOL AllowDeviceAssignment; + WHV_PROCESSOR_PERFMON_FEATURES ProcessorPerfmonFeatures; + WINBOOL DisableSmt; } WHV_PARTITION_PROPERTY; typedef UINT64 WHV_GUEST_PHYSICAL_ADDRESS; @@ -395,6 +596,36 @@ typedef struct WHV_TRANSLATE_GVA_RESULT { UINT32 Reserved; } WHV_TRANSLATE_GVA_RESULT; +C_ASSERT(sizeof(WHV_TRANSLATE_GVA_RESULT) == 8); + +typedef union WHV_ADVISE_GPA_RANGE { + WHV_ADVISE_GPA_RANGE_POPULATE Populate; +} WHV_ADVISE_GPA_RANGE; + +C_ASSERT(sizeof(WHV_ADVISE_GPA_RANGE) == 8); + +typedef enum WHV_CACHE_TYPE { + WHvCacheTypeUncached = 0, + WHvCacheTypeWriteCombining = 1, + WHvCacheTypeWriteThrough = 4, +#ifdef __x86_64__ + WHvCacheTypeWriteProtected = 5, +#endif + WHvCacheTypeWriteBack = 6 +} WHV_CACHE_TYPE; + +typedef union WHV_ACCESS_GPA_CONTROLS { + UINT64 AsUINT64; + __C89_NAMELESS struct { + WHV_CACHE_TYPE CacheType; + UINT32 Reserved; + }; +} WHV_ACCESS_GPA_CONTROLS; + +C_ASSERT(sizeof(WHV_ACCESS_GPA_CONTROLS) == 8); + +#define WHV_READ_WRITE_GPA_RANGE_MAX_SIZE 16 + typedef enum WHV_REGISTER_NAME { WHvX64RegisterRax = 0x00000000, WHvX64RegisterRcx = 0x00000001, @@ -815,6 +1046,14 @@ typedef union WHV_X64_PENDING_DEBUG_EXCEPTION { C_ASSERT(sizeof(WHV_X64_PENDING_DEBUG_EXCEPTION) == sizeof(UINT64)); +typedef struct WHV_SYNIC_SINT_DELIVERABLE_CONTEXT { + UINT16 DeliverableSints; + UINT16 Reserved1; + UINT32 Reserved2; +} WHV_SYNIC_SINT_DELIVERABLE_CONTEXT; + +C_ASSERT(sizeof(WHV_SYNIC_SINT_DELIVERABLE_CONTEXT) == 8); + typedef union WHV_REGISTER_VALUE { WHV_UINT128 Reg128; UINT64 Reg64; @@ -887,11 +1126,7 @@ typedef struct WHV_VP_EXIT_CONTEXT { UINT64 Rflags; } WHV_VP_EXIT_CONTEXT; -typedef enum WHV_MEMORY_ACCESS_TYPE { - WHvMemoryAccessRead = 0, - WHvMemoryAccessWrite = 1, - WHvMemoryAccessExecute = 2 -} WHV_MEMORY_ACCESS_TYPE; +C_ASSERT(sizeof(WHV_VP_EXIT_CONTEXT) == 40); typedef union WHV_MEMORY_ACCESS_INFO { __C89_NAMELESS struct { @@ -1090,6 +1325,24 @@ typedef struct WHV_X64_APIC_INIT_SIPI_CONTEXT { UINT64 ApicIcr; } WHV_X64_APIC_INIT_SIPI_CONTEXT; +C_ASSERT(sizeof(WHV_X64_APIC_INIT_SIPI_CONTEXT) == 8); + +typedef enum WHV_X64_APIC_WRITE_TYPE { + WHvX64ApicWriteTypeLdr = 0xD0, + WHvX64ApicWriteTypeDfr = 0xE0, + WHvX64ApicWriteTypeSvr = 0xF0, + WHvX64ApicWriteTypeLint0 = 0x350, + WHvX64ApicWriteTypeLint1 = 0x360 +} WHV_X64_APIC_WRITE_TYPE; + +typedef struct WHV_X64_APIC_WRITE_CONTEXT { + WHV_X64_APIC_WRITE_TYPE Type; + UINT32 Reserved; + UINT64 WriteValue; +} WHV_X64_APIC_WRITE_CONTEXT; + +C_ASSERT(sizeof(WHV_X64_APIC_WRITE_CONTEXT) == 16); + typedef struct WHV_RUN_VP_EXIT_CONTEXT { WHV_RUN_VP_EXIT_REASON ExitReason; UINT32 Reserved; @@ -1108,9 +1361,13 @@ typedef struct WHV_RUN_VP_EXIT_CONTEXT { WHV_X64_APIC_SMI_CONTEXT ApicSmi; WHV_HYPERCALL_CONTEXT Hypercall; WHV_X64_APIC_INIT_SIPI_CONTEXT ApicInitSipi; + WHV_X64_APIC_WRITE_CONTEXT ApicWrite; + WHV_SYNIC_SINT_DELIVERABLE_CONTEXT SynicSintDeliverable; }; } WHV_RUN_VP_EXIT_CONTEXT; +C_ASSERT(sizeof(WHV_RUN_VP_EXIT_CONTEXT) == 224); + typedef enum WHV_INTERRUPT_TYPE { WHvX64InterruptTypeFixed = 0, WHvX64InterruptTypeLowestPriority = 1, @@ -1221,4 +1478,233 @@ typedef struct WHV_PROCESSOR_APIC_COUNTERS { UINT64 SelfIpiCount; } WHV_PROCESSOR_APIC_COUNTERS; +C_ASSERT(sizeof(WHV_PROCESSOR_APIC_COUNTERS) == 40); + +typedef struct WHV_PROCESSOR_SYNTHETIC_FEATURES_COUNTERS { + UINT64 SyntheticInterruptsCount; + UINT64 LongSpinWaitHypercallsCount; + UINT64 OtherHypercallsCount; + UINT64 SyntheticInterruptHypercallsCount; + UINT64 VirtualInterruptHypercallsCount; + UINT64 VirtualMmuHypercallsCount; +} WHV_PROCESSOR_SYNTHETIC_FEATURES_COUNTERS; + +C_ASSERT(sizeof(WHV_PROCESSOR_SYNTHETIC_FEATURES_COUNTERS) == 48); + +typedef enum WHV_ADVISE_GPA_RANGE_CODE { + WHvAdviseGpaRangeCodePopulate = 0x00000000, + WHvAdviseGpaRangeCodePin = 0x00000001, + WHvAdviseGpaRangeCodeUnpin = 0x00000002 +} WHV_ADVISE_GPA_RANGE_CODE; + +typedef enum WHV_VIRTUAL_PROCESSOR_STATE_TYPE { + WHvVirtualProcessorStateTypeSynicMessagePage = 0x00000000, + WHvVirtualProcessorStateTypeSynicEventFlagPage = 0x00000001, + WHvVirtualProcessorStateTypeSynicTimerState = 0x00000002, + WHvVirtualProcessorStateTypeInterruptControllerState2 = 0x00001000, + WHvVirtualProcessorStateTypeXsaveState = 0x00001001 +} WHV_VIRTUAL_PROCESSOR_STATE_TYPE; + +typedef struct WHV_SYNIC_EVENT_PARAMETERS { + UINT32 VpIndex; + UINT8 TargetSint; + UINT8 Reserved; + UINT16 FlagNumber; +} WHV_SYNIC_EVENT_PARAMETERS; + +C_ASSERT(sizeof(WHV_SYNIC_EVENT_PARAMETERS) == 8); + +typedef enum WHV_ALLOCATE_VPCI_RESOURCE_FLAGS { + WHvAllocateVpciResourceFlagNone = 0x00000000, + WHvAllocateVpciResourceFlagAllowDirectP2P = 0x00000001 +} WHV_ALLOCATE_VPCI_RESOURCE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(WHV_ALLOCATE_VPCI_RESOURCE_FLAGS); + +#define WHV_MAX_DEVICE_ID_SIZE_IN_CHARS 200 + +typedef struct WHV_SRIOV_RESOURCE_DESCRIPTOR { + WCHAR PnpInstanceId[WHV_MAX_DEVICE_ID_SIZE_IN_CHARS]; + LUID VirtualFunctionId; + UINT16 VirtualFunctionIndex; + UINT16 Reserved; +} WHV_SRIOV_RESOURCE_DESCRIPTOR; + +C_ASSERT(sizeof(WHV_SRIOV_RESOURCE_DESCRIPTOR) == 412); + +typedef enum WHV_VPCI_DEVICE_NOTIFICATION_TYPE { + WHvVpciDeviceNotificationUndefined = 0, + WHvVpciDeviceNotificationMmioRemapping = 1, + WHvVpciDeviceNotificationSurpriseRemoval = 2 +} WHV_VPCI_DEVICE_NOTIFICATION_TYPE; + +typedef struct WHV_VPCI_DEVICE_NOTIFICATION { + WHV_VPCI_DEVICE_NOTIFICATION_TYPE NotificationType; + UINT32 Reserved1; + __C89_NAMELESS union { + UINT64 Reserved2; + }; +} WHV_VPCI_DEVICE_NOTIFICATION; + +C_ASSERT(sizeof(WHV_VPCI_DEVICE_NOTIFICATION) == 16); + +typedef enum WHV_CREATE_VPCI_DEVICE_FLAGS { + WHvCreateVpciDeviceFlagNone = 0x00000000, + WHvCreateVpciDeviceFlagPhysicallyBacked = 0x00000001, + WHvCreateVpciDeviceFlagUseLogicalInterrupts = 0x00000002 +} WHV_CREATE_VPCI_DEVICE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(WHV_CREATE_VPCI_DEVICE_FLAGS); + +typedef enum WHV_VPCI_DEVICE_PROPERTY_CODE { + WHvVpciDevicePropertyCodeUndefined = 0, + WHvVpciDevicePropertyCodeHardwareIDs = 1, + WHvVpciDevicePropertyCodeProbedBARs = 2 +} WHV_VPCI_DEVICE_PROPERTY_CODE; + +typedef struct WHV_VPCI_HARDWARE_IDS { + UINT16 VendorID; + UINT16 DeviceID; + UINT8 RevisionID; + UINT8 ProgIf; + UINT8 SubClass; + UINT8 BaseClass; + UINT16 SubVendorID; + UINT16 SubSystemID; +} WHV_VPCI_HARDWARE_IDS; + +C_ASSERT(sizeof(WHV_VPCI_HARDWARE_IDS) == 12); + +#define WHV_VPCI_TYPE0_BAR_COUNT 6 + +typedef struct WHV_VPCI_PROBED_BARS { + UINT32 Value[WHV_VPCI_TYPE0_BAR_COUNT]; +} WHV_VPCI_PROBED_BARS; + +C_ASSERT(sizeof(WHV_VPCI_PROBED_BARS) == 24); + +typedef enum WHV_VPCI_MMIO_RANGE_FLAGS { + WHvVpciMmioRangeFlagReadAccess = 0x00000001, + WHvVpciMmioRangeFlagWriteAccess = 0x00000002 +} WHV_VPCI_MMIO_RANGE_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(WHV_VPCI_MMIO_RANGE_FLAGS); + +typedef enum WHV_VPCI_DEVICE_REGISTER_SPACE { + WHvVpciConfigSpace = -1, + WHvVpciBar0 = 0, + WHvVpciBar1 = 1, + WHvVpciBar2 = 2, + WHvVpciBar3 = 3, + WHvVpciBar4 = 4, + WHvVpciBar5 = 5 +} WHV_VPCI_DEVICE_REGISTER_SPACE; + +typedef struct WHV_VPCI_MMIO_MAPPING { + WHV_VPCI_DEVICE_REGISTER_SPACE Location; + WHV_VPCI_MMIO_RANGE_FLAGS Flags; + UINT64 SizeInBytes; + UINT64 OffsetInBytes; + PVOID VirtualAddress; +} WHV_VPCI_MMIO_MAPPING; + +C_ASSERT(sizeof(WHV_VPCI_MMIO_MAPPING) == 32); + +typedef struct WHV_VPCI_DEVICE_REGISTER { + WHV_VPCI_DEVICE_REGISTER_SPACE Location; + UINT32 SizeInBytes; + UINT64 OffsetInBytes; +} WHV_VPCI_DEVICE_REGISTER; + +C_ASSERT(sizeof(WHV_VPCI_DEVICE_REGISTER) == 16); + +typedef enum WHV_VPCI_INTERRUPT_TARGET_FLAGS { + WHvVpciInterruptTargetFlagNone = 0x00000000, + WHvVpciInterruptTargetFlagMulticast = 0x00000001 +} WHV_VPCI_INTERRUPT_TARGET_FLAGS; + +DEFINE_ENUM_FLAG_OPERATORS(WHV_VPCI_INTERRUPT_TARGET_FLAGS); + +typedef struct WHV_VPCI_INTERRUPT_TARGET { + UINT32 Vector; + WHV_VPCI_INTERRUPT_TARGET_FLAGS Flags; + UINT32 ProcessorCount; + UINT32 Processors[ANYSIZE_ARRAY]; +} WHV_VPCI_INTERRUPT_TARGET; + +C_ASSERT(sizeof(WHV_VPCI_INTERRUPT_TARGET) == 16); + +typedef enum WHV_TRIGGER_TYPE { + WHvTriggerTypeInterrupt = 0, + WHvTriggerTypeSynicEvent = 1, + WHvTriggerTypeDeviceInterrupt = 2 +} WHV_TRIGGER_TYPE; + +typedef struct WHV_TRIGGER_PARAMETERS { + WHV_TRIGGER_TYPE TriggerType; + UINT32 Reserved; + __C89_NAMELESS union { + WHV_INTERRUPT_CONTROL Interrupt; + WHV_SYNIC_EVENT_PARAMETERS SynicEvent; + __C89_NAMELESS struct { + UINT64 LogicalDeviceId; + UINT64 MsiAddress; + UINT32 MsiData; + UINT32 Reserved; + } DeviceInterrupt; + }; +} WHV_TRIGGER_PARAMETERS; + +C_ASSERT(sizeof(WHV_TRIGGER_PARAMETERS) == 32); + +typedef PVOID WHV_TRIGGER_HANDLE; + +typedef enum WHV_VIRTUAL_PROCESSOR_PROPERTY_CODE { + WHvVirtualProcessorPropertyCodeNumaNode = 0x00000000 +} WHV_VIRTUAL_PROCESSOR_PROPERTY_CODE; + +typedef struct WHV_VIRTUAL_PROCESSOR_PROPERTY { + WHV_VIRTUAL_PROCESSOR_PROPERTY_CODE PropertyCode; + UINT32 Reserved; + __C89_NAMELESS union { + USHORT NumaNode; + UINT64 Padding; + }; +} WHV_VIRTUAL_PROCESSOR_PROPERTY; + +C_ASSERT(sizeof(WHV_VIRTUAL_PROCESSOR_PROPERTY) == 16); + +typedef enum WHV_NOTIFICATION_PORT_TYPE { + WHvNotificationPortTypeEvent = 2, + WHvNotificationPortTypeDoorbell = 4 +} WHV_NOTIFICATION_PORT_TYPE; + +typedef struct WHV_NOTIFICATION_PORT_PARAMETERS { + WHV_NOTIFICATION_PORT_TYPE NotificationPortType; + UINT32 Reserved; + __C89_NAMELESS union { + WHV_DOORBELL_MATCH_DATA Doorbell; + __C89_NAMELESS struct { + UINT32 ConnectionId; + } Event; + }; +} WHV_NOTIFICATION_PORT_PARAMETERS; + +C_ASSERT(sizeof(WHV_NOTIFICATION_PORT_PARAMETERS) == 32); + +typedef enum WHV_NOTIFICATION_PORT_PROPERTY_CODE { + WHvNotificationPortPropertyPreferredTargetVp = 1, + WHvNotificationPortPropertyPreferredTargetDuration = 5 +} WHV_NOTIFICATION_PORT_PROPERTY_CODE; + +typedef UINT64 WHV_NOTIFICATION_PORT_PROPERTY; + +#define WHV_ANY_VP (0xFFFFFFFF) + +#define WHV_NOTIFICATION_PORT_PREFERRED_DURATION_MAX (0xFFFFFFFFFFFFFFFFUI64) + +typedef PVOID WHV_NOTIFICATION_PORT_HANDLE; + +#define WHV_SYNIC_MESSAGE_SIZE 256 + #endif /* _WINHVAPIDEFS_H_ */ -- 2.32.0
From 80d4140c82484466f051dffe49aac84b7b1e34c8 Mon Sep 17 00:00:00 2001 From: Biswapriyo Nath <[email protected]> Date: Sun, 8 Aug 2021 23:35:41 +0530 Subject: [PATCH 4/4] crt: Add new exports in winhvplatform.def Signed-off-by: Biswapriyo Nath <[email protected]> --- mingw-w64-crt/lib64/winhvplatform.def | 37 +++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/mingw-w64-crt/lib64/winhvplatform.def b/mingw-w64-crt/lib64/winhvplatform.def index 7fae354..4be84a5 100644 --- a/mingw-w64-crt/lib64/winhvplatform.def +++ b/mingw-w64-crt/lib64/winhvplatform.def @@ -1,31 +1,68 @@ LIBRARY "winhvplatform.dll" EXPORTS +WHvAcceptPartitionMigration +WHvAdviseGpaRange +WHvAllocateVpciResource +WHvCancelPartitionMigration WHvCancelRunVirtualProcessor +WHvCompletePartitionMigration +WHvCreateNotificationPort WHvCreatePartition +WHvCreateTrigger WHvCreateVirtualProcessor +WHvCreateVirtualProcessor2 +WHvCreateVpciDevice +WHvDeleteNotificationPort WHvDeletePartition +WHvDeleteTrigger WHvDeleteVirtualProcessor +WHvDeleteVpciDevice WHvGetCapability +WHvGetInterruptTargetVpSet WHvGetPartitionCounters WHvGetPartitionProperty WHvGetVirtualProcessorCounters +WHvGetVirtualProcessorCpuidOutput WHvGetVirtualProcessorInterruptControllerState WHvGetVirtualProcessorInterruptControllerState2 WHvGetVirtualProcessorRegisters +WHvGetVirtualProcessorState WHvGetVirtualProcessorXsaveState +WHvGetVpciDeviceInterruptTarget +WHvGetVpciDeviceNotification +WHvGetVpciDeviceProperty WHvMapGpaRange +WHvMapGpaRange2 +WHvMapVpciDeviceInterrupt +WHvMapVpciDeviceMmioRanges +WHvPostVirtualProcessorSynicMessage WHvQueryGpaRangeDirtyBitmap +WHvReadGpaRange +WHvReadVpciDeviceRegister WHvRegisterPartitionDoorbellEvent WHvRequestInterrupt +WHvRequestVpciDeviceInterrupt +WHvResetPartition WHvResumePartitionTime +WHvRetargetVpciDeviceInterrupt WHvRunVirtualProcessor +WHvSetNotificationPortProperty WHvSetPartitionProperty WHvSetVirtualProcessorInterruptControllerState WHvSetVirtualProcessorInterruptControllerState2 WHvSetVirtualProcessorRegisters +WHvSetVirtualProcessorState WHvSetVirtualProcessorXsaveState +WHvSetVpciDevicePowerState WHvSetupPartition +WHvSignalVirtualProcessorSynicEvent +WHvStartPartitionMigration WHvSuspendPartitionTime WHvTranslateGva WHvUnmapGpaRange +WHvUnmapVpciDeviceInterrupt +WHvUnmapVpciDeviceMmioRanges WHvUnregisterPartitionDoorbellEvent +WHvUpdateTriggerParameters +WHvWriteGpaRange +WHvWriteVpciDeviceRegister -- 2.32.0
From d1253f5c494d3f7f7b36f6a75b8b77809f89e50d Mon Sep 17 00:00:00 2001 From: Biswapriyo Nath <[email protected]> Date: Sun, 8 Aug 2021 23:35:14 +0530 Subject: [PATCH 3/4] headers: Add new API declarations in winhvplatform.h Signed-off-by: Biswapriyo Nath <[email protected]> --- mingw-w64-headers/include/winhvplatform.h | 37 +++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/mingw-w64-headers/include/winhvplatform.h b/mingw-w64-headers/include/winhvplatform.h index 61f20f6..b148804 100644 --- a/mingw-w64-headers/include/winhvplatform.h +++ b/mingw-w64-headers/include/winhvplatform.h @@ -22,15 +22,18 @@ extern "C" { HRESULT WINAPI WHvGetCapability(WHV_CAPABILITY_CODE CapabilityCode, VOID *CapabilityBuffer, UINT32 CapabilityBufferSizeInBytes, UINT32 *WrittenSizeInBytes); HRESULT WINAPI WHvCreatePartition(WHV_PARTITION_HANDLE *Partition); HRESULT WINAPI WHvSetupPartition(WHV_PARTITION_HANDLE Partition); +HRESULT WINAPI WHvResetPartition(WHV_PARTITION_HANDLE Partition); HRESULT WINAPI WHvDeletePartition(WHV_PARTITION_HANDLE Partition); HRESULT WINAPI WHvGetPartitionProperty(WHV_PARTITION_HANDLE Partition, WHV_PARTITION_PROPERTY_CODE PropertyCode, VOID *PropertyBuffer, UINT32 PropertyBufferSizeInBytes, UINT32 *WrittenSizeInBytes); HRESULT WINAPI WHvSetPartitionProperty(WHV_PARTITION_HANDLE Partition, WHV_PARTITION_PROPERTY_CODE PropertyCode, const VOID *PropertyBuffer, UINT32 PropertyBufferSizeInBytes); HRESULT WINAPI WHvSuspendPartitionTime(WHV_PARTITION_HANDLE Partition); HRESULT WINAPI WHvResumePartitionTime(WHV_PARTITION_HANDLE Partition); HRESULT WINAPI WHvMapGpaRange(WHV_PARTITION_HANDLE Partition, VOID *SourceAddress, WHV_GUEST_PHYSICAL_ADDRESS GuestAddress, UINT64 SizeInBytes, WHV_MAP_GPA_RANGE_FLAGS Flags); +HRESULT WINAPI WHvMapGpaRange2(WHV_PARTITION_HANDLE Partition, HANDLE Process, VOID *SourceAddress, WHV_GUEST_PHYSICAL_ADDRESS GuestAddress, UINT64 SizeInBytes, WHV_MAP_GPA_RANGE_FLAGS Flags); HRESULT WINAPI WHvUnmapGpaRange(WHV_PARTITION_HANDLE Partition, WHV_GUEST_PHYSICAL_ADDRESS GuestAddress, UINT64 SizeInBytes); HRESULT WINAPI WHvTranslateGva(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, WHV_GUEST_VIRTUAL_ADDRESS Gva, WHV_TRANSLATE_GVA_FLAGS TranslateFlags, WHV_TRANSLATE_GVA_RESULT *TranslationResult, WHV_GUEST_PHYSICAL_ADDRESS *Gpa); HRESULT WINAPI WHvCreateVirtualProcessor(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, UINT32 Flags); +HRESULT WINAPI WHvCreateVirtualProcessor2(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, const WHV_VIRTUAL_PROCESSOR_PROPERTY *Properties, UINT32 PropertyCount); HRESULT WINAPI WHvDeleteVirtualProcessor(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex); HRESULT WINAPI WHvRunVirtualProcessor(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, VOID *ExitContext, UINT32 ExitContextSizeInBytes); HRESULT WINAPI WHvCancelRunVirtualProcessor(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, UINT32 Flags); @@ -48,6 +51,40 @@ HRESULT WINAPI WHvGetVirtualProcessorInterruptControllerState2(WHV_PARTITION_HAN HRESULT WINAPI WHvSetVirtualProcessorInterruptControllerState2(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, const VOID *State, UINT32 StateSize); HRESULT WINAPI WHvRegisterPartitionDoorbellEvent(WHV_PARTITION_HANDLE Partition, const WHV_DOORBELL_MATCH_DATA *MatchData, HANDLE EventHandle); HRESULT WINAPI WHvUnregisterPartitionDoorbellEvent(WHV_PARTITION_HANDLE Partition, const WHV_DOORBELL_MATCH_DATA *MatchData); +HRESULT WINAPI WHvAdviseGpaRange(WHV_PARTITION_HANDLE Partition, const WHV_MEMORY_RANGE_ENTRY *GpaRanges, UINT32 GpaRangesCount, WHV_ADVISE_GPA_RANGE_CODE Advice, const VOID *AdviceBuffer, UINT32 AdviceBufferSizeInBytes); +HRESULT WINAPI WHvReadGpaRange(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, WHV_GUEST_PHYSICAL_ADDRESS GuestAddress, WHV_ACCESS_GPA_CONTROLS Controls, PVOID Data, UINT32 DataSizeInBytes); +HRESULT WINAPI WHvWriteGpaRange(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, WHV_GUEST_PHYSICAL_ADDRESS GuestAddress, WHV_ACCESS_GPA_CONTROLS Controls, const VOID *Data, UINT32 DataSizeInBytes); +HRESULT WINAPI WHvSignalVirtualProcessorSynicEvent(WHV_PARTITION_HANDLE Partition, WHV_SYNIC_EVENT_PARAMETERS SynicEvent, WINBOOL *NewlySignaled); +HRESULT WINAPI WHvGetVirtualProcessorState(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, WHV_VIRTUAL_PROCESSOR_STATE_TYPE StateType, VOID *Buffer, UINT32 BufferSizeInBytes, UINT32 *BytesWritten); +HRESULT WINAPI WHvSetVirtualProcessorState(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, WHV_VIRTUAL_PROCESSOR_STATE_TYPE StateType, const VOID *Buffer, UINT32 BufferSizeInBytes); +HRESULT WINAPI WHvAllocateVpciResource(const GUID *ProviderId, WHV_ALLOCATE_VPCI_RESOURCE_FLAGS Flags, const VOID *ResourceDescriptor, UINT32 ResourceDescriptorSizeInBytes, HANDLE *VpciResource); +HRESULT WINAPI WHvCreateVpciDevice(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, HANDLE VpciResource, WHV_CREATE_VPCI_DEVICE_FLAGS Flags, HANDLE NotificationEventHandle); +HRESULT WINAPI WHvDeleteVpciDevice(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId); +HRESULT WINAPI WHvGetVpciDeviceProperty(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, WHV_VPCI_DEVICE_PROPERTY_CODE PropertyCode, VOID *PropertyBuffer, UINT32 PropertyBufferSizeInBytes, UINT32 *WrittenSizeInBytes); +HRESULT WINAPI WHvGetVpciDeviceNotification(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, WHV_VPCI_DEVICE_NOTIFICATION *Notification, UINT32 NotificationSizeInBytes); +HRESULT WINAPI WHvMapVpciDeviceMmioRanges(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, UINT32 *MappingCount, WHV_VPCI_MMIO_MAPPING **Mappings); +HRESULT WINAPI WHvUnmapVpciDeviceMmioRanges(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId); +HRESULT WINAPI WHvSetVpciDevicePowerState(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, DEVICE_POWER_STATE PowerState); +HRESULT WINAPI WHvReadVpciDeviceRegister(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, const WHV_VPCI_DEVICE_REGISTER *Register, VOID *Data); +HRESULT WINAPI WHvWriteVpciDeviceRegister(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, const WHV_VPCI_DEVICE_REGISTER *Register, const VOID *Data); +HRESULT WINAPI WHvMapVpciDeviceInterrupt(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, UINT32 Index, UINT32 MessageCount, const WHV_VPCI_INTERRUPT_TARGET *Target, UINT64 *MsiAddress, UINT32 *MsiData); +HRESULT WINAPI WHvUnmapVpciDeviceInterrupt(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, UINT32 Index); +HRESULT WINAPI WHvRetargetVpciDeviceInterrupt(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, UINT64 MsiAddress, UINT32 MsiData, const WHV_VPCI_INTERRUPT_TARGET *Target); +HRESULT WINAPI WHvRequestVpciDeviceInterrupt(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, UINT64 MsiAddress, UINT32 MsiData); +HRESULT WINAPI WHvGetVpciDeviceInterruptTarget(WHV_PARTITION_HANDLE Partition, UINT64 LogicalDeviceId, UINT32 Index, UINT32 MultiMessageNumber, WHV_VPCI_INTERRUPT_TARGET *Target, UINT32 TargetSizeInBytes, UINT32 *BytesWritten); +HRESULT WINAPI WHvCreateTrigger(WHV_PARTITION_HANDLE Partition, const WHV_TRIGGER_PARAMETERS *Parameters, WHV_TRIGGER_HANDLE *TriggerHandle, HANDLE *EventHandle); +HRESULT WINAPI WHvUpdateTriggerParameters(WHV_PARTITION_HANDLE Partition, const WHV_TRIGGER_PARAMETERS *Parameters, WHV_TRIGGER_HANDLE TriggerHandle); +HRESULT WINAPI WHvDeleteTrigger(WHV_PARTITION_HANDLE Partition, WHV_TRIGGER_HANDLE TriggerHandle); +HRESULT WINAPI WHvCreateNotificationPort(WHV_PARTITION_HANDLE Partition, const WHV_NOTIFICATION_PORT_PARAMETERS *Parameters, HANDLE EventHandle, WHV_NOTIFICATION_PORT_HANDLE *PortHandle); +HRESULT WINAPI WHvSetNotificationPortProperty(WHV_PARTITION_HANDLE Partition, WHV_NOTIFICATION_PORT_HANDLE PortHandle, WHV_NOTIFICATION_PORT_PROPERTY_CODE PropertyCode, WHV_NOTIFICATION_PORT_PROPERTY PropertyValue); +HRESULT WINAPI WHvDeleteNotificationPort(WHV_PARTITION_HANDLE Partition, WHV_NOTIFICATION_PORT_HANDLE PortHandle); +HRESULT WINAPI WHvPostVirtualProcessorSynicMessage(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, UINT32 SintIndex, const VOID *Message, UINT32 MessageSizeInBytes); +HRESULT WINAPI WHvGetVirtualProcessorCpuidOutput(WHV_PARTITION_HANDLE Partition, UINT32 VpIndex, UINT32 Eax, UINT32 Ecx, WHV_CPUID_OUTPUT *CpuidOutput); +HRESULT WINAPI WHvGetInterruptTargetVpSet(WHV_PARTITION_HANDLE Partition, UINT64 Destination, WHV_INTERRUPT_DESTINATION_MODE DestinationMode, UINT32 *TargetVps, UINT32 VpCount, UINT32 *TargetVpCount); +HRESULT WINAPI WHvStartPartitionMigration(WHV_PARTITION_HANDLE Partition, HANDLE *MigrationHandle); +HRESULT WHvCancelPartitionMigration(WHV_PARTITION_HANDLE Partition); +HRESULT WHvCompletePartitionMigration(WHV_PARTITION_HANDLE Partition); +HRESULT WINAPI WHvAcceptPartitionMigration(HANDLE MigrationHandle, WHV_PARTITION_HANDLE *Partition); #ifdef __cplusplus } -- 2.32.0
_______________________________________________ Mingw-w64-public mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/mingw-w64-public
