PoolManager.h File Reference

Headers of pool manager. More...

Go to the source code of this file.

Classes
struct	_POOL_TABLE
	Table of holding pools detail structure. More...
struct	_REQUEST_NEW_ALLOCATION
	Manage the requests for new allocations. More...

Macros
#define	MaximumRequestsQueueDepth   300
	Maximum Pool Requests (while not allocated).
#define	NumberOfPreAllocatedBuffers   10

Typedefs
typedef struct _POOL_TABLE	POOL_TABLE
	Table of holding pools detail structure.
typedef struct _POOL_TABLE *	PPOOL_TABLE
typedef struct _REQUEST_NEW_ALLOCATION	REQUEST_NEW_ALLOCATION
	Manage the requests for new allocations.
typedef struct _REQUEST_NEW_ALLOCATION *	PREQUEST_NEW_ALLOCATION

Functions
BOOLEAN	PoolManagerInitialize ()
	Initializes the pool manager.
VOID	PoolManagerUninitialize ()
	Uninitialize the pool manager (free the buffers, etc.).
VOID	PoolManagerShowPreAllocatedPools ()
	Shows list of pre-allocated pools available (used for debugging purposes).
BOOLEAN	PoolManagerCheckAndPerformAllocationAndDeallocation ()
	This function performs allocations from VMX non-root based on g_RequestNewAllocation.
BOOLEAN	PoolManagerRequestAllocation (SIZE_T Size, UINT32 Count, POOL_ALLOCATION_INTENTION Intention)
	Request to allocate new buffers.
UINT64	PoolManagerRequestPool (POOL_ALLOCATION_INTENTION Intention, BOOLEAN RequestNewPool, UINT32 Size)
	This function should be called from vmx-root in order to get a pool from the list.
BOOLEAN	PoolManagerFreePool (UINT64 AddressToFree)
	This function set a pool flag to be freed, and it will be freed on the next IOCTL when it's safe to remove.

Variables
REQUEST_NEW_ALLOCATION *	g_RequestNewAllocation
	If sb wants allocation from vmx root, adds it's request to this structure.
volatile LONG	LockForRequestAllocation
	Request allocation Spinlock.
volatile LONG	LockForReadingPool
	Spinlock for reading pool.
BOOLEAN	g_PoolManagerInitialized
	Pool manager memory allocator initialized.
BOOLEAN	g_IsNewRequestForAllocationReceived
	We set it when there is a new allocation.
BOOLEAN	g_IsNewRequestForDeAllocation
	We set it when there is a new allocation.
LIST_ENTRY	g_ListOfAllocatedPoolsHead
	Create a list from all pools.

Detailed Description

Headers of pool manager.

Author

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

Version

0.1

Date

2020-04-11

Copyright

This project is released under the GNU Public License v3.

Macro Definition Documentation

MaximumRequestsQueueDepth

#define MaximumRequestsQueueDepth   300

Maximum Pool Requests (while not allocated).

NumberOfPreAllocatedBuffers

#define NumberOfPreAllocatedBuffers   10

Typedef Documentation

POOL_TABLE

typedef struct _POOL_TABLE POOL_TABLE

Table of holding pools detail structure.

PPOOL_TABLE

typedef struct _POOL_TABLE * PPOOL_TABLE

PREQUEST_NEW_ALLOCATION

typedef struct _REQUEST_NEW_ALLOCATION * PREQUEST_NEW_ALLOCATION

REQUEST_NEW_ALLOCATION

typedef struct _REQUEST_NEW_ALLOCATION REQUEST_NEW_ALLOCATION

Manage the requests for new allocations.

Function Documentation

PoolManagerCheckAndPerformAllocationAndDeallocation()

BOOLEAN PoolManagerCheckAndPerformAllocationAndDeallocation

(

)

This function performs allocations from VMX non-root based on g_RequestNewAllocation.

Returns

BOOLEAN If the pool manager allocates buffer or there was no buffer to allocate then it returns true, if there was any error then it returns false

{
    BOOLEAN Result = TRUE;
 
    //
    // Make sure we're on vmx non-root and also we have new allocation
    // and also pool manager is initialized, otherwise we shouldn't allocate or deallocate
    //
    if (!g_PoolManagerInitialized || VmFuncVmxGetCurrentExecutionMode() == TRUE)
    {
        //
        // allocation's can't be done from vmx root
        // or pool manager is not initialized yet
        //
        return FALSE;
    }
 
    //
    // Make sure paging works properly
    //
    PAGED_CODE();
 
    SpinlockLock(&LockForReadingPool);
 
    //
    // Check for new allocation
    //
    if (g_IsNewRequestForAllocationReceived)
    {
        for (SIZE_T i = 0; i < MaximumRequestsQueueDepth; i++)
        {
            REQUEST_NEW_ALLOCATION * CurrentItem = &g_RequestNewAllocation[i];
 
            if (CurrentItem->Size != 0)
            {
                Result = PoolManagerAllocateAndAddToPoolTable(CurrentItem->Size,
                                                              CurrentItem->Count,
                                                              CurrentItem->Intention);
 
                //
                // Free the data for future use
                //
                CurrentItem->Count     = 0;
                CurrentItem->Intention = 0;
                CurrentItem->Size      = 0;
            }
        }
    }
 
    //
    // Check for deallocation
    //
    if (g_IsNewRequestForDeAllocation)
    {
        PLIST_ENTRY Link = g_ListOfAllocatedPoolsHead.Flink;
 
        while (Link != &g_ListOfAllocatedPoolsHead)
        {
            PLIST_ENTRY Next = Link->Flink;
 
            //
            // Get the head of the record
            //
            PPOOL_TABLE PoolTable = (PPOOL_TABLE)CONTAINING_RECORD(Link, POOL_TABLE, PoolsList);
 
            //
            // Check whether this pool should be freed or not and
            // also check whether it's already freed or not
            //
            if (PoolTable->ShouldBeFreed && !PoolTable->AlreadyFreed)
            {
                //
                // Set the flag to indicate that we freed
                //
                PoolTable->AlreadyFreed = TRUE;
 
                //
                // This item should be freed
                //
                PlatformMemFreePool((PVOID)PoolTable->Address);
 
                //
                // Now we should remove the entry from the g_ListOfAllocatedPoolsHead
                //
                RemoveEntryList(Link);
 
                //
                // Free the structure pool
                //
                PlatformMemFreePool(PoolTable);
            }
 
            Link = Next;
        }
    }
 
    //
    // All allocation and deallocation are performed
    //
    g_IsNewRequestForDeAllocation       = FALSE;
    g_IsNewRequestForAllocationReceived = FALSE;
 
    SpinlockUnlock(&LockForReadingPool);
 
    return Result;
}

PoolManagerFreePool()

BOOLEAN PoolManagerFreePool

(

UINT64

AddressToFree

)

This function set a pool flag to be freed, and it will be freed on the next IOCTL when it's safe to remove.

Parameters

AddressToFree

The pool address that was previously obtained from the pool manager

Returns

BOOLEAN If the address was already in the list of allocated pools by pool manager then it returns TRUE; otherwise, FALSE

{
    PLIST_ENTRY ListTemp = 0;
    BOOLEAN     Result   = FALSE;
    ListTemp             = &g_ListOfAllocatedPoolsHead;
 
    SpinlockLock(&LockForReadingPool);
 
    while (&g_ListOfAllocatedPoolsHead != ListTemp->Flink)
    {
        ListTemp = ListTemp->Flink;
 
        //
        // Get the head of the record
        //
        PPOOL_TABLE PoolTable = (PPOOL_TABLE)CONTAINING_RECORD(ListTemp, POOL_TABLE, PoolsList);
 
        if (PoolTable->Address == AddressToFree)
        {
            //
            // We found an entry that matched the detailed from
            // previously allocated pools
            //
            PoolTable->ShouldBeFreed = TRUE;
            Result                   = TRUE;
 
            g_IsNewRequestForDeAllocation = TRUE;
            break;
        }
    }
 
    SpinlockUnlock(&LockForReadingPool);
    return Result;
}

PoolManagerInitialize()

BOOLEAN PoolManagerInitialize

(

)

Initializes the pool manager.

Returns

BOOLEAN

{
    //
    // Allocate global requesting variable
    //
    SIZE_T BufferSize = MaximumRequestsQueueDepth * sizeof(REQUEST_NEW_ALLOCATION);
    if (!PlmgrAllocateRequestNewAllocation(BufferSize))
    {
        LogError("Err, insufficient memory");
        return FALSE;
    }
 
    //
    // Initialize list head
    //
    InitializeListHead(&g_ListOfAllocatedPoolsHead);
 
    //
    // Nothing to deallocate or allocate at the beginning
    //
    g_IsNewRequestForDeAllocation       = FALSE;
    g_IsNewRequestForAllocationReceived = FALSE;
 
    //
    // Memory allocator is initialized
    //
    g_PoolManagerInitialized = TRUE;
 
    //
    // Initialized successfully
    //
    return TRUE;
}

PoolManagerRequestAllocation()

BOOLEAN PoolManagerRequestAllocation	(	SIZE_T	Size,
		UINT32	Count,
		POOL_ALLOCATION_INTENTION	Intention )

Request to allocate new buffers.

Parameters

Size	Request new buffer to allocate
Count	Count of chunks
Intention	The intention of chunks (buffer tag)

Returns

BOOLEAN If the request is save it returns true otherwise it returns false

{
    BOOLEAN FoundAPlace = FALSE;
 
    //
    // ******** We check to find a free place to store ********
    //
 
    SpinlockLock(&LockForRequestAllocation);
 
    for (SIZE_T i = 0; i < MaximumRequestsQueueDepth; i++)
    {
        REQUEST_NEW_ALLOCATION * CurrentItem = &g_RequestNewAllocation[i];
 
        if (CurrentItem->Size == 0)
        {
            CurrentItem->Count     = Count;
            CurrentItem->Intention = Intention;
            CurrentItem->Size      = Size;
 
            FoundAPlace = TRUE;
 
            break;
        }
    }
 
    if (!FoundAPlace)
    {
        SpinlockUnlock(&LockForRequestAllocation);
        return FALSE;
    }
 
    //
    // Signals to show that we have new allocations
    //
    g_IsNewRequestForAllocationReceived = TRUE;
 
    SpinlockUnlock(&LockForRequestAllocation);
    return TRUE;
}

PoolManagerRequestPool()

UINT64 PoolManagerRequestPool	(	POOL_ALLOCATION_INTENTION	Intention,
		BOOLEAN	RequestNewPool,
		UINT32	Size )

This function should be called from vmx-root in order to get a pool from the list.

If RequestNewPool is TRUE then Size is used, otherwise Size is useless Note : Most of the times this function called from vmx root but not all the time

Parameters

Intention	The intention why we need this pool for (buffer tag)
RequestNewPool	Create a request to allocate a new pool with the same size, next time that it's safe to allocate (this way we never ran out of pools for this "Intention")
Size	If the RequestNewPool is true the we should specify a size for the new pool

Returns

UINT64 Returns a pool address or returns null if there was an error

{
    UINT64 Address = 0;
 
    ScopedSpinlock(
        LockForReadingPool,
        LIST_FOR_EACH_LINK(g_ListOfAllocatedPoolsHead, POOL_TABLE, PoolsList, PoolTable) {
            if (PoolTable->Intention == Intention && PoolTable->IsBusy == FALSE)
            {
                PoolTable->IsBusy = TRUE;
                Address           = PoolTable->Address;
                break;
            }
        });
 
    //
    // Check if we need additional pools e.g another pool or the pool
    // will be available for the next use blah blah
    //
    if (RequestNewPool)
    {
        PoolManagerRequestAllocation(Size, 1, Intention);
    }
 
    //
    // return Address might be null indicating there is no valid pools
    //
    return Address;
}

PoolManagerShowPreAllocatedPools()

VOID PoolManagerShowPreAllocatedPools

(

)

Shows list of pre-allocated pools available (used for debugging purposes).

Returns

VOID

{
    PLIST_ENTRY ListTemp = 0;
    ListTemp             = &g_ListOfAllocatedPoolsHead;
 
    while (&g_ListOfAllocatedPoolsHead != ListTemp->Flink)
    {
        ListTemp = ListTemp->Flink;
 
        //
        // Get the head of the record
        //
        PPOOL_TABLE PoolTable = (PPOOL_TABLE)CONTAINING_RECORD(ListTemp, POOL_TABLE, PoolsList);
 
        LogInfo("Pool details, Pool intention: %x | Pool address: %llx | Pool state: %s | Should be freed: %s | Already freed: %s\n",
                PoolTable->Intention,
                PoolTable->Address,
                PoolTable->IsBusy ? "used" : "free",
                PoolTable->ShouldBeFreed ? "true" : "false",
                PoolTable->AlreadyFreed ? "true" : "false");
    }
}

PoolManagerUninitialize()

VOID PoolManagerUninitialize

(

)

Uninitialize the pool manager (free the buffers, etc.).

Returns

VOID

{
    PLIST_ENTRY Link;
 
    //
    // Pool manager is not initialized anymore
    //
    g_PoolManagerInitialized = FALSE;
 
    SpinlockLock(&LockForReadingPool);
 
    Link = g_ListOfAllocatedPoolsHead.Flink;
 
    while (Link != &g_ListOfAllocatedPoolsHead)
    {
        PLIST_ENTRY Next = Link->Flink;
 
        //
        // Get the head of the record
        //
        PPOOL_TABLE PoolTable = (PPOOL_TABLE)CONTAINING_RECORD(Link, POOL_TABLE, PoolsList);
 
        //
        // Free the alloocated buffer (if not already changed)
        //
        if (!PoolTable->AlreadyFreed)
        {
            PlatformMemFreePool((PVOID)PoolTable->Address);
        }
 
        //
        // Unlink the PoolTable
        //
        RemoveEntryList(Link);
 
        //
        // Free the record itself
        //
        PlatformMemFreePool(PoolTable);
 
        Link = Next;
    }
 
    InitializeListHead(&g_ListOfAllocatedPoolsHead);
    g_IsNewRequestForDeAllocation       = FALSE;
    g_IsNewRequestForAllocationReceived = FALSE;
 
    SpinlockUnlock(&LockForReadingPool);
 
    PlmgrFreeRequestNewAllocation();
}

Variable Documentation

g_IsNewRequestForAllocationReceived

BOOLEAN g_IsNewRequestForAllocationReceived

We set it when there is a new allocation.

g_IsNewRequestForDeAllocation

BOOLEAN g_IsNewRequestForDeAllocation

We set it when there is a new allocation.

g_ListOfAllocatedPoolsHead

LIST_ENTRY g_ListOfAllocatedPoolsHead

Create a list from all pools.

g_PoolManagerInitialized

BOOLEAN g_PoolManagerInitialized

Pool manager memory allocator initialized.

g_RequestNewAllocation

REQUEST_NEW_ALLOCATION* g_RequestNewAllocation

If sb wants allocation from vmx root, adds it's request to this structure.

LockForReadingPool

volatile LONG LockForReadingPool

Spinlock for reading pool.

LockForRequestAllocation

volatile LONG LockForRequestAllocation

Request allocation Spinlock.