/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    buffer.c

Abstract:

    This module contains routines for handling non-bufferring TDI
    providers.  The AFD interface assumes that bufferring will be done
    below AFD; if the TDI provider doesn't buffer, then AFD must.

Author:

    David Treadwell (davidtr)    21-Feb-1992

Revision History:

--*/

#include "afdp.h"

VOID
AfdInitializeBuffer (
    IN PAFD_BUFFER AfdBuffer,
    IN CLONG BufferDataSize,
    IN CLONG AddressSize
    );

#ifdef ALLOC_PRAGMA
#pragma alloc_text( PAGEAFD, AfdAllocateBuffer )
#pragma alloc_text( PAGEAFD, AfdCalculateBufferSize )
#pragma alloc_text( PAGEAFD, AfdInitializeBuffer )
#pragma alloc_text( PAGEAFD, AfdGetBuffer )
#pragma alloc_text( PAGEAFD, AfdGetBufferChain )
#pragma alloc_text( PAGEAFD, AfdReturnBuffer )
#pragma alloc_text( PAGEAFD, AfdReturnBufferChain )
#if DBG
#pragma alloc_text( PAGEAFD, AfdFreeBufferPool )
#endif
#endif


PVOID
AfdAllocateBuffer (
    IN POOL_TYPE PoolType,
    IN ULONG NumberOfBytes,
    IN ULONG Tag
    )

/*++

Routine Description:

    Used by the lookaside list allocation function to allocate a new
    AFD buffer structure.  The returned structure will be fully
    initialized.

Arguments:

    PoolType - passed to ExAllocatePoolWithTag.

    NumberOfBytes - the number of bytes required for the data buffer
        portion of the AFD buffer.

    Tag - passed to ExAllocatePoolWithTag.

Return Value:

    PVOID - a fully initialized PAFD_BUFFER, or NULL if the allocation
        attempt fails.

--*/

{
    PAFD_BUFFER afdBuffer;
    ULONG bytesRequired;

    //
    // The requested length must be the same as one of the standard
    // AFD buffer sizes.
    //

    ASSERT( NumberOfBytes == AfdSmallBufferSize ||
            NumberOfBytes == AfdMediumBufferSize ||
            NumberOfBytes == AfdLargeBufferSize );

    //
    // Determine how much data we'll actually need for the buffer.
    //

    bytesRequired = AfdCalculateBufferSize(
                        NumberOfBytes,
                        AfdStandardAddressLength
                        );

    //
    // Get nonpaged pool for the buffer.
    //

    afdBuffer = AFD_ALLOCATE_POOL( PoolType, bytesRequired, Tag );
    if ( afdBuffer == NULL ) {
        return NULL;
    }

    //
    // Initialize the buffer and return a pointer to it.
    //

    AfdInitializeBuffer( afdBuffer, NumberOfBytes, AfdStandardAddressLength );

    return afdBuffer;


} // AfdAllocateBuffer


CLONG
AfdCalculateBufferSize (
    IN CLONG BufferDataSize,
    IN CLONG AddressSize
    )

/*++

Routine Description:

    Determines the size of an AFD buffer structure given the amount of
    data that the buffer contains.

Arguments:

    BufferDataSize - data length of the buffer.

    AddressSize - length of address structure for the buffer.

Return Value:

    Number of bytes needed for an AFD_BUFFER structure for data of
    this size.

--*/

{
    CLONG irpSize;
    CLONG mdlSize;
    CLONG bufferSize;

    ASSERT( BufferDataSize != 0 );
    ASSERT( AfdCacheLineSize < 100 );

    //
    // Determine the sizes of the various components of an AFD_BUFFER
    // structure.  Note that these are all worst-case calculations--
    // actual sizes of the MDL and the buffer may be smaller.
    //

    irpSize = IoSizeOfIrp( AfdIrpStackSize ) + 8;
    bufferSize = BufferDataSize + AfdCacheLineSize;
    mdlSize = MmSizeOfMdl( (PVOID)(PAGE_SIZE-1), bufferSize );

    return ( (sizeof(AFD_BUFFER) + irpSize + mdlSize +
              AddressSize + bufferSize + 3) & ~3);

} // AfdCalculateBufferSize


PAFD_BUFFER
AfdGetBuffer (
    IN CLONG BufferDataSize,
    IN CLONG AddressSize
    )

/*++

Routine Description:

    Obtains a buffer of the appropriate size for the caller.  Uses
    the preallocated buffers if possible, or else allocates a new buffer
    structure if required.

Arguments:

    BufferDataSize - the size of the data buffer that goes along with the
        buffer structure.

    AddressSize - size of the address field required for the buffer.

Return Value:

    PAFD_BUFFER - a pointer to an AFD_BUFFER structure, or NULL if one
        was not available or could not be allocated.

--*/

{
    PAFD_BUFFER afdBuffer;
    CLONG bufferSize;
    PLIST_ENTRY listEntry;
    PNPAGED_LOOKASIDE_LIST lookasideList;

    //
    // If possible, allocate the buffer from one of the lookaside lists.
    //

    if ( AddressSize <= AfdStandardAddressLength &&
             BufferDataSize <= AfdLargeBufferSize ) {

        if ( BufferDataSize <= AfdSmallBufferSize ) {

            lookasideList = &AfdLookasideLists->SmallBufferList;
            BufferDataSize = AfdSmallBufferSize;

        } else if ( BufferDataSize <= AfdMediumBufferSize ) {

            lookasideList = &AfdLookasideLists->MediumBufferList;
            BufferDataSize = AfdMediumBufferSize;

        } else {

            lookasideList = &AfdLookasideLists->LargeBufferList;
            BufferDataSize = AfdLargeBufferSize;
        }

        afdBuffer = ExAllocateFromNPagedLookasideList( lookasideList );
#if DBG
        if ( afdBuffer != NULL ) {

            RtlGetCallersAddress(
                &afdBuffer->Caller,
                &afdBuffer->CallersCaller
                );
        }
#endif

        return afdBuffer;

    }

    //
    // Couldn't find an appropriate buffer that was preallocated.
    // Allocate one manually.  If the buffer size requested was
    // zero bytes, give them four bytes.  This is because some of
    // the routines like MmSizeOfMdl() cannot handle getting passed
    // in a length of zero.
    //
    // !!! It would be good to ROUND_TO_PAGES for this allocation
    //     if appropriate, then use entire buffer size.
    //

    if ( BufferDataSize == 0 ) {
        BufferDataSize = sizeof(ULONG);
    }

    bufferSize = AfdCalculateBufferSize( BufferDataSize, AddressSize );

    afdBuffer = AFD_ALLOCATE_POOL(
                    NonPagedPool,
                    bufferSize,
                    AFD_DATA_BUFFER_POOL_TAG
                    );

    if ( afdBuffer == NULL ) {
        return NULL;
    }

    //
    // Initialize the AFD buffer structure and return it.
    //

    AfdInitializeBuffer( afdBuffer, BufferDataSize, AddressSize );

    return afdBuffer;

} // AfdGetBuffer


PAFD_BUFFER
AfdGetBufferChain (
    IN CLONG BufferDataSize
    )
{
    PAFD_BUFFER afdBuffer;
    PAFD_BUFFER bufferChain;
    PAFD_BUFFER *bufferChainTarget;
    PMDL mdlChain;
    PMDL *mdlChainTarget;
    CLONG currentBufferSize;
#if DBG
    CLONG totalChainLength = BufferDataSize;
#endif

    //
    // Sanity check.
    //

    ASSERT( BufferDataSize > AfdBufferLengthForOnePage );

    //
    // Setup so we know how to cleanup.
    //

    bufferChain = NULL;
    mdlChain = NULL;
    bufferChainTarget = &bufferChain;
    mdlChainTarget = &mdlChain;

    //
    // Loop, acquiring & chaining the buffers.
    //

    while ( BufferDataSize > 0 ) {

        //
        // Acquire a new buffer.  If this fails, we're toast.
        //

        currentBufferSize = max( BufferDataSize, AfdBufferLengthForOnePage );

        afdBuffer = AfdGetBuffer( currentBufferSize, 0 );

        if ( afdBuffer == NULL ) {

            break;

        }

        //
        // Chain it on.
        //

        *bufferChainTarget = afdBuffer;
        bufferChainTarget = &afdBuffer->NextBuffer;

        *mdlChainTarget = afdBuffer->Mdl;
        mdlChainTarget = &afdBuffer->Mdl->Next;

        BufferDataSize -= currentBufferSize;

    }

    if ( BufferDataSize == 0 ) {

        ASSERT( bufferChain != NULL );
        ASSERT( afdBuffer != NULL );
        ASSERT( currentBufferSize > 0 );
        ASSERT( currentBufferSize <= AfdBufferLengthForOnePage );

        //
        // Set the byte count in the final MDL in the chain.
        //

        afdBuffer->Mdl->ByteCount = currentBufferSize;
        SET_CHAIN_LENGTH( afdBuffer, totalChainLength );

        return bufferChain;

    }

    //
    //  Error, time to cleanup.
    //

    while( bufferChain != NULL ) {

        afdBuffer = bufferChain->NextBuffer;

        bufferChain->Mdl->Next = NULL;
        bufferChain->NextBuffer = NULL;
        RESET_CHAIN_LENGTH( bufferChain );
        AfdReturnBuffer( bufferChain );

        bufferChain = afdBuffer;

    }

    return NULL;

} // AfdGetBufferChain


VOID
AfdReturnBuffer (
    IN PAFD_BUFFER AfdBuffer
    )

/*++

Routine Description:

    Returns an AFD buffer to the appropriate global list, or frees
    it if necessary.

Arguments:

    AfdBuffer - points to the AFD_BUFFER structure to return or free.

Return Value:

    None.

--*/

{
    PNPAGED_LOOKASIDE_LIST lookasideList;

    //
    // Most of the AFD buffer must be zeroed when returning the buffer.
    //

    ASSERT( AfdBuffer->DataOffset == 0 );
    ASSERT( !AfdBuffer->ExpeditedData );
    ASSERT( AfdBuffer->TdiInputInfo.UserDataLength == 0 );
    ASSERT( AfdBuffer->TdiInputInfo.UserData == NULL );
    ASSERT( AfdBuffer->TdiInputInfo.OptionsLength == 0 );
    ASSERT( AfdBuffer->TdiInputInfo.Options == NULL );
    ASSERT( AfdBuffer->TdiInputInfo.RemoteAddressLength == 0 );
    ASSERT( AfdBuffer->TdiInputInfo.RemoteAddress == NULL );
    ASSERT( AfdBuffer->TdiOutputInfo.UserDataLength == 0 );
    ASSERT( AfdBuffer->TdiOutputInfo.UserData == NULL );
    ASSERT( AfdBuffer->TdiOutputInfo.OptionsLength == 0 );
    ASSERT( AfdBuffer->TdiOutputInfo.Options == NULL );
    ASSERT( AfdBuffer->TdiOutputInfo.RemoteAddressLength == 0 );
    ASSERT( AfdBuffer->TdiOutputInfo.RemoteAddress == NULL );

    ASSERT( AfdBuffer->Mdl->ByteCount == AfdBuffer->BufferLength );
    ASSERT( AfdBuffer->Mdl->Next == NULL );
    ASSERT( AfdBuffer->FileObject == NULL );
    ASSERT( AfdBuffer->NextBuffer == NULL );
    ASSERT( AfdBuffer->TotalChainLength == AfdBuffer->BufferLength );

#if DBG
    AfdBuffer->Caller = NULL;
    AfdBuffer->CallersCaller = NULL;
#endif

    //
    // If appropriate, return the buffer to one of the AFD buffer
    // lookaside lists.
    //

    if ( AfdBuffer->AllocatedAddressLength == AfdStandardAddressLength &&
             AfdBuffer->BufferLength <= AfdLargeBufferSize ) {

        if ( AfdBuffer->BufferLength == AfdSmallBufferSize ) {

            lookasideList = &AfdLookasideLists->SmallBufferList;

        } else if ( AfdBuffer->BufferLength == AfdMediumBufferSize ) {

            lookasideList = &AfdLookasideLists->MediumBufferList;

        } else {

            ASSERT( AfdBuffer->BufferLength == AfdLargeBufferSize );
            lookasideList = &AfdLookasideLists->LargeBufferList;
        }

        ExFreeToNPagedLookasideList( lookasideList, AfdBuffer );

        return;
    }

    //
    // The buffer was not from a lookaside list allocation, so just free
    // the pool we used for it.
    //

    AFD_FREE_POOL(
        AfdBuffer,
        AFD_DATA_BUFFER_POOL_TAG
        );

    return;

} // AfdReturnBuffer

VOID
AfdReturnBufferChain (
    IN PAFD_BUFFER AfdBuffer
    )

/*++

Routine Description:

    Returns an AFD buffer chain to the appropriate global list, or frees
    it if necessary.

Arguments:

    AfdBuffer - points to the AFD_BUFFER structure to return or free.

Return Value:

    None.

--*/

{
    PAFD_BUFFER nextBuffer;

    while ( AfdBuffer != NULL ) {

        nextBuffer = AfdBuffer->NextBuffer;

        AfdBuffer->NextBuffer = NULL;
        AfdBuffer->Mdl->Next = NULL;
        AfdBuffer->Mdl->ByteCount = AfdBuffer->BufferLength;
        RESET_CHAIN_LENGTH( AfdBuffer );
        AfdReturnBuffer( AfdBuffer );

        AfdBuffer = nextBuffer;

    }

} // AfdReturnBufferChain


VOID
AfdInitializeBuffer (
    IN PAFD_BUFFER AfdBuffer,
    IN CLONG BufferDataSize,
    IN CLONG AddressSize
    )

/*++

Routine Description:

    Initializes an AFD buffer.  Sets up fields in the actual AFD_BUFFER
    structure and initializes the IRP and MDL associated with the
    buffer.  This routine assumes that the caller has properly allocated
    sufficient space for all this.

Arguments:

    AfdBuffer - points to the AFD_BUFFER structure to initialize.

    BufferDataSize - the size of the data buffer that goes along with the
        buffer structure.

    AddressSize - the size of data allocated for the address buffer.

    ListHead - the global list this buffer belongs to, or NULL if it
        doesn't belong on any list.  This routine does NOT place the
        buffer structure on the list.

Return Value:

    None.

--*/

{
    CLONG irpSize;
    CLONG mdlSize;

    //
    // Initialize the IRP pointer and the IRP itself.
    //

    AfdBuffer->Irp = (PIRP)(( ((ULONG)(AfdBuffer + 1)) + 7) & ~7);
    irpSize = IoSizeOfIrp( AfdIrpStackSize );

    IoInitializeIrp( AfdBuffer->Irp, (USHORT)irpSize, AfdIrpStackSize );

    //
    // Set up the MDL pointer but don't build it yet.  We have to wait
    // until after the data buffer is built to build the MDL.
    //

    mdlSize = MmSizeOfMdl( (PVOID)(PAGE_SIZE-1), BufferDataSize );

    AfdBuffer->Mdl = (PMDL)( (PCHAR)AfdBuffer->Irp + irpSize );

    //
    // Set up the address buffer pointer.
    //

    AfdBuffer->SourceAddress = (PCHAR)AfdBuffer->Mdl + mdlSize;
    AfdBuffer->AllocatedAddressLength = (USHORT)AddressSize;

    //
    // Initialize the TDI information structures.
    //

    RtlZeroMemory( &AfdBuffer->TdiInputInfo, sizeof(AfdBuffer->TdiInputInfo) );
    RtlZeroMemory( &AfdBuffer->TdiOutputInfo, sizeof(AfdBuffer->TdiOutputInfo) );

    //
    // Set up the data buffer pointer and length.  Note that the buffer
    // MUST begin on a cache line boundary so that we can use the fast
    // copy routines like RtlCopyMemory on the buffer.
    //

    AfdBuffer->Buffer = (PVOID)
        ( ( (ULONG)AfdBuffer->SourceAddress + AddressSize +
                AfdCacheLineSize - 1 ) & ~(AfdCacheLineSize - 1) );

    AfdBuffer->BufferLength = BufferDataSize;
    RESET_CHAIN_LENGTH( AfdBuffer );

    //
    // Now build the MDL and set up a pointer to the MDL in the IRP.
    //

    MmInitializeMdl( AfdBuffer->Mdl, AfdBuffer->Buffer, BufferDataSize );
    MmBuildMdlForNonPagedPool( AfdBuffer->Mdl );

    AfdBuffer->Irp->MdlAddress = AfdBuffer->Mdl;
    AfdBuffer->DataOffset = 0;
    AfdBuffer->ExpeditedData = FALSE;
    AfdBuffer->PartialMessage = FALSE;
    AfdBuffer->FileObject = NULL;

    //
    // By default, buffers are not part of a chain.
    //

    AfdBuffer->NextBuffer = NULL;


#if DBG
    AfdBuffer->BufferListEntry.Flink = (PVOID)0xE0E1E2E3;
    AfdBuffer->BufferListEntry.Blink = (PVOID)0xE4E5E6E7;
    AfdBuffer->Caller = NULL;
    AfdBuffer->CallersCaller = NULL;
#endif

} // AfdInitializeBuffer


#if DBG
VOID
NTAPI
AfdFreeBufferPool(
    IN PVOID Block
    )
{

    AFD_FREE_POOL(
        Block,
        AFD_DATA_BUFFER_POOL_TAG
        );

} // AfdFreeBufferPool
#endif