534 lines
17 KiB
C
534 lines
17 KiB
C
|
/****************************************************************************/
|
||
|
|
// buffer.c
|
||
|
|
//
|
||
|
|
// TermDD default OutBuf management.
|
||
|
|
//
|
||
|
|
// Copyright (C) 1998-2000 Microsoft Corporation
|
||
|
|
/****************************************************************************/
|
||
|
|
|
||
|
|
#include <precomp.h>
|
||
|
|
#pragma hdrstop
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Define default stack size for IRP allocation.
|
||
|
|
* (This size will be checked by the TdRawWrite routine.)
|
||
|
|
*/
|
||
|
|
#define OUTBUF_STACK_SIZE 4
|
||
|
|
#define OUTBUF_TIMEOUT 60000 // 1 minute
|
||
|
|
|
||
|
|
|
||
|
|
#if DBG
|
||
|
|
extern PICA_DISPATCH IcaStackDispatchTable[];
|
||
|
|
#endif
|
||
|
|
|
||
|
|
|
||
|
|
/****************************************************************************/
|
||
|
|
// IcaBufferGetUsableSpace
|
||
|
|
//
|
||
|
|
// Used by the protocol stack drivers to determine the number of usable bytes
|
||
|
|
// in a TermDD-created OutBuf, given the total size of the OutBuf. This allows
|
||
|
|
// a stack driver to target a particular OutBuf size and pack data up to the
|
||
|
|
// edges of the internal OutBuf headers. The returned size can be used as an
|
||
|
|
// allocation size request that will return an OutBuf of the right size.
|
||
|
|
/****************************************************************************/
|
||
|
|
unsigned IcaBufferGetUsableSpace(unsigned OutBufTotalSize)
|
||
|
|
{
|
||
|
|
unsigned IrpSize;
|
||
|
|
unsigned MdlSize;
|
||
|
|
unsigned MaxOutBufOverhead;
|
||
|
|
|
||
|
|
// Use the same overhead calculations used in IcaBufferAllocInternal()
|
||
|
|
// below, plus a 4-byte offset to cover the extra 1-byte difference
|
||
|
|
// required in the requesting size to reach a target buffer size.
|
||
|
|
IrpSize = IoSizeOfIrp(OUTBUF_STACK_SIZE) + 8;
|
||
|
|
|
||
|
|
if (OutBufTotalSize <= MaxOutBufAlloc)
|
||
|
|
MdlSize = MaxOutBufMdlOverhead;
|
||
|
|
else
|
||
|
|
MdlSize = (unsigned)MmSizeOfMdl((PVOID)(PAGE_SIZE - 1),
|
||
|
|
OutBufTotalSize);
|
||
|
|
|
||
|
|
MaxOutBufOverhead = ((sizeof(OUTBUF) + 7) & ~7) + IrpSize + MdlSize;
|
||
|
|
return OutBufTotalSize - MaxOutBufOverhead - 4;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* IcaBufferAlloc
|
||
|
|
*
|
||
|
|
* pContext (input)
|
||
|
|
* pointer to SDCONTEXT of caller
|
||
|
|
* fWait (input)
|
||
|
|
* wait for buffer
|
||
|
|
* fControl (input)
|
||
|
|
* control buffer flag
|
||
|
|
* ByteCount (input)
|
||
|
|
* size of buffer to allocate (zero - use default size)
|
||
|
|
* pOutBufOrig (input)
|
||
|
|
* pointer to original OUTBUF (or null)
|
||
|
|
* pOutBuf (output)
|
||
|
|
* address to return pointer to OUTBUF structure
|
||
|
|
******************************************************************************/
|
||
|
|
NTSTATUS IcaBufferAlloc(
|
||
|
|
IN PSDCONTEXT pContext,
|
||
|
|
IN BOOLEAN fWait,
|
||
|
|
IN BOOLEAN fControl,
|
||
|
|
IN ULONG ByteCount,
|
||
|
|
IN POUTBUF pOutBufOrig,
|
||
|
|
OUT POUTBUF *ppOutBuf)
|
||
|
|
{
|
||
|
|
PSDLINK pSdLink;
|
||
|
|
PICA_STACK pStack;
|
||
|
|
NTSTATUS Status;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Use SD passed context to get the SDLINK pointer.
|
||
|
|
*/
|
||
|
|
pSdLink = CONTAINING_RECORD(pContext, SDLINK, SdContext);
|
||
|
|
pStack = pSdLink->pStack;
|
||
|
|
ASSERT(pSdLink->pStack->Header.Type == IcaType_Stack);
|
||
|
|
ASSERT(pSdLink->pStack->Header.pDispatchTable == IcaStackDispatchTable);
|
||
|
|
ASSERT(ExIsResourceAcquiredExclusiveLite( &pStack->Resource));
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Walk up the SDLINK list looking for a driver which has specified
|
||
|
|
* a BufferAlloc callup routine. If we find one, then call the
|
||
|
|
* driver BufferAlloc routine to let it handle the call.
|
||
|
|
*/
|
||
|
|
while ((pSdLink = IcaGetPreviousSdLink(pSdLink)) != NULL) {
|
||
|
|
ASSERT( pSdLink->pStack == pStack );
|
||
|
|
if (pSdLink->SdContext.pCallup->pSdBufferAlloc) {
|
||
|
|
IcaReferenceSdLink(pSdLink);
|
||
|
|
Status = (pSdLink->SdContext.pCallup->pSdBufferAlloc)(
|
||
|
|
pSdLink->SdContext.pContext,
|
||
|
|
fWait,
|
||
|
|
fControl,
|
||
|
|
ByteCount,
|
||
|
|
pOutBufOrig,
|
||
|
|
ppOutBuf);
|
||
|
|
IcaDereferenceSdLink(pSdLink);
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* We didn't find a callup routine to handle the request,
|
||
|
|
* so we'll process it here.
|
||
|
|
*/
|
||
|
|
Status = IcaBufferAllocInternal(pContext, fWait, fControl, ByteCount,
|
||
|
|
pOutBufOrig, ppOutBuf);
|
||
|
|
|
||
|
|
TRACESTACK((pStack, TC_ICADD, TT_API3,
|
||
|
|
"TermDD: IcaBufferAlloc: 0x%08x, Status=0x%x\n", *ppOutBuf,
|
||
|
|
Status));
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
NTSTATUS IcaBufferAllocInternal(
|
||
|
|
IN PSDCONTEXT pContext,
|
||
|
|
IN BOOLEAN fWait,
|
||
|
|
IN BOOLEAN fControl,
|
||
|
|
IN ULONG ByteCount,
|
||
|
|
IN POUTBUF pOutBufOrig,
|
||
|
|
OUT POUTBUF *ppOutBuf)
|
||
|
|
{
|
||
|
|
PSDLINK pSdLink;
|
||
|
|
PICA_STACK pStack;
|
||
|
|
int PoolIndex;
|
||
|
|
ULONG irpSize;
|
||
|
|
ULONG mdlSize;
|
||
|
|
ULONG AllocationSize;
|
||
|
|
KIRQL oldIrql;
|
||
|
|
PLIST_ENTRY Head;
|
||
|
|
POUTBUF pOutBuf;
|
||
|
|
NTSTATUS Status;
|
||
|
|
unsigned MaxOutBufOverhead;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Use SD passed context to get the SDLINK pointer.
|
||
|
|
*/
|
||
|
|
pSdLink = CONTAINING_RECORD( pContext, SDLINK, SdContext );
|
||
|
|
pStack = pSdLink->pStack;
|
||
|
|
ASSERT( pSdLink->pStack->Header.Type == IcaType_Stack );
|
||
|
|
ASSERT( pSdLink->pStack->Header.pDispatchTable == IcaStackDispatchTable );
|
||
|
|
|
||
|
|
/*
|
||
|
|
* If original buffer is specified use it's flags
|
||
|
|
*/
|
||
|
|
if (pOutBufOrig) {
|
||
|
|
fWait = (BOOLEAN) pOutBufOrig->fWait;
|
||
|
|
fControl = (BOOLEAN) pOutBufOrig->fControl;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Check if we already have our maximum number of buffers allocated
|
||
|
|
*/
|
||
|
|
while (!fControl && (pStack->OutBufAllocCount >= pStack->OutBufCount)) {
|
||
|
|
/*
|
||
|
|
* increment performance counter
|
||
|
|
*/
|
||
|
|
pStack->ProtocolStatus.Output.WaitForOutBuf++;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Return if it's not ok to wait
|
||
|
|
*/
|
||
|
|
if (!fWait)
|
||
|
|
return(STATUS_IO_TIMEOUT);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* We hit the high watermark
|
||
|
|
*/
|
||
|
|
pStack->fWaitForOutBuf = TRUE;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Only wait for non-control requests
|
||
|
|
*/
|
||
|
|
KeClearEvent(&pStack->OutBufEvent);
|
||
|
|
Status = IcaWaitForSingleObject(pContext, &pStack->OutBufEvent,
|
||
|
|
OUTBUF_TIMEOUT);
|
||
|
|
if (NT_SUCCESS(Status)) {
|
||
|
|
if (Status != STATUS_WAIT_0)
|
||
|
|
return STATUS_IO_TIMEOUT;
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* If the caller did not specify a byte count
|
||
|
|
* then use the standard outbuf size for this stack.
|
||
|
|
*/
|
||
|
|
if (ByteCount == 0)
|
||
|
|
ByteCount = pStack->OutBufLength;
|
||
|
|
|
||
|
|
// Note MaxOutBufOverhead is the max for the default max allocation.
|
||
|
|
// It will be recalculated if the requested alloc size is greater
|
||
|
|
// than can be handled by the default.
|
||
|
|
irpSize = IoSizeOfIrp(OUTBUF_STACK_SIZE) + 8;
|
||
|
|
mdlSize = MaxOutBufMdlOverhead;
|
||
|
|
MaxOutBufOverhead = ((sizeof(OUTBUF) + 7) & ~7) + irpSize + mdlSize;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Determine which buffer pool to use, if any,
|
||
|
|
* and the OutBuf length to allocate, if necessary.
|
||
|
|
* Note that the max requested ByteCount that will hit the buffer pool
|
||
|
|
* is (MaxOutBufAlloc - 1 - MaxOutBufOverhead).
|
||
|
|
*/
|
||
|
|
if ((ByteCount + MaxOutBufOverhead) < MaxOutBufAlloc) {
|
||
|
|
|
||
|
|
ASSERT(((ByteCount + MaxOutBufOverhead) / MinOutBufAlloc) <
|
||
|
|
(1 << NumAllocSigBits));
|
||
|
|
PoolIndex = OutBufPoolMapping[(ByteCount + MaxOutBufOverhead) /
|
||
|
|
MinOutBufAlloc];
|
||
|
|
|
||
|
|
IcaAcquireSpinLock(&IcaSpinLock, &oldIrql);
|
||
|
|
if (!IsListEmpty(&IcaFreeOutBufHead[PoolIndex])) {
|
||
|
|
Head = RemoveHeadList(&IcaFreeOutBufHead[PoolIndex]);
|
||
|
|
IcaReleaseSpinLock(&IcaSpinLock, oldIrql);
|
||
|
|
pOutBuf = CONTAINING_RECORD(Head, OUTBUF, Links);
|
||
|
|
ASSERT(pOutBuf->PoolIndex == PoolIndex);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
IcaReleaseSpinLock(&IcaSpinLock, oldIrql);
|
||
|
|
AllocationSize = OutBufPoolAllocSizes[PoolIndex];
|
||
|
|
pOutBuf = ICA_ALLOCATE_POOL(NonPagedPool, AllocationSize);
|
||
|
|
if (pOutBuf == NULL)
|
||
|
|
return STATUS_NO_MEMORY;
|
||
|
|
|
||
|
|
// Prevent leaking control OutBufs on OutBuf free.
|
||
|
|
if (fControl)
|
||
|
|
PoolIndex = FreeThisOutBuf;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
PoolIndex = FreeThisOutBuf;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Determine the sizes of the various components of an OUTBUF.
|
||
|
|
* Note that these are all worst-case calculations --
|
||
|
|
* actual size of the MDL may be smaller.
|
||
|
|
*/
|
||
|
|
mdlSize = (ULONG)MmSizeOfMdl((PVOID)(PAGE_SIZE - 1), ByteCount);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Add up the component sizes of an OUTBUF to determine
|
||
|
|
* the total size that is needed to allocate.
|
||
|
|
*/
|
||
|
|
AllocationSize = ((sizeof(OUTBUF) + 7) & ~7) + irpSize + mdlSize +
|
||
|
|
((ByteCount + 3) & ~3);
|
||
|
|
|
||
|
|
pOutBuf = ICA_ALLOCATE_POOL(NonPagedPool, AllocationSize);
|
||
|
|
if (pOutBuf == NULL)
|
||
|
|
return STATUS_NO_MEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Initialize the IRP pointer and the IRP itself.
|
||
|
|
*/
|
||
|
|
pOutBuf->pIrp = (PIRP)((BYTE *)pOutBuf + ((sizeof(OUTBUF) + 7) & ~7));
|
||
|
|
IoInitializeIrp(pOutBuf->pIrp, (USHORT)irpSize, OUTBUF_STACK_SIZE);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Set up the MDL pointer but don't build it yet.
|
||
|
|
* It will be built by the TD write code if needed.
|
||
|
|
*/
|
||
|
|
pOutBuf->pMdl = (PMDL)((PCHAR)pOutBuf->pIrp + irpSize);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Set up the address buffer pointer.
|
||
|
|
*/
|
||
|
|
pOutBuf->pBuffer = (PUCHAR)pOutBuf->pMdl + mdlSize +
|
||
|
|
pStack->SdOutBufHeader;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Initialize the rest of output buffer
|
||
|
|
*/
|
||
|
|
InitializeListHead(&pOutBuf->Links);
|
||
|
|
pOutBuf->OutBufLength = ByteCount;
|
||
|
|
pOutBuf->PoolIndex = PoolIndex;
|
||
|
|
pOutBuf->MaxByteCount = ByteCount - (pStack->SdOutBufHeader +
|
||
|
|
pStack->SdOutBufTrailer);
|
||
|
|
pOutBuf->ByteCount = 0;
|
||
|
|
pOutBuf->fIrpCompleted = FALSE;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Copy inherited fields
|
||
|
|
*/
|
||
|
|
if (pOutBufOrig == NULL) {
|
||
|
|
pOutBuf->fWait = fWait; // wait for outbuf allocation
|
||
|
|
pOutBuf->fControl = fControl; // control buffer (ack/nak)
|
||
|
|
pOutBuf->fRetransmit = FALSE; // not a retransmit
|
||
|
|
pOutBuf->fCompress = TRUE; // compress data
|
||
|
|
pOutBuf->StartTime = 0; // time stamp
|
||
|
|
pOutBuf->Sequence = 0; // zero sequence number
|
||
|
|
pOutBuf->Fragment = 0; // zero fragment number
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
pOutBuf->fWait = pOutBufOrig->fWait;
|
||
|
|
pOutBuf->fControl = pOutBufOrig->fControl;
|
||
|
|
pOutBuf->fRetransmit = pOutBufOrig->fRetransmit;
|
||
|
|
pOutBuf->fCompress = pOutBufOrig->fCompress;
|
||
|
|
pOutBuf->StartTime = pOutBufOrig->StartTime;
|
||
|
|
pOutBuf->Sequence = pOutBufOrig->Sequence;
|
||
|
|
pOutBuf->Fragment = pOutBufOrig->Fragment++;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Increment allocated buffer count
|
||
|
|
*/
|
||
|
|
pStack->OutBufAllocCount++;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Return buffer to caller
|
||
|
|
*/
|
||
|
|
*ppOutBuf = pOutBuf;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Return buffer to caller
|
||
|
|
*/
|
||
|
|
return STATUS_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* IcaBufferFree
|
||
|
|
*
|
||
|
|
* pContext (input)
|
||
|
|
* pointer to SDCONTEXT of caller
|
||
|
|
* pOutBuf (input)
|
||
|
|
* pointer to OUTBUF structure
|
||
|
|
******************************************************************************/
|
||
|
|
void IcaBufferFree(IN PSDCONTEXT pContext, IN POUTBUF pOutBuf)
|
||
|
|
{
|
||
|
|
PSDLINK pSdLink;
|
||
|
|
PICA_STACK pStack;
|
||
|
|
NTSTATUS Status;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Use SD passed context to get the SDLINK pointer.
|
||
|
|
*/
|
||
|
|
pSdLink = CONTAINING_RECORD(pContext, SDLINK, SdContext);
|
||
|
|
pStack = pSdLink->pStack;
|
||
|
|
ASSERT(pSdLink->pStack->Header.Type == IcaType_Stack);
|
||
|
|
ASSERT(pSdLink->pStack->Header.pDispatchTable == IcaStackDispatchTable);
|
||
|
|
ASSERT(ExIsResourceAcquiredExclusiveLite( &pStack->Resource));
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Walk up the SDLINK list looking for a driver which has specified
|
||
|
|
* a BufferFree callup routine. If we find one, then call the
|
||
|
|
* driver BufferFree routine to let it handle the call.
|
||
|
|
*/
|
||
|
|
while ((pSdLink = IcaGetPreviousSdLink(pSdLink)) != NULL) {
|
||
|
|
ASSERT(pSdLink->pStack == pStack);
|
||
|
|
if (pSdLink->SdContext.pCallup->pSdBufferFree) {
|
||
|
|
IcaReferenceSdLink(pSdLink);
|
||
|
|
(pSdLink->SdContext.pCallup->pSdBufferFree)(
|
||
|
|
pSdLink->SdContext.pContext,
|
||
|
|
pOutBuf);
|
||
|
|
IcaDereferenceSdLink(pSdLink);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
IcaBufferFreeInternal(pContext, pOutBuf);
|
||
|
|
|
||
|
|
TRACESTACK((pStack, TC_ICADD, TT_API3,
|
||
|
|
"TermDD: IcaBufferFree: 0x%08x\n", pOutBuf));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* IcaBufferError
|
||
|
|
*
|
||
|
|
* pContext (input)
|
||
|
|
* pointer to SDCONTEXT of caller
|
||
|
|
* pOutBuf (input)
|
||
|
|
* pointer to OUTBUF structure
|
||
|
|
******************************************************************************/
|
||
|
|
void IcaBufferError(IN PSDCONTEXT pContext, IN POUTBUF pOutBuf)
|
||
|
|
{
|
||
|
|
PSDLINK pSdLink;
|
||
|
|
PICA_STACK pStack;
|
||
|
|
NTSTATUS Status;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Use SD passed context to get the SDLINK pointer.
|
||
|
|
*/
|
||
|
|
pSdLink = CONTAINING_RECORD(pContext, SDLINK, SdContext);
|
||
|
|
pStack = pSdLink->pStack;
|
||
|
|
ASSERT(pSdLink->pStack->Header.Type == IcaType_Stack);
|
||
|
|
ASSERT(pSdLink->pStack->Header.pDispatchTable == IcaStackDispatchTable);
|
||
|
|
ASSERT(ExIsResourceAcquiredExclusiveLite( &pStack->Resource));
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Walk up the SDLINK list looking for a driver which has specified
|
||
|
|
* a BufferError callup routine. If we find one, then call the
|
||
|
|
* driver BufferError routine to let it handle the call.
|
||
|
|
*/
|
||
|
|
while ((pSdLink = IcaGetPreviousSdLink(pSdLink)) != NULL) {
|
||
|
|
ASSERT(pSdLink->pStack == pStack);
|
||
|
|
if (pSdLink->SdContext.pCallup->pSdBufferError) {
|
||
|
|
IcaReferenceSdLink(pSdLink);
|
||
|
|
(pSdLink->SdContext.pCallup->pSdBufferError)(
|
||
|
|
pSdLink->SdContext.pContext,
|
||
|
|
pOutBuf);
|
||
|
|
IcaDereferenceSdLink(pSdLink);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
IcaBufferFreeInternal(pContext, pOutBuf);
|
||
|
|
|
||
|
|
TRACESTACK((pStack, TC_ICADD, TT_API3,
|
||
|
|
"TermDD: IcaBufferError: 0x%08x\n", pOutBuf));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void IcaBufferFreeInternal(IN PSDCONTEXT pContext, IN POUTBUF pOutBuf)
|
||
|
|
{
|
||
|
|
PSDLINK pSdLink;
|
||
|
|
PICA_STACK pStack;
|
||
|
|
KIRQL oldIrql;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Use SD passed context to get the SDLINK pointer.
|
||
|
|
*/
|
||
|
|
pSdLink = CONTAINING_RECORD(pContext, SDLINK, SdContext);
|
||
|
|
pStack = pSdLink->pStack;
|
||
|
|
ASSERT(pSdLink->pStack->Header.Type == IcaType_Stack);
|
||
|
|
ASSERT(pSdLink->pStack->Header.pDispatchTable == IcaStackDispatchTable);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* If the buffer came from a free pool, return it to the pool,
|
||
|
|
* otherwise free it. Note that pOutBuf->OutBufLength is actually the
|
||
|
|
* pool index to use.
|
||
|
|
*/
|
||
|
|
if (pOutBuf->PoolIndex != FreeThisOutBuf) {
|
||
|
|
ASSERT(pOutBuf->PoolIndex >= 0 &&
|
||
|
|
pOutBuf->PoolIndex < NumOutBufPools);
|
||
|
|
IcaAcquireSpinLock(&IcaSpinLock, &oldIrql);
|
||
|
|
InsertHeadList(&IcaFreeOutBufHead[pOutBuf->PoolIndex],
|
||
|
|
&pOutBuf->Links);
|
||
|
|
IcaReleaseSpinLock(&IcaSpinLock, oldIrql);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
ICA_FREE_POOL(pOutBuf);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Decrement allocated buffer count
|
||
|
|
*/
|
||
|
|
pStack->OutBufAllocCount--;
|
||
|
|
ASSERT((LONG)pStack->OutBufAllocCount >= 0);
|
||
|
|
|
||
|
|
/*
|
||
|
|
* If we hit the high watermark then we should wait until the low
|
||
|
|
* watermark is hit before signaling the allocator to continue.
|
||
|
|
* This should prevent excessive task switching.
|
||
|
|
*/
|
||
|
|
if (pStack->fWaitForOutBuf) {
|
||
|
|
if (pStack->OutBufAllocCount <= pStack->OutBufLowWaterMark) {
|
||
|
|
pStack->fWaitForOutBuf = FALSE;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Signal outbuf event (buffer is now available)
|
||
|
|
*/
|
||
|
|
(void) KeSetEvent(&pStack->OutBufEvent, EVENT_INCREMENT, FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* IcaGetLowWaterMark
|
||
|
|
*
|
||
|
|
* Description : Gets the low water mark that the stack specified
|
||
|
|
*
|
||
|
|
* pContext (input)
|
||
|
|
* pointer to SDCONTEXT of caller
|
||
|
|
******************************************************************************/
|
||
|
|
ULONG IcaGetLowWaterMark(IN PSDCONTEXT pContext)
|
||
|
|
{
|
||
|
|
ULONG ulRet = 0;
|
||
|
|
PICA_STACK pStack;
|
||
|
|
PSDLINK pSdLink = CONTAINING_RECORD(pContext, SDLINK, SdContext);
|
||
|
|
|
||
|
|
ASSERT(pSdLink);
|
||
|
|
|
||
|
|
ASSERT(pSdLink->pStack->Header.Type == IcaType_Stack);
|
||
|
|
|
||
|
|
ASSERT(pSdLink->pStack->Header.pDispatchTable == IcaStackDispatchTable);
|
||
|
|
|
||
|
|
ASSERT(ExIsResourceAcquiredExclusive( &pSdLink->pStack->Resource));
|
||
|
|
|
||
|
|
if (NULL != pSdLink) {
|
||
|
|
pStack = pSdLink->pStack;
|
||
|
|
ulRet = pStack->OutBufLowWaterMark;
|
||
|
|
}
|
||
|
|
return ulRet;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*******************************************************************************
|
||
|
|
* IcaGetSizeForNoLowWaterMark
|
||
|
|
*
|
||
|
|
* Description : Finds if the stack specified a no low water mark
|
||
|
|
* If so, returns the size needed to bypass ring
|
||
|
|
* returns zero if the stack does not specify a PD_NO_LOWWATERMARK
|
||
|
|
* pContext (input)
|
||
|
|
* pointer to SDCONTEXT of caller
|
||
|
|
******************************************************************************/
|
||
|
|
ULONG IcaGetSizeForNoLowWaterMark(IN PSDCONTEXT pContext)
|
||
|
|
{
|
||
|
|
ULONG retVal = 0;
|
||
|
|
ULONG ulLowWm = IcaGetLowWaterMark(pContext);
|
||
|
|
|
||
|
|
if ( MAX_LOW_WATERMARK == ulLowWm ) {
|
||
|
|
retVal = MaxOutBufAlloc;
|
||
|
|
}
|
||
|
|
return retVal;
|
||
|
|
}
|