/*++
Copyright(c) 1995 Microsoft Corporation
MODULE NAME
table.c
ABSTRACT
Generic hash table manipulation routines.
AUTHOR
Anthony Discolo (adiscolo) 28-Jul-1995
REVISION HISTORY
--*/
#include <ndis.h>
#include <cxport.h>
#include <tdi.h>
#include <tdikrnl.h>
#include <tdistat.h>
#include <tdiinfo.h>
#include <acd.h>
#include <acdapi.h>
#include "acddefs.h"
#include "mem.h"
#include "debug.h"
//
// The maximum number of allocated
// objects we allocate from outside
// our zones.
//
#define MAX_ALLOCATED_OBJECTS 100
//
// Rounding up macro.
//
#define ROUNDUP(n, b) (((n) + ((b) - 1)) & ~((b) - 1))
//
// Map an object type to a zone.
//
#define OBJECT_INFO(fObject) \
(fObject < ACD_OBJECT_MAX) ? &AcdObjectInfoG[fObject] : &AcdObjectInfoG[ACD_OBJECT_MAX]
//
// The spin lock for this module.
//
KSPIN_LOCK AcdMemSpinLockG;
//
// Zone-based object information. One zone
// per object type.
//
typedef struct _OBJECT_INFORMATION {
ZONE_HEADER zone;
ULONG ulSize; // object size
ULONG ulTag; // ExAllocateFromPoolWithTag() tag
ULONG ulCurrent; // # currently allocated in zone
ULONG ulTotal; // total # zone allocations
} OBJECT_INFORMATION, *POBJECT_INFORMATION;
OBJECT_INFORMATION AcdObjectInfoG[ACD_OBJECT_MAX + 1];
//
// Pool-based object allocation. This is for
// objects that don't fit into any of the zones,
// or when the zone is full.
//
typedef struct _POOL_INFORMATION {
ULONG cbMin; // minimum size
ULONG cbMax; // maximum size
ULONG ulCurrent; // # current allocations
ULONG ulTotal; // total allocations
ULONG ulFailures; // total failures
} POOL_INFORMATION, *PPOOL_INFORMATION;
POOL_INFORMATION AcdPoolInfoG;
VOID
InitializeObjectAllocator()
{
NTSTATUS status;
PVOID pMem;
ULONG ulSize;
KeInitializeSpinLock(&AcdMemSpinLockG);
//
// Initialize zone 0 (ACD_OBJECT_CONNECTION).
//
AcdObjectInfoG[ACD_OBJECT_CONNECTION].ulTag = 'NdcA';
AcdObjectInfoG[ACD_OBJECT_CONNECTION].ulSize =
ROUNDUP(sizeof (ACD_CONNECTION), 8);
ulSize = PAGE_SIZE;
pMem = ExAllocatePoolWithTag(
NonPagedPool,
ulSize,
AcdObjectInfoG[ACD_OBJECT_CONNECTION].ulTag);
ASSERT(pMem != NULL);
status = ExInitializeZone(
&AcdObjectInfoG[ACD_OBJECT_CONNECTION].zone,
AcdObjectInfoG[ACD_OBJECT_CONNECTION].ulSize,
pMem,
ulSize);
IF_ACDDBG(ACD_DEBUG_MEMORY) {
AcdPrint((
"InitializeObjectAllocator: zone 0 created: blksiz=%d, size=%d (status=%d)\n",
AcdObjectInfoG[ACD_OBJECT_CONNECTION].ulSize,
ulSize,
status));
}
//
// Initialize zone 1 (ACD_OBJECT_COMPLETION).
//
AcdObjectInfoG[ACD_OBJECT_MAX].ulTag = 'MdcA';
//
// Allow for up to 6 parameters to a completion
// request (6 used by tcpip.sys).
//
AcdObjectInfoG[ACD_OBJECT_MAX].ulSize =
ROUNDUP(sizeof (ACD_COMPLETION) + (6 * sizeof (PVOID)), 8);
ulSize = ROUNDUP(6 * AcdObjectInfoG[ACD_OBJECT_MAX].ulSize, PAGE_SIZE),
pMem = ExAllocatePoolWithTag(
NonPagedPool,
ulSize,
AcdObjectInfoG[ACD_OBJECT_MAX].ulTag);
ASSERT(pMem != NULL);
status = ExInitializeZone(
&AcdObjectInfoG[ACD_OBJECT_MAX].zone,
AcdObjectInfoG[ACD_OBJECT_MAX].ulSize,
pMem,
ulSize);
IF_ACDDBG(ACD_DEBUG_MEMORY) {
AcdPrint((
"InitializeObjectAllocator: zone 1 created: blksiz=%d size=%d (status=%d)\n",
AcdObjectInfoG[ACD_OBJECT_MAX].ulSize,
ulSize,
status));
}
//
// Initialize the pool info.
//
AcdPoolInfoG.cbMin = 0xffffffff;
AcdPoolInfoG.cbMax = 0;
AcdPoolInfoG.ulCurrent = 0;
AcdPoolInfoG.ulTotal = 0;
AcdPoolInfoG.ulFailures = 0;
} // InitializeObjectAllocator
PVOID
AllocateObjectMemory(
IN ULONG fObject
)
{
KIRQL irql;
POBJECT_INFORMATION pObjectInfo = OBJECT_INFO(fObject);
PVOID pObject;
ULONG cbBytes = 0, ulTag;
static ULONG nAllocations = 0;
KeAcquireSpinLock(&AcdMemSpinLockG, &irql);
//
// If the zone is full, or the object
// size is greater than the zone object size,
// then use the pool allocator.
//
if (fObject > pObjectInfo->zone.BlockSize) {
cbBytes = fObject;
ulTag = 'PdcA';
}
else if (ExIsFullZone(&pObjectInfo->zone)) {
cbBytes = pObjectInfo->ulSize;
ulTag = pObjectInfo->ulTag;
}
if (cbBytes) {
//
// Limit memory usage under stress.
// If we have more than 100 outstanding
// requests, then we start dropping
// them.
//
if (AcdPoolInfoG.ulCurrent < MAX_ALLOCATED_OBJECTS)
pObject = ExAllocatePoolWithTag(NonPagedPool, cbBytes, ulTag);
else {
pObject = NULL;
AcdPoolInfoG.ulFailures++;
goto done;
}
if (cbBytes < AcdPoolInfoG.cbMin)
AcdPoolInfoG.cbMin = cbBytes;
if (cbBytes > AcdPoolInfoG.cbMax)
AcdPoolInfoG.cbMax = cbBytes;
AcdPoolInfoG.ulCurrent++;
AcdPoolInfoG.ulTotal++;
IF_ACDDBG(ACD_DEBUG_MEMORY) {
AcdPrint((
"AllocateObjectMemory: allocated type %d from pool: pObject=0x%x\n",
fObject,
pObject));
}
}
else {
pObject = ExAllocateFromZone(&pObjectInfo->zone);
pObjectInfo->ulCurrent++;
pObjectInfo->ulTotal++;
IF_ACDDBG(ACD_DEBUG_MEMORY) {
AcdPrint((
"AllocateObjectMemory: allocated type %d from zone: pObject=0x%x\n",
fObject,
pObject));
}
}
#if DBG
IF_ACDDBG(ACD_DEBUG_MEMORY) {
INT i;
if (!(++nAllocations % 10)) {
for (i = 0; i <= ACD_OBJECT_MAX; i++) {
AcdPrint((
"Zone %d: ulCurrent=%d, ulTotal=%d\n",
i,
AcdObjectInfoG[i].ulCurrent,
AcdObjectInfoG[i].ulTotal));
}
AcdPrint((
"Pool: ulCurrent=%d, ulTotal=%d\n",
AcdPoolInfoG.ulCurrent,
AcdPoolInfoG.ulTotal));
}
}
#endif
done:
KeReleaseSpinLock(&AcdMemSpinLockG, irql);
return pObject;
} // AllocateObjectMemory
VOID
FreeObjectMemory(
IN PVOID pObject
)
{
KIRQL irql;
INT i;
POBJECT_INFORMATION pObjectInfo;
KeAcquireSpinLock(&AcdMemSpinLockG, &irql);
for (i = 0; i <= ACD_OBJECT_MAX; i++) {
pObjectInfo = &AcdObjectInfoG[i];
if (ExIsObjectInFirstZoneSegment(&pObjectInfo->zone, pObject)) {
ExFreeToZone(&pObjectInfo->zone, pObject);
pObjectInfo->ulCurrent--;
IF_ACDDBG(ACD_DEBUG_MEMORY) {
AcdPrint((
"FreeObjectMemory: freed type %d into zone: pObject=0x%x\n",
i,
pObject));
}
goto done;
}
}
ExFreePool(pObject);
AcdPoolInfoG.ulCurrent--;
IF_ACDDBG(ACD_DEBUG_MEMORY) {
AcdPrint((
"FreeObjectMemory: freed into pool: pObject=0x%x\n",
pObject));
}
done:
KeReleaseSpinLock(&AcdMemSpinLockG, irql);
} // FreeObjectMemory
VOID
FreeObjectAllocator()
{
// Apparently, we can't do this?
} // FreeObjectAllocator
