/*++
Copyright(c) 1999-2000 Microsoft Corporation
Module Name:
brdgbuf.c
Abstract:
Ethernet MAC level bridge.
Buffer management section
Author:
Mark Aiken
(original bridge by Jameel Hyder)
Environment:
Kernel mode driver
Revision History:
Feb 2000 - Original version
--*/
#define NDIS_MINIPORT_DRIVER
#define NDIS50_MINIPORT 1
#define NDIS_WDM 1
#pragma warning( push, 3 )
#include <ndis.h>
#include <ntddk.h>
#pragma warning( pop )
#include "bridge.h"
#include "brdgbuf.h"
#include "brdgprot.h"
#include "brdgmini.h"
// ===========================================================================
//
// PRIVATE DECLARATIONS
//
// ===========================================================================
//
// A guess at how many buffer descriptors an average packet indicated on the
// no-copy path is likely to have.
//
// The size of the pool of MDLs used to construct wrapper packets is based on this
// guess
//
#define GUESS_BUFFERS_PER_PACKET 3
//
// Transit unicast packets on the no-copy path require one packet descriptor to wrap
// them for relay.
//
// Transit broadcast packets require n descriptors (where n == # of adapters) to
// wrap them for relay.
//
// We can't allow our descriptor usage to reach n^2, which is the worst case to handle
// broadcast traffic from all adapters. This number is a guess at how many wrapping
// descriptors we will need, on **average**, per packet. The idea is to not run out
// of packet descriptors under regular traffic conditions. If running on a machine
// with lots of adapters and lots of broadcast traffic, the # of wrapper descriptors
// may become a limiting factor if this guess is wrong.
//
// The size of the wrapper packet descriptor pool is based on this guess.
//
#define GUESS_AVERAGE_FANOUT 2
//
// In case we can't read it out of the registry, use this default value for the
// size of the copy packet pool safety buffer.
//
#define DEFAULT_SAFETY_MARGIN 10 // A percentage (10%)
//
// In case we can't read it out of the registry, use this default value for the
// total memory footprint we are allowed.
//
#define DEFAULT_MAX_BUF_MEMORY 2 * 1024 * 1024 // 2MB in bytes
//
// Registry values that hold our config values
//
const PWCHAR gMaxBufMemoryParameterName = L"MaxBufferMemory";
const PWCHAR gSafetyMarginParameterName = L"SafetyMargin";
//
// Constant for different types of quota-restricted packets
//
typedef enum
{
BrdgQuotaCopyPacket = 0,
BrdgQuotaWrapperPacket = 1
} QUOTA_PACKET_TYPE;
// ===========================================================================
//
// GLOBALS
//
// ===========================================================================
// List of free packet descriptors for copy-receives
BSINGLE_LIST_HEAD gFreeCopyPacketList;
NDIS_SPIN_LOCK gFreeCopyPacketListLock;
// List of free packet descriptors for wrapper packets
BSINGLE_LIST_HEAD gFreeWrapperPacketList;
NDIS_SPIN_LOCK gFreeWrapperPacketListLock;
// Look-aside list for copy-receive buffers
NPAGED_LOOKASIDE_LIST gCopyBufferList;
BOOLEAN gInitedCopyBufferList = FALSE;
// Look-aside list for packet info blocks
NPAGED_LOOKASIDE_LIST gPktInfoList;
BOOLEAN gInitedPktInfoList = FALSE;
// Packet descriptor pools for copy receives and wrapper packets
NDIS_HANDLE gCopyPacketPoolHandle = NULL;
NDIS_HANDLE gWrapperPacketPoolHandle = NULL;
// MDL pools for copy receives and wrapper packets
NDIS_HANDLE gCopyBufferPoolHandle = NULL;
NDIS_HANDLE gWrapperBufferPoolHandle = NULL;
// Spin lock to protect quota information
NDIS_SPIN_LOCK gQuotaLock;
// Quota information for the local miniport
ADAPTER_QUOTA gMiniportQuota;
//
// Maximum number of available packets of each type
//
// [0] == Copy packets
// [1] == Wrapper packets
//
ULONG gMaxPackets[2] = { 0L, 0L };
//
// Number of packets currently allocated from each pool
//
// [0] == Copy packets
// [1] == Wrapper packets
//
ULONG gUsedPackets[2] = { 0L, 0L };
#if DBG
ULONG gMaxUsedPackets[2] = { 0L, 0L };
#endif
//
// Amount of packets to keep as a buffer in each pool (the maximum consumption
// of any single adapter is gMaxPackets[X] - gSafetyBuffer[X].
//
// These values are computed from the safety margin proportion, which can
// optionally be specified by a registry value
//
ULONG gSafetyBuffer[2] = { 0L, 0L };
//
// Number of times we have had to deny an allocation request even though we wanted
// to allow it because we were flat out of packets. For debugging performance.
//
LARGE_INTEGER gStatOverflows[2] = {{ 0L, 0L }, {0L, 0L}};
//
// Number of times we failed to allocated memory unexpectedly (i.e., when we had
// not allocated up to the preset maximum size of our resource pool). Should only
// occur if the host machine is actually out of non-paged memory (yikes!)
//
LARGE_INTEGER gStatFailures = { 0L, 0L };
// ===========================================================================
//
// PRIVATE PROTOTYPES
//
// ===========================================================================
PNDIS_PACKET
BrdgBufCommonGetNewPacket(
IN NDIS_HANDLE Pool,
OUT PPACKET_INFO *pppi
);
PNDIS_PACKET
BrdgBufGetNewCopyPacket(
OUT PPACKET_INFO *pppi
);
// Type of function to pass to BrgBufCommonGetPacket
typedef PNDIS_PACKET (*PNEWPACKET_FUNC)(PPACKET_INFO*);
PNDIS_PACKET
BrdgBufCommonGetPacket(
OUT PPACKET_INFO *pppi,
IN PNEWPACKET_FUNC pNewPacketFunc,
IN PBSINGLE_LIST_HEAD pCacheList,
IN PNDIS_SPIN_LOCK ListLock
);
BOOLEAN
BrdgBufAssignQuota(
IN QUOTA_PACKET_TYPE type,
IN PADAPT pAdapt,
IN BOOLEAN bCountAlloc
);
VOID
BrdgBufReleaseQuota(
IN QUOTA_PACKET_TYPE type,
IN PADAPT pAdapt
);
// ===========================================================================
//
// INLINES / MACROS
//
// ===========================================================================
//
// Allocates a new wrapper packet
//
__forceinline PNDIS_PACKET
BrdgBufGetNewWrapperPacket(
OUT PPACKET_INFO *pppi
)
{
return BrdgBufCommonGetNewPacket( gWrapperPacketPoolHandle, pppi );
}
//
// Handles the special LOCAL_MINIPORT pseudo-pointer value
//
__forceinline PADAPTER_QUOTA
QUOTA_FROM_ADAPTER(
IN PADAPT pAdapt
)
{
SAFEASSERT( pAdapt != NULL );
if( pAdapt == LOCAL_MINIPORT )
{
return &gMiniportQuota;
}
else
{
return &pAdapt->Quota;
}
}
//
// Switches from the packet type constant to an index
//
__forceinline UINT
INDEX_FROM_TYPE(
IN QUOTA_PACKET_TYPE type
)
{
SAFEASSERT( (type == BrdgQuotaCopyPacket) || (type == BrdgQuotaWrapperPacket) );
return (type == BrdgQuotaCopyPacket) ? 0 : 1;
}
//
// Reinitializes a packet for reuse later
//
__forceinline
VOID
BrdgBufScrubPacket(
IN PNDIS_PACKET pPacket,
IN PPACKET_INFO ppi
)
{
// This scrubs NDIS's state
NdisReinitializePacket( pPacket );
// Aggressively forget previous state to catch bugs
NdisZeroMemory( ppi, sizeof(PACKET_INFO) );
ppi->pOwnerPacket = pPacket;
}
//
// Decrements an adapter's used packet count
//
__forceinline
VOID
BrdgBufReleaseQuota(
IN QUOTA_PACKET_TYPE type,
IN PADAPT pAdapt
)
{
PADAPTER_QUOTA pQuota = QUOTA_FROM_ADAPTER(pAdapt);
UINT index = INDEX_FROM_TYPE(type);
NdisAcquireSpinLock( &gQuotaLock );
SAFEASSERT( pQuota->UsedPackets[index] > 0L );
pQuota->UsedPackets[index] --;
NdisReleaseSpinLock( &gQuotaLock );
}
//
// Decrements the global usage count
//
__forceinline
VOID
BrdgBufCountDealloc(
IN QUOTA_PACKET_TYPE type
)
{
UINT index = INDEX_FROM_TYPE(type);
NdisAcquireSpinLock( &gQuotaLock );
SAFEASSERT( gUsedPackets[index] > 0L );
gUsedPackets[index]--;
NdisReleaseSpinLock( &gQuotaLock );
}
// ===========================================================================
//
// PUBLIC FUNCTIONS
//
// ===========================================================================
VOID
BrdgBufGetStatistics(
PBRIDGE_BUFFER_STATISTICS pStats
)
/*++
Routine Description:
Retrieves our internal statistics on buffer management.
Arguments:
pStats The statistics structure to fill in
Return Value:
None
--*/
{
pStats->CopyPoolOverflows = gStatOverflows[0];
pStats->WrapperPoolOverflows = gStatOverflows[1];
pStats->AllocFailures = gStatFailures;
pStats->MaxCopyPackets = gMaxPackets[0];
pStats->MaxWrapperPackets = gMaxPackets[1];
pStats->SafetyCopyPackets = gSafetyBuffer[0];
pStats->SafetyWrapperPackets = gSafetyBuffer[1];
NdisAcquireSpinLock( &gQuotaLock );
pStats->UsedCopyPackets = gUsedPackets[0];
pStats->UsedWrapperPackets = gUsedPackets[1];
NdisReleaseSpinLock( &gQuotaLock );
}
PACKET_OWNERSHIP
BrdgBufGetPacketOwnership(
IN PNDIS_PACKET pPacket
)
/*++
Routine Description:
Returns a value indicating who owns this packet (i.e., whether we own this
packet and it is from our copy pool, we own it and it's from our wrapper
pool, or we don't own the packet at all).
Arguments:
pPacket The packet to examine
Return Value:
Ownership enumerated value
--*/
{
NDIS_HANDLE Pool = NdisGetPoolFromPacket(pPacket);
if( Pool == gCopyPacketPoolHandle )
{
return BrdgOwnCopyPacket;
}
else if ( Pool == gWrapperPacketPoolHandle )
{
return BrdgOwnWrapperPacket;
}
return BrdgNotOwned;
}
VOID
BrdgBufFreeWrapperPacket(
IN PNDIS_PACKET pPacket,
IN PPACKET_INFO ppi,
IN PADAPT pQuotaOwner
)
/*++
Routine Description:
Frees a packet allocated from the wrapper pool and releases the quota previously
assigned to the owning adapter
Arguments:
pPacket The packet
ppi The packet's associated info block
pQuotaOwner The adapter previously "charged" for this packet
Return Value:
None
--*/
{
SAFEASSERT( pQuotaOwner != NULL );
SAFEASSERT( pPacket != NULL );
SAFEASSERT( ppi != NULL );
// Free the packet
BrdgBufFreeBaseWrapperPacket( pPacket, ppi );
// Account for this packet having been returned
BrdgBufReleaseQuota( BrdgQuotaWrapperPacket, pQuotaOwner );
}
PNDIS_PACKET
BrdgBufGetBaseCopyPacket(
OUT PPACKET_INFO *pppi
)
/*++
Routine Description:
Returns a new copy packet and associated info block from our pools
WITHOUT CHECKING FOR QUOTA against any particular adapter
This call is made to allocated copy packets for wrapping inbound packets before
any target adapter has been identified.
Arguments:
pppi Receives the info block pointer (NULL if the alloc fails)
Return Value:
The new packet or NULL if the target adapter failed quota
--*/
{
PNDIS_PACKET pPacket;
BOOLEAN bAvail = FALSE;
NdisAcquireSpinLock( &gQuotaLock );
if( gUsedPackets[BrdgQuotaCopyPacket] < gMaxPackets[BrdgQuotaCopyPacket] )
{
// There are packets still available in the pool. Grab one.
bAvail = TRUE;
gUsedPackets[BrdgQuotaCopyPacket]++;
#if DBG
// Keep track of the maximum used packets
if( gMaxUsedPackets[BrdgQuotaCopyPacket] < gUsedPackets[BrdgQuotaCopyPacket] )
{
gMaxUsedPackets[BrdgQuotaCopyPacket] = gUsedPackets[BrdgQuotaCopyPacket];
}
#endif
}
else if( gUsedPackets[BrdgQuotaCopyPacket] == gMaxPackets[BrdgQuotaCopyPacket] )
{
// We are at our limit. Hopefully this doesn't happen too often
ExInterlockedAddLargeStatistic( &gStatOverflows[BrdgQuotaCopyPacket], 1L );
bAvail = FALSE;
}
else
{
// This should never happen; it means we are over our limit somehow
SAFEASSERT( FALSE );
bAvail = FALSE;
}
NdisReleaseSpinLock( &gQuotaLock );
if( ! bAvail )
{
// None available
*pppi = NULL;
return NULL;
}
pPacket = BrdgBufCommonGetPacket( pppi, BrdgBufGetNewCopyPacket, &gFreeCopyPacketList,
&gFreeCopyPacketListLock );
if( pPacket == NULL )
{
// Our allocation failed. Reverse the usage increment.
BrdgBufCountDealloc( BrdgQuotaCopyPacket );
}
return pPacket;
}
PNDIS_PACKET
BrdgBufGetWrapperPacket(
OUT PPACKET_INFO *pppi,
IN PADAPT pAdapt
)
/*++
Routine Description:
Returns a new packet and associated info block from the wrapper pool, unless the
owning adapter does not does pass a quota check
Arguments:
pppi Receives the info block pointer (NULL if the target
adapter fails quota)
pAdapt The adapter to be "charged" for this packet
Return Value:
The new packet or NULL if the target adapter failed quota
--*/
{
PNDIS_PACKET NewPacket = NULL;
*pppi = NULL;
if( BrdgBufAssignQuota(BrdgQuotaWrapperPacket, pAdapt, TRUE/*Count the alloc we are about to do*/) )
{
// Passed quota. We can allocate.
NewPacket = BrdgBufCommonGetPacket( pppi, BrdgBufGetNewWrapperPacket, &gFreeWrapperPacketList,
&gFreeWrapperPacketListLock );
if( NewPacket == NULL )
{
// We failed to allocate even though we haven't yet hit the ceiling on our
// resource pool. This should only happen if we are physically out of non-paged
// memory.
// Reverse the adapter's quota bump
BrdgBufReleaseQuota( BrdgQuotaWrapperPacket, pAdapt );
// Reverse the usage count in BrdgBufAssignQuota
BrdgBufCountDealloc( BrdgQuotaWrapperPacket );
}
}
return NewPacket;
}
VOID
BrdgBufReleaseBasePacketQuota(
IN PNDIS_PACKET pPacket,
IN PADAPT pAdapt
)
/*++
Routine Description:
Called to release the previously assigned cost of a wrapper packet. The packet
provided can be any packet, even one we don't own. If we own the packet, we
decrement the appropriate usage count in the adapter's quota structure.
Arguments:
pPacket The packet the indicated adapter is no longer referring to
pAdapt The adapter no longer referring to pPacket
Return Value:
NULL
--*/
{
PACKET_OWNERSHIP Own = BrdgBufGetPacketOwnership(pPacket);
// This gets called for any base packet, even ones we don't own. Just NOOP if we
// don't own it.
if( Own != BrdgNotOwned )
{
BrdgBufReleaseQuota( (Own == BrdgOwnCopyPacket) ? BrdgQuotaCopyPacket : BrdgQuotaWrapperPacket,
pAdapt );
}
}
BOOLEAN
BrdgBufAssignBasePacketQuota(
IN PNDIS_PACKET pPacket,
IN PADAPT pAdapt
)
/*++
Routine Description:
Called to assign the cost of a base packet to an adapter, which is presumably attempting
to construct a child wrapper packet that refers to the given base packet. A "cost" is
assigned to pAdapt because by building a child wrapper packet that refers to the given
base packet, pAdapt will cause it to not be disposed until it is done using it.
It's OK for the input packet to be a packet we don't own; in that case, there is no cost
to assign so we do nothing.
Arguments:
pPacket The base packet that pAdapt wishes to build a child wrapper packet
referring to.
pAdapt The adapter wishing to refer to pPacket
Return Value:
TRUE : The adapter is permitted to refer to the given base packet
FALSE : The adapter did not pass qutoa and may not refer to the given base packet
--*/
{
PACKET_OWNERSHIP Own = BrdgBufGetPacketOwnership(pPacket);
// We get called for any base packet, even if we don't own it.
if( Own != BrdgNotOwned )
{
return BrdgBufAssignQuota( (Own == BrdgOwnCopyPacket) ? BrdgQuotaCopyPacket : BrdgQuotaWrapperPacket,
pAdapt, FALSE/*We aren't going to do an alloc for this quota bump*/);
}
else
{
return TRUE;
}
}
PNDIS_PACKET
BrdgBufCommonGetPacket(
OUT PPACKET_INFO *pppi,
IN PNEWPACKET_FUNC pNewPacketFunc,
IN PBSINGLE_LIST_HEAD pCacheList,
IN PNDIS_SPIN_LOCK ListLock
)
/*++
Routine Description:
Common processing for retrieving a new packet from either the copy pool or the wrapper pool
Since we know how many packets we've allocated from each pool at all times, the only time this
function should fail is if the host machine is physically out of memory.
Arguments:
pppi Receives the new info block (NULL if the alloc fails, which it shouldn't)
pNewPacketFunc Function to call to alloc a packet if the cache is empty
pCacheList Queue of cached packets that can be used to satisfy the alloc
ListLock The lock to use when manipulating the cache queue
Return Value:
The newly allocated packet, or NULL if severe memory constraints cause the allocation to fail
(this should be unusual)
--*/
{
PNDIS_PACKET pPacket;
PPACKET_INFO ppi;
PBSINGLE_LIST_ENTRY entry;
// Try to get a packet out of our cache.
entry = BrdgInterlockedRemoveHeadSingleList( pCacheList, ListLock );
if( entry == NULL )
{
// Try to allocate a packet and info block from our underlying pools
pPacket = (*pNewPacketFunc)( &ppi );
if( (pPacket == NULL) || (ppi == NULL) )
{
// This should only occur if our host machine is actually out
// of nonpaged memory; we should normally be able to allocate
// up to our preset limit from our pools.
ExInterlockedAddLargeStatistic( &gStatFailures, 1L );
}
}
else
{
ppi = CONTAINING_RECORD( entry, PACKET_INFO, List );
pPacket = ppi->pOwnerPacket;
SAFEASSERT( pPacket != NULL );
}
*pppi = ppi;
return pPacket;
}
VOID
BrdgBufFreeBaseCopyPacket(
IN PNDIS_PACKET pPacket,
IN PPACKET_INFO ppi
)
/*++
Routine Description:
Frees a packet allocated from the copy pool without quota adjustements. This is called directly
from non-buffer-management code to free base packets because the cost for base packets is
assigned and released directly with calls to BrdgBuf<Assign|Release>BasePacketQuota.
Arguments:
pPacket The packet to free
ppi Its info block to free
Return Value:
None
--*/
{
// If we're holding less than our cache amount, free the packet by putting it on the
// cache list
ULONG holding;
PNDIS_BUFFER pBuffer = BrdgBufPacketHeadBuffer( pPacket );
SAFEASSERT( (ppi != NULL) && (pPacket != NULL) );
SAFEASSERT( ppi->pOwnerPacket == pPacket );
SAFEASSERT( pBuffer != NULL );
// Return this packet descriptor to its original state
NdisAdjustBufferLength(pBuffer, MAX_PACKET_SIZE);
NdisAcquireSpinLock( &gFreeCopyPacketListLock );
holding = BrdgQuerySingleListLength( &gFreeCopyPacketList );
if( holding < gSafetyBuffer[BrdgQuotaCopyPacket] )
{
// Prep the packet for reuse
// This blows away the buffer chain
BrdgBufScrubPacket( pPacket, ppi );
// Put the buffer back on
SAFEASSERT( BrdgBufPacketHeadBuffer(pPacket) == NULL );
NdisChainBufferAtFront( pPacket, pBuffer );
// Push the packet onto the list
BrdgInsertHeadSingleList( &gFreeCopyPacketList, &ppi->List );
NdisReleaseSpinLock( &gFreeCopyPacketListLock );
}
else
{
PVOID pBuf;
UINT Size;
NdisReleaseSpinLock( &gFreeCopyPacketListLock );
NdisQueryBufferSafe( pBuffer, &pBuf, &Size, NormalPagePriority );
// Free the packet, the packet info block and the copy buffer to the underlying pools
NdisFreeBuffer( pBuffer );
NdisFreePacket( pPacket );
NdisFreeToNPagedLookasideList( &gPktInfoList, ppi );
if( pBuf != NULL )
{
NdisFreeToNPagedLookasideList( &gCopyBufferList, pBuf );
}
else
{
// Shouldn't be possible since the alloced memory is in kernel space
SAFEASSERT( FALSE );
}
}
// Note the deallocation
BrdgBufCountDealloc( BrdgQuotaCopyPacket );
}
VOID
BrdgBufFreeBaseWrapperPacket(
IN PNDIS_PACKET pPacket,
IN PPACKET_INFO ppi
)
/*++
Routine Description:
Frees a packet allocated from the wrapper pool without quota adjustements. This is called directly
from non-buffer-management code to free base packets because the cost for base packets is
assigned and released directly with calls to BrdgBuf<Assign|Release>BasePacketQuota.
Arguments:
pPacket The packet to free
ppi Its info block to free
Return Value:
None
--*/
{
// If we're holding less than our cache amount, free the packet by putting it on the
// cache list
ULONG holding;
SAFEASSERT( (ppi != NULL) && (pPacket != NULL) );
SAFEASSERT( ppi->pOwnerPacket == pPacket );
NdisAcquireSpinLock( &gFreeWrapperPacketListLock );
holding = BrdgQuerySingleListLength( &gFreeWrapperPacketList );
if( holding < gSafetyBuffer[BrdgQuotaWrapperPacket] )
{
// Prep the packet for reuse
SAFEASSERT( BrdgBufPacketHeadBuffer(pPacket) == NULL );
BrdgBufScrubPacket( pPacket, ppi );
// Push the packet onto the list
BrdgInsertHeadSingleList( &gFreeWrapperPacketList, &ppi->List );
NdisReleaseSpinLock( &gFreeWrapperPacketListLock );
}
else
{
NdisReleaseSpinLock( &gFreeWrapperPacketListLock );
// Free the packet and packet info block to the underlying pools
NdisFreePacket( pPacket );
NdisFreeToNPagedLookasideList( &gPktInfoList, ppi );
}
// Note the deallocation
BrdgBufCountDealloc( BrdgQuotaWrapperPacket );
}
NDIS_STATUS
BrdgBufChainCopyBuffers(
IN PNDIS_PACKET pTargetPacket,
IN PNDIS_PACKET pSourcePacket
)
/*++
Routine Description:
Allocates and chains buffer descriptors onto the target packet so it describes exactly
the same areas of memory as the source packet
Arguments:
pTargetPacket Target packet
pSourcePacket Source packet
Return Value:
Status of the operation. We have a limited-size pool of packet descriptors, so this
operation can fail if we run out.
--*/
{
PNDIS_BUFFER pCopyBuffer, pCurBuf = BrdgBufPacketHeadBuffer( pSourcePacket );
NDIS_STATUS Status;
SAFEASSERT( BrdgBufPacketHeadBuffer(pTargetPacket) == NULL );
// There must be something in the source packet!
if( pCurBuf == NULL )
{
SAFEASSERT( FALSE );
return NDIS_STATUS_RESOURCES;
}
while( pCurBuf != NULL )
{
PVOID p;
UINT Length;
// Pull the virtual address and size out of the MDL being copied
NdisQueryBufferSafe( pCurBuf, &p, &Length, NormalPagePriority );
if( p == NULL )
{
BrdgBufUnchainCopyBuffers( pTargetPacket );
return NDIS_STATUS_RESOURCES;
}
// Is wacky to have a MDL describing no memory
if( Length > 0 )
{
// Get a new MDL from our pool and point it to the same address
NdisAllocateBuffer( &Status, &pCopyBuffer, gWrapperBufferPoolHandle, p, Length );
if( Status != NDIS_STATUS_SUCCESS )
{
THROTTLED_DBGPRINT(BUF, ("Failed to allocate a MDL in BrdgBufChainCopyBuffers: %08x\n", Status));
BrdgBufUnchainCopyBuffers( pTargetPacket );
return Status;
}
// Use the new MDL to chain to the target packet
NdisChainBufferAtBack( pTargetPacket, pCopyBuffer );
}
else
{
SAFEASSERT( FALSE );
}
NdisGetNextBuffer( pCurBuf, &pCurBuf );
}
return NDIS_STATUS_SUCCESS;
}
NTSTATUS
BrdgBufDriverInit( )
/*++
Routine Description:
Driver-load-time initialization routine.
Arguments:
None
Return Value:
Status of initialization. A return code != STATUS_SUCCESS causes the driver load to fail.
Any event causing an error return code must be logged.
--*/
{
NDIS_STATUS Status;
ULONG NumCopyPackets, ConsumptionPerCopyPacket, SizeOfPacket, i;
ULONG MaxMemory = 0L, SafetyMargin = 0L;
NTSTATUS NtStatus;
// Initialize protective locks
NdisAllocateSpinLock( &gFreeCopyPacketListLock );
NdisAllocateSpinLock( &gFreeWrapperPacketListLock );
NdisAllocateSpinLock( &gQuotaLock );
// Initialize cache lists
BrdgInitializeSingleList( &gFreeCopyPacketList );
BrdgInitializeSingleList( &gFreeWrapperPacketList );
// Initialize look-aside lists for receive buffers and packet info blocks
NdisInitializeNPagedLookasideList( &gCopyBufferList, NULL, NULL, 0, MAX_PACKET_SIZE, 'gdrB', 0 );
NdisInitializeNPagedLookasideList( &gPktInfoList, NULL, NULL, 0, sizeof(PACKET_INFO), 'gdrB', 0 );
// Initialize the miniport's quota information
BrdgBufInitializeQuota( &gMiniportQuota );
//
// Read in registry values. Substitute default values on failure.
//
NtStatus = BrdgReadRegDWord( &gRegistryPath, gMaxBufMemoryParameterName, &MaxMemory );
if( NtStatus != STATUS_SUCCESS )
{
MaxMemory = DEFAULT_MAX_BUF_MEMORY;
DBGPRINT(BUF, ( "Using DEFAULT maximum memory of %i\n", MaxMemory ));
}
NtStatus = BrdgReadRegDWord( &gRegistryPath, gSafetyMarginParameterName, &SafetyMargin );
if( NtStatus != STATUS_SUCCESS )
{
SafetyMargin = DEFAULT_SAFETY_MARGIN;
DBGPRINT(BUF, ( "Using DEFAULT safety margin of %i%%\n", SafetyMargin ));
}
//
// Figure out the maximum number of packet descriptors in each pool we can allocate in order to
// fit in the prescribed maximum memory space.
//
// For every copy packet, we allow ourselves GUESS_AVERAGE_FANOUT wrapper packets.
// *Each* wrapper packet is allowed to consume GUESS_BUFFERS_PER_PACKET MDLs.
// Given these relationships, we can calculate the number of copy packets that will fit in a given
// memory footprint. The max for all other resources are set in relationship to that number.
//
SizeOfPacket = NdisPacketSize( PROTOCOL_RESERVED_SIZE_IN_PACKET );
ConsumptionPerCopyPacket = SizeOfPacket * (GUESS_AVERAGE_FANOUT + 1) + // Packet decriptor memory
MAX_PACKET_SIZE + // Copy buffer memory
sizeof(PACKET_INFO) * (GUESS_AVERAGE_FANOUT + 1) + // Packet info block memory
sizeof(NDIS_BUFFER) * ((GUESS_AVERAGE_FANOUT * GUESS_BUFFERS_PER_PACKET) + 1); // MDL memory
NumCopyPackets = MaxMemory / ConsumptionPerCopyPacket;
// Allocate the packet pools
NdisAllocatePacketPool( &Status, &gCopyPacketPoolHandle, NumCopyPackets, PROTOCOL_RESERVED_SIZE_IN_PACKET );
if( Status != NDIS_STATUS_SUCCESS )
{
NdisDeleteNPagedLookasideList( &gCopyBufferList );
NdisDeleteNPagedLookasideList( &gPktInfoList );
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_PACKET_POOL_CREATION_FAILED, 0L, 0L, NULL,
sizeof(NDIS_STATUS), &Status );
DBGPRINT(BUF, ("Unable to allocate copy-packet pool: %08x\n", Status));
return STATUS_INSUFFICIENT_RESOURCES;
}
NdisAllocatePacketPool( &Status, &gWrapperPacketPoolHandle, GUESS_AVERAGE_FANOUT * NumCopyPackets, PROTOCOL_RESERVED_SIZE_IN_PACKET );
if( Status != NDIS_STATUS_SUCCESS )
{
NdisDeleteNPagedLookasideList( &gCopyBufferList );
NdisDeleteNPagedLookasideList( &gPktInfoList );
NdisFreePacketPool( gCopyPacketPoolHandle );
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_PACKET_POOL_CREATION_FAILED, 0L, 0L, NULL,
sizeof(NDIS_STATUS), &Status );
DBGPRINT(BUF, ("Unable to allocate wrapper packet pool: %08x\n", Status));
return STATUS_INSUFFICIENT_RESOURCES;
}
// Allocate the buffer pools
NdisAllocateBufferPool( &Status, &gCopyBufferPoolHandle, NumCopyPackets );
if( Status != NDIS_STATUS_SUCCESS )
{
NdisDeleteNPagedLookasideList( &gCopyBufferList );
NdisDeleteNPagedLookasideList( &gPktInfoList );
NdisFreePacketPool( gCopyPacketPoolHandle );
NdisFreePacketPool( gWrapperPacketPoolHandle );
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_BUFFER_POOL_CREATION_FAILED, 0L, 0L, NULL,
sizeof(NDIS_STATUS), &Status );
DBGPRINT(BUF, ("Unable to allocate copy buffer pool: %08x\n", Status));
return STATUS_INSUFFICIENT_RESOURCES;
}
NdisAllocateBufferPool( &Status, &gWrapperBufferPoolHandle, GUESS_AVERAGE_FANOUT * GUESS_BUFFERS_PER_PACKET * NumCopyPackets );
if( Status != NDIS_STATUS_SUCCESS )
{
NdisDeleteNPagedLookasideList( &gCopyBufferList );
NdisDeleteNPagedLookasideList( &gPktInfoList );
NdisFreePacketPool( gCopyPacketPoolHandle );
NdisFreePacketPool( gWrapperPacketPoolHandle );
NdisFreeBufferPool( gCopyBufferPoolHandle );
NdisWriteEventLogEntry( gDriverObject, EVENT_BRIDGE_BUFFER_POOL_CREATION_FAILED, 0L, 0L, NULL,
sizeof(NDIS_STATUS), &Status );
DBGPRINT(BUF, ("Unable to allocate wrapper buffer pool: %08x\n", Status));
return STATUS_INSUFFICIENT_RESOURCES;
}
gInitedCopyBufferList = gInitedPktInfoList = TRUE;
// Note the number of each packet type
gMaxPackets[BrdgQuotaCopyPacket] = NumCopyPackets;
gMaxPackets[BrdgQuotaWrapperPacket] = NumCopyPackets * GUESS_AVERAGE_FANOUT;
// Calculate the safety buffer size in packets
SAFEASSERT( SafetyMargin > 0L );
gSafetyBuffer[BrdgQuotaCopyPacket] = (gMaxPackets[BrdgQuotaCopyPacket] * SafetyMargin) / 100;
gSafetyBuffer[BrdgQuotaWrapperPacket] = (gMaxPackets[BrdgQuotaWrapperPacket] * SafetyMargin) / 100;
DBGPRINT(BUF, ( "Max memory usage of %d == %d copy packets, %d wrapper packets, %d copy-buffer space, %d/%d safety packets\n",
MaxMemory, gMaxPackets[0], gMaxPackets[1], NumCopyPackets * MAX_PACKET_SIZE, gSafetyBuffer[0], gSafetyBuffer[1] ));
// Pre-allocate the appropriate number of packets from each pool for perf.
for( i = 0; i < gSafetyBuffer[BrdgQuotaCopyPacket]; i++ )
{
PNDIS_PACKET pPacket;
PPACKET_INFO ppi;
pPacket = BrdgBufGetNewCopyPacket( &ppi );
// Should be impossible for this to fail
if( (pPacket != NULL) && (ppi != NULL) )
{
// Count the usage ourselves because we're not going through normal channels
gUsedPackets[BrdgQuotaCopyPacket]++;
// This should retain the packet in memory and decrement the usage count
BrdgBufFreeBaseCopyPacket( pPacket, ppi );
}
else
{
SAFEASSERT( FALSE );
}
}
for( i = 0; i < gSafetyBuffer[BrdgQuotaWrapperPacket]; i++ )
{
PNDIS_PACKET pPacket;
PPACKET_INFO ppi;
pPacket = BrdgBufGetNewWrapperPacket( &ppi );
// Should be impossible for this to fail
if( (pPacket != NULL) && (ppi != NULL) )
{
// Count the usage ourselves because we're not going through normal channels
gUsedPackets[BrdgQuotaWrapperPacket]++;
// This should retain the packet in memory and decrement the usage count
BrdgBufFreeBaseWrapperPacket( pPacket, ppi );
}
else
{
SAFEASSERT( FALSE );
}
}
return STATUS_SUCCESS;
}
VOID
BrdgBufCleanup()
/*++
Routine Description:
Unload-time orderly shutdown
This function is guaranteed to be called exactly once
Arguments:
None
Return Value:
None
--*/
{
NDIS_HANDLE TmpHandle;
if( gCopyPacketPoolHandle != NULL )
{
PBSINGLE_LIST_ENTRY entry;
TmpHandle = gCopyPacketPoolHandle;
gCopyPacketPoolHandle = NULL;
// Free all cached packets before freeing the pool
entry = BrdgInterlockedRemoveHeadSingleList( &gFreeCopyPacketList, &gFreeCopyPacketListLock );
while( entry != NULL )
{
PNDIS_PACKET pPacket;
PPACKET_INFO ppi;
PNDIS_BUFFER pBuffer;
ppi = CONTAINING_RECORD( entry, PACKET_INFO, List );
pPacket = ppi->pOwnerPacket;
SAFEASSERT( pPacket != NULL );
// Pull off the data buffer
NdisUnchainBufferAtFront( pPacket, &pBuffer );
if( pBuffer != NULL )
{
PVOID pBuf;
UINT Size;
NdisQueryBufferSafe( pBuffer, &pBuf, &Size, NormalPagePriority );
if( pBuf != NULL )
{
// Ditch the data buffer
NdisFreeToNPagedLookasideList( &gCopyBufferList, pBuf );
}
// else can only fail under extreme memory pressure
NdisFreeBuffer( pBuffer );
}
else
{
// This packet should have a chained buffer
SAFEASSERT( FALSE );
}
NdisFreePacket( pPacket );
NdisFreeToNPagedLookasideList( &gPktInfoList, ppi );
entry = BrdgInterlockedRemoveHeadSingleList( &gFreeCopyPacketList, &gFreeCopyPacketListLock );
}
// Free the pool now that all packets have been returned
NdisFreePacketPool( TmpHandle );
}
if( gWrapperPacketPoolHandle != NULL )
{
PBSINGLE_LIST_ENTRY entry;
TmpHandle = gWrapperPacketPoolHandle;
gWrapperPacketPoolHandle = NULL;
// Free all cached packets before freeing the pool
entry = BrdgInterlockedRemoveHeadSingleList( &gFreeWrapperPacketList, &gFreeWrapperPacketListLock );
while( entry != NULL )
{
PNDIS_PACKET pPacket;
PPACKET_INFO ppi;
ppi = CONTAINING_RECORD( entry, PACKET_INFO, List );
pPacket = ppi->pOwnerPacket;
SAFEASSERT( pPacket != NULL );
NdisFreePacket( pPacket );
NdisFreeToNPagedLookasideList( &gPktInfoList, ppi );
entry = BrdgInterlockedRemoveHeadSingleList( &gFreeWrapperPacketList, &gFreeWrapperPacketListLock );
}
// Free the pool now that all packets have been returned
NdisFreePacketPool( TmpHandle );
}
// The two lookaside lists should now be empty as well
if( gInitedCopyBufferList )
{
gInitedCopyBufferList = FALSE;
NdisDeleteNPagedLookasideList( &gCopyBufferList );
}
if( gInitedPktInfoList )
{
gInitedPktInfoList = FALSE;
NdisDeleteNPagedLookasideList( &gPktInfoList );
}
if( gCopyBufferPoolHandle != NULL )
{
TmpHandle = gCopyBufferPoolHandle;
gCopyBufferPoolHandle = NULL;
NdisFreeBufferPool( TmpHandle );
}
if( gWrapperBufferPoolHandle != NULL )
{
TmpHandle = gWrapperBufferPoolHandle;
gWrapperBufferPoolHandle = NULL;
NdisFreeBufferPool( TmpHandle );
}
}
// ===========================================================================
//
// PRIVATE FUNCTIONS
//
// ===========================================================================
BOOLEAN
BrdgBufAssignQuota(
IN QUOTA_PACKET_TYPE type,
IN PADAPT pAdapt,
IN BOOLEAN bCountAlloc
)
/*++
Routine Description:
Determines whether a particular adapter should be permitted to allocate a new packet
from a particular pool. Implements our quota algorithm.
This can be called either to pre-approve an actual memory allocation or to check if
an adapter should be permitted to refer to a base packet in constructing a child
wrapper packet
Arguments:
type Type of packet pAdapt wishes to allocate or refer to
pAdapt The adapter involved
bCountAlloc Whether this is a check before an actual allocation. If it
is, the global usage counts will be incremented within the
gQuotaLock spin lock so everything is atomic
Return Value:
TRUE : The adapter is permitted to allocate / refer
FALSE : The adapter is not permitted to allocate / refer
--*/
{
BOOLEAN rc;
PADAPTER_QUOTA pQuota = QUOTA_FROM_ADAPTER(pAdapt);
UINT index = INDEX_FROM_TYPE(type);
// Freeze this value for the duration of the function
ULONG numAdapters = gNumAdapters;
NdisAcquireSpinLock( &gQuotaLock );
if( (numAdapters > 0) && (pQuota->UsedPackets[index] < (gMaxPackets[index] - gSafetyBuffer[index]) / numAdapters) )
{
// This adapter is under its "fair share"; it can allocate if there are actually
// any packets left!
if( gUsedPackets[index] < gMaxPackets[index] )
{
// There are packets left. This is the normal case.
rc = TRUE;
}
else if( gUsedPackets[index] == gMaxPackets[index] )
{
// This should be unusual; we've blown past our safety buffer. Hopefully this is
// transitory.
ExInterlockedAddLargeStatistic( &gStatOverflows[index], 1L );
rc = FALSE;
}
else
{
// This should never happen; it means we have allocated more than we should be able
// to.
SAFEASSERT( FALSE );
rc = FALSE;
}
}
else
{
// This adapter is over its "fair share"; it can allocate only if there are more packets
// left than the safety buffer calls for
if( gMaxPackets[index] - gUsedPackets[index] > gSafetyBuffer[index] )
{
rc = TRUE;
}
else
{
// We're too close to the wire; deny the request.
rc = FALSE;
}
}
if( rc )
{
pQuota->UsedPackets[index]++;
if( bCountAlloc )
{
// The caller will allocate. Count the allocation before releasing the spin lock.
gUsedPackets[index]++;
#if DBG
// Keep track of the maximum used packets
if( gMaxUsedPackets[index] < gUsedPackets[index] )
{
gMaxUsedPackets[index] = gUsedPackets[index];
}
#endif
}
}
NdisReleaseSpinLock( &gQuotaLock );
return rc;
}
PNDIS_PACKET
BrdgBufGetNewCopyPacket(
OUT PPACKET_INFO *pppi
)
/*++
Routine Description:
Allocates a brand new packet from the copy-packet pool. Every copy packet comes with
an associated data buffer large enough to hold a complete Ethernet frame, so the allocation
attempt has several steps
Arguments:
pppi The packet's info block, or NULL if the allocation fails
Return Value:
The new packet
--*/
{
PNDIS_PACKET pPacket;
PPACKET_INFO ppi;
// Try to allocate a packet and info block from our underlying pools
pPacket = BrdgBufCommonGetNewPacket( gCopyPacketPoolHandle, &ppi );
if( (pPacket == NULL) || (ppi == NULL) )
{
SAFEASSERT( (pPacket == NULL) && (ppi == NULL) );
}
else
{
PVOID pBuf;
// Allocate a copy buffer for the packet
pBuf = NdisAllocateFromNPagedLookasideList( &gCopyBufferList );
if( pBuf == NULL )
{
NdisFreePacket( pPacket );
NdisFreeToNPagedLookasideList( &gPktInfoList, ppi );
ppi = NULL;
pPacket = NULL;
}
else
{
NDIS_STATUS Status;
PNDIS_BUFFER pBuffer;
// Allocate a buffer descriptor for the copy buffer
NdisAllocateBuffer( &Status, &pBuffer, gCopyBufferPoolHandle, pBuf, MAX_PACKET_SIZE );
if( Status != NDIS_STATUS_SUCCESS )
{
NdisFreePacket( pPacket );
NdisFreeToNPagedLookasideList( &gPktInfoList, ppi );
NdisFreeToNPagedLookasideList( &gCopyBufferList, pBuf );
ppi = NULL;
pPacket = NULL;
}
else
{
SAFEASSERT( pBuffer != NULL );
NdisChainBufferAtFront( pPacket, pBuffer );
}
}
}
*pppi = ppi;
return pPacket;
}
PNDIS_PACKET
BrdgBufCommonGetNewPacket(
IN NDIS_HANDLE Pool,
OUT PPACKET_INFO *pppi
)
/*++
Routine Description:
Common logic for allocating a brand new packet from either the wrapper pool or the copy pool.
Every packet of any flavor comes with an associated info block. Both the alloc of the
packet descriptor and the info block must succeed for the packet allocation to succeed.
Arguments:
Pool The pool to allocate from
pppi The allocated info block or NULL if the alloc failed
Return Value:
The new packet or NULL if the alloc failed
--*/
{
PNDIS_PACKET pPacket;
PPACKET_INFO ppi;
NDIS_STATUS Status;
// Try to allocate a new packet descriptor
NdisAllocatePacket( &Status, &pPacket, Pool );
if( Status != NDIS_STATUS_SUCCESS )
{
*pppi = NULL;
return NULL;
}
SAFEASSERT( pPacket != NULL );
// Try to allocate a new packet info block
ppi = NdisAllocateFromNPagedLookasideList( &gPktInfoList );
if( ppi == NULL )
{
NdisFreePacket( pPacket );
pPacket = NULL;
}
else
{
ppi->pOwnerPacket = pPacket;
}
*pppi = ppi;
return pPacket;
}