230 lines
4.1 KiB
C
230 lines
4.1 KiB
C
/*++
|
||
|
||
Copyright (c) 1990, 1991 Microsoft Corporation
|
||
|
||
|
||
Module Name:
|
||
|
||
hwheap.c
|
||
|
||
Abstract:
|
||
|
||
This is a very simple Heap Manager for NT OS Hardware recognizer.
|
||
This module provides functions to allocate memory in byte-unit
|
||
from a permanent heap.
|
||
|
||
Author:
|
||
|
||
Shie-Lin Tzong (shielint) 18-Oct-91
|
||
|
||
|
||
Environment:
|
||
|
||
Kernel Mode
|
||
|
||
|
||
Revision History:
|
||
|
||
|
||
--*/
|
||
|
||
#include "hwdetect.h"
|
||
#include "string.h"
|
||
|
||
VOID
|
||
GrowHeapSpace(
|
||
ULONG
|
||
);
|
||
|
||
VOID
|
||
HeapCheck(
|
||
PVOID
|
||
);
|
||
|
||
//
|
||
// Heap management variables.
|
||
//
|
||
|
||
ULONG HwHeapBase = 0; // Current virtual address of base of heap
|
||
ULONG HwHeapPointer = 0; // Pointer to the end of available heap
|
||
ULONG HwHeapSize = 0; // Size of Heap
|
||
ULONG HwAvailableHeap = 0; // Currently available heap space
|
||
|
||
#if DBG
|
||
ULONG HwPreviousAllocSize = 0;
|
||
#endif
|
||
|
||
BOOLEAN
|
||
HwResizeHeap (
|
||
ULONG NewHeapSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
The routine grows current heap to the specified size.
|
||
It reallocates the heap, copies the data in current heap to
|
||
the new heap, updates heap variables, updates heap pointers
|
||
in hardware data structures and finally frees the old heap.
|
||
|
||
Arguments:
|
||
|
||
NewHeapSize - Specifies the size of the new heap.
|
||
|
||
Returns:
|
||
|
||
TRUE - if operation is done sucessfully. Else it returns FALSE.
|
||
|
||
--*/
|
||
|
||
{
|
||
//
|
||
// Not implemented yet.
|
||
//
|
||
|
||
return(FALSE);
|
||
}
|
||
|
||
BOOLEAN
|
||
HwInitializeHeap(
|
||
ULONG HeapStart,
|
||
ULONG HeapSize
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
The routine allocates heap and initializes some vital heap
|
||
variables.
|
||
|
||
Arguments:
|
||
|
||
None
|
||
|
||
Returns:
|
||
|
||
FALSE - if unable to allocate initial heap. Else it returns TRUE.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
HwHeapBase = HeapStart;
|
||
HwHeapPointer = HwHeapBase;
|
||
HwHeapSize = HeapSize;
|
||
HwAvailableHeap = HwHeapSize;
|
||
return(TRUE);
|
||
|
||
}
|
||
|
||
FPVOID
|
||
HwAllocateHeap(
|
||
ULONG RequestSize,
|
||
BOOLEAN ZeroInitialized
|
||
)
|
||
|
||
/**
|
||
|
||
Routine Description:
|
||
|
||
Allocates memory from the hardware recognizer's heap.
|
||
|
||
The heap begins with a default size. If a request exhausts heap space,
|
||
the heap will be grown to accomodate the request. The heap can grow
|
||
up to any size limited by NTLDR. If we run out of heap space and are
|
||
unable to allocate more memory, a value of NULL will be returned.
|
||
|
||
Arguments:
|
||
|
||
RequestSize - Size of block to allocate.
|
||
|
||
ZeroInitialized - Specifies if the heap should be zero initialized.
|
||
|
||
Returns:
|
||
|
||
Returns a pointer to the allocated block of memory. A NULL pointer
|
||
will be returned if we run out of heap and are unable to resize
|
||
current heap.
|
||
|
||
--*/
|
||
|
||
{
|
||
FPVOID ReturnPointer;
|
||
|
||
if (RequestSize > HwAvailableHeap) {
|
||
|
||
//
|
||
// We're out of heap. Try to grow current heap to satisfy the
|
||
// request.
|
||
//
|
||
|
||
if (!HwResizeHeap(HwHeapSize + RequestSize)) {
|
||
#if DBG
|
||
BlPrint("Unable to grow heap\n");
|
||
#endif
|
||
return(NULL);
|
||
}
|
||
}
|
||
|
||
//
|
||
// Set our return value to the new Heap pointer then
|
||
// update the remaining space and heap pointer.
|
||
//
|
||
|
||
MAKE_FP(ReturnPointer, HwHeapPointer);
|
||
HwHeapPointer += RequestSize;
|
||
#if DBG
|
||
HwPreviousAllocSize = RequestSize;
|
||
#endif
|
||
HwAvailableHeap -= RequestSize;
|
||
if (ZeroInitialized) {
|
||
_fmemset(ReturnPointer, 0, (USHORT)RequestSize);
|
||
}
|
||
return (ReturnPointer);
|
||
}
|
||
|
||
VOID
|
||
HwFreeHeap(
|
||
ULONG Size
|
||
)
|
||
|
||
/**
|
||
|
||
Routine Description:
|
||
|
||
Unallocates memory from the hardware recognizer's heap.
|
||
|
||
The unallocation is very basic. It simply moves heap pointer
|
||
back by the size specified and increases the heap size by the
|
||
specified size. The routine should be used only when previous
|
||
allocateHeap allocated too much memory.
|
||
|
||
Arguments:
|
||
|
||
RequestSize - Size of block to allocate.
|
||
|
||
Returns:
|
||
|
||
Returns a pointer to the allocated block of memory. A NULL pointer
|
||
will be returned if we run out of heap and are unable to resize
|
||
current heap.
|
||
|
||
--*/
|
||
|
||
{
|
||
|
||
#if DBG
|
||
if (Size > HwPreviousAllocSize) {
|
||
BlPrint("Invalid heap deallocation ...\n");
|
||
} else {
|
||
HwPreviousAllocSize -= Size;
|
||
}
|
||
#endif
|
||
|
||
HwHeapPointer -= Size;
|
||
HwAvailableHeap += Size;
|
||
}
|
||
|
||
|