Segmentation.h File Reference

Functions for handling memory segmentations. More...

Go to the source code of this file.

Macros
#define	USE_DEFAULT_OS_GDT_AS_HOST_GDT   FALSE
	Whether the hypervisor should use the default OS's GDT as the host GDT in VMCS or not.
#define	HOST_GDT_DESCRIPTOR_COUNT   10
	Maximum number of entries in GDT.
#define	HOST_INTERRUPT_STACK_SIZE   4 * PAGE_SIZE
	Size of host interrupt stack.
#define	USE_INTERRUPT_STACK_TABLE   FALSE
	Use Interrupt Stack Table (IST1..IST7)

Functions
	_Success_ (return) BOOLEAN SegmentGetDescriptor(_In_ PUCHAR GdtBase
VOID	SegmentPrepareHostGdt (SEGMENT_DESCRIPTOR_32 *OsGdtBase, UINT16 OsGdtLimit, UINT16 TrSelector, UINT64 HostStack, SEGMENT_DESCRIPTOR_32 *AllocatedHostGdt, TASK_STATE_SEGMENT_64 *AllocatedHostTss)
	Initialize the host GDT.

Variables
_In_ UINT16	Selector
_In_ UINT16 _Out_ PVMX_SEGMENT_SELECTOR	SegmentSelector

Detailed Description

Functions for handling memory segmentations.

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.

Macro Definition Documentation

HOST_GDT_DESCRIPTOR_COUNT

#define HOST_GDT_DESCRIPTOR_COUNT   10

Maximum number of entries in GDT.

HOST_INTERRUPT_STACK_SIZE

#define HOST_INTERRUPT_STACK_SIZE   4 * PAGE_SIZE

Size of host interrupt stack.

USE_DEFAULT_OS_GDT_AS_HOST_GDT

#define USE_DEFAULT_OS_GDT_AS_HOST_GDT   FALSE

Whether the hypervisor should use the default OS's GDT as the host GDT in VMCS or not.

USE_INTERRUPT_STACK_TABLE

#define USE_INTERRUPT_STACK_TABLE   FALSE

Use Interrupt Stack Table (IST1..IST7)

Function Documentation

_Success_()

_Success_

(

return

)

SegmentPrepareHostGdt()

VOID SegmentPrepareHostGdt	(	SEGMENT_DESCRIPTOR_32 *	OsGdtBase,
		UINT16	OsGdtLimit,
		UINT16	TrSelector,
		UINT64	HostStack,
		SEGMENT_DESCRIPTOR_32 *	AllocatedHostGdt,
		TASK_STATE_SEGMENT_64 *	AllocatedHostTss )

Initialize the host GDT.

Parameters

OsGdtBase
OsGdtLimit
TrSelector
HostStack
AllocatedHostGdt
AllocatedHostTss

Returns

VOID

{
    //
    // Copy current OS GDT into host GDT
    // Note that the limit is the maximum addressable byte offset within the segment,
    // so the actual size of the GDT is limit + 1
    //
    RtlCopyBytes(AllocatedHostGdt, OsGdtBase, OsGdtLimit + 1);
 
    //
    // Make sure host TSS is empty
    //
    RtlZeroBytes(AllocatedHostTss, sizeof(TASK_STATE_SEGMENT_64));
 
#if USE_INTERRUPT_STACK_TABLE == TRUE
 
    UINT64 EndOfStack = 0;
 
    //
    // Setup TSS memory for host (same host stack is used for all interrupts and privilege levels)
    //
    EndOfStack = ((UINT64)HostStack + HOST_INTERRUPT_STACK_SIZE - 1);
    EndOfStack = ((UINT64)((ULONG_PTR)(EndOfStack) & ~(16 - 1)));
 
    LogDebugInfo("Host Interrupt Stack, from: %llx, to: %llx", HostStack, EndOfStack);
 
    AllocatedHostTss->Rsp0 = EndOfStack;
    AllocatedHostTss->Rsp1 = EndOfStack;
    AllocatedHostTss->Rsp2 = EndOfStack;
    AllocatedHostTss->Ist1 = EndOfStack;
    AllocatedHostTss->Ist2 = EndOfStack;
    AllocatedHostTss->Ist3 = EndOfStack;
    AllocatedHostTss->Ist4 = EndOfStack;
    AllocatedHostTss->Ist5 = EndOfStack;
    AllocatedHostTss->Ist6 = EndOfStack;
    AllocatedHostTss->Ist7 = EndOfStack;
 
#else
 
    UNREFERENCED_PARAMETER(HostStack);
 
#endif // USE_INTERRUPT_STACK_TABLE == TRUE
 
    //
    // Setup the TSS segment descriptor
    //
    SEGMENT_DESCRIPTOR_64 * GdtTssDesc = (SEGMENT_DESCRIPTOR_64 *)&AllocatedHostGdt[TrSelector];
 
    //
    // Point the TSS descriptor to our TSS
    //
    UINT64 Base                   = (UINT64)AllocatedHostTss;
    GdtTssDesc->BaseAddressLow    = (Base >> 00) & 0xFFFF;
    GdtTssDesc->BaseAddressMiddle = (Base >> 16) & 0xFF;
    GdtTssDesc->BaseAddressHigh   = (Base >> 24) & 0xFF;
    GdtTssDesc->BaseAddressUpper  = (Base >> 32) & 0xFFFFFFFF;
 
 
    // SEGMENT_SELECTOR HostCsSelector = {0, 0, 1};
    // SEGMENT_SELECTOR HostTrSelector = {0, 0, 2};
    //
    // //
    // // Setup the CS segment descriptor
    // //
    // SEGMENT_DESCRIPTOR_32 CsDesc    = AllocatedHostGdt[HostCsSelector.Index];
    // CsDesc.Type                     = SEGMENT_DESCRIPTOR_TYPE_CODE_EXECUTE_READ;
    // CsDesc.DescriptorType           = SEGMENT_DESCRIPTOR_TYPE_CODE_OR_DATA;
    // CsDesc.DescriptorPrivilegeLevel = 0;
    // CsDesc.Present                  = 1;
    // CsDesc.LongMode                 = 1;
    // CsDesc.DefaultBig               = 0;
    // CsDesc.Granularity              = 0;
    //
    // //
    // // Setup the TSS segment descriptor
    // //
    // SEGMENT_DESCRIPTOR_64 * TssDesc   = (SEGMENT_DESCRIPTOR_64 *)&AllocatedHostGdt[HostTrSelector.Index];
    // TssDesc->Type                     = SEGMENT_DESCRIPTOR_TYPE_TSS_BUSY;
    // TssDesc->DescriptorType           = SEGMENT_DESCRIPTOR_TYPE_SYSTEM;
    // TssDesc->DescriptorPrivilegeLevel = 0;
    // TssDesc->Present                  = 1;
    // TssDesc->Granularity              = 0;
    // TssDesc->SegmentLimitLow          = 0x67;
    // TssDesc->SegmentLimitHigh         = 0;
    //
    // //
    // // Point the TSS descriptor to our TSS
    // //
    // UINT64 Base                = (UINT64)AllocatedHostTss;
    // TssDesc->BaseAddressLow    = (Base >> 00) & 0xFFFF;
    // TssDesc->BaseAddressMiddle = (Base >> 16) & 0xFF;
    // TssDesc->BaseAddressHigh   = (Base >> 24) & 0xFF;
    // TssDesc->BaseAddressUpper  = (Base >> 32) & 0xFFFFFFFF;
}

Variable Documentation

SegmentSelector

_In_ UINT16 _Out_ PVMX_SEGMENT_SELECTOR SegmentSelector

Selector

_In_ UINT16 Selector