VmxRegions.h File Reference

Headers for implement allocations for VMX Regions (VMXON Region, VMCS, MSR Bitmap and etc.) More...

Go to the source code of this file.

Functions
	_Success_ (return !=FALSE) BOOLEAN VmxAllocateVmxonRegion(_Out_ VIRTUAL_MACHINE_STATE *VCpu)
BOOLEAN	VmxAllocateVmmStack (_Inout_ VIRTUAL_MACHINE_STATE *VCpu)
	Allocate VMM Stack.
BOOLEAN	VmxAllocateMsrBitmap (_Inout_ VIRTUAL_MACHINE_STATE *VCpu)
	Allocate a buffer for Msr Bitmap.
BOOLEAN	VmxAllocateIoBitmaps (_Inout_ VIRTUAL_MACHINE_STATE *VCpu)
	Allocate a buffer for I/O Bitmap.
UINT64 *	VmxAllocateInvalidMsrBimap ()
	Allocates a buffer and tests for the MSRs that cause #GP.
BOOLEAN	VmxAllocateHostIdt (_Inout_ VIRTUAL_MACHINE_STATE *VCpu)
	Allocate a buffer for host IDT.
BOOLEAN	VmxAllocateHostGdt (_Inout_ VIRTUAL_MACHINE_STATE *VCpu)
	Allocate a buffer for host GDT.
BOOLEAN	VmxAllocateHostTss (_Inout_ VIRTUAL_MACHINE_STATE *VCpu)
	Allocate a buffer for host TSS.
BOOLEAN	VmxAllocateHostInterruptStack (_Inout_ VIRTUAL_MACHINE_STATE *VCpu)
	Allocate a buffer for host interrupt stack.

Detailed Description

Headers for implement allocations for VMX Regions (VMXON Region, VMCS, MSR Bitmap and etc.)

Author

Sina Karvandi (sina@.nosp@m.hype.nosp@m.rdbg..nosp@m.org)

Version

0.9

Date

2024-06-03

Copyright

This project is released under the GNU Public License v3.

Function Documentation

_Success_()

_Success_

(

return !

= FALSE

)

VmxAllocateHostGdt()

BOOLEAN VmxAllocateHostGdt

(

_Inout_ VIRTUAL_MACHINE_STATE *

VCpu

)

Allocate a buffer for host GDT.

Parameters

VCpu

Returns

BOOLEAN Returns true if allocation was successful otherwise returns false

{
    UINT32 GdtSize = HOST_GDT_DESCRIPTOR_COUNT * sizeof(SEGMENT_DESCRIPTOR_64);
 
    //
    // Make sure the memory is aligned
    //
    if (PAGE_SIZE > GdtSize)
    {
        GdtSize = PAGE_SIZE;
    }
 
    //
    // Allocate aligned memory for host GDT
    //
    VCpu->HostGdt = (UINT64)PlatformMemAllocateZeroedNonPagedPool(GdtSize); // should be aligned
 
    if (VCpu->HostGdt == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating host GDT");
        return FALSE;
    }
 
    LogDebugInfo("Host GDT virtual address : 0x%llx", VCpu->HostGdt);
 
    return TRUE;
}

VmxAllocateHostIdt()

BOOLEAN VmxAllocateHostIdt

(

_Inout_ VIRTUAL_MACHINE_STATE *

VCpu

)

Allocate a buffer for host IDT.

Parameters

VCpu

Returns

BOOLEAN Returns true if allocation was successful otherwise returns false

{
    UINT32 IdtSize = HOST_IDT_DESCRIPTOR_COUNT * sizeof(SEGMENT_DESCRIPTOR_INTERRUPT_GATE_64);
 
    //
    // Make sure the memory is aligned
    //
    if (PAGE_SIZE > IdtSize)
    {
        IdtSize = PAGE_SIZE;
    }
 
    //
    // Allocate aligned memory for host IDT
    //
    VCpu->HostIdt = (UINT64)PlatformMemAllocateZeroedNonPagedPool(IdtSize); // should be aligned
 
    if (VCpu->HostIdt == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating host IDT");
        return FALSE;
    }
 
    LogDebugInfo("Host IDT virtual address : 0x%llx", VCpu->HostIdt);
 
    return TRUE;
}

VmxAllocateHostInterruptStack()

BOOLEAN VmxAllocateHostInterruptStack

(

_Inout_ VIRTUAL_MACHINE_STATE *

VCpu

)

Allocate a buffer for host interrupt stack.

Parameters

VCpu

Returns

BOOLEAN Returns true if allocation was successful otherwise returns false

{
    VCpu->HostInterruptStack = (UINT64)PlatformMemAllocateZeroedNonPagedPool(HOST_INTERRUPT_STACK_SIZE);
 
    if (VCpu->HostInterruptStack == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating host interrupt stack");
        return FALSE;
    }
 
    LogDebugInfo("Host interrupt stack virtual address : 0x%llx", VCpu->HostInterruptStack);
 
    return TRUE;
}

VmxAllocateHostTss()

BOOLEAN VmxAllocateHostTss

(

_Inout_ VIRTUAL_MACHINE_STATE *

VCpu

)

Allocate a buffer for host TSS.

Parameters

VCpu

Returns

BOOLEAN Returns true if allocation was successful otherwise returns false

{
    UINT32 TssSize = PAGE_SIZE; // Make sure the memory is aligned
 
    //
    // Allocate aligned memory for host TSS
    //
    VCpu->HostTss = (UINT64)PlatformMemAllocateZeroedNonPagedPool(TssSize); // should be aligned
 
    if (VCpu->HostTss == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating host TSS");
        return FALSE;
    }
 
    LogDebugInfo("Host TSS virtual address : 0x%llx", VCpu->HostTss);
 
    return TRUE;
}

VmxAllocateInvalidMsrBimap()

UINT64 * VmxAllocateInvalidMsrBimap

(

)

Allocates a buffer and tests for the MSRs that cause #GP.

Returns

UINT64 Allocated buffer for MSR Bitmap

{
    UINT64 * InvalidMsrBitmap;
 
    InvalidMsrBitmap = PlatformMemAllocateZeroedNonPagedPool(0x1000 / 0x8);
 
    if (InvalidMsrBitmap == NULL)
    {
        return NULL;
    }
 
    for (UINT32 i = 0; i < 0x1000; ++i)
    {
        __try
        {
            __readmsr(i);
        }
        __except (EXCEPTION_EXECUTE_HANDLER)
        {
            SetBit(i, (unsigned long *)InvalidMsrBitmap);
        }
    }
 
    return InvalidMsrBitmap;
}

VmxAllocateIoBitmaps()

BOOLEAN VmxAllocateIoBitmaps

(

_Inout_ VIRTUAL_MACHINE_STATE *

VCpu

)

Allocate a buffer for I/O Bitmap.

Parameters

VCpu

Returns

BOOLEAN Returns true if allocation was successful otherwise returns false

{
    //
    // Allocate memory for I/O Bitmap (A)
    //
    VCpu->IoBitmapVirtualAddressA = (UINT64)PlatformMemAllocateZeroedNonPagedPool(PAGE_SIZE); // should be aligned
 
    if (VCpu->IoBitmapVirtualAddressA == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating I/O Bitmaps A");
        return FALSE;
    }
 
    VCpu->IoBitmapPhysicalAddressA = VirtualAddressToPhysicalAddress((PVOID)VCpu->IoBitmapVirtualAddressA);
 
    LogDebugInfo("I/O Bitmap A Virtual Address  : 0x%llx", VCpu->IoBitmapVirtualAddressA);
    LogDebugInfo("I/O Bitmap A Physical Address : 0x%llx", VCpu->IoBitmapPhysicalAddressA);
 
    //
    // Allocate memory for I/O Bitmap (B)
    //
    VCpu->IoBitmapVirtualAddressB = (UINT64)PlatformMemAllocateZeroedNonPagedPool(PAGE_SIZE); // should be aligned
 
    if (VCpu->IoBitmapVirtualAddressB == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating I/O Bitmaps B");
        return FALSE;
    }
 
    VCpu->IoBitmapPhysicalAddressB = VirtualAddressToPhysicalAddress((PVOID)VCpu->IoBitmapVirtualAddressB);
 
    LogDebugInfo("I/O Bitmap B virtual address  : 0x%llx", VCpu->IoBitmapVirtualAddressB);
    LogDebugInfo("I/O Bitmap B physical address : 0x%llx", VCpu->IoBitmapPhysicalAddressB);
 
    return TRUE;
}

VmxAllocateMsrBitmap()

BOOLEAN VmxAllocateMsrBitmap

(

_Inout_ VIRTUAL_MACHINE_STATE *

VCpu

)

Allocate a buffer for Msr Bitmap.

Parameters

VCpu	The virtual processor's state

Returns

BOOLEAN Returns true if allocation was successful otherwise returns false

{
    //
    // Allocate memory for MSR Bitmap
    // Should be aligned
    //
    VCpu->MsrBitmapVirtualAddress = (UINT64)PlatformMemAllocateZeroedNonPagedPool(PAGE_SIZE);
 
    if (VCpu->MsrBitmapVirtualAddress == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating MSR Bitmaps");
        return FALSE;
    }
 
    VCpu->MsrBitmapPhysicalAddress = VirtualAddressToPhysicalAddress((PVOID)VCpu->MsrBitmapVirtualAddress);
 
    LogDebugInfo("MSR Bitmap virtual address  : 0x%llx", VCpu->MsrBitmapVirtualAddress);
    LogDebugInfo("MSR Bitmap physical address : 0x%llx", VCpu->MsrBitmapPhysicalAddress);
 
    return TRUE;
}

VmxAllocateVmmStack()

BOOLEAN VmxAllocateVmmStack

(

_Inout_ VIRTUAL_MACHINE_STATE *

VCpu

)

Allocate VMM Stack.

Parameters

VCpu	The virtual processor's state

Returns

BOOLEAN Returns true if allocation was successful otherwise returns false

{
    //
    // Allocate stack for the VM Exit Handler
    //
    VCpu->VmmStack = (UINT64)PlatformMemAllocateZeroedNonPagedPool(VMM_STACK_SIZE);
 
    if (VCpu->VmmStack == NULL64_ZERO)
    {
        LogError("Err, insufficient memory in allocating vmm stack");
        return FALSE;
    }
 
    LogDebugInfo("VMM Stack for logical processor : 0x%llx", VCpu->VmmStack);
 
    return TRUE;
}