4981 lines
186 KiB
C
4981 lines
186 KiB
C
/*++
|
||
|
||
Copyright (c) 2000-2000 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
Send.c
|
||
|
||
Abstract:
|
||
|
||
This module implements Send routines
|
||
the PGM Transport
|
||
|
||
Author:
|
||
|
||
Mohammad Shabbir Alam (MAlam) 3-30-2000
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
|
||
#include "precomp.h"
|
||
|
||
|
||
//******************* Pageable Routine Declarations ****************
|
||
#ifdef ALLOC_PRAGMA
|
||
#endif
|
||
//******************* Pageable Routine Declarations ****************
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
InitDataSpmOptions(
|
||
IN tCOMMON_SESSION_CONTEXT *pSession,
|
||
IN tCLIENT_SEND_REQUEST *pSendContext,
|
||
IN PUCHAR pOptions,
|
||
IN OUT USHORT *pBufferSize,
|
||
IN ULONG PgmOptionsFlag,
|
||
IN tPACKET_OPTIONS *pPacketOptions
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine initializes the header options for Data and Spm packets
|
||
|
||
Arguments:
|
||
|
||
IN pOptions -- Options buffer
|
||
IN OUT pBufferSize -- IN Maximum packet size, OUT Options length
|
||
IN PgmOptionsFlag -- Options requested to be set by caller
|
||
IN pPacketOptions -- Data for specific options
|
||
IN pSendContext -- Context for this send
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the call
|
||
|
||
--*/
|
||
{
|
||
ULONG pOptionsData[3];
|
||
USHORT OptionsLength = 0;
|
||
USHORT MaxBufferSize = *pBufferSize;
|
||
tPACKET_OPTION_GENERIC UNALIGNED *pOptionHeader;
|
||
tPACKET_OPTION_LENGTH UNALIGNED *pLengthOption = (tPACKET_OPTION_LENGTH UNALIGNED *) pOptions;
|
||
|
||
//
|
||
// Set the Packet Extension information
|
||
//
|
||
OptionsLength += PGM_PACKET_EXTENSION_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmOptions",
|
||
"Not enough space for HeaderExtension! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pLengthOption->Type = PACKET_OPTION_LENGTH;
|
||
pLengthOption->Length = PGM_PACKET_EXTENSION_LENGTH;
|
||
|
||
//
|
||
// First fill in the Network-Element-specific options:
|
||
//
|
||
if (PgmOptionsFlag & (PGM_OPTION_FLAG_CRQST | PGM_OPTION_FLAG_NBR_UNREACH))
|
||
{
|
||
// Not supporting these options for now
|
||
ASSERT (0);
|
||
return (STATUS_NOT_SUPPORTED);
|
||
}
|
||
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_PARITY_PRM)
|
||
{
|
||
//
|
||
// Applies to SPMs only
|
||
//
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_PARITY_PRM_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"Not enough space for PARITY_PRM Option! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_PARITY_PRM;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_PARITY_PRM_LENGTH;
|
||
|
||
pOptionHeader->U_OptSpecific = pSession->FECOptions;
|
||
pOptionsData[0] = htonl (pPacketOptions->FECContext.FECGroupInfo);
|
||
PgmCopyMemory ((pOptionHeader + 1), pOptionsData, (sizeof(ULONG)));
|
||
}
|
||
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_PARITY_CUR_TGSIZE)
|
||
{
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_PARITY_CUR_TGSIZE_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"Not enough space for PARITY_CUR_TGSIZE Option! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_CURR_TGSIZE;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_PARITY_CUR_TGSIZE_LENGTH;
|
||
pOptionsData[0] = htonl (pPacketOptions->FECContext.NumPacketsInThisGroup);
|
||
PgmCopyMemory ((pOptionHeader + 1), pOptionsData, (sizeof(ULONG)));
|
||
}
|
||
|
||
//
|
||
// Now, fill in the non-Network significant options
|
||
//
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_SYN)
|
||
{
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_SYN_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmOptions",
|
||
"Not enough space for SYN Option! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_SYN;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_SYN_LENGTH;
|
||
|
||
if ((pSendContext) &&
|
||
(pSendContext->DataOptions & PGM_OPTION_FLAG_SYN))
|
||
{
|
||
//
|
||
// Remove this option once it has been used!
|
||
//
|
||
pSendContext->DataOptions &= ~PGM_OPTION_FLAG_SYN;
|
||
pSendContext->DataOptionsLength -= PGM_PACKET_OPT_SYN_LENGTH;
|
||
if (!pSendContext->DataOptions)
|
||
{
|
||
// No other options, so set the length to 0
|
||
pSendContext->DataOptionsLength = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_FIN)
|
||
{
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_FIN_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmOptions",
|
||
"Not enough space for FIN Option! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_FIN;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_FIN_LENGTH;
|
||
}
|
||
|
||
if (PgmOptionsFlag & (PGM_OPTION_FLAG_RST | PGM_OPTION_FLAG_RST_N))
|
||
{
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_RST_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmOptions",
|
||
"Not enough space for RST Option! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_RST;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_RST_LENGTH;
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_RST_N)
|
||
{
|
||
pOptionHeader->U_OptSpecific = PACKET_OPTION_SPECIFIC_RST_N_BIT;
|
||
}
|
||
}
|
||
|
||
//
|
||
// now, set the FEC-specific options
|
||
//
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_PARITY_GRP)
|
||
{
|
||
//
|
||
// Applies to Parity packets only
|
||
//
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_PARITY_GRP_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmOptions",
|
||
"Not enough space for PARITY_GRP Option! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_PARITY_GRP;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_PARITY_GRP_LENGTH;
|
||
|
||
pOptionsData[0] = htonl (pPacketOptions->FECContext.FECGroupInfo);
|
||
PgmCopyMemory ((pOptionHeader + 1), pOptionsData, (sizeof(ULONG)));
|
||
}
|
||
|
||
//
|
||
// The following options should always be at the end, since they
|
||
// are never net-sig.
|
||
//
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_FRAGMENT)
|
||
{
|
||
pPacketOptions->FragmentOptionOffset = OptionsLength;
|
||
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_FRAGMENT_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmOptions",
|
||
"Not enough space for FragmentExtension! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_FRAGMENT;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_FRAGMENT_LENGTH;
|
||
|
||
//
|
||
// The PACKET_OPTION_RES_F_OPX_ENCODED_BIT will be set if necessary
|
||
// later since the OptionSpecific component is computed at the same
|
||
// time the entire data is encoded
|
||
//
|
||
pOptionsData[0] = htonl ((ULONG) pPacketOptions->MessageFirstSequence);
|
||
pOptionsData[1] = htonl (pPacketOptions->MessageOffset);
|
||
pOptionsData[2] = htonl (pPacketOptions->MessageLength);
|
||
PgmCopyMemory ((pOptionHeader + 1), pOptionsData, (3 * sizeof(ULONG)));
|
||
}
|
||
|
||
if (PgmOptionsFlag & PGM_OPTION_FLAG_JOIN)
|
||
{
|
||
pPacketOptions->LateJoinerOptionOffset = OptionsLength;
|
||
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &pOptions[OptionsLength];
|
||
OptionsLength += PGM_PACKET_OPT_JOIN_LENGTH;
|
||
if (OptionsLength > MaxBufferSize)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmOptions",
|
||
"Not enough space for JOIN Option! <%d> > <%d>\n", OptionsLength, MaxBufferSize);
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_JOIN;
|
||
pOptionHeader->OptionLength = PGM_PACKET_OPT_JOIN_LENGTH;
|
||
pOptionsData[0] = htonl ((ULONG) (SEQ_TYPE) pPacketOptions->LateJoinerSequence);
|
||
PgmCopyMemory ((pOptionHeader + 1), pOptionsData, (sizeof(ULONG)));
|
||
}
|
||
|
||
//
|
||
// So far, so good -- so set the rest of the option-specific info
|
||
//
|
||
if (OptionsLength)
|
||
{
|
||
pLengthOption->TotalOptionsLength = htons (OptionsLength); // Total length of all options
|
||
pOptionHeader->E_OptionType |= PACKET_OPTION_TYPE_END_BIT; // Indicates the last option
|
||
}
|
||
|
||
*pBufferSize = OptionsLength;
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
InitDataSpmHeader(
|
||
IN tCOMMON_SESSION_CONTEXT *pSession,
|
||
IN tCLIENT_SEND_REQUEST *pSendContext,
|
||
IN PUCHAR pHeader,
|
||
IN OUT USHORT *pHeaderLength,
|
||
IN ULONG PgmOptionsFlag,
|
||
IN tPACKET_OPTIONS *pPacketOptions,
|
||
IN UCHAR PacketType
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine initializes most of the header for Data and Spm packets
|
||
and fills in all of the optional fields
|
||
|
||
Arguments:
|
||
|
||
IN pSession -- Pgm session (sender) context
|
||
IN pHeader -- Packet buffer
|
||
IN pHeaderLength -- Maximum packet size
|
||
IN PgmOptionsFlag -- Options requested to be set by caller
|
||
IN pPacketOptions -- Data for specific options
|
||
IN PacketType -- whether Data or Spm packet
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the call
|
||
|
||
--*/
|
||
{
|
||
tCOMMON_HEADER *pCommonHeader = (tCOMMON_HEADER *) pHeader;
|
||
USHORT HeaderLength;
|
||
USHORT OptionsLength;
|
||
NTSTATUS status = STATUS_SUCCESS;
|
||
|
||
// NOTE: Session Lock must be held on Entry and Exit!
|
||
|
||
if (!(PGM_VERIFY_HANDLE2 (pSession, PGM_VERIFY_SESSION_SEND, PGM_VERIFY_SESSION_DOWN)))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"Bad Session ptr = <%p>\n", pSession);
|
||
return (STATUS_UNSUCCESSFUL);
|
||
}
|
||
|
||
//
|
||
// Memory for the Header must have been pre-allocated by the caller
|
||
//
|
||
if (*pHeaderLength < sizeof (tCOMMON_HEADER))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"InBufferLength = <%x> < Min = <%d>\n", *pHeaderLength, sizeof (tCOMMON_HEADER));
|
||
return (STATUS_INVALID_BUFFER_SIZE);
|
||
}
|
||
|
||
pCommonHeader->SrcPort = htons (pSession->TSIPort);
|
||
pCommonHeader->DestPort = htons (pSession->pSender->DestMCastPort);
|
||
pCommonHeader->Type = PacketType;
|
||
pCommonHeader->Options = 0;
|
||
PgmCopyMemory (&pCommonHeader->gSourceId, &pSession->GSI, SOURCE_ID_LENGTH);
|
||
|
||
//
|
||
// Now, set the initial header size and verify that we have a
|
||
// valid set of options based on the Packet type
|
||
//
|
||
switch (PacketType)
|
||
{
|
||
case (PACKET_TYPE_SPM):
|
||
{
|
||
HeaderLength = sizeof (tBASIC_SPM_PACKET_HEADER);
|
||
if (PgmOptionsFlag != (PGM_VALID_SPM_OPTION_FLAGS & PgmOptionsFlag))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"Unsupported Options flags=<%x> for SPM packets\n", PgmOptionsFlag);
|
||
|
||
return (STATUS_INVALID_PARAMETER);
|
||
}
|
||
|
||
if (PgmOptionsFlag & NETWORK_SIG_SPM_OPTIONS_FLAGS)
|
||
{
|
||
pCommonHeader->Options |= PACKET_HEADER_OPTIONS_NETWORK_SIGNIFICANT;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case (PACKET_TYPE_ODATA):
|
||
{
|
||
HeaderLength = sizeof (tBASIC_DATA_PACKET_HEADER);
|
||
if (PgmOptionsFlag != (PGM_VALID_DATA_OPTION_FLAGS & PgmOptionsFlag))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"Unsupported Options flags=<%x> for ODATA packets\n", PgmOptionsFlag);
|
||
|
||
return (STATUS_INVALID_PARAMETER);
|
||
}
|
||
|
||
if (PgmOptionsFlag & NETWORK_SIG_ODATA_OPTIONS_FLAGS)
|
||
{
|
||
pCommonHeader->Options |= PACKET_HEADER_OPTIONS_NETWORK_SIGNIFICANT;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
case (PACKET_TYPE_RDATA):
|
||
{
|
||
HeaderLength = sizeof (tBASIC_DATA_PACKET_HEADER);
|
||
if (PgmOptionsFlag != (PGM_VALID_DATA_OPTION_FLAGS & PgmOptionsFlag))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"Unsupported Options flags=<%x> for RDATA packets\n", PgmOptionsFlag);
|
||
|
||
return (STATUS_INVALID_PARAMETER);
|
||
}
|
||
|
||
if (PgmOptionsFlag & NETWORK_SIG_RDATA_OPTIONS_FLAGS)
|
||
{
|
||
pCommonHeader->Options |= PACKET_HEADER_OPTIONS_NETWORK_SIGNIFICANT;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
default:
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"Unsupported packet type = <%x>\n", PacketType);
|
||
|
||
return (STATUS_INVALID_PARAMETER); // Unrecognized Packet type!
|
||
}
|
||
}
|
||
|
||
if (*pHeaderLength < HeaderLength)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"InBufferLength=<%x> < HeaderLength=<%d> based on PacketType=<%x>\n",
|
||
*pHeaderLength, HeaderLength, PacketType);
|
||
|
||
return (STATUS_INVALID_BLOCK_LENGTH);
|
||
}
|
||
|
||
//
|
||
// Add any options if specified
|
||
//
|
||
OptionsLength = 0;
|
||
if (PgmOptionsFlag)
|
||
{
|
||
OptionsLength = *pHeaderLength - HeaderLength;
|
||
status = InitDataSpmOptions (pSession,
|
||
pSendContext,
|
||
&pHeader[HeaderLength],
|
||
&OptionsLength,
|
||
PgmOptionsFlag,
|
||
pPacketOptions);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "InitDataSpmHeader",
|
||
"InitDataSpmOptions returned <%x>\n", status);
|
||
|
||
return (status);
|
||
}
|
||
|
||
//
|
||
// So far, so good -- so set the rest of the option-specific info
|
||
//
|
||
pCommonHeader->Options |= PACKET_HEADER_OPTIONS_PRESENT; // Set the options bit
|
||
}
|
||
|
||
//
|
||
// The caller must now set the Checksum and other header information
|
||
//
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "InitDataSpmHeader",
|
||
"pHeader=<%p>, HeaderLength=<%d>, OptionsLength=<%d>\n",
|
||
pHeader, (ULONG) HeaderLength, (ULONG) OptionsLength);
|
||
|
||
*pHeaderLength = HeaderLength + OptionsLength;
|
||
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmSendSpmCompletion(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tBASIC_SPM_PACKET_HEADER *pSpmPacket,
|
||
IN NTSTATUS status
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called by the transport when the Spm send has been completed
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pSpmPacket -- Spm packet buffer
|
||
IN status --
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
{
|
||
PGMLockHandle OldIrq;
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
if (NT_SUCCESS (status))
|
||
{
|
||
//
|
||
// Set the Spm statistics
|
||
//
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendSpmCompletion",
|
||
"SUCCEEDED\n");
|
||
}
|
||
else
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendSpmCompletion",
|
||
"status=<%x>\n", status);
|
||
}
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_SPM);
|
||
|
||
//
|
||
// Free the Memory that was allocated for this
|
||
//
|
||
PgmFreeMem (pSpmPacket);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmSendSpm(
|
||
IN tSEND_SESSION *pSend,
|
||
IN PGMLockHandle *pOldIrq,
|
||
OUT ULONG *pBytesSent
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to send an Spm packet
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pOldIrq -- pSend's OldIrq
|
||
OUT pBytesSent -- Set if send succeeded (used for calculating throughput)
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the send
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
ULONG XSum, OptionsFlags;
|
||
tBASIC_SPM_PACKET_HEADER *pSpmPacket = NULL;
|
||
tPACKET_OPTIONS PacketOptions;
|
||
USHORT PacketLength = (USHORT) pSend->pSender->pAddress->OutIfMTU; // Init to max
|
||
|
||
*pBytesSent = 0;
|
||
|
||
if (!(pSpmPacket = PgmAllocMem (PacketLength, PGM_TAG('2'))))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendSpm",
|
||
"STATUS_INSUFFICIENT_RESOURCES\n");
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
PgmZeroMemory (pSpmPacket, PacketLength);
|
||
PgmZeroMemory (&PacketOptions, sizeof(tPACKET_OPTIONS));
|
||
|
||
OptionsFlags = pSend->pSender->SpmOptions;
|
||
if (OptionsFlags & PGM_OPTION_FLAG_JOIN)
|
||
{
|
||
//
|
||
// See if we have enough packets for the LateJoiner sequence numbers
|
||
//
|
||
if (SEQ_GT (pSend->pSender->LastODataSentSequenceNumber, (pSend->pSender->TrailingGroupSequenceNumber +
|
||
pSend->pSender->LateJoinSequenceNumbers)))
|
||
{
|
||
PacketOptions.LateJoinerSequence = (ULONG) (SEQ_TYPE) (pSend->pSender->LastODataSentSequenceNumber -
|
||
pSend->pSender->LateJoinSequenceNumbers);
|
||
}
|
||
else
|
||
{
|
||
PacketOptions.LateJoinerSequence = (ULONG) (SEQ_TYPE) pSend->pSender->TrailingGroupSequenceNumber;
|
||
}
|
||
}
|
||
|
||
if (OptionsFlags & PGM_OPTION_FLAG_PARITY_PRM) // Check if this is FEC-enabled
|
||
{
|
||
PacketOptions.FECContext.FECGroupInfo = pSend->FECGroupSize;
|
||
|
||
//
|
||
// See if we need to set the CURR_TGSIZE option for variable Group length
|
||
//
|
||
if ((pSend->pSender->EmptySequencesForLastSend) &&
|
||
(pSend->pSender->LastVariableTGPacketSequenceNumber ==
|
||
(pSend->pSender->LastODataSentSequenceNumber - pSend->pSender->EmptySequencesForLastSend)))
|
||
{
|
||
PacketOptions.FECContext.NumPacketsInThisGroup = pSend->FECGroupSize -
|
||
(UCHAR)pSend->pSender->EmptySequencesForLastSend;
|
||
OptionsFlags |= PGM_OPTION_FLAG_PARITY_CUR_TGSIZE;
|
||
ASSERT (PacketOptions.FECContext.NumPacketsInThisGroup);
|
||
}
|
||
}
|
||
|
||
status = InitDataSpmHeader (pSend,
|
||
NULL,
|
||
(PUCHAR) pSpmPacket,
|
||
&PacketLength,
|
||
OptionsFlags,
|
||
&PacketOptions,
|
||
PACKET_TYPE_SPM);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendSpm",
|
||
"InitDataSpmHeader returned <%x>\n", status);
|
||
|
||
PgmFreeMem (pSpmPacket);
|
||
return (status);
|
||
}
|
||
|
||
ASSERT (PacketLength);
|
||
|
||
pSpmPacket->SpmSequenceNumber = htonl ((ULONG) pSend->pSender->NextSpmSequenceNumber++);
|
||
pSpmPacket->TrailingEdgeSeqNumber = htonl ((ULONG) pSend->pSender->TrailingGroupSequenceNumber);
|
||
pSpmPacket->LeadingEdgeSeqNumber = htonl ((ULONG)((SEQ_TYPE)(pSend->pSender->LastODataSentSequenceNumber -
|
||
pSend->pSender->EmptySequencesForLastSend)));
|
||
pSpmPacket->PathNLA.NLA_AFI = htons (IPV4_NLA_AFI);
|
||
pSpmPacket->PathNLA.IpAddress = htonl (pSend->pSender->SenderMCastOutIf);
|
||
|
||
pSpmPacket->CommonHeader.Checksum = 0;
|
||
XSum = 0;
|
||
XSum = tcpxsum (XSum, (CHAR *) pSpmPacket, PacketLength); // Compute the Checksum
|
||
pSpmPacket->CommonHeader.Checksum = (USHORT) (~XSum);
|
||
|
||
PGM_REFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_SPM, TRUE);
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
|
||
status = TdiSendDatagram (pSend->pSender->pAddress->pRAlertFileObject,
|
||
pSend->pSender->pAddress->pRAlertDeviceObject,
|
||
pSpmPacket,
|
||
PacketLength,
|
||
PgmSendSpmCompletion, // Completion
|
||
pSend, // Context1
|
||
pSpmPacket, // Context2
|
||
pSend->pSender->DestMCastIpAddress,
|
||
pSend->pSender->DestMCastPort);
|
||
|
||
ASSERT (NT_SUCCESS (status));
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendSpm",
|
||
"Sent <%d> bytes to <%x:%d>, Options=<%x>, Window=[%d--%d]\n",
|
||
(ULONG) PacketLength, pSend->pSender->DestMCastIpAddress, pSend->pSender->DestMCastPort,
|
||
OptionsFlags, (ULONG) pSend->pSender->TrailingGroupSequenceNumber,
|
||
(ULONG) pSend->pSender->LastODataSentSequenceNumber);
|
||
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
*pBytesSent = PacketLength;
|
||
return (status);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmSendRDataCompletion(
|
||
IN tSEND_RDATA_CONTEXT *pRDataContext,
|
||
IN PVOID pRDataBuffer,
|
||
IN NTSTATUS status
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called by the transport when the RData send has been completed
|
||
|
||
Arguments:
|
||
|
||
IN pRDataContext -- RData context
|
||
IN pContext2 -- not used
|
||
IN status --
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
{
|
||
tSEND_SESSION *pSend = pRDataContext->pSend;
|
||
PGMLockHandle OldIrq;
|
||
|
||
ASSERT (NT_SUCCESS (status));
|
||
|
||
//
|
||
// Set the RData statistics
|
||
//
|
||
PgmLock (pSend, OldIrq);
|
||
if ((!--pRDataContext->NumPacketsInTransport) &&
|
||
(!pRDataContext->NumNaks))
|
||
{
|
||
pRDataContext->CleanupTime = pSend->pSender->TimerTickCount + pRDataContext->PostRDataHoldTime;
|
||
}
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
if (pRDataBuffer)
|
||
{
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SenderBufferLookaside, pRDataBuffer);
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendRDataCompletion",
|
||
"status=<%x>, pRDataBuffer=<%p>\n", status, pRDataBuffer);
|
||
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_RDATA);
|
||
return;
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmBuildParityPacket(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tPACKET_BUFFER *pPacketBuffer,
|
||
IN tBUILD_PARITY_CONTEXT *pParityContext,
|
||
IN PUCHAR pFECPacket,
|
||
IN OUT USHORT *pPacketLength,
|
||
IN UCHAR PacketType
|
||
)
|
||
{
|
||
NTSTATUS status;
|
||
tPACKET_OPTIONS PacketOptions;
|
||
tPOST_PACKET_FEC_CONTEXT UNALIGNED *pFECContext;
|
||
tPOST_PACKET_FEC_CONTEXT FECContext;
|
||
ULONG SequenceNumber;
|
||
ULONG FECGroupMask;
|
||
tPACKET_OPTION_GENERIC UNALIGNED *pOptionHeader;
|
||
USHORT PacketLength = *pPacketLength; // Init to max buffer length
|
||
tBASIC_DATA_PACKET_HEADER UNALIGNED *pRData = (tBASIC_DATA_PACKET_HEADER UNALIGNED *)
|
||
&pPacketBuffer->DataPacket;
|
||
|
||
*pPacketLength = 0; // Init, in case of error
|
||
|
||
//
|
||
// First, get the options encoded in this RData packet to see
|
||
// if we need to use them!
|
||
//
|
||
FECGroupMask = pSend->FECGroupSize - 1;
|
||
pParityContext->NextFECPacketIndex = pPacketBuffer->PacketOptions.FECContext.SenderNextFECPacketIndex;
|
||
SequenceNumber = (ntohl(pRData->DataSequenceNumber)) | (pParityContext->NextFECPacketIndex & FECGroupMask);
|
||
ASSERT (!(pParityContext->OptionsFlags & ~(PGM_OPTION_FLAG_SYN |
|
||
PGM_OPTION_FLAG_FIN |
|
||
PGM_OPTION_FLAG_FRAGMENT |
|
||
PGM_OPTION_FLAG_PARITY_CUR_TGSIZE |
|
||
PGM_OPTION_FLAG_PARITY_GRP)));
|
||
|
||
PgmZeroMemory (&PacketOptions, sizeof (tPACKET_OPTIONS));
|
||
|
||
//
|
||
// We don't need to set any parameters for the SYN and FIN options
|
||
// We will set the parameters for the FRAGMENT option (if needed) later
|
||
// since will need to have the encoded paramters
|
||
//
|
||
if (pParityContext->OptionsFlags & PGM_OPTION_FLAG_PARITY_CUR_TGSIZE)
|
||
{
|
||
ASSERT (pParityContext->NumPacketsInThisGroup);
|
||
PacketOptions.FECContext.NumPacketsInThisGroup = pParityContext->NumPacketsInThisGroup;
|
||
}
|
||
|
||
if (pParityContext->NextFECPacketIndex >= pSend->FECGroupSize)
|
||
{
|
||
pParityContext->OptionsFlags |= PGM_OPTION_FLAG_PARITY_GRP;
|
||
PacketOptions.FECContext.FECGroupInfo = pParityContext->NextFECPacketIndex / pSend->FECGroupSize;
|
||
}
|
||
|
||
PgmZeroMemory (pFECPacket, PacketLength);
|
||
status = InitDataSpmHeader (pSend,
|
||
NULL,
|
||
(PUCHAR) pFECPacket,
|
||
&PacketLength,
|
||
pParityContext->OptionsFlags,
|
||
&PacketOptions,
|
||
PacketType);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmBuildParityPacket",
|
||
"InitDataSpmHeader returned <%x>\n", status);
|
||
return (status);
|
||
}
|
||
|
||
status = FECEncode (&pSend->FECContext,
|
||
&pParityContext->pDataBuffers[0],
|
||
pParityContext->NumPacketsInThisGroup,
|
||
(pSend->pSender->MaxPayloadSize + sizeof (tPOST_PACKET_FEC_CONTEXT)),
|
||
pParityContext->NextFECPacketIndex,
|
||
&pFECPacket[PacketLength]);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmBuildParityPacket",
|
||
"FECEncode returned <%x>\n", status);
|
||
return (status);
|
||
}
|
||
|
||
//
|
||
// Now, fill in the remaining fields of the header
|
||
//
|
||
pRData = (tBASIC_DATA_PACKET_HEADER *) pFECPacket;
|
||
|
||
//
|
||
// Set the FEC-specific options
|
||
//
|
||
pRData->CommonHeader.Options |= (PACKET_HEADER_OPTIONS_PARITY |
|
||
PACKET_HEADER_OPTIONS_VAR_PKTLEN);
|
||
|
||
if (pParityContext->OptionsFlags & PGM_OPTION_FLAG_FRAGMENT)
|
||
{
|
||
pFECContext = (tPOST_PACKET_FEC_CONTEXT UNALIGNED *) (pFECPacket +
|
||
PacketLength +
|
||
pSend->pSender->MaxPayloadSize);
|
||
PgmCopyMemory (&FECContext, pFECContext, sizeof (tPOST_PACKET_FEC_CONTEXT));
|
||
|
||
ASSERT (pRData->CommonHeader.Options & PACKET_HEADER_OPTIONS_PRESENT);
|
||
if (PacketOptions.FragmentOptionOffset)
|
||
{
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &((PUCHAR) (pRData + 1)) [PacketOptions.FragmentOptionOffset];
|
||
|
||
pOptionHeader->Reserved_F_Opx |= PACKET_OPTION_RES_F_OPX_ENCODED_BIT;
|
||
pOptionHeader->U_OptSpecific = FECContext.FragmentOptSpecific;
|
||
|
||
PgmCopyMemory ((pOptionHeader + 1),
|
||
&FECContext.EncodedFragmentOptions,
|
||
(sizeof (tFRAGMENT_OPTIONS)));
|
||
}
|
||
else
|
||
{
|
||
ASSERT (0);
|
||
}
|
||
}
|
||
|
||
pRData->CommonHeader.TSDULength = htons ((USHORT) pSend->pSender->MaxPayloadSize + sizeof (USHORT));
|
||
pRData->DataSequenceNumber = htonl (SequenceNumber);
|
||
|
||
//
|
||
// Set the next FECPacketIndex
|
||
//
|
||
if (++pParityContext->NextFECPacketIndex >= pSend->FECBlockSize) // n
|
||
{
|
||
pParityContext->NextFECPacketIndex = pSend->FECGroupSize; // k
|
||
}
|
||
pPacketBuffer->PacketOptions.FECContext.SenderNextFECPacketIndex = pParityContext->NextFECPacketIndex;
|
||
|
||
PacketLength += (USHORT) (pSend->pSender->MaxPayloadSize + sizeof (USHORT));
|
||
*pPacketLength = PacketLength;
|
||
return (status);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmSendRData(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tSEND_RDATA_CONTEXT *pRDataContext,
|
||
IN PGMLockHandle *pOldIrq,
|
||
OUT ULONG *pBytesSent
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to send a Repair Data (RData) packet
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pOldIrq -- pSend's OldIrq
|
||
OUT pBytesSent -- Set if send succeeded (used for calculating throughput)
|
||
|
||
Arguments:
|
||
|
||
IN
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the send request
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
KAPC_STATE ApcState;
|
||
BOOLEAN fAttached, fInserted;
|
||
LIST_ENTRY *pEntry;
|
||
ULONGLONG OffsetBytes;
|
||
ULONG XSum, PacketsBehindLeadingEdge;
|
||
tBASIC_DATA_PACKET_HEADER *pRData;
|
||
PUCHAR pSendBuffer = NULL;
|
||
USHORT i, PacketLength;
|
||
tPACKET_BUFFER *pPacketBuffer;
|
||
tPACKET_BUFFER *pPacketBufferTemp;
|
||
tSEND_RDATA_CONTEXT *pRDataTemp;
|
||
|
||
*pBytesSent = 0;
|
||
|
||
ASSERT (SEQ_LEQ (pRDataContext->RDataSequenceNumber, pSend->pSender->LastODataSentSequenceNumber) &&
|
||
SEQ_GEQ (pRDataContext->RDataSequenceNumber, pSend->pSender->TrailingGroupSequenceNumber));
|
||
|
||
//
|
||
// Find the buffer address based on offset from the trailing edge
|
||
// Also, check for wrap-around
|
||
//
|
||
OffsetBytes = (SEQ_TYPE) (pRDataContext->RDataSequenceNumber-pSend->pSender->TrailingEdgeSequenceNumber) *
|
||
pSend->pSender->PacketBufferSize;
|
||
OffsetBytes += pSend->pSender->TrailingWindowOffset;
|
||
if (OffsetBytes >= pSend->pSender->MaxDataFileSize)
|
||
{
|
||
OffsetBytes -= pSend->pSender->MaxDataFileSize; // Wrap -around
|
||
}
|
||
|
||
pPacketBuffer = (tPACKET_BUFFER *) (((PUCHAR) pSend->pSender->SendDataBufferMapping) + OffsetBytes);
|
||
pRData = &pPacketBuffer->DataPacket;
|
||
|
||
ASSERT (PGM_MAX_FEC_DATA_HEADER_LENGTH >= PGM_MAX_DATA_HEADER_LENGTH);
|
||
PacketLength = PGM_MAX_FEC_DATA_HEADER_LENGTH + (USHORT) pSend->pSender->MaxPayloadSize;
|
||
if (!(pSendBuffer = ExAllocateFromNPagedLookasideList (&pSend->pSender->SenderBufferLookaside)))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendRData",
|
||
"STATUS_INSUFFICIENT_RESOURCES\n");
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
|
||
//
|
||
// First do some sanity checks!
|
||
//
|
||
ASSERT ((pRDataContext->NakType == NAK_TYPE_PARITY) ||
|
||
(pRDataContext->NumNaks == 1));
|
||
|
||
pRDataContext->NumPacketsInTransport++; // So that this context cannot go away!
|
||
PGM_REFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_RDATA, TRUE);
|
||
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmAttachToProcessForVMAccess (pSend, &ApcState, &fAttached, REF_PROCESS_ATTACH_SEND_RDATA);
|
||
|
||
switch (pRDataContext->NakType)
|
||
{
|
||
case (NAK_TYPE_PARITY):
|
||
{
|
||
//
|
||
// If this is the first parity packet to be sent from this group,
|
||
// then we will need to initialize the buffers
|
||
//
|
||
if (!pRDataContext->OnDemandParityContext.NumPacketsInThisGroup)
|
||
{
|
||
pRDataContext->OnDemandParityContext.OptionsFlags = 0;
|
||
pRDataContext->OnDemandParityContext.NumPacketsInThisGroup = 0;
|
||
|
||
pPacketBufferTemp = pPacketBuffer;
|
||
for (i=0; i<pSend->FECGroupSize; i++)
|
||
{
|
||
pRDataContext->OnDemandParityContext.pDataBuffers[i] = &((PUCHAR) &pPacketBufferTemp->DataPacket)
|
||
[sizeof (tBASIC_DATA_PACKET_HEADER) +
|
||
pPacketBufferTemp->PacketOptions.OptionsLength];
|
||
|
||
pRDataContext->OnDemandParityContext.OptionsFlags |= pPacketBufferTemp->PacketOptions.OptionsFlags &
|
||
(PGM_OPTION_FLAG_SYN |
|
||
PGM_OPTION_FLAG_FIN |
|
||
PGM_OPTION_FLAG_FRAGMENT |
|
||
PGM_OPTION_FLAG_PARITY_CUR_TGSIZE);
|
||
|
||
if (pPacketBufferTemp->PacketOptions.OptionsFlags & PGM_OPTION_FLAG_PARITY_CUR_TGSIZE)
|
||
{
|
||
ASSERT (!pRDataContext->OnDemandParityContext.NumPacketsInThisGroup);
|
||
ASSERT (pPacketBufferTemp->PacketOptions.FECContext.NumPacketsInThisGroup);
|
||
pRDataContext->OnDemandParityContext.NumPacketsInThisGroup = pPacketBufferTemp->PacketOptions.FECContext.NumPacketsInThisGroup;
|
||
}
|
||
|
||
pPacketBufferTemp = (tPACKET_BUFFER *) (((PUCHAR) pPacketBufferTemp) +
|
||
pSend->pSender->PacketBufferSize);
|
||
}
|
||
|
||
if (!(pRDataContext->OnDemandParityContext.OptionsFlags & PGM_OPTION_FLAG_PARITY_CUR_TGSIZE))
|
||
{
|
||
ASSERT (!pRDataContext->OnDemandParityContext.NumPacketsInThisGroup);
|
||
pRDataContext->OnDemandParityContext.NumPacketsInThisGroup = pSend->FECGroupSize;
|
||
}
|
||
}
|
||
|
||
ASSERT (pRDataContext->OnDemandParityContext.pDataBuffers[0]);
|
||
|
||
//
|
||
// If we have just 1 packet in this group, then we just do
|
||
// a selective Nak
|
||
//
|
||
if (pRDataContext->OnDemandParityContext.NumPacketsInThisGroup != 1)
|
||
{
|
||
status = PgmBuildParityPacket (pSend,
|
||
pPacketBuffer,
|
||
&pRDataContext->OnDemandParityContext,
|
||
pSendBuffer,
|
||
&PacketLength,
|
||
PACKET_TYPE_RDATA);
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendRData",
|
||
"PgmBuildParityPacket returned <%x>\n", status);
|
||
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_SEND_RDATA);
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SenderBufferLookaside, pSendBuffer);
|
||
pRDataContext->NumPacketsInTransport--; // Undoing what we did earlier
|
||
return (status);
|
||
}
|
||
|
||
pRData = (tBASIC_DATA_PACKET_HEADER *) pSendBuffer;
|
||
|
||
break;
|
||
}
|
||
|
||
pRDataContext->NumNaks = 1; // Don't want to send excessive Selective naks!
|
||
}
|
||
|
||
case (NAK_TYPE_SELECTIVE):
|
||
{
|
||
//
|
||
// Since the packet was already filled in earlier, we just need to
|
||
// update the Trailing Edge Seq number + PacketType and Checksum!
|
||
//
|
||
ASSERT ((ULONG) pRDataContext->RDataSequenceNumber == (ULONG) ntohl (pRData->DataSequenceNumber));
|
||
|
||
PacketLength = pPacketBuffer->PacketOptions.TotalPacketLength;
|
||
|
||
PgmCopyMemory (pSendBuffer, pRData, PacketLength);
|
||
pRData = (tBASIC_DATA_PACKET_HEADER *) pSendBuffer;
|
||
|
||
break;
|
||
}
|
||
|
||
default:
|
||
{
|
||
ASSERT (0);
|
||
}
|
||
}
|
||
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_SEND_RDATA);
|
||
|
||
pRData->TrailingEdgeSequenceNumber = htonl ((ULONG) pSend->pSender->TrailingGroupSequenceNumber);
|
||
pRData->CommonHeader.Type = PACKET_TYPE_RDATA;
|
||
pRData->CommonHeader.Checksum = 0;
|
||
XSum = 0;
|
||
XSum = tcpxsum (XSum, (CHAR *) pRData, (ULONG) PacketLength); // Compute the Checksum
|
||
pRData->CommonHeader.Checksum = (USHORT) (~XSum);
|
||
|
||
status = TdiSendDatagram (pSend->pSender->pAddress->pRAlertFileObject,
|
||
pSend->pSender->pAddress->pRAlertDeviceObject,
|
||
pRData,
|
||
(ULONG) PacketLength,
|
||
PgmSendRDataCompletion, // Completion
|
||
pRDataContext, // Context1
|
||
pSendBuffer, // Context2
|
||
pSend->pSender->DestMCastIpAddress,
|
||
pSend->pSender->DestMCastPort);
|
||
|
||
ASSERT (NT_SUCCESS (status));
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendRData",
|
||
"[%d] Sent <%d> bytes to <%x->%d>\n",
|
||
(ULONG) pRDataContext->RDataSequenceNumber, (ULONG) PacketLength,
|
||
pSend->pSender->DestMCastIpAddress, pSend->pSender->DestMCastPort);
|
||
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
if (!--pRDataContext->NumNaks)
|
||
{
|
||
RemoveEntryList (&pRDataContext->Linkage);
|
||
//
|
||
// The Handled list has to be sorted for FilterAndAddNaksToList to work
|
||
// We will traverse the list backwards since there is a higher
|
||
// probability of inserting this context near the end of the list
|
||
// So, we will try to find an element we can insert after
|
||
//
|
||
fInserted = FALSE;
|
||
pEntry = &pSend->pSender->HandledRDataRequests;
|
||
while ((pEntry = pEntry->Blink) != &pSend->pSender->HandledRDataRequests)
|
||
{
|
||
pRDataTemp = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
|
||
//
|
||
// Sequences greater than this can be skipped
|
||
//
|
||
if (SEQ_GT (pRDataTemp->RDataSequenceNumber, pRDataContext->RDataSequenceNumber))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
//
|
||
// We will always order the Parity Nak before the Selective Nak
|
||
// Both the Nak types should not exist in the list for the
|
||
// same sequence number
|
||
//
|
||
if ((pRDataTemp->RDataSequenceNumber == pRDataContext->RDataSequenceNumber) &&
|
||
(pRDataTemp->NakType == NAK_TYPE_SELECTIVE))
|
||
{
|
||
ASSERT (pRDataTemp->NakType != pRDataContext->NakType);
|
||
continue;
|
||
}
|
||
|
||
pRDataContext->Linkage.Blink = pEntry;
|
||
pRDataContext->Linkage.Flink = pEntry->Flink;
|
||
pEntry->Flink->Blink = &pRDataContext->Linkage;
|
||
pEntry->Flink = &pRDataContext->Linkage;
|
||
|
||
fInserted = TRUE;
|
||
break;
|
||
}
|
||
|
||
if (!fInserted)
|
||
{
|
||
InsertHeadList (&pSend->pSender->HandledRDataRequests, &pRDataContext->Linkage);
|
||
}
|
||
|
||
pSend->pSender->NumRDataRequestsPending--;
|
||
|
||
//
|
||
// If the SendCompletion was called before this point, then we will
|
||
// need to set the CleanupTime outselves
|
||
//
|
||
if (!pRDataContext->NumPacketsInTransport)
|
||
{
|
||
pRDataContext->CleanupTime = pSend->pSender->TimerTickCount + pRDataContext->PostRDataHoldTime;
|
||
}
|
||
}
|
||
|
||
pSend->pSender->NumOutstandingNaks--;
|
||
pSend->pSender->RepairPacketsSent++;
|
||
|
||
*pBytesSent = PacketLength;
|
||
return (status);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmSendNcfCompletion(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tBASIC_NAK_NCF_PACKET_HEADER *pNcfPacket,
|
||
IN NTSTATUS status
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called by the transport when the Ncf send has been completed
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pNcfPacket -- Ncf packet buffer
|
||
IN status --
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
{
|
||
PGMLockHandle OldIrq;
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
if (NT_SUCCESS (status))
|
||
{
|
||
//
|
||
// Set the Ncf statistics
|
||
//
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendNcfCompletion",
|
||
"SUCCEEDED\n");
|
||
}
|
||
else
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendNcfCompletion",
|
||
"status=<%x>\n", status);
|
||
}
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_NCF);
|
||
PgmFreeMem (pNcfPacket);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmSendNcf(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tBASIC_NAK_NCF_PACKET_HEADER UNALIGNED *pNakPacket,
|
||
IN tNAKS_LIST *pNcfsList,
|
||
IN ULONG NakPacketLength
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to send an NCF packet
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pNakPacket -- Nak packet which trigerred the Ncf
|
||
IN NakPacketLength -- Length of Nak packet
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the send
|
||
|
||
--*/
|
||
{
|
||
ULONG i, XSum;
|
||
NTSTATUS status;
|
||
tBASIC_NAK_NCF_PACKET_HEADER *pNcfPacket;
|
||
tPACKET_OPTION_LENGTH *pPacketExtension;
|
||
tPACKET_OPTION_GENERIC *pOptionHeader;
|
||
USHORT OptionsLength = 0;
|
||
|
||
if (!(pNcfPacket = PgmAllocMem (NakPacketLength, PGM_TAG('2'))))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendNcf",
|
||
"STATUS_INSUFFICIENT_RESOURCES\n");
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
PgmZeroMemory (pNcfPacket, NakPacketLength); // Copy the packet in its entirety
|
||
|
||
//
|
||
// Now, set the fields specific to this sender
|
||
//
|
||
pNcfPacket->CommonHeader.SrcPort = htons (pSend->TSIPort);
|
||
pNcfPacket->CommonHeader.DestPort = htons (pSend->pSender->DestMCastPort);
|
||
pNcfPacket->CommonHeader.Type = PACKET_TYPE_NCF;
|
||
if (pNcfsList->NakType == NAK_TYPE_PARITY)
|
||
{
|
||
pNcfPacket->CommonHeader.Options = PACKET_HEADER_OPTIONS_PARITY;
|
||
}
|
||
else
|
||
{
|
||
pNcfPacket->CommonHeader.Options = 0;
|
||
}
|
||
PgmCopyMemory (&pNcfPacket->CommonHeader.gSourceId, &pSend->GSI, SOURCE_ID_LENGTH);
|
||
|
||
pNcfPacket->SourceNLA.NLA_AFI = pNakPacket->SourceNLA.NLA_AFI;
|
||
pNcfPacket->SourceNLA.IpAddress = pNakPacket->SourceNLA.IpAddress;
|
||
pNcfPacket->MCastGroupNLA.NLA_AFI = pNakPacket->MCastGroupNLA.NLA_AFI;
|
||
pNcfPacket->MCastGroupNLA.IpAddress = pNakPacket->MCastGroupNLA.IpAddress;
|
||
|
||
//
|
||
// Now, fill in the Sequence numbers
|
||
//
|
||
ASSERT (pNcfsList->NumNaks[0]);
|
||
pNcfPacket->RequestedSequenceNumber = htonl ((ULONG) ((SEQ_TYPE) (pNcfsList->pNakSequences[0] +
|
||
pNcfsList->NumNaks[0] - 1)));
|
||
if (pNcfsList->NumSequences > 1)
|
||
{
|
||
pPacketExtension = (tPACKET_OPTION_LENGTH *) (pNcfPacket + 1);
|
||
pPacketExtension->Type = PACKET_OPTION_LENGTH;
|
||
pPacketExtension->Length = PGM_PACKET_EXTENSION_LENGTH;
|
||
OptionsLength += PGM_PACKET_EXTENSION_LENGTH;
|
||
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC *) (pPacketExtension + 1);
|
||
pOptionHeader->E_OptionType = PACKET_OPTION_NAK_LIST;
|
||
pOptionHeader->OptionLength = 4 + (UCHAR) ((pNcfsList->NumSequences-1) * sizeof(ULONG));
|
||
for (i=1; i<pNcfsList->NumSequences; i++)
|
||
{
|
||
ASSERT (pNcfsList->NumNaks[i]);
|
||
((PULONG) (pOptionHeader))[i] = htonl ((ULONG) ((SEQ_TYPE) (pNcfsList->pNakSequences[i] +
|
||
pNcfsList->NumNaks[i] - 1)));
|
||
}
|
||
|
||
pOptionHeader->E_OptionType |= PACKET_OPTION_TYPE_END_BIT; // One and only (last) opt
|
||
pNcfPacket->CommonHeader.Options |=(PACKET_HEADER_OPTIONS_PRESENT |
|
||
PACKET_HEADER_OPTIONS_NETWORK_SIGNIFICANT);
|
||
OptionsLength = PGM_PACKET_EXTENSION_LENGTH + pOptionHeader->OptionLength;
|
||
pPacketExtension->TotalOptionsLength = htons (OptionsLength);
|
||
}
|
||
|
||
OptionsLength += sizeof(tBASIC_NAK_NCF_PACKET_HEADER); // Now is whole pkt
|
||
|
||
pNcfPacket->CommonHeader.Checksum = 0;
|
||
XSum = 0;
|
||
XSum = tcpxsum (XSum, (CHAR *) pNcfPacket, NakPacketLength);
|
||
pNcfPacket->CommonHeader.Checksum = (USHORT) (~XSum);
|
||
|
||
PGM_REFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_NCF, FALSE);
|
||
|
||
status = TdiSendDatagram (pSend->pSender->pAddress->pRAlertFileObject,
|
||
pSend->pSender->pAddress->pRAlertDeviceObject,
|
||
pNcfPacket,
|
||
OptionsLength,
|
||
PgmSendNcfCompletion, // Completion
|
||
pSend, // Context1
|
||
pNcfPacket, // Context2
|
||
pSend->pSender->DestMCastIpAddress,
|
||
pSend->pSender->DestMCastPort);
|
||
|
||
ASSERT (NT_SUCCESS (status));
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendNcf",
|
||
"Sent <%d> bytes to <%x:%d>\n",
|
||
NakPacketLength, pSend->pSender->DestMCastIpAddress, pSend->pSender->DestMCastPort);
|
||
|
||
return (status);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
FilterAndAddNaksToList(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tNAKS_LIST *pNaksList
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine processes a list of Naks, removing duplicates and adding
|
||
new Naks where necessary
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pNaksList -- Contains Nak type and List of Nak sequences
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the call
|
||
|
||
--*/
|
||
{
|
||
tSEND_RDATA_CONTEXT *pRDataContext;
|
||
tSEND_RDATA_CONTEXT *pRDataNew;
|
||
LIST_ENTRY *pEntry;
|
||
ULONG i, j, NumNcfs, RDataContextSize;
|
||
ULONGLONG PreRDataWait;
|
||
|
||
//
|
||
// First, eliminate the entries that are currently in the handled list!
|
||
//
|
||
i = 0;
|
||
NumNcfs = 0;
|
||
ASSERT (pNaksList->NumSequences);
|
||
pEntry = &pSend->pSender->HandledRDataRequests;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->HandledRDataRequests)
|
||
{
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
if (pRDataContext->NakType != pNaksList->NakType)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (pRDataContext->RDataSequenceNumber == pNaksList->pNakSequences[i])
|
||
{
|
||
#if 0
|
||
//
|
||
// If this RData has passed the Linger time, cleanup here!
|
||
//
|
||
if ((pRDataContext->CleanupTime) &&
|
||
(pSend->pSender->TimerTickCount > pRDataContext->CleanupTime))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "FilterAndAddNaksToList",
|
||
"Removing lingering RData for SeqNum=<%d>\n", (ULONG) pRDataContext->RDataSequenceNumber);
|
||
|
||
pEntry = pEntry->Blink; // Set this because this pEntry will not be valid any more!
|
||
RemoveEntryList (&pRDataContext->Linkage);
|
||
PgmFreeMem (pRDataContext);
|
||
|
||
continue;
|
||
}
|
||
#endif // 0
|
||
|
||
pSend->pSender->NumNaksAfterRData++;
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "FilterAndAddNaksToList",
|
||
"Ignoring Sequence # [%d] since we just sent RData for it!\n",
|
||
(ULONG) pNaksList->pNakSequences[i]);
|
||
|
||
pNaksList->NumSequences--;
|
||
for (j = i; j < pNaksList->NumSequences; j++)
|
||
{
|
||
pNaksList->pNakSequences[j] = pNaksList->pNakSequences[j+1];
|
||
pNaksList->NumNaks[j] = pNaksList->NumNaks[j+1];
|
||
}
|
||
}
|
||
else if (SEQ_GT (pRDataContext->RDataSequenceNumber, pNaksList->pNakSequences[i]))
|
||
{
|
||
//
|
||
// Our current sequence is not in the list, so go to the next one
|
||
// and recompare with this sequence
|
||
//
|
||
i++;
|
||
pEntry = pEntry->Blink;
|
||
}
|
||
|
||
if (i >= pNaksList->NumSequences)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Now, check for pending RData requests and add new ones if necessary
|
||
//
|
||
i = 0;
|
||
RDataContextSize = sizeof(tSEND_RDATA_CONTEXT) + pSend->FECGroupSize*sizeof(PUCHAR);
|
||
pEntry = &pSend->pSender->PendingRDataRequests;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->PendingRDataRequests)
|
||
{
|
||
if (i >= pNaksList->NumSequences)
|
||
{
|
||
break;
|
||
}
|
||
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
if (SEQ_LT (pRDataContext->RDataSequenceNumber, pNaksList->pNakSequences[i]))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (SEQ_GT (pRDataContext->RDataSequenceNumber, pNaksList->pNakSequences[i]) ||
|
||
((pRDataContext->NakType == NAK_TYPE_SELECTIVE) && // If seq #s are equal, parity Naks will be added before selective
|
||
(pNaksList->NakType == NAK_TYPE_PARITY)))
|
||
{
|
||
//
|
||
// Our current sequence is not in the list, so add it!
|
||
//
|
||
if (!(pRDataNew = PgmAllocMem (RDataContextSize, PGM_TAG('2'))))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "FilterAndAddNaksToList",
|
||
"[1] STATUS_INSUFFICIENT_RESOURCES\n");
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
PgmZeroMemory (pRDataNew, RDataContextSize);
|
||
|
||
pRDataNew->Linkage.Flink = pEntry;
|
||
pRDataNew->Linkage.Blink = pEntry->Blink;
|
||
pEntry->Blink->Flink = &pRDataNew->Linkage;
|
||
pEntry->Blink = &pRDataNew->Linkage;
|
||
|
||
pRDataNew->pSend = pSend;
|
||
pRDataNew->RDataSequenceNumber = pNaksList->pNakSequences[i];
|
||
pRDataNew->NakType = pNaksList->NakType;
|
||
pRDataNew->NumNaks = pNaksList->NumNaks[i];
|
||
pRDataNew->RequestTime = pSend->pSender->CurrentTimeoutCount;
|
||
|
||
pSend->pSender->NumOutstandingNaks += pNaksList->NumNaks[i];
|
||
pSend->pSender->NumRDataRequestsPending++;
|
||
if (SEQ_GT (pSend->pSender->LastODataSentSequenceNumber, pSend->pSender->TrailingGroupSequenceNumber))
|
||
{
|
||
PreRDataWait = (((SEQ_TYPE) (pRDataNew->RDataSequenceNumber -
|
||
pSend->pSender->TrailingGroupSequenceNumber)) *
|
||
pSend->pSender->RDataLingerTime) /
|
||
((SEQ_TYPE) (pSend->pSender->LastODataSentSequenceNumber -
|
||
pSend->pSender->TrailingGroupSequenceNumber + 1));
|
||
ASSERT (PreRDataWait <= RDATA_LINGER_TIME_MSECS / BASIC_TIMER_GRANULARITY_IN_MSECS);
|
||
pRDataNew->EarliestRDataSendTime = pSend->pSender->TimerTickCount + PreRDataWait;
|
||
pRDataNew->PostRDataHoldTime = pSend->pSender->RDataLingerTime - PreRDataWait;
|
||
}
|
||
else
|
||
{
|
||
pRDataNew->EarliestRDataSendTime = 0;
|
||
pRDataNew->PostRDataHoldTime = pSend->pSender->RDataLingerTime;
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "FilterAndAddNaksToList",
|
||
"Inserted Sequence # [%d] to RData list!\n",
|
||
(ULONG) pNaksList->pNakSequences[i]);
|
||
|
||
pEntry = &pRDataNew->Linkage;
|
||
}
|
||
//
|
||
// (pRDataContext->RDataSequenceNumber == pNaksList->pNakSequences[i])
|
||
//
|
||
else if (pRDataContext->NakType != pNaksList->NakType) // RData is Parity and Nak is Selective, so check next entry
|
||
{
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
if (pNaksList->NumNaks[i] > pRDataContext->NumNaks)
|
||
{
|
||
pSend->pSender->NumOutstandingNaks += (pNaksList->NumNaks[i] - pRDataContext->NumNaks);
|
||
pRDataContext->NumNaks = pNaksList->NumNaks[i];
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "FilterAndAddNaksToList",
|
||
"Ignoring Sequence # [%d] since we just already have pending RData!\n",
|
||
(ULONG) pNaksList->pNakSequences[i]);
|
||
}
|
||
|
||
i++;
|
||
}
|
||
|
||
//
|
||
// Now, add any remaining Nak entries at the end of the Pending list
|
||
//
|
||
for ( ; i < pNaksList->NumSequences; i++)
|
||
{
|
||
//
|
||
// Add this sequence number to the end of the list
|
||
//
|
||
if (!(pRDataNew = PgmAllocMem (RDataContextSize, PGM_TAG('2'))))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "FilterAndAddNaksToList",
|
||
"[2] STATUS_INSUFFICIENT_RESOURCES\n");
|
||
return (STATUS_DATA_NOT_ACCEPTED);
|
||
}
|
||
PgmZeroMemory (pRDataNew, RDataContextSize);
|
||
|
||
pRDataNew->pSend = pSend;
|
||
pRDataNew->RDataSequenceNumber = pNaksList->pNakSequences[i];
|
||
pRDataNew->NakType = pNaksList->NakType;
|
||
pRDataNew->NumNaks = pNaksList->NumNaks[i];
|
||
pRDataNew->RequestTime = pSend->pSender->CurrentTimeoutCount;
|
||
|
||
InsertTailList (&pSend->pSender->PendingRDataRequests, &pRDataNew->Linkage);
|
||
|
||
pSend->pSender->NumOutstandingNaks += pNaksList->NumNaks[i];
|
||
pSend->pSender->NumRDataRequestsPending++;
|
||
if (SEQ_GT (pSend->pSender->LastODataSentSequenceNumber, pSend->pSender->TrailingGroupSequenceNumber))
|
||
{
|
||
PreRDataWait = (((SEQ_TYPE) (pRDataNew->RDataSequenceNumber -
|
||
pSend->pSender->TrailingGroupSequenceNumber)) *
|
||
pSend->pSender->RDataLingerTime) /
|
||
((SEQ_TYPE) (pSend->pSender->LastODataSentSequenceNumber -
|
||
pSend->pSender->TrailingGroupSequenceNumber + 1));
|
||
pRDataNew->EarliestRDataSendTime = pSend->pSender->TimerTickCount + PreRDataWait;
|
||
pRDataNew->PostRDataHoldTime = pSend->pSender->RDataLingerTime - PreRDataWait;
|
||
}
|
||
else
|
||
{
|
||
pRDataNew->EarliestRDataSendTime = 0;
|
||
pRDataNew->PostRDataHoldTime = pSend->pSender->RDataLingerTime;
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "FilterAndAddNaksToList",
|
||
"Appended Sequence # [%d] to RData list!\n",
|
||
(ULONG) pNaksList->pNakSequences[i]);
|
||
}
|
||
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
SenderProcessNakPacket(
|
||
IN tADDRESS_CONTEXT *pAddress,
|
||
IN tSEND_SESSION *pSend,
|
||
IN ULONG PacketLength,
|
||
IN tBASIC_NAK_NCF_PACKET_HEADER UNALIGNED *pNakPacket
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine processes an incoming Nak packet sent to the sender
|
||
|
||
Arguments:
|
||
|
||
IN pAddress -- Pgm's address object
|
||
IN pSend -- Pgm session (sender) context
|
||
IN PacketLength -- Nak packet length
|
||
IN pNakPacket -- Nak packet data
|
||
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the call
|
||
|
||
--*/
|
||
{
|
||
PGMLockHandle OldIrq;
|
||
tNAKS_LIST NaksList;
|
||
tSEND_RDATA_CONTEXT *pRDataContext;
|
||
tSEND_RDATA_CONTEXT *pRDataNew;
|
||
SEQ_TYPE LastSequenceNumber;
|
||
NTSTATUS status;
|
||
|
||
if (PacketLength < sizeof(tBASIC_NAK_NCF_PACKET_HEADER))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "SenderProcessNakPacket",
|
||
"Invalid Packet length=<%d>, Min=<%d> ...\n",
|
||
PacketLength, sizeof(tBASIC_NAK_NCF_PACKET_HEADER));
|
||
return (STATUS_DATA_NOT_ACCEPTED);
|
||
}
|
||
|
||
ASSERT (!pNakPacket->CommonHeader.TSDULength);
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
|
||
status = ExtractNakNcfSequences (pNakPacket,
|
||
(PacketLength - sizeof(tBASIC_NAK_NCF_PACKET_HEADER)),
|
||
&NaksList,
|
||
pSend->FECGroupSize);
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmUnlock (pSend, OldIrq);
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "SenderProcessNakPacket",
|
||
"ExtractNakNcfSequences returned <%x>\n", status);
|
||
|
||
return (status);
|
||
}
|
||
|
||
pSend->pSender->NaksReceived += NaksList.NumSequences;
|
||
|
||
//
|
||
// The oldest as well as latest sequence numbers have to be in our window
|
||
//
|
||
if (SEQ_LT (NaksList.pNakSequences[0], pSend->pSender->TrailingGroupSequenceNumber) ||
|
||
SEQ_GT (NaksList.pNakSequences[NaksList.NumSequences-1], pSend->pSender->LastODataSentSequenceNumber))
|
||
{
|
||
pSend->pSender->NaksReceivedTooLate++;
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "SenderProcessNakPacket",
|
||
"Invalid %s Naks = [%d-%d] not in window [%d -- [%d]\n",
|
||
(NaksList.NakType == NAK_TYPE_PARITY ? "Parity" : "Selective"),
|
||
(ULONG) NaksList.pNakSequences[0], (ULONG) NaksList.pNakSequences[NaksList.NumSequences-1],
|
||
(ULONG) pSend->pSender->TrailingGroupSequenceNumber, (ULONG) pSend->pSender->LastODataSentSequenceNumber);
|
||
|
||
return (STATUS_DATA_NOT_ACCEPTED);
|
||
}
|
||
|
||
//
|
||
// Check if this is a parity Nak and we are anabled for Parity Naks
|
||
//
|
||
if ((pNakPacket->CommonHeader.Options & PACKET_HEADER_OPTIONS_PARITY) &&
|
||
!(pSend->FECOptions & PACKET_OPTION_SPECIFIC_FEC_OND_BIT))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "SenderProcessNakPacket",
|
||
"Receiver requested Parity Naks, but we are not enabled for parity!\n");
|
||
|
||
PgmUnlock (pSend, OldIrq);
|
||
return (STATUS_DATA_NOT_ACCEPTED);
|
||
}
|
||
|
||
status = FilterAndAddNaksToList (pSend, &NaksList);
|
||
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "SenderProcessNakPacket",
|
||
"FilterAndAddNaksToList returned <%x>\n", status);
|
||
|
||
return (status);
|
||
}
|
||
|
||
//
|
||
// If applicable, send the Ncf for this Nak
|
||
//
|
||
if (NaksList.NumSequences)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "SenderProcessNakPacket",
|
||
"Now sending Ncf for Nak received for <%d> Sequences, NakType=<%x>\n",
|
||
NaksList.NumSequences, NaksList.NakType);
|
||
|
||
status = PgmSendNcf (pSend, pNakPacket, &NaksList, PacketLength);
|
||
}
|
||
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmSetFin(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tCLIENT_SEND_REQUEST *pSendContext,
|
||
IN PGMLockHandle *pOldIrq
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to set the Fin option on the last data packet
|
||
if the packets have been packetized, but not yet sent out
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pOldIrq -- pSend's OldIrq
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the set FIN operation
|
||
|
||
--*/
|
||
{
|
||
KAPC_STATE ApcState;
|
||
BOOLEAN fAttached;
|
||
NTSTATUS status;
|
||
tPACKET_BUFFER *pPacketBuffer;
|
||
ULONG OptionsFlags;
|
||
ULONGLONG LastPacketOffset;
|
||
tBASIC_DATA_PACKET_HEADER *pLastDataPacket;
|
||
tBASIC_DATA_PACKET_HEADER *pFinPacket = NULL;
|
||
SEQ_TYPE LastODataSequenceNumber = pSend->pSender->NextODataSequenceNumber - 1;
|
||
USHORT OriginalHeaderLength, HeaderLength = (USHORT) pSend->pSender->PacketBufferSize;
|
||
|
||
//
|
||
// This will be called only if we have finished packetizing
|
||
// all the packets, but have not yet sent the last one out!
|
||
// We need to set the FIN on the last packet
|
||
//
|
||
ASSERT (!pSendContext->BytesLeftToPacketize);
|
||
ASSERT (pSendContext->pIrp);
|
||
|
||
//
|
||
// First set the FIN flag so that the Spm can get sent
|
||
//
|
||
pSendContext->DataOptions |= PGM_OPTION_FLAG_FIN;
|
||
|
||
//
|
||
// Allocate memory for saving the last packet's data
|
||
//
|
||
if (!(pFinPacket = PgmAllocMem (pSend->pSender->PacketBufferSize, PGM_TAG('2'))))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSetFin",
|
||
"STATUS_INSUFFICIENT_RESOURCES\n");
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
|
||
//
|
||
// First, determine where the last packet packetized is located
|
||
//
|
||
if (pSend->pSender->LeadingWindowOffset < pSend->pSender->PacketBufferSize)
|
||
{
|
||
ASSERT (pSend->pSender->LeadingWindowOffset == 0); // This is the only valid value!
|
||
LastPacketOffset = pSend->pSender->MaxDataFileSize - pSend->pSender->PacketBufferSize;
|
||
}
|
||
else
|
||
{
|
||
ASSERT (pSend->pSender->LeadingWindowOffset < pSend->pSender->MaxDataFileSize);
|
||
LastPacketOffset = pSend->pSender->LeadingWindowOffset - pSend->pSender->PacketBufferSize;
|
||
}
|
||
|
||
pPacketBuffer = (tPACKET_BUFFER *) (((PUCHAR) pSend->pSender->SendDataBufferMapping) + LastPacketOffset);
|
||
pLastDataPacket = &pPacketBuffer->DataPacket;
|
||
|
||
//
|
||
// First get all the options that were set in the last packet
|
||
//
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmAttachToProcessForVMAccess (pSend->Process, &ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
|
||
OptionsFlags = pPacketBuffer->PacketOptions.OptionsFlags | PGM_OPTION_FLAG_FIN;
|
||
OriginalHeaderLength = sizeof(tBASIC_DATA_PACKET_HEADER) + pPacketBuffer->PacketOptions.OptionsLength;
|
||
|
||
PgmZeroMemory (pFinPacket, pSend->pSender->PacketBufferSize);
|
||
status = InitDataSpmHeader (pSend,
|
||
pSendContext,
|
||
(PUCHAR) pFinPacket,
|
||
&HeaderLength,
|
||
OptionsFlags,
|
||
&pPacketBuffer->PacketOptions,
|
||
PACKET_TYPE_ODATA);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSetFin",
|
||
"[1] InitDataSpmHeader returned <%x>\n", status);
|
||
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
PgmFreeMem (pFinPacket);
|
||
return (status);
|
||
}
|
||
|
||
pFinPacket->DataSequenceNumber = htonl ((ULONG) LastODataSequenceNumber);
|
||
pFinPacket->CommonHeader.TSDULength = htons (pPacketBuffer->PacketOptions.TotalPacketLength -
|
||
OriginalHeaderLength);
|
||
|
||
ASSERT (pFinPacket->DataSequenceNumber == pLastDataPacket->DataSequenceNumber);
|
||
|
||
//
|
||
// Copy the data
|
||
//
|
||
PgmCopyMemory (&((PUCHAR) pFinPacket) [HeaderLength],
|
||
&((PUCHAR) pLastDataPacket) [OriginalHeaderLength],
|
||
(pSend->pSender->MaxPayloadSize));
|
||
|
||
//
|
||
// Now, copy the reconstructed packet back into the buffer
|
||
//
|
||
if (pSend->FECOptions)
|
||
{
|
||
PgmCopyMemory (&((PUCHAR)pFinPacket) [HeaderLength + pSend->pSender->MaxPayloadSize],
|
||
&((PUCHAR)pLastDataPacket) [OriginalHeaderLength + pSend->pSender->MaxPayloadSize],
|
||
sizeof(tPOST_PACKET_FEC_CONTEXT));
|
||
|
||
PgmCopyMemory (pLastDataPacket, pFinPacket,
|
||
(HeaderLength+pSend->pSender->MaxPayloadSize+sizeof(tPOST_PACKET_FEC_CONTEXT)));
|
||
}
|
||
else
|
||
{
|
||
PgmCopyMemory (pLastDataPacket, pFinPacket, (HeaderLength+pSend->pSender->MaxPayloadSize));
|
||
}
|
||
|
||
|
||
pPacketBuffer->PacketOptions.TotalPacketLength = HeaderLength +
|
||
ntohs (pFinPacket->CommonHeader.TSDULength);
|
||
pPacketBuffer->PacketOptions.OptionsFlags = OptionsFlags;
|
||
pPacketBuffer->PacketOptions.OptionsLength = HeaderLength - sizeof(tBASIC_DATA_PACKET_HEADER);
|
||
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
PgmFreeMem (pFinPacket);
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSetFin",
|
||
"Set Fin option on last packet\n");
|
||
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PacketizeMessage(
|
||
IN tSEND_SESSION *pSend,
|
||
IN PGMLockHandle *pOldIrq,
|
||
IN tCLIENT_SEND_REQUEST *pSendContext,
|
||
IN OUT ULONG *pBytesToPacketize,
|
||
IN OUT ULONGLONG *pLeadingWindowOffset,
|
||
IN ULONGLONG *pTrailingWindowOffset,
|
||
IN OUT ULONGLONG *pBufferSize,
|
||
IN OUT SEQ_TYPE *pNextODataSequenceNumber,
|
||
IN OUT ULONG *pBytesPacketized,
|
||
IN OUT ULONG *pNextDataOffsetInMdl,
|
||
IN OUT ULONG *pDataPacketsPacketized,
|
||
IN OUT ULONG *pDataBytesInLastPacket,
|
||
OUT PVOID *ppLastVariableTGPacket
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine pactizes the data to be sent into packets
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pOldIrq -- pSend's OldIrq
|
||
IN pSendContext -- Pgm's SendContext for this send request from client
|
||
IN OUT pBytesToPacketize -- Client data bytes left to packetize before and after
|
||
IN OUT pLeadingWindowOffset
|
||
IN OUT pBufferSizeAvailable -- IN ==> Buffer available, OUT ==> Buffer consumed
|
||
IN OUT pBytesPacketized
|
||
IN OUT pDataPacketsPacketized
|
||
IN OUT pDataBytesInLastPacket
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the request
|
||
|
||
--*/
|
||
{
|
||
tBASIC_DATA_PACKET_HEADER *pODataBuffer;
|
||
ULONG ulBytes, DataOptions;
|
||
USHORT usBytes, HeaderLength, PacketsLeftInGroup;
|
||
KAPC_STATE ApcState;
|
||
BOOLEAN fAttached;
|
||
tPACKET_OPTIONS *pPacketOptions;
|
||
tPACKET_BUFFER *pPacketBuffer;
|
||
tPACKET_BUFFER *pGroupLeaderPacketBuffer;
|
||
tPOST_PACKET_FEC_CONTEXT UNALIGNED *pBufferFECContext;
|
||
tPOST_PACKET_FEC_CONTEXT FECContext;
|
||
ULONGLONG Buffer1Packets, Buffer2Packets;
|
||
ULONGLONG ActualBuffer1Packets, ActualBuffer2Packets;
|
||
SEQ_TYPE FECGroupMask = pSend->FECGroupSize-1;
|
||
ULONG NumPacketsRemaining;
|
||
tSEND_CONTEXT *pSender = pSend->pSender;
|
||
NTSTATUS status = STATUS_SUCCESS;
|
||
PMDL pMdlChain = pSendContext->pIrp->MdlAddress;
|
||
ULONG BytesToPacketize = *pBytesToPacketize;
|
||
ULONGLONG LeadingWindowOffset = *pLeadingWindowOffset;
|
||
ULONGLONG TrailingWindowOffset = *pTrailingWindowOffset;
|
||
ULONGLONG BufferSizeAvailable = *pBufferSize;
|
||
SEQ_TYPE NextODataSequenceNumber = *pNextODataSequenceNumber;
|
||
ULONG BytesPacketized = *pBytesPacketized;
|
||
ULONG NextDataOffsetInMdl = *pNextDataOffsetInMdl;
|
||
ULONG DataPacketsPacketized = *pDataPacketsPacketized;
|
||
ULONG DataBytesInLastPacket = *pDataBytesInLastPacket;
|
||
|
||
//
|
||
// First do some sanity checks!
|
||
//
|
||
ASSERT (LeadingWindowOffset < pSender->MaxDataFileSize);
|
||
ASSERT (BufferSizeAvailable <= pSender->MaxDataFileSize);
|
||
ASSERT (pSend->FECGroupSize);
|
||
|
||
//
|
||
// Next, determine how many Packets we can packetize at this time
|
||
// For FEC, we will need to make sure we don't packetize beyond
|
||
// the first group of the trailing edge!
|
||
// We will do 2 sets of calculations -- ActualBuffer[n]Packets represents
|
||
// the actual number of available packets, while Buffer[n]Packets
|
||
// represents the packets available for packetization
|
||
//
|
||
if (!BufferSizeAvailable)
|
||
{
|
||
//
|
||
// Our buffer is full!
|
||
//
|
||
Buffer1Packets = Buffer2Packets = 0;
|
||
ActualBuffer1Packets = ActualBuffer2Packets = 0;
|
||
ASSERT (LeadingWindowOffset == TrailingWindowOffset);
|
||
}
|
||
else if (LeadingWindowOffset < TrailingWindowOffset)
|
||
{
|
||
#if DBG
|
||
// ActualBuffer1Packets = (TrailingWindowOffset - LeadingWindowOffset) / pSender->PacketBufferSize;
|
||
ActualBuffer1Packets = TrailingWindowOffset / pSender->PacketBufferSize;
|
||
ActualBuffer2Packets = LeadingWindowOffset / pSender->PacketBufferSize;
|
||
Buffer1Packets = ActualBuffer1Packets & ~((ULONGLONG) FECGroupMask);
|
||
|
||
ActualBuffer1Packets -= ActualBuffer2Packets;
|
||
Buffer1Packets -= ActualBuffer2Packets;
|
||
|
||
#else
|
||
Buffer1Packets = (TrailingWindowOffset / pSender->PacketBufferSize) & ~((ULONGLONG)FECGroupMask);
|
||
Buffer1Packets -= LeadingWindowOffset / pSender->PacketBufferSize;
|
||
#endif // DBG
|
||
ActualBuffer2Packets = Buffer2Packets = 0;
|
||
}
|
||
else
|
||
{
|
||
ActualBuffer1Packets = Buffer1Packets = (pSender->MaxDataFileSize - LeadingWindowOffset) /
|
||
pSender->PacketBufferSize;
|
||
#if DBG
|
||
ActualBuffer2Packets = TrailingWindowOffset / pSender->PacketBufferSize;
|
||
Buffer2Packets = ActualBuffer2Packets & ~((ULONGLONG)FECGroupMask);
|
||
#else
|
||
Buffer2Packets = (TrailingWindowOffset / pSender->PacketBufferSize) & ~((ULONGLONG)FECGroupMask);
|
||
#endif // DBG
|
||
}
|
||
ASSERT (Buffer1Packets || !Buffer2Packets);
|
||
ASSERT (((ActualBuffer1Packets + ActualBuffer2Packets) *
|
||
pSender->PacketBufferSize) == BufferSizeAvailable);
|
||
ASSERT (Buffer1Packets <= ActualBuffer1Packets);
|
||
ASSERT (Buffer2Packets <= ActualBuffer2Packets);
|
||
|
||
// Initialize
|
||
NumPacketsRemaining = pSender->NumPacketsRemaining;
|
||
PacketsLeftInGroup = pSend->FECGroupSize - (UCHAR) (NextODataSequenceNumber & FECGroupMask);
|
||
if (pSend->FECOptions)
|
||
{
|
||
PgmZeroMemory (&FECContext, sizeof (tPOST_PACKET_FEC_CONTEXT));
|
||
}
|
||
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmAttachToProcessForVMAccess (pSend->Process, &ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
|
||
while (Buffer1Packets || Buffer2Packets)
|
||
{
|
||
//
|
||
// For FEC, we must start the next send from the next group boundary.
|
||
// Thus, we need to pad any intermediate sequence# packets
|
||
//
|
||
if (!BytesToPacketize)
|
||
{
|
||
if ((NumPacketsRemaining >= 1) || // More packets, so not a partial group
|
||
(PacketsLeftInGroup == pSend->FECGroupSize)) // New group boundary (always TRUE for non-FEC packets!)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Get the next packet ptr and Packet size
|
||
//
|
||
pPacketBuffer = (tPACKET_BUFFER *) (pSender->SendDataBufferMapping + LeadingWindowOffset);
|
||
pODataBuffer = &pPacketBuffer->DataPacket;
|
||
pPacketOptions = &pPacketBuffer->PacketOptions;
|
||
PgmZeroMemory (pPacketBuffer, pSender->PacketBufferSize); // Zero the entire buffer
|
||
|
||
//
|
||
// Prepare info for any applicable options
|
||
//
|
||
pPacketOptions->OptionsFlags = pSendContext->DataOptions;
|
||
ulBytes = pSendContext->DataOptionsLength; // Save for assert below
|
||
|
||
if ((BytesToPacketize) &&
|
||
(pPacketOptions->OptionsFlags & PGM_OPTION_FLAG_FRAGMENT))
|
||
{
|
||
pPacketOptions->MessageFirstSequence = (ULONG) (SEQ_TYPE) pSendContext->MessageFirstSequenceNumber;
|
||
pPacketOptions->MessageOffset = pSendContext->LastMessageOffset + BytesPacketized;
|
||
pPacketOptions->MessageLength = pSendContext->ThisMessageLength;
|
||
}
|
||
else
|
||
{
|
||
if (pPacketOptions->OptionsFlags & PGM_OPTION_FLAG_FRAGMENT)
|
||
{
|
||
ASSERT (!BytesToPacketize);
|
||
pPacketOptions->OptionsFlags &= ~PGM_OPTION_FLAG_FRAGMENT;
|
||
if (pPacketOptions->OptionsFlags)
|
||
{
|
||
ulBytes -= PGM_PACKET_OPT_FRAGMENT_LENGTH;
|
||
}
|
||
else
|
||
{
|
||
ulBytes = 0;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pPacketOptions->OptionsFlags & PGM_OPTION_FLAG_JOIN)
|
||
{
|
||
//
|
||
// See if we have enough packets for the LateJoiner sequence numbers
|
||
//
|
||
if (SEQ_GT (NextODataSequenceNumber, (pSender->TrailingGroupSequenceNumber +
|
||
pSender->LateJoinSequenceNumbers)))
|
||
{
|
||
pPacketOptions->LateJoinerSequence = (ULONG) (SEQ_TYPE) (NextODataSequenceNumber -
|
||
pSender->LateJoinSequenceNumbers);
|
||
}
|
||
else
|
||
{
|
||
pPacketOptions->LateJoinerSequence = (ULONG) (SEQ_TYPE) pSender->TrailingGroupSequenceNumber;
|
||
}
|
||
}
|
||
|
||
if (pSend->FECBlockSize) // Check if this is FEC-enabled
|
||
{
|
||
//
|
||
// Save information if we are at beginning of group boundary
|
||
//
|
||
if (PacketsLeftInGroup == pSend->FECGroupSize)
|
||
{
|
||
pPacketOptions->FECContext.SenderNextFECPacketIndex = pSend->FECGroupSize;
|
||
}
|
||
|
||
//
|
||
// Check if we need to set the variable TG size option
|
||
//
|
||
if ((NumPacketsRemaining == 1) && // Last packet
|
||
(BytesToPacketize) && // non-Zero length
|
||
(PacketsLeftInGroup > 1)) // Variable TG size
|
||
{
|
||
//
|
||
// This is a variable Transmission Group Size, i.e. PacketsInGroup < pSend->FECGroupSize
|
||
//
|
||
ASSERT ((Buffer1Packets + Buffer2Packets) >= PacketsLeftInGroup);
|
||
|
||
if (!pPacketOptions->OptionsFlags)
|
||
{
|
||
ulBytes = PGM_PACKET_EXTENSION_LENGTH;
|
||
}
|
||
ulBytes += PGM_PACKET_OPT_PARITY_CUR_TGSIZE_LENGTH;
|
||
pPacketOptions->OptionsFlags |= PGM_OPTION_FLAG_PARITY_CUR_TGSIZE;
|
||
|
||
pPacketOptions->FECContext.NumPacketsInThisGroup = pSend->FECGroupSize - (PacketsLeftInGroup - 1);
|
||
*ppLastVariableTGPacket = (PVOID) pODataBuffer;
|
||
}
|
||
}
|
||
|
||
HeaderLength = (USHORT) pSender->MaxPayloadSize; // Init -- max buffer size available
|
||
status = InitDataSpmHeader (pSend,
|
||
pSendContext,
|
||
(PUCHAR) pODataBuffer,
|
||
&HeaderLength,
|
||
pPacketOptions->OptionsFlags,
|
||
pPacketOptions,
|
||
PACKET_TYPE_ODATA);
|
||
|
||
if (NT_SUCCESS (status))
|
||
{
|
||
ASSERT ((sizeof(tBASIC_DATA_PACKET_HEADER) + ulBytes) == HeaderLength);
|
||
ASSERT ((pSend->FECBlockSize && (HeaderLength+pSendContext->DataPayloadSize) <=
|
||
(pSender->PacketBufferSize-sizeof(tPOST_PACKET_FEC_CONTEXT))) ||
|
||
(!pSend->FECBlockSize && ((HeaderLength+pSendContext->DataPayloadSize) <=
|
||
pSender->PacketBufferSize)));
|
||
|
||
if (BytesToPacketize > pSender->MaxPayloadSize)
|
||
{
|
||
DataBytesInLastPacket = pSender->MaxPayloadSize;
|
||
}
|
||
else
|
||
{
|
||
DataBytesInLastPacket = (USHORT) BytesToPacketize;
|
||
}
|
||
pODataBuffer->CommonHeader.TSDULength = htons ((USHORT) DataBytesInLastPacket);
|
||
pODataBuffer->DataSequenceNumber = htonl ((ULONG) NextODataSequenceNumber++);
|
||
|
||
ulBytes = 0;
|
||
status = TdiCopyMdlToBuffer (pMdlChain,
|
||
NextDataOffsetInMdl,
|
||
(((PUCHAR) pODataBuffer) + HeaderLength),
|
||
0, // Destination Offset
|
||
DataBytesInLastPacket,
|
||
&ulBytes);
|
||
|
||
if (((!NT_SUCCESS (status)) && (STATUS_BUFFER_OVERFLOW != status)) || // Overflow acceptable!
|
||
(ulBytes != DataBytesInLastPacket))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PacketizeMessage",
|
||
"TdiCopyMdlToBuffer returned <%x>, BytesCopied=<%d/%d>\n",
|
||
status, ulBytes, DataBytesInLastPacket);
|
||
|
||
status = STATUS_UNSUCCESSFUL;
|
||
}
|
||
else
|
||
{
|
||
pPacketOptions->TotalPacketLength = HeaderLength + (USHORT) DataBytesInLastPacket;
|
||
pPacketOptions->OptionsLength = HeaderLength - sizeof (tBASIC_DATA_PACKET_HEADER);
|
||
//
|
||
// Set the PacketOptions Information for FEC packets
|
||
//
|
||
if (pSend->FECOptions)
|
||
{
|
||
pBufferFECContext = (tPOST_PACKET_FEC_CONTEXT *) (((PUCHAR) pODataBuffer) +
|
||
HeaderLength +
|
||
pSender->MaxPayloadSize);
|
||
|
||
if (DataBytesInLastPacket)
|
||
{
|
||
FECContext.EncodedTSDULength = htons ((USHORT) DataBytesInLastPacket);
|
||
|
||
FECContext.EncodedFragmentOptions.MessageFirstSequence = htonl ((ULONG) (SEQ_TYPE) pPacketOptions->MessageFirstSequence);
|
||
FECContext.EncodedFragmentOptions.MessageOffset = htonl (pPacketOptions->MessageOffset);
|
||
FECContext.EncodedFragmentOptions.MessageLength = htonl (pPacketOptions->MessageLength);
|
||
PgmCopyMemory (pBufferFECContext, &FECContext, sizeof (tPOST_PACKET_FEC_CONTEXT));
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// We had already initialized this memory earlier in the loop
|
||
//
|
||
// PgmZeroMemory (pBufferFECContext, sizeof (tPOST_PACKET_FEC_CONTEXT));
|
||
}
|
||
|
||
//
|
||
// If this is not a fragment, set the PACKET_OPTION_SPECIFIC_ENCODED_NULL_BIT
|
||
//
|
||
if ((!DataBytesInLastPacket) ||
|
||
(!(pPacketOptions->OptionsFlags & PGM_OPTION_FLAG_FRAGMENT)))
|
||
{
|
||
((PUCHAR) pBufferFECContext)
|
||
[FIELD_OFFSET (tPOST_PACKET_FEC_CONTEXT, FragmentOptSpecific)] =
|
||
PACKET_OPTION_SPECIFIC_ENCODED_NULL_BIT;
|
||
}
|
||
}
|
||
|
||
status = STATUS_SUCCESS;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PacketizeMessage",
|
||
"InitDataSpmHeader returned <%x>\n", status);
|
||
}
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
break;
|
||
}
|
||
|
||
LeadingWindowOffset += pSender->PacketBufferSize;
|
||
BufferSizeAvailable -= pSender->PacketBufferSize;
|
||
BytesPacketized += DataBytesInLastPacket;
|
||
NextDataOffsetInMdl += DataBytesInLastPacket;
|
||
if (DataBytesInLastPacket)
|
||
{
|
||
DataPacketsPacketized++;
|
||
NumPacketsRemaining--;
|
||
}
|
||
|
||
//
|
||
// Update the Send buffer information
|
||
//
|
||
if (!Buffer1Packets)
|
||
{
|
||
Buffer2Packets--;
|
||
}
|
||
else if (0 == --Buffer1Packets)
|
||
{
|
||
ASSERT (((Buffer2Packets == 0) && (TrailingWindowOffset != 0)) ||
|
||
(LeadingWindowOffset == pSender->MaxDataFileSize));
|
||
|
||
if (LeadingWindowOffset == pSender->MaxDataFileSize)
|
||
{
|
||
LeadingWindowOffset = 0;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Update the Send data information
|
||
//
|
||
BytesToPacketize -= DataBytesInLastPacket;
|
||
|
||
//
|
||
// See if we are at a group boundary
|
||
//
|
||
if (!--PacketsLeftInGroup)
|
||
{
|
||
PacketsLeftInGroup = pSend->FECGroupSize;
|
||
}
|
||
}
|
||
|
||
ASSERT ((Buffer1Packets || Buffer2Packets) ||
|
||
(BufferSizeAvailable < (pSender->PacketBufferSize * pSend->FECGroupSize)));
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PacketizeMessage",
|
||
"TotalBytesPacketized=<%d/%d>, BytesToP=<%d==>%d>\n",
|
||
BytesPacketized, pSendContext->BytesInSend, *pBytesToPacketize, BytesToPacketize);
|
||
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
//
|
||
// Set the state variables
|
||
//
|
||
*pBytesToPacketize = BytesToPacketize;
|
||
*pLeadingWindowOffset = LeadingWindowOffset;
|
||
*pBufferSize = (*pBufferSize - BufferSizeAvailable);
|
||
*pNextODataSequenceNumber = NextODataSequenceNumber;
|
||
*pBytesPacketized = BytesPacketized;
|
||
*pNextDataOffsetInMdl = NextDataOffsetInMdl;
|
||
*pDataPacketsPacketized = DataPacketsPacketized;
|
||
*pDataBytesInLastPacket = DataBytesInLastPacket;
|
||
|
||
return (status);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmPacketizeSend(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tCLIENT_SEND_REQUEST *pSendContext,
|
||
IN PGMLockHandle *pOldIrq
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to prepare the next set of packets
|
||
for sending on the wire
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pOldIrq -- pSend's OldIrq
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the request
|
||
|
||
--*/
|
||
{
|
||
ULONG BytesToPacketize = 0;
|
||
ULONGLONG LeadingWindowOffset;
|
||
ULONGLONG TrailingWindowOffset;
|
||
ULONGLONG BufferSize;
|
||
SEQ_TYPE NextODataSequenceNumber;
|
||
PVOID pLastVariableTGPacket;
|
||
ULONG BytesPacketized;
|
||
ULONG NextDataOffsetInMdl;
|
||
ULONG DataPacketsPacketized;
|
||
ULONG DataBytesInLastPacket;
|
||
NTSTATUS status = STATUS_SUCCESS;
|
||
LIST_ENTRY *pEntry;
|
||
|
||
if (pSendContext->BytesLeftToPacketize == pSendContext->BytesInSend)
|
||
{
|
||
pSendContext->NextPacketOffset = pSend->pSender->LeadingWindowOffset; // First packet's offset
|
||
pSendContext->StartSequenceNumber = pSend->pSender->NextODataSequenceNumber;
|
||
pSendContext->EndSequenceNumber = pSend->pSender->NextODataSequenceNumber; // temporary
|
||
|
||
if (pSendContext->LastMessageOffset)
|
||
{
|
||
pSendContext->MessageFirstSequenceNumber = pSend->pSender->LastMessageFirstSequence;
|
||
}
|
||
else
|
||
{
|
||
pSendContext->MessageFirstSequenceNumber = pSendContext->StartSequenceNumber;
|
||
pSend->pSender->LastMessageFirstSequence = pSendContext->StartSequenceNumber;
|
||
}
|
||
}
|
||
|
||
BytesToPacketize = pSendContext->BytesLeftToPacketize;
|
||
|
||
//
|
||
// Since we have a wrap around buffer to be copied into, we also need to
|
||
// determine the # of packets that can be copied contiguously
|
||
//
|
||
ASSERT (pSend->pSender->LeadingWindowOffset < pSend->pSender->MaxDataFileSize);
|
||
ASSERT (pSend->pSender->TrailingWindowOffset < pSend->pSender->MaxDataFileSize);
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmPacketizeSend",
|
||
"TotalBytes=<%d>, BytesToPacketize=<%d>\n",
|
||
pSendContext->BytesInSend, BytesToPacketize);
|
||
|
||
LeadingWindowOffset = pSend->pSender->LeadingWindowOffset;
|
||
NextODataSequenceNumber = pSend->pSender->NextODataSequenceNumber;
|
||
BytesPacketized = pSendContext->BytesInSend - pSendContext->BytesLeftToPacketize;
|
||
NextDataOffsetInMdl = pSendContext->NextDataOffsetInMdl;
|
||
DataBytesInLastPacket = pSendContext->DataBytesInLastPacket;
|
||
|
||
//
|
||
// Since some packet headers may have different lengths (based on options),
|
||
// we cannot always compute the exact number of packets needed, so will
|
||
// attempt to packetize sequentially keeping the limits in mind
|
||
//
|
||
//
|
||
// First fill in any packets from the first Message
|
||
//
|
||
if (BytesToPacketize)
|
||
{
|
||
pLastVariableTGPacket = (PVOID) -1;
|
||
DataPacketsPacketized = 0;
|
||
BufferSize = pSend->pSender->BufferSizeAvailable;
|
||
TrailingWindowOffset = pSend->pSender->TrailingWindowOffset;
|
||
status = PacketizeMessage (pSend,
|
||
pOldIrq,
|
||
pSendContext,
|
||
&BytesToPacketize,
|
||
&LeadingWindowOffset,
|
||
&TrailingWindowOffset,
|
||
&BufferSize,
|
||
&NextODataSequenceNumber,
|
||
&BytesPacketized,
|
||
&NextDataOffsetInMdl,
|
||
&DataPacketsPacketized,
|
||
&DataBytesInLastPacket,
|
||
&pLastVariableTGPacket);
|
||
|
||
if (NT_SUCCESS (status))
|
||
{
|
||
//
|
||
// Save all the state information
|
||
//
|
||
pSend->pSender->LeadingWindowOffset = LeadingWindowOffset;
|
||
pSend->pSender->BufferSizeAvailable -= BufferSize;
|
||
pSend->pSender->NumPacketsRemaining -= DataPacketsPacketized;
|
||
|
||
pSend->pSender->NextODataSequenceNumber = NextODataSequenceNumber;
|
||
pSendContext->BytesLeftToPacketize = pSendContext->BytesInSend - BytesPacketized;
|
||
pSendContext->NextDataOffsetInMdl = NextDataOffsetInMdl;
|
||
pSendContext->DataBytesInLastPacket = DataBytesInLastPacket;
|
||
pSendContext->DataPacketsPacketized += DataPacketsPacketized;
|
||
pSendContext->NumPacketsRemaining -= DataPacketsPacketized;
|
||
|
||
if (BytesToPacketize)
|
||
{
|
||
//
|
||
// We must have run out of Buffer space to copy the entire
|
||
// message, which is not an error -- so just return gracefully
|
||
//
|
||
pSendContext->EndSequenceNumber = pSend->pSender->NextODataSequenceNumber - 1;
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmPacketizeSend",
|
||
"PacketizeMessage[1] SUCCEEDed, but BytesToPacketize=<%d>\n", BytesToPacketize);
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
pSendContext->pLastMessageVariableTGPacket = pLastVariableTGPacket;
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// The function will ensure that Buffer1Packets != 0 on error
|
||
//
|
||
ASSERT (BytesToPacketize);
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmPacketizeSend",
|
||
"PacketizeMessage[1] returned <%x>\n", status);
|
||
}
|
||
}
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmPacketizeSend",
|
||
"status=<%x>, pSend=<%p>, pSendContext=<%p>, pIrp=<%p>\n",
|
||
status, pSend, pSendContext, pSendContext->pIrp);
|
||
|
||
//
|
||
// Mark the remainder of this send as invalid!
|
||
//
|
||
pSendContext->BytesLeftToPacketize = 0;
|
||
// pSend->pSender->SpmOptions |= PGM_OPTION_FLAG_RST; // ISSUE: Do we set this here ?
|
||
|
||
//
|
||
// We failed to packetize the last send, so see if we can complete the Irp here
|
||
//
|
||
RemoveEntryList (&pSendContext->Linkage);
|
||
pSend->pSender->NumODataRequestsPending--;
|
||
pSend->pSender->NumPacketsRemaining -= pSendContext->NumPacketsRemaining;
|
||
|
||
ASSERT (pSendContext->pIrp);
|
||
if (pSendContext->NumSendsPending == 0)
|
||
{
|
||
if (pSendContext->pIrpToComplete)
|
||
{
|
||
ASSERT (pSendContext == pSendContext->pMessage2Request->pMessage2Request);
|
||
if (pSendContext->pMessage2Request)
|
||
{
|
||
ASSERT (!pSendContext->pMessage2Request->pIrpToComplete);
|
||
pSendContext->pMessage2Request->pIrpToComplete = pSendContext->pIrpToComplete;
|
||
pSendContext->pIrpToComplete = NULL;
|
||
}
|
||
|
||
pSendContext->pMessage2Request->pMessage2Request = NULL;
|
||
pSendContext->pMessage2Request = NULL;
|
||
}
|
||
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmReleaseResource (&pSend->pSender->Resource);
|
||
|
||
if (pSendContext->pIrpToComplete)
|
||
{
|
||
PgmIoComplete (pSendContext->pIrpToComplete, STATUS_UNSUCCESSFUL, 0);
|
||
}
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW);
|
||
|
||
PgmAcquireResourceExclusive (&pSend->pSender->Resource, TRUE);
|
||
PgmLock (pSend, *pOldIrq);
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext);
|
||
}
|
||
else
|
||
{
|
||
pSendContext->DataPacketsPacketized = pSendContext->NumDataPacketsSent;
|
||
InsertTailList (&pSend->pSender->CompletedSendsInWindow, &pSendContext->Linkage);
|
||
}
|
||
return (status);
|
||
}
|
||
|
||
pSendContext->EndSequenceNumber = NextODataSequenceNumber - 1;
|
||
|
||
if ((pSendContext->bLastSend) &&
|
||
(!pSendContext->BytesLeftToPacketize))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmPacketizeSend",
|
||
"Calling PgmSetFin since bLastSend set for last packet!\n");
|
||
|
||
pSendContext->bLastSend = FALSE;
|
||
//
|
||
// We have finished packetizing all the packets, but
|
||
// since this is the last send we also need to set the
|
||
// FIN on the last packet
|
||
//
|
||
PgmSetFin (pSend, pSendContext, pOldIrq);
|
||
}
|
||
|
||
ASSERT (!pSendContext->BytesLeftToPacketize);
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmPacketizeSend",
|
||
"TotalBytes=<%d>, BytesToPacketize=<%d>, SeqNums=[%d--%d]\n",
|
||
pSendContext->BytesInSend, BytesToPacketize,
|
||
(ULONG) pSendContext->StartSequenceNumber, (ULONG) pSendContext->EndSequenceNumber);
|
||
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmPrepareNextSend(
|
||
IN tSEND_SESSION *pSend,
|
||
IN PGMLockHandle *pOldIrq,
|
||
IN BOOLEAN fPacketizeAll,
|
||
IN BOOLEAN fResourceLockHeld
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to prepare the next set of packets
|
||
for sending on the wire
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pOldIrq -- pSend's OldIrq
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the request
|
||
|
||
--*/
|
||
{
|
||
LIST_ENTRY *pEntry;
|
||
tCLIENT_SEND_REQUEST *pSendContext;
|
||
NTSTATUS status;
|
||
|
||
//
|
||
// See if we need to packetize all pending sends or just ensure
|
||
// that we have at least 1 send avaialble
|
||
//
|
||
if ((!fPacketizeAll) &&
|
||
(!IsListEmpty (&pSend->pSender->PendingPacketizedSends)))
|
||
{
|
||
pSendContext = CONTAINING_RECORD (pSend->pSender->PendingPacketizedSends.Flink, tCLIENT_SEND_REQUEST, Linkage);
|
||
if (pSendContext->NumDataPacketsSent < pSendContext->DataPacketsPacketized)
|
||
{
|
||
//
|
||
// We have more packets to send!
|
||
//
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmPrepareNextSend",
|
||
"Have more packets -- returning since caller preferred not to packetize!\n");
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (!fResourceLockHeld)
|
||
{
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmAcquireResourceExclusive (&pSend->pSender->Resource, TRUE);
|
||
PgmLock (pSend, *pOldIrq);
|
||
}
|
||
|
||
pSendContext = NULL;
|
||
if (!IsListEmpty (&pSend->pSender->PendingPacketizedSends))
|
||
{
|
||
//
|
||
// See if we need to packetize the remaining bytes of the last send
|
||
//
|
||
pSendContext = CONTAINING_RECORD (pSend->pSender->PendingPacketizedSends.Blink, tCLIENT_SEND_REQUEST, Linkage);
|
||
if (!pSendContext->BytesLeftToPacketize)
|
||
{
|
||
pSendContext = NULL;
|
||
}
|
||
}
|
||
|
||
while (pSend->pSender->BufferSizeAvailable)
|
||
{
|
||
//
|
||
// If we already have a send pending, see if we need to packetize
|
||
// any more packets
|
||
//
|
||
if ((!pSendContext) &&
|
||
(!IsListEmpty (&pSend->pSender->PendingSends)))
|
||
{
|
||
pEntry = RemoveHeadList (&pSend->pSender->PendingSends);
|
||
InsertTailList (&pSend->pSender->PendingPacketizedSends, pEntry);
|
||
pSendContext = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
}
|
||
|
||
if (!pSendContext)
|
||
{
|
||
//
|
||
// We have no more packets to packetize!
|
||
//
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmPrepareNextSend",
|
||
"No more sends Pending!\n");
|
||
|
||
break;
|
||
}
|
||
|
||
status = PgmPacketizeSend (pSend, pSendContext, pOldIrq);
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmPrepareNextSend",
|
||
"PgmPacketizeSend returned <%x>\n", status);
|
||
}
|
||
else if (pSendContext->BytesLeftToPacketize)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmPrepareNextSend",
|
||
"WARNING Packetizing buffer full!\n");
|
||
|
||
ASSERT (pSend->pSender->BufferSizeAvailable <
|
||
(pSend->pSender->PacketBufferSize * pSend->FECGroupSize));
|
||
break;
|
||
}
|
||
pSendContext = NULL;
|
||
}
|
||
|
||
if (!fResourceLockHeld)
|
||
{
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmReleaseResource (&pSend->pSender->Resource);
|
||
PgmLock (pSend, *pOldIrq);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmSendODataCompletion(
|
||
IN tCLIENT_SEND_REQUEST *pSendContext,
|
||
IN tBASIC_DATA_PACKET_HEADER *pODataBuffer,
|
||
IN NTSTATUS status
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called by the transport when the OData send has been completed
|
||
|
||
Arguments:
|
||
|
||
IN pSendContext -- Pgm's Send context
|
||
IN pUnused -- not used
|
||
IN status --
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
{
|
||
ULONG SendLength;
|
||
PGMLockHandle OldIrq;
|
||
PIRP pIrpCurrentSend = NULL;
|
||
PIRP pIrpToComplete = NULL;
|
||
tSEND_SESSION *pSend = pSendContext->pSend;
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
|
||
if (NT_SUCCESS (status))
|
||
{
|
||
//
|
||
// Set the Ncf statistics
|
||
//
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendODataCompletion",
|
||
"SUCCEEDED\n");
|
||
|
||
if (!(pODataBuffer->CommonHeader.Options & PACKET_HEADER_OPTIONS_PARITY))
|
||
{
|
||
pSendContext->NumDataPacketsSentSuccessfully++;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendODataCompletion",
|
||
"status=<%x>\n", status);
|
||
}
|
||
|
||
//
|
||
// If all the OData has been sent, we may need to complete the Irp
|
||
// Since we don't know whether we are on the CurrentSend or Completed
|
||
// Sends list, we will need to also check the Bytes
|
||
//
|
||
if ((--pSendContext->NumSendsPending == 0) && // No other sends pending
|
||
(pSendContext->NumParityPacketsToSend == 0) && // No parity packets pending
|
||
(!pSendContext->BytesLeftToPacketize) && // All bytes have been packetized
|
||
(pSendContext->NumDataPacketsSent == pSendContext->DataPacketsPacketized)) // Pkts sent == total Pkts
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendODataCompletion",
|
||
"Completing Send#=<%d>, pIrp=<%p> for <%d> packets, Seq=[%d, %d]\n",
|
||
pSendContext->SendNumber, pSendContext->pIrp, pSendContext->DataPacketsPacketized,
|
||
(ULONG) pSendContext->StartSequenceNumber, (ULONG) pSendContext->EndSequenceNumber);
|
||
|
||
pSend->DataBytes += pSendContext->BytesInSend;
|
||
if (pIrpCurrentSend = pSendContext->pIrp)
|
||
{
|
||
if (pSendContext->NumDataPacketsSentSuccessfully == pSendContext->NumDataPacketsSent)
|
||
{
|
||
status = STATUS_SUCCESS;
|
||
SendLength = pSendContext->BytesInSend;
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmSendODataCompletion",
|
||
"pIrp=<%p -- %p>, pSendContext=<%p>, NumPackets sent successfully = <%d/%d>\n",
|
||
pSendContext->pIrp, pSendContext->pIrpToComplete, pSendContext,
|
||
pSendContext->NumDataPacketsSentSuccessfully, pSendContext->NumDataPacketsSent);
|
||
}
|
||
else
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendODataCompletion",
|
||
"pIrp=<%p -- %p>, pSendContext=<%p>, NumPackets sent successfully = <%d/%d>\n",
|
||
pSendContext->pIrp, pSendContext->pIrpToComplete, pSendContext,
|
||
pSendContext->NumDataPacketsSentSuccessfully, pSendContext->NumDataPacketsSent);
|
||
|
||
status = STATUS_UNSUCCESSFUL;
|
||
SendLength = 0;
|
||
}
|
||
|
||
pSendContext->pIrp = NULL;
|
||
pIrpToComplete = pSendContext->pIrpToComplete;
|
||
}
|
||
else
|
||
{
|
||
ASSERT (0); // To verify there is no double completion!
|
||
}
|
||
|
||
if (pSendContext->pMessage2Request)
|
||
{
|
||
//
|
||
// We could have a situation where the send was split into 2, and
|
||
// the second send could either be in the PendingSends list or
|
||
// the PendingPacketizedSends list, or the CompletedSendsInWindow list
|
||
//
|
||
// We should have the other send complete the Irp and delink ourselves
|
||
//
|
||
ASSERT (pSendContext == pSendContext->pMessage2Request->pMessage2Request);
|
||
|
||
if (pIrpToComplete)
|
||
{
|
||
ASSERT (!pSendContext->pMessage2Request->pIrpToComplete);
|
||
pSendContext->pMessage2Request->pIrpToComplete = pSendContext->pIrpToComplete;
|
||
pIrpToComplete = pSendContext->pIrpToComplete = NULL;
|
||
}
|
||
|
||
pSendContext->pMessage2Request->pMessage2Request = NULL;
|
||
pSendContext->pMessage2Request = NULL;
|
||
}
|
||
}
|
||
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
if (pODataBuffer)
|
||
{
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SenderBufferLookaside, pODataBuffer);
|
||
}
|
||
|
||
if (pIrpCurrentSend)
|
||
{
|
||
if (pIrpToComplete)
|
||
{
|
||
PgmIoComplete (pIrpToComplete, status, SendLength);
|
||
}
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW);
|
||
}
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmBuildDataPacket(
|
||
IN tSEND_SESSION *pSend,
|
||
IN tCLIENT_SEND_REQUEST *pSendContext,
|
||
IN tPACKET_BUFFER *pPacketBuffer,
|
||
IN PUCHAR pSendBuffer,
|
||
IN USHORT *pSendBufferLength
|
||
)
|
||
{
|
||
ULONG i;
|
||
ULONG LateJoinerSequence;
|
||
SEQ_TYPE FECGroupMask = pSend->FECGroupSize-1;
|
||
tSEND_CONTEXT *pSender = pSend->pSender;
|
||
tPACKET_OPTION_GENERIC UNALIGNED *pOptionHeader;
|
||
tBASIC_DATA_PACKET_HEADER UNALIGNED *pODataBuffer = (tBASIC_DATA_PACKET_HEADER UNALIGNED *)
|
||
&pPacketBuffer->DataPacket;
|
||
|
||
//
|
||
// Get the SendLength and fill in the remaining fields of this send (Trailing edge + checksum)
|
||
//
|
||
*pSendBufferLength = pPacketBuffer->PacketOptions.TotalPacketLength;
|
||
if (pPacketBuffer->PacketOptions.OptionsFlags & PGM_OPTION_FLAG_JOIN)
|
||
{
|
||
ASSERT (pODataBuffer->CommonHeader.Options & PACKET_HEADER_OPTIONS_PRESENT);
|
||
if (pPacketBuffer->PacketOptions.LateJoinerOptionOffset)
|
||
{
|
||
if (SEQ_GT (pSend->pSender->LastODataSentSequenceNumber, (pSend->pSender->TrailingGroupSequenceNumber +
|
||
pSend->pSender->LateJoinSequenceNumbers)))
|
||
{
|
||
LateJoinerSequence = (ULONG) (SEQ_TYPE) (pSend->pSender->LastODataSentSequenceNumber -
|
||
pSend->pSender->LateJoinSequenceNumbers);
|
||
}
|
||
else
|
||
{
|
||
LateJoinerSequence = (ULONG) (SEQ_TYPE) pSend->pSender->TrailingGroupSequenceNumber;
|
||
}
|
||
pPacketBuffer->PacketOptions.LateJoinerSequence = LateJoinerSequence;
|
||
|
||
pOptionHeader = (tPACKET_OPTION_GENERIC UNALIGNED *) &((PUCHAR) (pODataBuffer + 1)) [pPacketBuffer->PacketOptions.LateJoinerOptionOffset];
|
||
|
||
LateJoinerSequence = htonl (LateJoinerSequence);
|
||
PgmCopyMemory ((pOptionHeader + 1), &LateJoinerSequence, (sizeof(ULONG)));
|
||
}
|
||
else
|
||
{
|
||
ASSERT (0);
|
||
}
|
||
}
|
||
|
||
PgmCopyMemory (pSendBuffer, pODataBuffer, *pSendBufferLength);
|
||
|
||
//
|
||
// Now, see if we need to build the parity context for the first
|
||
// pro-active parity packet following this one
|
||
//
|
||
if ((pSend->FECProActivePackets) && // Need to send FEC pro-active packets
|
||
(pSendContext->NumParityPacketsToSend == pSend->FECProActivePackets))
|
||
{
|
||
//
|
||
// Start from the Group leader packet
|
||
//
|
||
ASSERT (pSender->pLastProActiveGroupLeader);
|
||
pPacketBuffer = pSender->pLastProActiveGroupLeader;
|
||
pSendBuffer = (PUCHAR) pPacketBuffer;
|
||
|
||
pSender->pProActiveParityContext->OptionsFlags = 0;
|
||
pSender->pProActiveParityContext->NumPacketsInThisGroup = 0;
|
||
|
||
for (i=0; i<pSend->FECGroupSize; i++)
|
||
{
|
||
pSender->pProActiveParityContext->pDataBuffers[i] = &((PUCHAR) &pPacketBuffer->DataPacket)[sizeof (tBASIC_DATA_PACKET_HEADER) +
|
||
pPacketBuffer->PacketOptions.OptionsLength];
|
||
pSender->pProActiveParityContext->OptionsFlags |= pPacketBuffer->PacketOptions.OptionsFlags &
|
||
(PGM_OPTION_FLAG_SYN |
|
||
PGM_OPTION_FLAG_FIN |
|
||
PGM_OPTION_FLAG_FRAGMENT |
|
||
PGM_OPTION_FLAG_PARITY_CUR_TGSIZE);
|
||
|
||
if (pPacketBuffer->PacketOptions.OptionsFlags & PGM_OPTION_FLAG_PARITY_CUR_TGSIZE)
|
||
{
|
||
ASSERT (!pSender->pProActiveParityContext->NumPacketsInThisGroup);
|
||
ASSERT (pPacketBuffer->PacketOptions.FECContext.NumPacketsInThisGroup);
|
||
pSender->pProActiveParityContext->NumPacketsInThisGroup = pPacketBuffer->PacketOptions.FECContext.NumPacketsInThisGroup;
|
||
}
|
||
|
||
pSendBuffer += pSender->PacketBufferSize;
|
||
pPacketBuffer = (tPACKET_BUFFER *) pSendBuffer;
|
||
}
|
||
|
||
if (!(pSender->pProActiveParityContext->OptionsFlags & PGM_OPTION_FLAG_PARITY_CUR_TGSIZE))
|
||
{
|
||
ASSERT (!pSender->pProActiveParityContext->NumPacketsInThisGroup);
|
||
pSender->pProActiveParityContext->NumPacketsInThisGroup = pSend->FECGroupSize;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmSendNextOData(
|
||
IN tSEND_SESSION *pSend,
|
||
IN PGMLockHandle *pOldIrq,
|
||
OUT ULONG *pBytesSent
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to send a Data (OData) packet
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN pOldIrq -- pSend's OldIrq
|
||
OUT pBytesSent -- Set if send succeeded (used for calculating throughput)
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the send request
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status = STATUS_SUCCESS;
|
||
ULONG i, XSum;
|
||
USHORT SendBufferLength;
|
||
KAPC_STATE ApcState;
|
||
BOOLEAN fAttached;
|
||
BOOLEAN fSendingFECPacket = FALSE;
|
||
BOOLEAN fResetOptions = FALSE;
|
||
tBASIC_DATA_PACKET_HEADER *pODataBuffer = NULL;
|
||
PUCHAR pSendBuffer = NULL;
|
||
tCLIENT_SEND_REQUEST *pSendContext;
|
||
tPACKET_OPTIONS PacketOptions;
|
||
tPACKET_BUFFER *pPacketBuffer;
|
||
ULONG OptionValue;
|
||
SEQ_TYPE FECGroupMask = pSend->FECGroupSize-1;
|
||
UCHAR EmptyPackets = 0;
|
||
tSEND_CONTEXT *pSender = pSend->pSender;
|
||
|
||
*pBytesSent = 0; // Initialize
|
||
pODataBuffer = NULL;
|
||
|
||
if (IsListEmpty (&pSender->PendingPacketizedSends))
|
||
{
|
||
ASSERT (!IsListEmpty (&pSender->PendingSends));
|
||
|
||
PgmPrepareNextSend (pSend, pOldIrq, FALSE, FALSE);
|
||
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
pSendContext = CONTAINING_RECORD (pSender->PendingPacketizedSends.Flink, tCLIENT_SEND_REQUEST, Linkage);
|
||
|
||
//
|
||
// This routine is called only if we have a packet to send, so
|
||
// set pODataBuffer to the packet to be sent
|
||
// NumDataPacketsSent and DataPacketsPacketized should both be 0 for a fresh send
|
||
// They will be equal if we had run out of Buffer space for the last
|
||
// packetization (i.e. Send length > available buffer space)
|
||
//
|
||
|
||
SendBufferLength = PGM_MAX_FEC_DATA_HEADER_LENGTH + (USHORT) pSender->MaxPayloadSize;
|
||
if (!(pSendBuffer = ExAllocateFromNPagedLookasideList (&pSender->SenderBufferLookaside)))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendNextOData",
|
||
"STATUS_INSUFFICIENT_RESOURCES\n");
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
|
||
//
|
||
// See if we need to set the FIN flag
|
||
//
|
||
if ((pSendContext->bLastSend) &&
|
||
(!pSendContext->BytesLeftToPacketize))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmSendNextOData",
|
||
"Calling PgmSetFin since bLastSend set for last packet!\n");
|
||
|
||
pSendContext->bLastSend = FALSE;
|
||
//
|
||
// We have finished packetizing all the packets, but
|
||
// since this is the last send we also need to set the
|
||
// FIN on the last packet
|
||
//
|
||
PgmSetFin (pSend, pSendContext, pOldIrq);
|
||
}
|
||
|
||
if (pSendContext->NumParityPacketsToSend)
|
||
{
|
||
//
|
||
// Release the Send lock and attach to the SectionMap process
|
||
// to compute the parity packet
|
||
//
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmAttachToProcessForVMAccess (pSend->Process, &ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
|
||
status = PgmBuildParityPacket (pSend,
|
||
pSend->pSender->pLastProActiveGroupLeader,
|
||
pSender->pProActiveParityContext,
|
||
(PUCHAR) pSendBuffer,
|
||
&SendBufferLength,
|
||
PACKET_TYPE_ODATA);
|
||
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSendNextOData",
|
||
"PgmBuildParityPacket returned <%x>\n", status);
|
||
|
||
ExFreeToNPagedLookasideList (&pSender->SenderBufferLookaside, pSendBuffer);
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
pODataBuffer = (tBASIC_DATA_PACKET_HEADER *) pSendBuffer;
|
||
ASSERT (SendBufferLength <= (PGM_MAX_FEC_DATA_HEADER_LENGTH +
|
||
htons (pODataBuffer->CommonHeader.TSDULength)));
|
||
fSendingFECPacket = TRUE;
|
||
|
||
pSendContext->NumParityPacketsToSend--;
|
||
pSendContext->NumSendsPending++;
|
||
}
|
||
else if (pSendContext->NumDataPacketsSent < pSendContext->DataPacketsPacketized)
|
||
{
|
||
//
|
||
// Verify that this send has already been packetized
|
||
//
|
||
ASSERT (pSendContext->BytesLeftToPacketize < pSendContext->BytesInSend);
|
||
|
||
//
|
||
// Get the current send packet and send length
|
||
//
|
||
pPacketBuffer = (tPACKET_BUFFER *) (pSender->SendDataBufferMapping + pSendContext->NextPacketOffset);
|
||
pODataBuffer = &pPacketBuffer->DataPacket;
|
||
pSendContext->NumSendsPending++;
|
||
if (0 == pSendContext->NumDataPacketsSent++)
|
||
{
|
||
pSendContext->SendStartTime = pSend->pSender->TimerTickCount;
|
||
}
|
||
|
||
//
|
||
// Update the sender parameters
|
||
//
|
||
pSender->LastODataSentSequenceNumber++;
|
||
|
||
if (pSend->FECOptions) // Need to send FEC pro-active packets
|
||
{
|
||
//
|
||
// See if we are at the end of a variable TG send
|
||
//
|
||
if (pODataBuffer == pSendContext->pLastMessageVariableTGPacket)
|
||
{
|
||
pSender->LastVariableTGPacketSequenceNumber = pSender->LastODataSentSequenceNumber;
|
||
EmptyPackets = (UCHAR) (FECGroupMask - (pSender->LastODataSentSequenceNumber & FECGroupMask));
|
||
pSendContext->NumParityPacketsToSend = pSend->FECProActivePackets;
|
||
}
|
||
//
|
||
// Otherwise see if the next send needs to be for pro-active parity
|
||
//
|
||
else if ((pSend->FECProActivePackets) && // Need to send FEC pro-active packets
|
||
(FECGroupMask == (pSender->LastODataSentSequenceNumber & FECGroupMask))) // Last Packet In Group
|
||
{
|
||
pSendContext->NumParityPacketsToSend = pSend->FECProActivePackets;
|
||
}
|
||
|
||
//
|
||
// If this is the GroupLeader packet, and we have pro-active parity enabled,
|
||
// then we need to set the buffer information for computing the FEC packets
|
||
//
|
||
if ((pSend->FECProActivePackets) && // Need to send FEC pro-active packets
|
||
(0 == (pSender->LastODataSentSequenceNumber & FECGroupMask))) // GroupLeader
|
||
{
|
||
pSender->pLastProActiveGroupLeader = pPacketBuffer;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Since we will be accessing the buffer, we will need to release the
|
||
// lock to get at passive Irql + attach to the process
|
||
//
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
PgmAttachToProcessForVMAccess (pSend->Process, &ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
|
||
PgmBuildDataPacket (pSend, pSendContext, pPacketBuffer, pSendBuffer, &SendBufferLength);
|
||
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_PACKETIZE);
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
pODataBuffer = (tBASIC_DATA_PACKET_HEADER *) pSendBuffer;
|
||
|
||
//
|
||
// Verify that the packet we are sending is what we think we are sending!
|
||
//
|
||
ASSERT (ntohl(pODataBuffer->DataSequenceNumber) == (LONG) pSender->LastODataSentSequenceNumber);
|
||
|
||
pSender->EmptySequencesForLastSend = EmptyPackets;
|
||
pSender->LastODataSentSequenceNumber += EmptyPackets;
|
||
|
||
}
|
||
else
|
||
{
|
||
ExFreeToNPagedLookasideList (&pSender->SenderBufferLookaside, pSendBuffer);
|
||
pSendBuffer = NULL;
|
||
}
|
||
|
||
//
|
||
// Now, set the parameters for the next send
|
||
//
|
||
if ((pSendBuffer) &&
|
||
(!pSendContext->NumParityPacketsToSend)) // Verify no pro-active parity packets following this
|
||
{
|
||
pSendContext->NextPacketOffset += ((1 + EmptyPackets) * pSender->PacketBufferSize);
|
||
if (pSendContext->NextPacketOffset >= pSender->MaxDataFileSize)
|
||
{
|
||
pSendContext->NextPacketOffset = 0; // We need to wrap around!
|
||
}
|
||
}
|
||
|
||
//
|
||
// If we have sent all the data for this Send (or however many bytes
|
||
// we had packetized from this send), we need to packetize more packets
|
||
//
|
||
if ((pSendContext->NumDataPacketsSent == pSendContext->DataPacketsPacketized) &&
|
||
(!pSendContext->NumParityPacketsToSend))
|
||
{
|
||
//
|
||
// If we are done with this send, move it to the CompletedSends list
|
||
// The last send completion will complete the Send Irp
|
||
//
|
||
if (!pSendContext->BytesLeftToPacketize)
|
||
{
|
||
ASSERT (pSend->pSender->LastODataSentSequenceNumber == pSendContext->EndSequenceNumber);
|
||
ASSERT (pSendContext->NumSendsPending);
|
||
|
||
RemoveEntryList (&pSendContext->Linkage);
|
||
InsertTailList (&pSender->CompletedSendsInWindow, &pSendContext->Linkage);
|
||
pSender->NumODataRequestsPending--;
|
||
//
|
||
// If the last packet on this Send had a FIN, we will need to
|
||
// follow this send with an Ambient SPM including the FIN flag
|
||
//
|
||
ASSERT (!pSendContext->bLastSend);
|
||
if (pSendContext->DataOptions & PGM_OPTION_FLAG_FIN)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmSendNextOData",
|
||
"Setting FIN since client closed session!\n");
|
||
|
||
pSender->SpmOptions |= PGM_OPTION_FLAG_FIN;
|
||
pSender->CurrentSPMTimeout = pSender->AmbientSPMTimeout;
|
||
pSend->SessionFlags |= PGM_SESSION_FLAG_SEND_AMBIENT_SPM;
|
||
}
|
||
}
|
||
|
||
PgmPrepareNextSend (pSend, pOldIrq, FALSE, FALSE);
|
||
}
|
||
|
||
if (!pSendBuffer)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmSendNextOData",
|
||
"Setting FIN since client closed session!\n");
|
||
//
|
||
// This was the case of a new Send waiting to be packetized
|
||
// Return success here, and we should get called again for the
|
||
// actual send
|
||
//
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
|
||
pODataBuffer->TrailingEdgeSequenceNumber = htonl ((ULONG) pSender->TrailingGroupSequenceNumber);
|
||
XSum = 0;
|
||
pODataBuffer->CommonHeader.Checksum = 0;
|
||
XSum = tcpxsum (XSum, (CHAR *) pODataBuffer, SendBufferLength); // Compute the Checksum
|
||
pODataBuffer->CommonHeader.Checksum = (USHORT) (~XSum);
|
||
|
||
status = TdiSendDatagram (pSender->pAddress->pFileObject,
|
||
pSender->pAddress->pDeviceObject,
|
||
pODataBuffer,
|
||
(ULONG) SendBufferLength,
|
||
PgmSendODataCompletion, // Completion
|
||
pSendContext, // Context1
|
||
pODataBuffer, // Context2
|
||
pSender->DestMCastIpAddress,
|
||
pSender->DestMCastPort);
|
||
|
||
ASSERT (NT_SUCCESS (status));
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "PgmSendNextOData",
|
||
"[%d-%d] -- Sent <%d> bytes to <%x:%d>\n",
|
||
(ULONG) pSender->TrailingGroupSequenceNumber,
|
||
(ULONG) pSender->LastODataSentSequenceNumber,
|
||
SendBufferLength, pSender->DestMCastIpAddress, pSender->DestMCastPort);
|
||
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
*pBytesSent = SendBufferLength;
|
||
return (status);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmCancelAllSends(
|
||
IN tSEND_SESSION *pSend,
|
||
IN LIST_ENTRY *pListEntry,
|
||
IN PIRP pIrp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine handles the cancelling of a Send Irp. It must release the
|
||
cancel spin lock before returning re: IoCancelIrp().
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
{
|
||
PLIST_ENTRY pEntry;
|
||
tCLIENT_SEND_REQUEST *pSendContext;
|
||
PIRP pIrpToComplete = NULL;
|
||
SEQ_TYPE HighestLeadSeq;
|
||
ULONG NumExSequencesInOldWindow, NumRequests = 0;
|
||
ULONGLONG BufferSpaceFreed;
|
||
|
||
//
|
||
// Now cancel all the remaining send requests because the integrity
|
||
// of the data cannot be guaranteed
|
||
// We also have to deal with the fact that some Irps may have
|
||
// data in the transport (i.e. possibly the first send on the Packetized
|
||
// list, or the last send of the completed list)
|
||
//
|
||
// We will start with the unpacketized requests
|
||
//
|
||
while (!IsListEmpty (&pSend->pSender->PendingSends))
|
||
{
|
||
pEntry = RemoveHeadList (&pSend->pSender->PendingSends);
|
||
pSendContext = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
InsertTailList (pListEntry, pEntry);
|
||
NumRequests++;
|
||
|
||
ASSERT (!pSendContext->NumSendsPending);
|
||
|
||
//
|
||
// If this is a partial send, we will mark the Irp for completion
|
||
// initially to the companion send request (to avoid complications
|
||
// of Sends pending in the transport here)
|
||
//
|
||
if (pSendContext->pMessage2Request)
|
||
{
|
||
//
|
||
// pMessage2Request could either be on the PendingPacketizedSends
|
||
// list or on the Completed Sends list (awaiting a send completion)
|
||
//
|
||
ASSERT (pSendContext->pMessage2Request->pIrp);
|
||
if (pSendContext->pIrpToComplete)
|
||
{
|
||
ASSERT (!pSendContext->pMessage2Request->pIrpToComplete);
|
||
pSendContext->pMessage2Request->pIrpToComplete = pSendContext->pIrpToComplete;
|
||
pSendContext->pIrpToComplete = NULL;
|
||
}
|
||
|
||
pSendContext->pMessage2Request->pMessage2Request = NULL;
|
||
pSendContext->pMessage2Request = NULL;
|
||
}
|
||
|
||
ASSERT (pSendContext->BytesLeftToPacketize == pSendContext->BytesInSend);
|
||
pSend->pSender->NumODataRequestsPending--;
|
||
pSend->pSender->NumPacketsRemaining -= pSendContext->NumPacketsRemaining;
|
||
}
|
||
|
||
//
|
||
// Now, go through all the sends which have already been packetized
|
||
// except for the first one which we will handle below
|
||
//
|
||
HighestLeadSeq = pSend->pSender->NextODataSequenceNumber;
|
||
pEntry = pSend->pSender->PendingPacketizedSends.Flink;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->PendingPacketizedSends)
|
||
{
|
||
pSendContext = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
pEntry = pEntry->Blink;
|
||
RemoveEntryList (&pSendContext->Linkage);
|
||
InsertTailList (pListEntry, &pSendContext->Linkage);
|
||
pSend->pSender->NumODataRequestsPending--;
|
||
pSend->pSender->NumPacketsRemaining -= pSendContext->NumPacketsRemaining;
|
||
NumRequests++;
|
||
|
||
if (SEQ_LT (pSendContext->StartSequenceNumber, HighestLeadSeq))
|
||
{
|
||
HighestLeadSeq = pSendContext->StartSequenceNumber;
|
||
}
|
||
|
||
ASSERT ((!pSendContext->NumDataPacketsSent) && (!pSendContext->NumSendsPending));
|
||
if (pSendContext->pMessage2Request)
|
||
{
|
||
//
|
||
// pMessage2Request could either be on the PendingPacketizedSends
|
||
// list or on the Completed Sends list (awaiting a send completion)
|
||
//
|
||
ASSERT (pSendContext->pMessage2Request->pIrp);
|
||
if (pSendContext->pIrpToComplete)
|
||
{
|
||
ASSERT (!pSendContext->pMessage2Request->pIrpToComplete);
|
||
pSendContext->pMessage2Request->pIrpToComplete = pSendContext->pIrpToComplete;
|
||
pSendContext->pIrpToComplete = NULL;
|
||
}
|
||
|
||
pSendContext->pMessage2Request->pMessage2Request = NULL;
|
||
pSendContext->pMessage2Request = NULL;
|
||
}
|
||
}
|
||
|
||
//
|
||
// Terminate the first PendingPacketizedSend only if we have not
|
||
// yet started sending it or this Cancel was meant for that request
|
||
// (Try to protect data integrity as much as possible)
|
||
//
|
||
if (!IsListEmpty (&pSend->pSender->PendingPacketizedSends))
|
||
{
|
||
pSendContext = CONTAINING_RECORD (pSend->pSender->PendingPacketizedSends.Flink, tCLIENT_SEND_REQUEST, Linkage);
|
||
if ((!pSendContext->NumDataPacketsSent) ||
|
||
(!pIrp || (pSendContext->pIrp == pIrp)))
|
||
{
|
||
RemoveEntryList (&pSendContext->Linkage);
|
||
ASSERT (IsListEmpty (&pSend->pSender->PendingPacketizedSends));
|
||
NumRequests++;
|
||
|
||
//
|
||
// If we have some data pending in the transport,
|
||
// then we will have to let the SendCompletion handle that
|
||
//
|
||
ASSERT ((pSendContext->NumDataPacketsSent < pSendContext->DataPacketsPacketized) ||
|
||
(pSendContext->NumParityPacketsToSend));
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmCancelAllSends",
|
||
"Partial Send, pIrp=<%p>, BytesLeftToPacketize=<%d/%d>, PacketsSent=<%d/%d>, Pending=<%d>\n",
|
||
pSendContext->pIrp, pSendContext->BytesLeftToPacketize,
|
||
pSendContext->BytesInSend, pSendContext->NumDataPacketsSent,
|
||
pSendContext->DataPacketsPacketized, pSendContext->NumSendsPending);
|
||
|
||
pSendContext->BytesLeftToPacketize = 0;
|
||
pSendContext->DataPacketsPacketized = pSendContext->NumDataPacketsSent;
|
||
pSendContext->NumParityPacketsToSend = 0;
|
||
|
||
pSend->pSender->NumODataRequestsPending--;
|
||
pSend->pSender->NumPacketsRemaining -= pSendContext->NumPacketsRemaining;
|
||
|
||
if (pSendContext->NumSendsPending)
|
||
{
|
||
InsertTailList (&pSend->pSender->CompletedSendsInWindow, &pSendContext->Linkage);
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// If we have a companion partial, then it must be in the completed list
|
||
// awaiting SendCompletion
|
||
//
|
||
if (pSendContext->pMessage2Request)
|
||
{
|
||
ASSERT (pSendContext->pMessage2Request->pIrp);
|
||
if (pSendContext->pIrpToComplete)
|
||
{
|
||
ASSERT (!pSendContext->pMessage2Request->BytesLeftToPacketize);
|
||
ASSERT (!pSendContext->pMessage2Request->pIrpToComplete);
|
||
pSendContext->pMessage2Request->pIrpToComplete = pSendContext->pIrpToComplete;
|
||
pSendContext->pIrpToComplete = NULL;
|
||
}
|
||
|
||
pSendContext->pMessage2Request->pMessage2Request = NULL;
|
||
pSendContext->pMessage2Request = NULL;
|
||
}
|
||
|
||
InsertTailList (pListEntry, &pSendContext->Linkage);
|
||
}
|
||
|
||
pSendContext->EndSequenceNumber = pSend->pSender->LastODataSentSequenceNumber;
|
||
HighestLeadSeq = pSend->pSender->LastODataSentSequenceNumber + 1;
|
||
}
|
||
}
|
||
|
||
NumExSequencesInOldWindow = (ULONG) (SEQ_TYPE) (pSend->pSender->NextODataSequenceNumber-HighestLeadSeq);
|
||
BufferSpaceFreed = NumExSequencesInOldWindow * pSend->pSender->PacketBufferSize;
|
||
if (NumExSequencesInOldWindow)
|
||
{
|
||
pSend->SessionFlags |= PGM_SESSION_SENDS_CANCELLED;
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmCancelAllSends",
|
||
"[%d]: NumSeqs=<%d>, NextOData=<%d-->%d>, BuffFreeed=<%d>, LeadingOffset=<%d-->%d>\n",
|
||
NumRequests, NumExSequencesInOldWindow,
|
||
(ULONG) pSend->pSender->NextODataSequenceNumber, (ULONG) HighestLeadSeq,
|
||
(ULONG) BufferSpaceFreed, (ULONG) pSend->pSender->LeadingWindowOffset,
|
||
(ULONG) (pSend->pSender->LeadingWindowOffset - BufferSpaceFreed));
|
||
}
|
||
|
||
pSend->pSender->NextODataSequenceNumber = HighestLeadSeq;
|
||
|
||
pSend->pSender->BufferSizeAvailable += BufferSpaceFreed;
|
||
ASSERT (pSend->pSender->BufferSizeAvailable <= pSend->pSender->MaxDataFileSize);
|
||
if (pSend->pSender->LeadingWindowOffset >= BufferSpaceFreed)
|
||
{
|
||
pSend->pSender->LeadingWindowOffset -= BufferSpaceFreed;
|
||
}
|
||
else
|
||
{
|
||
pSend->pSender->LeadingWindowOffset = pSend->pSender->MaxDataFileSize - (BufferSpaceFreed - pSend->pSender->LeadingWindowOffset);
|
||
}
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
ULONG
|
||
AdvanceWindow(
|
||
IN tSEND_SESSION *pSend
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to check if we need to advance the
|
||
trailing window, and does so as appropriate
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
|
||
Return Value:
|
||
|
||
TRUE if the send window buffer is empty, FALSE otherwise
|
||
|
||
--*/
|
||
{
|
||
LIST_ENTRY *pEntry;
|
||
tCLIENT_SEND_REQUEST *pSendContextLast;
|
||
tCLIENT_SEND_REQUEST *pSendContext1;
|
||
tSEND_RDATA_CONTEXT *pRDataContext;
|
||
SEQ_TYPE HighestTrailSeq, MaxSequencesToAdvance, SequencesInSend;
|
||
ULONGLONG PreferredTrailTime = 0;
|
||
ULONG NumExSequencesInOldWindow = 0;
|
||
|
||
//
|
||
// See if we need to increment the Trailing edge of our transmit window
|
||
//
|
||
if (pSend->pSender->TimerTickCount > pSend->pSender->NextWindowAdvanceTime)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "AdvanceWindow",
|
||
"Advancing NextWindowAdvanceTime -- TimerTC = [%d:%d] >= NextWinAdvT [%d:%d]\n",
|
||
pSend->pSender->TimerTickCount, pSend->pSender->NextWindowAdvanceTime);
|
||
|
||
pSend->pSender->NextWindowAdvanceTime = pSend->pSender->TimerTickCount +
|
||
pSend->pSender->WindowAdvanceDeltaTime;
|
||
}
|
||
|
||
PreferredTrailTime = (pSend->pSender->NextWindowAdvanceTime - pSend->pSender->WindowAdvanceDeltaTime) -
|
||
pSend->pSender->WindowSizeTime;
|
||
|
||
//
|
||
// Determine the maximum sequences we can advance by (initially all seqs in window)
|
||
//
|
||
MaxSequencesToAdvance = pSend->pSender->LastODataSentSequenceNumber -
|
||
pSend->pSender->TrailingEdgeSequenceNumber + 1;
|
||
//
|
||
// If we are required to advance the window on-demand, then we
|
||
// will need to limit the Maximum sequences we can advance by
|
||
//
|
||
if ((pSend->pSender->pAddress->Flags & PGM_ADDRESS_USE_WINDOW_AS_DATA_CACHE) &&
|
||
!(pSend->SessionFlags & PGM_SESSION_DISCONNECT_INDICATED))
|
||
{
|
||
if (MaxSequencesToAdvance > (pSend->pSender->MaxPacketsInBuffer >> 1))
|
||
{
|
||
MaxSequencesToAdvance -= (ULONG) (pSend->pSender->MaxPacketsInBuffer >> 1);
|
||
}
|
||
else
|
||
{
|
||
MaxSequencesToAdvance = 0;
|
||
}
|
||
}
|
||
|
||
if ((MaxSequencesToAdvance) &&
|
||
(PreferredTrailTime >= pSend->pSender->TrailingEdgeTime)) // need to reset our current trailing edge
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "AdvanceWindow",
|
||
"PreferredTrail=[%d:%d] > TrailingEdge=[%d:%d], WinAdvMSecs=<%d:%d>, WinSizeMSecs=<%d:%d>\n",
|
||
PreferredTrailTime, pSend->pSender->TrailingEdgeTime, pSend->pSender->WindowAdvanceDeltaTime,
|
||
pSend->pSender->WindowSizeTime);
|
||
|
||
//
|
||
// First determine what is the maximum limit we can advance the
|
||
// window to (dependent on pending RData and send completions)
|
||
//
|
||
HighestTrailSeq = pSend->pSender->NextODataSequenceNumber & ~((SEQ_TYPE) pSend->FECGroupSize-1); // Init
|
||
|
||
// Start with pending RData requests
|
||
if (!IsListEmpty (&pSend->pSender->PendingRDataRequests))
|
||
{
|
||
//
|
||
// This list is ordered, so just compare with the first entry
|
||
//
|
||
pEntry = pSend->pSender->PendingRDataRequests.Flink;
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
if (SEQ_LT (pRDataContext->RDataSequenceNumber, HighestTrailSeq))
|
||
{
|
||
HighestTrailSeq = pRDataContext->RDataSequenceNumber;
|
||
}
|
||
}
|
||
// Now, verify that the handled RData requests do not need this
|
||
// buffer memory (i.e. the Sends have completed)
|
||
pEntry = &pSend->pSender->HandledRDataRequests;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->HandledRDataRequests)
|
||
{
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
if ((!pRDataContext->CleanupTime) && // CleanupTime is 0 for pending sends
|
||
SEQ_LT (pRDataContext->RDataSequenceNumber, HighestTrailSeq))
|
||
{
|
||
HighestTrailSeq = pRDataContext->RDataSequenceNumber;
|
||
}
|
||
}
|
||
|
||
// Now, check the completed sends list
|
||
pSendContextLast = pSendContext1 = NULL;
|
||
pEntry = &pSend->pSender->CompletedSendsInWindow;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->CompletedSendsInWindow)
|
||
{
|
||
pSendContext1 = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
ASSERT (SEQ_GEQ (pSendContext1->EndSequenceNumber, pSend->pSender->TrailingEdgeSequenceNumber));
|
||
if (SEQ_GT (pSend->pSender->TrailingEdgeSequenceNumber, pSendContext1->StartSequenceNumber))
|
||
{
|
||
SequencesInSend = pSendContext1->EndSequenceNumber - pSend->pSender->TrailingEdgeSequenceNumber + 1;
|
||
}
|
||
else
|
||
{
|
||
SequencesInSend = pSendContext1->EndSequenceNumber - pSendContext1->StartSequenceNumber + 1;
|
||
}
|
||
|
||
if ((pSendContext1->NumSendsPending) || // Cannot advance if completions are pending
|
||
(pSendContext1->SendStartTime >= PreferredTrailTime) ||
|
||
(MaxSequencesToAdvance < SequencesInSend))
|
||
{
|
||
if (SEQ_LT (pSendContext1->StartSequenceNumber, HighestTrailSeq))
|
||
{
|
||
HighestTrailSeq = pSendContext1->StartSequenceNumber;
|
||
}
|
||
break;
|
||
}
|
||
else if (SEQ_GEQ (pSendContext1->StartSequenceNumber, HighestTrailSeq))
|
||
{
|
||
break;
|
||
}
|
||
|
||
ASSERT (MaxSequencesToAdvance);
|
||
if (pSendContextLast)
|
||
{
|
||
MaxSequencesToAdvance -= (pSendContextLast->EndSequenceNumber -
|
||
pSendContextLast->StartSequenceNumber + 1);
|
||
|
||
// Remove the send that is definitely out of the new window
|
||
RemoveEntryList (&pSendContextLast->Linkage);
|
||
ASSERT ((!pSendContextLast->pMessage2Request) && (!pSendContextLast->pIrp));
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside,pSendContextLast);
|
||
}
|
||
pSendContextLast = pSendContext1;
|
||
}
|
||
|
||
//
|
||
// pSendContext1 will be NULL if there are no completed sends,
|
||
// in which case we may have 1 huge current send that could be hogging
|
||
// our buffer, so check that then!
|
||
//
|
||
if ((!pSendContext1) &&
|
||
(!IsListEmpty (&pSend->pSender->PendingPacketizedSends)))
|
||
{
|
||
pSendContextLast = CONTAINING_RECORD (pSend->pSender->PendingPacketizedSends.Flink, tCLIENT_SEND_REQUEST, Linkage);
|
||
if ((pSendContextLast->NumSendsPending) || // Ensure no sends pending
|
||
(pSendContextLast->NumParityPacketsToSend) || // No parity packets left to send
|
||
(!pSendContextLast->NumDataPacketsSent) || // No packets sent yet
|
||
(pSendContextLast->DataPacketsPacketized != pSendContextLast->NumDataPacketsSent))
|
||
{
|
||
pSendContextLast = NULL;
|
||
}
|
||
}
|
||
|
||
//
|
||
// pSendContextLast will be non-NULL if we need to advance
|
||
// the Trailing edge
|
||
//
|
||
if (pSendContextLast)
|
||
{
|
||
//
|
||
// Do some sanity checks!
|
||
//
|
||
ASSERT (PreferredTrailTime >= pSendContextLast->SendStartTime);
|
||
ASSERT (SEQ_GEQ (pSendContextLast->EndSequenceNumber,pSend->pSender->TrailingEdgeSequenceNumber));
|
||
ASSERT (SEQ_GEQ (HighestTrailSeq, pSendContextLast->StartSequenceNumber));
|
||
ASSERT (SEQ_GEQ (HighestTrailSeq, pSend->pSender->TrailingEdgeSequenceNumber));
|
||
|
||
//
|
||
// See if this send is partially in or out of the window now!
|
||
// Calculate the offset of sequences in this Send request for the
|
||
// preferred trail time
|
||
//
|
||
NumExSequencesInOldWindow = (ULONG) (SEQ_TYPE) (((PreferredTrailTime-pSendContextLast->SendStartTime)*
|
||
BASIC_TIMER_GRANULARITY_IN_MSECS * pSend->pSender->pAddress->RateKbitsPerSec) /
|
||
(pSend->pSender->pAddress->OutIfMTU * BITS_PER_BYTE));
|
||
|
||
//
|
||
// Now, adjust this offset to the trailing edge
|
||
//
|
||
if (SEQ_GT ((pSendContextLast->StartSequenceNumber + NumExSequencesInOldWindow),
|
||
pSend->pSender->TrailingEdgeSequenceNumber))
|
||
{
|
||
NumExSequencesInOldWindow = pSendContextLast->StartSequenceNumber +
|
||
NumExSequencesInOldWindow -
|
||
pSend->pSender->TrailingEdgeSequenceNumber;
|
||
}
|
||
else
|
||
{
|
||
ASSERT (pSend->pSender->TrailingEdgeSequenceNumber ==
|
||
(pSendContextLast->StartSequenceNumber + NumExSequencesInOldWindow));
|
||
|
||
NumExSequencesInOldWindow = 0;
|
||
}
|
||
|
||
//
|
||
// Now, limit the # sequences to advance with the window size
|
||
//
|
||
if (NumExSequencesInOldWindow > MaxSequencesToAdvance)
|
||
{
|
||
NumExSequencesInOldWindow = MaxSequencesToAdvance;
|
||
}
|
||
|
||
//
|
||
// Finally, see if we need to limit the advance based on the RData pending requests
|
||
//
|
||
if (SEQ_GT (HighestTrailSeq, (pSend->pSender->TrailingEdgeSequenceNumber +
|
||
NumExSequencesInOldWindow)))
|
||
{
|
||
HighestTrailSeq = (SEQ_TYPE) (pSend->pSender->TrailingEdgeSequenceNumber + NumExSequencesInOldWindow);
|
||
}
|
||
else if (SEQ_GEQ (HighestTrailSeq, pSend->pSender->TrailingEdgeSequenceNumber))
|
||
{
|
||
//
|
||
// We are limited by the pending RData
|
||
// So, recalculate the PreferredTrailTime (to set the actual trail time)!
|
||
//
|
||
NumExSequencesInOldWindow = (ULONG) (SEQ_TYPE) (HighestTrailSeq - pSend->pSender->TrailingEdgeSequenceNumber);
|
||
PreferredTrailTime = (NumExSequencesInOldWindow * pSend->pSender->pAddress->OutIfMTU * BITS_PER_BYTE) /
|
||
(pSend->pSender->pAddress->RateKbitsPerSec * BASIC_TIMER_GRANULARITY_IN_MSECS);
|
||
PreferredTrailTime += pSend->pSender->TrailingEdgeTime;
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "AdvanceWindow",
|
||
"LastSend: NumExSeq=<%d>, HighestTrailSeq=<%d>, PreferredTrailTime=<%d:%d>\n",
|
||
(ULONG) NumExSequencesInOldWindow, (ULONG) HighestTrailSeq, PreferredTrailTime);
|
||
|
||
if (SEQ_GT (HighestTrailSeq, pSendContextLast->EndSequenceNumber) &&
|
||
(!pSendContextLast->BytesLeftToPacketize))
|
||
{
|
||
//
|
||
// We can drop this whole send since it is outside of our window
|
||
// Set the new trailing edge based on whether we have a following
|
||
// send or not!
|
||
//
|
||
if ((pSendContext1) &&
|
||
(pSendContext1 != pSendContextLast))
|
||
{
|
||
//
|
||
// Readjust the trailing time to the next send
|
||
//
|
||
PreferredTrailTime = pSendContext1->SendStartTime;
|
||
}
|
||
HighestTrailSeq = pSendContextLast->EndSequenceNumber + 1;
|
||
|
||
// Remove this send and free it!
|
||
ASSERT ((!pSendContextLast->pMessage2Request) && (!pSendContextLast->pIrp));
|
||
RemoveEntryList (&pSendContextLast->Linkage);
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside,pSendContextLast);
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "AdvanceWindow",
|
||
"Window Adv: NumSeq=<%d>, TrailSeqNum=<%d>==><%d>, TrailTime=<%d:%d>==><%d:%d>\n",
|
||
(ULONG) NumExSequencesInOldWindow, (ULONG) pSend->pSender->TrailingGroupSequenceNumber,
|
||
(ULONG) HighestTrailSeq, pSend->pSender->TrailingEdgeTime, PreferredTrailTime);
|
||
|
||
//
|
||
// Now, adjust the buffer settings
|
||
//
|
||
ASSERT (SEQ_GEQ (HighestTrailSeq, pSend->pSender->TrailingEdgeSequenceNumber));
|
||
NumExSequencesInOldWindow = (ULONG) (SEQ_TYPE) (HighestTrailSeq - pSend->pSender->TrailingEdgeSequenceNumber);
|
||
pSend->pSender->BufferSizeAvailable += (NumExSequencesInOldWindow * pSend->pSender->PacketBufferSize);
|
||
ASSERT (pSend->pSender->BufferSizeAvailable <= pSend->pSender->MaxDataFileSize);
|
||
pSend->pSender->TrailingWindowOffset += (NumExSequencesInOldWindow * pSend->pSender->PacketBufferSize);
|
||
if (pSend->pSender->TrailingWindowOffset >= pSend->pSender->MaxDataFileSize)
|
||
{
|
||
// Wrap around case!
|
||
pSend->pSender->TrailingWindowOffset -= pSend->pSender->MaxDataFileSize;
|
||
}
|
||
ASSERT (pSend->pSender->TrailingWindowOffset < pSend->pSender->MaxDataFileSize);
|
||
pSend->pSender->TrailingEdgeSequenceNumber = HighestTrailSeq;
|
||
pSend->pSender->TrailingGroupSequenceNumber = (HighestTrailSeq+pSend->FECGroupSize-1) &
|
||
~((SEQ_TYPE) pSend->FECGroupSize-1);
|
||
pSend->pSender->TrailingEdgeTime = PreferredTrailTime;
|
||
} // else nothing to advance!
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "AdvanceWindow",
|
||
"Transmit Window Range=[%d, %d], TimerTC=[%d:%d]\n",
|
||
(ULONG) pSend->pSender->TrailingEdgeSequenceNumber,
|
||
(ULONG) (pSend->pSender->NextODataSequenceNumber-1),
|
||
pSend->pSender->TimerTickCount);
|
||
|
||
return (NumExSequencesInOldWindow);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
BOOLEAN
|
||
CheckForTermination(
|
||
IN tSEND_SESSION *pSend,
|
||
IN PGMLockHandle *pOldIrq
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called to check and terminate the session
|
||
if necessary.
|
||
The pSend lock is held before calling this routine
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
|
||
Return Value:
|
||
|
||
TRUE if the send window buffer is empty, FALSE otherwise
|
||
|
||
--*/
|
||
{
|
||
LIST_ENTRY *pEntry;
|
||
LIST_ENTRY ListEntry;
|
||
tCLIENT_SEND_REQUEST *pSendContext;
|
||
tSEND_RDATA_CONTEXT *pRDataContext;
|
||
PIRP pIrp;
|
||
ULONG NumSequences;
|
||
|
||
if (!(PGM_VERIFY_HANDLE (pSend, PGM_VERIFY_SESSION_DOWN)) &&
|
||
!(PGM_VERIFY_HANDLE (pSend->pSender->pAddress, PGM_VERIFY_ADDRESS_DOWN)) &&
|
||
!(pSend->SessionFlags & PGM_SESSION_CLIENT_DISCONNECTED))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_CONNECT, "CheckForTermination",
|
||
"Session for pSend=<%p> does not need to be terminated\n", pSend);
|
||
|
||
return (FALSE);
|
||
}
|
||
|
||
//
|
||
// See if we have processed the disconnect for the first time yet
|
||
//
|
||
if (!(pSend->SessionFlags & PGM_SESSION_DISCONNECT_INDICATED))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "CheckForTermination",
|
||
"Session is going down!, Packets remaining=<%d>\n", pSend->pSender->NumPacketsRemaining);
|
||
|
||
pSend->SessionFlags |= PGM_SESSION_DISCONNECT_INDICATED;
|
||
|
||
//
|
||
// We have to set the FIN on the Data as well as SPM packets.
|
||
// Thus, there are 2 situations -- either we have finished sending
|
||
// all the Data packets, or we are still in the midst of sending
|
||
//
|
||
// If there are no more sends pending, we will have to
|
||
// modify the last packet ourselves to set the FIN option
|
||
//
|
||
if (!IsListEmpty (&pSend->pSender->PendingSends))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "CheckForTermination",
|
||
"Send pending on list -- setting bLastSend for FIN on last Send\n");
|
||
|
||
pSendContext = CONTAINING_RECORD (pSend->pSender->PendingSends.Blink, tCLIENT_SEND_REQUEST,Linkage);
|
||
|
||
//
|
||
// We will just set a flag here, so that when the last packet
|
||
// is packetized, the FIN flags are set
|
||
//
|
||
pSendContext->bLastSend = TRUE;
|
||
}
|
||
else if (pSend->pSender->NumODataRequestsPending)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "CheckForTermination",
|
||
"Last Send in progress -- setting bLastSend for FIN on this Send\n");
|
||
|
||
//
|
||
// If have already packetized the last send, but have not yet
|
||
// sent it out, then PgmSendNextOData will put the FIN in the data packet
|
||
// otherwise, if we have not yet packetized the packet, then we will set the
|
||
// FIN option while preparing the last packet
|
||
//
|
||
pSendContext = CONTAINING_RECORD (pSend->pSender->PendingPacketizedSends.Blink, tCLIENT_SEND_REQUEST,Linkage);
|
||
pSendContext->bLastSend = TRUE;
|
||
}
|
||
else
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "CheckForTermination",
|
||
"No Sends in progress -- setting FIN for next SPM\n");
|
||
|
||
//
|
||
// We have finished packetizing and sending all the packets,
|
||
// so set the FIN flag on the SPMs and also modify the last
|
||
// RData packet (if still in the window) for the FIN -- this
|
||
// will be done when the next RData packet is sent out
|
||
//
|
||
if (pSend->SessionFlags & PGM_SESSION_SENDS_CANCELLED)
|
||
{
|
||
pSend->pSender->SpmOptions &= ~PGM_OPTION_FLAG_FIN;
|
||
pSend->pSender->SpmOptions |= PGM_OPTION_FLAG_RST;
|
||
}
|
||
else
|
||
{
|
||
pSend->pSender->SpmOptions &= ~PGM_OPTION_FLAG_RST;
|
||
pSend->pSender->SpmOptions |= PGM_OPTION_FLAG_FIN;
|
||
}
|
||
|
||
//
|
||
// We also need to send an SPM immediately
|
||
//
|
||
pSend->pSender->CurrentSPMTimeout = pSend->pSender->AmbientSPMTimeout;
|
||
pSend->SessionFlags |= PGM_SESSION_FLAG_SEND_AMBIENT_SPM;
|
||
}
|
||
|
||
return (FALSE);
|
||
}
|
||
|
||
//
|
||
// If we have a (graceful) disconnect Irp to complete, we should complete
|
||
// it if we have timed out, or are ready to do so now
|
||
//
|
||
if ((pIrp = pSend->pIrpDisconnect) && // Disconnect Irp pending
|
||
(((pSend->pSender->DisconnectTimeInTicks) && (pSend->pSender->TimerTickCount >
|
||
pSend->pSender->DisconnectTimeInTicks)) ||
|
||
((IsListEmpty (&pSend->pSender->PendingSends)) && // No Unpacketized Sends pending
|
||
(IsListEmpty (&pSend->pSender->PendingPacketizedSends)) && // No Packetized sends pending
|
||
(IsListEmpty (&pSend->pSender->PendingRDataRequests)) && // No Pending RData requests
|
||
(IsListEmpty (&pSend->pSender->CompletedSendsInWindow)) && // Window is Empty
|
||
(pSend->pSender->SpmOptions & (PGM_OPTION_FLAG_FIN | // FIN | RST | RST_N set on SPMs
|
||
PGM_OPTION_FLAG_RST |
|
||
PGM_OPTION_FLAG_RST_N)) &&
|
||
!(pSend->SessionFlags & PGM_SESSION_FLAG_SEND_AMBIENT_SPM)))) // No Ambient Spm pending
|
||
{
|
||
pSend->pIrpDisconnect = NULL;
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_CONNECT, "CheckForTermination",
|
||
"Completing Graceful disconnect pIrp=<%p>\n", pIrp);
|
||
|
||
PgmIoComplete (pIrp, STATUS_SUCCESS, 0);
|
||
|
||
PgmLock (pSend, *pOldIrq);
|
||
return (FALSE);
|
||
}
|
||
|
||
//
|
||
// Do the final cleanup only if the handles have been closed
|
||
// or the disconnect has timed out
|
||
//
|
||
if (!(PGM_VERIFY_HANDLE (pSend, PGM_VERIFY_SESSION_DOWN)) &&
|
||
!(PGM_VERIFY_HANDLE (pSend->pSender->pAddress, PGM_VERIFY_ADDRESS_DOWN)) &&
|
||
((!pSend->pSender->DisconnectTimeInTicks) || (pSend->pSender->TimerTickCount <
|
||
pSend->pSender->DisconnectTimeInTicks)))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_CONNECT, "CheckForTermination",
|
||
"Handles have not yet been closed for pSend=<%p>, TC=<%x:%x>, DisconnectTime=<%x:%x>\n",
|
||
pSend, pSend->pSender->TimerTickCount, pSend->pSender->DisconnectTimeInTicks);
|
||
|
||
return (FALSE);
|
||
}
|
||
|
||
// *****************************************************************
|
||
// We will reach here only if we need to cleanup ASAP
|
||
// *****************************************************************
|
||
|
||
//
|
||
// First, cleanup all handled RData requests (which have completed)
|
||
//
|
||
pEntry = &pSend->pSender->HandledRDataRequests;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->HandledRDataRequests)
|
||
{
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
|
||
ASSERT (!pRDataContext->NumNaks);
|
||
if (!pRDataContext->NumPacketsInTransport)
|
||
{
|
||
pEntry = pEntry->Blink; // Set this because this pEntry will not be valid any more!
|
||
RemoveEntryList (&pRDataContext->Linkage);
|
||
PgmFreeMem (pRDataContext);
|
||
}
|
||
}
|
||
|
||
//
|
||
// Now, remove all pending RData requests (since this is an Abort scenario)
|
||
// If they have any sends pending, we will put them on the handled
|
||
// list now and cleanup later
|
||
//
|
||
pEntry = &pSend->pSender->PendingRDataRequests;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->PendingRDataRequests)
|
||
{
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
pEntry = pEntry->Blink; // Set this because this pEntry will not be valid any more!
|
||
|
||
ASSERT (pRDataContext->NumNaks);
|
||
pRDataContext->NumNaks = 0;
|
||
RemoveEntryList (&pRDataContext->Linkage);
|
||
pSend->pSender->NumRDataRequestsPending--;
|
||
|
||
if (pRDataContext->NumPacketsInTransport)
|
||
{
|
||
InsertTailList (&pSend->pSender->HandledRDataRequests, &pRDataContext->Linkage);
|
||
}
|
||
else
|
||
{
|
||
PgmFreeMem (pRDataContext);
|
||
}
|
||
}
|
||
|
||
|
||
//
|
||
// Now, Cancel and Complete all the send requests which are pending
|
||
//
|
||
InitializeListHead (&ListEntry);
|
||
PgmCancelAllSends (pSend, &ListEntry, NULL);
|
||
while (!IsListEmpty (&ListEntry))
|
||
{
|
||
pEntry = RemoveHeadList (&ListEntry);
|
||
pSendContext = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
ASSERT (!pSendContext->pMessage2Request);
|
||
|
||
PgmUnlock (pSend, *pOldIrq);
|
||
if (pSendContext->pIrpToComplete)
|
||
{
|
||
ASSERT (pSendContext->pIrpToComplete == pSendContext->pIrp);
|
||
PgmIoComplete (pSendContext->pIrpToComplete, STATUS_CANCELLED, 0);
|
||
}
|
||
else
|
||
{
|
||
ASSERT (pSendContext->pIrp);
|
||
}
|
||
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW);
|
||
PgmLock (pSend, *pOldIrq);
|
||
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext);
|
||
}
|
||
|
||
//
|
||
// Verify that at least 1 SPM with the FIN or RST or RST_N flag
|
||
// has been sent
|
||
//
|
||
if (!(pSend->pSender->SpmOptions & (PGM_OPTION_FLAG_FIN |
|
||
PGM_OPTION_FLAG_RST |
|
||
PGM_OPTION_FLAG_RST_N)))
|
||
{
|
||
if (pSend->SessionFlags & PGM_SESSION_SENDS_CANCELLED)
|
||
{
|
||
pSend->pSender->SpmOptions &= ~PGM_OPTION_FLAG_FIN;
|
||
pSend->pSender->SpmOptions |= PGM_OPTION_FLAG_RST;
|
||
}
|
||
else
|
||
{
|
||
pSend->pSender->SpmOptions &= ~PGM_OPTION_FLAG_RST;
|
||
pSend->pSender->SpmOptions |= PGM_OPTION_FLAG_FIN;
|
||
}
|
||
|
||
pSend->SessionFlags |= PGM_SESSION_FLAG_SEND_AMBIENT_SPM;
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_CONNECT, "CheckForTermination",
|
||
"SPM with FIN|RST|RST_N has not yet been sent for pSend=<%p>\n", pSend);
|
||
|
||
return (FALSE);
|
||
}
|
||
|
||
//
|
||
// Verify that there are no SPMs pending
|
||
//
|
||
if (pSend->SessionFlags & PGM_SESSION_FLAG_SEND_AMBIENT_SPM)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_CONNECT, "CheckForTermination",
|
||
"Cannot cleanup pSend=<%p> since we have Ambient SPM pending!\n", pSend);
|
||
|
||
return (FALSE);
|
||
}
|
||
|
||
//
|
||
// Verify that we do not have any completions pending also since
|
||
// Ip would need to reference the data buffer otherwise
|
||
//
|
||
while (!IsListEmpty (&pSend->pSender->CompletedSendsInWindow))
|
||
{
|
||
pSendContext = CONTAINING_RECORD (pSend->pSender->CompletedSendsInWindow.Flink, tCLIENT_SEND_REQUEST, Linkage);
|
||
if (pSendContext->NumSendsPending)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_SEND, "CheckForTermination",
|
||
"Session has terminated, but cannot continue cleanup since Sends are still pending!\n");
|
||
|
||
break;
|
||
}
|
||
|
||
//
|
||
// Now, set the buffer settings
|
||
//
|
||
ASSERT (SEQ_GEQ (pSend->pSender->TrailingEdgeSequenceNumber, pSendContext->StartSequenceNumber) &&
|
||
SEQ_LEQ (pSend->pSender->TrailingEdgeSequenceNumber, pSendContext->EndSequenceNumber));
|
||
|
||
NumSequences = (ULONG) (SEQ_TYPE) (pSendContext->EndSequenceNumber-pSend->pSender->TrailingEdgeSequenceNumber) +1;
|
||
pSend->pSender->BufferSizeAvailable += (NumSequences * pSend->pSender->PacketBufferSize);
|
||
ASSERT (pSend->pSender->BufferSizeAvailable <= pSend->pSender->MaxDataFileSize);
|
||
pSend->pSender->TrailingWindowOffset += (NumSequences * pSend->pSender->PacketBufferSize);
|
||
if (pSend->pSender->TrailingWindowOffset >= pSend->pSender->MaxDataFileSize)
|
||
{
|
||
// Wrap around case!
|
||
pSend->pSender->TrailingWindowOffset -= pSend->pSender->MaxDataFileSize;
|
||
}
|
||
ASSERT (pSend->pSender->TrailingWindowOffset < pSend->pSender->MaxDataFileSize);
|
||
pSend->pSender->TrailingEdgeSequenceNumber += (SEQ_TYPE) NumSequences;
|
||
|
||
ASSERT ((!pSendContext->pMessage2Request) && (!pSendContext->pIrp));
|
||
RemoveEntryList (&pSendContext->Linkage);
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext);
|
||
}
|
||
|
||
//
|
||
// If any sends are pending, return False
|
||
//
|
||
if ((pSend->pIrpDisconnect) ||
|
||
!(IsListEmpty (&pSend->pSender->CompletedSendsInWindow)) ||
|
||
!(IsListEmpty (&pSend->pSender->PendingSends)) ||
|
||
!(IsListEmpty (&pSend->pSender->PendingPacketizedSends)) ||
|
||
!(IsListEmpty (&pSend->pSender->PendingRDataRequests)) ||
|
||
!(IsListEmpty (&pSend->pSender->HandledRDataRequests)))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_SEND, "CheckForTermination",
|
||
"Cannot cleanup completely since transmit Window=[%d--%d] still has pending Sends!\n",
|
||
(ULONG) pSend->pSender->TrailingEdgeSequenceNumber,
|
||
(ULONG) (pSend->pSender->NextODataSequenceNumber-1));
|
||
|
||
return (FALSE);
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "CheckForTermination",
|
||
"Transmit Window has no pending Sends! TimerTC=[%d:%d]\n", pSend->pSender->TimerTickCount);
|
||
|
||
ASSERT (!pSend->pIrpDisconnect);
|
||
return (TRUE);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
BOOLEAN
|
||
SendNextPacket(
|
||
IN tSEND_SESSION *pSend
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is queued by the timer to send Data/Spm packets
|
||
based on available throughput
|
||
|
||
Arguments:
|
||
|
||
IN pSend -- Pgm session (sender) context
|
||
IN Unused1
|
||
IN Unused2
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
{
|
||
ULONG BytesSent;
|
||
ULONG NumSequences;
|
||
PGMLockHandle OldIrq;
|
||
BOOLEAN fTerminateSession = FALSE;
|
||
LIST_ENTRY *pEntry;
|
||
tSEND_RDATA_CONTEXT *pRDataContext, *pRDataToSend;
|
||
BOOLEAN fSendRData = TRUE;
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
//
|
||
// pSend->pSender->CurrentBytesSendable applies to OData, RData and SPMs only
|
||
//
|
||
while (pSend->pSender->CurrentBytesSendable >= pSend->pSender->pAddress->OutIfMTU)
|
||
{
|
||
BytesSent = 0;
|
||
|
||
//
|
||
// See if we need to send any Ambient SPMs
|
||
//
|
||
if ((pSend->SessionFlags & PGM_SESSION_FLAG_SEND_AMBIENT_SPM) &&
|
||
((pSend->pSender->PacketsSentSinceLastSpm > MAX_DATA_PACKETS_BEFORE_SPM) ||
|
||
(pSend->pSender->CurrentSPMTimeout >= pSend->pSender->AmbientSPMTimeout)))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "DelayedSendNextPacket",
|
||
"Send Ambient SPM, TC=[%d:%d], BS=<%d>\n",
|
||
pSend->pSender->TimerTickCount, pSend->pSender->CurrentBytesSendable);
|
||
//
|
||
// Some data packet was sent recently, so we are in Ambient SPM mode
|
||
//
|
||
PgmSendSpm (pSend, &OldIrq, &BytesSent);
|
||
|
||
pSend->pSender->CurrentSPMTimeout = 0; // Reset the SPM timeout
|
||
pSend->pSender->HeartbeatSPMTimeout = pSend->pSender->InitialHeartbeatSPMTimeout;
|
||
pSend->SessionFlags &= ~PGM_SESSION_FLAG_SEND_AMBIENT_SPM;
|
||
pSend->pSender->PacketsSentSinceLastSpm = 0;
|
||
}
|
||
//
|
||
// Otherwise see if we need to send any Heartbeat SPMs
|
||
//
|
||
else if ((!(pSend->SessionFlags & PGM_SESSION_FLAG_SEND_AMBIENT_SPM)) &&
|
||
(pSend->pSender->CurrentSPMTimeout >= pSend->pSender->HeartbeatSPMTimeout))
|
||
{
|
||
//
|
||
// No data packet was sent recently, so we need to send a Heartbeat SPM
|
||
//
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "DelayedSendNextPacket",
|
||
"Send Heartbeat SPM, TC=[%d:%d], BS=<%d>\n",
|
||
pSend->pSender->TimerTickCount, pSend->pSender->CurrentBytesSendable);
|
||
|
||
//
|
||
// (Send Heartbeat SPM Packet)
|
||
//
|
||
PgmSendSpm (pSend, &OldIrq, &BytesSent);
|
||
|
||
pSend->pSender->CurrentSPMTimeout = 0; // Reset the SPM timeout
|
||
pSend->pSender->HeartbeatSPMTimeout *= 2;
|
||
if (pSend->pSender->HeartbeatSPMTimeout > pSend->pSender->MaxHeartbeatSPMTimeout)
|
||
{
|
||
pSend->pSender->HeartbeatSPMTimeout = pSend->pSender->MaxHeartbeatSPMTimeout;
|
||
}
|
||
pSend->pSender->PacketsSentSinceLastSpm = 0;
|
||
}
|
||
//
|
||
// Next, see if we need to send any RData
|
||
//
|
||
else if ((pSend->pSender->NumRDataRequestsPending) || (pSend->pSender->NumODataRequestsPending))
|
||
{
|
||
//
|
||
// See if we need to send an RData packet now
|
||
//
|
||
pRDataToSend = NULL;
|
||
if ((pSend->pSender->NumRDataRequestsPending) &&
|
||
(fSendRData || !pSend->pSender->NumODataRequestsPending))
|
||
{
|
||
pEntry = &pSend->pSender->PendingRDataRequests;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->PendingRDataRequests)
|
||
{
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
if (pSend->pSender->TimerTickCount >= pRDataContext->EarliestRDataSendTime)
|
||
{
|
||
pRDataToSend = pRDataContext;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (pRDataToSend)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "DelayedSendNextPacket",
|
||
"Send RData[%d] -- TC=[%d:%d], BS=<%d>, MTU=<%d>\n",
|
||
pRDataContext->RDataSequenceNumber, pSend->pSender->TimerTickCount,
|
||
pSend->pSender->CurrentBytesSendable, pSend->pSender->pAddress->OutIfMTU);
|
||
|
||
PgmSendRData (pSend, pRDataToSend, &OldIrq, &BytesSent);
|
||
}
|
||
else if (!pSend->pSender->NumODataRequestsPending)
|
||
{
|
||
//
|
||
// Since we don't have any OData pending, send the next RData anyway!
|
||
//
|
||
pRDataToSend = CONTAINING_RECORD (pSend->pSender->PendingRDataRequests.Flink, tSEND_RDATA_CONTEXT, Linkage);
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "DelayedSendNextPacket",
|
||
"No OData! Send RData[%d] -- TC=[%d:%d], BS=<%d>, MTU=<%d>\n",
|
||
pRDataContext->RDataSequenceNumber, pSend->pSender->TimerTickCount,
|
||
pSend->pSender->CurrentBytesSendable, pSend->pSender->pAddress->OutIfMTU);
|
||
|
||
PgmSendRData (pSend, pRDataToSend, &OldIrq, &BytesSent);
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// We will not attempt to send any more RData at this time
|
||
//
|
||
fSendRData = FALSE;
|
||
}
|
||
}
|
||
|
||
if ((!pRDataToSend) &&
|
||
pSend->pSender->NumODataRequestsPending)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "DelayedSendNextPacket",
|
||
"Send OData -- TC=[%d:%d], BS=<%d>, MTU=<%d>\n",
|
||
pSend->pSender->TimerTickCount, pSend->pSender->CurrentBytesSendable,
|
||
pSend->pSender->pAddress->OutIfMTU);
|
||
|
||
//
|
||
// Send OData
|
||
//
|
||
PgmSendNextOData (pSend, &OldIrq, &BytesSent);
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "DelayedSendNextPacket",
|
||
"Sent <%d> Data bytes\n", BytesSent);
|
||
|
||
if (BytesSent == 0)
|
||
{
|
||
//
|
||
// We may not have enough buffer space to packetize and send
|
||
// more data, or we have no data to send at this time, so just
|
||
// break out and see if we can advance the trailing window!
|
||
//
|
||
if (pSend->pSender->CurrentBytesSendable >
|
||
(NUM_LEAKY_BUCKETS * pSend->pSender->IncrementBytesOnSendTimeout))
|
||
{
|
||
pSend->pSender->CurrentBytesSendable = NUM_LEAKY_BUCKETS *
|
||
pSend->pSender->IncrementBytesOnSendTimeout;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
pSend->SessionFlags |= PGM_SESSION_FLAG_SEND_AMBIENT_SPM;
|
||
pSend->pSender->PacketsSentSinceLastSpm++;
|
||
}
|
||
|
||
//
|
||
// We do not have any more packets to send, so reset
|
||
// BytesSendable so that we don't exceed the rate on
|
||
// the next send
|
||
//
|
||
else
|
||
{
|
||
if (pSend->pSender->CurrentBytesSendable >
|
||
(NUM_LEAKY_BUCKETS * pSend->pSender->IncrementBytesOnSendTimeout))
|
||
{
|
||
pSend->pSender->CurrentBytesSendable = NUM_LEAKY_BUCKETS *
|
||
pSend->pSender->IncrementBytesOnSendTimeout;
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
pSend->TotalBytes += BytesSent;
|
||
pSend->pSender->CurrentBytesSendable -= BytesSent;
|
||
} // while (CurrentBytesSendable >= pSend->pSender->pAddress->OutIfMTU)
|
||
|
||
//
|
||
// See if we need to scavenge completed RData requests
|
||
//
|
||
pEntry = &pSend->pSender->HandledRDataRequests;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->HandledRDataRequests)
|
||
{
|
||
pRDataContext = CONTAINING_RECORD (pEntry, tSEND_RDATA_CONTEXT, Linkage);
|
||
if ((pRDataContext->CleanupTime) &&
|
||
(pSend->pSender->TimerTickCount > pRDataContext->CleanupTime))
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "DelayedSendNextPacket",
|
||
"Removing lingering RData for SeqNum=<%d>\n", (ULONG) pRDataContext->RDataSequenceNumber);
|
||
|
||
pEntry = pEntry->Blink; // Set this because this pEntry will not be valid any more!
|
||
RemoveEntryList (&pRDataContext->Linkage);
|
||
PgmFreeMem (pRDataContext);
|
||
}
|
||
}
|
||
|
||
//
|
||
// See if we need to increment the Trailing Window -- returns number of Sequences advanced
|
||
//
|
||
NumSequences = AdvanceWindow (pSend);
|
||
|
||
//
|
||
// Now check if we need to terminate this session
|
||
//
|
||
fTerminateSession = CheckForTermination (pSend, &OldIrq);
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "DelayedSendNextPacket",
|
||
"Sent <%d> total bytes, fTerminateSession=<%x>\n", pSend->TotalBytes, fTerminateSession);
|
||
|
||
//
|
||
// Clear the WorkerRunning flag so that the next Worker
|
||
// routine can be queued
|
||
//
|
||
pSend->SessionFlags &= ~PGM_SESSION_FLAG_WORKER_RUNNING;
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
return (fTerminateSession);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
SendSessionTimeout(
|
||
IN PKDPC Dpc,
|
||
IN PVOID DeferredContext,
|
||
IN PVOID SystemArg1,
|
||
IN PVOID SystemArg2
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is the timout that gets called every BASIC_TIMER_GRANULARITY_IN_MSECS
|
||
to schedule the next Send request
|
||
|
||
Arguments:
|
||
|
||
IN Dpc
|
||
IN DeferredContext -- Our context for this timer
|
||
IN SystemArg1
|
||
IN SystemArg2
|
||
|
||
Return Value:
|
||
|
||
NONE
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
tADDRESS_CONTEXT *pAddress;
|
||
PGMLockHandle OldIrq;
|
||
tSEND_SESSION *pSend = (tSEND_SESSION *) DeferredContext;
|
||
LARGE_INTEGER Now, Frequency;
|
||
LARGE_INTEGER DeltaTime, GranularTimeElapsed, TimeoutGranularity;
|
||
ULONG NumTimeouts;
|
||
SEQ_TYPE NumSequencesInWindow;
|
||
|
||
Now = KeQueryPerformanceCounter (&Frequency);
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
|
||
//
|
||
// First check if we have been told to stop the timer
|
||
//
|
||
if (pSend->SessionFlags & PGM_SESSION_FLAG_STOP_TIMER)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_SEND, "SendSessionTimeout",
|
||
"Session has terminated -- will deref and not restart timer!\n");
|
||
|
||
//
|
||
// Deref for the timer reference
|
||
//
|
||
pAddress = pSend->pSender->pAddress;
|
||
pSend->pSender->pAddress = NULL;
|
||
PgmUnlock (pSend, OldIrq);
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_TIMER_RUNNING);
|
||
PGM_DEREFERENCE_ADDRESS (pAddress, REF_ADDRESS_SEND_IN_PROGRESS);
|
||
return;
|
||
}
|
||
|
||
DeltaTime.QuadPart = Now.QuadPart - pSend->pSender->LastTimeout.QuadPart;
|
||
TimeoutGranularity.QuadPart = pSend->pSender->TimeoutGranularity.QuadPart;
|
||
for (GranularTimeElapsed.QuadPart = 0, NumTimeouts = 0;
|
||
DeltaTime.QuadPart > TimeoutGranularity.QuadPart;
|
||
NumTimeouts++)
|
||
{
|
||
GranularTimeElapsed.QuadPart += TimeoutGranularity.QuadPart;
|
||
DeltaTime.QuadPart -= TimeoutGranularity.QuadPart;
|
||
}
|
||
|
||
if (NumTimeouts)
|
||
{
|
||
pSend->RateCalcTimeout += NumTimeouts;
|
||
if (pSend->RateCalcTimeout >=
|
||
(INTERNAL_RATE_CALCULATION_FREQUENCY/BASIC_TIMER_GRANULARITY_IN_MSECS))
|
||
{
|
||
pSend->RateKBitsPerSecOverall = (pSend->TotalBytes << LOG2_BITS_PER_BYTE) /
|
||
(pSend->pSender->TimerTickCount * BASIC_TIMER_GRANULARITY_IN_MSECS);
|
||
|
||
pSend->RateKBitsPerSecLast = (pSend->TotalBytes - pSend->TotalBytesAtLastInterval) >>
|
||
(LOG2_INTERNAL_RATE_CALCULATION_FREQUENCY - LOG2_BITS_PER_BYTE);
|
||
|
||
pSend->DataBytesAtLastInterval = pSend->DataBytes;
|
||
pSend->TotalBytesAtLastInterval = pSend->TotalBytes;
|
||
pSend->RateCalcTimeout = 0;
|
||
}
|
||
|
||
pSend->pSender->LastTimeout.QuadPart += GranularTimeElapsed.QuadPart;
|
||
|
||
//
|
||
// Increment the absolute timer, and check for overflow
|
||
//
|
||
pSend->pSender->TimerTickCount += NumTimeouts;
|
||
|
||
//
|
||
// If the SPMTimeout value is less than the HeartbeatTimeout, increment it
|
||
//
|
||
if (pSend->pSender->CurrentSPMTimeout <= pSend->pSender->HeartbeatSPMTimeout)
|
||
{
|
||
pSend->pSender->CurrentSPMTimeout += NumTimeouts;
|
||
}
|
||
|
||
//
|
||
// See if we can send anything
|
||
//
|
||
ASSERT (pSend->pSender->CurrentTimeoutCount);
|
||
ASSERT (pSend->pSender->SendTimeoutCount);
|
||
if (pSend->pSender->CurrentTimeoutCount > NumTimeouts)
|
||
{
|
||
pSend->pSender->CurrentTimeoutCount -= NumTimeouts;
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// We got here because NumTimeouts >= pSend->pSender->CurrentTimeoutCount
|
||
//
|
||
pSend->pSender->CurrentBytesSendable += (ULONG) pSend->pSender->IncrementBytesOnSendTimeout;
|
||
if (NumTimeouts != pSend->pSender->CurrentTimeoutCount)
|
||
{
|
||
if (1 == pSend->pSender->SendTimeoutCount)
|
||
{
|
||
pSend->pSender->CurrentBytesSendable += (ULONG) ((NumTimeouts - pSend->pSender->CurrentTimeoutCount)
|
||
* pSend->pSender->IncrementBytesOnSendTimeout);
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// This path will get taken on a slow receiver when the timer
|
||
// fires at a lower granularity than that requested
|
||
//
|
||
pSend->pSender->CurrentBytesSendable += (ULONG) (((NumTimeouts - pSend->pSender->CurrentTimeoutCount)
|
||
* pSend->pSender->IncrementBytesOnSendTimeout) /
|
||
pSend->pSender->SendTimeoutCount);
|
||
}
|
||
}
|
||
pSend->pSender->CurrentTimeoutCount = pSend->pSender->SendTimeoutCount;
|
||
|
||
//
|
||
// Send a synchronization event to the sender thread to
|
||
// send the next available data
|
||
//
|
||
KeSetEvent (&pSend->pSender->SendEvent, 0, FALSE);
|
||
}
|
||
}
|
||
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
//
|
||
// Now, restart the timer
|
||
//
|
||
PgmInitTimer (&pSend->SessionTimer);
|
||
PgmStartTimer (&pSend->SessionTimer, BASIC_TIMER_GRANULARITY_IN_MSECS, SendSessionTimeout, pSend);
|
||
|
||
PgmLog (PGM_LOG_INFORM_ALL_FUNCS, DBG_SEND, "SendSessionTimeout",
|
||
"TickCount=<%d:%d>, CurrentTimeoutCount=<%d:%d>, CurrentSPMTimeout=<%d:%d>, Worker %srunning\n",
|
||
pSend->pSender->TimerTickCount, pSend->pSender->CurrentTimeoutCount,
|
||
pSend->pSender->CurrentSPMTimeout,
|
||
((pSend->SessionFlags & PGM_SESSION_FLAG_WORKER_RUNNING) ? "" : "NOT "));
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
SenderWorkerThread(
|
||
IN tSEND_SESSION *pSend
|
||
)
|
||
{
|
||
BOOLEAN fTerminateSends;
|
||
PGMLockHandle OldIrq;
|
||
NTSTATUS status;
|
||
|
||
do
|
||
{
|
||
status = KeWaitForSingleObject (&pSend->pSender->SendEvent, // Object to wait on.
|
||
Executive, // Reason for waiting
|
||
KernelMode, // Processor mode
|
||
FALSE, // Alertable
|
||
NULL); // Timeout
|
||
ASSERT (NT_SUCCESS (status));
|
||
|
||
fTerminateSends = SendNextPacket (pSend);
|
||
}
|
||
while (!fTerminateSends);
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
pSend->SessionFlags |= PGM_SESSION_FLAG_STOP_TIMER; // To ensure timer does last deref and stops
|
||
PgmUnlock (pSend, OldIrq);
|
||
|
||
// PsTerminateSystemThread (STATUS_SUCCESS);
|
||
return;
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
VOID
|
||
PgmCancelSendIrp(
|
||
IN PDEVICE_OBJECT DeviceContext,
|
||
IN PIRP pIrp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine handles the cancelling of a Send Irp. It must release the
|
||
cancel spin lock before returning re: IoCancelIrp().
|
||
|
||
Arguments:
|
||
|
||
|
||
Return Value:
|
||
|
||
None
|
||
|
||
--*/
|
||
{
|
||
PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation (pIrp);
|
||
tSEND_SESSION *pSend = (tSEND_SESSION *) pIrpSp->FileObject->FsContext;
|
||
PGMLockHandle OldIrq;
|
||
PLIST_ENTRY pEntry;
|
||
LIST_ENTRY ListEntry;
|
||
tCLIENT_SEND_REQUEST *pSendContext1;
|
||
tCLIENT_SEND_REQUEST *pSendContext2 = NULL;
|
||
ULONG NumRequests;
|
||
|
||
if (!PGM_VERIFY_HANDLE (pSend, PGM_VERIFY_SESSION_SEND))
|
||
{
|
||
IoReleaseCancelSpinLock (pIrp->CancelIrql);
|
||
|
||
PgmLog (PGM_LOG_ERROR, (DBG_SEND | DBG_ADDRESS | DBG_CONNECT), "PgmCancelSendIrp",
|
||
"pIrp=<%p> pSend=<%p>, pAddress=<%p>\n", pIrp, pSend, pSend->pAssociatedAddress);
|
||
return;
|
||
}
|
||
|
||
PgmLock (pSend, OldIrq);
|
||
|
||
//
|
||
// First, see if the Irp is on any of our lists
|
||
//
|
||
pEntry = &pSend->pSender->PendingSends;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->PendingSends)
|
||
{
|
||
pSendContext1 = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
if (pSendContext1->pIrp == pIrp)
|
||
{
|
||
pSendContext2 = pSendContext1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!pSendContext2)
|
||
{
|
||
//
|
||
// Now, search the packetized list
|
||
//
|
||
pEntry = &pSend->pSender->PendingPacketizedSends;
|
||
while ((pEntry = pEntry->Flink) != &pSend->pSender->PendingPacketizedSends)
|
||
{
|
||
pSendContext1 = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
if (pSendContext1->pIrp == pIrp)
|
||
{
|
||
pSendContext2 = pSendContext1;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!pSendContext2)
|
||
{
|
||
//
|
||
// We did not find the irp -- either it was just being completed
|
||
// (or waiting for a send-complete), or the Irp was bad ?
|
||
//
|
||
PgmUnlock (pSend, OldIrq);
|
||
IoReleaseCancelSpinLock (pIrp->CancelIrql);
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_CONNECT, "PgmCancelSendIrp",
|
||
"Did not find Cancel Irp=<%p>\n", pIrp);
|
||
|
||
return;
|
||
}
|
||
}
|
||
|
||
InitializeListHead (&ListEntry);
|
||
PgmCancelAllSends (pSend, &ListEntry, pIrp);
|
||
|
||
PgmUnlock (pSend, OldIrq);
|
||
IoReleaseCancelSpinLock (pIrp->CancelIrql);
|
||
|
||
//
|
||
// Now, complete all the sends which we removed
|
||
//
|
||
NumRequests = 0;
|
||
while (!IsListEmpty (&ListEntry))
|
||
{
|
||
pEntry = RemoveHeadList (&ListEntry);
|
||
pSendContext1 = CONTAINING_RECORD (pEntry, tCLIENT_SEND_REQUEST, Linkage);
|
||
ASSERT (!pSendContext1->pMessage2Request);
|
||
|
||
if (pSendContext1->pIrpToComplete)
|
||
{
|
||
NumRequests++;
|
||
ASSERT (pSendContext1->pIrpToComplete == pSendContext1->pIrp);
|
||
PgmIoComplete (pSendContext1->pIrpToComplete, STATUS_CANCELLED, 0);
|
||
}
|
||
else
|
||
{
|
||
ASSERT (pSendContext1->pIrp);
|
||
}
|
||
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW);
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext1);
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_CONNECT, "PgmCancelSendIrp",
|
||
"Cancelled <%d> Irps for pIrp=<%p>\n", NumRequests, pIrp);
|
||
}
|
||
|
||
|
||
//----------------------------------------------------------------------------
|
||
|
||
NTSTATUS
|
||
PgmSendRequestFromClient(
|
||
IN tPGM_DEVICE *pPgmDevice,
|
||
IN PIRP pIrp,
|
||
IN PIO_STACK_LOCATION pIrpSp
|
||
)
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine is called via dispatch by the client to post a Send pIrp
|
||
|
||
Arguments:
|
||
|
||
IN pPgmDevice -- Pgm's Device object context
|
||
IN pIrp -- Client's request Irp
|
||
IN pIrpSp -- current request's stack pointer
|
||
|
||
Return Value:
|
||
|
||
NTSTATUS - Final status of the request
|
||
|
||
--*/
|
||
{
|
||
NTSTATUS status;
|
||
PGMLockHandle OldIrq1, OldIrq2, OldIrq3, OldIrq4;
|
||
tADDRESS_CONTEXT *pAddress = NULL;
|
||
tCLIENT_SEND_REQUEST *pSendContext1;
|
||
tCLIENT_SEND_REQUEST *pSendContext2 = NULL;
|
||
ULONG BytesLeftInMessage;
|
||
tSEND_SESSION *pSend = (tSEND_SESSION *) pIrpSp->FileObject->FsContext;
|
||
PTDI_REQUEST_KERNEL_SEND pTdiRequest = (PTDI_REQUEST_KERNEL_SEND) &pIrpSp->Parameters;
|
||
KAPC_STATE ApcState;
|
||
BOOLEAN fFirstSend, fResourceAcquired, fAttached;
|
||
LARGE_INTEGER Frequency;
|
||
LIST_ENTRY ListEntry;
|
||
|
||
PgmLock (&PgmDynamicConfig, OldIrq1);
|
||
|
||
//
|
||
// Verify that the connection is valid and is associated with an address
|
||
//
|
||
if ((!PGM_VERIFY_HANDLE (pSend, PGM_VERIFY_SESSION_SEND)) ||
|
||
(!(pAddress = pSend->pAssociatedAddress)) ||
|
||
(!PGM_VERIFY_HANDLE (pAddress, PGM_VERIFY_ADDRESS)) ||
|
||
(pSend->SessionFlags & (PGM_SESSION_CLIENT_DISCONNECTED | PGM_SESSION_SENDS_CANCELLED)) ||
|
||
(pAddress->Flags & PGM_ADDRESS_FLAG_INVALID_OUT_IF))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, (DBG_SEND | DBG_ADDRESS | DBG_CONNECT), "PgmSend",
|
||
"Invalid Handles pSend=<%p>, pAddress=<%p>\n", pSend, pAddress);
|
||
|
||
PgmUnlock (&PgmDynamicConfig, OldIrq1);
|
||
return (STATUS_INVALID_HANDLE);
|
||
}
|
||
|
||
if (!pSend->pSender->DestMCastIpAddress)
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSend",
|
||
"Destination address not specified for pSend=<%p>\n", pSend);
|
||
|
||
PgmUnlock (&PgmDynamicConfig, OldIrq1);
|
||
return (STATUS_INVALID_ADDRESS_COMPONENT);
|
||
}
|
||
|
||
if (!pTdiRequest->SendLength)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_STATUS, DBG_SEND, "PgmSend",
|
||
"pIrp=<%p> for pSend=<%p> is of length 0!\n", pIrp, pSend);
|
||
|
||
PgmUnlock (&PgmDynamicConfig, OldIrq1);
|
||
return (STATUS_SUCCESS);
|
||
}
|
||
|
||
PgmLock (pAddress, OldIrq2);
|
||
PgmLock (pSend, OldIrq3);
|
||
|
||
if (!(pSendContext1 = ExAllocateFromNPagedLookasideList (&pSend->pSender->SendContextLookaside)))
|
||
{
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSend",
|
||
"STATUS_INSUFFICIENT_RESOURCES allocating pSendContext1\n");
|
||
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
|
||
//
|
||
// If we have more that 1 message data in this request,
|
||
// we will need another send context
|
||
//
|
||
if ((pSend->pSender->ThisSendMessageLength) && // Client has specified current message length
|
||
(BytesLeftInMessage = pSend->pSender->ThisSendMessageLength - pSend->pSender->BytesSent) &&
|
||
(BytesLeftInMessage < pTdiRequest->SendLength) && // ==> Have some extra data in this request
|
||
(!(pSendContext2 = ExAllocateFromNPagedLookasideList (&pSend->pSender->SendContextLookaside))))
|
||
{
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext1);
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSend",
|
||
"STATUS_INSUFFICIENT_RESOURCES allocating pSendContext1\n");
|
||
|
||
return (STATUS_INSUFFICIENT_RESOURCES);
|
||
}
|
||
|
||
//
|
||
//
|
||
// Zero the SendDataContext structure(s)
|
||
//
|
||
PgmZeroMemory (pSendContext1, sizeof (tCLIENT_SEND_REQUEST));
|
||
InitializeListHead (&pSendContext1->Linkage);
|
||
if (pSendContext2)
|
||
{
|
||
PgmZeroMemory (pSendContext2, sizeof (tCLIENT_SEND_REQUEST));
|
||
InitializeListHead (&pSendContext2->Linkage);
|
||
}
|
||
|
||
if (pSend->SessionFlags & PGM_SESSION_FLAG_FIRST_PACKET)
|
||
{
|
||
fFirstSend = TRUE;
|
||
}
|
||
else
|
||
{
|
||
fFirstSend = FALSE;
|
||
}
|
||
|
||
//
|
||
// Reference the Address and Connection so that they cannot go away
|
||
// while we are processing!
|
||
//
|
||
PGM_REFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW, TRUE);
|
||
|
||
PgmUnlock (pSend, OldIrq3);
|
||
PgmUnlock (pAddress, OldIrq2);
|
||
PgmUnlock (&PgmDynamicConfig, OldIrq1);
|
||
|
||
if (PgmGetCurrentIrql())
|
||
{
|
||
fResourceAcquired = FALSE;
|
||
}
|
||
else
|
||
{
|
||
fResourceAcquired = TRUE;
|
||
PgmAcquireResourceExclusive (&pSend->pSender->Resource, TRUE);
|
||
}
|
||
|
||
if (fFirstSend)
|
||
{
|
||
//
|
||
// Don't start the timer yet, but start the sender thread
|
||
//
|
||
PgmAttachToProcessForVMAccess (pSend, &ApcState, &fAttached, REF_PROCESS_ATTACH_START_SENDER_THREAD);
|
||
|
||
status = PsCreateSystemThread (&pSend->pSender->SendHandle,
|
||
PROCESS_ALL_ACCESS,
|
||
NULL,
|
||
NULL,
|
||
NULL,
|
||
SenderWorkerThread,
|
||
pSend);
|
||
|
||
if (!NT_SUCCESS (status))
|
||
{
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_START_SENDER_THREAD);
|
||
if (fResourceAcquired)
|
||
{
|
||
PgmReleaseResource (&pSend->pSender->Resource);
|
||
}
|
||
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext1);
|
||
if (pSendContext2)
|
||
{
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext2);
|
||
}
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW);
|
||
|
||
PgmLog (PGM_LOG_ERROR, DBG_SEND, "PgmSend",
|
||
"status=<%x> starting sender thread\n", status);
|
||
|
||
return (status);
|
||
}
|
||
|
||
//
|
||
// Close the handle to the thread so that it goes away when the
|
||
// thread terminates
|
||
//
|
||
ZwClose (pSend->pSender->SendHandle);
|
||
PgmDetachProcess (&ApcState, &fAttached, REF_PROCESS_ATTACH_START_SENDER_THREAD);
|
||
|
||
PgmLock (&PgmDynamicConfig, OldIrq1);
|
||
IoAcquireCancelSpinLock (&OldIrq2);
|
||
PgmLock (pAddress, OldIrq3);
|
||
PgmLock (pSend, OldIrq4);
|
||
|
||
pSend->SessionFlags &= ~PGM_SESSION_FLAG_FIRST_PACKET;
|
||
pSend->pSender->pAddress = pAddress;
|
||
pSend->pSender->LastODataSentSequenceNumber = -1;
|
||
|
||
//
|
||
// Set the SYN flag for the first packet
|
||
//
|
||
pSendContext1->DataOptions |= PGM_OPTION_FLAG_SYN; // First packet only
|
||
pSendContext1->DataOptionsLength += PGM_PACKET_OPT_SYN_LENGTH;
|
||
|
||
PGM_REFERENCE_SESSION_SEND (pSend, REF_SESSION_TIMER_RUNNING, TRUE);
|
||
PGM_REFERENCE_ADDRESS (pAddress, REF_ADDRESS_SEND_IN_PROGRESS, TRUE);
|
||
|
||
//
|
||
// Now, set and start the timer
|
||
//
|
||
pSend->pSender->LastTimeout = KeQueryPerformanceCounter (&Frequency);
|
||
pSend->pSender->TimeoutGranularity.QuadPart = (Frequency.QuadPart * BASIC_TIMER_GRANULARITY_IN_MSECS) / 1000;
|
||
pSend->pSender->TimerTickCount = 1;
|
||
PgmInitTimer (&pSend->SessionTimer);
|
||
PgmStartTimer (&pSend->SessionTimer, BASIC_TIMER_GRANULARITY_IN_MSECS, SendSessionTimeout, pSend);
|
||
}
|
||
else
|
||
{
|
||
PgmLock (&PgmDynamicConfig, OldIrq1);
|
||
IoAcquireCancelSpinLock (&OldIrq2);
|
||
PgmLock (pAddress, OldIrq3);
|
||
PgmLock (pSend, OldIrq4);
|
||
}
|
||
|
||
pSendContext1->pSend = pSend;
|
||
pSendContext1->pIrp = pIrp;
|
||
pSendContext1->pIrpToComplete = pIrp;
|
||
pSendContext1->NextDataOffsetInMdl = 0;
|
||
pSendContext1->SendNumber = pSend->pSender->NextSendNumber++;
|
||
pSendContext1->DataPayloadSize = pSend->pSender->MaxPayloadSize;
|
||
pSendContext1->DataOptions |= pSend->pSender->DataOptions; // Attach options common for every send
|
||
pSendContext1->DataOptionsLength += pSend->pSender->DataOptionsLength;
|
||
pSendContext1->pLastMessageVariableTGPacket = (PVOID) -1; // FEC-specific
|
||
|
||
if (pSend->pSender->ThisSendMessageLength)
|
||
{
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmSend",
|
||
"Send # [%d]: MessageLength=<%d>, BytesSent=<%d>, BytesInSend=<%d>\n",
|
||
pSendContext1->SendNumber, pSend->pSender->ThisSendMessageLength,
|
||
pSend->pSender->BytesSent, pTdiRequest->SendLength);
|
||
|
||
pSendContext1->ThisMessageLength = pSend->pSender->ThisSendMessageLength;
|
||
pSendContext1->LastMessageOffset = pSend->pSender->BytesSent;
|
||
if (pSendContext2)
|
||
{
|
||
//
|
||
// First, set the parameters for SendDataContext1
|
||
//
|
||
pSendContext1->BytesInSend = BytesLeftInMessage;
|
||
pSendContext1->pIrpToComplete = NULL; // This Irp will be completed by the Context2
|
||
|
||
//
|
||
// Now, set the parameters for SendDataContext1
|
||
//
|
||
pSendContext2->pSend = pSend;
|
||
pSendContext2->pIrp = pIrp;
|
||
pSendContext2->pIrpToComplete = pIrp;
|
||
pSendContext2->SendNumber = pSend->pSender->NextSendNumber++;
|
||
pSendContext2->DataPayloadSize = pSend->pSender->MaxPayloadSize;
|
||
pSendContext2->DataOptions |= pSend->pSender->DataOptions; // Attach options common for every send
|
||
pSendContext2->DataOptionsLength += pSend->pSender->DataOptionsLength;
|
||
pSendContext2->pLastMessageVariableTGPacket = (PVOID) -1; // FEC-specific
|
||
|
||
pSendContext2->ThisMessageLength = pTdiRequest->SendLength - BytesLeftInMessage;
|
||
pSendContext2->BytesInSend = pSendContext2->ThisMessageLength;
|
||
pSendContext2->NextDataOffsetInMdl = BytesLeftInMessage;
|
||
}
|
||
else
|
||
{
|
||
pSendContext1->BytesInSend = pTdiRequest->SendLength;
|
||
}
|
||
|
||
pSend->pSender->BytesSent += pSendContext1->BytesInSend;
|
||
if (pSend->pSender->BytesSent == pSend->pSender->ThisSendMessageLength)
|
||
{
|
||
pSend->pSender->BytesSent = pSend->pSender->ThisSendMessageLength = 0;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
pSendContext1->ThisMessageLength = pTdiRequest->SendLength;
|
||
pSendContext1->BytesInSend = pTdiRequest->SendLength;
|
||
}
|
||
|
||
// If the total Message length exceeds that of PayloadSize/Packet, then we need to fragment
|
||
if ((pSendContext1->ThisMessageLength > pSendContext1->DataPayloadSize) ||
|
||
(pSendContext1->ThisMessageLength > pSendContext1->BytesInSend))
|
||
{
|
||
pSendContext1->DataOptions |= PGM_OPTION_FLAG_FRAGMENT;
|
||
pSendContext1->DataOptionsLength += PGM_PACKET_OPT_FRAGMENT_LENGTH;
|
||
|
||
pSendContext1->NumPacketsRemaining = (pSendContext1->BytesInSend +
|
||
(pSend->pSender->MaxPayloadSize - 1)) /
|
||
pSend->pSender->MaxPayloadSize;
|
||
ASSERT (pSendContext1->NumPacketsRemaining >= 1);
|
||
}
|
||
else
|
||
{
|
||
pSendContext1->NumPacketsRemaining = 1;
|
||
}
|
||
pSend->pSender->NumPacketsRemaining += pSendContext1->NumPacketsRemaining;
|
||
|
||
// Adjust the OptionsLength for the Packet Extension and determine
|
||
if (pSendContext1->DataOptions)
|
||
{
|
||
pSendContext1->DataOptionsLength += PGM_PACKET_EXTENSION_LENGTH;
|
||
}
|
||
|
||
pSendContext1->BytesLeftToPacketize = pSendContext1->BytesInSend;
|
||
InsertTailList (&pSend->pSender->PendingSends, &pSendContext1->Linkage);
|
||
pSend->pSender->NumODataRequestsPending++;
|
||
|
||
//
|
||
// Do the same for Context2, if applicable
|
||
if (pSendContext2)
|
||
{
|
||
//
|
||
// Interlink the 2 Send requests
|
||
//
|
||
pSendContext2->pMessage2Request = pSendContext1;
|
||
pSendContext1->pMessage2Request = pSendContext2;
|
||
|
||
PGM_REFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW, TRUE);
|
||
|
||
if (pSendContext2->ThisMessageLength > pSendContext1->DataPayloadSize)
|
||
{
|
||
pSendContext2->DataOptions |= PGM_OPTION_FLAG_FRAGMENT;
|
||
pSendContext2->DataOptionsLength += PGM_PACKET_OPT_FRAGMENT_LENGTH;
|
||
|
||
pSendContext2->NumPacketsRemaining = (pSendContext2->BytesInSend +
|
||
(pSend->pSender->MaxPayloadSize - 1)) /
|
||
pSend->pSender->MaxPayloadSize;
|
||
ASSERT (pSendContext2->NumPacketsRemaining >= 1);
|
||
}
|
||
else
|
||
{
|
||
pSendContext2->NumPacketsRemaining = 1;
|
||
}
|
||
pSend->pSender->NumPacketsRemaining += pSendContext2->NumPacketsRemaining;
|
||
|
||
// Adjust the OptionsLength for the Packet Extension and determine
|
||
if (pSendContext2->DataOptions)
|
||
{
|
||
pSendContext2->DataOptionsLength += PGM_PACKET_EXTENSION_LENGTH;
|
||
}
|
||
|
||
pSendContext2->BytesLeftToPacketize = pSendContext2->BytesInSend;
|
||
InsertTailList (&pSend->pSender->PendingSends, &pSendContext2->Linkage);
|
||
pSend->pSender->NumODataRequestsPending++;
|
||
}
|
||
|
||
if (!NT_SUCCESS (PgmCheckSetCancelRoutine (pIrp, PgmCancelSendIrp, TRUE)))
|
||
{
|
||
pSend->SessionFlags |= PGM_SESSION_SENDS_CANCELLED;
|
||
|
||
pSend->pSender->NumODataRequestsPending--;
|
||
pSend->pSender->NumPacketsRemaining -= pSendContext1->NumPacketsRemaining;
|
||
RemoveEntryList (&pSendContext1->Linkage);
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext1);
|
||
|
||
if (pSendContext2)
|
||
{
|
||
pSend->pSender->NumODataRequestsPending--;
|
||
pSend->pSender->NumPacketsRemaining -= pSendContext2->NumPacketsRemaining;
|
||
RemoveEntryList (&pSendContext2->Linkage);
|
||
ExFreeToNPagedLookasideList (&pSend->pSender->SendContextLookaside, pSendContext2);
|
||
}
|
||
|
||
PgmUnlock (pSend, OldIrq4);
|
||
PgmUnlock (pAddress, OldIrq3);
|
||
IoReleaseCancelSpinLock (OldIrq2);
|
||
PgmUnlock (&PgmDynamicConfig, OldIrq1);
|
||
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW);
|
||
if (pSendContext2)
|
||
{
|
||
PGM_DEREFERENCE_SESSION_SEND (pSend, REF_SESSION_SEND_IN_WINDOW);
|
||
}
|
||
|
||
PgmLog (PGM_LOG_ERROR, (DBG_RECEIVE | DBG_ADDRESS | DBG_CONNECT), "PgmReceive",
|
||
"Could not set Cancel routine on Send Irp=<%p>, pSend=<%p>, pAddress=<%p>\n",
|
||
pIrp, pSend, pAddress);
|
||
|
||
return (STATUS_CANCELLED);
|
||
}
|
||
|
||
IoReleaseCancelSpinLock (OldIrq4);
|
||
|
||
PgmUnlock (pAddress, OldIrq3);
|
||
PgmUnlock (&PgmDynamicConfig, OldIrq2);
|
||
|
||
if (fResourceAcquired)
|
||
{
|
||
// PgmPrepareNextSend (pSend, &OldIrq1, TRUE, TRUE);
|
||
}
|
||
|
||
if (pSend->pSender->CurrentBytesSendable >= pAddress->OutIfMTU)
|
||
{
|
||
//
|
||
// Send a synchronization event to the sender thread to
|
||
// send the next available data
|
||
//
|
||
KeSetEvent (&pSend->pSender->SendEvent, 0, FALSE);
|
||
}
|
||
|
||
PgmUnlock (pSend, OldIrq1);
|
||
|
||
if (fResourceAcquired)
|
||
{
|
||
PgmReleaseResource (&pSend->pSender->Resource);
|
||
}
|
||
|
||
PgmLog (PGM_LOG_INFORM_PATH, DBG_SEND, "PgmSend",
|
||
"[%d] Send pending for pIrp=<%p>, pSendContext=<%p -- %p>\n",
|
||
pSendContext1->SendNumber, pIrp, pSendContext1, pSendContext2);
|
||
|
||
return (STATUS_PENDING);
|
||
}
|
||
|
||
|