ExPools.c File Reference

#include <kmt_test.h>
#include <debug.h>

Include dependency graph for ExPools.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	TAG_POOLTEST   'tstP'
#define	BASE_POOL_TYPE_MASK   1
#define	QUOTA_POOL_MASK   8

Functions
static LONG	GetRefCount (_In_ PVOID Object)
static VOID	PoolsTest (VOID)
static VOID	PoolsCorruption (VOID)
static VOID	TestPoolTags (VOID)
static VOID	TestPoolQuota (VOID)
static VOID	TestBigPoolExpansion (VOID)
	START_TEST (ExPools)

Macro Definition Documentation

BASE_POOL_TYPE_MASK

#define BASE_POOL_TYPE_MASK   1

Definition at line 15 of file ExPools.c.

NDEBUG

#define NDEBUG

Definition at line 10 of file ExPools.c.

QUOTA_POOL_MASK

#define QUOTA_POOL_MASK   8

Definition at line 16 of file ExPools.c.

TAG_POOLTEST

#define TAG_POOLTEST   'tstP'

Definition at line 13 of file ExPools.c.

Function Documentation

GetRefCount()

static LONG GetRefCount ( _In_ PVOID  Object )

static

Definition at line 20 of file ExPools.c.

{
    POBJECT_HEADER Header = OBJECT_TO_OBJECT_HEADER(Object);
    return Header->PointerCount;
}

Referenced by TestPoolQuota().

PoolsCorruption()

static VOID PoolsCorruption ( VOID  )

static

Definition at line 112 of file ExPools.c.

{
    PULONG Ptr;
    ULONG AllocSize;
 
    // start with non-paged pool
    AllocSize = 4096 + 0x10;
    Ptr = ExAllocatePoolWithTag(NonPagedPool, AllocSize, TAG_POOLTEST);
 
    // touch all bytes, it shouldn't cause an exception
    RtlZeroMemory(Ptr, AllocSize);
 
/* TODO: These fail because accessing invalid memory doesn't necessarily
         cause an access violation */
#ifdef THIS_DOESNT_WORK
    // test buffer overrun, right after our allocation ends
    _SEH2_TRY
    {
        TestPtr = (PULONG)((PUCHAR)Ptr + AllocSize);
        //Ptr[4] = 0xd33dbeef;
        *TestPtr = 0xd33dbeef;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Get the status */
        Status = _SEH2_GetExceptionCode();
    } _SEH2_END;
 
    ok(Status == STATUS_ACCESS_VIOLATION, "Exception should occur, but got Status 0x%08lX\n", Status);
 
    // test overrun in a distant byte range, but within 4096KB
    _SEH2_TRY
    {
        Ptr[2020] = 0xdeadb33f;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Get the status */
        Status = _SEH2_GetExceptionCode();
    } _SEH2_END;
 
    ok(Status == STATUS_ACCESS_VIOLATION, "Exception should occur, but got Status 0x%08lX\n", Status);
#endif
 
    // free the pool
    ExFreePoolWithTag(Ptr, TAG_POOLTEST);
}

Referenced by START_TEST().

PoolsTest()

static VOID PoolsTest ( VOID  )

static

Definition at line 27 of file ExPools.c.

{
    PVOID Ptr;
    ULONG AllocSize, i, AllocNumber;
    PVOID *Allocs;
 
    // Stress-test nonpaged pool
    for (i=1; i<10000; i++)
    {
        // make up some increasing, a bit irregular size
        AllocSize = i*10;
 
        if (i % 10)
            AllocSize++;
 
        if (i % 25)
            AllocSize += 13;
 
        // start with non-paged pool
        Ptr = ExAllocatePoolWithTag(NonPagedPool, AllocSize, TAG_POOLTEST);
 
        // it may fail due to no-memory condition
        if (!Ptr) break;
 
        // try to fully fill it
        RtlFillMemory(Ptr, AllocSize, 0xAB);
 
        // free it
        ExFreePoolWithTag(Ptr, TAG_POOLTEST);
    }
 
    // now paged one
    for (i=1; i<10000; i++)
    {
        // make up some increasing, a bit irregular size
        AllocSize = i*50;
 
        if (i % 10)
            AllocSize++;
 
        if (i % 25)
            AllocSize += 13;
 
        // start with non-paged pool
        Ptr = ExAllocatePoolWithTag(PagedPool, AllocSize, TAG_POOLTEST);
 
        // it may fail due to no-memory condition
        if (!Ptr) break;
 
        // try to fully fill it
        RtlFillMemory(Ptr, AllocSize, 0xAB);
 
        // free it
        ExFreePoolWithTag(Ptr, TAG_POOLTEST);
    }
 
    // test super-big allocations
    /*AllocSize = 2UL * 1024 * 1024 * 1024;
    Ptr = ExAllocatePoolWithTag(NonPagedPool, AllocSize, TAG_POOLTEST);
    ok(Ptr == NULL, "Allocating 2Gb of nonpaged pool should fail\n");
 
    Ptr = ExAllocatePoolWithTag(PagedPool, AllocSize, TAG_POOLTEST);
    ok(Ptr == NULL, "Allocating 2Gb of paged pool should fail\n");*/
 
    // now test allocating lots of small/medium blocks
    AllocNumber = 100000;
    Allocs = ExAllocatePoolWithTag(PagedPool, sizeof(*Allocs) * AllocNumber, TAG_POOLTEST);
 
    // alloc blocks
    for (i=0; i<AllocNumber; i++)
    {
        AllocSize = 42;
        Allocs[i] = ExAllocatePoolWithTag(NonPagedPool, AllocSize, TAG_POOLTEST);
    }
 
    // now free them
    for (i=0; i<AllocNumber; i++)
    {
        ExFreePoolWithTag(Allocs[i], TAG_POOLTEST);
    }
 
 
    ExFreePoolWithTag(Allocs, TAG_POOLTEST);
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

ExPools

)

Definition at line 308 of file ExPools.c.

{
    PoolsTest();
    PoolsCorruption();
    TestPoolTags();
    TestPoolQuota();
    TestBigPoolExpansion();
}

TestBigPoolExpansion()

static VOID TestBigPoolExpansion ( VOID  )

static

Definition at line 269 of file ExPools.c.

{
    POOL_TYPE PoolType;
    PVOID *BigAllocations;
    const ULONG MaxAllocations = 1024 * 128;
    ULONG NumAllocations;
 
    for (PoolType = NonPagedPool; PoolType <= PagedPool; PoolType++)
    {
        BigAllocations = ExAllocatePoolWithTag(PoolType,
                                               MaxAllocations * sizeof(*BigAllocations),
                                               'ABmK');
 
        /* Allocate a lot of pages (== big pool allocations) */
        for (NumAllocations = 0; NumAllocations < MaxAllocations; NumAllocations++)
        {
            BigAllocations[NumAllocations] = ExAllocatePoolWithTag(PoolType,
                                                                   PAGE_SIZE,
                                                                   'aPmK');
            if (BigAllocations[NumAllocations] == NULL)
            {
                NumAllocations--;
                break;
            }
        }
 
        trace("Got %lu allocations for PoolType %d\n", NumAllocations, PoolType);
 
        /* Free them */
        for (; NumAllocations < MaxAllocations; NumAllocations--)
        {
            ASSERT(BigAllocations[NumAllocations] != NULL);
            ExFreePoolWithTag(BigAllocations[NumAllocations],
                              'aPmK');
        }
        ExFreePoolWithTag(BigAllocations, 'ABmK');
    }
}

Referenced by START_TEST().

TestPoolQuota()

static VOID TestPoolQuota ( VOID  )

static

Definition at line 189 of file ExPools.c.

{
    PEPROCESS Process = PsGetCurrentProcess();
    PEPROCESS StoredProcess;
    PVOID Memory;
    LONG InitialRefCount;
    LONG RefCount;
    USHORT PoolType;
 
    InitialRefCount = GetRefCount(Process);
 
    /* We get some memory from this function, and it's properly aligned.
     * Also, it takes a reference to the process, and releases it on free */
    Memory = ExAllocatePoolWithQuotaTag(PagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
                                        sizeof(LIST_ENTRY),
                                        'tQmK');
    ok(Memory != NULL, "ExAllocatePoolWithQuotaTag returned NULL\n");
    if (!skip(Memory != NULL, "No memory\n"))
    {
        ok((ULONG_PTR)Memory % sizeof(LIST_ENTRY) == 0,
           "Allocation %p is badly aligned\n",
           Memory);
        RefCount = GetRefCount(Process);
        ok_eq_long(RefCount, InitialRefCount + 1);
 
        /* A pointer to the process is found right before the next pool header */
        StoredProcess = ((PVOID *)((ULONG_PTR)Memory + 2 * sizeof(LIST_ENTRY)))[-1];
        ok_eq_pointer(StoredProcess, Process);
 
        /* Pool type should have QUOTA_POOL_MASK set */
        PoolType = KmtGetPoolType(Memory);
        ok(PoolType != 0, "PoolType is 0\n");
        PoolType--;
        ok(PoolType & QUOTA_POOL_MASK, "PoolType = %x\n", PoolType);
        ok((PoolType & BASE_POOL_TYPE_MASK) == PagedPool, "PoolType = %x\n", PoolType);
 
        ExFreePoolWithTag(Memory, 'tQmK');
        RefCount = GetRefCount(Process);
        ok_eq_long(RefCount, InitialRefCount);
    }
 
    /* Large allocations are page-aligned, don't reference the process */
    Memory = ExAllocatePoolWithQuotaTag(PagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
                                        PAGE_SIZE,
                                        'tQmK');
    ok(Memory != NULL, "ExAllocatePoolWithQuotaTag returned NULL\n");
    if (!skip(Memory != NULL, "No memory\n"))
    {
        ok((ULONG_PTR)Memory % PAGE_SIZE == 0,
           "Allocation %p is badly aligned\n",
           Memory);
        RefCount = GetRefCount(Process);
        ok_eq_long(RefCount, InitialRefCount);
        ExFreePoolWithTag(Memory, 'tQmK');
        RefCount = GetRefCount(Process);
        ok_eq_long(RefCount, InitialRefCount);
    }
 
    /* Function raises by default */
    KmtStartSeh()
        Memory = ExAllocatePoolWithQuotaTag(PagedPool,
                                            0x7FFFFFFF,
                                            'tQmK');
        if (Memory)
            ExFreePoolWithTag(Memory, 'tQmK');
    KmtEndSeh(STATUS_INSUFFICIENT_RESOURCES);
 
    /* Function returns NULL with POOL_QUOTA_FAIL_INSTEAD_OF_RAISE */
    KmtStartSeh()
        Memory = ExAllocatePoolWithQuotaTag(PagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
                                            0x7FFFFFFF,
                                            'tQmK');
        ok(Memory == NULL, "Successfully got 2GB block: %p\n", Memory);
        if (Memory)
            ExFreePoolWithTag(Memory, 'tQmK');
    KmtEndSeh(STATUS_SUCCESS);
}

Referenced by START_TEST().

TestPoolTags()

static VOID TestPoolTags ( VOID  )

static

Definition at line 162 of file ExPools.c.

{
    PVOID Memory;
 
    Memory = ExAllocatePoolWithTag(PagedPool, 8, 'MyTa');
    ok_eq_tag(KmtGetPoolTag(Memory), 'MyTa');
    ExFreePoolWithTag(Memory, 'MyTa');
 
    Memory = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, 'MyTa');
    ok_eq_tag(KmtGetPoolTag(Memory), 'TooL');
    ExFreePoolWithTag(Memory, 'MyTa');
 
    Memory = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE - 3 * sizeof(PVOID), 'MyTa');
    ok_eq_tag(KmtGetPoolTag(Memory), 'TooL');
    ExFreePoolWithTag(Memory, 'MyTa');
 
    Memory = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE - 4 * sizeof(PVOID) + 1, 'MyTa');
    ok_eq_tag(KmtGetPoolTag(Memory), 'TooL');
    ExFreePoolWithTag(Memory, 'MyTa');
 
    Memory = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE - 4 * sizeof(PVOID), 'MyTa');
    ok_eq_tag(KmtGetPoolTag(Memory), 'MyTa');
    ExFreePoolWithTag(Memory, 'MyTa');
}

Referenced by START_TEST().