/* BEGIN_ICS_COPYRIGHT7 ****************************************

Copyright (c) 2015-2020, Intel Corporation

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,

      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

      documentation and/or other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its contributors

      may be used to endorse or promote products derived from this software

      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

** END_ICS_COPYRIGHT7   ****************************************/

/* [ICS VERSION STRING: unknown] */

#include "sm_l.h"

#include "pm_l.h"

#include <iba/ibt.h>

#include "pm_topology.h"

#include "sm_dbsync.h"

#include <limits.h>

#include "if3.h"

// Dispatcher Design.

// The dispatcher has 4 primary entry points:

// PmSweepAllPortCounters - used by PMEngine to start a sweep

// DispatchNodeCallback - callback when a Node level single packet response or timeout

// DispatchPacketCallback - callback when a Node level multi-packet response or timeout

//

// Each entry point is responsible for progressing the PM sweep.

// They do this by ensuring the configured number of parallel nodes and ports

// per node are in progress.  As such a single call could issue one or

// more packets.  Each call must hence be diligent in trying to find work to

// be done, especially if a given port or node is now done.

//

// Each call returns:

// 	VSTATUS_OK - as much work as possible is in progress

// 				- typically indicates new work was started.  Could also

// 					indicate that while a port finished on a node, and there

// 					are no other ports to start, there are other ports not yet

// 					done so we can't start anything else

// 	VSTATUS_NOT_FOUND - did not start any new work

// 	other - assorted errors from low level routines, did not start any new work

//

// One complicating factor is when send's fail immediately.  This is atypical

// but could be caused by problems in the IB stack or perhaps if the local

// port is down.  In this case, the call will continue to try and find other

// work.  Send failures could be transient or perhaps due to a simple problem

// like a duplicate TID.

//

// Each entry point starts from a different perspective (fabric, node or port)

// and tries to find work.  It does this by checking state for the node/port

// it is focused on, and if there is no more work to be done for that node/port

// it must advance to a different node/port.  Once the last port on a device is

// completed, it must advance to a different node, until there are no nodes left

// or until all the possible work is started.

//

// The walking to new Nodes is done only in these three routines.  As such

// when the processing of a given Node or Port is completed, these callers

// will try to start work on the next node available (and may conclude there is

// no new work to be started)

//

// A special case is the rare case of a Send call failing.

// The present approach is for the callback to immediately try to find other

// work (B below).

// An alternative approach is to ignore the Send failure and let the

// cs_context aging and timeout mechanisms handle it (A below)

// This is a trade-off between:

// A. Increasing the PM sweep time when some or all sends fail

// B. spending more time in a callback to search/try more work

static Status_t DispatchNextPacket(Pm_t *pm, PmDispatcherNode_t *dispnode, PmDispatcherPacket_t *disppacket);

static uint8 DispatcherStartSweepAllPorts(Pm_t *pm, PmDispatcherNode_t *dispnode);

static Status_t DispatchNextNode(Pm_t *pm, PmDispatcherNode_t *dispnode);

static Status_t DispatchNodeNextStep(Pm_t *pm, PmNode_t *pmnodep, PmDispatcherNode_t *dispnode);

static Status_t DispatchPacketNextStep(Pm_t *pm, PmDispatcherNode_t *dispnode, PmDispatcherPacket_t *disppacket);

static void DispatchPacketCallback(cntxt_entry_t *entry, Status_t status, void *data, Mai_t *mad);

static void DispatchNodeCallback(cntxt_entry_t *entry, Status_t status, void *data, Mai_t *mad);

static void DispatchPacketDone(Pm_t *pm, PmDispatcherPacket_t *disppacket);

static void DispatchNodeDone(Pm_t *pm, PmDispatcherNode_t *dispnode); 

int MergePortIntoPacket(Pm_t *pm, PmDispatcherNode_t *dispnode, PmPort_t *pmportp, PmDispatcherPacket_t *disppacket);

size_t CalculatePortInPacket(PmDispatcherNode_t *dispnode, PmDispatcherPacket_t *disppacket);

#define CHECK_NEED_CLEAR(dispnode, portNum) \

	((dispnode)->info.needClear[(portNum)/64] & ((uint64)1 << ((portNum) % 64)))

#define SET_NEED_CLEAR(dispnode, portNum) \

	(dispnode)->info.needClear[(portNum)/64] |= ((uint64)1 << ((portNum) % 64))

// -------------------------------------------------------------------------

// Utility routines

// -------------------------------------------------------------------------

static void PmFailNodeQuery(cntxt_entry_t *entry, PmDispatcherNode_t *dispnode, uint8 method, uint16 aid)

{

	dispnode->info.u.s.failed = 1;

	PmFailNode(dispnode->pm, dispnode->info.pmnodep, PM_QUERY_STATUS_FAIL_QUERY, method, aid);

	if (entry)

		cs_cntxt_retire_nolock( entry, &dispnode->pm->Dispatcher.cntx  );

	DispatchNodeDone(dispnode->pm, dispnode);

}

static void PmFailPacketClear(cntxt_entry_t *entry, PmDispatcherPacket_t *disppacket, uint8 method, uint16 aid)

{

	PmDispatcherNode_t *dispnode = disppacket->dispnode;

	dispnode->info.u.s.failed = 1;

	PmFailPacket(dispnode->pm, disppacket, PM_QUERY_STATUS_FAIL_CLEAR, method, aid);

	if (entry)

		cs_cntxt_retire_nolock( entry, &dispnode->pm->Dispatcher.cntx  );

	DispatchPacketDone(dispnode->pm, disppacket);

}

static void PmFailPacketQuery(cntxt_entry_t *entry, PmDispatcherPacket_t *disppacket, uint8 method, uint16 aid)

{

	PmDispatcherNode_t *dispnode = disppacket->dispnode;

	dispnode->info.u.s.failed = 1;

	PmFailPacket(dispnode->pm, disppacket, PM_QUERY_STATUS_FAIL_QUERY, method, aid);

	if (entry)

		cs_cntxt_retire_nolock( entry, &dispnode->pm->Dispatcher.cntx  );

	DispatchPacketDone(dispnode->pm, disppacket);

}

static void PmNodeMadFail(Mai_t *mad, PmNode_t *pmnodep)

{

	IB_LOG_WARN_FMT(__func__, "PMA response for %s(%s) with bad status: 0x%x From %.*s Guid "FMT_U64" LID 0x%x",

		StlPmMadMethodToText(mad->base.method), StlPmMadAttributeToText(mad->base.aid), mad->base.status,

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid);

}

static void PmMadFailNodeQuery(cntxt_entry_t *entry, Mai_t *mad, PmDispatcherNode_t *dispnode)

{

	PmNodeMadFail(mad, dispnode->info.pmnodep);

	PmFailNodeQuery(entry, dispnode, mad->base.method, mad->base.aid);

}

static void PmPacketMadFail(Mai_t *mad, PmDispatcherPacket_t *disppacket)

{

#ifndef VIEO_TRACE_DISABLED

	PmNode_t *pmnodep = disppacket->dispnode->info.pmnodep;

	IB_LOG_WARN_FMT(__func__, "PMA response for %s(%s) with bad status: 0x%x From %.*s Guid "FMT_U64" LID 0x%x Ports %u",

		StlPmMadMethodToText(mad->base.method), StlPmMadAttributeToText(mad->base.aid), mad->base.status,

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, (mad->base.amod >> 24) & 0xFF);

#endif

}

static void PmMadFailPacketQuery(cntxt_entry_t *entry, Mai_t *mad, PmDispatcherPacket_t *disppacket)

{

	PmPacketMadFail(mad, disppacket);

	PmFailPacketQuery(entry, disppacket, mad->base.method, mad->base.aid);

}

static void PmNodeMadAttrWrong(Mai_t *mad, PmNode_t *pmnodep)

{

	IB_LOG_WARN_FMT(__func__, "PMA response for %s(%s) with wrong Attr: 0x%x From %.*s Guid "FMT_U64" LID 0x%x",

		StlPmMadMethodToText(mad->base.method), StlPmMadAttributeToText(mad->base.aid), mad->base.aid,

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid);

}

static void PmMadAttrWrongNodeQuery(cntxt_entry_t *entry, Mai_t *mad, PmDispatcherNode_t *dispnode)

{

	PmNodeMadAttrWrong(mad, dispnode->info.pmnodep);

	PmFailNodeQuery(entry, dispnode, mad->base.method, mad->base.aid);

}

static void PmNodeMadSelectWrong(Mai_t *mad, PmNode_t *pmnodep)

{

	IB_LOG_WARN_FMT(__func__, "PMA response for %s(%s) with wrong Port/VL Select From %.*s Guid "FMT_U64" LID 0x%x",

		StlPmMadMethodToText(mad->base.method), StlPmMadAttributeToText(mad->base.aid),

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid);

}

static void PmMadAttrWrongPacketQuery(cntxt_entry_t *entry, Mai_t *mad, PmDispatcherPacket_t *disppacket)

{

	PmNodeMadAttrWrong(mad, disppacket->dispnode->info.pmnodep);

	PmFailPacketQuery(entry, disppacket, mad->base.method, mad->base.aid);

}

static void PmMadSelectWrongPacketQuery(cntxt_entry_t *entry, Mai_t *mad, PmDispatcherPacket_t *disppacket)

{

	PmNodeMadSelectWrong(mad, disppacket->dispnode->info.pmnodep);

	PmFailPacketQuery(entry, disppacket, mad->base.method, mad->base.aid);

}

// Dispatcher Perf globals

static PmDispPerfMap_t g_pm_disp_perf_map[] = {

	{ STL_PM_ATTRIB_ID_CLASS_PORTINFO,      STL_NODE_FI, MMTHD_GET, offsetof(PmDispatcherPerf_t, hfi_get_cpi) },

	{ STL_PM_ATTRIB_ID_CLASS_PORTINFO,      STL_NODE_SW, MMTHD_GET, offsetof(PmDispatcherPerf_t, sw_get_cpi) },

	{ STL_PM_ATTRIB_ID_PORT_STATUS,         STL_NODE_FI, MMTHD_GET, offsetof(PmDispatcherPerf_t, hfi_get_cntrs) },

	{ STL_PM_ATTRIB_ID_DATA_PORT_COUNTERS,  STL_NODE_SW, MMTHD_GET, offsetof(PmDispatcherPerf_t, sw_get_data_cntrs) },

	{ STL_PM_ATTRIB_ID_ERROR_PORT_COUNTERS, STL_NODE_SW, MMTHD_GET, offsetof(PmDispatcherPerf_t, sw_get_error_cntrs) },

	{ STL_PM_ATTRIB_ID_CLEAR_PORT_STATUS,   STL_NODE_FI, MMTHD_SET, offsetof(PmDispatcherPerf_t, hfi_clr_cntrs) },

	{ STL_PM_ATTRIB_ID_CLEAR_PORT_STATUS,   STL_NODE_SW, MMTHD_SET, offsetof(PmDispatcherPerf_t, sw_clr_cntrs) },

	{ STL_PM_ATTRIB_ID_ERROR_INFO,          STL_NODE_FI, MMTHD_GET, offsetof(PmDispatcherPerf_t, hfi_get_error_info) },

	{ STL_PM_ATTRIB_ID_ERROR_INFO,          STL_NODE_SW, MMTHD_GET, offsetof(PmDispatcherPerf_t, sw_get_error_info) },

	{ STL_PM_ATTRIB_ID_ERROR_INFO,          STL_NODE_FI, MMTHD_SET, offsetof(PmDispatcherPerf_t, hfi_set_error_info) },

	{ STL_PM_ATTRIB_ID_ERROR_INFO,          STL_NODE_SW, MMTHD_SET, offsetof(PmDispatcherPerf_t, sw_set_error_info) },

	{ 0 }

};

// Dispatcher Perf Functions

void PmDispatcherPerfInit(PmDispatcherPerf_t *perf)

{

	memset(perf, 0, sizeof(PmDispatcherPerf_t));

	g_pmDebugPerf = pm_config.pm_debug_perf;

}

static PmDispatcherPerfPhase_t *PmDispatcherPerfGetPhase(Pm_t *pm, uint16_t aid, uint8_t node_type, uint8_t method)

{

	int i;

	for (i = 0; g_pm_disp_perf_map[i].phase_aid; i++) {

		if (g_pm_disp_perf_map[i].phase_aid == aid

			&& g_pm_disp_perf_map[i].phase_node_type == node_type

			&& g_pm_disp_perf_map[i].phase_method == method)

		{

			return (PmDispatcherPerfPhase_t *)(((size_t)&pm->Dispatcher.perf_stats) + g_pm_disp_perf_map[i].phase_offset);

		}

	}

	return NULL;

}

void PmDispatcherPerfCalcStart(Pm_t *pm, Mai_t *mad, PmNode_t *pmnodep)

{

	PmDispatcherPerfPhase_t *phase = PmDispatcherPerfGetPhase(pm, mad->base.aid, pmnodep->nodeType, mad->base.method);

	if (phase && phase->phase_start == 0) {

		(void)vs_time_get(&phase->phase_start);

		phase->min_roundtrip_time = (uint64_t )-1;

	}

}

void PmDispatcherPerfCalcPost(Pm_t *pm, Mai_t *mad, cntxt_entry_t *entry, PmNode_t *pmnodep)

{

	PmDispatcherPerfPhase_t *phase = PmDispatcherPerfGetPhase(pm, mad->base.aid, pmnodep->nodeType, entry->mad.base.method);

	uint64_t roundtrip = mad->intime - entry->tstamp;

	if (phase == NULL) return;

	/* Update end phase time (last packet received) */

	phase->phase_end = mad->intime;

	phase->phase_count++;

	if (roundtrip < phase->min_roundtrip_time) {

		phase->min_roundtrip_time = roundtrip;

	}

	if (roundtrip > phase->max_roundtrip_time) {

		phase->max_roundtrip_time = roundtrip;

	}

	phase->sum_roundtrip_time += roundtrip;

}

static void PmDispatcherPerfEndHelper(PmDispatcherPerfPhase_t *phase, const char *phase_str)

{

	uint64_t avg_roundtrip_time = 0;

	if (phase->phase_count > 0) {

		avg_roundtrip_time = phase->sum_roundtrip_time / phase->phase_count;

	}

	IB_LOG_INFINI_INFO_FMT("PmDispatcherPerf", "%s, %"PRIu64", %"PRIu64", %"PRIu64", %"PRIu64", %"PRIu64,

		phase_str, phase->phase_count, (phase->phase_end - phase->phase_start),

		avg_roundtrip_time, phase->min_roundtrip_time, phase->max_roundtrip_time);

	avg_roundtrip_time = 0;

}

void PmDispatcherPerfEnd(Pm_t *pm)

{

	int i;

	char phase_desc[64];

	PmDispatcherPerfPhase_t *phase;

	IB_LOG_INFINI_INFO_FMT("PmDispatcherPerf", "Phase, NodeType, Pkt Count, Phase Time, RoundTrip (avg), RT (min), RT (max)");

	for (i = 0; g_pm_disp_perf_map[i].phase_aid; i++) {

		phase = PmDispatcherPerfGetPhase(pm, g_pm_disp_perf_map[i].phase_aid,

			g_pm_disp_perf_map[i].phase_node_type, g_pm_disp_perf_map[i].phase_method);

		if (phase) {

			snprintf(phase_desc, 64, "%s(%s), %s",

				StlPmMadMethodToText(g_pm_disp_perf_map[i].phase_method),

				StlPmMadAttributeToText(g_pm_disp_perf_map[i].phase_aid),

				StlNodeTypeToText(g_pm_disp_perf_map[i].phase_node_type));

			PmDispatcherPerfEndHelper(phase, phase_desc);

		}

	}

	IB_LOG_INFINI_INFO_FMT("Total DispatchCallback", "%"PRIu64,

		pm->Dispatcher.perf_stats.callback_calc_time);

}

// Copy port counters in STL_PORT_STATUS_RSP to port counters as referenced

//   by PmDispatcherPort_t.pPortImage->StlPortCounters/StlVLPortCounters

static void PmCopyPortStatus(STL_PORT_STATUS_RSP *madp, PmDispatcherPacket_t * disppacket)

{

	uint32 vl, i, vlSelMask;

	size_t size_counters;

	PmCompositePortCounters_t * pCounters = &disppacket->DispPorts[0].pPortImage->StlPortCounters;

	PmCompositeVLCounters_t * pVlCounters = &disppacket->DispPorts[0].pPortImage->StlVLPortCounters[0];

	PmCompositePortCounters_t * pCountersPrev;

#ifndef VIEO_TRACE_DISABLED

	PmPort_t *pmportp = disppacket->DispPorts[0].pmportp;

	PmNode_t *pmnodep = pmportp->pmnodep;

	IB_LOG_DEBUG4_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x Port %u",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, pmportp->portNum);

#endif

	size_counters = (size_t)&madp->UncorrectableErrors - (size_t)&madp->PortXmitData + 1;

	memcpy( &pCounters->PortXmitData, &madp->PortXmitData, size_counters );

	pCounters->lq.s.LinkQualityIndicator = madp->lq.s.LinkQualityIndicator;

	for (vl = 0, i = 0, vlSelMask = madp->VLSelectMask; (vl < STL_MAX_VLS) && vlSelMask;

			vl++, vlSelMask >>= 1) {

		if (vlSelMask & 0x1) {

			memcpy( &pVlCounters[vl_to_idx(vl)], &madp->VLs[i++], sizeof(struct _vls_pctrs) );

		}

	}

	pCountersPrev = disppacket->DispPorts[0].pPortImagePrev ?

		&disppacket->DispPorts[0].pPortImagePrev->StlPortCounters : NULL;

	if (isErrorInfoNeeded(disppacket->dispnode->pm, pCounters, pCountersPrev)) {

		disppacket->DispPorts[0].dispNodeSwPort->flags.s.NeedsErrorInfo = 1;

		disppacket->dispnode->info.u.s.needErrorInfo = 1;

	}

}	// End of PmCopyPortStatus()

// Copy data port counters in STL_DATA_PORT_COUNTERS_RSP to port counters

//   as referenced by disppacket; VLSelectMask has been checked == 0 if

//   process_vl_counters == 0

static void PmCopyDataPortCounters(STL_DATA_PORT_COUNTERS_RSP *madp, PmDispatcherPacket_t * disppacket)

{

	uint32 i, vl, j, vlSelMask;

	size_t size_counters, size_port;

	STL_DATA_PORT_COUNTERS_RSP * respp = madp;

	PmCompositePortCounters_t * pCounters;

	PmCompositeVLCounters_t * pVlCounters;

	PmDispatcherNode_t * dispnode = disppacket->dispnode;

	PmDispatcherPort_t * dispport;

#ifndef VIEO_TRACE_DISABLED

	PmNode_t *pmnodep = dispnode->info.pmnodep;

	IB_LOG_DEBUG4_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3] "FMT_U64" VLSelectMask 0x%08x",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, madp->PortSelectMask[3], madp->VLSelectMask);

#endif

	size_port = CalculatePortInPacket(dispnode, disppacket);

	size_counters = (size_t)&madp->Port->PortErrorCounterSummary - (size_t)&madp->Port->PortXmitData;

	// Copy DataPortCounters

	for (i = 0; i < disppacket->numPorts; i++) {

		dispport = &disppacket->DispPorts[i];

		pCounters = &dispport->pPortImage->StlPortCounters;

		pVlCounters = &dispport->pPortImage->StlVLPortCounters[0];

		pCounters->lq.s.LinkQualityIndicator = respp->Port->lq.s.LinkQualityIndicator;

		memcpy(&pCounters->PortXmitData, &respp->Port->PortXmitData, size_counters);

		for ( vl = 0, j = 0, vlSelMask = madp->VLSelectMask; (vl < STL_MAX_VLS) && vlSelMask;

				vl++, vlSelMask >>= 1 ) {

			if (vlSelMask & 0x1) {

				memcpy( &pVlCounters[vl_to_idx(vl)],

					&respp->Port->VLs[j++], sizeof(struct _vls_dpctrs) );

			}

		}

		dispport->pPortImage->u.s.gotDataCntrs = 1;

		// Get Error if sum is non-zero and previous image is invalid

		//  OR get Error if previous image is valid and

		//       previous sum is different than current sum

		if ((respp->Port->PortErrorCounterSummary != 0 && dispport->pPortImagePrev == NULL)

			|| (dispport->pPortImagePrev

				&& (PM_PORT_ERROR_SUMMARY(dispport->pPortImagePrev,

					StlResolutionToShift(pm_config.resolution.LocalLinkIntegrity, RES_ADDER_LLI),

					StlResolutionToShift(pm_config.resolution.LinkErrorRecovery, RES_ADDER_LER)

					) != respp->Port->PortErrorCounterSummary) ) )

		{

			dispport->dispNodeSwPort->flags.s.NeedsError = 1;

			disppacket->dispnode->info.u.s.needError = 1;

		} else if (dispport->pPortImagePrev == NULL

			&& isErrorInfoNeeded(disppacket->dispnode->pm, pCounters, NULL))

		{

			// If the previous Image is invalid get ErrorInfo if to be safe

			disppacket->dispnode->info.u.s.needErrorInfo = 1;

			dispport->dispNodeSwPort->flags.s.NeedsErrorInfo = 1;

		}

		respp = (STL_DATA_PORT_COUNTERS_RSP *)((uint8 *)respp + size_port);

	}

}	// End of PmCopyDataPortCounters()

// Copy error port counters in STL_ERROR_PORT_COUNTERS_RSP to port counters

//   as referenced by disppacket; VLSelectMask has been checked == 0 if

//   process_vl_counters == 0

static void PmCopyErrorPortCounters(STL_ERROR_PORT_COUNTERS_RSP *madp, PmDispatcherPacket_t * disppacket)

{

	uint32 i, vl, j, vlSelMask;

	size_t size_port, size_counters;

	STL_ERROR_PORT_COUNTERS_RSP * respp = madp;

	PmCompositePortCounters_t * pCounters;

	PmCompositeVLCounters_t * pVlCounters;

	PmCompositePortCounters_t * pCountersPrev;

	PmDispatcherPort_t * dispport;

#ifndef VIEO_TRACE_DISABLED

	PmNode_t *pmnodep = disppacket->dispnode->info.pmnodep;

	IB_LOG_DEBUG4_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3] "FMT_U64" VLSelectMask 0x%08x",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, madp->PortSelectMask[3], madp->VLSelectMask);

#endif

	size_port = CalculatePortInPacket(disppacket->dispnode, disppacket);

	size_counters = (size_t)&madp->Port->UncorrectableErrors - (size_t)&madp->Port->PortRcvConstraintErrors + 1;

	// Copy ErrorPortCounters

	for (i = 0; i < disppacket->numPorts; i++) {

		dispport = &disppacket->DispPorts[i];

		pCounters = &dispport->pPortImage->StlPortCounters;

		pVlCounters = &dispport->pPortImage->StlVLPortCounters[0];

		memcpy(&pCounters->PortRcvConstraintErrors, &respp->Port->PortRcvConstraintErrors, size_counters);

		for (vl = 0, j = 0, vlSelMask = madp->VLSelectMask; (vl < STL_MAX_VLS) && vlSelMask;

				vl++, vlSelMask >>= 1) {

			if (vlSelMask & 0x1) {

				pVlCounters[vl_to_idx(vl)].PortVLXmitDiscards = respp->Port->VLs[j++].PortVLXmitDiscards;

			}

		}

		dispport->pPortImage->u.s.gotErrorCntrs = 1;

		pCountersPrev = dispport->pPortImagePrev ?

			&dispport->pPortImagePrev->StlPortCounters : NULL;

		if (isErrorInfoNeeded(disppacket->dispnode->pm, pCounters, pCountersPrev)) {

			dispport->dispNodeSwPort->flags.s.NeedsErrorInfo = 1;

			disppacket->dispnode->info.u.s.needErrorInfo = 1;

		}

		respp = (STL_ERROR_PORT_COUNTERS_RSP *)((uint8 *)respp + size_port);

	}

}	// End of PmCopyErrorPortCounters()

static void PmCopyErrorInfo(STL_ERROR_INFO_RSP *madp, PmDispatcherPacket_t * disppacket)

{

	uint32 i;

	PmCompositeErrorInfo_t * pErrorInfo;

	PmDispatcherPort_t * dispport;

#ifndef VIEO_TRACE_DISABLED

	PmNode_t *pmnodep = disppacket->dispnode->info.pmnodep;

	IB_LOG_DEBUG4_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3] "FMT_U64"",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, madp->PortSelectMask[3]);

#endif

	// Copy ErrorInfo

	for (i = 0; i < disppacket->numPorts; i++) {

		dispport = &disppacket->DispPorts[i];

		pErrorInfo = &dispport->pPortImage->ErrorInfo;

		memcpy(pErrorInfo, &madp->Port[i], sizeof(PmCompositeErrorInfo_t));

		if (isErrorInfoStatusSet(pErrorInfo)) {

			dispport->pPortImage->u.s.gotErrorInfo = 1; // We go an ErrorInfo with Status Set

			dispport->dispNodeSwPort->flags.s.NeedsClearErrorInfo = 1;

			disppacket->dispnode->info.u.s.needClearErrorInfo = 1;

		}

	}

}	// End of PmCopyErrorInfo()

// -------------------------------------------------------------------------

// PMA Outbound Mad processing

// -------------------------------------------------------------------------

static void PmSetMadAddressAndTid(Pm_t *pm, PmNode_t *pmnodep, cntxt_entry_t *entry)

{

	entry->mad.addrInfo.sl = pmnodep->sl;

	entry->mad.addrInfo.slid = pm->pm_slid;

	entry->mad.addrInfo.dlid =pmnodep->dlid;	// always set,used by redirect retry

	entry->mad.addrInfo.pkey = pmnodep->pkey;

	entry->mad.addrInfo.destqp = pmnodep->qpn;

	entry->mad.addrInfo.qkey = pmnodep->qkey;

	(void) mai_alloc_tid(hpma, MAD_CV_PERF, &entry->mad.base.tid);

	IB_LOG_DEBUG2LX("send MAD tid:", entry->mad.base.tid);

}

// returns NULL if unable to allocate an entry.  Since entry pool is pre-sized

// errors allocating the entry are unexpected.

static cntxt_entry_t *PmInitMad(Pm_t *pm, PmNode_t *pmnodep,

			uint8 method, uint32 attr, uint32 modifier)

{

    cntxt_entry_t *entry=NULL;

    if ((entry = cs_cntxt_get_nolock(NULL, &pm->Dispatcher.cntx, FALSE)) == NULL) {

        // could not get a context

        IB_LOG_ERROR0("Error allocating an PM async send/rcv context");

        //cntxt_cb(NULL, VSTATUS_BAD, cntxt_data, NULL);

		return NULL;	// let caller handle it, doing a callback could be recursive and cause a deep stack

	}

	STL_BasicMadInit(&entry->mad, MAD_CV_PERF, method, attr, modifier,

					pm->pm_slid, pmnodep->dlid, pmnodep->sl);

	PmSetMadAddressAndTid(pm, pmnodep, entry);

	if (g_pmDebugPerf) {

		PmDispatcherPerfCalcStart(pm, &entry->mad, pmnodep);

	}

	return entry;

}

// caller must retire entry on failure

static __inline Status_t PmDispatcherSend(Pm_t *pm, cntxt_entry_t *entry)

{

	// Alternative for send failures is to ignore them and let timeout fire

	// (void)cs_cntxt_send_mad_nolock (entry, &pm->Dispatcher.cntx);

	// return VSTATUS_OK;

    return cs_cntxt_send_mad_nolock (entry, &pm->Dispatcher.cntx);

}

// on success a Get(ClassPortInfo) has been sent and Dispatcher.cntx is

// ready to process the response

// On failure, no request nor context entry is outstanding.

static Status_t PmSendGetClassPortInfo(Pm_t *pm, PmDispatcherNode_t *dispnode)

{

	cntxt_entry_t *entry;

	PmNode_t *pmnodep = dispnode->info.pmnodep;

    INCREMENT_PM_COUNTER(pmCounterGetClassPortInfo);

	entry = PmInitMad(pm, pmnodep, MMTHD_GET, STL_PM_ATTRIB_ID_CLASS_PORTINFO, 0);

	if (! entry)

		goto fail;

	entry->mad.datasize = 0;

	// fill in rest of entry->mad.data as needed

	IB_LOG_DEBUG1_FMT(__func__,"%.*s Guid "FMT_U64" LID 0x%x",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid);

	cs_cntxt_set_callback(entry, DispatchNodeCallback, dispnode);

	if (VSTATUS_OK ==  PmDispatcherSend(pm, entry))

		return VSTATUS_OK;

fail:

	PmFailNodeQuery(entry, dispnode, MMTHD_GET, STL_PM_ATTRIB_ID_CLASS_PORTINFO);

	return VSTATUS_NOT_FOUND;	// no work started

}

void setPortSelectMask(uint64 *selectMask, uint8 portNum, boolean clear)

{

	// selectMask points to an array of 4 uint64s representing sel mask

	int index;

    if (clear) memset(&selectMask[0], 0, 4 * sizeof(uint64));

	// find index

	index = (3 - (portNum / 64));

	selectMask[index] |= (uint64)(1) << (portNum - (64 * (3 - index)));

	return;

}

// on success a Set(PortCounters) has been sent and Dispatcher.cntx is

// ready to process the response

// On failure, no request nor context entry is outstanding.

static Status_t PmSendClearPortStatus(Pm_t *pm, PmDispatcherNode_t *dispnode,

                                        PmDispatcherPacket_t *disppacket)

{

	cntxt_entry_t *entry;

	PmNode_t *pmnodep = dispnode->info.pmnodep;

	STL_CLEAR_PORT_STATUS *p;

	// only called if we successfully got port counters

	DEBUG_ASSERT(disppacket->DispPorts[0].pPortImage->u.s.gotDataCntrs || disppacket->DispPorts[0].pPortImage->u.s.gotErrorCntrs);

	INCREMENT_PM_COUNTER(pmCounterSetClearPortStatus);

	entry = PmInitMad(pm, pmnodep, MMTHD_SET, STL_PM_ATTRIB_ID_CLEAR_PORT_STATUS, 1 << 24);

	if (! entry)

		goto fail;

	entry->mad.datasize = sizeof(STL_CLEAR_PORT_STATUS);

	// fill in rest of entry->mad.data as needed

	p = (STL_CLEAR_PORT_STATUS *)&entry->mad.data;

	memset(p, 0, sizeof(STL_CLEAR_PORT_STATUS));

	memcpy(p->PortSelectMask, disppacket->PortSelectMask, STL_PORT_SELECTMASK_SIZE);

	p->CounterSelectMask.AsReg32 = disppacket->DispPorts[0].pPortImage->clearSelectMask.AsReg32;

	IB_LOG_DEBUG1_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3] "FMT_U64" SelMask 0x%04x",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, p->PortSelectMask[3], p->CounterSelectMask.AsReg32);

	BSWAP_STL_CLEAR_PORT_STATUS_REQ(p);

	cs_cntxt_set_callback(entry, DispatchPacketCallback, disppacket);

	if (VSTATUS_OK ==  PmDispatcherSend(pm, entry))

		return VSTATUS_OK;

fail:

	PmFailPacketClear(entry, disppacket, MMTHD_SET, STL_PM_ATTRIB_ID_CLEAR_PORT_STATUS);

	return VSTATUS_NOT_FOUND;	// no work started

}

// on success a Get(PortStatus) has been sent and Dispatcher.cntx is

// ready to process the response

// On failure, no request nor context entry is outstanding.

static Status_t PmSendGetPortStatus(Pm_t *pm, PmDispatcherNode_t *dispnode,

                                    PmDispatcherPacket_t *disppacket)

{

	cntxt_entry_t *entry;

	PmNode_t *pmnodep = dispnode->info.pmnodep;

	STL_PORT_STATUS_REQ *p;

	INCREMENT_PM_COUNTER(pmCounterGetPortStatus);

	entry = PmInitMad(pm, pmnodep, MMTHD_GET, STL_PM_ATTRIB_ID_PORT_STATUS, (disppacket->numPorts) << 24);

	if (! entry)

		goto fail;

	entry->mad.datasize = sizeof(STL_PORT_STATUS_REQ);

	// fill in rest of entry->mad.data as needed

	p = (STL_PORT_STATUS_REQ *)entry->mad.data;

	p->PortNumber = disppacket->DispPorts[0].pmportp->portNum;

	p->VLSelectMask = disppacket->VLSelectMask;

	memset(p->Reserved, 0, sizeof(p->Reserved));

	IB_LOG_DEBUG1_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x Port %d",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, disppacket->DispPorts[0].pmportp->portNum);

	BSWAP_STL_PORT_STATUS_REQ(p);

	cs_cntxt_set_callback(entry, DispatchPacketCallback, disppacket);

	if (VSTATUS_OK ==  PmDispatcherSend(pm, entry))

		return VSTATUS_OK;

fail:

	PmFailPacketQuery(entry, disppacket, MMTHD_GET, STL_PM_ATTRIB_ID_PORT_STATUS);

	return VSTATUS_NOT_FOUND;	// no work started

}	// End of PmSendGetPortStatus()

// on success a Get(DataPortCounters) has been sent and Dispatcher.cntx is

// ready to process the response

// On failure, no request nor context entry is outstanding.

static Status_t PmSendGetDataPortCounters(Pm_t *pm, PmDispatcherNode_t *dispnode,

                                          PmDispatcherPacket_t *disppacket)

{

	cntxt_entry_t *entry;

	PmNode_t *pmnodep = dispnode->info.pmnodep;

	STL_DATA_PORT_COUNTERS_REQ *p;

	INCREMENT_PM_COUNTER(pmCounterGetDataPortCounters);

	entry = PmInitMad(pm, pmnodep, MMTHD_GET, STL_PM_ATTRIB_ID_DATA_PORT_COUNTERS, (disppacket->numPorts) << 24);

	if (! entry)

		goto fail;

	entry->mad.datasize = sizeof(STL_DATA_PORT_COUNTERS_REQ);

	// fill in rest of entry->mad.data as needed

	p = (STL_DATA_PORT_COUNTERS_REQ *)entry->mad.data;

	memcpy(p->PortSelectMask, disppacket->PortSelectMask, STL_PORT_SELECTMASK_SIZE);

	p->VLSelectMask = disppacket->VLSelectMask;

	p->res.s.LocalLinkIntegrityResolution = StlResolutionToShift(pm_config.resolution.LocalLinkIntegrity, RES_ADDER_LLI);

	p->res.s.LinkErrorRecoveryResolution = StlResolutionToShift(pm_config.resolution.LinkErrorRecovery, RES_ADDER_LER);

	IB_LOG_DEBUG1_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3]: "FMT_U64,

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, p->PortSelectMask[3]);

	BSWAP_STL_DATA_PORT_COUNTERS_REQ(p);

	cs_cntxt_set_callback(entry, DispatchPacketCallback, disppacket);

	if (VSTATUS_OK ==  PmDispatcherSend(pm, entry))

		return VSTATUS_OK;

fail:

	PmFailPacketQuery(entry, disppacket, MMTHD_GET, STL_PM_ATTRIB_ID_DATA_PORT_COUNTERS);

	return VSTATUS_NOT_FOUND;	// no work started

}	// End of PmSendGetDataPortCounters()

// on success a Get(ErrorPortCounters) has been sent and Dispatcher.cntx is

// ready to process the response

// On failure, no request nor context entry is outstanding.

static Status_t PmSendGetErrorPortCounters(Pm_t *pm, PmDispatcherNode_t *dispnode,

                                           PmDispatcherPacket_t *disppacket)

{

	cntxt_entry_t *entry;

	PmNode_t *pmnodep = dispnode->info.pmnodep;

	STL_ERROR_PORT_COUNTERS_REQ *p;

	INCREMENT_PM_COUNTER(pmCounterGetErrorPortCounters);

	entry = PmInitMad(pm, pmnodep, MMTHD_GET, STL_PM_ATTRIB_ID_ERROR_PORT_COUNTERS, (disppacket->numPorts) << 24);

	if (! entry)

		goto fail;

	entry->mad.datasize = sizeof(STL_ERROR_PORT_COUNTERS_REQ);

	// fill in rest of entry->mad.data as needed

	p = (STL_ERROR_PORT_COUNTERS_REQ *)entry->mad.data;

	memcpy(p->PortSelectMask, disppacket->PortSelectMask, STL_PORT_SELECTMASK_SIZE);

	p->VLSelectMask = disppacket->VLSelectMask;

	IB_LOG_DEBUG1_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3]: "FMT_U64" VLSelectMask 0x%08x",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, p->PortSelectMask[3], p->VLSelectMask);

	BSWAP_STL_ERROR_PORT_COUNTERS_REQ(p);

	cs_cntxt_set_callback(entry, DispatchPacketCallback, disppacket);

	if (VSTATUS_OK ==  PmDispatcherSend(pm, entry))

		return VSTATUS_OK;

fail:

	PmFailPacketQuery(entry, disppacket, MMTHD_GET, STL_PM_ATTRIB_ID_ERROR_PORT_COUNTERS);

	return VSTATUS_NOT_FOUND;	// no work started

}	// End of PmSendGetErrorPortCounters()

static Status_t PmSendGetErrorInfo(Pm_t *pm, PmDispatcherNode_t *dispnode, PmDispatcherPacket_t *disppacket)

{

	cntxt_entry_t *entry;

	PmNode_t *pmnodep = dispnode->info.pmnodep;

	STL_ERROR_INFO_REQ *p;

	INCREMENT_PM_COUNTER(pmCounterGetErrorInfo);

	entry = PmInitMad(pm, pmnodep, MMTHD_GET, STL_PM_ATTRIB_ID_ERROR_INFO, (disppacket->numPorts) << 24);

	if (! entry)

		goto fail;

	entry->mad.datasize = sizeof(STL_ERROR_INFO_REQ);

	// fill in rest of entry->mad.data as needed

	p = (STL_ERROR_INFO_REQ *)entry->mad.data;

	memcpy(p->PortSelectMask, disppacket->PortSelectMask, STL_PORT_SELECTMASK_SIZE);

	IB_LOG_DEBUG1_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3]: "FMT_U64"",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, p->PortSelectMask[3]);

	BSWAP_STL_ERROR_INFO_REQ(p);

	cs_cntxt_set_callback(entry, DispatchPacketCallback, disppacket);

	if (VSTATUS_OK ==  PmDispatcherSend(pm, entry))

		return VSTATUS_OK;

fail:

	PmFailPacketQuery(entry, disppacket, MMTHD_GET, STL_PM_ATTRIB_ID_ERROR_INFO);

	return VSTATUS_NOT_FOUND;	// no work started

}	// End of PmSendGetErrorInfo()

static Status_t PmSendClearErrorInfo(Pm_t *pm, PmDispatcherNode_t *dispnode, PmDispatcherPacket_t *disppacket)

{

	cntxt_entry_t *entry;

	PmNode_t *pmnodep = dispnode->info.pmnodep;

	STL_ERROR_INFO_REQ *p;

	INCREMENT_PM_COUNTER(pmCounterSetErrorInfo);

	entry = PmInitMad(pm, pmnodep, MMTHD_SET, STL_PM_ATTRIB_ID_ERROR_INFO, (disppacket->numPorts) << 24);

	if (! entry)

		goto fail;

	entry->mad.datasize = sizeof(STL_ERROR_INFO_REQ);

	// fill in rest of entry->mad.data as needed

	p = (STL_ERROR_INFO_REQ *)entry->mad.data;

	memcpy(p->PortSelectMask, disppacket->PortSelectMask, STL_PORT_SELECTMASK_SIZE);

	p->ErrorInfoSelectMask.AsReg32 = IB_UINT32_MAX;

	p->ErrorInfoSelectMask.s.Reserved = 0;

	IB_LOG_DEBUG1_FMT(__func__, "%.*s Guid "FMT_U64" LID 0x%x PortSelectMask[3]: "FMT_U64"",

		(int)sizeof(pmnodep->nodeDesc.NodeString), pmnodep->nodeDesc.NodeString,

		pmnodep->NodeGUID, pmnodep->dlid, p->PortSelectMask[3]);

	BSWAP_STL_ERROR_INFO_REQ(p);

	cs_cntxt_set_callback(entry, DispatchPacketCallback, disppacket);

	if (VSTATUS_OK ==  PmDispatcherSend(pm, entry))

		return VSTATUS_OK;

fail:

	PmFailPacketClear(entry, disppacket, MMTHD_SET, STL_PM_ATTRIB_ID_ERROR_INFO);

	return VSTATUS_NOT_FOUND;	// no work started

}	// End of PmSendGetErrorInfo()

static void DispatchPacketDone(Pm_t *pm, PmDispatcherPacket_t *disppacket)

{

	PmDispatcherNode_t *dispnode = disppacket->dispnode;

	IB_LOG_DEBUG3_FMT(__func__,"%.*s Guid "FMT_U64" LID 0x%x",

		(int)sizeof(dispnode->info.pmnodep->nodeDesc.NodeString), dispnode->info.pmnodep->nodeDesc.NodeString,

		dispnode->info.pmnodep->NodeGUID, dispnode->info.pmnodep->dlid);

	DEBUG_ASSERT(dispnode->info.state != PM_DISP_NODE_DONE);

	// if dispport->failed,

	// 		then already incremented pm->Image[pm->SweepIndex].NoRespPorts

	dispnode->info.numOutstandingPackets--;

	//Cleanup DispPacket

	memset(disppacket->PortSelectMask, 0, sizeof(uint64)*4);

	disppacket->numPorts = 0;

	vs_pool_free(&pm_pool, (void *)disppacket->DispPorts);

	disppacket->DispPorts = NULL;

}

// -------------------------------------------------------------------------

// PM Packet Processing State Machine

// -------------------------------------------------------------------------

// cs_send_mad callback for all operations against multiple ports

static void DispatchPacketCallback(cntxt_entry_t *entry, Status_t status, void *data, Mai_t *mad)

{

	PmDispatcherPacket_t *disppacket = (PmDispatcherPacket_t *)data;

	PmDispatcherNode_t *dispnode = disppacket->dispnode;

	PmDispatcherPort_t *dispport;

	STL_CLEAR_PORT_STATUS *clearPortStatusMad;

	uint64_t sTime, eTime;

	if (g_pmDebugPerf) {

		(void)vs_time_get(&sTime);

	}

	IB_LOG_DEBUG3_FMT( __func__,"%.*s Guid "FMT_U64" LID 0x%x NodeState %u Ports %u PortSelectMask[3] "FMT_U64,

		(int)sizeof(dispnode->info.pmnodep->nodeDesc.NodeString), dispnode->info.pmnodep->nodeDesc.NodeString,

		dispnode->info.pmnodep->NodeGUID, dispnode->info.pmnodep->dlid, dispnode->info.state,

		disppacket->numPorts, disppacket->PortSelectMask[3] );

	switch (dispnode->info.state) {

	case PM_DISP_NODE_GET_DATACOUNTERS:

		if (dispnode->info.pmnodep->nodeType == STL_NODE_FI) {

			if (status != VSTATUS_OK || mad == NULL) {

				PmFailPacketQuery(entry, disppacket, (mad ? mad->base.method : MMTHD_GET),

								  (mad ? mad->base.aid : STL_PM_ATTRIB_ID_PORT_STATUS) );

				goto nextpacket;	// PacketDone called on Fail

			} else if (mad->base.status != MAD_STATUS_SUCCESS) {

				PmMadFailPacketQuery(entry, mad, disppacket);

				goto nextpacket;	// PacketDone called on Fail

			} else {

				// process port status

				{

					STL_PORT_STATUS_RSP *portStatusMad = (STL_PORT_STATUS_RSP *)&mad->data;

					BSWAP_STL_PORT_STATUS_RSP(portStatusMad);

					PmCopyPortStatus(portStatusMad, disppacket);

				}

				dispport = &disppacket->DispPorts[0];

				dispport->pPortImage->u.s.gotDataCntrs = 1;

				dispport->pPortImage->u.s.gotErrorCntrs = 1;

			}

		} else if (dispnode->info.pmnodep->nodeType == STL_NODE_SW) {

			if (status != VSTATUS_OK || mad == NULL) {

				PmFailPacketQuery(entry, disppacket, (mad ? mad->base.method : MMTHD_GET),

					(mad ? mad->base.aid : STL_PM_ATTRIB_ID_DATA_PORT_COUNTERS) );

				goto nextpacket;	// PacketDone called on Fail

			} else if (mad->base.status != MAD_STATUS_SUCCESS) {

				PmMadFailPacketQuery(entry, mad, disppacket);

				goto nextpacket;	// PacketDone called on Fail

			}

			{

				if (mad->base.aid != STL_PM_ATTRIB_ID_DATA_PORT_COUNTERS) {

					PmMadAttrWrongPacketQuery(entry, mad, disppacket);

					goto nextpacket;    // PacketDone called on Fail

				}

				STL_DATA_PORT_COUNTERS_RSP *dataPortCountersMad = (STL_DATA_PORT_COUNTERS_RSP *)&mad->data;

				BSWAP_STL_DATA_PORT_COUNTERS_RSP(dataPortCountersMad);

				if ((memcmp(dataPortCountersMad->PortSelectMask, disppacket->PortSelectMask, sizeof(uint64)*4) != 0) ||

					(dataPortCountersMad->VLSelectMask != disppacket->VLSelectMask)) {

					PmMadSelectWrongPacketQuery(entry, mad, disppacket);