/* 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] */

#ifdef IB_STACK_OPENIB


#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <assert.h>
#include <ctype.h>
#include <string.h>
#include <errno.h>

#include <infiniband/umad_types.h>
#include <infiniband/verbs.h>
#include <infiniband/umad.h>
#include <infiniband/umad_sa.h>
#include <infiniband/umad_sm.h>

#define OPAMGT_PRIVATE 1

// Includes / Defines from IBACCESS
#include "ibt.h"
#include "opamgt_priv.h"
#include "ib_utils_openib.h"
#include "stl_pa_priv.h"
#include "ib_mad.h"
#include "opamgt_dump_mad.h"
#include "stl_sd.h"
#include "stl_pm.h"
#include "opamgt_pa_priv.h"
#include "opamgt_sa_priv.h"

/************************************** 
 * Defines and global variables 
 **************************************/

#define IB_SA_DATA_OFFS         56

#define MAX_PORTS_LIST          300000  // Max number of ports in port list

#define OPAMGT_MAD_SIZE      256
#define OPAMGT_DEF_RETRIES   3
#define MAD_STATUS_PA_MINIMUM   0x0A00

// from ib_sa.h
#define	PR_COMPONENTMASK_SRV_ID	0x0000000000000001ull
#define	PR_COMPONENTMASK_DGID	0x0000000000000004ull
#define	PR_COMPONENTMASK_SGID	0x0000000000000008ull

//from ib_sa_records.h
#define IB_MULTIPATH_RECORD_COMP_NUMBPATH	0x00000040

static uint8_t ib_truescale_oui[] = {OUI_TRUESCALE_0, OUI_TRUESCALE_1, OUI_TRUESCALE_2};

static const char* const pa_query_input_type_text[] = 
{
    "InputTypeNoInput",
};

static const char* const pa_query_result_type_text[] = 
{
    "OutputTypePaTableRecord",        /* PA_TABLE_PACKET_RESULTS complete PA MultiPacketRespRecords */
};

static const char* const pa_sa_status_text[] =
{
    "Success",  // not used by code below
	"PA: Insufficient Resources",             //  0x0100 NO_RESOURCES
	"PA: Invalid Request",                    //  0x0200 REQ_INVALID
	"PA: No Records",                         //  0x0300 NO_RECORDS
	"PA: Too Many Records",                   //  0x0400 TOO_MANY_RECORDS
	"PA: Invalid GID in Request",             //  0x0500 REQ_INVALID_GID
	"PA: Insufficient Components in Request", //  0x0600 REQ_INSUFFICIENT_COMPONENT
};
static const char* const pa_status_text[] =
{
    "Success",  // not used by code below
    "PA: PM Engine Unavailable",			//0x0A00 - Engine unavailable
    "PA: Group Not Found",  				//0x0B00 - No such group
    "PA: Port Not Found", 					//0x0C00 - Port not found
    "PA: Virtual Fabric Not Found", 		//0x0D00 - VF not found
    "PA: Invalid Parameter",  				//0x0E00 - Invalid parameter
    "PA: Image Not Found",  				//0x0F00 - Image not found
    "PA: No Data",  					//0x1000 - no data skipped port
    "PA: Bad Data",  					//0x1100 - query fail or clear fail
};

/**************************************** 
 * Prototypes
 ****************************************/


/******************************************************** 
 * Local file functions
 *******************************************************/

/** 
 *  Send a PA query and get the result.
 * 
 * @param port              The port from which we access the fabric.
 * @param method            PA method identifier.
 * @param attr_id           PA attribute identifier
 * @param attr_mod          PA attribute modifier
 * @param snd_data          Outbound request data.
 * @param snd_data_len      Outbound request data length.
 * @param rcv_buf_len       Max rcv buffer length (required for OFED driver)
 * @param rsp_mad           Response MAD packet. The caller should free it after use.
 * @param query_result      Query return result (pointer to pointer to the query result). Allocated
 *                          here if successful and the caller must free it.
 *
 * @return 
 *   FSUCCESS - Query successful
 *     FERROR - Error
 */
static FSTATUS
pa_query_common(
	struct omgt_port      *port,
	uint8_t                method,
	uint32_t               attr_id,
	uint32_t               attr_mod,
	uint8_t               *snd_data,
	size_t                 snd_data_len,
	size_t                *rcv_buf_len,
	SA_MAD               **rsp_mad,
	PQUERY_RESULT_VALUES  *query_result
	)
{
	FSTATUS    fstatus = FSUCCESS;
	uint32_t   rec_sz = 0;
	uint32_t   rec_cnt = 0;
	uint32_t   mem_size;
	SA_MAD	   *send_mad = (SA_MAD *)snd_data;
	SA_MAD     *rcv_mad = NULL;
	struct omgt_mad_addr addr = {0};
	MAD_STATUS madStatus = {0};
	static uint32_t mad_tid = 1;

	// do some common stuff for each command / query.
	DBG_ENTER_FUNC(port);

	/* If port is In-Band, set up addr */
	if (!port->is_oob_enabled) {
		uint8_t port_state;
		(void)omgt_port_get_port_state(port, &port_state);
		if (port_state != PortStateActive) {
			OMGT_OUTPUT_ERROR(port, "Local port not Active!\n");
			return FINVALID_STATE;
		}
		if ((port->pa_service_state != OMGT_SERVICE_STATE_OPERATIONAL)
			&& (omgt_pa_service_connect(port) != OMGT_SERVICE_STATE_OPERATIONAL)) {

			OMGT_OUTPUT_ERROR(port, "Query PA failed: PA Service Not Operational: %s (%d)\n",
				omgt_service_state_totext(port->pa_service_state), port->pa_service_state);
			return FUNAVAILABLE;
		}
		addr.lid = port->primary_pm_lid;
		addr.sl = port->primary_pm_sl;
		addr.qpn = 1;
		addr.qkey = QP1_WELL_KNOWN_Q_KEY;
		addr.pkey = OMGT_DEFAULT_PKEY;
		if (omgt_find_pkey(port, OMGT_DEFAULT_PKEY) < 0) {
			OMGT_OUTPUT_ERROR(port, "Query PA failed: requires full management node. Status:(%u)\n", FPROTECTION);
			return FPROTECTION;
		}
	}

	OMGT_DBGPRINT(port, "Request MAD method: 0x%x\n", method);
	OMGT_DBGPRINT(port, "\taid: 0x%x\n", attr_id);
	OMGT_DBGPRINT(port, "\tamod: 0x%x\n", attr_mod);

	// default the parameters to failed state.
	*query_result = NULL;
	*rsp_mad = NULL;

	/* Setup MAD Header */
	MAD_SET_VERSION_INFO(send_mad, STL_BASE_VERSION, MCLASS_VFI_PM, STL_PA_CLASS_VERSION);
	MAD_SET_METHOD_TYPE(send_mad, method);
	MAD_SET_ATTRIB_ID(send_mad, attr_id);
	MAD_SET_ATTRIB_MOD(send_mad, attr_mod); /* should be zero */
	MAD_SET_TRANSACTION_ID(send_mad, mad_tid++);

	BSWAP_SA_HDR(&send_mad->SaHdr);
	BSWAP_MAD_HEADER((MAD *)&send_mad->common);

	/* Add OUI to MAD after BSWAP */
	struct umad_vendor_packet *pkt = (struct umad_vendor_packet *)send_mad;
	memcpy(&pkt->oui, ib_truescale_oui, 3);

	// submit RMPP MAD request
	fstatus = omgt_send_recv_mad_alloc(port, snd_data, (size_t)snd_data_len, &addr,
		(uint8_t **)rsp_mad, rcv_buf_len, port->ms_timeout, port->retry_count);

	if (fstatus != FSUCCESS) {
		if (fstatus == FPROTECTION) {
			// PKEY lookup error.
			OMGT_OUTPUT_ERROR(port, "Query Failed: requires full management node.\n");
		} else {
			OMGT_DBGPRINT(port, "Query Failed: %u.\n", (unsigned int)fstatus);
			port->pa_service_state = OMGT_SERVICE_STATE_DOWN;
		}
		goto done;
	}

	if (*rcv_buf_len < PA_REQ_HEADER_SIZE) {
		OMGT_DBGPRINT(port, "Query PA: Failed to receive packet\n");
		fstatus = FNOT_FOUND;
		goto done;
	}

	rcv_mad = *rsp_mad;
	BSWAP_MAD_HEADER((MAD *)&rcv_mad->common);
	BSWAP_SA_HDR(&rcv_mad->SaHdr);
	MAD_GET_STATUS(rcv_mad, &madStatus);

	// dump of PA header for debug
	OMGT_DBGPRINT(port, " PA Header\n");
	OMGT_DBGPRINT(port, " length %zu (0x%zx) vs Header length %d\n",
		*rcv_buf_len, *rcv_buf_len, (int)PA_REQ_HEADER_SIZE);
	//OMGT_DBGPRINT(port, " SmKey (0x%016"PRIx64")\n", rcv_mad->SaHdr.SmKey);
	OMGT_DBGPRINT(port, " AttributeOffset %u (0x%x) : in bytes: %u\n",
		rcv_mad->SaHdr.AttributeOffset, rcv_mad->SaHdr.AttributeOffset,
		(rcv_mad->SaHdr.AttributeOffset * 8));
	OMGT_DBGPRINT(port, " Reserved (0x%x)\n", rcv_mad->SaHdr.Reserved);
	//OMGT_DBGPRINT(port, " ComponentMask (0x%016"PRIx64")\n", rcv_mad->SaHdr.ComponentMask);

	rec_sz = rcv_mad->SaHdr.AttributeOffset * 8;
	if (rcv_mad->common.mr.AsReg8 == STL_PA_CMD_GET_RESP) {
		/* Attribute Offset is 0 on GetResp() as there is only one record */
		rec_sz = *rcv_buf_len - PA_REQ_HEADER_SIZE;
		rec_cnt = 1;
	} else if (rcv_mad->SaHdr.AttributeOffset) {
		rec_cnt = (int)((*rcv_buf_len - PA_REQ_HEADER_SIZE) /
			(rcv_mad->SaHdr.AttributeOffset * 8));
	} else {
		rec_cnt = 0;
	}
	OMGT_DBGPRINT(port, "Record count is %d\n", rec_cnt);

	// If the command was not successful (mad status is not 0)
	// Change overall return status to failed.
	// Fill in the result pointer so the caller can evaluate the return mad status.
	port->pa_mad_status = madStatus.AsReg16;
	if (madStatus.AsReg16 != 0) {
		OMGT_DBGPRINT(port, "Query PA failed: Mad status is 0x%x: %s\n",
			madStatus.AsReg16, iba_pa_mad_status_msg(port));

		switch (madStatus.AsReg16) {
		case STL_MAD_STATUS_STL_PA_NO_GROUP:
		case STL_MAD_STATUS_STL_PA_NO_PORT:
		case STL_MAD_STATUS_STL_PA_NO_VF:
		case STL_MAD_STATUS_STL_PA_NO_IMAGE:
		case STL_MAD_STATUS_STL_PA_NO_DATA:
			fstatus = FNOT_FOUND;
			break;
		case STL_MAD_STATUS_STL_PA_INVALID_PARAMETER:
			fstatus = FINVALID_PARAMETER;
			break;
		case STL_MAD_STATUS_STL_PA_UNAVAILABLE:
			fstatus = FINVALID_STATE;
			break;
		case STL_MAD_STATUS_STL_PA_BAD_DATA:
		default:
			fstatus = FERROR;
			break;
		}
	}

	mem_size  = rec_sz * rec_cnt;
	mem_size += sizeof(uint32_t);
	mem_size += sizeof(QUERY_RESULT_VALUES);

	// resultDataSize should be 0 when status is not successful and no data is returned
	*query_result = MemoryAllocate2AndClear(mem_size, IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (*query_result == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating query result buffer\n");
		fstatus = FINSUFFICIENT_MEMORY;
		goto done;
	}
	(*query_result)->Status = fstatus;
	(*query_result)->MadStatus = port->pa_mad_status;
	(*query_result)->ResultDataSize = rec_sz * rec_cnt;
	*((uint32_t *)((*query_result)->QueryResult)) = rec_cnt;

done:
	if (fstatus != FSUCCESS) {
		if (*rsp_mad != NULL) {
			free(*rsp_mad);
			*rsp_mad = NULL;
		}
	}

	DBG_EXIT_FUNC(port);
	return (fstatus);
}   // End of pa_query_common()

const char* 
iba_pa_query_input_type_msg(
    QUERY_INPUT_TYPE    code
    )
{
    if (code < 0 || code >= (int)(sizeof(pa_query_input_type_text)/sizeof(char*)))
        return "Unknown PA Query Input Type";
    else
        return pa_query_input_type_text[code];
}

const char* 
iba_pa_query_result_type_msg(
    QUERY_RESULT_TYPE   code
    )
{
    if (code < 0 || code >= (int)(sizeof(pa_query_result_type_text)/sizeof(char*)))
        return "Unknown PA Query Result Type";
    else
        return pa_query_result_type_text[code];
}


/******************************************************* 
 * Public functions
 *******************************************************/
/**
 *   Enable debugging output in the opamgt library.
 *
 * @param   port    The local port to operate on.
 *  
 * @return 
 *   None
 */
void 
set_opapaquery_debug (
    IN struct omgt_port  *port
    )
{
    port->pa_verbose = 1;

    // Should we pass along the debug info
    //_openib_debug_ = 1;     // enable general debugging

    return;
}

/**
 *  Get the classportinfo from the given port.
 *
 * @param port                  Local port to operate on.  
 *  
 * @return 
 *   Valid pointer  -   A pointer to the ClassPortInfo. The caller must free it after use.
 *   NULL           -   Error.
 */
OMGT_STATUS_T
omgt_pa_get_classportinfo(
    IN struct omgt_port  *port,
	STL_CLASS_PORT_INFO **cpi
    )
{
    FSTATUS                 fstatus = FSUCCESS;
    QUERY_RESULT_VALUES     *query_result = NULL;
    STL_CLASS_PORT_INFO     *response = NULL;
    SA_MAD                  *rsp_mad = NULL;
    size_t                  rcv_buf_len = 0;
    uint8_t                 request_data[PA_REQ_HEADER_SIZE] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_GET, STL_PA_ATTRID_GET_CLASSPORTINFO, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		fstatus = FERROR;
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_CLASS_PORT_INFO), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		fstatus = FINSUFFICIENT_RESOURCES;
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_CLASS_PORT_INFO), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_CLASS_PORT_INFO(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);
	*cpi = response;
	DBG_EXIT_FUNC(port);
	return fstatus;

}   // End of omgt_pa_get_classportinfo()

/**
 *  Get port statistics (counters)
 *
 * @param port                  Local port to operate on. 
 * @param node_lid              Remote node LID.
 * @param port_num              Remote port number. 
 * @param port_counters         Pointer to port counters to fill.
 * @param delta_flag            1 for delta counters, 0 for raw image counters.
 * @param user_ctrs_flag        1 for running counters, 0 for image counters. (delta must be 0)
 * @param image_id              Pointer to image ID of port counters to get. 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the counters data. The caller must free it.
 *     NULL         - Error
 */
STL_PORT_COUNTERS_DATA *
iba_pa_single_mad_port_counters_response_query(
    IN struct omgt_port  *port,
    IN STL_LID           node_lid,
    IN uint8_t           port_number,
    IN uint32_t          delta_flag,
    IN uint32_t          user_cntrs_flag,
    IN STL_PA_IMAGE_ID_DATA    *image_id
    )
{
    FSTATUS                 fstatus = FSUCCESS;
    QUERY_RESULT_VALUES     *query_result = NULL;
    STL_PORT_COUNTERS_DATA  *response = NULL, *p;
    SA_MAD                  *rsp_mad = NULL;
    size_t                  rcv_buf_len = 0;
    uint8_t                 request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PORT_COUNTERS_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

	// Build Request
    p = (STL_PORT_COUNTERS_DATA *)(((SA_MAD *)request_data)->Data);
    p->nodeLid = node_lid;
    p->portNumber = port_number;
    p->flags = (delta_flag ? STL_PA_PC_FLAG_DELTA : 0) |
			   (user_cntrs_flag ? STL_PA_PC_FLAG_USER_COUNTERS : 0);

    p->imageId.imageNumber = image_id->imageNumber;
    p->imageId.imageOffset = image_id->imageOffset;
	p->imageId.imageTime.absoluteTime = image_id->imageTime.absoluteTime;
	memset(p->reserved, 0, sizeof(p->reserved));
	memset(p->reserved2, 0, sizeof(p->reserved2));
	p->lq.s.reserved = 0;
    BSWAP_STL_PA_PORT_COUNTERS(p);

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_GET, STL_PA_ATTRID_GET_PORT_CTRS, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PORT_COUNTERS_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PORT_COUNTERS_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_PORT_COUNTERS(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}


/**
 *  Clear port statistics (counters)
 *
 * @param port                  Local Port to operate on. 
 * @param node_lid              Remote node LID.
 * @param port_num              Remote port number. 
 * @param select                Port's counters to clear. 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the clear port counters data (containing the
 *                    info as which counters have been cleared).  The caller must free it.
 *     NULL         - Error
 */
STL_CLR_PORT_COUNTERS_DATA *
iba_pa_single_mad_clr_port_counters_response_query(
    IN struct omgt_port  *port,
    IN uint32_t          node_lid,
    IN uint8_t           port_number,
    IN uint32_t          select
    )
{
    FSTATUS                 fstatus = FSUCCESS;
    QUERY_RESULT_VALUES     *query_result = NULL;
    STL_CLR_PORT_COUNTERS_DATA  *response = NULL, *p;
    SA_MAD                  *rsp_mad = NULL;
    size_t                  rcv_buf_len = 0;
    uint8_t                 request_data[PA_REQ_HEADER_SIZE + sizeof(STL_CLR_PORT_COUNTERS_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_CLR_PORT_COUNTERS_DATA *)(((SA_MAD *)request_data)->Data);
    p->NodeLid = node_lid;
    p->PortNumber = port_number;
    p->CounterSelectMask.AsReg32 = select;
	p->CounterSelectMask.s.Reserved = 0;
	memset(p->Reserved, 0, sizeof(p->Reserved));
    BSWAP_STL_PA_CLR_PORT_COUNTERS(p);

    // submit request
	fstatus = pa_query_common(port, STL_PA_CMD_SET, STL_PA_ATTRID_CLR_PORT_CTRS, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_CLR_PORT_COUNTERS_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_CLR_PORT_COUNTERS_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_CLR_PORT_COUNTERS(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Clear all ports, statistics (counters)
 *
 * @param port                  Local port to operate on. 
 * @param select                Port's counters to clear. 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the clear all port counters data (containing the
 *                    info as which counters have been cleared).  The caller must free it.
 *     NULL         - Error
 */
STL_CLR_ALL_PORT_COUNTERS_DATA *
iba_pa_single_mad_clr_all_port_counters_response_query(
    IN struct omgt_port  *port,
    IN uint32_t          select
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    STL_CLR_ALL_PORT_COUNTERS_DATA  *response = NULL, *p;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_CLR_ALL_PORT_COUNTERS_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_CLR_ALL_PORT_COUNTERS_DATA *)(((SA_MAD *)request_data)->Data);
    p->CounterSelectMask.AsReg32 = select;
	p->CounterSelectMask.s.Reserved = 0;
	BSWAP_STL_PA_CLR_ALL_PORT_COUNTERS(p);

    // submit request
	fstatus = pa_query_common(port, STL_PA_CMD_SET, STL_PA_ATTRID_CLR_ALL_PORT_CTRS, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_CLR_ALL_PORT_COUNTERS_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_CLR_ALL_PORT_COUNTERS_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_CLR_ALL_PORT_COUNTERS(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Get the PM config data.
 *
 * @param port                  Local port to operate on. 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for pm config data.  The caller must free it.
 *     NULL         - Error
 */
STL_PA_PM_CFG_DATA *
iba_pa_single_mad_get_pm_config_response_query(
    IN struct omgt_port  *port
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    STL_PA_PM_CFG_DATA       	*response = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_PM_CFG_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_GET, STL_PA_ATTRID_GET_PM_CONFIG, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PA_PM_CFG_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PA_PM_CFG_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_PM_CFG(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Free a sweep image.
 *
 * @param port                  Local port to operate on. 
 * @param image_id              ID of image to freeze. 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the frozen image id data.  The caller must free it.
 *     NULL         - Error
 */
STL_PA_IMAGE_ID_DATA *
iba_pa_single_mad_freeze_image_response_query(
    IN struct omgt_port  *port,
    IN STL_PA_IMAGE_ID_DATA    *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    STL_PA_IMAGE_ID_DATA        *response = NULL, *p;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_IMAGE_ID_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_PA_IMAGE_ID_DATA *)(((SA_MAD *)request_data)->Data);
    p->imageNumber = hton64(image_id->imageNumber);
    p->imageOffset = hton32(image_id->imageOffset);
	p->imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_SET, STL_PA_ATTRID_FREEZE_IMAGE, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PA_IMAGE_ID_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PA_IMAGE_ID_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_IMAGE_ID(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Release a sweep image.
 *
 * @param port                  Local port to operate on. 
 * @param image_id              Ponter to id of image to release. 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the released image id data.  The caller must free it.
 *     NULL         - Error
 */
STL_PA_IMAGE_ID_DATA *
iba_pa_single_mad_release_image_response_query(
    IN struct omgt_port  *port,
    IN STL_PA_IMAGE_ID_DATA    *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    STL_PA_IMAGE_ID_DATA        *response = NULL, *p;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_IMAGE_ID_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_PA_IMAGE_ID_DATA *)(((SA_MAD *)request_data)->Data);
    p->imageNumber = hton64(image_id->imageNumber);
    p->imageOffset = hton32(image_id->imageOffset);
	p->imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_SET, STL_PA_ATTRID_RELEASE_IMAGE, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PA_IMAGE_ID_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PA_IMAGE_ID_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_IMAGE_ID(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Renew a sweep image.
 *
 * @param port                  Local port to operate on. 
 * @param image_id              Ponter to id of image to renew. 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the renewed image id data.  The caller must free it.
 *     NULL         - Error
 */
STL_PA_IMAGE_ID_DATA *
iba_pa_single_mad_renew_image_response_query(
    IN struct omgt_port  *port,
    IN STL_PA_IMAGE_ID_DATA    *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    STL_PA_IMAGE_ID_DATA        *response = NULL, *p;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_IMAGE_ID_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_PA_IMAGE_ID_DATA *)(((SA_MAD *)request_data)->Data);
    p->imageNumber = hton64(image_id->imageNumber);
    p->imageOffset = hton32(image_id->imageOffset);
	p->imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_SET, STL_PA_ATTRID_RENEW_IMAGE, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PA_IMAGE_ID_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PA_IMAGE_ID_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_IMAGE_ID(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Move a frozen image 1 to image 2.
 *
 * @param port                  Local port to operate on. 
 * @param move_info             Ponter to move info (src and dest image ID). 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the image  move info.  The caller must free it.
 *     NULL         - Error
 */
STL_MOVE_FREEZE_DATA *
iba_pa_single_mad_move_freeze_response_query(
    IN struct omgt_port  *port,
    IN STL_MOVE_FREEZE_DATA *move_info
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    STL_MOVE_FREEZE_DATA        *response = NULL, *p;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_MOVE_FREEZE_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_MOVE_FREEZE_DATA *)(((SA_MAD *)request_data)->Data);
	*p = *move_info;
	BSWAP_STL_PA_MOVE_FREEZE(p);

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_SET, STL_PA_ATTRID_MOVE_FREEZE_FRAME, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_MOVE_FREEZE_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_MOVE_FREEZE_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_MOVE_FREEZE(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Get image info
 *
 * @param port                  Local port to operate on. 
 * @param image_info            Ponter to image info (containing valid image ID). 
 *
 * @return 
 *   Valid Pointer  - A pointer to the memory for the image info data.  The caller must free it.
 *     NULL         - Error
 */
STL_PA_IMAGE_INFO_DATA *
iba_pa_multi_mad_get_image_info_response_query (
    IN struct omgt_port  *port,
    IN STL_PA_IMAGE_INFO_DATA  *image_info
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    STL_PA_IMAGE_INFO_DATA      *response = NULL, *p;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_IMAGE_INFO_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_PA_IMAGE_INFO_DATA *)(((SA_MAD *)request_data)->Data);
    p->imageId.imageNumber = hton64(image_info->imageId.imageNumber);
    p->imageId.imageOffset = hton32(image_info->imageId.imageOffset);
	p->imageId.imageTime.absoluteTime = hton32(image_info->imageId.imageTime.absoluteTime);
	p->reserved = 0;

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_IMAGE_INFO, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PA_IMAGE_INFO_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PA_IMAGE_INFO_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_IMAGE_INFO(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

/**
 *  Get multi-record response for pa group data (group list).
 *
 * @param port                      Local port to operate on.
 * @param query                     Pointer to the query
 * @param pquery_result             Pointer to query result to be filled. The caller
 *                                  has to free the buffer.
 *
 * @return
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS
iba_pa_multi_mad_group_list_response_query(
	IN struct omgt_port       *port,
	IN POMGT_QUERY            query,
	OUT PQUERY_RESULT_VALUES  *pquery_result
	)
{
	FSTATUS                     fstatus = FSUCCESS;
	QUERY_RESULT_VALUES         *query_result = NULL;
	SA_MAD                      *rsp_mad = NULL;
	size_t                      rcv_buf_len = 0;
	uint8_t                     request_data[PA_REQ_HEADER_SIZE] = { 0 };
	STL_PA_GROUP_LIST           *pa_data;
	STL_PA_GROUP_LIST_RESULTS   *pa_result;
	int i;

	DBG_ENTER_FUNC(port);
	// Check the incoming port parameter
	if (port == NULL) return FERROR;

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_GRP_LIST, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS) {
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n", (unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose) {
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_GROUP_LIST_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->GroupListRecords;
		for (i = 0; i < pa_result->NumGroupListRecords; i++) {
			STL_PA_GROUP_LIST *groupname = (STL_PA_GROUP_LIST *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *groupname;
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}
FSTATUS
iba_pa_multi_mad_group_list2_response_query(
	IN struct omgt_port       *port,
	IN POMGT_QUERY            query,
	IN STL_PA_IMAGE_ID_DATA   *imageId,
	OUT PQUERY_RESULT_VALUES  *pquery_result
	)
{
	FSTATUS                     fstatus = FSUCCESS;
	QUERY_RESULT_VALUES         *query_result = NULL;
	SA_MAD                      *rsp_mad = NULL;
	size_t                      rcv_buf_len = 0;
	uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_IMAGE_ID_DATA)] = { 0 };
	STL_PA_GROUP_LIST2          *pa_data;
	STL_PA_GROUP_LIST2_RESULTS  *pa_result;
	STL_PA_IMAGE_ID_DATA        *p;
	int i;

	DBG_ENTER_FUNC(port);
	// Check the incoming port parameter
	if (port == NULL) return FERROR;

	p = (STL_PA_IMAGE_ID_DATA *)(((SA_MAD *)request_data)->Data);
	*p = *imageId;
	BSWAP_STL_PA_IMAGE_ID(p);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_GRP_LIST2, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS) {
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n", (unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose) {
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_GROUP_LIST2_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->GroupList2Records;
		for (i = 0; i < pa_result->NumGroupList2Records; i++) {
			STL_PA_GROUP_LIST2 *group = (STL_PA_GROUP_LIST2 *)GET_RESULT_OFFSET(rsp_mad, i);
			BSWAP_STL_PA_IMAGE_ID(&group->imageId);
			pa_data[i] = *group;
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}
/**
 *  Get multi-record response for pa group info (stats).
 *
 * @param port                      Local port to operate on. 
 * @param query                     Pointer to the query 
 * @param group_name                Group name 
 * @param pquery_result             Pointer to query result to be filled. The caller has to 
 *                                  to free the buffer.
 * @param image_id                  Pointer to the image ID. 
 *
 * @return 
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS 
iba_pa_multi_mad_group_stats_response_query(
    IN struct omgt_port              *port,
    IN POMGT_QUERY                   query,
    IN char                         *group_name,
    OUT PQUERY_RESULT_VALUES        *pquery_result,
    IN STL_PA_IMAGE_ID_DATA         *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + 80] = {0}; // 80 = GroupName + ImageId (Request)
    STL_PA_PM_GROUP_INFO_DATA   *pa_data, *p;
    STL_PA_GROUP_INFO_RESULTS   *pa_result;
	int i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
    p = (STL_PA_PM_GROUP_INFO_DATA *)(((SA_MAD *)request_data)->Data);
    snprintf(p->groupName, sizeof(p->groupName), "%s", group_name);
    p->imageId.imageNumber = image_id->imageNumber;
    p->imageId.imageOffset = image_id->imageOffset;
	p->imageId.imageTime.absoluteTime = image_id->imageTime.absoluteTime;
	BSWAP_STL_PA_PM_GROUP_INFO(p, 1);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_GRP_INFO, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS){
			if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",(unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose){
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_GROUP_INFO_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->GroupInfoRecords;
		for (i = 0; i < pa_result->NumGroupInfoRecords; i++) {
			STL_PA_PM_GROUP_INFO_DATA *group = (STL_PA_PM_GROUP_INFO_DATA *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *group;
			BSWAP_STL_PA_PM_GROUP_INFO(&pa_data[i], 0);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}

/**
 *  Get multi-record response for pa group config.
 *
 * @param port                      Local port to operate on. 
 * @param query                     Pointer to the query 
 * @param group_name                Group name 
 * @param pquery_result             Pointer to query result to be filled. The caller has 
 *                                  to free the buffer.
 * @param imageID                   Pointer to the image ID. 
 *
 * @return 
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS 
iba_pa_multi_mad_group_config_response_query(
    IN struct omgt_port              *port,
    IN POMGT_QUERY             query,
    IN char                         *group_name,
    OUT PQUERY_RESULT_VALUES        *pquery_result,
    IN STL_PA_IMAGE_ID_DATA         *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_PM_GROUP_CFG_REQ)] = {0};
    STL_PA_PM_GROUP_CFG_RSP     *pa_data;
	STL_PA_PM_GROUP_CFG_REQ     *p;
    STL_PA_GROUP_CONFIG_RESULTS *pa_result;
	int	i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
    p = (STL_PA_PM_GROUP_CFG_REQ *)(((SA_MAD *)request_data)->Data);
    snprintf(p->groupName, sizeof(p->groupName), "%s", group_name);

    p->imageId.imageNumber = hton64(image_id->imageNumber);
    p->imageId.imageOffset = hton32(image_id->imageOffset);
	p->imageId.imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);
    
    // process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_GRP_CFG, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS){
			if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",(unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose){
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_GROUP_CONFIG_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->GroupConfigRecords;
		for (i = 0; i < pa_result->NumGroupConfigRecords; i++) {
			STL_PA_PM_GROUP_CFG_RSP *group_cfg = (STL_PA_PM_GROUP_CFG_RSP *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *group_cfg;
			BSWAP_STL_PA_GROUP_CONFIG_RSP(&pa_data[i]);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}	// End of iba_pa_multi_mad_group_config_response_query()

/**
 *  Get multi-record response for pa group node Info.
 *
 * @param port           	Local port to operate on.
 * @param query                 Pointer to the query
 * @param group_name 		Group name
 * @param nodeLid               node LID
 * @param nodeGuid              node GUID
 * @param nodeDesc              node Description
 * @param pquery_result       	Pointer to query result to be filled. The caller has
 *                              to free the buffer.
 * @param imageID               Pointer to the image ID.
 *
 * @return
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS
iba_pa_multi_mad_group_nodeinfo_response_query(
	IN struct omgt_port              *port,
	IN POMGT_QUERY                   query,
	IN char                         *group_name,
	IN STL_LID                      nodeLid,
	IN uint64                       nodeGuid,
	IN char                         *nodeDesc,
	OUT PQUERY_RESULT_VALUES        *pquery_result,
	IN STL_PA_IMAGE_ID_DATA         *image_id
	)
{
	FSTATUS                     fstatus = FSUCCESS;
	QUERY_RESULT_VALUES         *query_result = NULL;
	SA_MAD                      *rsp_mad = NULL;
	size_t                      rcv_buf_len = 0;
	uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_GROUP_NODEINFO_REQ)] = {0};
	STL_PA_GROUP_NODEINFO_RSP     *pa_data;
	STL_PA_GROUP_NODEINFO_REQ     *p;
	STL_PA_GROUP_NODEINFO_RESULTS *pa_result;
	int i;

	DBG_ENTER_FUNC(port);
	// Check the incoming port parameter
	if (port == NULL) return FERROR;

	p = (STL_PA_GROUP_NODEINFO_REQ *)(((SA_MAD *)request_data)->Data);
	snprintf(p->groupName, sizeof(p->groupName), "%s", group_name);
	p->nodeLID = nodeLid;
	p->nodeGUID = nodeGuid;
	if(nodeDesc)
		snprintf(p->nodeDesc, sizeof(p->nodeDesc), "%s", nodeDesc);
	p->imageId.imageNumber = image_id->imageNumber;
	p->imageId.imageOffset = image_id->imageOffset;
	p->imageId.imageTime.absoluteTime = image_id->imageTime.absoluteTime;
	BSWAP_STL_PA_GROUP_NODE_INFO_REQ(p);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_GRP_NODE_INFO, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS){
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",(unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose){
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_GROUP_NODEINFO_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->GroupNodeInfoRecords;
		for (i = 0; i < pa_result->NumGroupNodeInfoRecords; i++) {
			STL_PA_GROUP_NODEINFO_RSP *group_node_info = (STL_PA_GROUP_NODEINFO_RSP *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *group_node_info;
			BSWAP_STL_PA_GROUP_NODE_INFO_RSP(&pa_data[i]);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
		iba_pa_query_input_type_msg(query->InputType),
		iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
} // End of iba_pa_multi_mad_group_nodeinfo_response_query()

/**
 *  Get multi-record response for pa group link Info.
 *
 * @param port        		Local port to operate on.
 * @param query                 Pointer to the query
 * @param group_name         	Group name
 * @param inputLid              input LID
 * @param inputPort          	input port
 * @param pquery_result       	Pointer to query result to be filled. The caller has
 *                              to free the buffer.
 * @param imageID               Pointer to the image ID.
 *
 * @return
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS
iba_pa_multi_mad_group_linkinfo_response_query(
	IN struct omgt_port       	*port,
	IN POMGT_QUERY             	query,
	IN char                         *group_name,
	IN STL_LID                      inputLid,
	IN uint8                      	inputPort,
	OUT PQUERY_RESULT_VALUES        *pquery_result,
	IN STL_PA_IMAGE_ID_DATA         *image_id
	)
{
	FSTATUS                     fstatus = FSUCCESS;
	QUERY_RESULT_VALUES         *query_result = NULL;
	SA_MAD                      *rsp_mad = NULL;
	size_t                      rcv_buf_len = 0;
	uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_GROUP_LINKINFO_REQ)] = {0};
	STL_PA_GROUP_LINKINFO_RSP     *pa_data;
	STL_PA_GROUP_LINKINFO_REQ     *p;
	STL_PA_GROUP_LINKINFO_RESULTS *pa_result;
	int i;

	DBG_ENTER_FUNC(port);
	// Check the incoming port parameter
	if (port == NULL) return FERROR;

	p = (STL_PA_GROUP_LINKINFO_REQ *)(((SA_MAD *)request_data)->Data);
	snprintf(p->groupName, sizeof(p->groupName), "%s", group_name);
	p->lid = inputLid;
	p->port = inputPort;
	p->imageId.imageNumber = image_id->imageNumber;
	p->imageId.imageOffset = image_id->imageOffset;
	p->imageId.imageTime.absoluteTime = image_id->imageTime.absoluteTime;
	BSWAP_STL_PA_GROUP_LINK_INFO_REQ(p);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_GRP_LINK_INFO, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS){
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",(unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose){
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_GROUP_LINKINFO_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->GroupLinkInfoRecords;
		for (i = 0; i < pa_result->NumGroupLinkInfoRecords; i++) {
			STL_PA_GROUP_LINKINFO_RSP *group_link_info = (STL_PA_GROUP_LINKINFO_RSP *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *group_link_info;
			BSWAP_STL_PA_GROUP_LINK_INFO_RSP(&pa_data[i]);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
		iba_pa_query_input_type_msg(query->InputType),
		iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}


/**
 *  Get multi-record response for pa group focus portlist.
 *
 * @param port                      Local port to operate on. 
 * @param query                     Pointer to the query 
 * @param group_name                Group name 
 * @param select                    Select value for focus portlist. 
 * @param start                     Start index value of portlist 
 * @param range                     Index range of portlist. 
 * @param pquery_result             Pointer to query result to be filled. The caller has 
 *                                  to fill the buffer.
 * @param imageID                   Pointer to the image ID. 
 *
 * @return 
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS 
iba_pa_multi_mad_focus_ports_response_query (
    IN struct omgt_port              *port,
    IN POMGT_QUERY             query,
    IN char                         *group_name,
    IN uint32                       select,
    IN uint32                       start,
    IN uint32                       range,
    OUT PQUERY_RESULT_VALUES        *pquery_result,
    IN STL_PA_IMAGE_ID_DATA         *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_FOCUS_PORTS_REQ)] = {0};
    STL_FOCUS_PORTS_RSP         *pa_data;
	STL_FOCUS_PORTS_REQ         *p;
    STL_PA_FOCUS_PORTS_RESULTS  *pa_result;
    int i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
    p = (STL_FOCUS_PORTS_REQ *)(((SA_MAD *)request_data)->Data);
    snprintf(p->groupName, sizeof(p->groupName), "%s", group_name);
    p->select = hton32(select);
    p->start = hton32(start);
    p->range = hton32(range);

    p->imageId.imageNumber = hton64(image_id->imageNumber);
    p->imageId.imageOffset = hton32(image_id->imageOffset);
    p->imageId.imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_FOCUS_PORTS, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS) {
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n", (unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose) {
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_FOCUS_PORTS_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->FocusPortsRecords;
		for (i = 0; i < pa_result->NumFocusPortsRecords; i++) {
			STL_FOCUS_PORTS_RSP *focus_port = (STL_FOCUS_PORTS_RSP *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *focus_port;
			BSWAP_STL_PA_FOCUS_PORTS_RSP(&pa_data[i]);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}


/**
 *  Get multi-record response for pa group focus portlist.
 *
 * @param port              Local port to operate on.
 * @param query             Pointer to the query.
 * @param group_name        Group name.
 * @param select            Select value for focus portlist.
 * @param start             Start index value of portlist.
 * @param range             Index range of portlist.
 * @param pquery_result     Pointer to query result to be filled. The caller has
 *  						to fill the buffer.
 * @param imageID           Pointer to the image ID.
 *
 * @return
 *   FSUCCESS	- Get successfully
 *     FERROR	- Error
 */
FSTATUS
iba_pa_multi_mad_focus_ports_multiselect_response_query (
	IN struct omgt_port		    *port,
	IN POMGT_QUERY              query,
	IN char				        *group_name,
	IN uint32			        start,
	IN uint32			        range,
	OUT PQUERY_RESULT_VALUES	*pquery_result,
	IN STL_PA_IMAGE_ID_DATA		*image_id,
	IN STL_FOCUS_PORT_TUPLE		*tuple,
	IN uint8			        logical_operator
	)
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_FOCUS_PORTS_MULTISELECT_REQ)] = {0};
    STL_FOCUS_PORTS_MULTISELECT_RSP         *pa_data;
	STL_FOCUS_PORTS_MULTISELECT_REQ         *p;
    STL_PA_FOCUS_PORTS_MULTISELECT_RESULTS  *pa_result;
    int i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
    p = (STL_FOCUS_PORTS_MULTISELECT_REQ *)(((SA_MAD *)request_data)->Data);
	snprintf(p->groupName, STL_PM_GROUPNAMELEN, "%s", group_name);
	p->start = hton32(start);
	p->range = hton32(range);

	for (i = 0; i < MAX_NUM_FOCUS_PORT_TUPLES; i++) {
		p->tuple[i].select = hton32(tuple[i].select);
		p->tuple[i].comparator = tuple[i].comparator;
		p->tuple[i].argument = hton64(tuple[i].argument);
	}

	p->logical_operator = logical_operator;

	p->imageId.imageNumber = hton64(image_id->imageNumber);
	p->imageId.imageOffset = hton32(image_id->imageOffset);
	p->imageId.imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_FOCUS_PORTS_MULTISELECT, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS) {
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n", (unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose) {
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_FOCUS_PORTS_MULTISELECT_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->FocusPortsRecords;
		for (i = 0; i < pa_result->NumFocusPortsRecords; i++) {
			STL_FOCUS_PORTS_MULTISELECT_RSP *focus_port = (STL_FOCUS_PORTS_MULTISELECT_RSP *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *focus_port;
			BSWAP_STL_PA_FOCUS_PORTS_MULTISELECT_RSP(&pa_data[i]);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}

/**
 *  Get multi-record response for pa vf data (vf list).
 *
 * @param port                      Local port to operate on. 
 * @param query                     Pointer to the query 
 * @param pquery_result             Pointer to query result to be filled. The caller 
 *                                  has to free the buffer.
 *
 * @return 
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS 
iba_pa_multi_mad_vf_list_response_query(
    IN struct omgt_port              *port,
    IN POMGT_QUERY             query,
    OUT PQUERY_RESULT_VALUES        *pquery_result
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
	uint8_t                     request_data[PA_REQ_HEADER_SIZE] = {0};
    STL_PA_VF_LIST	        	*pa_data;
    STL_PA_VF_LIST_RESULTS		*pa_result;
	int i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
	// process the command.
	switch (query->OutputType){
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_VF_LIST, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS){
			if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",(unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose){
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_VF_LIST_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->VFListRecords;
		for (i = 0; i < pa_result->NumVFListRecords; i++) {
			STL_PA_VF_LIST *vfname = (STL_PA_VF_LIST *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *vfname;
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}
FSTATUS
iba_pa_multi_mad_vf_list2_response_query(
	IN struct omgt_port       *port,
	IN POMGT_QUERY            query,
	IN STL_PA_IMAGE_ID_DATA   *imageId,
	OUT PQUERY_RESULT_VALUES  *pquery_result
	)
{
	FSTATUS                     fstatus = FSUCCESS;
	QUERY_RESULT_VALUES         *query_result = NULL;
	SA_MAD                      *rsp_mad = NULL;
	size_t                      rcv_buf_len = 0;
	uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_IMAGE_ID_DATA)] = { 0 };
	STL_PA_VF_LIST2             *pa_data;
	STL_PA_VF_LIST2_RESULTS     *pa_result;
	STL_PA_IMAGE_ID_DATA        *p;

	DBG_ENTER_FUNC(port);
	// Check the incoming port parameter
	if (port == NULL) return FERROR;

	p = (STL_PA_IMAGE_ID_DATA *)(((SA_MAD *)request_data)->Data);
	*p = *imageId;
	BSWAP_STL_PA_IMAGE_ID(p);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_VF_LIST2, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS) {
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n", (unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose) {
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		int i;
		// translate the data.
		pa_result = (STL_PA_VF_LIST2_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->VFList2Records;
		for (i = 0; i < pa_result->NumVFList2Records; i++) {
			STL_PA_VF_LIST2 *vf = (STL_PA_VF_LIST2 *)GET_RESULT_OFFSET(rsp_mad, i);
			BSWAP_STL_PA_IMAGE_ID(&vf->imageId);
			pa_data[i] = *vf;
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}
/**
 *  Get multi-record response for pa vf info (stats).
 *
 * @param port                      Local port to operate on. 
 * @param query                     Pointer to the query 
 * @param vf_name                	VF name 
 * @param pquery_result             Pointer to query result to be filled. The caller has to 
 *                                  to free the buffer.
 * @param image_id                  Pointer to the image ID. 
 *
 * @return 
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS 
iba_pa_multi_mad_vf_info_response_query(
    IN struct omgt_port              *port,
    IN POMGT_QUERY             query,
    IN char                         *vf_name,
    OUT PQUERY_RESULT_VALUES        *pquery_result,
    IN STL_PA_IMAGE_ID_DATA         *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + 88] = {0}; //80 = VFName + reserved + ImageID
    STL_PA_VF_INFO_DATA         *pa_data, *p;
    STL_PA_VF_INFO_RESULTS      *pa_result;
	int i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
    p = (STL_PA_VF_INFO_DATA *)(((SA_MAD *)request_data)->Data);
    snprintf(p->vfName, sizeof(p->vfName), "%s", vf_name);
    p->imageId.imageNumber = image_id->imageNumber;
    p->imageId.imageOffset = image_id->imageOffset;
	p->imageId.imageTime.absoluteTime = image_id->imageTime.absoluteTime;
	BSWAP_STL_PA_VF_INFO(p, 1);
    
	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_VF_INFO, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS){
			if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",(unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose){
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_VF_INFO_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->VFInfoRecords;
		for (i = 0; i < pa_result->NumVFInfoRecords; i++) {
			STL_PA_VF_INFO_DATA *vfinfo = (STL_PA_VF_INFO_DATA *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *vfinfo;
			BSWAP_STL_PA_VF_INFO(&pa_data[i], 0);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}

/**
 *  Get multi-record response for pa vf config.
 *
 * @param port                      Local port to operate on.
 * @param query                     Pointer to the query
 * @param vf_name                   VF Name
 * @param pquery_result             Pointer to query result to be filled. The
 *  								caller has to free the buffer.
 * @param image_id					Pointer to the image ID.
 *
 * @return
 *   FSUCCESS       - Get successfully
 *     FERROR       - Error
 */
FSTATUS 
iba_pa_multi_mad_vf_config_response_query(
    IN struct omgt_port              *port,
    IN POMGT_QUERY             query,
    IN char                         *vf_name,
    OUT PQUERY_RESULT_VALUES        *pquery_result,
    IN STL_PA_IMAGE_ID_DATA         *image_id
    )
{
    FSTATUS                     fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         *query_result = NULL;
    SA_MAD                      *rsp_mad = NULL;
    size_t                      rcv_buf_len = 0;
    uint8_t                     request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_VF_CFG_REQ)] = {0};
    STL_PA_VF_CFG_RSP           *pa_data;
	STL_PA_VF_CFG_REQ           *p;
    STL_PA_VF_CONFIG_RESULTS    *pa_result;
	int	i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
    p = (STL_PA_VF_CFG_REQ *)(((SA_MAD *)request_data)->Data);
    snprintf(p->vfName, sizeof(p->vfName), "%s", vf_name);

    p->imageId.imageNumber = hton64(image_id->imageNumber);
    p->imageId.imageOffset = hton32(image_id->imageOffset);
    p->imageId.imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_VF_CONFIG, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS) {
			if (port->pa_verbose)
				OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n", (unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose) {
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_VF_CONFIG_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->VFConfigRecords;
		for (i = 0; i < pa_result->NumVFConfigRecords; i++) {
			STL_PA_VF_CFG_RSP *vf_cfg = (STL_PA_VF_CFG_RSP *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *vf_cfg;
			BSWAP_STL_PA_VF_CFG_RSP(&pa_data[i]);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}

STL_PA_VF_PORT_COUNTERS_DATA *
iba_pa_single_mad_vf_port_counters_response_query(
    IN struct omgt_port      *port,
    IN STL_LID               node_lid,
    IN uint8_t               port_number,
    IN uint32_t              delta_flag,
    IN uint32_t              user_cntrs_flag,
    IN char                 *vfName,
    IN STL_PA_IMAGE_ID_DATA *image_id
    )
{
    FSTATUS                 fstatus = FSUCCESS;
    QUERY_RESULT_VALUES     *query_result = NULL;
    STL_PA_VF_PORT_COUNTERS_DATA *response = NULL, *p;
    SA_MAD                  *rsp_mad = NULL;
    size_t                  rcv_buf_len = 0;
    uint8_t                 request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_VF_PORT_COUNTERS_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_PA_VF_PORT_COUNTERS_DATA *)(((SA_MAD *)request_data)->Data);
    p->nodeLid = node_lid;
    p->portNumber = port_number;
    p->flags =  (delta_flag ? STL_PA_PC_FLAG_DELTA : 0) |
                (user_cntrs_flag ? STL_PA_PC_FLAG_USER_COUNTERS : 0);
    snprintf(p->vfName, STL_PM_VFNAMELEN, "%s", vfName);

    p->imageId.imageNumber = image_id->imageNumber;
    p->imageId.imageOffset = image_id->imageOffset;
	p->imageId.imageTime.absoluteTime = image_id->imageTime.absoluteTime;
	memset(p->reserved, 0, sizeof(p->reserved));
	p->reserved1 = 0;
    BSWAP_STL_PA_VF_PORT_COUNTERS(p);

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_GET, STL_PA_ATTRID_GET_VF_PORT_CTRS, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PA_VF_PORT_COUNTERS_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PA_VF_PORT_COUNTERS_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_VF_PORT_COUNTERS(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

STL_PA_CLEAR_VF_PORT_COUNTERS_DATA *
iba_pa_single_mad_clr_vf_port_counters_response_query(
    IN struct omgt_port  *port,
    IN uint32_t         node_lid,
    IN uint8_t         port_number,
    IN uint32_t         select,
	IN char				*vfName
    )
{
    FSTATUS                 fstatus = FSUCCESS;
    QUERY_RESULT_VALUES     *query_result = NULL;
    STL_PA_CLEAR_VF_PORT_COUNTERS_DATA  *response = NULL, *p;
    SA_MAD                  *rsp_mad = NULL;
    size_t                  rcv_buf_len = 0;
    uint8_t                 request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_CLEAR_VF_PORT_COUNTERS_DATA)] = {0};

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return response;

    p = (STL_PA_CLEAR_VF_PORT_COUNTERS_DATA *)(((SA_MAD *)request_data)->Data);
    p->nodeLid = hton32(node_lid);
    p->portNumber = port_number;
    p->vfCounterSelectMask.AsReg32 = hton32(select);
    snprintf(p->vfName, STL_PM_VFNAMELEN, "%s", vfName);
	memset(p->reserved, 0, sizeof(p->reserved));
	p->reserved2 = 0;

	// submit request
	fstatus = pa_query_common(port, STL_PA_CMD_SET, STL_PA_ATTRID_CLR_VF_PORT_CTRS, 0,
		request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
	if (fstatus != FSUCCESS) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",  (unsigned int)fstatus);
		goto done;
	} else if (rsp_mad->SaHdr.AttributeOffset) {
		if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, unexpected multiple MAD response\n");
		goto done;
	} else {
		if (port->pa_verbose) {
			OMGT_DBGPRINT(port, "Completed request: OK\n");
		}
	}

	response = MemoryAllocate2AndClear(sizeof(STL_PA_CLEAR_VF_PORT_COUNTERS_DATA), IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG);
	if (response == NULL) {
		OMGT_OUTPUT_ERROR(port, "error allocating response buffer\n");
		goto done;
	}
	memcpy((uint8 *)response, rsp_mad->Data, min(sizeof(STL_PA_CLEAR_VF_PORT_COUNTERS_DATA), rcv_buf_len - IB_SA_DATA_OFFS));

	// translate the data.
	BSWAP_STL_PA_CLEAR_VF_PORT_COUNTERS(response);
done:
	omgt_free_query_result_buffer(query_result);
	if (rsp_mad)
		free(rsp_mad);

	DBG_EXIT_FUNC(port);
	return response;
}

FSTATUS 
iba_pa_multi_mad_vf_focus_ports_response_query (
    IN struct omgt_port              *port,
    IN POMGT_QUERY             query,
    IN char                         *vf_name,
    IN uint32                       select,
    IN uint32                       start,
    IN uint32                       range,
    OUT PQUERY_RESULT_VALUES        *pquery_result,
    IN STL_PA_IMAGE_ID_DATA         *image_id
    )
{
    FSTATUS                     	fstatus = FSUCCESS;
    QUERY_RESULT_VALUES         	*query_result = NULL;
    SA_MAD                          *rsp_mad = NULL;
    size_t                         	rcv_buf_len = 0;
    uint8                        	request_data[PA_REQ_HEADER_SIZE + sizeof(STL_PA_VF_FOCUS_PORTS_REQ)] = {0};
    STL_PA_VF_FOCUS_PORTS_RSP     	*pa_data;
	STL_PA_VF_FOCUS_PORTS_REQ       *p;
    STL_PA_VF_FOCUS_PORTS_RESULTS 	*pa_result;
    int i;

    DBG_ENTER_FUNC(port);
    // Check the incoming port parameter
    if (port == NULL) return FERROR;
    
    p = (STL_PA_VF_FOCUS_PORTS_REQ *)(((SA_MAD *)request_data)->Data);
    snprintf(p->vfName, sizeof(p->vfName), "%s", vf_name);
    p->select = hton32(select);
    p->start = hton32(start);
    p->range = hton32(range);

    p->imageId.imageNumber = hton64(image_id->imageNumber);
    p->imageId.imageOffset = hton32(image_id->imageOffset);
	p->imageId.imageTime.absoluteTime = hton32(image_id->imageTime.absoluteTime);

	// process the command.
	switch (query->OutputType) {
	case OutputTypePaTableRecord:
		// submit request
		fstatus = pa_query_common(port, STL_PA_CMD_GETTABLE, STL_PA_ATTRID_GET_VF_FOCUS_PORTS, 0,
			request_data, sizeof(request_data), &rcv_buf_len, &rsp_mad, &query_result);
		if (fstatus != FSUCCESS){
			if (port->pa_verbose)
			OMGT_OUTPUT_ERROR(port, "Error, request failed: status=%u\n",(unsigned int)fstatus);
			goto done;
		} else {
			if (port->pa_verbose){
				OMGT_DBGPRINT(port, "Completed request: OK\n");
			}
		}

		// translate the data.
		pa_result = (STL_PA_VF_FOCUS_PORTS_RESULTS *)query_result->QueryResult;
		pa_data = pa_result->FocusPortsRecords;
		for (i = 0; i < pa_result->NumVFFocusPortsRecords; i++) {
			STL_PA_VF_FOCUS_PORTS_RSP *vf_focus = (STL_PA_VF_FOCUS_PORTS_RSP *)GET_RESULT_OFFSET(rsp_mad, i);
			pa_data[i] = *vf_focus;
			BSWAP_STL_PA_VF_FOCUS_PORTS_RSP(&pa_data[i]);
		}
		break;

	default:
		OMGT_OUTPUT_ERROR(port, "Query Not supported in OPAMGT: Input=%s, Output=%s\n",
			iba_pa_query_input_type_msg(query->InputType),
			iba_pa_query_result_type_msg(query->OutputType));
		fstatus = FERROR;
		goto done;
		break;
	}

done:
	if (rsp_mad)
		free(rsp_mad);

	*pquery_result = query_result;

	DBG_EXIT_FUNC(port);
	return fstatus;
}

/**
 * @brief Get LID and SL of master PM service
 *
 * This function will query the SA service records to get the PM's GID. It will
 * then construct a PATH record query (using the ServiceGID as the DGID for the
 * request) to get the PM's LID and SL for sending PA queries.
 *
 * @param port         port object to to store master PM LID and SL.
 *
 * @return FSTATUS
 */
FSTATUS 
iba_pa_query_master_pm_lid(struct omgt_port *port)
{
    FSTATUS                 status;
    OMGT_QUERY         query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    PQUERY_RESULT_VALUES    query_path_results = NULL;
    SERVICE_RECORD_RESULTS  *service_record_results;

    // Check the incoming port parameter
    if (NULL == port) {
        return (FERROR);
    }

    // query SA for Service Records to all PMs within the fabric
    memset(&query, 0, sizeof(query));
    query.InputType = InputTypeNoInput;
    query.OutputType = OutputTypeServiceRecord;

	status = omgt_query_sa(port, &query, &query_results);
	if (status != FSUCCESS) {
		OMGT_OUTPUT_ERROR(port, "Error, failed to get service records (status=0x%x) query_results=%p: %s\n",
			(unsigned int)status, (void *)query_results, FSTATUS_MSG(status));
	} else if ((query_results == NULL) || (query_results->ResultDataSize == 0)) {
		status = FUNAVAILABLE;
	} else {
		int i, ix, pmCount = 0;

		status = FUNAVAILABLE;
		service_record_results = (SERVICE_RECORD_RESULTS *)query_results->QueryResult;
		if (service_record_results->NumServiceRecords) {
			OMGT_DBGPRINT(port, "Got Service Records: records=%d\n", service_record_results->NumServiceRecords);
			for (i = 0; i < service_record_results->NumServiceRecords; ++i) {
				if (STL_PM_SERVICE_ID == service_record_results->ServiceRecords[i].RID.ServiceID) {
					pmCount++;
					if ((service_record_results->ServiceRecords[i].ServiceData8[0] >= STL_PM_VERSION) &&
						(service_record_results->ServiceRecords[i].ServiceData8[1] == STL_PM_MASTER)) {
						OMGT_DBGPRINT(port, "This is the Primary PM.\n");

						//
						// query SA for Path Record to the primary PM
						memset(&query, 0, sizeof(query));
						{
							query.InputType = InputTypePathRecord;
							query.OutputType = OutputTypePathRecord;
							query.InputValue.IbPathRecord.PathRecord.PathRecord.DGID =
								service_record_results->ServiceRecords[i].RID.ServiceGID;
							omgt_port_get_port_prefix(port,
								&query.InputValue.IbPathRecord.PathRecord.PathRecord.SGID.Type.Global.SubnetPrefix);
							omgt_port_get_port_guid(port,
								&query.InputValue.IbPathRecord.PathRecord.PathRecord.SGID.Type.Global.InterfaceID);
							query.InputValue.IbPathRecord.PathRecord.PathRecord.ServiceID = STL_PM_SERVICE_ID;

							query.InputValue.IbPathRecord.PathRecord.ComponentMask =
								IB_PATH_RECORD_COMP_NUMBPATH | IB_PATH_RECORD_COMP_SERVICEID |
								IB_PATH_RECORD_COMP_DGID | IB_PATH_RECORD_COMP_SGID;
							query.InputValue.IbPathRecord.PathRecord.PathRecord.NumbPath = 32;
						}

						status = omgt_query_sa(port, &query, &query_path_results);
						if ((status != FSUCCESS) || (query_path_results == NULL) || (query_path_results->ResultDataSize == 0)) {
							OMGT_OUTPUT_ERROR(port, "Error, failed to get path record (status=0x%x) query_path_results=%p: %s\n",
								(unsigned int)status, (void *)query_path_results, FSTATUS_MSG(status));
							status = FERROR;
							break;
						}
						else {
							PATH_RESULTS *path_record_results = (PATH_RESULTS *)query_path_results->QueryResult;
							OMGT_DBGPRINT(port, "Got Path Records: records=%d\n", path_record_results->NumPathRecords);
							if (path_record_results->NumPathRecords >= 1) {
							 // Find PathRecord with default P_Key or use PathRecords[0]
							for (ix = path_record_results->NumPathRecords - 1; ix > 0; ix--) {
								if ((path_record_results->PathRecords[ix].P_Key & 0x7FFF) ==
										(DEFAULT_P_KEY & 0x7FFF))
										break;
							}
							OMGT_DBGPRINT(port, "DGID in path record: 0x%lx:0x%lx\n",
								path_record_results->PathRecords[ix].DGID.Type.Global.SubnetPrefix,
								path_record_results->PathRecords[ix].DGID.Type.Global.InterfaceID);
								/* Check for Extended LID in the OPA GID */
								if ((path_record_results->PathRecords[ix].DGID.Type.Global.InterfaceID >> 40)
									== OMGT_STL_OUI) {
									port->primary_pm_lid =
										path_record_results->PathRecords[ix].DGID.Type.Global.InterfaceID & 0xFFFFFFFF;
								} else {
									port->primary_pm_lid = path_record_results->PathRecords[ix].DLID;
								}
								// Remember that for our own use
								port->primary_pm_sl = path_record_results->PathRecords[ix].u2.s.SL;
								OMGT_DBGPRINT(port, "Found Master PM LID 0x%x SL %u\n",
									port->primary_pm_lid, port->primary_pm_sl);
								} else {
									status = FERROR;
									OMGT_OUTPUT_ERROR(port, "Error, received no path records\n");
									break;
								}
						}
					}
				}
			}
			OMGT_DBGPRINT(port, "Number of PMs found %d\n", pmCount);
		}
	}
	// deallocate results buffers
	if (query_results)
		omgt_free_query_result_buffer(query_results);
	if (query_path_results)
		omgt_free_query_result_buffer(query_path_results);

	return status;
}

/**
 *  Get and Convert a MAD status code into string.
 *
 * @param port                    Local port to operate on. 
 * 
 * @return 
 *   The corresponding status string.
 */
const char* 
iba_pa_mad_status_msg(
    IN struct omgt_port              *port
    )
{
    // this is a little more complex than most due to bitfields and reserved
    // values
    MAD_STATUS  mad_status;
    uint16_t    code = port->pa_mad_status;

    mad_status.AsReg16 = port->pa_mad_status; // ignore reserved bits in mad_status
    if (code == MAD_STATUS_SUCCESS || (code & 0xff))
        return iba_mad_status_msg(mad_status);   // standard mad status fields
    else 
    {
		// SA specific status code field 0-6
		code = mad_status.S.ClassSpecific;
		if (code >= (unsigned)(sizeof(pa_sa_status_text)/sizeof(char*))) {
			// PA specific status code field - codes start at 'A' (10)
			code = mad_status.S.ClassSpecific - 9;
			if (code >= (unsigned)(sizeof(pa_status_text)/sizeof(char*)))
				return "Unknown PA Mad Status";
			else
				return pa_status_text[code];
		} else
			return pa_sa_status_text[code];
    }
}

/*
 * @brief Initialize PA connection on existing omgt_port session
 *
 * @param port                      omgt_port session to start PA interface on
 *
 * @return
 *  PACLIENT_OPERATIONAL - initialization successful
 *         PACLIENT_DOWN - initialization not successful/PaServer not available
 */
int
omgt_pa_service_connect(struct omgt_port *port)
{
	FSTATUS fstatus;
	uint8_t mclass = MCLASS_VFI_PM;
	struct omgt_class_args mgmt_class[2];
	int err = 0;
	IB_PORT_ATTRIBUTES *attrib = NULL;
	int pa_service_state = OMGT_SERVICE_STATE_DOWN;

	fstatus = omgt_get_portguid(port->hfi_num, port->hfi_port_num, NULL, port, NULL, NULL, NULL, &attrib, NULL, NULL, NULL, NULL, NULL);

	if (FSUCCESS == fstatus && attrib) {
		port->local_gid = attrib->GIDTable[0];
	} else {
		OMGT_OUTPUT_ERROR(port, "Could not get port guid: %s\n", iba_fstatus_msg(fstatus));
		goto done;
	}

	if ((fstatus = iba_pa_query_master_pm_lid(port)) != FSUCCESS) {
		OMGT_OUTPUT_ERROR(port, "Can't query primary PM LID!\n");
		if (fstatus == FUNAVAILABLE) {
			pa_service_state = OMGT_SERVICE_STATE_UNAVAILABLE;
		}
		goto done;
	}

	// register PA methods with OFED
	memset(mgmt_class, 0, sizeof(mgmt_class));
	mgmt_class[0].base_version = STL_BASE_VERSION;
	mgmt_class[0].mgmt_class = mclass;
	mgmt_class[0].class_version = STL_PM_CLASS_VERSION;
	mgmt_class[0].is_responding_client = 0;
	mgmt_class[0].is_trap_client = 0;
	mgmt_class[0].is_report_client = 0;
	mgmt_class[0].kernel_rmpp = 1;
	mgmt_class[0].use_methods = 0;
	mgmt_class[0].oui = ib_truescale_oui;

	if ((err = omgt_bind_classes(port, mgmt_class)) != 0) {
		OMGT_OUTPUT_ERROR(port, "Failed to  register management class 0x%02x: %s\n",
			mclass, strerror(err));
		goto done;
	}

	pa_service_state = OMGT_SERVICE_STATE_OPERATIONAL;
done:
	if (attrib)
		MemoryDeallocate(attrib);

	return (port->pa_service_state = pa_service_state);
}

/** 
 *  Get PM configuration data
 *
 * @param port          Port to operate on. 
 * @param pm_config     Pointer to PM config data to fill
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_pm_config(
    struct omgt_port     *port, 
    STL_PA_PM_CFG_DATA      *pm_config
    )
{
    OMGT_STATUS_T         fstatus = OMGT_STATUS_ERROR;
	STL_PA_PM_CFG_DATA * response;

    // Validate parameters
    if (NULL == port || !pm_config)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    OMGT_DBGPRINT(port, "Getting PM Configuration...\n");

    if ( ( response =
           iba_pa_single_mad_get_pm_config_response_query(port) ) != NULL )
    {
#if 0
TODO STL COMPILE!
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "Interval = %u\n", response->sweepInterval);
        OMGT_DBGPRINT(port, "Max Clients = %u\n", response->MaxClients);
        OMGT_DBGPRINT(port, "History Size = %u\n", response->sizeHistory);
        OMGT_DBGPRINT(port, "Freeze Size = %u\n", response->sizeFreeze);
        OMGT_DBGPRINT(port, "Freeze Lease = %u\n", response->lease);
        OMGT_DBGPRINT(port, "Flags = 0x%X\n", response->pmFlags);
        OMGT_DBGPRINT(port,  "Memory Footprint = 0x%" PRIX64 "\n",
                  response->memoryFootprint );
#endif
        memcpy(pm_config, response, sizeof(*pm_config));

        MemoryDeallocate(response);
        fstatus = OMGT_STATUS_SUCCESS;
    }
    else
        OMGT_DBGPRINT(port, "Got NULL response - FAILED\n");

    return (fstatus);
}

/** 
 *  Get image info
 *
 * @param port              Port to operate on. 
 * @param pm_image_Id       Image ID of image info to get 
 * @param pm_image_info     Pointer to image info to fill 
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_image_info(
    struct omgt_port     *port, 
    STL_PA_IMAGE_ID_DATA       pm_image_id,
    STL_PA_IMAGE_INFO_DATA     *pm_image_info 
    )
{
    OMGT_STATUS_T         fstatus = OMGT_STATUS_ERROR;
    uint32          ix;
    STL_PA_IMAGE_INFO_DATA query = {{0}};
    STL_PA_IMAGE_INFO_DATA *response;;

    if (NULL == port || !pm_image_info)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    query.imageId = pm_image_id;

    OMGT_DBGPRINT(port, "Getting Image Info...\n");

    if ( ( response = iba_pa_multi_mad_get_image_info_response_query( 
       port, &query ) ) != NULL )
    {
#if 0        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port,  "RespImageNum = 0x%" PRIX64 " Offset = %d\n",
                  response->imageId.imageNumber, response->imageId.imageOffset );
        OMGT_DBGPRINT(port,  "sweepStart = 0x%" PRIX64 "\n",
                  response->sweepStart );
        OMGT_DBGPRINT(port,  "sweepDuration = %u\n",
                  response->sweepDuration );
        OMGT_DBGPRINT(port,  "numHFIPorts = %u\n",
                  response->numHFIPorts );
        OMGT_DBGPRINT(port,  "numSwNodes = %u\n",
                  response->numSwitchNodes );
        OMGT_DBGPRINT(port,  "numSwPorts = %u\n",
                  response->numSwitchPorts );
        OMGT_DBGPRINT(port,  "numLinks = %u\n",
                  response->numLinks );
        OMGT_DBGPRINT(port,  "numSMs = %u\n",
                  response->numSMs );
        OMGT_DBGPRINT(port,  "numFailedNodes = %u\n",
                  response->numFailedNodes );
        OMGT_DBGPRINT(port,  "numFailedPorts = %u\n",
                  response->numFailedPorts );
        OMGT_DBGPRINT(port,  "numSkippedPorts = %u\n",
                  response->numSkippedPorts );
        OMGT_DBGPRINT(port,  "numUnexpectedClearPorts = %u\n",
                  response->numUnexpectedClearPorts );
#endif
        memcpy(pm_image_info, response, sizeof(*pm_image_info));

        for (ix = pm_image_info->numSMs; ix < 2; ix++)
            memset(&pm_image_info->SMInfo[ix], 0, sizeof(STL_SMINFO_DATA));

        MemoryDeallocate(response);
        fstatus = OMGT_STATUS_SUCCESS;
    }
    else
        OMGT_DBGPRINT(port, "Got NULL response - FAILED\n");

    return (fstatus);
}

/** 
 *  Get list of group names
 *
 * @param port              Port to operate on. 
 * @param pm_group_list     Pointer to group list to fill 
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_group_list(
    struct omgt_port   *port,
    uint32             *pNum_Groups,
    STL_PA_GROUP_LIST  **pm_group_list
    )
{
    OMGT_STATUS_T				fstatus = OMGT_STATUS_ERROR;
    uint32						size_group_list;
    OMGT_QUERY					query;
    PQUERY_RESULT_VALUES		query_results = NULL;
    STL_PA_GROUP_LIST_RESULTS	*p;

    // Validate the parameters and state
    if (!port || !pNum_Groups || !pm_group_list || *pm_group_list)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));   // initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Multi Record Response For Group Data...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
              iba_pa_query_input_type_msg(query.InputType),
              iba_pa_query_result_type_msg(query.OutputType) );

    fstatus = iba_pa_multi_mad_group_list_response_query( port, &query, &query_results );

    if (!query_results)
    {
        OMGT_DBGPRINT(port,  "PA Group List query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA Group List query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status),
                  port->pa_mad_status, iba_pa_mad_status_msg(port) );
        goto fail;
    }

    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_Groups = 0;
        fstatus = OMGT_STATUS_SUCCESS;
        goto done;
    }
    else
    {
		p = (STL_PA_GROUP_LIST_RESULTS*)query_results->QueryResult;

        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port,  "MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port));
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for Group Data:\n");
		OMGT_DBGPRINT(port, "NumGroupListRecords = %d\n",
				 (int)p->NumGroupListRecords );

		*pNum_Groups = p->NumGroupListRecords;
		size_group_list = sizeof(STL_PA_GROUP_LIST) * *pNum_Groups;

		if ( !( *pm_group_list = MemoryAllocate2AndClear( size_group_list, IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }

		memcpy(*pm_group_list, p->GroupListRecords, size_group_list);
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // omgt_query_port_fabric will have allocated a result buffer
    // we must free the buffer when we are done with it
    if (query_results)
        omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;

}

void omgt_pa_release_group_list(STL_PA_GROUP_LIST **pm_group_list)
{
	if (pm_group_list && *pm_group_list) {
		MemoryDeallocate(*pm_group_list);
		*pm_group_list = NULL;
	}
}
OMGT_STATUS_T
omgt_pa_get_group_list2(
    struct omgt_port     *port,
    STL_PA_IMAGE_ID_DATA pm_image_id_query,
    uint32               *pNum_Groups,
    STL_PA_GROUP_LIST2   **pm_group_list
    )
{
	OMGT_STATUS_T              fstatus = OMGT_STATUS_ERROR;
	uint32                     size_group_list;
	OMGT_QUERY                 query;
	PQUERY_RESULT_VALUES       query_results = NULL;
	STL_PA_IMAGE_ID_DATA       image_id = pm_image_id_query;
	STL_PA_GROUP_LIST2_RESULTS *p;

	// Validate the parameters and state
	if (!port || !pNum_Groups || !pm_group_list || *pm_group_list) {
		OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
		return (fstatus);
	}

	memset(&query, 0, sizeof(query));   // initialize reserved fields
	query.InputType     = InputTypeNoInput;
	query.OutputType    = OutputTypePaTableRecord;

	OMGT_DBGPRINT(port, "Getting Multi Record Response For Group List...\n");
	OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
		iba_pa_query_input_type_msg(query.InputType),
		iba_pa_query_result_type_msg(query.OutputType));

	fstatus = iba_pa_multi_mad_group_list2_response_query(port, &query, &image_id, &query_results);

	if (!query_results) {
		OMGT_DBGPRINT(port,  "PA Group List2 query Failed: %s\n",
			iba_fstatus_msg(fstatus));
		goto fail;
	} else if (query_results->Status != FSUCCESS) {
		OMGT_DBGPRINT(port,  "PA Group List2 query Failed: %s MadStatus 0x%X: %s\n",
			iba_fstatus_msg(query_results->Status),
			port->pa_mad_status, iba_pa_mad_status_msg(port));
		goto fail;
	} else if (query_results->ResultDataSize == 0) {
		OMGT_DBGPRINT(port, "No Records Returned\n");
		*pNum_Groups = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
	} else {
		p = (STL_PA_GROUP_LIST2_RESULTS *)query_results->QueryResult;

		// TBD remove some of these after additional MAD testing
		OMGT_DBGPRINT(port, "MadStatus 0x%X: %s\n", port->pa_mad_status,
			iba_pa_mad_status_msg(port));
		OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
		OMGT_DBGPRINT(port, "PA Multiple MAD Response for Group Data:\n");
		OMGT_DBGPRINT(port, "NumGroupList2Records = %d\n",
			(int)p->NumGroupList2Records);

		*pNum_Groups = p->NumGroupList2Records;
		size_group_list = sizeof(STL_PA_GROUP_LIST2) * *pNum_Groups;

		if (!(*pm_group_list = MemoryAllocate2AndClear(size_group_list, IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG))) {
			OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
			goto fail;
		}
		memcpy(*pm_group_list, p->GroupList2Records, size_group_list);
		fstatus = OMGT_STATUS_SUCCESS;
	}

done:
	// omgt_query_port_fabric will have allocated a result buffer
	// we must free the buffer when we are done with it
	if (query_results)
		omgt_free_query_result_buffer(query_results);
	return (fstatus);
fail:
	fstatus = OMGT_STATUS_ERROR;
	goto done;
}

void omgt_pa_release_group_list2(STL_PA_GROUP_LIST2 **pm_group_list)
{
	if (pm_group_list && *pm_group_list) {
		MemoryDeallocate(*pm_group_list);
		*pm_group_list = NULL;
	}
}
/**
 *  Get list of vf names
 *
 * @param port              Port to operate on.
 * @param pm_vf_list     Pointer to vf list to fill
 *
 * @return
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_vf_list(
    struct omgt_port          *port,
	uint32					 *pNum_VFs,
    STL_PA_VF_LIST  		**pm_vf_list
    )
{
    OMGT_STATUS_T						fstatus = OMGT_STATUS_ERROR;
    uint32						size_vf_list;
    OMGT_QUERY					query;
    PQUERY_RESULT_VALUES		query_results = NULL;
    STL_PA_VF_LIST_RESULTS		*p;

    // Validate the parameters and state
    if (!port || !pNum_VFs || !pm_vf_list || *pm_vf_list)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));   // initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Multi Record Response For VF Data...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
              iba_pa_query_input_type_msg(query.InputType),
              iba_pa_query_result_type_msg(query.OutputType) );

    fstatus = iba_pa_multi_mad_vf_list_response_query( port, &query, &query_results );

    if (!query_results)
    {
        OMGT_DBGPRINT(port,  "PA VF List query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA VF List query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status),
                  port->pa_mad_status, iba_pa_mad_status_msg(port) );
        goto fail;
    }

    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_VFs = 0;
        fstatus = OMGT_STATUS_SUCCESS;
        goto done;
    }
    else
    {
		p = (STL_PA_VF_LIST_RESULTS*)query_results->QueryResult;

        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port,  "MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port));
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for VF Data:\n");
		OMGT_DBGPRINT(port, "NumVFListRecords = %d\n",
				 (int)p->NumVFListRecords );

		*pNum_VFs = p->NumVFListRecords;
		size_vf_list = sizeof(STL_PA_VF_LIST) * *pNum_VFs;

		if ( !( *pm_vf_list = MemoryAllocate2AndClear( size_vf_list, IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }

		memcpy(*pm_vf_list, p->VFListRecords, size_vf_list);
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // omgt_query_port_fabric will have allocated a result buffer
    // we must free the buffer when we are done with it
    if (query_results)
        omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;

}

void omgt_pa_release_vf_list(STL_PA_VF_LIST **pm_vf_list)
{
	if (pm_vf_list && *pm_vf_list) {
		MemoryDeallocate(*pm_vf_list);
		*pm_vf_list = NULL;
	}
}
OMGT_STATUS_T
omgt_pa_get_vf_list2(
	struct omgt_port     *port,
	STL_PA_IMAGE_ID_DATA pm_image_id_query,
	uint32               *pNum_VFs,
	STL_PA_VF_LIST2      **pm_vf_list
	)
{
	OMGT_STATUS_T           fstatus = OMGT_STATUS_ERROR;
	uint32                  size_vf_list;
	OMGT_QUERY              query;
	PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_IMAGE_ID_DATA    image_id = pm_image_id_query;
	STL_PA_VF_LIST2_RESULTS *p;

	// Validate the parameters and state
	if (!port || !pNum_VFs || !pm_vf_list || *pm_vf_list) {
		OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
		return (fstatus);
	}

	memset(&query, 0, sizeof(query));   // initialize reserved fields
	query.InputType     = InputTypeNoInput;
	query.OutputType    = OutputTypePaTableRecord;

	OMGT_DBGPRINT(port, "Getting Multi Record Response For VF Data...\n");
	OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
		iba_pa_query_input_type_msg(query.InputType),
		iba_pa_query_result_type_msg(query.OutputType));

	fstatus = iba_pa_multi_mad_vf_list2_response_query(port, &query, &image_id, &query_results);
	if (!query_results) {
		OMGT_DBGPRINT(port, "PA VF List2 query Failed: %s\n",
			iba_fstatus_msg(fstatus));
		goto fail;
	} else if (query_results->Status != FSUCCESS) {
		OMGT_DBGPRINT(port, "PA VF List2 query Failed: %s MadStatus 0x%X: %s\n",
			iba_fstatus_msg(query_results->Status),
			port->pa_mad_status, iba_pa_mad_status_msg(port));
		goto fail;
	} else if (query_results->ResultDataSize == 0) {
		OMGT_DBGPRINT(port, "No Records Returned\n");
		*pNum_VFs = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
	} else {
		p = (STL_PA_VF_LIST2_RESULTS *)query_results->QueryResult;

		// TBD remove some of these after additional MAD testing
		OMGT_DBGPRINT(port, "MadStatus 0x%X: %s\n", port->pa_mad_status,
			iba_pa_mad_status_msg(port));
		OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
		OMGT_DBGPRINT(port, "PA Multiple MAD Response for VF Data:\n");
		OMGT_DBGPRINT(port, "NumVFList2Records = %d\n",
			(int)p->NumVFList2Records);

		*pNum_VFs = p->NumVFList2Records;
		size_vf_list = sizeof(STL_PA_VF_LIST2) * *pNum_VFs;

		if (!(*pm_vf_list = MemoryAllocate2AndClear(size_vf_list, IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG))) {
			OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
			goto fail;
		}

		memcpy(*pm_vf_list, p->VFList2Records, size_vf_list);
		fstatus = OMGT_STATUS_SUCCESS;
	}

done:
	// omgt_query_port_fabric will have allocated a result buffer
	// we must free the buffer when we are done with it
	if (query_results)
		omgt_free_query_result_buffer(query_results);
	return (fstatus);
fail:
	fstatus = OMGT_STATUS_ERROR;
	goto done;

}
void omgt_pa_release_vf_list2(STL_PA_VF_LIST2 **pm_vf_list)
{
	if (pm_vf_list && *pm_vf_list) {
		MemoryDeallocate(*pm_vf_list);
		*pm_vf_list = NULL;
	}
}
/** 
 *  Get group info
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of group info to get. 
 * @param group_name            Pointer to group name 
 * @param pm_image_id_resp      Pointer to image ID of group info returned. 
 * @param pm_group_info         Pointer to group info to fill. 
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_group_info(
    struct omgt_port     *port, 
    STL_PA_IMAGE_ID_DATA       pm_image_id_query,
    char                *group_name, 
    STL_PA_IMAGE_ID_DATA       *pm_image_id_resp, 
    STL_PA_PM_GROUP_INFO_DATA     *pm_group_info
    )
{
    OMGT_STATUS_T                 fstatus = OMGT_STATUS_ERROR;
    STL_PA_IMAGE_ID_DATA           image_id = pm_image_id_query;
    OMGT_QUERY              query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_GROUP_INFO_RESULTS   *p;

    // Validate the parameters and state
    if (!port || !group_name || !pm_group_info)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));	// initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Multi Record Response For Group Info...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
             iba_pa_query_input_type_msg(query.InputType),
             iba_pa_query_result_type_msg(query.OutputType));

    fstatus = iba_pa_multi_mad_group_stats_response_query( 
       port, &query, group_name, &query_results, &image_id );

    if (!query_results)
    {
        OMGT_DBGPRINT(port,  "PA GroupInfo query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA GroupInfo query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        goto fail;
    }
    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        fstatus = OMGT_STATUS_SUCCESS;
        goto done;
    }
    else
    {
        p = (STL_PA_GROUP_INFO_RESULTS*)query_results->QueryResult;
#if 0
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port,  "MadStatus 0x%X: %s\n", port->pa_mad_status,
        	iba_pa_mad_status_msg(port->pa_mad_status );
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for Group Info group %s:\n",
                  group_name );
        OMGT_DBGPRINT(port, "NumGroupInfoRecords = %d\n",
                  (int)p->NumGroupInfoRecords );
        
        // TBD should this allow multiple records of group info ?
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "\tgroup name: %s\n", p->GroupInfoRecords[0].groupName);
        OMGT_DBGPRINT(port, "\tinternal ports: %d\n", p->GroupInfoRecords[0].numInternalPorts);
        OMGT_DBGPRINT(port, "\tinternal rate min: %d\n", p->GroupInfoRecords[0].minInternalRate);
        OMGT_DBGPRINT(port, "\tinternal rate max: %d\n", p->GroupInfoRecords[0].maxInternalRate);
        OMGT_DBGPRINT(port, "\tinternal MBps max: %d\n", p->GroupInfoRecords[0].maxInternalMBps);
        OMGT_DBGPRINT(port, "\texternal ports: %d\n", p->GroupInfoRecords[0].numExternalPorts);
        OMGT_DBGPRINT(port, "\texternal rate min: %d\n", p->GroupInfoRecords[0].minExternalRate);
        OMGT_DBGPRINT(port, "\texternal rate max: %d\n", p->GroupInfoRecords[0].maxExternalRate);
        OMGT_DBGPRINT(port, "\texternal MBps max: %d\n", p->GroupInfoRecords[0].maxExternalMBps);
        OMGT_DBGPRINT(port,  "\tinternal util totalMBps: %" PRIu64 "\n",
                  p->GroupInfoRecords[0].internalUtilStats.totalMBps );
        OMGT_DBGPRINT(port,  "\tinternal util avgMBps: %u\n",
                  p->GroupInfoRecords[0].internalUtilStats.avgMBps );
        OMGT_DBGPRINT(port,  "\tinternal util maxMBps: %u\n",
                  p->GroupInfoRecords[0].internalUtilStats.maxMBps );
        OMGT_DBGPRINT(port,  "\tinternal util totalKPps: %" PRIu64 "\n",
                  p->GroupInfoRecords[0].internalUtilStats.totalKPps );
        OMGT_DBGPRINT(port,  "\tinternal util avgKPps: %u\n",
                  p->GroupInfoRecords[0].internalUtilStats.avgKPps );
        OMGT_DBGPRINT(port,  "\tinternal util maxKPps: %u\n",
                  p->GroupInfoRecords[0].internalUtilStats.maxKPps );
        OMGT_DBGPRINT(port,  "\tsend util stats: %" PRIu64 "\n",
                  p->GroupInfoRecords[0].sendUtilStats.totalMBps );
        OMGT_DBGPRINT(port,  "\trecv util stats: %" PRIu64 "\n",
                  p->GroupInfoRecords[0].recvUtilStats.totalMBps );
        OMGT_DBGPRINT(port,  "\tinternal max integrity errors: %u\n",
                  p->GroupInfoRecords[0].internalCategoryStats.categoryMaximums.integrityErrors );
        OMGT_DBGPRINT(port,  "\texternal max integrity errors: %u\n",
                  p->GroupInfoRecords[0].externalCategoryStats.categoryMaximums.integrityErrors );
        OMGT_DBGPRINT(port,  "\tinternal integrity bucket[4]: %u\n",
                  p->GroupInfoRecords[0].internalCategoryStats.ports[4].integrityErrors );
        OMGT_DBGPRINT(port,  "\texternal integrity bucket[4]: %u\n",
                  p->GroupInfoRecords[0].externalCategoryStats.ports[4].integrityErrors );
#endif
        memcpy(pm_group_info, p->GroupInfoRecords, sizeof(*pm_group_info));
        if (pm_image_id_resp)
            *pm_image_id_resp = p->GroupInfoRecords[0].imageId;

        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // iba_pa_query_port_fabric_info will have allocated a result buffer
    // we must free the buffer when we are done with it
    if (query_results)
        omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;
}

/**
 *  Get vf info
 *
 * @param port                  Port to operate on.
 * @param pm_image_id_query     Image ID of vf info to get.
 * @param vf_name               Pointer to vf name
 * @param pm_image_id_resp      Pointer to image ID of vf info returned.
 * @param pm_vf_info            Pointer to vf info to fill.
 *
 * @return
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_vf_info(
    struct omgt_port           *port,
    STL_PA_IMAGE_ID_DATA        pm_image_id_query,
    char                       *vf_name,
    STL_PA_IMAGE_ID_DATA       *pm_image_id_resp,
    STL_PA_VF_INFO_DATA        *pm_vf_info
    )
{
	OMGT_STATUS_T status = OMGT_STATUS_ERROR;
	STL_PA_IMAGE_ID_DATA image_id = pm_image_id_query;
	OMGT_QUERY query;
	PQUERY_RESULT_VALUES query_results = NULL;
	STL_PA_VF_INFO_RESULTS *p;

	// Validate the parameters and state
	if (!port || !vf_name || !pm_vf_info){
		OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
		return status;
	}

	memset(&query, 0, sizeof(query));
	query.InputType  = InputTypeNoInput;
	query.OutputType = OutputTypePaTableRecord;

	OMGT_DBGPRINT(port, "Getting Multi Record Response for VF Info...\n");
	OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n", iba_pa_query_input_type_msg(query.InputType),
	                                                    iba_pa_query_result_type_msg(query.OutputType));

	status = iba_pa_multi_mad_vf_info_response_query(port, &query, vf_name, &query_results, &image_id);

	if (!query_results)
	{
		OMGT_DBGPRINT(port, "PA VFInfo query Failed: %s\n", iba_fstatus_msg(status));
		goto fail;
	}
	else if (query_results->Status != FSUCCESS)
	{
		OMGT_DBGPRINT(port,  "PA VFInfo query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
		goto fail;
	}
	else if (query_results->ResultDataSize == 0)
	{
		OMGT_DBGPRINT(port, "No Records Returned\n");
		status = OMGT_STATUS_SUCCESS;
		goto done;
	}
	else
	{
		p = (STL_PA_VF_INFO_RESULTS*)query_results->QueryResult;

		memcpy(pm_vf_info, p->VFInfoRecords, sizeof(*pm_vf_info));
		if (pm_image_id_resp)
			*pm_image_id_resp = p->VFInfoRecords[0].imageId;

		status = OMGT_STATUS_SUCCESS;
	}

done:
	if (query_results)
		omgt_free_query_result_buffer(query_results);
	return (status);

fail:
	status = OMGT_STATUS_ERROR;
	goto done;
}

/**
 *  Get group config info
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of group config to get. 
 * @param group_name            Pointer to group name 
 * @param pm_image_id_resp      Pointer to image ID of group info returned. 
 * @param pm_group_config       Pointer to group config to fill. Upon successful return, a memory to 
 *                              contain the group config is allocated. The caller must call
 *                              omgt_pa_release_group_config to free the memory later.
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_group_config(
    struct omgt_port     *port, 
    STL_PA_IMAGE_ID_DATA       pm_image_id_query,
    char                *group_name, 
    STL_PA_IMAGE_ID_DATA       *pm_image_id_resp, 
	uint32						*pNum_ports,
    STL_PA_PM_GROUP_CFG_RSP   **pm_group_config 
    )
{
    OMGT_STATUS_T           fstatus = OMGT_STATUS_ERROR;
    uint32                  num_ports;
    uint32                  size_group_config;
    STL_PA_IMAGE_ID_DATA           image_id = pm_image_id_query;
    OMGT_QUERY              query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_GROUP_CONFIG_RESULTS *p;

    // Validate the parameters and state
    if (!port || !group_name || !pm_group_config || *pm_group_config)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));	// initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Group Config...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
             iba_pa_query_input_type_msg(query.InputType),
             iba_pa_query_result_type_msg(query.OutputType));

    fstatus = iba_pa_multi_mad_group_config_response_query( 
       port, &query, group_name, &query_results, &image_id );

    if (!query_results)
    {
        OMGT_DBGPRINT(port,  "PA GroupConfig query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA GroupConfig query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        goto fail;
    }
    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_ports = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
    }
    else
    {
        p = (STL_PA_GROUP_CONFIG_RESULTS*)query_results->QueryResult;
        
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for GroupConfig group %s:\n",
                  group_name );
        OMGT_DBGPRINT(port, "NumGroupConfigRecords = %d\n",
                  (int)p->NumGroupConfigRecords );
        
        num_ports = p->NumGroupConfigRecords < MAX_PORTS_LIST ?
            p->NumGroupConfigRecords : MAX_PORTS_LIST;
		*pNum_ports = num_ports;
        size_group_config = sizeof(STL_PA_PM_GROUP_CFG_RSP) * num_ports;
        
        if ( !( *pm_group_config = MemoryAllocate2AndClear( size_group_config,
                                                            IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }
        
        OMGT_DBGPRINT(port,  "\tname:%s, ports:%u\n",
                  group_name,
                  (unsigned int)num_ports );
        
        memcpy(*pm_group_config, p->GroupConfigRecords, size_group_config); 
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // iba_pa_query_port_fabric_info will have allocated a result buffer
    // we must free the buffer when we are done with it
    omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;
}

/** 
 *  Release group config info
 *
 * @param port                  Port to operate on. 
 * @param pm_group_config       Pointer to pointer to the group config to free. 
 *
 * @return 
 *   None
 */
void 
omgt_pa_release_group_config(
    STL_PA_PM_GROUP_CFG_RSP   **pm_group_config
    )
{
    if (pm_group_config && *pm_group_config)
    {
        MemoryDeallocate(*pm_group_config);
        *pm_group_config = NULL;
    }

}

/**
 *  Get group node info
 *
 * @param port                  Port to operate on.
 * @param pm_image_id_query     Image ID of group config to get.
 * @param group_name            Pointer to group name
 * @param nodeLid               node LID
 * @param nodeGuid              node GUID
 * @param nodeDesc              node Description
 * @param pm_image_id_resp      Pointer to image ID of group info returned.
 * @param pm_group_config       Pointer to group config to fill. Upon successful return, a memory to
 *                              contain the group config is allocated. The caller must call
 *                              omgt_pa_release_group_config to free the memory later.
 *
 * @return
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_group_nodeinfo(
    struct omgt_port     	*port,
    STL_PA_IMAGE_ID_DATA       	pm_image_id_query,
    char                	*group_name,
    STL_LID             	nodeLid,
    uint64              	nodeGuid,
    char                        *nodeDesc,
    STL_PA_IMAGE_ID_DATA       	*pm_image_id_resp,
    uint32               	*pNum_nodes,
    STL_PA_GROUP_NODEINFO_RSP   **pm_group_nodeinfo
    )
{
    OMGT_STATUS_T           fstatus = OMGT_STATUS_ERROR;
    uint32                  num_nodes;
    uint32                  size_group_nodeinfo;
    STL_PA_IMAGE_ID_DATA    image_id = pm_image_id_query;
    OMGT_QUERY              query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_GROUP_NODEINFO_RESULTS *p;

    // Validate the parameters and state
    if (!port || !group_name || !pm_group_nodeinfo || *pm_group_nodeinfo)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));	// initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Group Node Info...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
             iba_pa_query_input_type_msg(query.InputType),
             iba_pa_query_result_type_msg(query.OutputType));

    fstatus = iba_pa_multi_mad_group_nodeinfo_response_query(
       port, &query, group_name, nodeLid, nodeGuid, nodeDesc, &query_results, &image_id );

    if (!query_results)
    {
        OMGT_DBGPRINT(port,  "PA GroupNodeInfo query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA GroupNodeInfo query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        goto fail;
    }
    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_nodes = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
    }
    else
    {
        p = (STL_PA_GROUP_NODEINFO_RESULTS*)query_results->QueryResult;

        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for GroupNodeInfo group %s:\n",
                  group_name );
        OMGT_DBGPRINT(port, "NumGroupNodeInfoRecords = %d\n",
                  (int)p->NumGroupNodeInfoRecords );

        num_nodes = p->NumGroupNodeInfoRecords;
        *pNum_nodes = num_nodes;
        size_group_nodeinfo = sizeof(STL_PA_GROUP_NODEINFO_RSP) * num_nodes;

        if ( !( *pm_group_nodeinfo = MemoryAllocate2AndClear( size_group_nodeinfo,
                                                            IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }

        OMGT_DBGPRINT(port,  "\tname:%s, nodes:%u\n",
                  group_name,
                  (unsigned int)num_nodes );

        memcpy(*pm_group_nodeinfo, p->GroupNodeInfoRecords, size_group_nodeinfo);
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // iba_pa_query_port_fabric_info will have allocated a result buffer
    // we must free the buffer when we are done with it
    omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;
}

/**
 *  Release group node info
 *
 * @param pm_group_nodeinfo       Pointer to pointer to the group nodeinfo to free.
 *
 * @return
 *   None
 */
void
omgt_pa_release_group_nodeinfo(
    STL_PA_GROUP_NODEINFO_RSP   **pm_group_nodeinfo
    )
{
    if (pm_group_nodeinfo && *pm_group_nodeinfo)
    {
        MemoryDeallocate(*pm_group_nodeinfo);
        *pm_group_nodeinfo = NULL;
    }
}

/**
 *  Get group link info
 *
 * @param port                  Port to operate on.
 * @param pm_image_id_query     Image ID of group config to get.
 * @param group_name            Pointer to group name
 * @param inputLid              input LID
 * @param inputPort             input Port
 * @param pm_image_id_resp      Pointer to image ID of group info returned.
 * @param pm_group_config       Pointer to group config to fill. Upon successful return, a memory to
 *                              contain the group config is allocated. The caller must call
 *                              omgt_pa_release_group_config to free the memory later.
 *
 * @return
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_group_linkinfo(
    struct omgt_port     *port,
    STL_PA_IMAGE_ID_DATA       pm_image_id_query,
    char                *group_name,
    STL_LID             inputLid,
    uint8               inputPort,
    STL_PA_IMAGE_ID_DATA       *pm_image_id_resp,
    uint32               *pNum_links,
    STL_PA_GROUP_LINKINFO_RSP   **pm_group_linkinfo
    )
{
    OMGT_STATUS_T           fstatus = OMGT_STATUS_ERROR;
    uint32                  num_links;
    uint32                  size_group_linkinfo;
    STL_PA_IMAGE_ID_DATA    image_id = pm_image_id_query;
    OMGT_QUERY              query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_GROUP_LINKINFO_RESULTS *p;

    // Validate the parameters and state
    if (!port || !group_name || !pm_group_linkinfo || *pm_group_linkinfo)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));	// initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Group Link Info...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
             iba_pa_query_input_type_msg(query.InputType),
             iba_pa_query_result_type_msg(query.OutputType));

    fstatus = iba_pa_multi_mad_group_linkinfo_response_query(
       port, &query, group_name, inputLid, inputPort, &query_results, &image_id );

    if (!query_results)
    {
        OMGT_DBGPRINT(port,  "PA GroupLinkInfo query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA GroupLinkInfo query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        goto fail;
    }
    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_links = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
    }
    else
    {
        p = (STL_PA_GROUP_LINKINFO_RESULTS*)query_results->QueryResult;

        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for GroupLinkInfo group %s:\n",
                  group_name );
        OMGT_DBGPRINT(port, "NumGroupLinkInfoRecords = %d\n",
                  (int)p->NumGroupLinkInfoRecords );

        num_links = p->NumGroupLinkInfoRecords;
        *pNum_links = num_links;
        size_group_linkinfo = sizeof(STL_PA_GROUP_LINKINFO_RSP) * num_links;

        if ( !( *pm_group_linkinfo = MemoryAllocate2AndClear( size_group_linkinfo,
                                                            IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }

        OMGT_DBGPRINT(port,  "\tname:%s, links:%u\n",
                  group_name,
                  (unsigned int)num_links );

        memcpy(*pm_group_linkinfo, p->GroupLinkInfoRecords, size_group_linkinfo);
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // iba_pa_query_port_fabric_info will have allocated a result buffer
    // we must free the buffer when we are done with it
    omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;
}

/**
 *  Release group link info
 *
 * @param port         		Port to operate on.
 * @param pm_group_nodeinfo     Pointer to pointer to the group nodeinfo to free.
 *
 * @return
 *   None
 */
void
omgt_pa_release_group_linkinfo(
    STL_PA_GROUP_LINKINFO_RSP   **pm_group_linkinfo
    )
{
    if (pm_group_linkinfo && *pm_group_linkinfo)
    {
        MemoryDeallocate(*pm_group_linkinfo);
        *pm_group_linkinfo = NULL;
    }
}

/* Get VF config info
 *
 * @param port					Port to operate on
 * @param pm_image_id_query		Image ID of VF config to get.
 * @param vf_name				Pointer to VF name.
 * @param pm_image_id_resp		Pointer to image ID of VF info returned.
 * @param pm_vf_config			Pointer to VF config to fill. Upon successful return, a memory to
 * 								contain the VF config is allocated. The caller must call
 * 								omgt_pa_release_vf_config to free the memory later.
 *
 * 	@return
 * 	  OMGT_STATUS_SUCCESS - Get successful
 * 	    OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_vf_config(
	struct omgt_port				*port,
	STL_PA_IMAGE_ID_DATA		pm_image_id_query,
	char						*vf_name,
	STL_PA_IMAGE_ID_DATA		*pm_image_id_resp,
	uint32						*pNum_ports,
	STL_PA_VF_CFG_RSP		**pm_vf_config
	)
{
    OMGT_STATUS_T           fstatus = OMGT_STATUS_ERROR;
    uint32                  num_ports;
    uint32                  size_vf_config;
    STL_PA_IMAGE_ID_DATA    image_id = pm_image_id_query;
    OMGT_QUERY              query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_VF_CONFIG_RESULTS *p;

    // Validate the parameters and state
    if (!port || !vf_name || !pm_vf_config || *pm_vf_config)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));	// initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Group Config...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
             iba_pa_query_input_type_msg(query.InputType),
             iba_pa_query_result_type_msg(query.OutputType));

    fstatus = iba_pa_multi_mad_vf_config_response_query( 
       port, &query, vf_name, &query_results, &image_id );

    if (!query_results)
    {
        OMGT_DBGPRINT(port,  "PA VFConfig query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA VFConfig query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        goto fail;
    }
    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_ports = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
    }
    else
    {
        p = (STL_PA_VF_CONFIG_RESULTS*)query_results->QueryResult;
        
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for VFConfig group %s:\n",
                  vf_name );
        OMGT_DBGPRINT(port, "NumVFConfigRecords = %d\n",
                  (int)p->NumVFConfigRecords );
        
        num_ports = p->NumVFConfigRecords < MAX_PORTS_LIST ?
            p->NumVFConfigRecords : MAX_PORTS_LIST;
		*pNum_ports = num_ports;
        size_vf_config = sizeof(STL_PA_VF_CFG_RSP) * num_ports;
        
        if ( !( *pm_vf_config = MemoryAllocate2AndClear( size_vf_config,
                                                            IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }
        
        OMGT_DBGPRINT(port, "\tname:%s, ports:%u\n",
                  vf_name,
                  (unsigned int)num_ports );
        
        memcpy(*pm_vf_config, p->VFConfigRecords, size_vf_config); 
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // iba_pa_query_port_fabric_info will have allocated a result buffer
    // we must free the buffer when we are done with it
    omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;
}


/* Release VF config info
 *
 * @param port					Port to operate on.
 * @param pm_vf_config			Pointer to pointer to the VF config to free
 *
 * @return
 *   None
 */
void
omgt_pa_release_vf_config(
	STL_PA_VF_CFG_RSP		**pm_vf_config
	)
{
    if (pm_vf_config && *pm_vf_config)
    {
        MemoryDeallocate(*pm_vf_config);
        *pm_vf_config = NULL;
    }
}

/**
 *  Get group focus portlist
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of group focus portlist to get. 
 * @param group_name            Pointer to group name.
 * @param select                Select value for focus portlist. 
 * @param start                 Start index value of portlist 
 * @param range                 Index range of portlist. 
 * @param pm_image_id_resp      Pointer to image ID of group focus portlist returned. 
 * @param pm_group_focus        Pointer to pointer to focus portlist to fill. Upon 
 *                              successful return, a memory to contain the group focus
 *                              portlist is allocated. The caller must call
 *                              omgt_pa_release_group_focus to free the memory later.
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */

OMGT_STATUS_T
omgt_pa_get_group_focus(
    struct omgt_port     *port, 
    STL_PA_IMAGE_ID_DATA       pm_image_id_query,
    char                *group_name, 
    uint32              select, 
    uint32              start, 
    uint32              range,
    STL_PA_IMAGE_ID_DATA       *pm_image_id_resp, 
	uint32						*pNum_ports,
    STL_FOCUS_PORTS_RSP    **pm_group_focus 
    )
{
    OMGT_STATUS_T           fstatus = OMGT_STATUS_ERROR;
    uint32                  num_ports;
    uint32                  size_group_focus;
    STL_PA_IMAGE_ID_DATA           image_id = pm_image_id_query;
    OMGT_QUERY              query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_FOCUS_PORTS_RESULTS  *p;

    // Validate the parameters and state
    if (!port ||
        !group_name ||
        (range > MAX_PORTS_LIST) ||
        !pm_group_focus || *pm_group_focus)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));   // initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting Group Focus...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
             iba_pa_query_input_type_msg(query.InputType),
             iba_pa_query_result_type_msg(query.OutputType));

    fstatus = iba_pa_multi_mad_focus_ports_response_query(port, &query,
		group_name, select, start, range, &query_results, &image_id );

    if (!query_results)
    {
        OMGT_DBGPRINT(port, "PA Group Focus query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port, "PA Group Focus query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        goto fail;
    }
    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_ports = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
    }
    else
    {
        p = (STL_PA_FOCUS_PORTS_RESULTS*)query_results->QueryResult;
        
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for Focus portlist group %s:\n",
                 group_name );
        OMGT_DBGPRINT(port, "NumFocusPortsRecords = %d\n",
                  (int)p->NumFocusPortsRecords );
        
        num_ports = p->NumFocusPortsRecords < range ?
            p->NumFocusPortsRecords : range;

		*pNum_ports = num_ports;
        size_group_focus = sizeof(STL_FOCUS_PORTS_RSP) * num_ports;
        
        if ( !( *pm_group_focus = MemoryAllocate2AndClear( size_group_focus,
                                                         IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }
        
        OMGT_DBGPRINT(port,  "\tname:%s, ports:%u\n",
                  group_name,
                  (unsigned int)num_ports );
        
        memcpy(*pm_group_focus, p->FocusPortsRecords, size_group_focus); 
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // iba_pa_query_port_fabric_info will have allocated a result buffer
    // we must free the buffer when we are done with it
    omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;
}

/** 
 *  Release group focus portlist
 *
 * @param port                  Port to operate on. 
 * @param pm_group_config       Pointer to pointer to the group focus portlist to free. 
 *
 * @return 
 *   None
 */
void 
omgt_pa_release_group_focus(
    STL_FOCUS_PORTS_RSP     **pm_group_focus
   )
{
    if (pm_group_focus && *pm_group_focus)
    {
        MemoryDeallocate(*pm_group_focus);
        *pm_group_focus = NULL;
    }
}


/*
 *  Get VF focus portlist
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of vf focus portlist to get. 
 * @param vf_name            Pointer to vf name.
 * @param select                Select value for focus portlist. 
 * @param start                 Start index value of portlist 
 * @param range                 Index range of portlist. 
 * @param pm_image_id_resp      Pointer to image ID of group focus portlist returned. 
 * @param pm_vf_focus        Pointer to pointer to focus portlist to fill. Upon 
 *                              successful return, a memory to contain the group focus
 *                              portlist is allocated. The caller must call
 *                              omgt_pa_release_vf_focus to free the memory later.
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */

OMGT_STATUS_T
omgt_pa_get_vf_focus(
    struct omgt_port           *port, 
    STL_PA_IMAGE_ID_DATA       pm_image_id_query,
    char                      *vf_name, 
    uint32                     select, 
    uint32                     start, 
    uint32                     range,
    STL_PA_IMAGE_ID_DATA      *pm_image_id_resp, 
	uint32						*pNum_ports,
    STL_PA_VF_FOCUS_PORTS_RSP     **pm_vf_focus 
    )
{
    OMGT_STATUS_T           fstatus = OMGT_STATUS_ERROR;
    uint32                  num_ports;
    uint32                  size_vf_focus;
    STL_PA_IMAGE_ID_DATA           image_id = pm_image_id_query;
    OMGT_QUERY              query;
    PQUERY_RESULT_VALUES    query_results = NULL;
    STL_PA_VF_FOCUS_PORTS_RESULTS  *p;

    // Validate the parameters and state
    if (!port ||
        !vf_name ||
        (range > MAX_PORTS_LIST) ||
        !pm_vf_focus || *pm_vf_focus)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    memset(&query, 0, sizeof(query));   // initialize reserved fields
    query.InputType     = InputTypeNoInput;
    query.OutputType    = OutputTypePaTableRecord;

    OMGT_DBGPRINT(port, "Getting VF Focus...\n");
    OMGT_DBGPRINT(port, "Query: Input=%s, Output=%s\n",
             iba_pa_query_input_type_msg(query.InputType),
             iba_pa_query_result_type_msg(query.OutputType));

	fstatus = iba_pa_multi_mad_vf_focus_ports_response_query(port, &query,
		vf_name, select, start, range, &query_results, &image_id);

    if (!query_results)
    {
        OMGT_DBGPRINT(port, "PA VF Focus query Failed: %s\n",
                  iba_fstatus_msg(fstatus) );
        goto fail;
    }
    else if (query_results->Status != FSUCCESS)
    {
        OMGT_DBGPRINT(port,  "PA VF Focus query Failed: %s MadStatus 0x%X: %s\n",
                  iba_fstatus_msg(query_results->Status), port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        goto fail;
    }
    else if (query_results->ResultDataSize == 0)
    {
        OMGT_DBGPRINT(port, "No Records Returned\n");
        *pNum_ports = 0;
		fstatus = OMGT_STATUS_SUCCESS;
		goto done;
    }
    else
    {
        p = (STL_PA_VF_FOCUS_PORTS_RESULTS*)query_results->QueryResult;
        
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, " MadStatus 0x%X: %s\n", port->pa_mad_status,
                  iba_pa_mad_status_msg(port) );
        OMGT_DBGPRINT(port, "%d Bytes Returned\n", query_results->ResultDataSize);
        OMGT_DBGPRINT(port, "PA Multiple MAD Response for Focus portlist vf %s:\n",
                 vf_name );
        OMGT_DBGPRINT(port, "NumVFFocusPortsRecords = %d\n",
                  (int)p->NumVFFocusPortsRecords );
        
        num_ports = p->NumVFFocusPortsRecords < range ?
            p->NumVFFocusPortsRecords : range;
		*pNum_ports = num_ports;
        size_vf_focus = sizeof(STL_PA_VF_FOCUS_PORTS_RSP) * num_ports;
        
        if ( !( *pm_vf_focus = MemoryAllocate2AndClear( size_vf_focus,
                                                         IBA_MEM_FLAG_PREMPTABLE, OMGT_MEMORY_TAG ) ) )
        {
            OMGT_OUTPUT_ERROR(port, "can not allocate memory\n");
            goto fail;
        }
        
        OMGT_DBGPRINT(port,  "\tname:%s, ports:%u\n",
                  vf_name,
                  (unsigned int)num_ports );
        
        memcpy(*pm_vf_focus, p->FocusPortsRecords, size_vf_focus); 
        fstatus = OMGT_STATUS_SUCCESS;
    }

done:
    // iba_pa_query_port_fabric_info will have allocated a result buffer
    // we must free the buffer when we are done with it
    omgt_free_query_result_buffer(query_results);
    return (fstatus);

fail:
    fstatus = OMGT_STATUS_ERROR;
    goto done;
}


/* 
 *  Release vf focus portlist
 *
 * @param port                  Port to operate on. 
 * @param pm_vf_focus       Pointer to pointer to the vf focus portlist to free. 
 *
 * @return 
 *   None
 */
void 
omgt_pa_release_vf_focus(
    STL_PA_VF_FOCUS_PORTS_RSP     **pm_vf_focus
   )
{
    if (pm_vf_focus && *pm_vf_focus)
    {
        MemoryDeallocate(*pm_vf_focus);
        *pm_vf_focus = NULL;
    }
}

/**
 *  Get port statistics (counters). Supports 32 bit lids
 *
 * @param port                  Port to operate on.
 * @param pm_image_id_query     Image ID of port counters to get.
 * @param lid                   LID of node.
 * @param port_num              Port number.
 * @param pm_image_id_resp      Pointer to image ID of port counters returned.
 * @param port_counters         Pointer to port counters to fill.
 * @param flags                 Pointer to flags
 * @param delta                 1 for delta counters, 0 for raw image counters.
 * @param user_cntrs            1 for running counters, 0 for image counters. (delta must be 0)
 *
 * @return
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_port_stats2(
    struct omgt_port         *port,
    STL_PA_IMAGE_ID_DATA     pm_image_id_query,
    STL_LID                  lid,
    uint8                    port_num,
    STL_PA_IMAGE_ID_DATA    *pm_image_id_resp,
    STL_PORT_COUNTERS_DATA  *port_counters,
    uint32                  *flags,
    uint32                   delta,
	uint32                   user_cntrs
    )
{
    OMGT_STATUS_T            fstatus = OMGT_STATUS_ERROR;
    STL_PA_IMAGE_ID_DATA     image_id = pm_image_id_query;
    STL_PORT_COUNTERS_DATA  *response;

    // Validate the parameters and state
    if (!port || !port_counters)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    OMGT_DBGPRINT(port, "Getting Port Counters...\n");

    if ( ( response = iba_pa_single_mad_port_counters_response_query(
       port, lid, port_num, delta, user_cntrs, &image_id ) ) != NULL )
    {
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "%s Controlled Port Counters (%s) Response for nodeLid 0x%X portNumber %d%s%s:\n",
				 (user_cntrs?"User":"PM"), (delta?"Delta":"Total"), lid, port_num,
				 response->flags & STL_PA_PC_FLAG_UNEXPECTED_CLEAR?" (Unexpected Clear)":"",
				 response->flags & STL_PA_PC_FLAG_CLEAR_FAIL?" (Clear Unsuccessful)":"" );
        OMGT_DBGPRINT(port, "\tXmitData = %" PRIu64 "\n", response->portXmitData);
        OMGT_DBGPRINT(port, "\tRcvData = %" PRIu64 "\n", response->portRcvData);
        OMGT_DBGPRINT(port, "\tXmitPkts = %" PRIu64 "\n", response->portXmitPkts);
        OMGT_DBGPRINT(port, "\tRcvPkts = %" PRIu64 "\n", response->portRcvPkts);
        OMGT_DBGPRINT(port, "\tMulticastXmitPkts = %" PRIu64 "\n", response->portMulticastXmitPkts);
        OMGT_DBGPRINT(port, "\tMulticastRcvPkts = %" PRIu64 "\n", response->portMulticastRcvPkts);

        OMGT_DBGPRINT(port, "\tLinkQualityIndicator = %u\n", response->lq.s.linkQualityIndicator);
        OMGT_DBGPRINT(port, "\tUncorrectableErrors = %u\n", response->uncorrectableErrors); // 8 bit
        OMGT_DBGPRINT(port, "\tLinkDowned = %u\n", response->linkDowned);	// 32 bit
        OMGT_DBGPRINT(port, "\tNumLanesDown = %u\n", response->lq.s.numLanesDown);
        OMGT_DBGPRINT(port, "\tRcvErrors = %"PRIu64"\n", response->portRcvErrors);
        OMGT_DBGPRINT(port,  "\tExcessiveBufferOverruns = %"PRIu64"\n",
                  response->excessiveBufferOverruns );
        OMGT_DBGPRINT(port, "\tFMConfigErrors = %"PRIu64"\n",
                  response->fmConfigErrors );
        OMGT_DBGPRINT(port,  "\tLinkErrorRecovery = %u\n", response->linkErrorRecovery);	// 32 bit
        OMGT_DBGPRINT(port, "\tLocalLinkIntegrityErrors = %"PRIu64"\n",
                  response->localLinkIntegrityErrors );
        OMGT_DBGPRINT(port, "\tRcvRemotePhysicalErrors = %"PRIu64"\n",
                  response->portRcvRemotePhysicalErrors);
        OMGT_DBGPRINT(port, "\tXmitConstraintErrors = %"PRIu64"\n",
                  response->portXmitConstraintErrors );
        OMGT_DBGPRINT(port,  "\tRcvConstraintErrors = %"PRIu64"\n",
                  response->portRcvConstraintErrors );
        OMGT_DBGPRINT(port, "\tRcvSwitchRelayErrors = %"PRIu64"\n",
                  response->portRcvSwitchRelayErrors);
        OMGT_DBGPRINT(port, "\tXmitDiscards = %"PRIu64"\n", response->portXmitDiscards);
        OMGT_DBGPRINT(port,  "\tCongDiscards = %"PRIu64"\n",
                  response->swPortCongestion);
        OMGT_DBGPRINT(port, "\tRcvFECN = %"PRIu64"\n", response->portRcvFECN);
        OMGT_DBGPRINT(port, "\tRcvBECN = %"PRIu64"\n", response->portRcvBECN);
        OMGT_DBGPRINT(port, "\tMarkFECN = %"PRIu64"\n", response->portMarkFECN);
        OMGT_DBGPRINT(port, "\tXmitTimeCong = %"PRIu64"\n", response->portXmitTimeCong);
        OMGT_DBGPRINT(port, "\tXmitWait = %"PRIu64"\n", response->portXmitWait);
        OMGT_DBGPRINT(port, "\tXmitWastedBW = %"PRIu64"\n", response->portXmitWastedBW);
        OMGT_DBGPRINT(port, "\tXmitWaitData = %"PRIu64"\n", response->portXmitWaitData);
        OMGT_DBGPRINT(port, "\tRcvBubble = %"PRIu64"\n", response->portRcvBubble);
        if (pm_image_id_resp)
            *pm_image_id_resp = response->imageId;
        if (flags)
            *flags = response->flags;

        memcpy(port_counters, response, sizeof(*port_counters));
        MemoryDeallocate(response);
        fstatus = OMGT_STATUS_SUCCESS;
    }
    else
        OMGT_DBGPRINT(port, "Got NULL response - FAILED\n");

    return (fstatus);
}

/* Deprecated. Use omgt_get_vf_port_stats2
*  This Should be removed in favor of the version that supports 32bit lids
*  when opamgt public library decides breaking compatibility is acceptable. 
*/
OMGT_STATUS_T
omgt_pa_get_port_stats(
    struct omgt_port         *port,
    STL_PA_IMAGE_ID_DATA     pm_image_id_query,
    uint16_t                 lid,
    uint8                    port_num,
    STL_PA_IMAGE_ID_DATA    *pm_image_id_resp,
    STL_PORT_COUNTERS_DATA  *port_counters,
    uint32                  *flags,
    uint32                   delta,
	uint32                   user_cntrs
    )
{
	OMGT_DBGPRINT(port, "omgt_pa_get_port_stats is deprecated. Please use omgt_pa_get_port_stats2\n");
	return omgt_pa_get_port_stats2(port, pm_image_id_query, lid, port_num, pm_image_id_resp, port_counters, flags, delta, user_cntrs);
}



/**
 *  Clear specified port counters for specified port
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of port counters to clear. 
 * @param lid                   LID of port.
 * @param port_num              Port number. 
 * @param selct_flags           Port's counters to clear. 
 *
 * @return 
 *   FSUCCESS - Clear successful
 *     FERROR - Error
 */
FSTATUS 
pa_client_clr_port_counters( 
    struct omgt_port     *port,
    STL_PA_IMAGE_ID_DATA       pm_image_id_query, 
    STL_LID             lid,
    uint8               port_num, 
    uint32              select_flag 
    )
{
    FSTATUS                 fstatus = FERROR;
    STL_CLR_PORT_COUNTERS_DATA  *response;
    
    // Validate the parameters and state
    if (!port)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }
  
    if ( ( response =
           iba_pa_single_mad_clr_port_counters_response_query(
               port, lid, port_num, select_flag ) ) )
    {
        MemoryDeallocate(response);
        fstatus = FSUCCESS;
    }

    return (fstatus);
}

/**
 *  Get vf port statistics (counters). Supports 32 bit lids. 
 *
 * @param port                  Port to operate on.
 * @param pm_image_id_query     Image ID of port counters to get.
 * @param vf_name				Pointer to VF name.
 * @param lid                   LID of node.
 * @param port_num              Port number.
 * @param pm_image_id_resp      Pointer to image ID of port counters returned.
 * @param vf_port_counters      Pointer to vf port counters to fill.
 * @param flags                 Pointer to flags
 * @param delta                 1 for delta counters, 0 for raw image counters.
 * @param user_cntrs            1 for running counters, 0 for image counters. (delta must be 0)
 *
 * @return
 *   OMGT_STATUS_SUCCESS - Get successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_get_vf_port_stats2(
    struct omgt_port              *port,
    STL_PA_IMAGE_ID_DATA          pm_image_id_query,
	char				         *vf_name,
    STL_LID                       lid,
    uint8                         port_num,
    STL_PA_IMAGE_ID_DATA         *pm_image_id_resp,
    STL_PA_VF_PORT_COUNTERS_DATA *vf_port_counters,
    uint32                       *flags,
    uint32                        delta,
	uint32                        user_cntrs
    )
{
	OMGT_STATUS_T                 fstatus = OMGT_STATUS_ERROR;
    STL_PA_IMAGE_ID_DATA          image_id = pm_image_id_query;
    STL_PA_VF_PORT_COUNTERS_DATA *response;

    // Validate the parameters and state
    if (!port || !vf_port_counters)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    OMGT_DBGPRINT(port, "Getting Port Counters...\n");

    if ( ( response = iba_pa_single_mad_vf_port_counters_response_query(
       port, lid, port_num, delta, user_cntrs, vf_name, &image_id ) ) != NULL )
    {
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "%s Controlled VF Port Counters (%s) Response for nodeLid 0x%X portNumber %d%s%s:\n",
				 (user_cntrs?"User":"PM"), (delta?"Delta":"Total"), lid, port_num,
				 response->flags & STL_PA_PC_FLAG_UNEXPECTED_CLEAR?" (Unexpected Clear)":"",
				 response->flags & STL_PA_PC_FLAG_CLEAR_FAIL?" (Clear Unsuccessful)":"" );
        OMGT_DBGPRINT(port, "\tvfName = %s\n", response->vfName);
        OMGT_DBGPRINT(port, "\tXmitData = %" PRIu64 "\n", response->portVFXmitData);
        OMGT_DBGPRINT(port, "\tRcvData = %" PRIu64 "\n", response->portVFRcvData);
        OMGT_DBGPRINT(port, "\tXmitPkts = %" PRIu64 "\n", response->portVFXmitPkts);
        OMGT_DBGPRINT(port, "\tRcvPkts = %" PRIu64 "\n", response->portVFRcvPkts);
        OMGT_DBGPRINT(port, "\tXmitDiscards = %"PRIu64"\n", response->portVFXmitDiscards);
        OMGT_DBGPRINT(port, "\tCongDiscards = %"PRIu64"\n", response->swPortVFCongestion);
        OMGT_DBGPRINT(port, "\tRcvFECN = %"PRIu64"\n", response->portVFRcvFECN);
        OMGT_DBGPRINT(port, "\tRcvBECN = %"PRIu64"\n", response->portVFRcvBECN);
        OMGT_DBGPRINT(port, "\tMarkFECN = %"PRIu64"\n", response->portVFMarkFECN);
        OMGT_DBGPRINT(port, "\tXmitTimeCong = %"PRIu64"\n", response->portVFXmitTimeCong);
        OMGT_DBGPRINT(port, "\tXmitWait = %"PRIu64"\n", response->portVFXmitWait);
        OMGT_DBGPRINT(port, "\tXmitWastedBW = %"PRIu64"\n", response->portVFXmitWastedBW);
        OMGT_DBGPRINT(port, "\tXmitWaitData = %"PRIu64"\n", response->portVFXmitWaitData);
        OMGT_DBGPRINT(port, "\tRcvBubble = %"PRIu64"\n", response->portVFRcvBubble);
        if (pm_image_id_resp)
            *pm_image_id_resp = response->imageId;
        if (flags)
            *flags = response->flags;

        memcpy(vf_port_counters, response, sizeof(*vf_port_counters));
        MemoryDeallocate(response);
        fstatus = OMGT_STATUS_SUCCESS;
    }
    else
        OMGT_DBGPRINT(port, "Got NULL response - FAILED\n");

    return (fstatus);
}

/* Deprecated. Use omgt_get_vf_port_stats2
*  This Should be removed in favor of the version that supports 32bit lids
*  when opamgt public library decides breaking compatibility is acceptable. 
*/

OMGT_STATUS_T
omgt_pa_get_vf_port_stats(
    struct omgt_port         *port,
    STL_PA_IMAGE_ID_DATA     pm_image_id_query,
	char    		         *vf_name,
    uint16_t                 lid,
    uint8                    port_num,
    STL_PA_IMAGE_ID_DATA    *pm_image_id_resp,
    STL_PA_VF_PORT_COUNTERS_DATA *vf_port_counters,
    uint32                  *flags,
    uint32                   delta,
	uint32                   user_cntrs
    )
{
	OMGT_DBGPRINT(port, "omgt_pa_get_vf_port_stats is deprecated. Please use omgt_pa_get_vf_port_stats2\n");
	return omgt_pa_get_vf_port_stats2(port, pm_image_id_query, vf_name, lid, port_num, pm_image_id_resp, vf_port_counters, flags, delta, user_cntrs);
}

/**
 *  Freeze specified image
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of image to free. 
 * @param pm_image_id_resp      Pointer to image ID of image frozen. 
 *
 * @return 
 *   OMGT_STATUS_SUCCESS - Freeze successful
 *     OMGT_STATUS_ERROR - Error
 */
OMGT_STATUS_T
omgt_pa_freeze_image(
    struct omgt_port     *port,
    STL_PA_IMAGE_ID_DATA       pm_image_id_query,
    STL_PA_IMAGE_ID_DATA       *pm_image_id_resp 
    )
{
    OMGT_STATUS_T          fstatus = OMGT_STATUS_ERROR;
    STL_PA_IMAGE_ID_DATA   image_id = pm_image_id_query;
    STL_PA_IMAGE_ID_DATA   *response;

    // Validate the parameters and state
    if (!port)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    OMGT_DBGPRINT(port, "QueryImageNum = 0x%" PRIX64 " Offset = %d\n",
              pm_image_id_query.imageNumber, (int)pm_image_id_query.imageOffset );

    if ( ( response =
           iba_pa_single_mad_freeze_image_response_query(
              port, &image_id ) ) != NULL )
    {
        OMGT_DBGPRINT(port, "RespImageNum = 0x%" PRIX64 " Offset = %d\n",
                  response->imageNumber, (int)response->imageOffset );
        
        if (pm_image_id_resp)
            *pm_image_id_resp = *response;
        
        MemoryDeallocate(response);
        fstatus = OMGT_STATUS_SUCCESS;
    }
    else
        OMGT_DBGPRINT(port, "Got NULL response - FAILED\n");

    return (fstatus);
}

/**
 *   Move freeze of image 1 to image 2
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of frozen image 1. 
 * @param pm_image_id_resp      Pointer to image ID of image2. 
 *  
 * @return 
 *   OMGT_STATUS_SUCCESS       - Move image Freeze successful
 *   OMGT_STATUS_UNAVAILABLE   - Image 2 unavailable freeze
 *   OMGT_STATUS_ERROR         - Error
 */
OMGT_STATUS_T
omgt_pa_move_image_freeze(
    struct omgt_port     *port, 
    STL_PA_IMAGE_ID_DATA       pm_image_id1,
    STL_PA_IMAGE_ID_DATA       *pm_image_id2 
    )
{
    FSTATUS fstatus     = OMGT_STATUS_ERROR;
    STL_MOVE_FREEZE_DATA    request;
    STL_MOVE_FREEZE_DATA    *response;

    // Validate the parameters and state
    if (!port || !pm_image_id2)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    OMGT_DBGPRINT(port, "Img1ImageNum = 0x%" PRIX64 " Offset = %d\n",
              pm_image_id1.imageNumber, (int)pm_image_id1.imageOffset );
    OMGT_DBGPRINT(port, "Img2ImageNum = 0x%" PRIX64 " Offset = %d\n",
              pm_image_id2->imageNumber, (int)pm_image_id2->imageOffset );
    request.oldFreezeImage = pm_image_id1;
    request.newFreezeImage = *pm_image_id2;

    if ( ( response =
           iba_pa_single_mad_move_freeze_response_query( 
              port, &request ) ) != NULL )
    {
        OMGT_DBGPRINT(port, "RespOldImageNum = 0x%" PRIX64 " Offset = %d\n",
                  response->oldFreezeImage.imageNumber, response->oldFreezeImage.imageOffset );
        OMGT_DBGPRINT(port, "RespNewImageNum = 0x%" PRIX64 " Offset = %d\n",
                  response->newFreezeImage.imageNumber, response->newFreezeImage.imageOffset );
         
        *pm_image_id2 = response->newFreezeImage;
        fstatus = OMGT_STATUS_SUCCESS;
        MemoryDeallocate(response);
    }
    else
    {
        OMGT_DBGPRINT(port, "Got NULL response - UNAVAILABLE\n");
        fstatus = OMGT_STATUS_UNAVAILABLE;
    }

    return (fstatus);
}

/**
 *   Release specified image.
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of image to release. 
 *  
 * @return 
 *   OMGT_STATUS_SUCCESS       - Release successful
 *     OMGT_STATUS_ERROR       - Error
 */
OMGT_STATUS_T
omgt_pa_release_image(
    struct omgt_port     *port,
    STL_PA_IMAGE_ID_DATA       pm_image_id_query
    )
{
    OMGT_STATUS_T          fstatus = OMGT_STATUS_ERROR;
    STL_PA_IMAGE_ID_DATA   image_id = pm_image_id_query;
    STL_PA_IMAGE_ID_DATA   *response;

    // Validate the parameters and state
    if (!port)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    if ( ( response = iba_pa_single_mad_release_image_response_query( 
               port, &image_id ) ) != NULL )
    {
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "QueryImageNum = 0x%" PRIX64 " Offset = %d\n",
                  pm_image_id_query.imageNumber, (int)pm_image_id_query.imageOffset );
        OMGT_DBGPRINT(port, "RespImageNum = 0x%" PRIX64 " Offset = %d\n",
                  response->imageNumber, (int)response->imageOffset );
        
        MemoryDeallocate(response);
        fstatus = OMGT_STATUS_SUCCESS;
    }
    else
        OMGT_DBGPRINT(port, "Got NULL response - FAILED\n");

    return (fstatus);
}

/**
 *   Renew lease of specified image.
 *
 * @param port                  Port to operate on. 
 * @param pm_image_id_query     Image ID of image to renew. 
 *  
 * @return 
 *   OMGT_STATUS_SUCCESS       - Renew successful
 *     OMGT_STATUS_ERROR       - Error
 */
OMGT_STATUS_T
omgt_pa_renew_image(
    struct omgt_port     *port,
    STL_PA_IMAGE_ID_DATA       pm_image_id_query
    )
{
    OMGT_STATUS_T          fstatus = OMGT_STATUS_ERROR;
    STL_PA_IMAGE_ID_DATA   image_id = pm_image_id_query;
    STL_PA_IMAGE_ID_DATA   *response;

    // Validate the parameters and state
    if (!port)
    {
        OMGT_OUTPUT_ERROR(port, "invalid params or state\n");
        return (fstatus);
    }

    if ( ( response = iba_pa_single_mad_renew_image_response_query( 
       port, &image_id ) ) != NULL )
    {
        // TBD remove some of these after additional MAD testing
        OMGT_DBGPRINT(port, "QueryImageNum = 0x%" PRIX64 " Offset = %d\n",
                  pm_image_id_query.imageNumber, (int)pm_image_id_query.imageOffset );
        OMGT_DBGPRINT(port, "RespImageNum = 0x%" PRIX64 " Offset = %d\n",
                  response->imageNumber, (int)response->imageOffset );
        
        MemoryDeallocate(response);
        fstatus = OMGT_STATUS_SUCCESS;
    }
    else
        OMGT_DBGPRINT(port, "Got NULL response - FAILED\n");

    return (fstatus);
}

#endif
