/*++ Copyright (c) 1996-1999 Microsoft Corporation Module Name: DRRSeq.c Abstract: Priority/DRR Sequencer. This module is a scheduling component that determines the order in which submitted packets should be sent. Author: Environment: Kernel Mode Revision History: --*/ #include "psched.h" #pragma hdrstop // The sequencer classifies each flow into an internal "priority group" based // on the flow's service type and conformance status. Within each priority // group, there may be one or more priority levels or offsets. The total // number of internal priority levels is the sum of the priority levels for // each priority group. The internal priority assigned to each flow is // calculated from the priority group and the relative priority within the // group, which is obtained from the QOS Priority object. The 802.1 priority, // is set by the wrapper. The non conforming values are obtained from the // packet. // // The flows of the following servicetypes have no internal priority. // SERVICETYPE_BESTEFFORT // SERVICETYPE_NONCONFORMING // SERVICETYPE_QUALITATIVE. // // SERVICETYPE_BESTEFFORT is treated as SERVICETYPE_QUALITATIVE in the sequencer, so the no of priority // groups is 1 less than the no. of servicetypes. #define RELATIVE_PRIORITIES 8 #define PRIORITY_GROUPS (NUM_TC_SERVICETYPES - 1) #define INTERNAL_PRIORITIES (((PRIORITY_GROUPS - 2) * RELATIVE_PRIORITIES) + 2) #define DEFAULT_PRIORITY_OFFSET 3 #define DEFAULT_MIN_QUANTUM 1500 #define PRIORITY_GROUP_NON_CONFORMING 0 #define PRIORITY_GROUP_BEST_EFFORT 1 #define PRIORITY_GROUP_CONTROLLED_LOAD 2 #define PRIORITY_GROUP_GUARANTEED 3 #define PRIORITY_GROUP_NETWORK_CONTROL 4 // // For maintaining stats // #define SEQUENCER_AVERAGING_ARRAY_SIZE 256 #define NETCARD_AVERAGING_ARRAY_SIZE 256 #define SEQUENCER_FLOW_AVERAGING_ARRAY_SIZE 256 // The DRR Sequencer's pipe information typedef struct _DSEQ_PIPE { // ContextInfo - Generic context info // Lock - Protects pipe and flow data // Flags - See below // Flows - List of all installed flows // ActiveFlows - Lists of flows that are waiting to send packets // PriorityLevels - Number of priority offsets for each priority group // StartPriority - Lowest internal priority value for each priority group // ActiveFlowCount - Number of active flows for each service type // MaxOutstandingSends - Maximum number of outstanding sends // OutstandingSends - Number of outstanding sends // PacketsInNetcardAveragingArray // PacketsInSequencer - Current number packets in sequencer // PacketsInSequencerAveragingArray // Bandwidth - Link speed // MinimumQuantum - Minimum quantum size for DRR // MinimumRate - Smallest rate currently assigned to a flow // TimerResolution - Timer resolution in OS time units // PsFlags - Flags from pipe parameters // PsPipeContext - PS's pipe context value PS_PIPE_CONTEXT ContextInfo; PS_DRRSEQ_STATS Stats; PRUNNING_AVERAGE PacketsInNetcardAveragingArray; ULONG PacketsInSequencer; PRUNNING_AVERAGE PacketsInSequencerAveragingArray; NDIS_SPIN_LOCK Lock; ULONG Flags; LIST_ENTRY Flows; LIST_ENTRY ActiveFlows[INTERNAL_PRIORITIES]; ULONG PriorityLevels[PRIORITY_GROUPS]; ULONG StartPriority[PRIORITY_GROUPS]; ULONG ActiveFlowCount[PRIORITY_GROUPS]; ULONG TotalActiveFlows; ULONG MaxOutstandingSends; ULONG ConfiguredMaxOutstandingSends; // This is added to keep track of what the Registry/User-asked value of MOS is, while we might // have changed MOS to be able to do DRR on this Pipe/WanLink. When we switch back from DRR mode // with MOS=1, we'll use this going forward. ULONG IsslowFlowCount; // This is added to keep track of the number of active/current ISSLOW flows. We will do DRR on this // WanLink (if it is a WanLink) only if this count is 0. ULONG OutstandingSends; ULONG Bandwidth; ULONG MinimumQuantum; ULONG MinimumRate; ULONG TimerResolution; ULONG PsFlags; HANDLE PsPipeContext; PPS_PROCS PsProcs; PSU_SEND_COMPLETE PreviousUpcallsSendComplete; PPS_PIPE_CONTEXT PreviousUpcallsSendCompletePipeContext; } DSEQ_PIPE, *PDSEQ_PIPE; // Pipe flag values #define DSEQ_DEQUEUE 1 #define DSEQ_PASSTHRU 2 typedef enum _FLOW_STATE { DRRSEQ_FLOW_CREATED = 1, DRRSEQ_FLOW_DELETED } FLOW_STATE; // The DRR Sequencer's flow information typedef struct _DSEQ_FLOW { // ContextInfo - Generic context info // ActiveLinks - Links in active flow list // Links - Links in installed flow list // PacketQueue - Self-explanatory // PacketSendTime - Send time for current packet // LastConformanceTime - Absolute conformance time of last packet // TokenRate - TokenRate from GQOS // UserPriority - Priority offset assigned by user // Priority - Internal priority // PriorityGroup - Priority group for flow // Quantum - Quantum assigned to flow for DRR // DeficitCounter - Current value of DRR deficit counter // Flags - See below // PsFlowContext - PS's flow context value // BucketSize - TokenBucketSize from GQOS // NumPacketsInSeq - Number of packets from this flow in the sequencer // PacketsInSeqAveragingArray-Data for computing average packets in seq from this flow PS_FLOW_CONTEXT ContextInfo; LIST_ENTRY ActiveLinks; LIST_ENTRY Links; LIST_ENTRY PacketQueue; LARGE_INTEGER PacketSendTime; LARGE_INTEGER LastConformanceTime; ULONG TokenRate; ULONG UserPriority; ULONG Priority; ULONG PriorityGroup; ULONG Quantum; ULONG DeficitCounter; ULONG Flags; HANDLE PsFlowContext; ULONG BucketSize; ULONG PacketsInSequencer; PS_DRRSEQ_STATS Stats; PRUNNING_AVERAGE PacketsInSeqAveragingArray; FLOW_STATE State; } DSEQ_FLOW, *PDSEQ_FLOW; #define MAX_DEQUEUED_PACKETS 8 // // Values for Drr Seq Flow flags: [ Don't know why 1 was not used here] #define FLOW_USER_PRIORITY 0x00000002 // GPC_ISSLOW_FLOW 0x00000040 Indicates that this is an ISSLOW flow. // Make sure not to use the same flag for something else. // The following macro checks a packet for conformance based on the flow's // LastPacketTime, the current time, and the timer resolution. #define PacketIsConforming(_flow, _packetinfo, _curtime, _r) \ ( (_flow)->PacketSendTime.QuadPart <= ((_curtime).QuadPart + (_r)) && \ (_packetinfo)->PacketLength <= (_flow)->BucketSize \ ) #define AdjustLastPacketTime(_flow, _curtime, _r) \ if ((_curtime).QuadPart > ((_flow)->PacketSendTime.QuadPart + (_r))) \ if ((_curtime).QuadPart > ((_flow)->LastConformanceTime.QuadPart - (_r))) \ (_flow)->PacketSendTime = (_flow)->LastConformanceTime; \ else \ (_flow)->PacketSendTime = (_curtime); #define LOCK_PIPE(_p) NdisAcquireSpinLock(&(_p)->Lock) #define UNLOCK_PIPE(_p) NdisReleaseSpinLock(&(_p)->Lock) /* External */ /* Static */ /* Forward */ NDIS_STATUS DrrSeqInitializePipe ( IN HANDLE PsPipeContext, IN PPS_PIPE_PARAMETERS PipeParameters, IN PPS_PIPE_CONTEXT ComponentPipeContext, IN PPS_PROCS PsProcs, IN PPS_UPCALLS Upcalls ); NDIS_STATUS DrrSeqModifyPipe ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_PIPE_PARAMETERS PipeParameters ); VOID DrrSeqDeletePipe ( IN PPS_PIPE_CONTEXT PipeContext ); NDIS_STATUS DrrSeqCreateFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN HANDLE PsFlowContext, IN PCO_CALL_PARAMETERS CallParameters, IN PPS_FLOW_CONTEXT ComponentFlowContext ); NDIS_STATUS DrrSeqModifyFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext, IN PCO_CALL_PARAMETERS CallParameters ); VOID DrrSeqDeleteFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext ); VOID DrrSeqEmptyFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext ); static NDIS_STATUS DrrSeqCreateClassMap ( IN PPS_PIPE_CONTEXT PipeContext, IN HANDLE PsClassMapContext, IN PTC_CLASS_MAP_FLOW ClassMap, IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext ); static NDIS_STATUS DrrSeqDeleteClassMap ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext ); BOOLEAN DrrSeqSubmitPacket ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext, IN PPS_CLASS_MAP_CONTEXT ClassMapContext, IN PPACKET_INFO_BLOCK PacketInfo ); VOID DrrSeqSendComplete ( IN PPS_PIPE_CONTEXT PipeContext, IN PNDIS_PACKET Packet ); VOID DrrSetInformation( IN PPS_PIPE_CONTEXT ComponentPipeContext, IN PPS_FLOW_CONTEXT ComponentFlowContext, IN NDIS_OID Oid, IN ULONG Len, IN PVOID Data); VOID DrrQueryInformation ( IN PPS_PIPE_CONTEXT ComponentPipeContext, IN PPS_FLOW_CONTEXT ComponentFlowContext, IN NDIS_OID Oid, IN ULONG Len, IN PVOID Data, IN OUT PULONG BytesWritten, IN OUT PULONG BytesNeeded, IN OUT PNDIS_STATUS Status); VOID DrrSeqSendComplete ( IN PPS_PIPE_CONTEXT PipeContext, IN PNDIS_PACKET Packet ); /* End Forward */ VOID InitializeDrrSequencer( PPSI_INFO Info) /*++ Routine Description: Initialization routine for the DRR sequencer. This routine just fills in the PSI_INFO struct and returns. Arguments: Info - Pointer to component interface info struct Return Values: NDIS_STATUS_SUCCESS --*/ { Info->PipeContextLength = ((sizeof(DSEQ_PIPE) + 7) & ~7); Info->FlowContextLength = ((sizeof(DSEQ_FLOW) + 7) & ~7); Info->ClassMapContextLength = sizeof(PS_CLASS_MAP_CONTEXT); Info->InitializePipe = DrrSeqInitializePipe; Info->ModifyPipe = DrrSeqModifyPipe; Info->DeletePipe = DrrSeqDeletePipe; Info->CreateFlow = DrrSeqCreateFlow; Info->ModifyFlow = DrrSeqModifyFlow; Info->DeleteFlow = DrrSeqDeleteFlow; Info->EmptyFlow = DrrSeqEmptyFlow; Info->CreateClassMap = DrrSeqCreateClassMap; Info->DeleteClassMap = DrrSeqDeleteClassMap; Info->SubmitPacket = DrrSeqSubmitPacket; Info->ReceivePacket = NULL; Info->ReceiveIndication = NULL; Info->SetInformation = DrrSetInformation; Info->QueryInformation = DrrQueryInformation; } // InitializeDrrSequencer VOID CleanupDrrSequencer( VOID) /*++ Routine Description: Cleanup routine for the DRR sequencer. Arguments: Return Values: NDIS_STATUS_SUCCESS --*/ { } // CleanupDrrSequencer VOID AdjustFlowQuanta( PDSEQ_PIPE Pipe, ULONG MinRate) /*++ Routine Description: Adjust the quantum value for all flows based on the new minimum value. If MinRate is unspecified then a search for the new minimum rate will be performed. Arguments: Pipe - Pointer to pipe context information MinRate - New value for minimum rate, or GQPS_UNSPECIFIED to force a search Return Values: --*/ { PDSEQ_FLOW Flow; PLIST_ENTRY Entry; if (MinRate == QOS_NOT_SPECIFIED) { if (Pipe->Bandwidth > 0) { MinRate = Pipe->Bandwidth; } for (Entry = Pipe->Flows.Flink; Entry != &Pipe->Flows; Entry = Entry->Flink) { Flow = CONTAINING_RECORD(Entry, DSEQ_FLOW, Links); if ((Flow->TokenRate < MinRate) && (Flow->PriorityGroup > PRIORITY_GROUP_BEST_EFFORT) && (Flow->PriorityGroup != PRIORITY_GROUP_NETWORK_CONTROL)) { MinRate = Flow->TokenRate; } } } for (Entry = Pipe->Flows.Flink; Entry != &Pipe->Flows; Entry = Entry->Flink) { Flow = CONTAINING_RECORD(Entry, DSEQ_FLOW, Links); if ((Flow->TokenRate == QOS_NOT_SPECIFIED) || (Flow->PriorityGroup == PRIORITY_GROUP_NETWORK_CONTROL) || (Flow->PriorityGroup <= PRIORITY_GROUP_BEST_EFFORT)) { Flow->Quantum = Pipe->MinimumQuantum; } else { Flow->Quantum = (ULONG) (((ULONGLONG)(Flow->TokenRate) * (ULONGLONG)(Pipe->MinimumQuantum) ) / MinRate); } PsAssert((LONG)Flow->Quantum > 0); } Pipe->MinimumRate = MinRate; PsAssert(Pipe->MinimumRate != 0); } // AdjustFlowQuanta VOID DequeuePackets( PDSEQ_PIPE Pipe) /*++ Routine Description: Select the next packet(s) to send. The lock must be held upon entry to this routine. Arguments: Pipe - Pointer to pipe context information Return Values: --*/ { PDSEQ_FLOW Flow; LARGE_INTEGER CurrentTime; PLIST_ENTRY LowPriorityList = &Pipe->ActiveFlows[0]; PLIST_ENTRY CurrentLink; PPACKET_INFO_BLOCK PacketInfo; PNDIS_PACKET Packet; ULONG Priority; ULONG PriorityGroup; PPACKET_INFO_BLOCK PacketsToSend[MAX_DEQUEUED_PACKETS]; ULONG SendingPriority[MAX_DEQUEUED_PACKETS]; ULONG PacketSendCount = 0; ULONG MaxDequeuedPackets = Pipe->MaxOutstandingSends - Pipe->OutstandingSends; ULONG i; // Need to call this to disable the user APCs after this point. // Note that the DDK says it should be called at PASSIVE. But it can very well be // called at DISPATCH. KeEnterCriticalRegion(); Pipe->Flags |= DSEQ_DEQUEUE; PsGetCurrentTime(&CurrentTime); PsAssert(Pipe->MaxOutstandingSends >= Pipe->OutstandingSends); if (MaxDequeuedPackets > MAX_DEQUEUED_PACKETS) { MaxDequeuedPackets = MAX_DEQUEUED_PACKETS; } // First update the conformance status of the flows in the lowest priority list CurrentLink = LowPriorityList->Flink; while (CurrentLink != LowPriorityList) { // Get the flow pointer from the linkage and set new value for CurrentLink Flow = CONTAINING_RECORD(CurrentLink, DSEQ_FLOW, ActiveLinks); CurrentLink = CurrentLink->Flink; // If this flow's priority is higher than the DRR priority, then // it is a candidate for a status change. if (Flow->Priority > 0) { PacketInfo = (PPACKET_INFO_BLOCK)Flow->PacketQueue.Flink; if (PacketIsConforming(Flow, PacketInfo, CurrentTime, Pipe->TimerResolution)) { // Move flow to higher priority list Flow->DeficitCounter = Flow->Quantum; RemoveEntryList(&Flow->ActiveLinks); InsertTailList(&Pipe->ActiveFlows[Flow->Priority], &Flow->ActiveLinks); } } } // Now select the next packet(s) to send for (PriorityGroup = PRIORITY_GROUPS - 1; ((PriorityGroup > 0) && (Pipe->ActiveFlowCount[PriorityGroup] == 0)); PriorityGroup--) ; Priority = Pipe->StartPriority[PriorityGroup] + Pipe->PriorityLevels[PriorityGroup] - 1; while ((PacketSendCount < MaxDequeuedPackets) && (Pipe->TotalActiveFlows > 0) && Priority < INTERNAL_PRIORITIES) { if (!IsListEmpty(&Pipe->ActiveFlows[Priority])) { // Get first flow in the current list, and get a pointer to the info // about the first packet CurrentLink = Pipe->ActiveFlows[Priority].Flink; Flow = CONTAINING_RECORD(CurrentLink, DSEQ_FLOW, ActiveLinks); PacketInfo = (PPACKET_INFO_BLOCK)Flow->PacketQueue.Flink; if (Pipe->PsFlags & PS_DISABLE_DRR) { // DRR is disabled. Remove the first packet from the queue // and send it. RemoveEntryList(&PacketInfo->SchedulerLinks); Flow->LastConformanceTime.QuadPart = PacketInfo->ConformanceTime.QuadPart; if (Priority > 0) { AdjustLastPacketTime(Flow, CurrentTime, Pipe->TimerResolution); } else { Flow->PacketSendTime = CurrentTime; } InterlockedIncrement( &Pipe->OutstandingSends ); if(Pipe->OutstandingSends > Pipe->Stats.MaxPacketsInNetcard){ Pipe->Stats.MaxPacketsInNetcard = Pipe->OutstandingSends; } if(gEnableAvgStats) { // // Track max packets outstanding. This is a measure // of how congested the media gets. Of course, it // will be clipped by the MaxOutstandingSends parameter. // So - for a valid reading, need to set MOS very large. // Pipe->Stats.AveragePacketsInNetcard = RunningAverage(Pipe->PacketsInNetcardAveragingArray, Pipe->OutstandingSends); } SendingPriority[PacketSendCount] = Priority; PacketsToSend[PacketSendCount++] = PacketInfo; // For logging purposes... PacketInfo->ConformanceTime = Flow->PacketSendTime; // If the flow has no more packets to send, remove it from the list. // Otherwise move it to the end of the appropriate list, depending on // the conformance time of the next packet. RemoveEntryList(&Flow->ActiveLinks); if (IsListEmpty(&Flow->PacketQueue)) { Pipe->TotalActiveFlows--; Pipe->ActiveFlowCount[Flow->PriorityGroup]--; } else { PacketInfo = (PPACKET_INFO_BLOCK)Flow->PacketQueue.Flink; Flow->PacketSendTime.QuadPart += (PacketInfo->ConformanceTime.QuadPart - Flow->LastConformanceTime.QuadPart); if (!PacketIsConforming(Flow, PacketInfo, CurrentTime, Pipe->TimerResolution)) { InsertTailList(LowPriorityList, &Flow->ActiveLinks); } else { InsertTailList(&Pipe->ActiveFlows[Priority], &Flow->ActiveLinks); } } } else if (PacketInfo->PacketLength <= Flow->DeficitCounter) { // DRR is being used and the flow has a large enough deficit counter // to send the packet. Remove the packet from the queue and send it. RemoveEntryList(&PacketInfo->SchedulerLinks); Flow->LastConformanceTime.QuadPart = PacketInfo->ConformanceTime.QuadPart; if (Priority > 0) { AdjustLastPacketTime(Flow, CurrentTime, Pipe->TimerResolution); } else { Flow->PacketSendTime = CurrentTime; } Flow->DeficitCounter -= PacketInfo->PacketLength; InterlockedIncrement( &Pipe->OutstandingSends ); if(Pipe->OutstandingSends > Pipe->Stats.MaxPacketsInNetcard){ Pipe->Stats.MaxPacketsInNetcard = Pipe->OutstandingSends; } if(gEnableAvgStats) { // // Track max packets outstanding. This is a measure // of how congested the media gets. Of course, it // will be clipped by the MaxOutstandingSends parameter. // So - for a valid reading, need to set MOS very large. // Pipe->Stats.AveragePacketsInNetcard = RunningAverage(Pipe->PacketsInNetcardAveragingArray, Pipe->OutstandingSends); } SendingPriority[PacketSendCount] = Priority; PacketsToSend[PacketSendCount++] = PacketInfo; // For logging purposes... PacketInfo->ConformanceTime = Flow->PacketSendTime; // If the flow has no more packets to send, remove it from the list. // If the flow still has conforming packets to send, leave it at the head // of the list. If the flow has non-conforming packets to send, move it // to the lowest priority list. If we are servicing the zero priority // level, then no conformance checking is necessary. if (IsListEmpty(&Flow->PacketQueue)) { RemoveEntryList(&Flow->ActiveLinks); Pipe->TotalActiveFlows--; Pipe->ActiveFlowCount[Flow->PriorityGroup]--; } else { PacketInfo = (PPACKET_INFO_BLOCK)Flow->PacketQueue.Flink; Flow->PacketSendTime.QuadPart += (PacketInfo->ConformanceTime.QuadPart - Flow->LastConformanceTime.QuadPart); if ((Priority > 0) && !PacketIsConforming(Flow, PacketInfo, CurrentTime, Pipe->TimerResolution)) { Flow->DeficitCounter = Flow->Quantum; RemoveEntryList(&Flow->ActiveLinks); InsertTailList(LowPriorityList, &Flow->ActiveLinks); } } } else { // The packet cannot be sent because the flow's deficit counter // is too small. Place the flow at the end of the same priority // queue and increment the flow's deficit counter by its quantum. Flow->DeficitCounter += Flow->Quantum; RemoveEntryList(&Flow->ActiveLinks); InsertTailList(&Pipe->ActiveFlows[Priority], &Flow->ActiveLinks); } } else { Priority--; } } // // We're gonna send these now, which means they're leaving the // sequencer. Update the stats. // Pipe->PacketsInSequencer -= PacketSendCount; Flow->PacketsInSequencer -= PacketSendCount; if(gEnableAvgStats) { Flow->Stats.AveragePacketsInSequencer = RunningAverage(Flow->PacketsInSeqAveragingArray, Flow->PacketsInSequencer); } // Send the next group of packets UNLOCK_PIPE(Pipe); if (PacketSendCount == 0) { PsDbgOut(DBG_CRITICAL_ERROR, DBG_SCHED_DRR, ("PSCHED: No packets selected\n")); } for (i = 0; i < PacketSendCount; i++) { PacketInfo = PacketsToSend[i]; Flow = (PDSEQ_FLOW)PacketInfo->FlowContext; Packet = PacketInfo->NdisPacket; // // The 802.1 priority is already set by the wrapper. But, if the packet // is non-conforming, then we want to reset it. We also want to clear // the IP Precedence Bits. // if ((SendingPriority[i] == 0)) { // // Non conforming packet! // NDIS_PACKET_8021Q_INFO VlanPriInfo; VlanPriInfo.Value = NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, Ieee8021QInfo); VlanPriInfo.TagHeader.UserPriority = PacketInfo->UserPriorityNonConforming; NDIS_PER_PACKET_INFO_FROM_PACKET(Packet, Ieee8021QInfo) = VlanPriInfo.Value; Flow->Stats.NonconformingPacketsTransmitted ++; Pipe->Stats.NonconformingPacketsTransmitted ++; // // Reset the TOS byte for IP Packets. // if(NDIS_GET_PACKET_PROTOCOL_TYPE(Packet) == NDIS_PROTOCOL_ID_TCP_IP) { if(!PacketInfo->IPHdr) { PacketInfo->IPHdr = GetIpHeader(PacketInfo->IPHeaderOffset, Packet); } SET_TOS_XSUM(Packet, PacketInfo->IPHdr, PacketInfo->TOSNonConforming); } } PsDbgSched(DBG_INFO, DBG_SCHED_DRR, DRR_SEQUENCER, PKT_DEQUEUE, Flow->PsFlowContext, Packet, PacketInfo->PacketLength, SendingPriority[i], CurrentTime.QuadPart, PacketInfo->ConformanceTime.QuadPart, Pipe->PacketsInSequencer, 0); if (!(*Pipe->ContextInfo.NextComponent->SubmitPacket)( Pipe->ContextInfo.NextComponentContext, Flow->ContextInfo.NextComponentContext, (PacketInfo->ClassMapContext != NULL) ? ((PPS_CLASS_MAP_CONTEXT)PacketInfo->ClassMapContext)->NextComponentContext : NULL, PacketInfo)) { (*Pipe->PsProcs->DropPacket)(Pipe->PsPipeContext, Flow->PsFlowContext, Packet, NDIS_STATUS_FAILURE); } } LOCK_PIPE(Pipe); Pipe->Flags &= ~DSEQ_DEQUEUE; // Re-enable the APCs again. KeLeaveCriticalRegion(); } // DequeuePackets NDIS_STATUS DrrSeqInitializePipe ( IN HANDLE PsPipeContext, IN PPS_PIPE_PARAMETERS PipeParameters, IN PPS_PIPE_CONTEXT ComponentPipeContext, IN PPS_PROCS PsProcs, IN PPS_UPCALLS Upcalls ) /*++ Routine Description: Pipe initialization routine for the DRR sequencer. Arguments: PsPipeContext - PS pipe context value PipeParameters - Pointer to pipe parameters ComponentPipeContext - Pointer to this component's context area PsProcs - PS's support routines Upcalls - Previous component's upcall table Return Values: Status value from next component --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)ComponentPipeContext; HANDLE NdisHandle; ULONG i; ULONG PriorityLevel = 0; PS_UPCALLS DrrSeqUpcalls; NDIS_STATUS Status; NdisAllocateSpinLock(&Pipe->Lock); Pipe->Flags = 0; // // Relative Priorities allow us to further subdivide each priority group // into sub priorities. This does not exist for NonConforming, BestEffort, // and Qualitative. // Pipe->PriorityLevels[PRIORITY_GROUP_NON_CONFORMING] = 1; Pipe->PriorityLevels[PRIORITY_GROUP_BEST_EFFORT] = 1; Pipe->PriorityLevels[PRIORITY_GROUP_CONTROLLED_LOAD] = RELATIVE_PRIORITIES; Pipe->PriorityLevels[PRIORITY_GROUP_GUARANTEED] = RELATIVE_PRIORITIES; Pipe->PriorityLevels[PRIORITY_GROUP_NETWORK_CONTROL] = RELATIVE_PRIORITIES; InitializeListHead(&Pipe->Flows); for (i = 0; i < INTERNAL_PRIORITIES; i++) { InitializeListHead(&Pipe->ActiveFlows[i]); } for (i = 0; i < PRIORITY_GROUPS; i++) { Pipe->ActiveFlowCount[i] = 0; Pipe->StartPriority[i] = PriorityLevel; PriorityLevel += Pipe->PriorityLevels[i]; } Pipe->TotalActiveFlows = 0; Pipe->OutstandingSends = 0; NdisZeroMemory(&Pipe->Stats, sizeof(PS_DRRSEQ_STATS)); Pipe->PacketsInSequencer = 0; Pipe->PacketsInSequencerAveragingArray = NULL; Pipe->PacketsInNetcardAveragingArray = NULL; Status = CreateAveragingArray(&Pipe->PacketsInSequencerAveragingArray, SEQUENCER_AVERAGING_ARRAY_SIZE); if(Status != NDIS_STATUS_SUCCESS) { return(Status); } Status = CreateAveragingArray(&Pipe->PacketsInNetcardAveragingArray, NETCARD_AVERAGING_ARRAY_SIZE); if(Status != NDIS_STATUS_SUCCESS) { DeleteAveragingArray(Pipe->PacketsInSequencerAveragingArray); return(Status); } Pipe->MinimumQuantum = PipeParameters->MTUSize - PipeParameters->HeaderSize; if (Pipe->MinimumQuantum == 0) { Pipe->MinimumQuantum = DEFAULT_MIN_QUANTUM; } Pipe->Bandwidth = PipeParameters->Bandwidth; // This will be set to something more realistic when the first flow is created. Pipe->MinimumRate = (PipeParameters->Bandwidth > 0) ? PipeParameters->Bandwidth : QOS_NOT_SPECIFIED; PsAssert(Pipe->MinimumRate != 0); Pipe->PsFlags = PipeParameters->Flags; Pipe->IsslowFlowCount = 0; Pipe->ConfiguredMaxOutstandingSends = Pipe->MaxOutstandingSends = PipeParameters->MaxOutstandingSends; // Change the MOS if necessary.. if( ( PipeParameters->MediaType == NdisMediumWan) && ( Pipe->Bandwidth <= MAX_LINK_SPEED_FOR_DRR) ) { Pipe->MaxOutstandingSends = 1; } (*PsProcs->GetTimerInfo)(&Pipe->TimerResolution); Pipe->TimerResolution /= 2; Pipe->PsPipeContext = PsPipeContext; Pipe->PsProcs = PsProcs; if(Upcalls) { Pipe->PreviousUpcallsSendComplete = Upcalls->SendComplete; Pipe->PreviousUpcallsSendCompletePipeContext = Upcalls->PipeContext; } else { Pipe->PreviousUpcallsSendComplete = 0; Pipe->PreviousUpcallsSendCompletePipeContext = 0; } DrrSeqUpcalls.SendComplete = DrrSeqSendComplete; DrrSeqUpcalls.PipeContext = ComponentPipeContext; /* This put the DrrSeq in the pass-thru mode when the MaxOutStandingSends == MAX */ if( Pipe->MaxOutstandingSends == 0xffffffff ) Pipe->Flags |= DSEQ_PASSTHRU; else Pipe->Flags &= ~ DSEQ_PASSTHRU; PsDbgOut(DBG_INFO, DBG_SCHED_DRR, ("PSCHED: DrrSeq pipe initialized at %x.\n", &Pipe)); Status = (*Pipe->ContextInfo.NextComponent->InitializePipe)( PsPipeContext, PipeParameters, Pipe->ContextInfo.NextComponentContext, PsProcs, &DrrSeqUpcalls); if (Status != NDIS_STATUS_SUCCESS) { NdisFreeSpinLock(&Pipe->Lock); DeleteAveragingArray(Pipe->PacketsInSequencerAveragingArray); DeleteAveragingArray(Pipe->PacketsInNetcardAveragingArray); } return Status; } // DrrSeqInitializePipe // // Unload routine: currently do nothing // void UnloadSequencer() { } NDIS_STATUS DrrSeqModifyPipe ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_PIPE_PARAMETERS PipeParameters ) /*++ Routine Description: Pipe parameter modification routine for the DRR sequencer. Arguments: PipeContext - Pointer to this component's pipe context area PipeParameters - Pointer to pipe parameters Return Values: Status value from next component --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; ULONG MinQuantum = PipeParameters->MTUSize - PipeParameters->HeaderSize; BOOLEAN AdjustQuanta = FALSE; ULONG MinRate = Pipe->MinimumRate; LOCK_PIPE(Pipe); (*Pipe->PsProcs->GetTimerInfo)(&Pipe->TimerResolution); Pipe->TimerResolution /= 2; if ((MinQuantum > 0) && (MinQuantum != Pipe->MinimumQuantum)) { Pipe->MinimumQuantum = MinQuantum; AdjustQuanta = TRUE; } Pipe->Bandwidth = PipeParameters->Bandwidth; Pipe->ConfiguredMaxOutstandingSends = Pipe->MaxOutstandingSends = PipeParameters->MaxOutstandingSends; // Change the MOS if necessary.. if( ( PipeParameters->MediaType == NdisMediumWan) && ( Pipe->Bandwidth <= MAX_LINK_SPEED_FOR_DRR) ) { Pipe->MaxOutstandingSends = 1; } // This put the DrrSeq in the pass-thru mode when the MaxOutStandingSends == MAX if( Pipe->MaxOutstandingSends == 0xffffffff ) { // Make sure not to do this. It could lead to packets queued up in the sequencer being never sent // [ Pipe->Flags |= DSEQ_PASSTHRU; ] } else { Pipe->Flags &= ~ DSEQ_PASSTHRU; } if (Pipe->MinimumRate > Pipe->Bandwidth) { MinRate = QOS_NOT_SPECIFIED; AdjustQuanta = TRUE; } if (AdjustQuanta) { AdjustFlowQuanta(Pipe, MinRate); } UNLOCK_PIPE(Pipe); return (*PipeContext->NextComponent->ModifyPipe)( PipeContext->NextComponentContext, PipeParameters); } // DrrSeqModifyPipe VOID DrrSeqDeletePipe ( IN PPS_PIPE_CONTEXT PipeContext ) /*++ Routine Description: Pipe removal routine for token bucket conformer. Arguments: PipeContext - Pointer to this component's pipe context area Return Values: --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; DeleteAveragingArray(Pipe->PacketsInSequencerAveragingArray); DeleteAveragingArray(Pipe->PacketsInNetcardAveragingArray); PsDbgOut(DBG_INFO, DBG_SCHED_DRR, ("PSCHED: DrrSeq pipe deleted\n")); PsAssert(Pipe->OutstandingSends == 0); NdisFreeSpinLock(&Pipe->Lock); (*Pipe->ContextInfo.NextComponent->DeletePipe)(Pipe->ContextInfo.NextComponentContext); } // DrrSeqDeletePipe NDIS_STATUS DrrSeqCreateFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN HANDLE PsFlowContext, IN PCO_CALL_PARAMETERS CallParameters, IN PPS_FLOW_CONTEXT ComponentFlowContext ) /*++ Routine Description: Flow creation routine for the DRR sequencer. Arguments: PipeContext - Pointer to this component's pipe context area PsFlowContext - PS flow context value CallParameters - Pointer to call parameters for flow ComponentFlowContext - Pointer to this component's flow context area Return Values: Status value from next component --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; PDSEQ_FLOW Flow = (PDSEQ_FLOW)ComponentFlowContext; SERVICETYPE ServiceType; ULONG ParamsLength; LPQOS_OBJECT_HDR QoSObject; ULONG UserPriority; ULONG i; NDIS_STATUS Status; ServiceType = CallParameters->CallMgrParameters->Transmit.ServiceType; if ((ServiceType < SERVICETYPE_BESTEFFORT) || (ServiceType > SERVICETYPE_QUALITATIVE)) { return NDIS_STATUS_FAILURE; } Flow->TokenRate = CallParameters->CallMgrParameters->Transmit.TokenRate; Flow->BucketSize = CallParameters->CallMgrParameters->Transmit.TokenBucketSize; InitializeListHead(&Flow->PacketQueue); PsGetCurrentTime(&Flow->PacketSendTime); Flow->LastConformanceTime = Flow->PacketSendTime; Flow->PsFlowContext = PsFlowContext; Flow->State = DRRSEQ_FLOW_CREATED; // Set the flow's priority group based on service type. switch (ServiceType) { case SERVICETYPE_CONTROLLEDLOAD: Flow->PriorityGroup = PRIORITY_GROUP_CONTROLLED_LOAD; break; case SERVICETYPE_GUARANTEED: Flow->PriorityGroup = PRIORITY_GROUP_GUARANTEED; break; case SERVICETYPE_NETWORK_CONTROL: Flow->PriorityGroup = PRIORITY_GROUP_NETWORK_CONTROL; break; case SERVICETYPE_QUALITATIVE: default: Flow->PriorityGroup = PRIORITY_GROUP_BEST_EFFORT; } Flow->Flags = 0; // Save the flow in a list so that quantum values can be adjusted if // a new flow is added with a smaller rate than the existing flows. LOCK_PIPE(Pipe); InsertTailList(&Pipe->Flows, &Flow->Links); // If this flow's rate is smaller than the rate assigned to any existing // flow, adjust the other flow's quantum values accordingly. if (ServiceType == SERVICETYPE_BESTEFFORT || ServiceType == SERVICETYPE_NETWORK_CONTROL || ServiceType == SERVICETYPE_QUALITATIVE) { Flow->Quantum = Pipe->MinimumQuantum; } else if (Flow->TokenRate < Pipe->MinimumRate) { AdjustFlowQuanta(Pipe, Flow->TokenRate); } else { Flow->Quantum = (ULONG)( (ULONGLONG)(Flow->TokenRate) * (ULONGLONG)(Pipe->MinimumQuantum) / Pipe->MinimumRate ); PsAssert((LONG)Flow->Quantum > 0); } Flow->DeficitCounter = 0; // If this is a RAS-ISSLOW flow, need to set the MOS back to whatever requested by the user.. if( ((PGPC_CLIENT_VC)(PsFlowContext))->Flags & GPC_ISSLOW_FLOW) { Pipe->MaxOutstandingSends = Pipe->ConfiguredMaxOutstandingSends; Pipe->IsslowFlowCount++; Flow->Flags |= GPC_ISSLOW_FLOW; } UNLOCK_PIPE(Pipe); // Now set default values for UserPriority UserPriority = (Pipe->PriorityLevels[Flow->PriorityGroup] - 1) / 2; // Look for the priority object and traffic class in the call manager specific parameters ParamsLength = CallParameters->CallMgrParameters->CallMgrSpecific.Length; if (CallParameters->CallMgrParameters->CallMgrSpecific.ParamType == PARAM_TYPE_GQOS_INFO) { QoSObject = (LPQOS_OBJECT_HDR)CallParameters->CallMgrParameters->CallMgrSpecific.Parameters; while ((ParamsLength > 0) && (QoSObject->ObjectType != QOS_OBJECT_END_OF_LIST)) { if (QoSObject->ObjectType == QOS_OBJECT_PRIORITY) { UserPriority = ((LPQOS_PRIORITY)QoSObject)->SendPriority; Flow->Flags |= FLOW_USER_PRIORITY; } ParamsLength -= QoSObject->ObjectLength; QoSObject = (LPQOS_OBJECT_HDR)((UINT_PTR)QoSObject + QoSObject->ObjectLength); } } Flow->UserPriority = UserPriority; if (UserPriority < Pipe->PriorityLevels[Flow->PriorityGroup]) { Flow->Priority = Pipe->StartPriority[Flow->PriorityGroup] + UserPriority; } else { Flow->Priority = Pipe->StartPriority[Flow->PriorityGroup] + Pipe->PriorityLevels[Flow->PriorityGroup] - 1; } Flow->PacketsInSequencer = 0; NdisZeroMemory(&Flow->Stats, sizeof(PS_DRRSEQ_STATS)); Status = CreateAveragingArray(&Flow->PacketsInSeqAveragingArray, SEQUENCER_FLOW_AVERAGING_ARRAY_SIZE); if(Status != NDIS_STATUS_SUCCESS){ LOCK_PIPE(Pipe); RemoveEntryList(&Flow->Links); if(Flow->TokenRate == Pipe->MinimumRate) { AdjustFlowQuanta(Pipe, QOS_NOT_SPECIFIED); } UNLOCK_PIPE(Pipe); return(Status); } PsDbgOut(DBG_INFO, DBG_SCHED_DRR, ("PSCHED: DrrSeq flow created. Quantum = %u, Priority = %u\n", Flow->Quantum, Flow->Priority)); Status = (*Pipe->ContextInfo.NextComponent->CreateFlow)( Pipe->ContextInfo.NextComponentContext, PsFlowContext, CallParameters, Flow->ContextInfo.NextComponentContext); if(Status != NDIS_STATUS_SUCCESS) { DeleteAveragingArray(Flow->PacketsInSeqAveragingArray); LOCK_PIPE(Pipe); RemoveEntryList(&Flow->Links); if(Flow->TokenRate == Pipe->MinimumRate) { AdjustFlowQuanta(Pipe, QOS_NOT_SPECIFIED); } UNLOCK_PIPE(Pipe); } return Status; } // DrrSeqCreateFlow NDIS_STATUS DrrSeqModifyFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext, IN PCO_CALL_PARAMETERS CallParameters ) /*++ Routine Description: Flow modification routine for the DRR sequencer. Arguments: PipeContext - Pointer to this component's pipe context area FlowContext - Pointer to this component's flow context area CallParameters - Pointer to call parameters for flow Return Values: Status value from next component --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; PDSEQ_FLOW Flow = (PDSEQ_FLOW)FlowContext; SERVICETYPE ServiceType; ULONG TokenRate; ULONG ParamsLength; LPQOS_OBJECT_HDR QoSObject; LPQOS_PRIORITY PriorityObject = NULL; ULONG i; ULONG OldPriorityGroup; ULONG OldRate; ULONG OldPriority; PPACKET_INFO_BLOCK PacketInfo; LARGE_INTEGER CurrentTime; ServiceType = CallParameters->CallMgrParameters->Transmit.ServiceType; if ((ServiceType != SERVICETYPE_NOCHANGE) && ((ServiceType < SERVICETYPE_BESTEFFORT) || (ServiceType > SERVICETYPE_QUALITATIVE))) { return NDIS_STATUS_FAILURE; } // Look for the priority and traffic class objects in the call manager // specific parameters, and save the pointers if found. ParamsLength = CallParameters->CallMgrParameters->CallMgrSpecific.Length; if (CallParameters->CallMgrParameters->CallMgrSpecific.ParamType == PARAM_TYPE_GQOS_INFO) { QoSObject = (LPQOS_OBJECT_HDR)CallParameters->CallMgrParameters->CallMgrSpecific.Parameters; while ((ParamsLength > 0) && (QoSObject->ObjectType != QOS_OBJECT_END_OF_LIST)) { if (QoSObject->ObjectType == QOS_OBJECT_PRIORITY) { PriorityObject = (LPQOS_PRIORITY)QoSObject; } ParamsLength -= QoSObject->ObjectLength; QoSObject = (LPQOS_OBJECT_HDR)((UINT_PTR)QoSObject + QoSObject->ObjectLength); } } LOCK_PIPE(Pipe); OldPriorityGroup = Flow->PriorityGroup; OldPriority = Flow->Priority; if (ServiceType != SERVICETYPE_NOCHANGE) { // Set the flow's priority group based on service type. switch (ServiceType) { case SERVICETYPE_CONTROLLEDLOAD: Flow->PriorityGroup = PRIORITY_GROUP_CONTROLLED_LOAD; break; case SERVICETYPE_GUARANTEED: Flow->PriorityGroup = PRIORITY_GROUP_GUARANTEED; break; case SERVICETYPE_NETWORK_CONTROL: Flow->PriorityGroup = PRIORITY_GROUP_NETWORK_CONTROL; break; case SERVICETYPE_QUALITATIVE: default: Flow->PriorityGroup = PRIORITY_GROUP_BEST_EFFORT; } TokenRate = CallParameters->CallMgrParameters->Transmit.TokenRate; OldRate = Flow->TokenRate; if ((TokenRate != OldRate) || (OldPriorityGroup != Flow->PriorityGroup)) { // If this flow's rate is smaller than the rate assigned to any existing // flow, adjust the other flows' quantum values accordingly. If this flow's // old rate was equal to the minimum rate, then locate the new minimum rate and // adjust the other flows' quantum values accordingly. Flow->TokenRate = TokenRate; if ((OldRate == Pipe->MinimumRate) && (OldPriorityGroup > PRIORITY_GROUP_BEST_EFFORT) && (OldPriorityGroup != PRIORITY_GROUP_NETWORK_CONTROL)) { AdjustFlowQuanta(Pipe, QOS_NOT_SPECIFIED); } else if (Flow->PriorityGroup <= PRIORITY_GROUP_BEST_EFFORT || Flow->PriorityGroup == PRIORITY_GROUP_NETWORK_CONTROL) { Flow->Quantum = Pipe->MinimumQuantum; } else if (TokenRate < Pipe->MinimumRate) { AdjustFlowQuanta(Pipe, TokenRate); } else { PsAssert(Pipe->MinimumRate != 0); Flow->Quantum = (ULONG)((ULONGLONG)(TokenRate * Pipe->MinimumQuantum) / Pipe->MinimumRate); PsAssert((LONG)Flow->Quantum > 0); } } Flow->BucketSize = CallParameters->CallMgrParameters->Transmit.TokenBucketSize; } // Now set the new values for UserPriority and Priority if (PriorityObject != NULL) { Flow->UserPriority = PriorityObject->SendPriority; Flow->Flags |= FLOW_USER_PRIORITY; } else if ((Flow->Flags & FLOW_USER_PRIORITY) == 0) { Flow->UserPriority = (Pipe->PriorityLevels[Flow->PriorityGroup] - 1) / 2; } if (Flow->UserPriority < Pipe->PriorityLevels[Flow->PriorityGroup]) { Flow->Priority = Pipe->StartPriority[Flow->PriorityGroup] + Flow->UserPriority; } else { Flow->Priority = Pipe->StartPriority[Flow->PriorityGroup] + Pipe->PriorityLevels[Flow->PriorityGroup] - 1; } // Move the flow to the proper priority list if necessary if ((Flow->Priority != OldPriority) && !IsListEmpty(&Flow->PacketQueue)) { Pipe->ActiveFlowCount[OldPriorityGroup]--; RemoveEntryList(&Flow->ActiveLinks); PacketInfo = (PPACKET_INFO_BLOCK)Flow->PacketQueue.Flink; PsGetCurrentTime(&CurrentTime); Flow->DeficitCounter = Flow->Quantum; Pipe->ActiveFlowCount[Flow->PriorityGroup]++; if (!PacketIsConforming(Flow, PacketInfo, CurrentTime, Pipe->TimerResolution)) { InsertTailList(&Pipe->ActiveFlows[0], &Flow->ActiveLinks); } else { InsertTailList(&Pipe->ActiveFlows[Flow->Priority], &Flow->ActiveLinks); } } UNLOCK_PIPE(Pipe); PsDbgOut(DBG_INFO, DBG_SCHED_DRR, ("PSCHED: DrrSeq flow modified. Quantum = %u, Priority = %u\n", Flow->Quantum, Flow->Priority)); return (*Pipe->ContextInfo.NextComponent->ModifyFlow)( Pipe->ContextInfo.NextComponentContext, Flow->ContextInfo.NextComponentContext, CallParameters); } // DrrSeqModifyFlow VOID DrrSeqDeleteFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext ) /*++ Routine Description: Flow removal routine for the DRR sequencer. Arguments: PipeContext - Pointer to this component's pipe context area FlowContext - Pointer to this component's flow context area Return Values: --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; PDSEQ_FLOW Flow = (PDSEQ_FLOW)FlowContext; PPACKET_INFO_BLOCK PacketInfo; PNDIS_PACKET Packet; LIST_ENTRY DropList; InitializeListHead(&DropList); LOCK_PIPE(Pipe); if( (Flow->State & DRRSEQ_FLOW_DELETED) != 0) { UNLOCK_PIPE(Pipe); goto DELETE_SEQ_FLOW; } Flow->State = DRRSEQ_FLOW_DELETED; RemoveEntryList(&Flow->Links); if (!IsListEmpty(&Flow->PacketQueue)) { // Remove flow from active list RemoveEntryList(&Flow->ActiveLinks); Pipe->ActiveFlowCount[Flow->PriorityGroup]--; Pipe->TotalActiveFlows--; while (!IsListEmpty(&Flow->PacketQueue)) { // Drop any packets that remain queued for this flow. PacketInfo = (PPACKET_INFO_BLOCK)RemoveHeadList(&Flow->PacketQueue); InsertTailList(&DropList, &PacketInfo->SchedulerLinks); } } if (Flow->TokenRate == Pipe->MinimumRate) { AdjustFlowQuanta(Pipe, QOS_NOT_SPECIFIED); } if( Flow->Flags & GPC_ISSLOW_FLOW) { // If this is an ISSLOW flow, we have one less now. Pipe->IsslowFlowCount--; if(Pipe->IsslowFlowCount == 0) { // If there are no more ISSLOW flows, turn DRR back on. Pipe->MaxOutstandingSends = 1; } } UNLOCK_PIPE(Pipe); while (!IsListEmpty(&DropList)) { PacketInfo = (PPACKET_INFO_BLOCK)RemoveHeadList(&DropList); Packet = PacketInfo->NdisPacket; (*Pipe->PsProcs->DropPacket)(Pipe->PsPipeContext, Flow->PsFlowContext, Packet, NDIS_STATUS_FAILURE); } DELETE_SEQ_FLOW: DeleteAveragingArray(Flow->PacketsInSeqAveragingArray); PsDbgOut(DBG_INFO, DBG_SCHED_DRR, ("PSCHED: DrrSeq flow deleted\n")); (*Pipe->ContextInfo.NextComponent->DeleteFlow)( Pipe->ContextInfo.NextComponentContext, Flow->ContextInfo.NextComponentContext); } VOID DrrSeqEmptyFlow ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext ) /*++ Routine Description: Flow removal routine for the DRR sequencer. Arguments: PipeContext - Pointer to this component's pipe context area FlowContext - Pointer to this component's flow context area Return Values: --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; PDSEQ_FLOW Flow = (PDSEQ_FLOW)FlowContext; PPACKET_INFO_BLOCK PacketInfo; PNDIS_PACKET Packet; LIST_ENTRY DropList; InitializeListHead(&DropList); LOCK_PIPE(Pipe); Flow->State = DRRSEQ_FLOW_DELETED; RemoveEntryList(&Flow->Links); if (!IsListEmpty(&Flow->PacketQueue)) { // Remove flow from active list RemoveEntryList(&Flow->ActiveLinks); Pipe->ActiveFlowCount[Flow->PriorityGroup]--; Pipe->TotalActiveFlows--; while (!IsListEmpty(&Flow->PacketQueue)) { // Drop any packets that remain queued for this flow. PacketInfo = (PPACKET_INFO_BLOCK)RemoveHeadList(&Flow->PacketQueue); InsertTailList(&DropList, &PacketInfo->SchedulerLinks); } } if (Flow->TokenRate == Pipe->MinimumRate) { AdjustFlowQuanta(Pipe, QOS_NOT_SPECIFIED); } if( Flow->Flags & GPC_ISSLOW_FLOW) { // If this is an ISSLOW flow, we have one less now. Pipe->IsslowFlowCount--; if(Pipe->IsslowFlowCount == 0) { // If there are no more ISSLOW flows, turn DRR back on. Pipe->MaxOutstandingSends = 1; } } UNLOCK_PIPE(Pipe); while (!IsListEmpty(&DropList)) { PacketInfo = (PPACKET_INFO_BLOCK)RemoveHeadList(&DropList); Packet = PacketInfo->NdisPacket; (*Pipe->PsProcs->DropPacket)(Pipe->PsPipeContext, Flow->PsFlowContext, Packet, NDIS_STATUS_FAILURE); } PsDbgOut(DBG_INFO, DBG_SCHED_DRR, ("PSCHED: DrrSeq flow emptied\n")); (*Pipe->ContextInfo.NextComponent->EmptyFlow)( Pipe->ContextInfo.NextComponentContext, Flow->ContextInfo.NextComponentContext); } static NDIS_STATUS DrrSeqCreateClassMap ( IN PPS_PIPE_CONTEXT PipeContext, IN HANDLE PsClassMapContext, IN PTC_CLASS_MAP_FLOW ClassMap, IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext) { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; return (*Pipe->ContextInfo.NextComponent->CreateClassMap)( Pipe->ContextInfo.NextComponentContext, PsClassMapContext, ClassMap, ComponentClassMapContext->NextComponentContext); } static NDIS_STATUS DrrSeqDeleteClassMap ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_CLASS_MAP_CONTEXT ComponentClassMapContext) { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; return (*Pipe->ContextInfo.NextComponent->DeleteClassMap)( Pipe->ContextInfo.NextComponentContext, ComponentClassMapContext->NextComponentContext); } BOOLEAN DrrSeqSubmitPacket ( IN PPS_PIPE_CONTEXT PipeContext, IN PPS_FLOW_CONTEXT FlowContext, IN PPS_CLASS_MAP_CONTEXT ClassMapContext, IN PPACKET_INFO_BLOCK PacketInfo ) /*++ Routine Description: Packet submission routine for the DRR sequencer. Arguments: PipeContext - Pointer to this component's pipe context area FlowContext - Pointer to this component's flow context area Packet - Pointer to packet Return Values: Always returns TRUE --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; PDSEQ_FLOW Flow = (PDSEQ_FLOW)FlowContext; LARGE_INTEGER CurrentTime; PNDIS_PACKET Packet = PacketInfo->NdisPacket; BOOLEAN FlowInactive; PGPC_CLIENT_VC Vc = Flow->PsFlowContext; if(Pipe->Flags & DSEQ_PASSTHRU) { InterlockedIncrement( &Pipe->OutstandingSends ); if(Pipe->OutstandingSends > Pipe->Stats.MaxPacketsInNetcard){ Pipe->Stats.MaxPacketsInNetcard = Pipe->OutstandingSends; } if(gEnableAvgStats) { // // Track max packets outstanding. This is a measure // of how congested the media gets. Of course, it // will be clipped by the MaxOutstandingSends parameter. // So - for a valid reading, need to set MOS very large. // Pipe->Stats.AveragePacketsInNetcard = RunningAverage(Pipe->PacketsInNetcardAveragingArray, Pipe->OutstandingSends); } // // Note: The 802.1p is already set by the wrapper // if (!(*Pipe->ContextInfo.NextComponent->SubmitPacket)( Pipe->ContextInfo.NextComponentContext, Flow->ContextInfo.NextComponentContext, (ClassMapContext != NULL) ? ClassMapContext->NextComponentContext : NULL, PacketInfo)) { (*Pipe->PsProcs->DropPacket)(Pipe->PsPipeContext, Flow->PsFlowContext, Packet, NDIS_STATUS_FAILURE); } return TRUE; } LOCK_PIPE(Pipe); if (Flow->State == DRRSEQ_FLOW_DELETED) { UNLOCK_PIPE(Pipe); return FALSE; } // // On WanLinks, when we are doing DRR, we need to put a maximum on the queue-limit. // NDISWAN has a queue limit of 132KBytes on a modem link; So, we'll limit it to 120 // packets by default. // if( ( Pipe->Bandwidth <= MAX_LINK_SPEED_FOR_DRR) && ( Pipe->MaxOutstandingSends == 1) && ( Pipe->PacketsInSequencer >= 120) ) { UNLOCK_PIPE( Pipe); return FALSE; } // // There is one case where the PIPE might go away because the send-complete happened // on a VC belonging to it before the send returned. So, to prevent that, we add a // Ref on that VC and take it out just before the send returns. // // Add a Ref. InterlockedIncrement(&Vc->RefCount); PacketInfo->FlowContext = FlowContext; PacketInfo->ClassMapContext = ClassMapContext; Pipe->PacketsInSequencer++; if(Pipe->PacketsInSequencer > Pipe->Stats.MaxPacketsInSequencer){ Pipe->Stats.MaxPacketsInSequencer = Pipe->PacketsInSequencer; } Flow->PacketsInSequencer++; if (Flow->PacketsInSequencer > Flow->Stats.MaxPacketsInSequencer){ Flow->Stats.MaxPacketsInSequencer = Flow->PacketsInSequencer; } if(gEnableAvgStats) { // // Track packets in the sequencer at any time. // Pipe->Stats.AveragePacketsInSequencer = RunningAverage(Pipe->PacketsInSequencerAveragingArray, Pipe->PacketsInSequencer); Flow->Stats.AveragePacketsInSequencer = RunningAverage(Flow->PacketsInSeqAveragingArray, Flow->PacketsInSequencer); } FlowInactive = IsListEmpty(&Flow->PacketQueue); InsertTailList(&Flow->PacketQueue, &PacketInfo->SchedulerLinks); PsGetCurrentTime(&CurrentTime); PsDbgSched(DBG_INFO, DBG_SCHED_DRR, DRR_SEQUENCER, PKT_ENQUEUE, Flow->PsFlowContext, Packet, PacketInfo->PacketLength, Flow->Priority, CurrentTime.QuadPart, PacketInfo->ConformanceTime.QuadPart, Pipe->PacketsInSequencer, 0); if (FlowInactive) { Flow->PacketSendTime.QuadPart += (PacketInfo->ConformanceTime.QuadPart - Flow->LastConformanceTime.QuadPart); Flow->DeficitCounter = Flow->Quantum; Pipe->TotalActiveFlows++; Pipe->ActiveFlowCount[Flow->PriorityGroup]++; if (!PacketIsConforming(Flow, PacketInfo, CurrentTime, Pipe->TimerResolution)) { InsertTailList(&Pipe->ActiveFlows[0], &Flow->ActiveLinks); } else { InsertTailList(&Pipe->ActiveFlows[Flow->Priority], &Flow->ActiveLinks); } } while ((Pipe->TotalActiveFlows > 0) && (Pipe->OutstandingSends < Pipe->MaxOutstandingSends) && ((Pipe->Flags & DSEQ_DEQUEUE) == 0)) { DequeuePackets(Pipe); } UNLOCK_PIPE(Pipe); // Take out the ref. DerefClVc(Vc); return TRUE; } // DrrSeqSubmitPacket VOID DrrSeqSendComplete ( IN PPS_PIPE_CONTEXT PipeContext, IN PNDIS_PACKET Packet ) /*++ Routine Description: Send complete handler for the DRR sequencer. Arguments: PipeContext - Pointer to this component's pipe context area FlowContext - Pointer to this component's flow context area Packet - Packet that has completed sending Return Values: --*/ { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)PipeContext; InterlockedDecrement( &Pipe->OutstandingSends); // Need to do this only if the sequencer is not in the bypass mode // if( (Pipe->Flags & DSEQ_PASSTHRU) == 0) { LOCK_PIPE(Pipe); PsAssert((LONG)Pipe->OutstandingSends >= 0); while ((Pipe->TotalActiveFlows > 0) && (Pipe->OutstandingSends < Pipe->MaxOutstandingSends) && ((Pipe->Flags & DSEQ_DEQUEUE) == 0)) { DequeuePackets(Pipe); } UNLOCK_PIPE(Pipe); } // // Call the previous upcalls (if any) // if(Pipe->PreviousUpcallsSendComplete) { (*Pipe->PreviousUpcallsSendComplete)(Pipe->PreviousUpcallsSendCompletePipeContext, Packet); } } // DrrSeqSendComplete VOID DrrSetInformation ( IN PPS_PIPE_CONTEXT ComponentPipeContext, IN PPS_FLOW_CONTEXT ComponentFlowContext, IN NDIS_OID Oid, IN ULONG Len, IN PVOID Data) { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)ComponentPipeContext; PDSEQ_FLOW Flow = (PDSEQ_FLOW)ComponentFlowContext; switch(Oid) { case OID_QOS_STATISTICS_BUFFER: if(Flow) { NdisZeroMemory(&Flow->Stats, sizeof(PS_DRRSEQ_STATS)); } else { NdisZeroMemory(&Pipe->Stats, sizeof(PS_DRRSEQ_STATS)); } break; default: break; } (*Pipe->ContextInfo.NextComponent->SetInformation)( Pipe->ContextInfo.NextComponentContext, (Flow)?Flow->ContextInfo.NextComponentContext:0, Oid, Len, Data); } VOID DrrQueryInformation ( IN PPS_PIPE_CONTEXT ComponentPipeContext, IN PPS_FLOW_CONTEXT ComponentFlowContext, IN NDIS_OID Oid, IN ULONG Len, IN PVOID Data, IN OUT PULONG BytesWritten, IN OUT PULONG BytesNeeded, IN OUT PNDIS_STATUS Status) { PDSEQ_PIPE Pipe = (PDSEQ_PIPE)ComponentPipeContext; PDSEQ_FLOW Flow = (PDSEQ_FLOW)ComponentFlowContext; PS_COMPONENT_STATS Stats; ULONG Size; ULONG RemainingLength; switch(Oid) { case OID_QOS_STATISTICS_BUFFER: Size = sizeof(PS_DRRSEQ_STATS) + FIELD_OFFSET(PS_COMPONENT_STATS, Stats); if(*Status == NDIS_STATUS_SUCCESS) { // // The previous component has succeeded - Let us // see if we can write the data // RemainingLength = Len - *BytesWritten; if(RemainingLength < Size) { *Status = NDIS_STATUS_BUFFER_TOO_SHORT; *BytesNeeded = Size + *BytesWritten; *BytesWritten = 0; } else { PPS_COMPONENT_STATS Cstats = (PPS_COMPONENT_STATS) Data; *BytesWritten += Size; *BytesNeeded = 0; if(Flow) { Cstats->Type = PS_COMPONENT_DRRSEQ; Cstats->Length = sizeof(PS_DRRSEQ_STATS); NdisMoveMemory(&Cstats->Stats, &Flow->Stats, sizeof(PS_DRRSEQ_STATS)); } else { Cstats->Type = PS_COMPONENT_DRRSEQ; Cstats->Length = sizeof(PS_DRRSEQ_STATS); NdisMoveMemory(&Cstats->Stats, &Pipe->Stats, sizeof(PS_DRRSEQ_STATS)); } // // Advance Data so that the next component can update its stats // Data = (PVOID) ((PUCHAR)Data + Size); } } else { *BytesNeeded += Size; *BytesWritten = 0; } break; default: break; } (*Pipe->ContextInfo.NextComponent->QueryInformation)( Pipe->ContextInfo.NextComponentContext, (Flow)?Flow->ContextInfo.NextComponentContext : 0, Oid, Len, Data, BytesWritten, BytesNeeded, Status); }