PlatformMem.h File Reference

Cross platform APIs for memory allocation. More...

Go to the source code of this file.

Functions
INT	PlatformSprintf (char *Buffer, SIZE_T BufferSize, const char *Format,...)
	Platform independent wrapper for sprintf_s / snprintf.
VOID	PlatformFreeMemory (PVOID Memory)
	Frees a previously allocated memory block.
VOID	PlatformWriteMemory (PVOID Address, PVOID Buffer, SIZE_T Size)
	Writes data from a buffer to a memory address.
VOID	PlatformSetMemory (PVOID Destination, int Value, SIZE_T Size)
	Sets a memory block to a specific value.
VOID	PlatformZeroMemory (PVOID Destination, SIZE_T Size)
	Zeros a memory block.
PVOID	PlatformAllocateMemory (SIZE_T Size)
	... New Unified API ...
PVOID	PlatformMemAllocateContiguousZeroedMemory (SIZE_T NumberOfBytes)
	... Backward Compatibility / Specific APIs ...
PVOID	PlatformMemAllocateNonPagedPool (SIZE_T NumberOfBytes)
	Allocates non-paged pool memory.
PVOID	PlatformMemAllocateNonPagedPoolWithQuota (SIZE_T NumberOfBytes)
	Allocates non-paged pool memory with quota charging.
PVOID	PlatformMemAllocateZeroedNonPagedPool (SIZE_T NumberOfBytes)
	Allocates zeroed non-paged pool memory.
PVOID	PlatformMemFreePool (PVOID BufferAddress)
	Frees a memory pool.

Detailed Description

Cross platform APIs for memory allocation.

Author

Behrooz Abbassi (Behro.nosp@m.ozAb.nosp@m.bassi.nosp@m.@hyp.nosp@m.erdbg.nosp@m..org)

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

Alirez Moradi (alish014)

Version

0.1

Date

2022-01-17

Copyright

This project is released under the GNU Public License v3.

Function Documentation

PlatformAllocateMemory()

PVOID PlatformAllocateMemory

(

SIZE_T

Size

)

... New Unified API ...

Allocates a block of memory in the kernel pool.

On Windows: Allocates from NonPagedPool and zeroes it. On Linux: Uses kzalloc (GFP_KERNEL) which zeroes memory.

Parameters

Size	The number of bytes to allocate.

Returns

PVOID Pointer to the allocated memory, or NULL on failure.

{
#ifdef _WIN32
    PVOID Result = ExAllocatePool2(
        POOL_FLAG_NON_PAGED, // non-paged pool
        Size,
        POOLTAG);
 
    if (Result != NULL)
        RtlSecureZeroMemory(Result, Size);
 
    return Result;
#else
    // Linux Kernel: kzalloc allocates zeroed memory
    PVOID ptr = kzalloc(Size, GFP_KERNEL);
 
    if (ptr)
    {
        printk(KERN_INFO "MemAllocKernel: Allocated %zu bytes at %px\n", Size, ptr);
    }
    else
    {
        printk(KERN_ERR "MemAllocKernel: failed to allocate %zu bytes\n", Size);
    }
 
    return ptr;
#endif
}

PlatformFreeMemory()

VOID PlatformFreeMemory

(

PVOID

Memory

)

Frees a previously allocated memory block.

Parameters

Memory

Pointer to the memory block. Handles NULL safely.

{
    if (!Memory)
        return;
 
#ifdef _WIN32
    ExFreePoolWithTag(Memory, POOLTAG);
#else
    kfree(Memory);
#endif
}

PlatformMemAllocateContiguousZeroedMemory()

PVOID PlatformMemAllocateContiguousZeroedMemory

(

SIZE_T

NumberOfBytes

)

... Backward Compatibility / Specific APIs ...

Allocates contiguous zeroed physical memory.

On Windows: Uses MmAllocateContiguousMemory. On Linux: Uses kmalloc (which is usually physically contiguous) or dma_alloc_coherent. For simplicity in this driver, we map to kzalloc.

Parameters

NumberOfBytes

Size in bytes.

Returns

PVOID Pointer to memory or NULL.

{
#ifdef _WIN32
    PVOID            Result          = NULL;
    PHYSICAL_ADDRESS MaxPhysicalAddr = {0};
    MaxPhysicalAddr.QuadPart         = MAXULONG64;
 
    Result = MmAllocateContiguousMemory(NumberOfBytes, MaxPhysicalAddr);
    if (Result != NULL)
        RtlSecureZeroMemory(Result, NumberOfBytes);
    return Result;
#else
    // In Linux, kmalloc/kzalloc returns physically contiguous memory
    // (unless vmalloc is used, which we aren't using here).
    return kzalloc(NumberOfBytes, GFP_KERNEL);
#endif
}

PlatformMemAllocateNonPagedPool()

PVOID PlatformMemAllocateNonPagedPool

(

SIZE_T

NumberOfBytes

)

Allocates non-paged pool memory.

Parameters

NumberOfBytes

Size in bytes.

Returns

PVOID Pointer to memory.

{
#ifdef _WIN32
    return ExAllocatePool2(
        POOL_FLAG_NON_PAGED,
        NumberOfBytes,
        POOLTAG);
#else
    // Linux kernel memory is non-paged by default (except vmalloc)
    return kmalloc(NumberOfBytes, GFP_KERNEL);
#endif
}

PlatformMemAllocateNonPagedPoolWithQuota()

PVOID PlatformMemAllocateNonPagedPoolWithQuota

(

SIZE_T

NumberOfBytes

)

Allocates non-paged pool memory with quota charging.

Parameters

NumberOfBytes

Size in bytes.

Returns

PVOID Pointer to memory.

{
#ifdef _WIN32
    // POOL_FLAG_USE_QUOTA is used with ExAllocatePool2
    // Note: Ensure your WDK supports ExAllocatePool2, otherwise use ExAllocatePoolWithQuotaTag
    return ExAllocatePool2(
        POOL_FLAG_NON_PAGED | POOL_FLAG_USE_QUOTA,
        NumberOfBytes,
        POOLTAG);
#else
    // Quotas are not explicitly managed in simple Linux kernel allocations like this
    return kmalloc(NumberOfBytes, GFP_KERNEL);
#endif
}

PlatformMemAllocateZeroedNonPagedPool()

PVOID PlatformMemAllocateZeroedNonPagedPool

(

SIZE_T

NumberOfBytes

)

Allocates zeroed non-paged pool memory.

Parameters

NumberOfBytes

Size in bytes.

Returns

PVOID Pointer to memory.

{
#ifdef _WIN32
    PVOID Result = ExAllocatePool2(
        POOL_FLAG_NON_PAGED,
        NumberOfBytes,
        POOLTAG);
    if (Result != NULL)
        RtlSecureZeroMemory(Result, NumberOfBytes);
    return Result;
#else
    return kzalloc(NumberOfBytes, GFP_KERNEL);
#endif
}

PlatformMemFreePool()

PVOID PlatformMemFreePool

(

PVOID

BufferAddress

)

Frees a memory pool.

Parameters

BufferAddress

Pointer to the memory to free.

Returns

PVOID (Void pointer in original API, usually ignored).

{
    if (!BufferAddress)
        return NULL;
 
#ifdef _WIN32
    ExFreePoolWithTag(BufferAddress, POOLTAG);
#else
    kfree(BufferAddress);
#endif
    return NULL;
}

PlatformSetMemory()

VOID PlatformSetMemory	(	PVOID	Destination,
		int	Value,
		SIZE_T	Size )

Sets a memory block to a specific value.

Parameters

Destination	Memory address.
Value	Value to set.
Size	Number of bytes.

{
    if (!Destination)
        return;
 
#ifdef _WIN32
    RtlFillMemory(Destination, Size, Value);
#else
    memset(Destination, Value, Size);
#endif
}

PlatformSprintf()

INT PlatformSprintf	(	char *	Buffer,
		SIZE_T	BufferSize,
		const char *	Format,
			... )

Platform independent wrapper for sprintf_s / snprintf.

Parameters

Buffer	output buffer
BufferSize	size of the output buffer
Format	format string

Returns

INT number of characters written, or -1 on error

{
    va_list Args;
    va_start(Args, Format);
    INT Result;
#if defined(_WIN32) || defined(_WIN64)
    Result = vsprintf_s(Buffer, BufferSize, Format, Args);
#elif defined(__linux__)
    Result = vsnprintf(Buffer, BufferSize, Format, Args);
#else
#    error "Unsupported platform"
#endif
    va_end(Args);
    return Result;
}

PlatformWriteMemory()

VOID PlatformWriteMemory	(	PVOID	Address,
		PVOID	Buffer,
		SIZE_T	Size )

Writes data from a buffer to a memory address.

Parameters

Process	Reserved (unused).
Address	Destination address.
Buffer	Source buffer.
Size	Number of bytes to copy.

Returns

VOID

{
#ifdef _WIN32
    RtlCopyMemory(Address, Buffer, Size);
#else
    memcpy(Address, Buffer, Size);
#endif
}

PlatformZeroMemory()

VOID PlatformZeroMemory	(	PVOID	Destination,
		SIZE_T	Size )

Zeros a memory block.

Parameters

Destination	Memory address.
Size	Number of bytes.

{
    if (!Destination)
        return;
 
#ifdef _WIN32
    RtlZeroMemory(Destination, Size);
#elif defined(__linux__)
    memset(Destination, 0, Size);
#else
#    error "Unsupported platform"
#endif
}