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

Copyright (c) 2015-2017, Intel Corporation

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

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

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

      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

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

      documentation and/or other materials provided with the distribution.

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

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

      without specific prior written permission.

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

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

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

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

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

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

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

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

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

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

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

/* [ICS VERSION STRING: unknown] */

#include <iba/ibt.h>

#include <iba/ipublic.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <unistd.h>

#include <ctype.h>

#define _GNU_SOURCE

#include <ixml_ib.h>

#include <topology.h>

#include <getopt.h>

#include <limits.h>

#include <math.h>

#include <arpa/inet.h>

#include <stl_helper.h>

#include <time.h>

#include <string.h>

#define MYTAG MAKE_MEM_TAG('o','2', 'r', 'm')

#define DBGPRINT(format, args...) \

	do { if (g_verbose) { fflush(stdout); fprintf(stderr, format, ##args); } } while (0)

#define PROGRESS_PRINT(newline, format, args...) \

	do { if (! g_quiet) { ProgressPrint(newline, format, ##args); }  } while (0)

#define PROGRESS_FREQ 1000

#define MIN_LIST_ITEMS 10	// for neighbor sw and fi DLISTs

// macro to always return a valid pointer for use in %s formats

#define OPTIONAL_STR(s) (s?s:"")

#define RANGE_IN_MIDDLE 0	// should ranges in middle of name be permitted

uint8			g_verbose		= 0;

uint8			g_quiet			= 0;	// omit progress output

#define MAX_FOCUS	10

char			*g_focus_arg[MAX_FOCUS];

Point			g_focus[MAX_FOCUS];

int				g_num_focus = 0;

char*			g_prefix = NULL;	// prefix for all FIs

char*			g_suffix = NULL;	// suffix for all FIs

// All the information about the fabric

FabricData_t	g_Fabric;

// In order to allow removal of spaces, sorting and compacting

// names into ranges (eg. compute[1-10]) we keep a NameData per

// name we want to show.  The NameData includes the reformated full name

// and the parsed elements of body, numeric range and end

typedef struct NameData_s {

	cl_map_item_t	NameListEntry;	// nameList, key is name

	char		name[NODE_DESCRIPTION_ARRAY_SIZE];	// full name

	// a name is broken into four parts, body is alphanumeric

	// start,end is a numeric part at the end of the body

	// prefix is a prefix we will add afterwards such as opa- for IPoIB on OPA

	// suffix is a suffix we will add afterwards such as -opa for IPoIB on OPA

	const char	*prefix;

	char		body[NODE_DESCRIPTION_ARRAY_SIZE];

	uint32		start, end;	// numeric range

	boolean		leadzero;	// did original name have leading zeros for number

	int8		numlen;		// number of characters in number in original name

	const char	*suffix;

} NameData_t;

// This will be attached to each switch node via ExpectedNode.context 

typedef struct SwitchLists_s {

	cl_qmap_t	fiNeighborNames;// filtered list of neighbor FIs NameData_t

	cl_qmap_t	swNeighborNames;// filtered list of neighbor SWs NameData_t

	uint8		tier;			// tier in tree of given switch

								// (distance from FIs)

	DLIST		swNeighbors;	// list of all neighbor SWs ExpectedNode*

} SwitchLists_t;

boolean CompareExpectedNodeFocus(ExpectedNode *enodep);

boolean CompareExpectedLinkFocus(ExpectedLink *elinkp);

// -------------- output of Expected* functions --------------------

// these next few functions are for error output and debug

// They allow dumping of the input topology file which was parsed

// output goes to stderr

// show 1 port selector in link data in brief form

void ShowExpectedLinkPortSelBriefSummary(ExpectedLink *elinkp, PortSelector *portselp,

			 uint8 side, int indent, int detail)

{

	DEBUG_ASSERT(side == 1 || side == 2);

	fprintf(stderr, "%*s%4s ", indent, "",

			(side == 1)?

				elinkp->expected_rate?

					StlStaticRateToText(elinkp->expected_rate)

					:""

			: "<-> ");

	if (side == 1 && elinkp->expected_mtu)

		fprintf(stderr, "%5s ", IbMTUToText(elinkp->expected_mtu));

	else

		fprintf(stderr, "     ");

	if (portselp) {

		if (portselp->NodeGUID)

			fprintf(stderr, "0x%016"PRIx64, portselp->NodeGUID);

		else

			fprintf(stderr, "                  ");

		if (portselp->gotPortNum)

			fprintf(stderr, " %3u               ",portselp->PortNum);

		else if (portselp->PortGUID)

			fprintf(stderr, " 0x%016"PRIx64, portselp->PortGUID);

		else

			fprintf(stderr, "                   ");

		if (portselp->NodeType)

			fprintf(stderr, " %s",

				StlNodeTypeToText(portselp->NodeType));

		else

			fprintf(stderr, "   ");

		if (portselp->NodeDesc)

			fprintf(stderr, " %.*s\n",

				NODE_DESCRIPTION_ARRAY_SIZE, portselp->NodeDesc);

		else

			fprintf(stderr, "\n");

		if (detail) {

			if (portselp->details) {

				fprintf(stderr, "%*sPortDetails: %s\n", indent+4, "", portselp->details);

			}

		}

	} else {

		fprintf(stderr, "unspecified\n");

	}

}

// show cable information for a link in multi-line format with field headings

void ShowExpectedLinkSummary(ExpectedLink *elinkp,

			int indent, int detail)

{

	// From Side (Port 1)

	ShowExpectedLinkPortSelBriefSummary(elinkp, elinkp->portselp1,

										1, indent, detail);

	// To Side (Port 2)

	ShowExpectedLinkPortSelBriefSummary(elinkp, elinkp->portselp2,

										2, indent, detail);

	if (elinkp->details) {

		fprintf(stderr, "%*sLinkDetails: %s\n", indent, "", elinkp->details);

	}

	if (elinkp->CableData.length || elinkp->CableData.label

		|| elinkp->CableData.details) {

		fprintf(stderr, "%*sCableLabel: %-*s  CableLen: %-*s\n",

			indent, "",

			CABLE_LABEL_STRLEN, OPTIONAL_STR(elinkp->CableData.label),

			CABLE_LENGTH_STRLEN, OPTIONAL_STR(elinkp->CableData.length));

		fprintf(stderr, "%*sCableDetails: %s\n",

			indent, "",

			OPTIONAL_STR(elinkp->CableData.details));

	}

}

// Verify links in fabric against specified topology

void ShowExpectedLinksReport(/*Point *focus,*/ int indent, int detail)

{

	LIST_ITEM *p;

	uint32 input_checked = 0;

	fprintf(stderr, "%*sLinks Topology Expected\n", indent, "");

	fprintf(stderr, "%*sRate MTU  NodeGUID          Port or PortGUID    Type Name\n", indent, "");

	if (detail && (g_Fabric.flags & FF_CABLEDATA)) {

		//fprintf(stderr, "%*sPortDetails\n", indent+4, "");

		//fprintf(stderr, "%*sLinkDetails\n", indent+4, "");

		fprintf(stderr, "%*sCable: %-*s %-*s\n", indent+4, "",

						CABLE_LABEL_STRLEN, "CableLabel",

						CABLE_LENGTH_STRLEN, "CableLen");

		fprintf(stderr, "%*s%s\n", indent+4, "", "CableDetails");

	}

	for (p=QListHead(&g_Fabric.ExpectedLinks); p != NULL; p = QListNext(&g_Fabric.ExpectedLinks, p)) {

		ExpectedLink *elinkp = (ExpectedLink *)QListObj(p);

		if (! elinkp)

			continue;

		if (! CompareExpectedLinkFocus(elinkp))

				continue;

		input_checked++;

		ShowExpectedLinkSummary(elinkp, indent, detail);

	}

	if (detail && input_checked)

		fprintf(stderr, "\n");	// blank line between links

	fprintf(stderr, "%*s%u of %u Input Links Shown\n", indent, "",

				input_checked, QListCount(&g_Fabric.ExpectedLinks));

	return;

}

// output brief summary of an expected IB Node

void ShowExpectedNodeBriefSummary(ExpectedNode *enodep, int indent, int detail)

{

	fprintf(stderr, "%*s", indent, "");

	if (enodep->NodeGUID)

		fprintf(stderr, "0x%016"PRIx64, enodep->NodeGUID);

	else

		fprintf(stderr, "                  ");

	if (enodep->NodeType)

		fprintf(stderr, " %s", StlNodeTypeToText(enodep->NodeType));

	else

		fprintf(stderr, "   ");

	if (enodep->NodeDesc)

		fprintf(stderr, " %s\n", enodep->NodeDesc);

	else

		fprintf(stderr, "\n");

	if (enodep->details)

		fprintf(stderr, "%*sNodeDetails: %s\n", indent+4, "", enodep->details);

}

// Verify nodes in fabric against specified topology

void ShowExpectedNodesReport(/*Point *focus,*/ uint8 NodeType, int indent, int detail)

{

	LIST_ITEM *p;

	uint32 input_checked = 0;

	const char *NodeTypeText = StlNodeTypeToText(NodeType);

	QUICK_LIST *input_listp;

	switch (NodeType) {

	case STL_NODE_FI:

			input_listp = &g_Fabric.ExpectedFIs;

			break;

	case STL_NODE_SW:

			input_listp = &g_Fabric.ExpectedSWs;

			break;

	default:

			ASSERT(0);

			break;

	}

	// intro for report

	fprintf(stderr, "%*s%ss Topology Expected\n", indent, "", NodeTypeText);

	for (p=QListHead(input_listp); p != NULL; p = QListNext(input_listp, p)) {

		ExpectedNode *enodep = (ExpectedNode *)QListObj(p);

		if (! enodep)

			continue;

		input_checked++;

		ShowExpectedNodeBriefSummary(enodep, indent, detail);

	}

	if (detail && input_checked)

		fprintf(stderr, "\n");	// blank line between links

	fprintf(stderr, "%*s%u of %u Input %ss Shown\n", indent, "",

					input_checked, QListCount(input_listp), NodeTypeText);

	return;

}

// --------------------- NameData functions ----------------------------

// when using GUIDs as name, put whole value in body

void SetNameToGuid(NameData_t *namep, EUI64 guid)

{

	sprintf(namep->name, "0x%016"PRIx64, guid);

	namep->prefix = NULL;

	StringCopy(namep->body, namep->name, NODE_DESCRIPTION_ARRAY_SIZE);

	namep->start = 0;

	namep->end = 0;

	namep->leadzero = FALSE;

	namep->numlen = 0;

	namep->suffix = NULL;

}

// Name processing copy Modes:

// underscore - simple conversion of space to underscore

// trunc - take all chars after 1st space and remove

//				host405 hfi1_0 -> host405

//				can be useful for single and multi-rail hosts

//				can also be useful to produce a more concise slurm file

//				by treating large switches as a single black box entity

// flip - take all chars after 1st space and put at start of name

//				any additional spaces converted to underscore

//				opacore7 Leaf101 -> Leaf101_opacore7

//				can be useful so can sort and combine to get ranges

//				such as Leaf101_opacore[1-7]

// guid - use text representation of hex GUID

// TBD - future - could add multi-rail suffix addition or replace modes

//		- algortihmic suffix (hf1_0 -> -opa1, hfi1_1 -> -opa2)

typedef enum {

	NAME_MODE_UNDERSCORE = 1,

	NAME_MODE_FLIP = 2,

	NAME_MODE_TRUNC = 3,

	NAME_MODE_GUID = 4

} name_mode_t;

// translate and copy name into a NameData, separating out body and number

// and adding prefix and suffix

void CopyName(NameData_t *namep, const char *name, EUI64 guid, name_mode_t mode,

				const char *prefix, const char *suffix)

{

	int len = 0;

	int i;

	if (! name || mode == NAME_MODE_GUID) {

		DEBUG_ASSERT(guid);

		SetNameToGuid(namep, guid);

		return;

	}

	if (mode == NAME_MODE_UNDERSCORE) {

		// change spaces to underscore

		int l;

		char *d;

		StringCopy(namep->name, name, sizeof(namep->name));

		len = strnlen(namep->name, sizeof(namep->name));

		for (l=len, d=namep->name; l; d++, l--)

			if (isspace(*d))

				*d = '_';

	} else if (mode == NAME_MODE_TRUNC) {

		// truncate at 1st space

		int l;

		char *d;

		StringCopy(namep->name, name, sizeof(namep->name));

		len = strnlen(namep->name, sizeof(namep->name));

		for (l=len, d=namep->name; l; d++, l--) {

			if (isspace(*d)) {

				*d = '\0';

				break;

			}

		}

		len = (d - namep->name);

	} else if (mode == NAME_MODE_FLIP) {

		// put content after 1st space at start of string,

		// replacing space w/underscore

		int l;

		const char *s;

		char *d = namep->name;

		for (l=sizeof(namep->name), s=name; l && *s && ! isspace(*s); s++, l--)

			;

		if (l && *s) {

			// we found a space

			DEBUG_ASSERT(isspace(*s));

			s++; l--;

			// copy remaining characters to start of string

			for (; l && *s; s++, l--)

				if(!isspace(*s))

					*d++ = *s;

			*d++ = '_';

		}

		// now copy up to the 1st space into the remainder

		for (l=sizeof(namep->name) - (d-namep->name), s=name; l && *s && ! isspace(*s); s++, d++, l--)

			*d = *s;

		if (l)

			*d='\0';

		len = (d - namep->name);

	}

	namep->prefix = prefix;

	StringCopy(namep->body, namep->name, sizeof(namep->body));

	// assume no number

	namep->numlen = 0;

	namep->start = 0;

	namep->end = 0;

	if (len) {

		for (i=len; i> 0 && isdigit(namep->body[i-1]); i--)

			;

		if (i != len) {

			// we have a number, starting at body[i]

			if (FSUCCESS == StringToUint32(&namep->start, &namep->body[i], NULL, 10, FALSE)) {

				namep->numlen = len - i;

				namep->end = namep->start;

				namep->leadzero = (namep->numlen > 1 && namep->body[i] == '0');

				namep->body[i] = '\0';

			}

		}

	}

	namep->suffix = suffix;

	DBGPRINT("name=%s, prefix=%s body=%s, suffix=%s\n", namep->name,

			namep->prefix?namep->prefix:"", namep->body,

			namep->suffix?namep->suffix:"");

	DBGPRINT("numlen=%u, leadzero=%d, start=%u end=%u\n", namep->numlen,

			namep->leadzero, namep->start, namep->end);

}

void PrintName(const NameData_t *namep)

{

	if (namep->prefix)

		printf("%s", namep->prefix);

	printf("%.*s", NODE_DESCRIPTION_ARRAY_SIZE, namep->body);

	if (namep->numlen) {

		if (namep->leadzero)

			if (namep->start != namep->end)

				printf("[%0*u-%0*u]", namep->numlen, namep->start, namep->numlen, namep->end);

			else

				printf("%0*u", namep->numlen, namep->start);

		else

			if (namep->start != namep->end)

				printf("[%u-%u]", namep->start, namep->end);

			else

				printf("%u", namep->start);

	}

	if (namep->suffix)

		printf("%s", namep->suffix);

}

// is name2 numerically sequential and after name1

// if so we can consider combining them

boolean SequentialNames(const NameData_t *name1p, const NameData_t *name2p)

{

	// to optimize speed of compare, we do the faster checks 1st

	if (! name1p->numlen || ! name2p->numlen)

		return FALSE;	// only sequential if have numbers

	if (name1p->end+1 != name2p->start)

		return FALSE;	// not in sequence

	if (name1p->leadzero && name1p->numlen == name2p->numlen) {

		// ok, leading zeros in the lower numbered namep and constant length

	} else if (!name2p->leadzero && ! name2p->leadzero) {

		// ok, no leading zeros, all good

	} else {

		return FALSE;   // number representation inconsistent

	}

#if ! RANGE_IN_MIDDLE

	if (name1p->suffix || name2p->suffix)

		return FALSE;	// can't have range in middle of a name

#endif

	if (name1p->prefix) {

		if (!name2p->prefix || 0 != strncmp(name1p->prefix, name2p->prefix, NODE_DESCRIPTION_ARRAY_SIZE))

			return FALSE;	// different prefix

	} else if (name2p->prefix) {

		return FALSE;	// different prefix

	}

	if (0 != strncmp(name1p->body, name2p->body, NODE_DESCRIPTION_ARRAY_SIZE))

		return FALSE;   // different body

	if (name1p->suffix) {

		if (!name2p->suffix || 0 != strncmp(name1p->suffix, name2p->suffix, NODE_DESCRIPTION_ARRAY_SIZE))

			return FALSE;	// different suffix

	} else if (name2p->suffix) {

		return FALSE;	// different suffix

	}

	return TRUE;

}

// compare two names and return:

// -1 - name1 < name2

// 0 - name1 == name2

// 1 - name1 > name2

int CompareNameData(IN const uint64 name1, IN  const uint64 name2)

{

	const NameData_t *name1p = (const NameData_t*)name1;

	const NameData_t *name2p = (const NameData_t*)name2;

	int ret;

	DBGPRINT("CompareNameData: %s, %s\n", name1p->name, name2p->name);

	if (name1p->prefix) {

		if (!name2p->prefix) {

			return 1;

		} else {

			ret = strncmp(name1p->prefix, name2p->prefix, NODE_DESCRIPTION_ARRAY_SIZE);

			if (ret)

				return ret;

		}

	} else if (name2p->prefix) {

		return -1;

	}

	ret = strncmp(name1p->body, name2p->body, NODE_DESCRIPTION_ARRAY_SIZE);

	if (ret)

		return ret;

	if (! name1p->numlen || ! name2p->numlen) {

		// if only 1 has a number, put one without a number 1st

		if (name1p->numlen)

			return 1;

		else if (name2p->numlen)

			return -1;

	}

	// for RANGE_IN_MIDDLE we want items with same suffix together so we can

	// find best opportunities to combine, so sort by suffix prior to sorting

	// by numeric field

	// for ! RANGE_IN_MIDDLE, we want to sort by suffix after sort by numeric

	if (name1p->suffix) {

		if (!name2p->suffix) {

			ret = 1;

		} else {

			ret = strncmp(name1p->suffix, name2p->suffix, NODE_DESCRIPTION_ARRAY_SIZE);

			if (ret)

				return ret;

		}

	} else if (name2p->suffix) {

		ret = -1;

	}

#if RANGE_IN_MIDDLE

	if (ret)

		return ret;

#endif

	if (! name1p->numlen && ! name2p->numlen)

		return ret;

	// if we see two styles of format, we want to sort those with shorter

	// numeric fields first.  c0, c1, c000, c001 so we can find best

	// opportunities to combine sequential ranges

	if (name1p->leadzero || name2p->leadzero) {

		if (name1p->numlen < name2p->numlen)

			return -1;

		else if (name1p->numlen > name2p->numlen)

			return -1;

	}

	if (name1p->start < name2p->start)

		return -1;

	else if (name1p->start > name2p->start)

		return 1;

	else

		return ret;

}

// updates name1p to include name2p

// only valid if name1p and name2p are sequential

// before or after this update, name2p should be remove from list

void CombineNames(NameData_t *name1p, const NameData_t *name2p)

{

	DEBUG_ASSERT(SequentialNames(name1p, name2p));

	DBGPRINT("Combining: %s, %s\n", name1p->name, name2p->name);

	name1p->end = name2p->end;

}

// --------------------- NameData list functions ----------------------------

void InitNameList(cl_qmap_t *listp)

{

	cl_qmap_init(listp, CompareNameData);

}

// add name to list if not already on list

// the algorithm assumes duplicates are relatively infrequent so its simpler

// to just build the final NameData for comparison and throw it away on a

// duplicate. Alternatives would be more complex and have an extra copy

// of the name string for each non-dup

// rationale:

//	- hosts on a switch will have no dups

//	- ISLs will have dups limited to trunk size of link (1-4 typical)

FSTATUS AddNameList(cl_qmap_t *listp, const char* name, EUI64 guid, name_mode_t mode,

				const char *prefix, const char *suffix)

{

	NameData_t *namep;

	if (name)

		DBGPRINT("AddNameList: %s 0x%016"PRIx64"\n", name, guid);

	else

		DBGPRINT("AddNameList: NULL 0x%016"PRIx64"\n", guid);

	namep = (NameData_t *)MemoryAllocate2AndClear(sizeof(NameData_t), IBA_MEM_FLAG_PREMPTABLE, MYTAG);

	if (! namep) {

		fprintf(stderr, "Out of memory\n");

		return FINSUFFICIENT_MEMORY;

	}

	CopyName(namep, name, guid, mode, prefix, suffix);

	if (cl_qmap_insert(listp, (uint64)(uintn)namep, &namep->NameListEntry) != &namep->NameListEntry) {

		// name already on list

		MemoryDeallocate(namep);

		return FSUCCESS;

	}

	DBGPRINT("AddNameList: created new entry\n");

	return FSUCCESS;

}

// take the sorted list and convert sequential names to a numeric range

// two styles of numeric ranges: name[0-10] and name[00-10] indicate if

// leading zeros were present in the original names

void CompactNameList(cl_qmap_t *listp)

{

	cl_map_item_t *p;

	DBGPRINT("compacting name list\n");

	for (p=cl_qmap_head(listp); p != cl_qmap_end(listp);) {

		NameData_t *name1p = PARENT_STRUCT(p, NameData_t, NameListEntry);

		NameData_t *name2p;

		cl_map_item_t *next= cl_qmap_next(p);

		if (next == cl_qmap_end(listp))

			break;

		DBGPRINT("compacting name list: p: %p, next: %p\n", p, next);

		name2p = PARENT_STRUCT(next, NameData_t, NameListEntry);

		if (SequentialNames(name1p, name2p)) {

			cl_qmap_remove_item(listp, next);

			CombineNames(name1p, name2p);

			MemoryDeallocate(name2p);

		} else {

			p = cl_qmap_next(p);

		}

	}

}

void FreeNameList(cl_qmap_t *listp)

{

	cl_map_item_t *p;

	for (p=cl_qmap_head(listp); p != cl_qmap_end(listp); p = cl_qmap_head(listp)) {

		NameData_t *namep = PARENT_STRUCT(p, NameData_t, NameListEntry);

		cl_qmap_remove_item(listp, p);

		MemoryDeallocate(namep);

	}

}

// --------------------- SwitchLists functions ----------------------------

static __inline cl_qmap_t *GetSwitchFiNeighNameList(ExpectedNode *enodep)

{

	return &((SwitchLists_t*)enodep->context)->fiNeighborNames;

}

static __inline cl_qmap_t *GetSwitchSwNeighNameList(ExpectedNode *enodep)

{

	return &((SwitchLists_t*)enodep->context)->swNeighborNames;

}

static __inline uint8 GetSwitchTier(ExpectedNode *enodep)

{

	return ((SwitchLists_t*)enodep->context)->tier;

}

static __inline DLIST *GetSwitchSwNeighList(ExpectedNode *enodep)

{

	return &((SwitchLists_t*)enodep->context)->swNeighbors;

}

FSTATUS AllocSwitchLists(ExpectedNode *enodep)

{

	enodep->context = MemoryAllocate2AndClear(sizeof(SwitchLists_t), IBA_MEM_FLAG_PREMPTABLE, MYTAG);

	if (! enodep->context)

		return FINSUFFICIENT_MEMORY;

	InitNameList(GetSwitchFiNeighNameList(enodep));

	InitNameList(GetSwitchSwNeighNameList(enodep));

	ListInitState(&((SwitchLists_t*)enodep->context)->swNeighbors);

	if (! ListInit(&((SwitchLists_t*)enodep->context)->swNeighbors, MIN_LIST_ITEMS))

		goto fail;

	return FSUCCESS;

fail:

	MemoryDeallocate(enodep->context);

	return FINSUFFICIENT_MEMORY;

}

void FreeSwitchLists(ExpectedNode *enodep)

{

	if (enodep->context) {

		FreeNameList(GetSwitchFiNeighNameList(enodep));

		FreeNameList(GetSwitchSwNeighNameList(enodep));

		ListDestroy(&((SwitchLists_t*)enodep->context)->swNeighbors);

		MemoryDeallocate(enodep->context);

		enodep->context = NULL;

	}

}

FSTATUS AddSwitchFiNameList(ExpectedNode *enodep, const char* name, EUI64 guid, name_mode_t mode,

				const char *prefix, const char *suffix)

{

	if (! enodep->context) {

		FSTATUS status = AllocSwitchLists(enodep);

		if (FSUCCESS != status)

			return status;

	}

	return AddNameList(GetSwitchFiNeighNameList(enodep), name, guid, mode,

				prefix, suffix);

}

FSTATUS AddSwitchSwNameList(ExpectedNode *enodep, const char* name, EUI64 guid, name_mode_t mode,

				const char *prefix, const char *suffix)

{

	if (! enodep->context) {

		FSTATUS status = AllocSwitchLists(enodep);

		if (FSUCCESS != status)

			return status;

	}

	return AddNameList(GetSwitchSwNeighNameList(enodep), name, guid, mode,

				prefix, suffix);

}

FSTATUS SetSwitchTier(ExpectedNode *enodep, uint8 tier)

{

	if (! enodep->context) {

		FSTATUS status = AllocSwitchLists(enodep);

		if (FSUCCESS != status)

			return status;

	}

	((SwitchLists_t*)enodep->context)->tier = tier;

	return FSUCCESS;

}

FSTATUS AddSwitchSwNeighbor(ExpectedNode *enodep, ExpectedNode *swnodep)

{

	if (! enodep->context) {

		FSTATUS status = AllocSwitchLists(enodep);

		if (FSUCCESS != status)

			return status;

	}

	if (! ListInsertTail(&((SwitchLists_t*)enodep->context)->swNeighbors, swnodep))

		return FINSUFFICIENT_MEMORY;

	return FSUCCESS;

}

// analyze the expected links to determine the swNeighbors for each switch.

// TBD - Future - would be nice to be able to filter out selected hosts such as

// service nodes connected to core, but would need to figure out how to

// filter out edge switches left with no hosts so they aren't mistaken for

// core switches.  For now, SLURM uses with impure trees or other topologies

// should use the -o slurm option which will provide a brief report which does

// not list all the ISLs

void BuildSwitchNeighList(boolean get_isls)

{

	LIST_ITEM *q;

	LIST_ITEM *p;

	uint8 tier = 0;

	boolean found;

	if (! get_isls)

		return;

	// now populate swNeighbors for each switch and identify tier 1 switches

	for (q=QListHead(&g_Fabric.ExpectedLinks); q != NULL; q = QListNext(&g_Fabric.ExpectedLinks, q)) {

		ExpectedLink *elinkp = (ExpectedLink *)QListObj(q);

		if (! elinkp->portselp1 || ! elinkp->portselp1->enodep

			|| ! elinkp->portselp2 || ! elinkp->portselp2->enodep) {

			// Skipping Link, unresolved

			continue;

		}

		// figure out the types on both ends

		switch (elinkp->portselp1->enodep->NodeType) {

		case STL_NODE_FI:

			switch (elinkp->portselp2->enodep->NodeType) {

			case STL_NODE_FI: // FI<->FI

				// Skipping Link, unexpected FI<->FI link

				break;

			case STL_NODE_SW: // FI<->SW

				(void)SetSwitchTier(elinkp->portselp2->enodep, 1);

				break;

			default:	// should not happen, enodep should always have type

				// Skipping Link, unspecified NodeType

				break;

			}

			break;

		case STL_NODE_SW:

			switch (elinkp->portselp2->NodeType) {

			case STL_NODE_FI: // SW<->FI

				(void)SetSwitchTier(elinkp->portselp1->enodep, 1);

				break;

			case STL_NODE_SW: // SW<->SW

				(void)AddSwitchSwNeighbor(elinkp->portselp1->enodep, elinkp->portselp2->enodep);

				(void)AddSwitchSwNeighbor(elinkp->portselp2->enodep, elinkp->portselp1->enodep);

				break;

			default:	// should not happen, enodep should always have type

				// Skipping Link, unspecified NodeType

				break;

			}

			break;

		default:	// should not happen, enodep should always have type

			// Skipping Link, unspecified NodeType

			continue;

		}

	}

	// now we have tier 1 switches identified, need to walk up the tree to

	// identify higher tier switches (higher is closer to core and further from

	// FIs)

	// This algorithm is based on Topology/route.c:DetermineSwitchTiers except

	// this works with ExpectedNode while route.c works with NodeData

	//

	// switches connected to tier 1 switches are tier 2, etc

	// This algorithm works fine for pure trees, however for impure trees

	// it can yield unexpected results, for example a core switch with an HFI

	// will be considered a tier 1 switch.

	tier=2;

	do {

		found = FALSE;

		for (p=QListHead(&g_Fabric.ExpectedSWs); p != NULL; p = QListNext(&g_Fabric.ExpectedSWs, p)) {

			ExpectedNode *enodep = (ExpectedNode *)QListObj(p);

			LIST_ITERATOR i;

			if (GetSwitchTier(enodep) != tier-1)

				continue;

			for (i=ListHead(GetSwitchSwNeighList(enodep)); i != NULL;

						i = ListNext(GetSwitchSwNeighList(enodep),i)) {

				ExpectedNode* nswnodep = (ExpectedNode*)ListObj(i);

				if (! GetSwitchTier(nswnodep)) {

					SetSwitchTier(nswnodep, tier);

					found = TRUE;

				}

			}

		}

		tier++;

	} while (found);

	return;

}

// Analyze ExpectedLinks and build lists of neighbors in ExpectedSW's context

// pointer in preparation for output generation

// The algorithm here assumes:

//	- ExpectedSWs and ExpectedLinks are both supplied and consistent

//	- NodeDesc and/or NodeGUID is listed for each entry

//	- All entries in both have NodeType

// The above will all be true if the topology.xml was autogenerated by

// opaxlattopologory or opareport -o topology

void BuildAllSwitchLists(name_mode_t switch_name_mode, name_mode_t node_name_mode, boolean get_isls, boolean get_hfis)

{

	LIST_ITEM *q;

	uint32 input_checked = 0;

	uint32 bad_input = 0;

	uint32 fi_links = 0;

	uint32 isl_links = 0;

	uint32 bad_isl_links = 0;

	uint32 ix = 0;

	BuildSwitchNeighList(get_isls);

	PROGRESS_PRINT(TRUE, "Processing Links...");

	for (q=QListHead(&g_Fabric.ExpectedLinks); q != NULL; q = QListNext(&g_Fabric.ExpectedLinks, q)) {

		ExpectedLink *elinkp = (ExpectedLink *)QListObj(q);

		ExpectedNode *swenodep = NULL;

		ExpectedNode *nswenodep = NULL;

		ExpectedNode *fienodep = NULL;

		if ((ix++ % PROGRESS_FREQ) == 0) {

			PROGRESS_PRINT(FALSE, "Processed %6d of %6d Links...",

				ix, QListCount(&g_Fabric.ExpectedLinks));

		}

		if (! elinkp->portselp1 || ! elinkp->portselp1->enodep

			|| ! elinkp->portselp2 || ! elinkp->portselp2->enodep) {

			fprintf(stderr, "Skipping Link (topology file line %"PRIu64"), unresolved:\n", elinkp->lineno);

			ShowExpectedLinkSummary(elinkp, 4, 0);

			bad_input++;

			continue;

		}

		// figure out the types on both ends, want FI-SW and SW-SW links

		switch (elinkp->portselp1->enodep->NodeType) {

		case STL_NODE_FI:

			switch (elinkp->portselp2->enodep->NodeType) {

			case STL_NODE_FI:

				fprintf(stderr, "Skipping Link (topology file line %"PRIu64"), unexpected FI<->FI link:\n", elinkp->lineno);

				ShowExpectedLinkSummary(elinkp, 4, 0);

				bad_input++;

				continue;

			case STL_NODE_SW:

				fienodep = elinkp->portselp1->enodep;

				swenodep = elinkp->portselp2->enodep;

				break;

			default:

				fprintf(stderr, "Skipping Link (topology file line %"PRIu64"), unspecified NodeType:\n", elinkp->lineno);

				ShowExpectedLinkSummary(elinkp, 4, 0);

				bad_input++;

				continue;

			}

			break;

		case STL_NODE_SW:

			switch (elinkp->portselp2->enodep->NodeType) {

			case STL_NODE_FI:

				swenodep = elinkp->portselp1->enodep;

				fienodep = elinkp->portselp2->enodep;

				break;

			case STL_NODE_SW:

				swenodep = elinkp->portselp1->enodep;