able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/nwlink/spx/spxmem.c

1368 lines
43 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1989-1993 Microsoft Corporation
Module Name:
spxmem.c
Abstract:
This module contains code which implements the memory allocation wrappers.
Author:
Nikhil Kamkolkar (nikhilk) 11-November-1993
Jameel Hyder (jameelh) Initial Version
Environment:
Kernel mode
Revision History:
--*/
#include "precomp.h"
#pragma hdrstop
#ifdef ALLOC_PRAGMA
#pragma alloc_text( INIT, SpxInitMemorySystem)
#pragma alloc_text( PAGE, SpxDeInitMemorySystem)
#endif
#if !defined SPX_OWN_PACKETS
typedef struct NdisResEntry {
struct NdisResEntry *nre_next;
NDIS_HANDLE nre_handle;
uchar *nre_buffer;
} NdisResEntry;
NdisResEntry *SendPacketPoolList = NULL;
SLIST_HEADER SendPacketList;
NdisResEntry *RecvPacketPoolList = NULL;
SLIST_HEADER RecvPacketList;
DEFINE_LOCK_STRUCTURE(SendHeaderLock);
DEFINE_LOCK_STRUCTURE(RecvHeaderLock);
uint CurrentSendPacketCount = 0;
uint CurrentRecvPacketCount = 0;
uint MaxPacketCount = 0x0ffffff;
#define PACKET_GROW_COUNT 16
#endif // SPX_OWN_PACKETS
// Define module number for event logging entries
#define FILENUM SPXMEM
// Globals for this module
// Some block sizes (like NDISSEND/NDISRECV are filled in after binding with IPX)
USHORT spxBlkSize[NUM_BLKIDS] = // Size of each block
{
sizeof(BLK_HDR)+sizeof(TIMERLIST), // BLKID_TIMERLIST
0, // BLKID_NDISSEND
0 // BLKID_NDISRECV
};
USHORT spxChunkSize[NUM_BLKIDS] = // Size of each Chunk
{
512-BC_OVERHEAD, // BLKID_TIMERLIST
512-BC_OVERHEAD, // BLKID_NDISSEND
512-BC_OVERHEAD // BLKID_NDISRECV
};
// Filled in after binding with IPX
// Reference for below.
// ( 512-BC_OVERHEAD-sizeof(BLK_CHUNK))/
// (sizeof(BLK_HDR)+sizeof(TIMERLIST)), // BLKID_TIMERLIST
USHORT spxNumBlks[NUM_BLKIDS] = // Number of blocks per chunk
{
( 512-BC_OVERHEAD-sizeof(BLK_CHUNK))/
(sizeof(BLK_HDR)+sizeof(TIMERLIST)), // BLKID_TIMERLIST
0, // BLKID_NDISSEND
0 // BLKID_NDISRECV
};
CTELock spxBPLock[NUM_BLKIDS] = { 0 };
PBLK_CHUNK spxBPHead[NUM_BLKIDS] = { 0 };
NTSTATUS
SpxInitMemorySystem(
IN PDEVICE pSpxDevice
)
/*++
Routine Description:
!!! MUST BE CALLED AFTER BINDING TO IPX!!!
Arguments:
Return Value:
--*/
{
LONG i;
NDIS_STATUS ndisStatus;
// Try to allocate the ndis buffer pool.
NdisAllocateBufferPool(
&ndisStatus,
&pSpxDevice->dev_NdisBufferPoolHandle,
20);
if (ndisStatus != NDIS_STATUS_SUCCESS)
return(STATUS_INSUFFICIENT_RESOURCES);
for (i = 0; i < NUM_BLKIDS; i++)
CTEInitLock (&spxBPLock[i]);
// Set the sizes in the block id info arrays.
for (i = 0; i < NUM_BLKIDS; i++)
{
switch (i)
{
case BLKID_NDISSEND:
#ifdef SPX_OWN_PACKETS
spxBlkSize[i] = sizeof(BLK_HDR) +
sizeof(SPX_SEND_RESD) +
NDIS_PACKET_SIZE +
IpxMacHdrNeeded +
MIN_IPXSPX2_HDRSIZE;
#else
spxBlkSize[i] = sizeof(PNDIS_PACKET);
#endif
//
// Round the block size up to the next 8-byte boundary.
//
spxBlkSize[i] = QWORDSIZEBLOCK(spxBlkSize[i]);
// Set number blocks
spxNumBlks[i] = ( 512-BC_OVERHEAD-sizeof(BLK_CHUNK))/spxBlkSize[i];
break;
case BLKID_NDISRECV:
#ifdef SPX_OWN_PACKETS
spxBlkSize[i] = sizeof(BLK_HDR) +
sizeof(SPX_RECV_RESD) +
NDIS_PACKET_SIZE;
#else
spxBlkSize[i] = sizeof(PNDIS_PACKET);
#endif
//
// Round the block size up to the next 8-byte boundary.
//
spxBlkSize[i] = QWORDSIZEBLOCK(spxBlkSize[i]);
// Set number blocks
spxNumBlks[i] = ( 512-BC_OVERHEAD-sizeof(BLK_CHUNK))/spxBlkSize[i];
break;
default:
break;
}
}
SpxTimerScheduleEvent((TIMER_ROUTINE)spxBPAgePool,
BLOCK_POOL_TIMER,
NULL);
return STATUS_SUCCESS;
}
VOID
SpxDeInitMemorySystem(
IN PDEVICE pSpxDevice
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
LONG i, j, NumBlksPerChunk;
PBLK_CHUNK pChunk, pFree;
for (i = 0; i < NUM_BLKIDS; i++)
{
NumBlksPerChunk = spxNumBlks[i];
for (pChunk = spxBPHead[i];
pChunk != NULL; )
{
DBGPRINT(RESOURCES, ERR,
("SpxInitMemorySystem: Freeing %lx\n", pChunk));
CTEAssert (pChunk->bc_NumFrees == NumBlksPerChunk);
if ((pChunk->bc_BlkId == BLKID_NDISSEND) ||
(pChunk->bc_BlkId == BLKID_NDISRECV))
{
PBLK_HDR pBlkHdr;
// We need to free the Ndis stuff for these guys
for (j = 0, pBlkHdr = pChunk->bc_FreeHead;
j < NumBlksPerChunk;
j++, pBlkHdr = pBlkHdr->bh_Next)
{
PNDIS_PACKET pNdisPkt;
PNDIS_BUFFER pNdisBuffer;
#ifdef SPX_OWN_PACKETS
// Only need to free the ndis buffer.
pNdisPkt = (PNDIS_PACKET)((PBYTE)pBlkHdr + sizeof(BLK_HDR));
if (pChunk->bc_BlkId == BLKID_NDISSEND)
{
NdisUnchainBufferAtFront(pNdisPkt, &pNdisBuffer);
if (pNdisBuffer == NULL)
{
// Something is terribly awry.
KeBugCheck(0);
}
NdisFreeBuffer(pNdisBuffer);
//
// Free the second MDL also
//
NdisUnchainBufferAtFront(pNdisPkt, &pNdisBuffer);
if (pNdisBuffer == NULL)
{
// Something is terribly awry.
KeBugCheck(0);
}
NdisFreeBuffer(pNdisBuffer);
}
#else
/* // Need to free both the packet and the buffer.
pNdisPkt = (PNDIS_PACKET *)((PBYTE)pBlkHdr + sizeof(BLK_HDR));
if (pChunk->bc_BlkId == BLKID_NDISSEND)
{
NdisUnchainBufferAtFront(*pNdisPkt, &pNdisBuffer);
if (pNdisBuffer == NULL)
{
// Something is terribly awry.
KeBugCheck(0);
}
NdisFreeBuffer(pNdisBuffer);
}
NdisFreePacket(*pNdisPkt);
*/
#endif
}
}
pFree = pChunk;
pChunk = pChunk->bc_Next;
#ifndef SPX_OWN_PACKETS
/*
// Free the ndis packet pool in chunk
NdisFreePacketPool((NDIS_HANDLE)pFree->bc_ChunkCtx); */
#endif
SpxFreeMemory(pFree);
}
}
// Free up the ndis buffer pool
NdisFreeBufferPool(
pSpxDevice->dev_NdisBufferPoolHandle);
return;
}
PVOID
SpxAllocMem(
#ifdef TRACK_MEMORY_USAGE
IN ULONG Size,
IN ULONG FileLine
#else
IN ULONG Size
#endif // TRACK_MEMORY_USAGE
)
/*++
Routine Description:
Allocate a block of non-paged memory. This is just a wrapper over ExAllocPool.
Allocation failures are error-logged. We always allocate a ULONG more than
the specified size to accomodate the size. This is used by SpxFreeMemory
to update the statistics.
Arguments:
Return Value:
--*/
{
PBYTE pBuf;
BOOLEAN zeroed;
// round up the size so that we can put a signature at the end
// that is on a LARGE_INTEGER boundary
zeroed = ((Size & ZEROED_MEMORY_TAG) == ZEROED_MEMORY_TAG);
Size = QWORDSIZEBLOCK(Size & ~ZEROED_MEMORY_TAG);
// Do the actual memory allocation. Allocate eight extra bytes so
// that we can store the size of the allocation for the free routine
// and still keep the buffer quadword aligned.
if ((pBuf = ExAllocatePoolWithTag(NonPagedPool, Size + sizeof(LARGE_INTEGER)
#if DBG
+ sizeof(ULONG)
#endif
,SPX_TAG)) == NULL)
{
DBGPRINT(RESOURCES, FATAL,
("SpxAllocMemory: failed - size %lx\n", Size));
TMPLOGERR();
return NULL;
}
// Save the size of this block in the four extra bytes we allocated.
*((PULONG)pBuf) = (Size + sizeof(LARGE_INTEGER));
// Return a pointer to the memory after the size longword.
pBuf += sizeof(LARGE_INTEGER);
#if DBG
*((PULONG)(pBuf+Size)) = SPX_MEMORY_SIGNATURE;
DBGPRINT(RESOURCES, INFO,
("SpxAllocMemory: %p Allocated %lx bytes @%p\n",
_ReturnAddress(), Size, pBuf));
#endif
SpxTrackMemoryUsage((PVOID)(pBuf - sizeof(LARGE_INTEGER)), TRUE, FileLine);
if (zeroed)
RtlZeroMemory(pBuf, Size);
return (pBuf);
}
VOID
SpxFreeMemory(
IN PVOID pBuf
)
/*++
Routine Description:
Free the block of memory allocated via SpxAllocMemory. This is
a wrapper around ExFreePool.
Arguments:
Return Value:
--*/
{
PULONG pRealBuffer;
// Get a pointer to the block allocated by ExAllocatePool --
// we allocate a LARGE_INTEGER at the front.
pRealBuffer = ((PULONG)pBuf - 2);
SpxTrackMemoryUsage(pRealBuffer, FALSE, 0);
#if DBG
// Check the signature at the end
if (*(PULONG)((PCHAR)pRealBuffer + *(PULONG)pRealBuffer)
!= SPX_MEMORY_SIGNATURE)
{
DBGPRINT(RESOURCES, FATAL,
("SpxFreeMemory: Memory overrun on block %lx\n", pRealBuffer));
DBGBRK(FATAL);
}
*(PULONG)((PCHAR)pRealBuffer + *(PULONG)pRealBuffer) = 0;
#endif
#if DBG
*pRealBuffer = 0;
#endif
// Free the pool and return.
ExFreePool(pRealBuffer);
}
#ifdef TRACK_MEMORY_USAGE
#define MAX_PTR_COUNT 4*1024
#define MAX_MEM_USERS 512
CTELock spxMemTrackLock = {0};
CTELockHandle lockHandle = {0};
struct
{
PVOID mem_Ptr;
ULONG mem_FileLine;
} spxMemPtrs[MAX_PTR_COUNT] = {0};
struct
{
ULONG mem_FL;
ULONG mem_Count;
} spxMemUsage[MAX_MEM_USERS] = {0};
VOID
SpxTrackMemoryUsage(
IN PVOID pMem,
IN BOOLEAN Alloc,
IN ULONG FileLine
)
/*++
Routine Description:
Keep track of memory usage by storing and clearing away pointers as and
when they are allocated or freed. This helps in keeping track of memory
leaks.
Arguments:
Return Value:
--*/
{
static int i = 0;
int j, k;
CTEGetLock (&spxMemTrackLock, &lockHandle);
if (Alloc)
{
for (j = 0; j < MAX_PTR_COUNT; i++, j++)
{
i = i & (MAX_PTR_COUNT-1);
if (spxMemPtrs[i].mem_Ptr == NULL)
{
spxMemPtrs[i].mem_Ptr = pMem;
spxMemPtrs[i++].mem_FileLine = FileLine;
break;
}
}
for (k = 0; k < MAX_MEM_USERS; k++)
{
if (spxMemUsage[k].mem_FL == FileLine)
{
spxMemUsage[k].mem_Count ++;
break;
}
}
if (k == MAX_MEM_USERS)
{
for (k = 0; k < MAX_MEM_USERS; k++)
{
if (spxMemUsage[k].mem_FL == 0)
{
spxMemUsage[k].mem_FL = FileLine;
spxMemUsage[k].mem_Count = 1;
break;
}
}
}
if (k == MAX_MEM_USERS)
{
DBGPRINT(RESOURCES, ERR,
("SpxTrackMemoryUsage: Out of space on spxMemUsage !!!\n"));
DBGBRK(FATAL);
}
}
else
{
for (j = 0, k = i; j < MAX_PTR_COUNT; j++, k--)
{
k = k & (MAX_PTR_COUNT-1);
if (spxMemPtrs[k].mem_Ptr == pMem)
{
spxMemPtrs[k].mem_Ptr = 0;
spxMemPtrs[k].mem_FileLine = 0;
break;
}
}
}
CTEFreeLock (&spxMemTrackLock, lockHandle);
if (j == MAX_PTR_COUNT)
{
DBGPRINT(RESOURCES, ERR,
("SpxTrackMemoryUsage: %s\n", Alloc ? "Table Full" : "Can't find"));
DBGBRK(FATAL);
}
}
#endif // TRACK_MEMORY_USAGE
PVOID
SpxBPAllocBlock(
IN BLKID BlockId
)
/*++
Routine Description:
Alloc a block of memory from the block pool package. This is written to speed up
operations where a lot of small fixed size allocations/frees happen. Going to
ExAllocPool() in these cases is expensive.
Arguments:
Return Value:
--*/
{
PBLK_HDR pBlk = NULL;
PBLK_CHUNK pChunk, *ppChunkHead;
USHORT BlkSize;
CTELockHandle lockHandle;
PSPX_SEND_RESD pSendResd;
PSPX_RECV_RESD pRecvResd;
PNDIS_PACKET pNdisPkt;
PNDIS_BUFFER pNdisBuffer;
PNDIS_BUFFER pNdisIpxSpxBuffer;
CTEAssert (BlockId < NUM_BLKIDS);
if (BlockId < NUM_BLKIDS)
{
BlkSize = spxBlkSize[BlockId];
ppChunkHead = &spxBPHead[BlockId];
CTEGetLock(&spxBPLock[BlockId], &lockHandle);
for (pChunk = *ppChunkHead;
pChunk != NULL;
pChunk = pChunk->bc_Next)
{
CTEAssert(pChunk->bc_BlkId == BlockId);
if (pChunk->bc_NumFrees > 0)
{
DBGPRINT(SYSTEM, INFO,
("SpxBPAllocBlock: Found space in Chunk %lx\n", pChunk));
#ifdef PROFILING
InterlockedIncrement( &SpxStatistics.stat_NumBPHits);
#endif
break;
}
}
if (pChunk == NULL)
{
DBGPRINT(SYSTEM, INFO,
("SpxBPAllocBlock: Allocating a new chunk for Id %d\n", BlockId));
#ifdef PROFILING
InterlockedIncrement( &SpxStatistics.stat_NumBPMisses);
#endif
pChunk = SpxAllocateMemory(spxChunkSize[BlockId]);
if (pChunk != NULL)
{
LONG i, j;
PBLK_HDR pBlkHdr;
USHORT NumBlksPerChunk;
NumBlksPerChunk = spxNumBlks[BlockId];
pChunk->bc_NumFrees = NumBlksPerChunk;
pChunk->bc_BlkId = BlockId;
pChunk->bc_FreeHead = (PBLK_HDR)((PBYTE)pChunk + sizeof(BLK_CHUNK));
DBGPRINT(SYSTEM, INFO,
("SpxBPAllocBlock: Initializing chunk %lx\n", pChunk));
// Initialize the blocks in the chunk
for (i = 0, pBlkHdr = pChunk->bc_FreeHead;
i < NumBlksPerChunk;
i++, pBlkHdr = pBlkHdr->bh_Next)
{
NDIS_STATUS ndisStatus;
pBlkHdr->bh_Next = (PBLK_HDR)((PBYTE)pBlkHdr + BlkSize);
if (BlockId == BLKID_NDISSEND)
{
PBYTE pHdrMem;
#ifdef SPX_OWN_PACKETS
// Point to the ndis packet,initialize it.
pNdisPkt = (PNDIS_PACKET)((PBYTE)pBlkHdr + sizeof(BLK_HDR));
NdisReinitializePacket(pNdisPkt);
// Allocate a ndis buffer descriptor describing hdr memory
// and queue it in.
pHdrMem = (PBYTE)pNdisPkt +
NDIS_PACKET_SIZE +
sizeof(SPX_SEND_RESD);
NdisAllocateBuffer(
&ndisStatus,
&pNdisBuffer,
SpxDevice->dev_NdisBufferPoolHandle,
pHdrMem,
IpxMacHdrNeeded);
if (ndisStatus != NDIS_STATUS_SUCCESS)
{
break;
}
// Link the buffer descriptor into the packet descriptor
NdisChainBufferAtBack(
pNdisPkt,
pNdisBuffer);
NdisAllocateBuffer(
&ndisStatus,
&pNdisIpxSpxBuffer,
SpxDevice->dev_NdisBufferPoolHandle,
pHdrMem + IpxMacHdrNeeded,
MIN_IPXSPX2_HDRSIZE);
if (ndisStatus != NDIS_STATUS_SUCCESS)
{
break;
}
// Link the buffer descriptor into the packet descriptor
NdisChainBufferAtBack(
pNdisPkt,
pNdisIpxSpxBuffer);
pSendResd = (PSPX_SEND_RESD)pNdisPkt->ProtocolReserved;
//#else
// Allocate a ndis packet pool for this chunk
// NdisAllocatePacketPool();
// etc.
// Initialize elements of the protocol reserved structure.
pSendResd->sr_Id = IDENTIFIER_SPX;
pSendResd->sr_Reserved1 = NULL;
pSendResd->sr_Reserved2 = NULL;
pSendResd->sr_State = SPX_SENDPKT_IDLE;
#endif
}
else if (BlockId == BLKID_NDISRECV)
{
#ifdef SPX_OWN_PACKETS
// Point to the ndis packet,initialize it.
pNdisPkt = (PNDIS_PACKET)((PBYTE)pBlkHdr + sizeof(BLK_HDR));
NdisReinitializePacket(pNdisPkt);
pRecvResd = (PSPX_RECV_RESD)pNdisPkt->ProtocolReserved;
//#else
// Allocate a ndis packet pool for this chunk
// NdisAllocatePacketPool();
// etc.
// Initialize elements of the protocol reserved structure.
pRecvResd->rr_Id = IDENTIFIER_SPX;
pRecvResd->rr_State = SPX_RECVPKT_IDLE;
#endif
}
}
if (i != NumBlksPerChunk)
{
// This has to be a failure from Ndis for send blocks!!!
// Undo a bunch of stuff
CTEAssert (BlockId == BLKID_NDISSEND);
pBlkHdr = pChunk->bc_FreeHead;
for (j = 0, pBlkHdr = pChunk->bc_FreeHead;
j < i; j++, pBlkHdr = pBlkHdr->bh_Next)
{
NdisUnchainBufferAtFront(
(PNDIS_PACKET)((PBYTE)pBlkHdr + sizeof(BLK_HDR)),
&pNdisBuffer);
CTEAssert(pNdisBuffer != NULL);
NdisFreeBuffer(pNdisBuffer);
NdisUnchainBufferAtFront(
(PNDIS_PACKET)((PBYTE)pBlkHdr + sizeof(BLK_HDR)),
&pNdisIpxSpxBuffer);
if (pNdisIpxSpxBuffer)
{
NdisFreeBuffer(pNdisIpxSpxBuffer);
}
}
SpxFreeMemory(pChunk);
pChunk = NULL;
}
else
{
// Successfully initialized the chunk, link it in
pChunk->bc_Next = *ppChunkHead;
*ppChunkHead = pChunk;
}
}
}
if (pChunk != NULL)
{
CTEAssert(pChunk->bc_BlkId == BlockId);
DBGPRINT(RESOURCES, INFO,
("SpxBPAllocBlock: Allocating a block out of chunk %lx(%d) for Id %d\n",
pChunk, pChunk->bc_NumFrees, BlockId));
pChunk->bc_NumFrees --;
pChunk->bc_Age = 0; // Reset age
pBlk = pChunk->bc_FreeHead;
pChunk->bc_FreeHead = pBlk->bh_Next;
pBlk->bh_pChunk = pChunk;
// Skip the block header!
pBlk++;
}
CTEFreeLock(&spxBPLock[BlockId], lockHandle);
}
return pBlk;
}
VOID
SpxBPFreeBlock(
IN PVOID pBlock,
IN BLKID BlockId
)
/*++
Routine Description:
Return a block to its owning chunk.
Arguments:
Return Value:
--*/
{
PBLK_CHUNK pChunk;
PBLK_HDR pBlkHdr = (PBLK_HDR)((PCHAR)pBlock - sizeof(BLK_HDR));
CTELockHandle lockHandle;
CTEGetLock(&spxBPLock[BlockId], &lockHandle);
for (pChunk = spxBPHead[BlockId];
pChunk != NULL;
pChunk = pChunk->bc_Next)
{
CTEAssert(pChunk->bc_BlkId == BlockId);
if (pBlkHdr->bh_pChunk == pChunk)
{
DBGPRINT(SYSTEM, INFO,
("SpxBPFreeBlock: Returning Block %lx to chunk %lx for Id %d\n",
pBlkHdr, pChunk, BlockId));
CTEAssert (pChunk->bc_NumFrees < spxNumBlks[BlockId]);
pChunk->bc_NumFrees ++;
pBlkHdr->bh_Next = pChunk->bc_FreeHead;
pChunk->bc_FreeHead = pBlkHdr;
break;
}
}
CTEAssert ((pChunk != NULL) && (pChunk->bc_FreeHead == pBlkHdr));
CTEFreeLock(&spxBPLock[BlockId], lockHandle);
return;
}
ULONG
spxBPAgePool(
IN PVOID Context,
IN BOOLEAN TimerShuttingDown
)
/*++
Routine Description:
Age out the block pool of unused blocks
Arguments:
Return Value:
--*/
{
PBLK_CHUNK pChunk, *ppChunk, pFree = NULL;
LONG i, j, NumBlksPerChunk;
CTELockHandle lockHandle;
PNDIS_PACKET pNdisPkt;
PNDIS_BUFFER pNdisBuffer;
if (TimerShuttingDown)
{
return TIMER_DONT_REQUEUE;
}
for (i = 0; i < NUM_BLKIDS; i++)
{
NumBlksPerChunk = spxNumBlks[i];
CTEGetLock(&spxBPLock[i], &lockHandle);
for (ppChunk = &spxBPHead[i];
(pChunk = *ppChunk) != NULL; )
{
if ((pChunk->bc_NumFrees == NumBlksPerChunk) &&
(++(pChunk->bc_Age) >= MAX_BLOCK_POOL_AGE))
{
DBGPRINT(SYSTEM, INFO,
("spxBPAgePool: freeing Chunk %lx, Id %d\n",
pChunk, pChunk->bc_BlkId));
*ppChunk = pChunk->bc_Next;
#ifdef PROFILING
InterlockedIncrement( &SpxStatistics.stat_NumBPAge);
#endif
if (pChunk->bc_BlkId == BLKID_NDISSEND)
{
PBLK_HDR pBlkHdr;
// We need to free Ndis stuff for these guys
pBlkHdr = pChunk->bc_FreeHead;
for (j = 0, pBlkHdr = pChunk->bc_FreeHead;
j < NumBlksPerChunk;
j++, pBlkHdr = pBlkHdr->bh_Next)
{
pNdisPkt = (PNDIS_PACKET)((PBYTE)pBlkHdr + sizeof(BLK_HDR));
NdisUnchainBufferAtFront(
pNdisPkt,
&pNdisBuffer);
NdisFreeBuffer(pNdisBuffer);
NdisUnchainBufferAtFront(
pNdisPkt,
&pNdisBuffer);
NdisFreeBuffer(pNdisBuffer);
}
}
SpxFreeMemory(pChunk);
}
else
{
ppChunk = &pChunk->bc_Next;
}
}
CTEFreeLock(&spxBPLock[i], lockHandle);
}
return TIMER_REQUEUE_CUR_VALUE;
}
#if !defined SPX_OWN_PACKETS
//
// GrowSPXSendPacketsList
// Called when we dont have any free packets in the SendPacketsList.
//
// Allocate a packet pool, allocate all the packets for that pool and
// store these on a list.
//
// Returns: Pointer to newly allocated packet, or NULL if this faild.
//
PNDIS_PACKET
GrowSPXSendPacketList(void)
{
NdisResEntry *NewEntry;
NDIS_STATUS Status;
PNDIS_PACKET Packet, ReturnPacket;
uint i;
CTELockHandle Handle;
CTEGetLock(&SendHeaderLock, &Handle);
if (CurrentSendPacketCount >= MaxPacketCount)
goto failure;
// First, allocate a tracking structure.
NewEntry = CTEAllocMem(sizeof(NdisResEntry));
if (NewEntry == NULL)
goto failure;
NewEntry->nre_handle = (void *) NDIS_PACKET_POOL_TAG_FOR_NWLNKSPX;
// Got a tracking structure. Now allocate a packet pool.
NdisAllocatePacketPoolEx(
&Status,
&NewEntry->nre_handle,
PACKET_GROW_COUNT,
0,
sizeof(SPX_SEND_RESD)
);
if (Status != NDIS_STATUS_SUCCESS) {
CTEFreeMem(NewEntry);
goto failure;
}
NdisSetPacketPoolProtocolId(NewEntry->nre_handle,NDIS_PROTOCOL_ID_IPX);
// We've allocated the pool. Now initialize the packets, and link them
// on the free list.
ReturnPacket = NULL;
// Link the new NDIS resource tracker entry onto the list.
NewEntry->nre_next = SendPacketPoolList;
SendPacketPoolList = NewEntry;
CurrentSendPacketCount += PACKET_GROW_COUNT;
CTEFreeLock(&SendHeaderLock, Handle);
for (i = 0; i < PACKET_GROW_COUNT; i++) {
SPX_SEND_RESD *SendReserved;
NdisAllocatePacket(&Status, &Packet, NewEntry->nre_handle);
if (Status != NDIS_STATUS_SUCCESS) {
CTEAssert(FALSE);
break;
}
CTEMemSet(Packet->ProtocolReserved, 0, sizeof(SPX_SEND_RESD));
SendReserved = (SPX_SEND_RESD *)Packet->ProtocolReserved;
// store whatever's required in the reserved section.
if (i != 0) {
(void)SpxFreeSendPacket(SpxDevice, Packet);
} else
ReturnPacket = Packet;
}
// We've put all but the first one on the list. Return the first one.
return ReturnPacket;
failure:
CTEFreeLock(&SendHeaderLock, Handle);
return NULL;
}
//
// GrowSPXRecvPacketsList
// Called when we dont have any free packets in the RecvPacketsList.
//
// Allocate a packet pool, allocate all the packets for that pool and
// store these on a list.
//
// Returns: Pointer to newly allocated packet, or NULL if this faild.
//
PNDIS_PACKET
GrowSPXRecvPacketList(void)
{
NdisResEntry *NewEntry;
NDIS_STATUS Status;
PNDIS_PACKET Packet, ReturnPacket;
uint i;
CTELockHandle Handle;
CTEGetLock(&RecvHeaderLock, &Handle);
if (CurrentRecvPacketCount >= MaxPacketCount)
goto failure;
// First, allocate a tracking structure.
NewEntry = CTEAllocMem(sizeof(NdisResEntry));
if (NewEntry == NULL)
goto failure;
NewEntry->nre_handle = (void *) NDIS_PACKET_POOL_TAG_FOR_NWLNKSPX;
// Got a tracking structure. Now allocate a packet pool.
NdisAllocatePacketPoolEx(
&Status,
&NewEntry->nre_handle,
PACKET_GROW_COUNT,
0,
sizeof(SPX_RECV_RESD)
);
if (Status != NDIS_STATUS_SUCCESS) {
CTEFreeMem(NewEntry);
goto failure;
}
NdisSetPacketPoolProtocolId(NewEntry->nre_handle,NDIS_PROTOCOL_ID_IPX);
// We've allocated the pool. Now initialize the packets, and link them
// on the free list.
ReturnPacket = NULL;
// Link the new NDIS resource tracker entry onto the list.
NewEntry->nre_next = RecvPacketPoolList;
RecvPacketPoolList = NewEntry;
CurrentRecvPacketCount += PACKET_GROW_COUNT;
CTEFreeLock(&RecvHeaderLock, Handle);
for (i = 0; i < PACKET_GROW_COUNT; i++) {
SPX_RECV_RESD *RecvReserved;
NdisAllocatePacket(&Status, &Packet, NewEntry->nre_handle);
if (Status != NDIS_STATUS_SUCCESS) {
CTEAssert(FALSE);
break;
}
CTEMemSet(Packet->ProtocolReserved, 0, sizeof(SPX_RECV_RESD));
RecvReserved = (SPX_RECV_RESD *)Packet->ProtocolReserved;
// store whatever's required in the reserved section.
if (i != 0) {
(void)SpxFreeRecvPacket(SpxDevice, Packet);
} else
ReturnPacket = Packet;
}
// We've put all but the first one on the list. Return the first one.
return ReturnPacket;
failure:
CTEFreeLock(&RecvHeaderLock, Handle);
return NULL;
}
PNDIS_PACKET
SpxAllocSendPacket(
IN PDEVICE _Device,
OUT NDIS_PACKET **_SendPacket,
OUT NDIS_STATUS *_Status)
{
PSINGLE_LIST_ENTRY Link;
SPX_SEND_RESD *Common, *pSendResd;
PNDIS_BUFFER pNdisIpxMacBuffer, pNdisIpxSpxBuffer;
NDIS_STATUS ndisStatus;
PUCHAR pHdrMem = NULL;
Link = ExInterlockedPopEntrySList(&SendPacketList, &SendHeaderLock);
if (Link != NULL) {
Common = STRUCT_OF(SPX_SEND_RESD, Link, Linkage);
(*_SendPacket) = STRUCT_OF(NDIS_PACKET, Common, ProtocolReserved);
(*_Status) = NDIS_STATUS_SUCCESS;
} else {
(*_SendPacket) = GrowSPXSendPacketList();
(*_Status) = NDIS_STATUS_SUCCESS;
if (NULL == *_SendPacket) {
DBGPRINT(NDIS, DBG, ("Couldn't grow packets allocated...\r\n"));
(*_Status) = NDIS_STATUS_RESOURCES;
return NULL;
}
}
//
// Now add the NdisBuffers to the packet.
// 1. IPX MAC HDR
// 2. IPX/SPX Hdr
// 3. Chain these
//
if (NDIS_STATUS_SUCCESS == (*_Status)) {
//
// First allocate the memory
//
pHdrMem = SpxAllocateMemory(IpxMacHdrNeeded + MIN_IPXSPX2_HDRSIZE);
if (NULL == pHdrMem) {
DBGPRINT(NDIS, DBG, ("Cannot allocate non paged pool for sendpacket\n"));
(*_Status) = NDIS_STATUS_RESOURCES;
goto failure;
}
NdisAllocateBuffer(
&ndisStatus,
&pNdisIpxMacBuffer,
SpxDevice->dev_NdisBufferPoolHandle,
pHdrMem,
IpxMacHdrNeeded);
if (ndisStatus != NDIS_STATUS_SUCCESS)
{
if (NULL != pHdrMem) {
SpxFreeMemory(pHdrMem);
pHdrMem = NULL;
}
DBGPRINT(NDIS, DBG, ("NdisallocateBuffer failed\r\n", ndisStatus));
goto failure;
}
// Link the buffer descriptor into the packet descriptor
NdisChainBufferAtBack(
(*_SendPacket),
pNdisIpxMacBuffer);
NdisAllocateBuffer(
&ndisStatus,
&pNdisIpxSpxBuffer,
SpxDevice->dev_NdisBufferPoolHandle,
pHdrMem + IpxMacHdrNeeded,
MIN_IPXSPX2_HDRSIZE);
if (ndisStatus != NDIS_STATUS_SUCCESS)
{
DBGPRINT(NDIS, DBG, ("NdisallocateBuffer failed\r\n", ndisStatus));
goto failure;
}
// Link the buffer descriptor into the packet descriptor
NdisChainBufferAtBack(
(*_SendPacket),
pNdisIpxSpxBuffer);
pSendResd = (PSPX_SEND_RESD)(*_SendPacket)->ProtocolReserved;
// Initialize elements of the protocol reserved structure.
pSendResd->sr_Id = IDENTIFIER_SPX;
pSendResd->sr_Reserved1 = NULL;
pSendResd->sr_Reserved2 = NULL;
pSendResd->sr_State = SPX_SENDPKT_IDLE;
return (*_SendPacket);
}
failure:
SpxFreeSendPacket(SpxDevice, (*_SendPacket));
(*_Status) = NDIS_STATUS_RESOURCES;
return NULL;
}
PNDIS_PACKET
SpxAllocRecvPacket(
IN PDEVICE _Device,
OUT NDIS_PACKET **_RecvPacket,
OUT NDIS_STATUS *_Status)
{
PSINGLE_LIST_ENTRY Link;
SPX_RECV_RESD *Common, *pRecvResd;
Link = ExInterlockedPopEntrySList(
&RecvPacketList,
&RecvHeaderLock
);
if (Link != NULL) {
Common = STRUCT_OF(SPX_RECV_RESD, Link, Linkage);
//PC = STRUCT_OF(PacketContext, Common, pc_common);
(*_RecvPacket) = STRUCT_OF(NDIS_PACKET, Common, ProtocolReserved);
(*_Status) = NDIS_STATUS_SUCCESS;
} else {
(*_RecvPacket) = GrowSPXRecvPacketList();
(*_Status) = NDIS_STATUS_SUCCESS;
if (NULL == *_RecvPacket) {
DBGPRINT(NDIS, DBG, ("Couldn't grow packets allocated...\r\n"));
(*_Status) = NDIS_STATUS_RESOURCES;
}
}
if ((*_Status) == NDIS_STATUS_SUCCESS) {
pRecvResd = (PSPX_RECV_RESD)(*_RecvPacket)->ProtocolReserved;
// Initialize elements of the protocol reserved structure.
pRecvResd->rr_Id = IDENTIFIER_SPX;
pRecvResd->rr_State = SPX_RECVPKT_IDLE;
}
return (*_RecvPacket);
}
//* SpxFreeSendPacket - Free an SPX packet when we're done with it.
//
// Called when a send completes and a packet needs to be freed. We look at the
// packet, decide what to do with it, and free the appropriate components.
//
// Entry: Packet - Packet to be freed.
//
//
void
SpxFreeSendPacket(PDEVICE _Device,
PNDIS_PACKET _Packet)
{
PNDIS_BUFFER NextBuffer, Buffer;
SPX_SEND_RESD *Context = (SPX_SEND_RESD *)_Packet->ProtocolReserved;
PVOID Header = NULL;
ULONG Length = 0;
DBGPRINT(NDIS, DBG,
("SpxFreeSendPacket\n"));
NdisQueryPacket(_Packet, NULL, NULL, &Buffer, NULL);
if (NULL != Buffer) {
NdisQueryBuffer(Buffer, &Header, &Length);
//KdPrint(("Pointer = %x Length = %x", Header, Length));
if (Header != NULL && Length > 0) {
//KdPrint(("Freed buffer"));
SpxFreeMemory(Header);
}
}
while (Buffer != (PNDIS_BUFFER)NULL) {
NdisGetNextBuffer(Buffer, &NextBuffer);
NdisFreeBuffer(Buffer);
Buffer = NextBuffer;
}
NdisReinitializePacket(_Packet);
ExInterlockedPushEntrySList(
&SendPacketList,
STRUCT_OF(SINGLE_LIST_ENTRY, &(Context->Linkage), Next),
&SendHeaderLock
);
return;
}
//* SpxFreeRecvPacket - Free an SPX packet when we're done with it.
//
// Called when a recv completes and a packet needs to be freed. We look at the
// packet, decide what to do with it, and free the appropriate components.
//
// Entry: Packet - Packet to be freed.
//
//
void
SpxFreeRecvPacket(PDEVICE _Device,
PNDIS_PACKET _Packet)
{
PNDIS_BUFFER NextBuffer, Buffer;
SPX_RECV_RESD *Context = (SPX_RECV_RESD *)_Packet->ProtocolReserved;
DBGPRINT(NDIS, DBG,
("SpxFreeRecvPacket\n"));
NdisQueryPacket(_Packet, NULL, NULL, &Buffer, NULL);
while (Buffer != (PNDIS_BUFFER)NULL) {
NdisGetNextBuffer(Buffer, &NextBuffer);
NdisFreeBuffer(Buffer);
Buffer = NextBuffer;
}
NdisReinitializePacket(_Packet);
ExInterlockedPushEntrySList(
&RecvPacketList,
STRUCT_OF(SINGLE_LIST_ENTRY, &(Context->Linkage), Next),
&RecvHeaderLock
);
return;
}
void
SpxReInitSendPacket(PNDIS_PACKET _Packet)
{
DBGPRINT(NDIS, DBG,
("SpxReInitSendPacket\n"));
}
void
SpxReInitRecvPacket(PNDIS_PACKET _Packet)
{
DBGPRINT(NDIS, DBG,
("SpxReInitRecvPacket\n"));
}
#endif //SPX_OWN_PACKETS
Reference in a new issue Copy permalink