/* BEGIN_ICS_COPYRIGHT2 ****************************************

Copyright (c) 2015-2018, 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_COPYRIGHT2   ****************************************/

//===========================================================================//

//

// FILE NAME

//    fm_xml.h

//

// DESCRIPTION

//    This file contains structures used for parsing the fm_config.xml

//    file for configuring SM

//

//===========================================================================//

#ifndef	_FM_XML_H_

#define	_FM_XML_H_

#include <stdio.h>

#include <signal.h>

#include <ixml.h>

#include "cs_log.h"

#ifdef __VXWORKS__

#include "regexp.h"

#else

#include "regex.h"

#endif

#ifndef __VXWORKS__

#define MAX_SUBNET_SIZE						64000		// HSM has no realistic max

#define DEFAULT_SUBNET_SIZE					2560		// XML default subnet size

#else  // __VXWORKS__

#define MAX_SUBNET_SIZE						288			// ESM has a max subnet size of 288

#define DEFAULT_SUBNET_SIZE					100		    // XML default subnet size

#endif // __VXWORKS__

// Key PM config parameter defaults and ranges

#define PM_DEFAULT_TOTAL_IMAGES	10			// for Image[] and history[]

#define PM_MIN_TOTAL_IMAGES	3				// for Image[] and history[]

#ifdef __VXWORKS__

// keep vxWorks limited to save memory and also because pm_compute_pool_size

// is called before reading config file

#define PM_MAX_TOTAL_IMAGES	10				// for Image[] and history[]

#else

#define PM_MAX_TOTAL_IMAGES	100000			// for Image[] and history[]

#endif

#define PM_DEFAULT_FF_IMAGES 5				// for freezeFrame[]

#define PM_MIN_FF_IMAGES 2					// for freezeFrame[]

#ifdef __VXWORKS__

#define PM_MAX_FF_IMAGES (PM_MAX_TOTAL_IMAGES-2)	// for freezeFrame[]

#else

// due to some linear searches, we limit number of FF.  2-3 per client is enough

// and only a handful of clients are expected, 100 should be plenty

#define PM_MAX_FF_IMAGES 100				// for freezeFrame[]

#endif

#define PM_DEFAULT_PA_MAX_CLIENTS 3

#define PM_MIN_MAX_CLIENTS	3

#ifdef __VXWORKS__

// keep vxWorks limited to save memory and also because pm_compute_pool_size

// is called before reading config file

#define PM_MAX_MAX_CLIENTS	4

#else

#define PM_MAX_MAX_CLIENTS	20

#endif

#define PM_DEFAULT_FF_LEASE 60				// in seconds

#define PM_DEFAULT_MAX_ATTEMPTS			3

#define PM_DEFAULT_RESP_TIMEOUT			250

#define PM_DEFAULT_MIN_RESP_TIMEOUT		35

#define PM_DEFAULT_SWEEP_ERRORS_LOG_THRESHOLD	10

#define PM_DEFAULT_MAX_PARALLEL_NODES	10

#define PM_DEFAULT_PMA_BATCH_SIZE		2

#define STL_PM_MAX_DG_PER_PMPG	5		//Maximum number of Monitors allowed in a PmPortGroup

#define STL_PM_GROUPNAMELEN		64

#define STL_PM_MAX_CUSTOM_PORT_GROUPS 8 // HFIs and SWs take the first 2 slots.

#define FE_LISTEN_PORT     	3245    // FAB_EXEC listen port

#define FE_WIN_SIZE			1       // Default Window Size for Reliable

#define FE_MAX_WIN_SIZE    	16      // Maximum window size

#define FE_MIN_WIN_SIZE    	1       // Minimum window size

#define FE_MAX_TRAP_SUBS    20      // Maximum number of TrapSubs

// max number of times to fail to check on master

#define SM_CHECK_MASTER_INTERVAL 5

#define SM_CHECK_MASTER_MAX_COUNT 3

#define SM_TRAP_THRESHOLD_MIN 10

#define SM_TRAP_THRESHOLD_MAX 100

#define SM_TRAP_THRESHOLD_DEFAULT 0 // off

#define SM_TRAP_THRESHOLD_COUNT_DEFAULT 10

#define SM_TRAP_THRESHOLD_COUNT_MIN     2

#define SM_TRAP_THRESHOLD_COUNT_MAX     100

#define STL_CONFIGURABLE_SLS		16

#define NONRESP_TIMEOUT  	600ull

#define NONRESP_MAXRETRY 	3

// Cable Info Policy

#define CIP_NONE 0

#define CIP_LINK 1

#define CIP_PORT 2

// SwitchCascadeActivateEnable setting

#define SCAE_DISABLED 0

#define SCAE_SW_ONLY 1

#define SCAE_ALL 2

// PortBounceLogLimit no limit setting

#define PORT_BOUNCE_LOG_NO_LIMIT 0

// While logging of traps from a port is suppressed, summary trap information

// will be logged for that port after accumulating a certain number of traps.

// This number starts with SM_TRAP_LOG_SUMMARY_THRESHOLD_START.

// Once that number is reached and sa_TrapNeedsLogging() is called, the count

// of traps is reset to zero and the threshold  is increased by

// SM_TRAP_LOG_SUMMARY_THRESHOLD_INCREMENT, with the maximum value of the

// threshold being capped off by  SM_TRAP_LOG_SUMMARY_THRESHOLD_MAX

#define SM_TRAP_LOG_SUMMARY_THRESHOLD_START     5

#define SM_TRAP_LOG_SUMMARY_THRESHOLD_INCREMENT 5

/* Should not be greater than 250 - logSuppressTrapCount is an 8 bit field*/

#define SM_TRAP_LOG_SUMMARY_THRESHOLD_MAX       250

// Below constants are for suppressing trap logging information to reduce

// too much noise in the log

// If two traps are received from the same port with in

// SM_TRAP_LOG_SUPPRESS_TRIGGER_INTERVAL, logging of trap information from

// that port will be suppressed

#define SM_TRAP_LOG_SUPPRESS_TRIGGER_INTERVAL   30      /*in seconds*/

// Preemption Default Values

#define SM_PREEMPT_SMALL_PACKET_MIN 32

#define SM_PREEMPT_SMALL_PACKET_MAX 8192

#define SM_PREEMPT_SMALL_PACKET_DEF 256

#define SM_PREEMPT_SMALL_PACKET_INC 32

#define SM_PREEMPT_LARGE_PACKET_MIN 512

#define SM_PREEMPT_LARGE_PACKET_MAX 8192

#define SM_PREEMPT_LARGE_PACKET_DEF 4096

#define SM_PREEMPT_LARGE_PACKET_INC 512

#define SM_PREEMPT_LIMIT_MIN 256    // Note 0 is a valid value, but effectively turns off preemption

#define SM_PREEMPT_LIMIT_MAX 65024  // This is the max without being infinite

#define SM_PREEMPT_LIMIT_INF 65280  // This is the magical infinite value. SM_PREEMPT_LIMIT_INF / SM_PREEMPT_LIMIT_INC = 0xff.

#define SM_PREEMPT_LIMIT_DEF 4096

#define SM_PREEMPT_LIMIT_INC 256

#define SM_PREEMPT_TAIL_MIN 80

#define SM_PREEMPT_TAIL_DEF 80

#define SM_PREEMPT_TAIL_INC 8

#define SM_PREEMPT_HEAD_MIN 80

#define SM_PREEMPT_HEAD_DEF 80

#define SM_PREEMPT_HEAD_INC 8

#define SM_DEFAULT_MAX_LID  0xBFFF

#define SM_MAX_LID_LIMIT    0xBFFF

#define SM_MAX_9B_LID       0xBFFF

// Note: Multicast and Collective masks are currently

// not configurable.

#define SM_DEFAULT_MULTICAST_MASK 4

#define SM_DEFAULT_COLLECTIVE_MASK 1

// Constants related to our multicast lid collescing scheme

#define MAX_SUPPORTED_MCAST_GRP_CLASSES 32

#define DEFAULT_SW_MLID_TABLE_CAP 1024

#define XML_PARSE_MEMORY_LIMIT				10000000	// limit to 10M per instance of FM

// this define will turn on a series of debug statements for XML parsing

//#define XML_DEBUG

// this define will turn on memory debugging for XML and VF parsing

//#define XML_MEMORY

// Max number on FM instances - ESM only requires one instance and will be

// adjusted for in the parser

#define MAX_INSTANCES 						8

// VF definitions - note that the number of devices is unlimited and has been

// tested to 20,000

#ifdef __VXWORKS__

#define MAX_CONFIGURED_VFABRICS             64

#define MAX_ENABLED_VFABRICS                32

#else /* __VXWORKS__ */

#define MAX_CONFIGURED_VFABRICS           1000

#define MAX_ENABLED_VFABRICS              1000

#endif /* __VXWORKS__ */

#define MAX_VFABRIC_APPS				64

#define MAX_VFABRIC_GROUPS				1024

#define MAX_VFABRIC_MEMBERS_PER_VF			1024

#define MAX_VFABRIC_APPS_PER_VF				64

#define MAX_VFABRIC_APP_SIDS				64

#define MAX_VFABRIC_APP_MGIDS				64

#define MAX_QOS_GROUPS					32

#define MAX_INCLUDED_GROUPS				32

#define MAX_INCLUDED_APPS				32

#define MAX_DEFAULT_GROUPS				64

#define MAX_VFABRIC_DG_MGIDS				32

// Length of VirtualFabric, Group, Application, Fm instance  Names

#define MAX_VFABRIC_NAME					64

// Length of longest compound string in App - typically MGID

#define MAX_VFABRIC_APP_ELEMENT				96

// same quantity as MAX_SUPPORTED_MCAST_GRP_CLASSES in sm_l.h

#define MAX_SUPPORTED_MCAST_GRP_CLASSES_XML 32

// priority range

#define MAX_PRIORITY						15

// VL15CreditRate range

#define MAX_VL15_CREDIT_RATE				21

// Max ports per switch, used in config definitions

#define MAX_SWITCH_PORTS					255

// out of memory error

#define OUT_OF_MEMORY					"Memory limit has been exceeded parsing the XML configuration"

#define OUT_OF_MEMORY_RETURN			"Memory limit has been exceeded parsing the XML configuration\n"

#define PRINT_MEMORY_ERROR				IXmlParserPrintError(state, OUT_OF_MEMORY);

// undefined XML values - used to see if XML config provided value after parsing

#define UNDEFINED_XML8					0xff

#define UNDEFINED_XML16					0xffff

#define UNDEFINED_XML32					0xffffffff

#define UNDEFINED_XML64					0xffffffffffffffffull

// array sizes

#define FILENAME_SIZE					256

#define LOGFILE_SIZE					100

#define STRING_SIZE						32

// config consistency check levels

#define NO_CHECK_CCC_LEVEL				0

#define CHECK_NO_ACTION_CCC_LEVEL		1

#define CHECK_ACTION_CCC_LEVEL			2

#define DEFAULT_CCC_LEVEL				CHECK_ACTION_CCC_LEVEL

#define DEFAULT_CCC_METHOD				MD5_CHECKSUM_METHOD

// values for Sm.PathSelection parameter

#define PATH_MODE_MINIMAL	0	// no more than 1 path per lid

#define PATH_MODE_PAIRWISE	1	// cover every lid on "bigger side" exactly once

#define PATH_MODE_ORDERALL	2	// PAIRWISE, then all src, all dst (skip dups)

#define PATH_MODE_SRCDSTALL	3	// all src, all dst

// Bitmask definitions for [Debug] SM Skip Write

#define SM_SKIP_WRITE_PORTINFO		0x00000001	// Includes Port Info

#define SM_SKIP_WRITE_SMINFO		0x00000002	// Includes Sm Info

#define SM_SKIP_WRITE_GUID			0x00000004	// Includes GUID Info

#define SM_SKIP_WRITE_SWITCHINFO	0x00000008	// Includes Switch Info

#define SM_SKIP_WRITE_VLARB			0x00000020	// Includes VLArb Tables (High / Low / Preempt Matrix)

#define SM_SKIP_WRITE_MAPS			0x00000040	// Includes SL::SC, SC::SL, SC::VL

#define SM_SKIP_WRITE_LFT			0x00000080	// Includes LFT and  MFT

#define SM_SKIP_WRITE_AR			0x00000100	// Includes port group table, portgroup FDB

#define SM_SKIP_WRITE_PKEY			0x00000200

#define SM_SKIP_WRITE_CONG			0x00000400	// Includes HFI congestion / Switch congestion

#define SM_SKIP_WRITE_BFRCTRL		0x00000800

#define SM_SKIP_WRITE_NOTICE		0x00001000

#define SM_SKIP_WRITE_PORTSTATEINFO 0x00002000  // Includes PortStateInfo sets for cascade activation

// This can be used for values such as LogMask's where it is necessary

// to know if a value was supplied.

typedef struct _FmParamU32 {

	uint32_t			value;

	uint8_t				valid;	// is value valid

} FmParamU32_t;

// Structures for parsing of Virtual Fabric XML tags

typedef struct _XmlGuid {

	uint64_t			guid;

	struct _XmlGuid		*next;

} XmlGuid_t;

typedef struct _XmlNode {

	char				node[MAX_VFABRIC_NAME];

	struct _XmlNode		*next;

} XmlNode_t;

typedef struct _XmlIncGroup {

	char group[MAX_VFABRIC_NAME];

	int  dg_index; // Index into dg_config

	struct _XmlIncGroup	*next;

} XmlIncGroup_t;

#define MAX_BRACKETS_SUPPORTED 10

#define MAX_DIGITS_TO_PROCESS 5

#define MAX_NODE_DESC_REG_EXPR 1500

typedef struct _RegexBracketParseInfo{

  int     totalGroups;

  boolean portRangeDefined;

  int     portNum1;

  int     portNum2;

  int     lead0sPort1;

  int     lead0sPort2;

  int numBracketRangesDefined;

  int number1[MAX_BRACKETS_SUPPORTED];

  int numDigitsNum1[MAX_BRACKETS_SUPPORTED];

  int number2[MAX_BRACKETS_SUPPORTED];

  int numDigitsNum2[MAX_BRACKETS_SUPPORTED];

  int leading0sNum1[MAX_BRACKETS_SUPPORTED];

  int leading0sNum2[MAX_BRACKETS_SUPPORTED];

  int bracketGroupNum[MAX_BRACKETS_SUPPORTED];

} RegexBracketParseInfo_t;

typedef struct _RegExp {

	char			     	regexString[MAX_NODE_DESC_REG_EXPR];

	boolean                 isSyntaxValid;

	RegexBracketParseInfo_t regexInfo;

#ifdef __VXWORKS__

	regexp                  *regexpCompiled;

#else

	regmatch_t              groupArray[MAX_BRACKETS_SUPPORTED];

	regex_t                 regexCompiled;

#endif

	struct _RegExp   	    *next;

} RegExp_t;

// Virtual Fabric Group configuration

typedef struct  _DGConfig {

	char            name[MAX_VFABRIC_NAME];

	int             dg_index; // index into dg_config

	uint32_t        number_of_system_image_guids;

	cl_qmap_t       system_image_guid;

	uint32_t        number_of_node_guids;

	cl_qmap_t       node_guid;

	uint32_t        number_of_port_guids;

	cl_qmap_t       port_guid;

	uint32_t        number_of_node_descriptions;

	XmlNode_t      *node_description;

	RegExp_t       *reg_expr; // setup by SM

	uint32_t        number_of_included_groups;

	XmlIncGroup_t  *included_group;

	// Select

	uint8_t         select_all;

	uint8_t         select_self;

	uint8_t         select_swe0;

	uint8_t         select_all_mgmt_allowed;

	uint8_t         select_hfi_direct_connect;

	uint8_t         select_all_tfis;

	// NodeType

	uint8_t         node_type_fi;

	uint8_t         node_type_sw;

} DGConfig_t;

typedef struct _XmlAppMgid {

	char			mgid[MAX_VFABRIC_NAME];

} XmlAppMgid_t;

typedef struct _XmlAppMgidRng {

	char			range[MAX_VFABRIC_APP_ELEMENT];

} XmlAppMgidRng_t;

typedef struct _XmlAppMgidMsk {

	char			masked[MAX_VFABRIC_APP_ELEMENT];

} XmlAppMgidMsk_t;

// Virtual Fabric Application configuration

typedef struct 	_AppConfig {

	char			name[MAX_VFABRIC_NAME]; /* MUST BE FIRST FIELD FOR MAP */

	uint32_t		serviceIdMapSize;

	cl_qmap_t		serviceIdMap;

	uint32_t		serviceIdRangeMapSize;

	cl_qmap_t		serviceIdRangeMap;

	uint32_t		serviceIdMaskedMapSize;

	cl_qmap_t		serviceIdMaskedMap;

	uint32_t		number_of_mgids;

	XmlAppMgid_t	mgid[MAX_VFABRIC_APP_MGIDS];

	uint32_t		number_of_mgid_ranges;

	XmlAppMgidRng_t	mgid_range[MAX_VFABRIC_APP_MGIDS];

	uint32_t		number_of_mgid_maskeds;

	XmlAppMgidMsk_t	mgid_masked[MAX_VFABRIC_APP_MGIDS];

	uint32_t		number_of_included_apps;

	XmlNode_t		included_app[MAX_INCLUDED_APPS];

	uint8_t			select_sa;

	uint8_t			select_unmatched_sid;

	uint8_t			select_unmatched_mgid;

	uint8_t			select_pm;

} AppConfig_t;

// Virtual Fabric QOS Group configuration

typedef struct 	_QosConfig {

	char			name[MAX_VFABRIC_NAME];

	uint8_t			enable;

	uint8_t			qos_enable; /* For legacy support of VFs with QOS=0 */

	uint8_t			private_group;     /* For legacy support of VFs with QOS=0 */

	uint8_t			base_sl;

	uint8_t			base_sl_specified;

	uint8_t			resp_sl;

	uint8_t			resp_sl_specified;

	uint8_t			requires_resp_sl;

	uint8_t			mcast_sl;

	uint8_t			mcast_sl_specified;

	uint8_t			contains_mcast;

	uint8_t			flowControlDisable;

	uint8_t			percent_bandwidth;

	uint8_t			priority;

	uint8_t			pkt_lifetime_mult; /* Converted to power of 2 */

    uint32_t		hoqlife_qos;

    uint8_t			preempt_rank;

	uint32_t		num_implicit_vfs;

	uint32_t		num_vfs;

	uint8_t			pkt_lifetime_specified;

	uint8_t			hoqlife_specified;

} QosConfig_t;

// Application configuration

typedef struct _XMLApp {

	char            application[MAX_VFABRIC_NAME];

} XMLApp_t;

typedef struct _XMLMember {

	char member[MAX_VFABRIC_NAME];

	int  dg_index; // Index into dg_config;

} XMLMember_t;

// Virtual Fabric configuration

typedef struct 	_VFConfig {

	char			name[MAX_VFABRIC_NAME]; /* MUST BE FIRST FIELD FOR MAP */

	uint32_t		enable;

	uint32_t		standby;

	uint32_t		pkey;

	uint32_t		security;

	uint32_t		qos_index;

	char			qos_group[MAX_VFABRIC_NAME];

	uint32_t		number_of_full_members;

	XMLMember_t		full_member[MAX_VFABRIC_MEMBERS_PER_VF];

	uint32_t		number_of_limited_members;

	XMLMember_t		limited_member[MAX_VFABRIC_MEMBERS_PER_VF];

	uint32_t		number_of_applications;

	XMLApp_t 		application[MAX_VFABRIC_APPS_PER_VF];

	uint8_t			max_mtu_int;

	uint8_t			max_rate_int;

	uint8_t			qos_implicit;

	// Deprecated configuration items (see QOSConfig_t for new fields)

	uint8_t			qos_enable;

	uint8_t			base_sl;

	uint8_t			resp_sl;

	uint8_t			mcast_sl;

	uint8_t			flowControlDisable;

	uint8_t			percent_bandwidth;

	uint8_t			priority;

	uint8_t			pkt_lifetime_mult;

    uint8_t			preempt_rank;

    uint32_t		hoqlife_vf;

} VFConfig_t;

// Application Database Composite per FM

typedef struct 	_AppXmlConfig {

	uint32_t			appMapSize;

	cl_qmap_t			appMap;					// binary tree of apps by name

} AppXmlConfig_t;

// DeviceGroup Database Composite per FM

typedef struct 	_DGXmlConfig {

	uint32_t			number_of_dgs;

	DGConfig_t			*dg[MAX_VFABRIC_GROUPS];

} DGXmlConfig_t;

// QOSGroup Database Composite per FM

typedef struct 	_QosXmlConfig {

	uint32_t			number_of_qosgroups;

	QosConfig_t			*qosgroups[MAX_QOS_GROUPS];

} QosXmlConfig_t;

// VirtualFabrics Database Composite per FM

typedef struct 	_VFXmlConfig {

	uint32_t			number_of_vfs;

	VFConfig_t			*vf[MAX_CONFIGURED_VFABRICS];

	uint8_t				securityEnabled;				// Composite of all vf's

	uint8_t				qosEnabled;						// Composite of all vf's

} VFXmlConfig_t;

// Internal structures for internal application use for Virtual Fabric Configuration

// Internal Service ID's

typedef struct VFAppSid_t {

	uint64_t        	service_id;					// service_id or first service_id in range

													// if 0xfffffffffffffff then all apps

	uint64_t        	service_id_last;			// if 0 then then no range

	uint64_t        	service_id_mask;			// if 0xfffffffffffffff then no mask

} VFAppSid_t;

// Internal Multicast Group ID's

typedef struct _VFAppMgid {

	uint64_t			mgid[2];					// 128 bit MGID - upper word at index 0

	uint64_t			mgid_last[2];				// 128 bit MGID upper range - if 0 then

													// no range

	uint64_t			mgid_mask[2];				// 128 bit MGID mask

													// if 0xffffffffffffffffffffffffffffff

													// then no mask

} VFAppMgid_t;

// Internal Virtual Fabric Applications

typedef struct _VFApp {

	// Service ID list

	uint32_t			sidMapSize;

	cl_qmap_t			sidMap;						// Map of VFAppSid_t

	// Multicast Group list

	uint32_t			mgidMapSize;

	cl_qmap_t			mgidMap;					// Map of VFAppMgid_t

	// aggregate settings from application and included applications

	uint8_t				select_sa;					// boolean select SA - defaults to 0

	uint8_t				select_unmatched_sid;		// boolean select unmatched service id

													// defaults to 0

	uint8_t				select_unmatched_mgid;		// boolean select unmatched MGID

	uint8_t				select_pm;					// boolean select PM - defaults to 0

} VFApp_t;

// Internal rendering of Virtual Fabric Members

typedef struct _VFMem {

	// System Image GUID's

	uint32_t		sysGuidMapSize;					// number of System Image GUID entries

	cl_qmap_t		sysGuidMap;						// binary tree of System Image GUID's

	// Node GUID entries

	uint32_t		nodeGuidMapSize;				// number of Node GUID entries

	cl_qmap_t		nodeGuidMap;					// binary tree of Node GUID's

	// Port GUID entries

	uint32_t        portGuidMapSize;    			// number of Port GUID entries

	cl_qmap_t		portGuidMap;					// binary tree of Port GUID's

	// Node Description entries

	uint32_t        nodeDescMapSize;				// number of Node descriptions

	cl_qmap_t		nodeDescMap;					// binary tree of Node Description pointers

	// aggregate settings from group and included groups

	uint8_t			select_all;						// boolean select all - defaults to 0

	uint8_t			select_self;					// boolean select self - defaults to 0

	uint8_t			select_hfi_direct_connect;		// boolean select all nodes in b2b (hfi direct connect)

	uint8_t			select_swe0;					// boolean select SWE0 - defaults to 0

	uint8_t			select_all_mgmt_allowed; 		// boolean select all mgmt allowed - defaults to 0

	uint8_t			select_all_tfis; 	         	// boolean select all TFIs - defaults to 0

	// aggregate settings from group and included groups

	uint8_t			node_type_fi;					// boolean FI type - defaults to 0

	uint8_t			node_type_sw;					// boolean SW type - defaults to 0

} VFMem_t;

// Internal rendering of Default Groups

typedef struct _VFDg {

	uint8_t				def_mc_create;				// if undefined will default to 1

	uint32_t			def_mc_mlid;				// if undefined will default to 0x0

	uint32_t			def_mc_pkey;			 	// if undefined will default to

													// STL_DEFAULT_APP_PKEY

	uint8_t				def_mc_mtu_int;				// if undefined will default to 0xff

	uint8_t				def_mc_rate_int;			// if undefined will default to 0xff

	uint8_t				def_mc_sl;					// if undefined will default to 0xff

	uint32_t			def_mc_qkey;				// if undefined will default to 0x0

	uint32_t			def_mc_fl;					// if undefined will default to 0x0

	uint32_t			def_mc_tc;					// if undefined will default to 0x0

	uint32_t			mgidMapSize;

	cl_qmap_t			mgidMap;					// Map of VFAppMgid_t

	struct _VFDg		*next_default_group;		// pointer to next group

} VFDg_t;

// Internal rendering of Virtual Fabric configuration - if no Vitual Fabrics

// are configured or all Virtual Fabrics are Disabled, a default single

// Virtual Fabric will be created. Disabled Virtual Fabrics will not show

// up as a defined VirtualFabric within this structure.

typedef struct _VFabric {

	char			name[MAX_VFABRIC_NAME];		    // defaults to "Default"

	uint32_t		index;							// one will be uniquely assigned

	uint32_t		pkey;							// if 0xffffffff use default pkey

	uint32_t		qos_index;

	uint8_t			qos_implicit;

	union {											// Index in old/new vf array

		uint32_t    old_index;                      // if 0xFFFFFFFF (-1) then it is a new VF (added)

		uint32_t    new_index;						// if 0xFFFFFFFF (-1) then it is a deleted VF (removed)

	} reconf_idx;

	uint8_t			standby;

	uint8_t			security;						// defaults to 0 or false

	uint8_t			max_mtu_int;					// if 0xff then unlimited

	uint8_t			max_mtu_specified;

	uint8_t			max_rate_int;					// if 0xff then unlimited

	uint8_t			max_rate_specified;				// set by SM for use in queries

	VFApp_t			apps;							// application SID's and MGID's etc...

	uint32_t		number_of_full_members;

	XMLMember_t		full_member[MAX_VFABRIC_MEMBERS_PER_VF];

	uint32_t		number_of_limited_members;

	XMLMember_t		limited_member[MAX_VFABRIC_MEMBERS_PER_VF];

	uint32_t		number_of_default_groups;		// number of default multicast groups

	VFDg_t			*default_group;					// default group configuration linked list

	uint32_t		consistency_checksum;

	uint32_t		disruptive_checksum;

	uint32_t		overall_checksum;

} VF_t;

// Internal rendering of Composite Virtual Fabric configuration

typedef struct _SMVirtualFabricsInternal {

	uint32_t		number_of_vfs_all;

	uint32_t		number_of_qos_all;

	uint8_t			securityEnabled;				// setup by SM

	uint8_t			qosEnabled;						// setup by SM

	VF_t			v_fabric_all[MAX_ENABLED_VFABRICS];

	QosConfig_t		qos_all[MAX_QOS_GROUPS];

	DGXmlConfig_t	dg_config;

	uint32_t		consistency_checksum;

	uint32_t		disruptive_checksum;

	uint32_t		overall_checksum;

} VirtualFabrics_t;

// SM Dynamic Packet Lifetime configuration

typedef struct _SMDPLXmlConfig {

    uint32_t    dp_lifetime[10];

} SMDPLXmlConfig_t;

// SM Multicast DefaultGroup configuration

typedef struct _SMMcastDefGrp {

	uint32_t		def_mc_create;

	uint32_t		def_mc_mlid;

	char			virtual_fabric[MAX_VFABRIC_NAME];

	uint32_t		def_mc_pkey;

	uint8_t			def_mc_mtu_int;

	uint8_t			def_mc_rate_int;

	uint8_t			def_mc_sl;

	uint32_t		def_mc_qkey;

	uint32_t		def_mc_fl;

	uint32_t		def_mc_tc;

	uint32_t		number_of_mgids;

	XmlAppMgid_t	mgid[MAX_VFABRIC_DG_MGIDS];

	uint32_t		number_of_mgid_ranges;

	XmlAppMgidRng_t	mgid_range[MAX_VFABRIC_DG_MGIDS];  // May implement in future

	uint32_t		number_of_mgid_maskeds;

	XmlAppMgidMsk_t	mgid_masked[MAX_VFABRIC_DG_MGIDS];  // May implement in future

} SMMcastDefGrp_t;

// SM Multicast DefaultGroups

typedef struct _SMMcastDefGrpCfg {

	uint32_t			number_of_groups;

	SMMcastDefGrp_t		group[MAX_DEFAULT_GROUPS];	// list of default groups

} SMMcastDefGrpCfg_t;

// SM configuration for McastGrpMGidLimitMask

typedef struct _mcastGrpMGidLimitMask {

    char    	value[40];

} mcastGrpMGidLimitMask_t;

// SM configuration for McastGrpMGidLimitValue

typedef struct _mcastGrpMGidLimitValue {

    char    	value[40];

} mcastGrpMGidLimitValue_t;

// SM configuration of MLIDShared

typedef struct _SmMcastMlidShared {

	uint32_t					enable;

	mcastGrpMGidLimitMask_t		mcastGrpMGidLimitMaskConvert;

	mcastGrpMGidLimitValue_t	mcastGrpMGidLimitValueConvert;

	uint32_t					mcastGrpMGidLimitMax;

	uint32_t					mcastGrpMGidperPkeyMax;

} SmMcastMlidShared_t;

// SM MLIDShared Instances

typedef struct _SmMcastMlidShare {

	uint32_t					number_of_shared;

	SmMcastMlidShared_t			mcastMlid[MAX_SUPPORTED_MCAST_GRP_CLASSES_XML];

} SmMcastMlidShare_t;

// SM configuration for Multicast configuration

typedef struct _SMMcastConfig {

    uint32_t 	disable_mcast_check;

    uint32_t   	enable_pruning;

    uint32_t   	mcast_mlid_table_cap;

	char		mcroot_select_algorithm[STRING_SIZE];

	char		mcroot_min_cost_improvement[STRING_SIZE];

} SMMcastConfig_t;

// SM configuration for Link Policy

typedef struct _SMPolicyConfig {

	uint8_t	    	enabled;

	uint16_t		policy;

} SMPolicyConfig_t;

typedef struct _SMLinkPolicyXmlConfig {

    uint16_t				link_max_downgrade;

    SMPolicyConfig_t		width_policy;

    SMPolicyConfig_t		speed_policy;

} SMLinkPolicyXmlConfig_t;

typedef struct _SMFlappingXmlConfig{

	uint32_t window_size; //Size in minutes of sliding window over which bounce events are counted

	uint32_t high_thresh; // Threshold of bounce events used to trigger quarantine state for port

	uint32_t low_thresh; // threshold of bounce events to trigger unquarantine or unmonitor of port

} SMFlappingXmlConfig_t;

typedef struct _SMPortQuarantineXmlConfig {

	uint8_t enabled;

	SMFlappingXmlConfig_t flapping;

} SMPortQuarantineXmlConfig_t;

// SM configuration for Preemption

typedef struct _SMPreemptionXmlConfig {

    uint32_t    small_packet;

    uint32_t    large_packet;

    uint32_t    preempt_limit;

} SMPreemptionXmlConfig_t;

// uniform switch congestion control settings

typedef struct _SmSwCongestionXmlConfig {

	uint8_t  victim_marking_enable;

	uint8_t  threshold;

	uint8_t  packet_size;

	uint8_t  cs_threshold;

	uint16_t cs_return_delay;

	uint32_t marking_rate;

} SmSwCongestionXmlConfig_t;

// uniform congestion control settings

typedef struct _SmCaCongestionXmlConfig {

	uint8_t  sl_based;

	uint8_t  increase;

	uint16_t timer;

	uint8_t  threshold;

	uint8_t  min;

	uint16_t  limit;

	uint32_t desired_max_delay;

} SmCaCongestionXmlConfig_t;

// uniform congestion control settings

typedef struct _SmCongestionXmlConfig {

	uint8_t enable;

	uint8_t debug;

	SmSwCongestionXmlConfig_t sw;

	SmCaCongestionXmlConfig_t ca;

} SmCongestionXmlConfig_t;

// Adaptive Routing control settings

typedef struct _SmAdaptiveRoutingXmlConfig {

	uint8_t enable;

	uint8_t debug;

	uint8_t lostRouteOnly;

	uint8_t algorithm;

	uint8_t	arFrequency;

	uint8_t threshold;

} SmAdaptiveRoutingXmlConfig_t;

#define MAX_TIER	10

typedef struct _SmFtreeRouting_t {

	uint8_t 	debug;

	uint8_t 	passthru;

	uint8_t 	converge;

	uint8_t		tierCount;				// height of the fat tree. edges are rank 0.

	uint8_t		fis_on_same_tier;		// indicates that all end nodes are at the bottom of the tree.

	XMLMember_t	coreSwitches;			// device group indicating core switches

	XMLMember_t	routeLast;				// device group indicating HFIs that should be routed last.

} SmFtreeRouting_t;

/*

 * Structure for Device Group Min Hop routing.

 *

 * MAX_DGROUTING_ORDER is arbitrarily capped at 8. This could be higher,

 * but raising it might cause a performance hit.

 */

#define MAX_DGROUTING_ORDER 8

typedef struct _SmDGRouting_t {

	uint8_t 	dgCount;

	XMLMember_t	dg[MAX_DGROUTING_ORDER];

} SmDGRouting_t;

/*

 * Structures for Enhanced Routing Control for Hypercube Routing, per switch.

 */

typedef uint32_t portMap_t;

static __inline__ void portMapSet(portMap_t *portMap, int port)

{

	portMap[port/(sizeof(portMap_t)*8)] |= (1u << port%(sizeof(portMap_t)*8));

}

static __inline__ portMap_t portMapTest(portMap_t *portMap, int port)

{

	return portMap[port/(sizeof(portMap_t)*8)] & (1u << port%(sizeof(portMap_t)*8));

}

typedef struct _SmSPRoutingPort {

	uint8_t			pport;

	uint8_t			vport;

	uint16_t		cost;

} SmSPRoutingPort_t;

typedef struct _SmSPRoutingCtrl {

	struct _SmSPRoutingCtrl	*next;

	XMLMember_t		switches;			// one or more switches

	portMap_t		pportMap[MAX_SWITCH_PORTS/(sizeof(portMap_t)*8) + 1];

	portMap_t		vportMap[MAX_SWITCH_PORTS/(sizeof(portMap_t)*8) + 1];

	SmSPRoutingPort_t *ports;

	uint16_t		portCount;

} SmSPRoutingCtrl_t;

typedef struct _SmHypercubeRouting_t {

	uint8_t				debug;

	XMLMember_t			routeLast;		// device group indicating HFIs that should be routed last.

	SmSPRoutingCtrl_t	*enhancedRoutingCtrl;

} SmHypercubeRouting_t;

#define MAX_TOROIDAL_DIMENSIONS 6

#define MAX_DOR_DIMENSIONS 20

#define DEFAULT_DOR_PORT_PAIR_WARN_THRESHOLD	5

#define DEFAULT_UPDN_MC_SAME_SPANNING_TREE	1

#define DEFAULT_ESCAPE_VLS_IN_USE			1

#define DEFAULT_FAULT_REGIONS_IN_USE		1

typedef enum {

	DOR_MESH,

	DOR_TORUS,

	DOR_PARTIAL_TORUS,

} DorTop_t;

typedef struct _SmPortPair {

	uint8_t				port1;

	uint8_t				port2;

} SmPortPair_t;

typedef struct _SmDimension {

	uint8_t				toroidal;

	uint8_t				length;

	uint8_t				portCount;

	uint8_t				created;