mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
599 lines
13 KiB
599 lines
13 KiB
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ipinip\ppool.h
|
|
|
|
Abstract:
|
|
|
|
Code for managing NDIS_PACKET pools. This is merely a reformatted version
|
|
of SteveC's l2tp\ppool.c
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
#define __FILE_SIG__ PPOOL_SIG
|
|
|
|
#include "inc.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Local prototypes (alphabetically)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
PPACKET_HEAD
|
|
AddPacketBlockToPool(
|
|
IN PPACKET_POOL pPool
|
|
);
|
|
|
|
VOID
|
|
FreeUnusedPacketPoolBlocks(
|
|
IN PPACKET_POOL pPool
|
|
);
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Interface routines
|
|
//-----------------------------------------------------------------------------
|
|
|
|
VOID
|
|
InitPacketPool(
|
|
OUT PPACKET_POOL pPool,
|
|
IN ULONG ulProtocolReservedLength,
|
|
IN ULONG ulMaxPackets,
|
|
IN ULONG ulPacketsPerBlock,
|
|
IN ULONG ulFreesPerCollection,
|
|
IN ULONG ulTag
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Initialize caller's packet pool control block 'pPool'
|
|
|
|
Locks
|
|
|
|
Caller's 'pPool' packet must be protected from multiple access during
|
|
this call.
|
|
|
|
Arguments
|
|
|
|
ulProtocolReservedLength size in bytes of the 'ProtocolReserved'
|
|
array of each individual packet.
|
|
ulMaxPackets maximum number of packets allowed in the
|
|
entire pool, or 0 for unlimited.
|
|
ulPacketsPerBlock number of packets to include in each block
|
|
of packets.
|
|
ulFreesPerCollection number of FreePacketToPool calls until the
|
|
next garbage collect scan, or 0 for default.
|
|
ulTag pool tag to use when allocating blocks
|
|
|
|
Return Value
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
pPool->ulProtocolReservedLength = ulProtocolReservedLength;
|
|
pPool->ulPacketsPerBlock = ulPacketsPerBlock;
|
|
pPool->ulMaxPackets = ulMaxPackets;
|
|
pPool->ulFreesSinceCollection = 0;
|
|
pPool->ulTag = ulTag;
|
|
|
|
if(ulFreesPerCollection)
|
|
{
|
|
pPool->ulFreesPerCollection = ulFreesPerCollection;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Calculate default garbage collection trigger. Don't want to be too
|
|
// aggressive here.
|
|
//
|
|
|
|
pPool->ulFreesPerCollection = 50 * pPool->ulPacketsPerBlock;
|
|
}
|
|
|
|
InitializeListHead(&(pPool->leBlockHead));
|
|
InitializeListHead(&(pPool->leFreePktHead));
|
|
|
|
RtInitializeSpinLock(&(pPool->rlLock));
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
FreePacketPool(
|
|
IN PPACKET_POOL pPool
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Free up all resources allocated in packet pool 'pPool'. This is the
|
|
inverse of InitPacketPool.
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
|
|
TRUE if successful
|
|
FALSE if any of the pool could not be freed due to outstanding packets
|
|
|
|
--*/
|
|
{
|
|
BOOLEAN fSuccess;
|
|
KIRQL irql;
|
|
|
|
RtAcquireSpinLock(&(pPool->rlLock),
|
|
&irql);
|
|
|
|
FreeUnusedPacketPoolBlocks(pPool);
|
|
|
|
fSuccess = (pPool->ulCurPackets is 0);
|
|
|
|
RtReleaseSpinLock(&(pPool->rlLock),
|
|
irql);
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
PNDIS_PACKET
|
|
GetPacketFromPool(
|
|
IN PPACKET_POOL pPool,
|
|
OUT PACKET_HEAD **ppHead
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Returns the address of the NDIS_PACKET descriptor allocated from the
|
|
pool. The pool is expanded, if necessary, but caller should
|
|
still check for NULL return since the pool may have been at maximum
|
|
size.
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
pPool Pool to get packet from
|
|
ppHead Pointer the "cookie" that is used to return the packet to
|
|
the pool (see FreePacketToPool). Caller would normally stash this
|
|
value in the appropriate 'reserved' areas of the packet for
|
|
retrieval later.
|
|
|
|
Return Value
|
|
|
|
Pointer to NDIS_PACKET or NULL
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY pleNode;
|
|
PPACKET_HEAD pHead;
|
|
PNDIS_PACKET pPacket;
|
|
KIRQL irql;
|
|
|
|
|
|
RtAcquireSpinLock(&(pPool->rlLock),
|
|
&irql);
|
|
|
|
if(IsListEmpty(&pPool->leFreePktHead))
|
|
{
|
|
pleNode = NULL;
|
|
}
|
|
else
|
|
{
|
|
pleNode = RemoveHeadList(&(pPool->leFreePktHead));
|
|
|
|
pHead = CONTAINING_RECORD(pleNode, PACKET_HEAD, leFreePktLink);
|
|
|
|
pHead->pBlock->ulFreePackets--;
|
|
}
|
|
|
|
RtReleaseSpinLock(&(pPool->rlLock),
|
|
irql);
|
|
|
|
if(!pleNode)
|
|
{
|
|
//
|
|
// The free list was empty. Try to expand the pool.
|
|
//
|
|
|
|
pHead = AddPacketBlockToPool(pPool);
|
|
|
|
if(!pHead)
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
*ppHead = pHead;
|
|
|
|
return pHead->pNdisPacket;
|
|
}
|
|
|
|
|
|
VOID
|
|
FreePacketToPool(
|
|
IN PPACKET_POOL pPool,
|
|
IN PPACKET_HEAD pHead,
|
|
IN BOOLEAN fGarbageCollection
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Returns a packet to the pool of unused packet. The packet must have
|
|
been previously allocate with GetaPacketFromPool.
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
pPool Pool to which the packet is to be returned
|
|
pHead The "cookie" that was given when the packet was allocated
|
|
|
|
fGarbageCollection is set when the free should be considered for
|
|
purposes of garbage collection. This is used by the AddPacketToPool
|
|
routine to avoid counting the initial "add" frees. Normal callers
|
|
should set this flag.
|
|
|
|
Return Value
|
|
NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
KIRQL irql;
|
|
|
|
RtAcquireSpinLock(&(pPool->rlLock),
|
|
&irql);
|
|
|
|
InsertHeadList(&(pPool->leFreePktHead),
|
|
&(pHead->leFreePktLink));
|
|
|
|
pHead->pBlock->ulFreePackets++;
|
|
|
|
if(fGarbageCollection)
|
|
{
|
|
pPool->ulFreesSinceCollection++;
|
|
|
|
if(pPool->ulFreesSinceCollection >= pPool->ulFreesPerCollection)
|
|
{
|
|
//
|
|
// Time to collect garbage, i.e. free any blocks in the pool
|
|
// not in use.
|
|
//
|
|
|
|
FreeUnusedPacketPoolBlocks(pPool);
|
|
|
|
pPool->ulFreesSinceCollection = 0;
|
|
}
|
|
}
|
|
|
|
RtReleaseSpinLock(&(pPool->rlLock),
|
|
irql);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Utility routines (alphabetically)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
PPACKET_HEAD
|
|
AddPacketBlockToPool(
|
|
IN PPACKET_POOL pPool
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Allocate a new packet block and add it to the packet pool
|
|
|
|
Locks
|
|
|
|
|
|
Arguments
|
|
|
|
|
|
Return Value
|
|
NO_ERROR
|
|
|
|
--*/
|
|
{
|
|
NDIS_STATUS status;
|
|
PPACKET_BLOCK pNew;
|
|
ULONG ulSize;
|
|
ULONG ulCount;
|
|
BOOLEAN fOk;
|
|
PPACKET_HEAD pReturn;
|
|
KIRQL irql;
|
|
|
|
|
|
fOk = FALSE;
|
|
pNew = NULL;
|
|
|
|
RtAcquireSpinLock(&(pPool->rlLock),
|
|
&irql);
|
|
|
|
do
|
|
{
|
|
if((pPool->ulMaxPackets) and
|
|
(pPool->ulCurPackets >= pPool->ulMaxPackets))
|
|
{
|
|
//
|
|
// No can do. The pool was initialized with a max size and that
|
|
// has been reached.
|
|
//
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Calculate the contiguous block's size and the number of packets
|
|
// it will hold.
|
|
//
|
|
|
|
ulCount = pPool->ulPacketsPerBlock;
|
|
|
|
if(pPool->ulMaxPackets)
|
|
{
|
|
if(ulCount > (pPool->ulMaxPackets - pPool->ulCurPackets))
|
|
{
|
|
//
|
|
// If a max was specified, respect that
|
|
//
|
|
|
|
ulCount = pPool->ulMaxPackets - pPool->ulCurPackets;
|
|
}
|
|
}
|
|
|
|
//
|
|
// We allocate a PACKET_BLOCK to account for this block of packets
|
|
// and one PACKET_HEAD per packet
|
|
//
|
|
|
|
ulSize = sizeof(PACKET_BLOCK) + (ulCount * sizeof(PACKET_HEAD));
|
|
|
|
//
|
|
// Allocate the contiguous memory block for the PACKETBLOCK header
|
|
// and the individual PACKET_HEADs.
|
|
//
|
|
|
|
pNew = RtAllocate(NonPagedPool,
|
|
ulSize,
|
|
pPool->ulTag);
|
|
|
|
if(!pNew)
|
|
{
|
|
Trace(UTIL, ERROR,
|
|
("AddPacketBlockToPool: Unable to allocate %d bytes\n",
|
|
ulSize));
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Zero only the block header portion.
|
|
//
|
|
|
|
NdisZeroMemory(pNew, sizeof(PACKET_BLOCK));
|
|
|
|
//
|
|
// Allocate a pool of NDIS_PACKET descriptors.
|
|
//
|
|
|
|
NdisAllocatePacketPool(&status,
|
|
&pNew->nhNdisPool,
|
|
ulCount,
|
|
pPool->ulProtocolReservedLength);
|
|
|
|
if(status isnot NDIS_STATUS_SUCCESS)
|
|
{
|
|
Trace(UTIL, ERROR,
|
|
("AddPacketBlockToPool: Unable to allocate packet pool for %d packets\n",
|
|
ulCount));
|
|
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Fill in the back pointer to the pool.
|
|
//
|
|
|
|
pNew->pPool = pPool;
|
|
|
|
//
|
|
// Link the new block. At this point, all the packets are
|
|
// effectively "in use". They are made available in the loop
|
|
// below.
|
|
//
|
|
|
|
pNew->ulPackets = ulCount;
|
|
pPool->ulCurPackets += ulCount;
|
|
|
|
InsertHeadList(&(pPool->leBlockHead),
|
|
&(pNew->leBlockLink));
|
|
|
|
fOk = TRUE;
|
|
|
|
}while(FALSE);
|
|
|
|
RtReleaseSpinLock(&pPool->rlLock,
|
|
irql);
|
|
|
|
if(!fOk)
|
|
{
|
|
//
|
|
// Bailing, undo whatever succeeded.
|
|
//
|
|
|
|
if(pNew)
|
|
{
|
|
RtFree(pNew);
|
|
|
|
if(pNew->nhNdisPool)
|
|
{
|
|
NdisFreePacketPool(pNew->nhNdisPool);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Initialize each individual packet header and add it to the list of free
|
|
// packets.
|
|
//
|
|
|
|
{
|
|
ULONG i;
|
|
PPACKET_HEAD pHead;
|
|
|
|
pReturn = NULL;
|
|
|
|
//
|
|
// For each PACKET_HEAD of the block...
|
|
//
|
|
|
|
for(i = 0, pHead = (PPACKET_HEAD)(pNew + 1);
|
|
i < ulCount;
|
|
i++, pHead++)
|
|
{
|
|
InitializeListHead(&pHead->leFreePktLink);
|
|
|
|
pHead->pBlock = pNew;
|
|
pHead->pNdisPacket = NULL;
|
|
|
|
//
|
|
// Associate an NDIS_PACKET descriptor from the pool we
|
|
// allocated above.
|
|
//
|
|
|
|
NdisAllocatePacket(&status,
|
|
&pHead->pNdisPacket,
|
|
pNew->nhNdisPool);
|
|
|
|
if(status isnot NDIS_STATUS_SUCCESS)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(pReturn)
|
|
{
|
|
//
|
|
// Add the constructed packet to the list of free packets.
|
|
// The 'FALSE' tells the garbage collection algorithm the
|
|
// operation is an "add" rather than a "release" and should be
|
|
// ignored.
|
|
//
|
|
|
|
FreePacketToPool(pPool,
|
|
pHead,
|
|
FALSE);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The first successfully constructed packet is returned by
|
|
// this routine.
|
|
//
|
|
|
|
pReturn = pHead;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pReturn;
|
|
}
|
|
|
|
|
|
VOID
|
|
FreeUnusedPacketPoolBlocks(
|
|
IN PPACKET_POOL pPool
|
|
)
|
|
/*++
|
|
Routine Description
|
|
|
|
Check if any of the blocks in pool are not in use, and if so, free them.
|
|
|
|
Locks
|
|
|
|
Caller must hold the pool lock
|
|
|
|
NOTE: The MSDN doc says that no locks may be held while calling
|
|
NdisFreePacketXxx, but according to JameelH that is incorrect.
|
|
|
|
Arguments
|
|
|
|
pPool Pointer to pool
|
|
|
|
Return Value
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY pleNode;
|
|
|
|
//
|
|
// For each block in the pool...
|
|
//
|
|
|
|
pleNode = pPool->leBlockHead.Flink;
|
|
|
|
while(pleNode isnot &(pPool->leBlockHead))
|
|
{
|
|
PLIST_ENTRY pleNextNode;
|
|
PPACKET_BLOCK pBlock;
|
|
|
|
pleNextNode = pleNode->Flink;
|
|
|
|
pBlock = CONTAINING_RECORD(pleNode, PACKET_BLOCK, leBlockLink);
|
|
|
|
if(pBlock->ulFreePackets >= pBlock->ulPackets)
|
|
{
|
|
ULONG i;
|
|
PPACKET_HEAD pHead;
|
|
|
|
//
|
|
// Found a block with no packets in use. Walk the packet block
|
|
// removing each packet from the pool's free list and freeing any
|
|
// associated NDIS_PACKET descriptor.
|
|
//
|
|
|
|
for(i = 0, pHead = (PPACKET_HEAD)(pBlock + 1);
|
|
i < pBlock->ulPackets;
|
|
i++, pHead++)
|
|
{
|
|
RemoveEntryList(&(pHead->leFreePktLink));
|
|
|
|
if(pHead->pNdisPacket)
|
|
{
|
|
NdisFreePacket(pHead->pNdisPacket);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Remove and release the unused block.
|
|
//
|
|
|
|
RemoveEntryList(pleNode);
|
|
|
|
pPool->ulCurPackets -= pBlock->ulPackets;
|
|
|
|
if(pBlock->nhNdisPool)
|
|
{
|
|
NdisFreePacketPool(pBlock->nhNdisPool);
|
|
}
|
|
|
|
RtFree(pBlock);
|
|
}
|
|
|
|
pleNode = pleNextNode;
|
|
}
|
|
}
|