windows-server-2003/net/nwlink/spx/spxmem.c

/*++

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)					

{
        PSLIST_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)
{

        PSLIST_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(SLIST_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(SLIST_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