From e611b132f9b8abe35b362e5870b74bce94a1e58e Mon Sep 17 00:00:00 2001 From: Adam Date: Sat, 16 May 2020 20:51:50 -0700 Subject: initial commit --- private/ntos/ndis/testprot/tpdrvr/tputils.c | 1080 +++++++++++++++++++++++++++ 1 file changed, 1080 insertions(+) create mode 100644 private/ntos/ndis/testprot/tpdrvr/tputils.c (limited to 'private/ntos/ndis/testprot/tpdrvr/tputils.c') diff --git a/private/ntos/ndis/testprot/tpdrvr/tputils.c b/private/ntos/ndis/testprot/tpdrvr/tputils.c new file mode 100644 index 000000000..b16105ccf --- /dev/null +++ b/private/ntos/ndis/testprot/tpdrvr/tputils.c @@ -0,0 +1,1080 @@ +// ******************************* +// +// Copyright (c) 1990 Microsoft Corporation +// +// Module Name: +// +// tputils.c +// +// Abstract: +// +// This module implements the utility functions for the NDIS 3.0 +// Test Protocol Tester. +// +// Author: +// +// Tom Adams (tomad) 14-Jul-1990 +// +// Environment: +// +// Kernel mode +// +// Revision History: +// +// Tom Adams (tomad) 15-Dec-1990 +// seperate from testprot.c and add test control and statistics fcns. +// +// Tom Adams (tomad) 14-March-1991 +// add support for calling TpStress from command line with arguments. +// +// Tim Wynsma (timothyw) 5-18-94 +// Fixed warnings, some general cleanup +// +// **************************** + +#include +#include +#include + +#include "tpdefs.h" +#include "media.h" +#include "tpprocs.h" + + +PUCHAR +TpGetStatus( + NDIS_STATUS GeneralStatus + ) +{ + static NDIS_STATUS Status[] = { + NDIS_STATUS_SUCCESS, + NDIS_STATUS_PENDING, + NDIS_STATUS_NOT_RECOGNIZED, + NDIS_STATUS_NOT_COPIED, + NDIS_STATUS_ONLINE, + NDIS_STATUS_RESET_START, + NDIS_STATUS_RESET_END, + NDIS_STATUS_RING_STATUS, + NDIS_STATUS_CLOSED, + + NDIS_STATUS_WAN_LINE_UP, + NDIS_STATUS_WAN_LINE_DOWN, + NDIS_STATUS_WAN_FRAGMENT, + + NDIS_STATUS_NOT_RESETTABLE, + NDIS_STATUS_SOFT_ERRORS, + NDIS_STATUS_HARD_ERRORS, + NDIS_STATUS_FAILURE, + NDIS_STATUS_RESOURCES, + NDIS_STATUS_CLOSING, + NDIS_STATUS_BAD_VERSION, + NDIS_STATUS_BAD_CHARACTERISTICS, + NDIS_STATUS_ADAPTER_NOT_FOUND, + NDIS_STATUS_OPEN_FAILED, + NDIS_STATUS_DEVICE_FAILED, + NDIS_STATUS_MULTICAST_FULL, + NDIS_STATUS_MULTICAST_EXISTS, + NDIS_STATUS_MULTICAST_NOT_FOUND, + NDIS_STATUS_REQUEST_ABORTED, + NDIS_STATUS_RESET_IN_PROGRESS, + NDIS_STATUS_CLOSING_INDICATING, + NDIS_STATUS_NOT_SUPPORTED, + NDIS_STATUS_INVALID_PACKET, + NDIS_STATUS_OPEN_LIST_FULL, + NDIS_STATUS_ADAPTER_NOT_READY, + NDIS_STATUS_ADAPTER_NOT_OPEN, + NDIS_STATUS_NOT_INDICATING, + NDIS_STATUS_INVALID_LENGTH, + NDIS_STATUS_INVALID_DATA, + NDIS_STATUS_BUFFER_TOO_SHORT, + NDIS_STATUS_INVALID_OID, + NDIS_STATUS_ADAPTER_REMOVED, + NDIS_STATUS_UNSUPPORTED_MEDIA, + NDIS_STATUS_GROUP_ADDRESS_IN_USE, + NDIS_STATUS_FILE_NOT_FOUND, + NDIS_STATUS_ERROR_READING_FILE, + NDIS_STATUS_ALREADY_MAPPED, + NDIS_STATUS_RESOURCE_CONFLICT, + NDIS_STATUS_TOKEN_RING_OPEN_ERROR, + TP_STATUS_NO_SERVERS, + TP_STATUS_NO_EVENTS + }; + + static PUCHAR String[] = { + "NDIS_STATUS_SUCCESS", + "NDIS_STATUS_PENDING", + "NDIS_STATUS_NOT_RECOGNIZED", + "NDIS_STATUS_NOT_COPIED", + "NDIS_STATUS_ONLINE", + "NDIS_STATUS_RESET_START", + "NDIS_STATUS_RESET_END", + "NDIS_STATUS_RING_STATUS", + "NDIS_STATUS_CLOSED", + "NDIS_STATUS_WAN_LINE_UP", + "NDIS_STATUS_WAN_LINE_DOWN", + "NDIS_STATUS_WAN_FRAGMENT", + "NDIS_STATUS_NOT_RESETTABLE", + "NDIS_STATUS_SOFT_ERRORS", + "NDIS_STATUS_HARD_ERRORS", + "NDIS_STATUS_FAILURE", + "NDIS_STATUS_RESOURCES", + "NDIS_STATUS_CLOSING", + "NDIS_STATUS_BAD_VERSION", + "NDIS_STATUS_BAD_CHARACTERISTICS", + "NDIS_STATUS_ADAPTER_NOT_FOUND", + "NDIS_STATUS_OPEN_FAILED", + "NDIS_STATUS_DEVICE_FAILED", + "NDIS_STATUS_MULTICAST_FULL", + "NDIS_STATUS_MULTICAST_EXISTS", + "NDIS_STATUS_MULTICAST_NOT_FOUND", + "NDIS_STATUS_REQUEST_ABORTED", + "NDIS_STATUS_RESET_IN_PROGRESS", + "NDIS_STATUS_CLOSING_INDICATING", + "NDIS_STATUS_NOT_SUPPORTED", + "NDIS_STATUS_INVALID_PACKET", + "NDIS_STATUS_OPEN_LIST_FULL", + "NDIS_STATUS_ADAPTER_NOT_READY", + "NDIS_STATUS_ADAPTER_NOT_OPEN", + "NDIS_STATUS_NOT_INDICATING", + "NDIS_STATUS_INVALID_LENGTH", + "NDIS_STATUS_INVALID_DATA", + "NDIS_STATUS_BUFFER_TOO_SHORT", + "NDIS_STATUS_INVALID_OID", + "NDIS_STATUS_ADAPTER_REMOVED", + "NDIS_STATUS_UNSUPPORTED_MEDIA", + "NDIS_STATUS_GROUP_ADDRESS_IN_USE", + "NDIS_STATUS_FILE_NOT_FOUND", + "NDIS_STATUS_ERROR_READING_FILE", + "NDIS_STATUS_ALREADY_MAPPED", + "NDIS_STATUS_RESOURCE_CONFLICT", + "NDIS_STATUS_TOKEN_RING_OPEN_ERROR", + "TP_STATUS_NO_SERVERS", + "TP_STATUS_NO_EVENTS" + }; + + static UCHAR BadStatus[] = "UNDEFINED"; + +#define StatusCount (sizeof(Status)/sizeof(NDIS_STATUS)) + + INT i; + + for (i=0; iMemberType = CmdArgs->ARGS.TPSTRESS.MemberType; + (*StressArguments)->PacketType = CmdArgs->ARGS.TPSTRESS.PacketType; + (*StressArguments)->PacketSize = CmdArgs->ARGS.TPSTRESS.PacketSize; + (*StressArguments)->PacketMakeUp = CmdArgs->ARGS.TPSTRESS.PacketMakeUp; + (*StressArguments)->ResponseType = CmdArgs->ARGS.TPSTRESS.ResponseType; + (*StressArguments)->Iterations = 0; + (*StressArguments)->TotalIterations = CmdArgs->ARGS.TPSTRESS.TotalIterations; + (*StressArguments)->TotalPackets = CmdArgs->ARGS.TPSTRESS.TotalPackets; + (*StressArguments)->AllPacketsSent = FALSE; + (*StressArguments)->DelayType = CmdArgs->ARGS.TPSTRESS.DelayType; + (*StressArguments)->DelayLength = CmdArgs->ARGS.TPSTRESS.DelayLength; + (*StressArguments)->WindowEnabled = (UCHAR)CmdArgs->ARGS.TPSTRESS.WindowEnabled; + (*StressArguments)->DataChecking = (UCHAR)CmdArgs->ARGS.TPSTRESS.DataChecking; + (*StressArguments)->PacketsFromPool = (UCHAR)CmdArgs->ARGS.TPSTRESS.PacketsFromPool; + (*StressArguments)->BeginReceives = FALSE; + (*StressArguments)->ServerContinue = TRUE; + + return NDIS_STATUS_SUCCESS; +} + + + +NDIS_STATUS +TpInitServerArguments( + PSTRESS_ARGUMENTS *StressArguments + ) + +// ----------- +// +// Routine Description: +// +// Arguments: +// +// The arguments for the test to be run. +// +// Return Value: +// +// ---------------- + +{ + NDIS_STATUS Status; + + Status = NdisAllocateMemory((PVOID *)StressArguments, + sizeof( STRESS_ARGUMENTS ), + 0, + HighestAddress ); + + if ( Status != NDIS_STATUS_SUCCESS ) + { + IF_TPDBG (TP_DEBUG_RESOURCES) + { + TpPrint0("TpInitServerArguments: unable to allocate Argument buffer.\n"); + } + return NDIS_STATUS_RESOURCES; + } + else + { + NdisZeroMemory( *StressArguments,sizeof( STRESS_ARGUMENTS )); + } + + (*StressArguments)->MemberType = TP_SERVER; + (*StressArguments)->PacketType = 0; + (*StressArguments)->PacketSize = 100; + (*StressArguments)->PacketMakeUp = RAND; + (*StressArguments)->ResponseType = ACK_EVERY; + (*StressArguments)->Iterations = 0; + (*StressArguments)->TotalIterations = 0; + (*StressArguments)->TotalPackets = 0; + (*StressArguments)->AllPacketsSent = FALSE; + (*StressArguments)->DelayType = 0; + (*StressArguments)->DelayLength = FIXEDDELAY; + (*StressArguments)->WindowEnabled = TRUE; + (*StressArguments)->DataChecking = FALSE; + (*StressArguments)->PacketsFromPool = TRUE; + (*StressArguments)->BeginReceives = FALSE; + (*StressArguments)->ServerContinue = TRUE; + + return NDIS_STATUS_SUCCESS; +} + + + +VOID +TpStressWriteResults( + IN POPEN_BLOCK OpenP + ) + +// --------- +// +// Routine Description: +// +// Arguments: +// +// Return Value: +// +// None. +// +// --------- + +{ + PSTRESS_RESULTS OutputBuffer; + + NdisAcquireSpinLock( &OpenP->SpinLock ); + + OutputBuffer = MmGetSystemAddressForMdl( OpenP->Stress->StressIrp->MdlAddress ); + + RtlMoveMemory( OutputBuffer, + OpenP->Stress->Results, + sizeof( STRESS_RESULTS ) ); + + NdisReleaseSpinLock( &OpenP->SpinLock ); +} + + + +VOID +TpCopyClientStatistics( + IN POPEN_BLOCK OpenP + ) + +// -------- +// +// Routine Description: +// +// Arguments: +// +// Return Value: +// +// None. +// +// --------- + +{ + PSTRESS_RESULTS res; + PGLOBAL_COUNTERS gc; + PINSTANCE_COUNTERS ic; + PINSTANCE_COUNTERS lc; + PUCHAR p, q; + USHORT i; + + p = OpenP->Stress->Results->Address; + q = OpenP->StationAddress; + + for ( i=0;iMedia->AddressLen;i++ ) + { + *p++ = *q++; + } + + res = OpenP->Stress->Results; + gc = OpenP->GlobalCounters; + + res->OpenInstance = OpenP->OpenInstance; + res->NumServers = OpenP->Stress->Client->NumServers; + + res->Global.Sends = gc->Sends; + res->Global.SendComps = gc->SendComps; + res->Global.Receives = gc->Receives; + res->Global.ReceiveComps = gc->ReceiveComps; + res->Global.CorruptRecs = gc->CorruptRecs; + res->Global.InvalidPacketRecs = gc->InvalidPacketRecs; + + // + // Now calculate the Packets Per Second value. + // + + // first find the total number of test packets sent. + + gc->Sends = 0; + gc->Receives = 0; + + for ( i = 0 ; i < OpenP->Stress->Client->NumServers ; i++ ) + { + ic = OpenP->Stress->Client->Servers[i].Counters; + gc->Sends += ic->Sends; + gc->Receives += ic->Receives; + } + + // find the total test time in Nanoseconds + + OpenP->Stress->EndTime = RtlLargeIntegerSubtract( OpenP->Stress->EndTime, + OpenP->Stress->StartTime ); + // convert it to seconds. + + OpenP->Stress->EndTime = RtlExtendedLargeIntegerDivide( OpenP->Stress->EndTime, + 10000000, + NULL ); + + // then determine the packets per second value. + // NOTE: we are assuming that the high part of time is now 0. + + res->PacketsPerSecond = OpenP->Stress->PacketsPerSecond = + (( gc->Sends + gc->Receives ) / OpenP->Stress->EndTime.LowPart ); + + // + // Now copy the Server stats into the buffer. + // + + for( i=0;iStress->Client->NumServers;i++ ) + { + ic = OpenP->Stress->Client->Servers[i].Counters; + lc = &res->Servers[i].Instance; + + lc->Sends = ic->Sends; + lc->SendPends = ic->SendPends; + lc->SendComps = ic->SendComps; + lc->SendFails = ic->SendFails; + lc->Receives = ic->Receives; + ic->ReceiveComps = ic->ReceiveComps; + lc->CorruptRecs = ic->CorruptRecs; + } +} + + + +VOID +TpCopyServerStatistics( + IN POPEN_BLOCK OpenP, + IN PVOID Buffer, + IN INT ServerReference + ) + +// ----------- +// +// Routine Description: +// +// Arguments: +// +// Return Value: +// +// None. +// +// ------------- + +{ + PSERVER_RESULTS res; + PINSTANCE_COUNTERS ic; + PGLOBAL_COUNTERS gc; + PUCHAR p, q; + USHORT i; + + res = &OpenP->Stress->Results->Servers[ServerReference]; + + ic = (PINSTANCE_COUNTERS)((PUCHAR)Buffer + + (ULONG)sizeof( PACKET_INFO ) + + (ULONG)sizeof( STRESS_CONTROL )); + + gc = (PGLOBAL_COUNTERS)((PUCHAR)Buffer + + (ULONG)( sizeof( PACKET_INFO ) + + sizeof( STRESS_CONTROL ) + + sizeof( INSTANCE_COUNTERS ))); + + res->OpenInstance = OpenP->Stress->Client->Servers[ServerReference].ServerInstance; + + res->StatsRcvd = TRUE; + + // p = res->Address; + p = OpenP->Stress->Results->Servers[ServerReference].Address; + q = OpenP->Stress->Client->Servers[ServerReference].Address; + + for ( i=0;iMedia->AddressLen;i++ ) + { + *p++ = *q++; + } + + // + // Now copy the servers instance counters into the results buffer array. + // + + res->S_Instance.Sends = ic->Sends; + res->S_Instance.SendPends = ic->SendPends; + res->S_Instance.SendComps = ic->SendComps; + res->S_Instance.SendFails = ic->SendFails; + + res->S_Instance.Receives = ic->Receives; + res->S_Instance.ReceiveComps = ic->ReceiveComps; + res->S_Instance.CorruptRecs = ic->CorruptRecs; + + res->S_Instance.XferData = ic->XferData; + res->S_Instance.XferDataPends = ic->XferDataPends; + res->S_Instance.XferDataComps = ic->XferDataComps; + res->S_Instance.XferDataFails = ic->XferDataFails; + + // + // and the servers global counters. + // + + res->S_Global.Sends = gc->Sends; + res->S_Global.SendComps = gc->SendComps; + res->S_Global.Receives = gc->Receives; + res->S_Global.ReceiveComps = gc->ReceiveComps; + + res->S_Global.CorruptRecs = gc->CorruptRecs; + res->S_Global.InvalidPacketRecs = gc->InvalidPacketRecs; +} + + + +VOID +TpWriteServerStatistics( + IN POPEN_BLOCK OpenP, + IN OUT PNDIS_PACKET Packet, + IN PCLIENT_INFO Client + ) + +// ----------------- +// +// Routine Description: +// +// +// NOTE: This routine requires a packet with one single contiguous +// buffer, it does not attempt to write to any other buffers. +// +// Arguments: +// +// OpenP - A pointer to the OPEN_BLOCK describing the Server. +// +// Return Value: +// +// None. +// +// ----------------- + +{ + PNDIS_BUFFER Buffer; + PUCHAR Memory; + UINT BufLen; + + + NdisQueryPacket(Packet,NULL,NULL,&Buffer,NULL); + + NdisQueryBuffer( Buffer,(PVOID *)&Memory,&BufLen ); + + RtlMoveMemory( Memory + sizeof( STRESS_PACKET ), + (PVOID)Client->Counters, + sizeof( INSTANCE_COUNTERS ) ); + + RtlMoveMemory( Memory + (ULONG) ( sizeof( STRESS_PACKET ) + + sizeof( INSTANCE_COUNTERS )), + (PVOID)OpenP->GlobalCounters, + sizeof( GLOBAL_COUNTERS ) ); +} + + + +VOID +TpPrintClientStatistics( + POPEN_BLOCK OpenP + ) + +// -------------- +// +// Routine Description: +// +// This routine dumps the interesting statistics held in the Client's +// Test Protocol data structures at the end of the test. +// +// Arguments: +// +// OpenP - A pointer to the OPEN_BLOCK describing the Client. +// +// Return Value: +// +// None. +// +// -------------- + +{ + PGLOBAL_COUNTERS GCounters; + PINSTANCE_COUNTERS ICounters; + PSERVER_INFO Server; + USHORT i; + + // + // Print out the Client Network Address and Test Counters. + // + + IF_TPDBG ( TP_DEBUG_STATISTICS ) + { + TpPrint0("\n\t****** CLIENT STATISTICS ******\n\n"); + if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) + { + TpPrint1("\tLocal Address %x\t", OpenP->StationAddress[0]); + } + else + { + TpPrint6("\tLocal Address %x-%x-%x-%x-%x-%x\t", + OpenP->StationAddress[0],OpenP->StationAddress[1], + OpenP->StationAddress[2],OpenP->StationAddress[3], + OpenP->StationAddress[4],OpenP->StationAddress[5]); + } + TpPrint1("OpenInstance %d\n",OpenP->OpenInstance); + + TpPrint0("\n\t****** Global Statistics ******\n\n"); + + GCounters = OpenP->GlobalCounters; + + GCounters->Sends = 0; + GCounters->Receives = 0; + + for (i=0;iStress->Client->NumServers;i++) + { + ICounters = OpenP->Stress->Client->Servers[i].Counters; + GCounters->Sends += ICounters->Sends; + GCounters->Receives += ICounters->Receives; + } + + TpPrint1("\tTotal Packets Sent:\t\t%8lu\n",GCounters->Sends); + TpPrint1("\tTotal Packets Received:\t\t%8lu\n",GCounters->Receives); + TpPrint1("\tTotal Packets Lost:\t\t%8lu\n\n", GCounters->Sends-GCounters->Receives); + + TpPrint1("\tTotal Packet Sends Completed:\t%8lu\n", GCounters->SendComps); + TpPrint1("\tTotal Packet Receives Completed:%8lu\n\n", GCounters->ReceiveComps); + + TpPrint1("\tCorrupted Packet Receives:\t%8lu\n", GCounters->CorruptRecs); + TpPrint1("\tInvalid Packet Receives:\t%8lu\n", GCounters->InvalidPacketRecs); + + // + // And then print out the information about each of the Servers + // involved in the test. + // + + TpPrint0("\n\t***** Remote Server Statistics ******\n\n"); + + TpPrint1("\tClient at this address has %d Server(s) as follows:\n", + OpenP->Stress->Client->NumServers); + + for (i=0;iStress->Client->NumServers;i++) + { + Server = &OpenP->Stress->Client->Servers[i]; + + if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) + { + TpPrint1("\n\tRemote Server Address %x, ", Server->Address[0]); + } + else + { + TpPrint6("\n\tRemote Server Address %x-%x-%x-%x-%x-%x, ", + Server->Address[0],Server->Address[1],Server->Address[2], + Server->Address[3],Server->Address[4],Server->Address[5]); + } + + TpPrint1("OpenInstance %d\n\n",Server->ServerInstance); + + ICounters = Server->Counters; + + TpPrint1("\tTotal Packets Sent To:\t\t%8lu\n", ICounters->Sends); + TpPrint1("\tTotal Packets Received From:\t%8lu\n", ICounters->Receives); + TpPrint1("\tTotal Packets Lost:\t\t%8lu\n\n", ICounters->Sends-ICounters->Receives); + + TpPrint1("\tPacket Sends Failed:\t\t%8lu\n", ICounters->SendFails); + TpPrint1("\tPacket Sends Pended:\t\t%8lu\n", ICounters->SendPends); + TpPrint1("\tPacket Sends Completed:\t\t%8lu\n\n", ICounters->SendComps); + } + } +} + + + +VOID +TpPrintServerStatistics( + POPEN_BLOCK OpenP, + PCLIENT_INFO Client + ) + +// -------------- +// +// Routine Description: +// +// This routine dumps the interesting statistics held in the Server's +// Test Protocol data structures at the end of the test, and information +// about the Client that the Server was cooperating with. +// +// Arguments: +// +// OpenP - A pointer to the OPEN_BLOCK describing the Server. +// +// Client - A pointer to the CLIENT_INFO structure describing the +// Client this Server was responding to. +// +// Return Value: +// +// None. +// +// ---------------- + +{ + PINSTANCE_COUNTERS ICounters; + + // + // Print out the Server's Network Address and Test Counters. + // + IF_TPDBG ( TP_DEBUG_STATISTICS ) + { + TpPrint0("\t****** SERVER STATISTICS ******\n\n"); + + if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) + { + TpPrint1("\tLocal Address %x\t", OpenP->StationAddress[0]); + } + else + { + TpPrint6("\tLocal Address %x-%x-%x-%x-%x-%x\t", + OpenP->StationAddress[0],OpenP->StationAddress[1], + OpenP->StationAddress[2],OpenP->StationAddress[3], + OpenP->StationAddress[4],OpenP->StationAddress[5]); + } + + TpPrint1("OpenInstance %d\n",OpenP->OpenInstance); + + TpPrint0("\n\t****** Client Instance Statistics ******\n"); + + if ( OpenP->Media->MediumType == NdisMediumArcnet878_2 ) + { + TpPrint1("\n\tRemote Client Address %x, ", Client->Address[0]); + } + else + { + TpPrint6("\n\tRemote Client Address %x-%x-%x-%x-%x-%x, ", + Client->Address[0],Client->Address[1],Client->Address[2], + Client->Address[3],Client->Address[4],Client->Address[5]); + } + TpPrint1("OpenInstance %d\n\n",Client->ClientInstance); + + // + // And then print out the information about the Client involved + // in the test. + // + + ICounters = Client->Counters; + + TpPrint1("\tPackets Received:\t\t%8lu\n",ICounters->Receives); + TpPrint1("\tPackets Sent:\t\t\t%8lu\n",ICounters->Sends); + TpPrint1("\tPackets Not Responded To:\t%8lu\n\n", ICounters->Receives-ICounters->Sends); + + TpPrint1("\tPacket Sends Failed:\t\t%8lu\n",ICounters->SendFails); + TpPrint1("\tPacket Sends Pended:\t\t%8lu\n",ICounters->SendPends); + TpPrint1("\tPacket Sends Completed:\t\t%8lu\n", ICounters->SendComps); + TpPrint1("\tPacket Receives Completed:\t%8lu\n\n", ICounters->ReceiveComps); + } +} + + + +VOID +TpWriteSendReceiveResults( + PINSTANCE_COUNTERS Counters, + PIRP Irp + ) + +// ------------ +// +// Routine Description: +// +// Write the SEND test statistics into the Output buffer passed +// in by the IOCTL call. The buffer is in the Irp->MdlAddress. +// NOTE: The OpenP->SpinLock must be held when making this call. +// +// Arguments: +// +// OpenP - The location of the Irp to find the Output buffer on. +// +// Counters - The counters to write into the Output buffer into. +// +// Return Value: +// +// None. +// +// ------------- + +{ + PSEND_RECEIVE_RESULTS OutputBuffer; + + // + // Get the output buffer out of the MDL stored in the IRP, and map + // it so we may write the statistics to it. + // + + OutputBuffer = MmGetSystemAddressForMdl( Irp->MdlAddress ); + + // + // Write the statistics to the outbuffer + // + + OutputBuffer->Signature = SENDREC_RESULTS_SIGNATURE; + OutputBuffer->ResultsExist = TRUE; + + OutputBuffer->Counters.Sends = Counters->Sends; + OutputBuffer->Counters.SendPends = Counters->SendPends; + OutputBuffer->Counters.SendComps = Counters->SendComps; + OutputBuffer->Counters.SendFails = Counters->SendFails; + + OutputBuffer->Counters.Receives = Counters->Receives; + OutputBuffer->Counters.ReceiveComps = Counters->ReceiveComps; + OutputBuffer->Counters.CorruptRecs = Counters->CorruptRecs; + + OutputBuffer->Counters.XferData = Counters->XferData; + OutputBuffer->Counters.XferDataPends = Counters->XferDataPends; + OutputBuffer->Counters.XferDataComps = Counters->XferDataComps; + OutputBuffer->Counters.XferDataFails = Counters->XferDataFails; +} + + + +VOID +TpInitializePending( + PPENDING Pend + ) + +// ---------- +// +// Routine Description: +// +// This routine zeroes the counters in a PENDING_WATCH structure, and +// sets up the storage area for pending packets. +// +// Arguments: +// +// Pend - A pointer to the Pend Structure to be zeroed. +// +// Return Value: +// +// None. +// +// ---------- + +{ + INT i; + + // + // set up the pending packet storage and counters. + // + + Pend->PendingPackets = 0; + Pend->PendingRequests = 0; + Pend->PacketPendNumber = 0; + Pend->PacketCompleteNumber = 0; + + for ( i=0 ; iPackets[i] = NULL; + } +} + + + +VOID +TpInitializeStressResults( + PSTRESS_RESULTS Results + ) + +// --------- +// +// Routine Description: +// +// Arguments: +// +// Return Value: +// +// None. +// +// --------- + +{ + INT i; + + NdisZeroMemory((PVOID)Results,sizeof( STRESS_RESULTS )); + + Results->Signature = STRESS_RESULTS_SIGNATURE; + + for ( i=0;iServers[i].Signature = STRESS_RESULTS_SIGNATURE; + } +} + + +#if 0 + +// do it on a per open basis. + + +VOID +TpDumpInfo( + VOID + ) + +// -------------- +// +// Routine Description: +// +// TpDumpInfo is a debugging routine that may be called from the kernel +// debugger by resetting EIP to the entry of TpDumpInfo to dump the state +// for the Test Protocol at any given time. +// +// NOTE: This routine does not reset the stack so care must be used if +// one wishes to continue running the Test Protocol after this +// procedure has executed. This routine was designed to dump +// the state of the Protocol after a system crash. +// +// Arguments: +// +// None. +// +// Return Value: +// +// None. +// +// -------------- + +{ + static POPEN_BLOCK OpenP; + static PSTRESS_ARGUMENTS Args; + static PCLIENT_STORAGE Client; + static PSERVER_STORAGE Server; + static PGLOBAL_COUNTERS GCounters + static PINSTANCE_COUNTERS ICounters; + static INT i; + + OpenP = OpenList; + + TpPrint0("****** Open Block Structure ******\n\n"); + + TpPrint1("Ndis Handle\t\t%10lX\n",OpenP->NdisBindingHandle); + TpPrint1("Next Open Block\t\t%10lX\n",OpenP->Next); + TpPrint1("Open Instance\t\t%10ld\n",OpenP->OpenInstance); + + if ( OpenP->Media->NdisMedium == NdisMediumArcnet878_2 ) + { + TpPrint1("Machine Address \t%x\n\n", OpenP->StationAddress[0] ); + } + else + { + TpPrint6("Machine Address \t%x-%x-%x-%x-%x-%x\n\n", + OpenP->StationAddress[0],OpenP->StationAddress[1], + OpenP->StationAddress[2],OpenP->StationAddress[3], + OpenP->StationAddress[4],OpenP->StationAddress[5]); + } + + TpPrint0("****** Test Arguments Structure ******\n\n"); + + Args = OpenP->Arguments; + + TpPrint1("MemberType\t\t%10d\n",Args->MemberType); + TpPrint1"PACKET_TYPE\t\t%10d\n",Args->PacketType); + TpPrint1("Packet Size Value\t%10d\n",Args->PacketSize); + TpPrint1("PACKET_MAKEUP\t\t%10d\n",Args->PacketMakeUp); + TpPrint1("RESPONSE_TYPE\t\t%10d\n",Args->ResponseType); + TpPrint1("Iterations So Far\t%10lu\n",Args->Iterations); + TpPrint1("Total Iterations\t%10lu\n",Args->TotalIterations); + TpPrint1("Total Packets\t\t%10lu\n",Args->TotalPackets); + TpPrint1("Interpacket Delay\t%10lu\n",Args->DelayLength); + TpPrint1("All Packets Sent?\t\t%s\n",(Args->AllPacketsSent) ? "TRUE" : "FALSE"); + TpPrint1("Window Enabled?\t\t\t%s\n",(Args->WindowEnabled) ? "TRUE" : "FALSE"); + TpPrint1("Data Checking?\t\t\t%s\n",(Args->DataChecking) ? "TRUE" : "FALSE"); + TpPrint1("Packets From Pool?\t\t%s\n",(Args->PacketsFromPool) ? "TRUE" : "FALSE"); + TpPrint1("Begin Receives?\t\t\t%s\n",(Args->BeginReceives) ? "TRUE" : "FALSE"); + TpPrint1("Server Continue?\t\t\t%s\n\n",(Args->ServerContinue) ? "TRUE" : "FALSE"); + + TpPrint0("****** Global Counters Structure ******\n\n"); + + GCounters = OpenP->GlobalCounters; + + TpPrint1("Packet Sends\t\t\t%10lu\n",GCounters->Sends); + TpPrint1("Packet Receives\t\t%10lu\n",GCounters->Receives); + TpPrint1("Corrupted Packet Receives\t%10lu\n",GCounters->CorruptRecs); + TpPrint1("Invalid Protocol Receives\t%10lu\n",GCounters->InvalidPacketRecs); + + if (OpenP->Stress->Client != NULL) + { + TpPrint0("****** Client Storage Structure ******\n\n"); + + Client = OpenP->Stress->Client; + + TpPrint1("Number of Servers\t\t%10ld\n",Client->NumServers); + TpPrint1("Packet Pool\t\t\t%10lX\n",Client->PacketPool); + TpPrint1("Transmit Pool\t\t\t%10lX\n",Client->TransmitPool); + + TpPrint0("\n****** Servers with this Client ******\n\n"); + + for (i=0;iNumServers;i++) + { + TpPrint1("****** Server Number %d ******\n\n",i+1); + TpPrint1("Server Instance\t\t\t%10ld\n",Client->Servers[i].ServerInstance); + TpPrint1("Client Reference\t\t%10ld\n",Client->Servers[i].ClientReference); + TpPrint1("Server Reference\t\t\t%10ld\n",Client->Servers[i].ServerReference); + + if ( OpenP->Media->NdisMedium == NdisMediumArcnet878_2 ) + { + TpPrint1("Server[%d] Address\t%x\n",i, Client->Servers[i].Address[0]); + } + else + { + TpPrint6("Server[%d] Address\t%x-%x-%x-%x-%x-%x\n",i, + Client->Servers[i].Address[0],Client->Servers[i].Address[1], + Client->Servers[i].Address[2],Client->Servers[i].Address[3], + Client->Servers[i].Address[4],Client->Servers[i].Address[5]); + } + + TpPrint1("Sequence Number\t\t\t%10lu\n",Client->Servers[i].SequenceNumber); + TpPrint1("Max Sequence Number\t\t%10lu\n",Client->Servers[i].MaxSequenceNumber); + TpPrint1("Packet Delay\t\t\t%10lu\n\n", Client->Servers[i].PacketDelay); + + ICounters = Client->Servers[i].Counters; + + TpPrint1("****** Server Number %d's Counters ******\n\n",i+1); + TpPrint1("Packet Sends\t\t\t%10lu\n",ICounters->Sends); + TpPrint1("Packet Send Pends\t\t%10lu\n",ICounters->SendPends); + TpPrint1("Packet Send Completes\t\t%10lu\n",ICounters->SendComps); + TpPrint1("Packet Send Fails\t\t%10lu\n",ICounters->SendFails); + TpPrint1("Packet Receives\t\t\t%10lu\n",ICounters->Receives); + TpPrint1("Corrupted Packet Receives\t%10lu\n",ICounters->CorruptRecs); + } + } + + if (OpenP->Stress->Server != NULL) + { + TpPrint0("****** Server Storage Structure ******\n\n"); + + Server = OpenP->Stress->Server; + + TpPrint1("Number of Clients\t%10ld\n",Server->NumClients); + TpPrint1("Number of Active Clients%10ld\n",Server->ActiveClients); + TpPrint1("Packet Pool\t\t%10lX\n",Server->PacketPool); + TpPrint1("Transmit Pool\t\t%10lX\n\n",Server->TransmitPool); + + TpPrint0("******Clients with this Server******\n\n"); + + for (i=0;iNumClients;i++) + { + TpPrint1("****** Client Number %d ******\n\n",i+1); + TpPrint1("Client Instance\t\t%10ld\n",Server->Clients[i].ClientInstance); + TpPrint1("Client Reference\t%10ld\n",Server->Clients[i].ClientReference); + TpPrint1("Data Checking\t\t\t%s\n", + (Server->Clients[i].DataChecking) ? "TRUE" : "FALSE"); + + if ( OpenP->Media->NdisMedium == NdisMediumArcnet878_2 ) + { + TpPrint1("Client[%d] Address\t%x\n\n",i, Server->Clients[i].Address[0]); + } + else + { + TpPrint6("Client[%d] Address\t%x-%x-%x-%x-%x-%x\n\n",i, + Server->Clients[i].Address[0],Server->Clients[i].Address[1], + Server->Clients[i].Address[2],Server->Clients[i].Address[3], + Server->Clients[i].Address[4],Server->Clients[i].Address[5]); + } + + ICounters = Server->Clients[i].Counters; + + TpPrint1("****** Client Number %d's ICountersers ******\n\n",i); + TpPrint1("Packet Sends\t\t\t%10lu\n",ICounters->Sends); + TpPrint1("Packet Send Pends\t\t%10lu\n",ICounters->SendPends); + TpPrint1("Packet Send Completes\t\t%10lu\n",ICounters->SendComps); + TpPrint1("Packet Send Fails\t\t%10lu\n",ICounters->SendFails); + TpPrint1("Packet Receives\t\t\t%10lu\n",ICounters->Receives); + TpPrint1("Corrupted Packet Receives\t%10lu\n",ICounters->CorruptRecs); + } + } + + TpPrint0("\n\n\n"); + + ASSERT( FALSE ); +} + +#endif + -- cgit v1.2.3