/*

 * Copyright (c) 2005-2009 Voltaire, Inc. All rights reserved.

 * Copyright (c) 2009,2010 HNR Consulting. All rights reserved.

 * Copyright (c) 2010,2011 Mellanox Technologies LTD. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     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.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 *

 */

#if HAVE_CONFIG_H

#  include <config.h>

#endif				/* HAVE_CONFIG_H */

#include <stdio.h>

#include <stdlib.h>

#include <sys/poll.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netdb.h>

#include <regex.h>

#ifdef ENABLE_OSM_CONSOLE_LOOPBACK

#include <arpa/inet.h>

#endif

#include <unistd.h>

#include <errno.h>

#include <ctype.h>

#include <sys/time.h>

#include <opensm/osm_file_ids.h>

#define FILE_ID OSM_FILE_CONSOLE_C

#include <opensm/osm_console.h>

#include <complib/cl_passivelock.h>

#include <opensm/osm_perfmgr.h>

#include <opensm/osm_subnet.h>

extern void osm_update_node_desc(IN osm_opensm_t *osm);

struct command {

	const char *name;

	void (*help_function) (FILE * out, int detail);

	void (*parse_function) (char **p_last, osm_opensm_t * p_osm,

				FILE * out);

};

static struct {

	int on;

	int delay_s;

	time_t previous;

	void (*loop_function) (osm_opensm_t * p_osm, FILE * out);

} loop_command = {

.on = 0, .delay_s = 2, .loop_function = NULL};

static const struct command console_cmds[];

static char *next_token(char **p_last)

{

	return strtok_r(NULL, " \t\n\r", p_last);

}

#ifdef ENABLE_OSM_PERF_MGR

static char *name_token(char **p_last)

{

	return strtok_r(NULL, "\t\n\r", p_last);

}

#endif

static void help_command(FILE * out, int detail)

{

	int i;

	fprintf(out, "Supported commands and syntax:\n");

	fprintf(out, "help [<command>]\n");

	/* skip help command */

	for (i = 1; console_cmds[i].name; i++)

		console_cmds[i].help_function(out, 0);

}

static void help_quit(FILE * out, int detail)

{

	fprintf(out, "quit (not valid in local mode; use ctl-c)\n");

}

static void help_loglevel(FILE * out, int detail)

{

	fprintf(out, "loglevel [<log-level>]\n");

	if (detail) {

		fprintf(out, "   log-level is OR'ed from the following\n");

		fprintf(out, "   OSM_LOG_NONE             0x%02X\n",

			OSM_LOG_NONE);

		fprintf(out, "   OSM_LOG_ERROR            0x%02X\n",

			OSM_LOG_ERROR);

		fprintf(out, "   OSM_LOG_INFO             0x%02X\n",

			OSM_LOG_INFO);

		fprintf(out, "   OSM_LOG_VERBOSE          0x%02X\n",

			OSM_LOG_VERBOSE);

		fprintf(out, "   OSM_LOG_DEBUG            0x%02X\n",

			OSM_LOG_DEBUG);

		fprintf(out, "   OSM_LOG_FUNCS            0x%02X\n",

			OSM_LOG_FUNCS);

		fprintf(out, "   OSM_LOG_FRAMES           0x%02X\n",

			OSM_LOG_FRAMES);

		fprintf(out, "   OSM_LOG_ROUTING          0x%02X\n",

			OSM_LOG_ROUTING);

		fprintf(out, "   OSM_LOG_SYS              0x%02X\n",

			OSM_LOG_SYS);

		fprintf(out, "\n");

		fprintf(out, "   OSM_LOG_DEFAULT_LEVEL    0x%02X\n",

			OSM_LOG_DEFAULT_LEVEL);

	}

}

static void help_permodlog(FILE * out, int detail)

{

	fprintf(out, "permodlog\n");

}

static void help_priority(FILE * out, int detail)

{

	fprintf(out, "priority [<sm-priority>]\n");

}

static void help_resweep(FILE * out, int detail)

{

	fprintf(out, "resweep [heavy|light]\n");

}

static void help_reroute(FILE * out, int detail)

{

	fprintf(out, "reroute\n");

	if (detail) {

		fprintf(out, "reroute the fabric\n");

	}

}

static void help_sweep(FILE * out, int detail)

{

	fprintf(out, "sweep [on|off]\n");

	if (detail) {

		fprintf(out, "enable or disable sweeping\n");

		fprintf(out, "   [on] sweep normally\n");

		fprintf(out, "   [off] inhibit all sweeping\n");

	}

}

static void help_status(FILE * out, int detail)

{

	fprintf(out, "status [loop]\n");

	if (detail) {

		fprintf(out, "   loop -- type \"q<ret>\" to quit\n");

	}

}

static void help_logflush(FILE * out, int detail)

{

	fprintf(out, "logflush [on|off] -- toggle opensm.log file flushing\n");

}

static void help_querylid(FILE * out, int detail)

{

	fprintf(out,

		"querylid lid -- print internal information about the lid specified\n");

}

static void help_portstatus(FILE * out, int detail)

{

	fprintf(out, "portstatus [ca|switch|router]\n");

	if (detail) {

		fprintf(out, "summarize port status\n");

		fprintf(out,

			"   [ca|switch|router] -- limit the results to the node type specified\n");

	}

}

static void help_switchbalance(FILE * out, int detail)

{

	fprintf(out, "switchbalance [verbose] [guid]\n");

	if (detail) {

		fprintf(out, "output switch balancing information\n");

		fprintf(out,

			"  [verbose] -- verbose output\n"

			"  [guid] -- limit results to specified guid\n");

	}

}

static void help_lidbalance(FILE * out, int detail)

{

	fprintf(out, "lidbalance [switchguid]\n");

	if (detail) {

		fprintf(out, "output lid balanced forwarding information\n");

		fprintf(out,

			"  [switchguid] -- limit results to specified switch guid\n");

	}

}

static void help_dump_conf(FILE *out, int detail)

{

	fprintf(out, "dump_conf\n");

	if (detail) {

		fprintf(out, "dump current opensm configuration\n");

	}

}

static void help_update_desc(FILE *out, int detail)

{

	fprintf(out, "update_desc\n");

	if (detail) {

		fprintf(out, "update node description for all nodes\n");

	}

}

#ifdef ENABLE_OSM_PERF_MGR

static void help_perfmgr(FILE * out, int detail)

{

	fprintf(out,

		"perfmgr(pm) [enable|disable\n"

		"             |clear_counters|dump_counters|print_counters(pc)|print_errors(pe)\n"

		"             |set_rm_nodes|clear_rm_nodes|clear_inactive\n"

		"             |set_query_cpi|clear_query_cpi\n"

		"             |dump_redir|clear_redir\n"

		"             |sweep|sweep_time[seconds]]\n");

	if (detail) {

		fprintf(out,

			"perfmgr -- print the performance manager state\n");

		fprintf(out,

			"   [enable|disable] -- change the perfmgr state\n");

		fprintf(out,

			"   [sweep] -- Initiate a sweep of the fabric\n");

		fprintf(out,

			"   [sweep_time] -- change the perfmgr sweep time (requires [seconds] option)\n");

		fprintf(out,

			"   [clear_counters] -- clear the counters stored\n");

		fprintf(out,

			"   [dump_counters [mach]] -- dump the counters (optionally in [mach]ine readable format)\n");

		fprintf(out,

			"   [print_counters [<nodename|nodeguid>][:<port>]] -- print the internal counters\n"

			"                                                      Optionally limit output by name, guid, or port\n");

		fprintf(out,

			"   [pc [<nodename|nodeguid>][:<port>]] -- same as print_counters\n");

		fprintf(out,

			"   [print_errors [<nodename|nodeguid>]] -- print only ports with errors\n"

			"                                           Optionally limit output by name or guid\n");

		fprintf(out,

			"   [pe [<nodename|nodeguid>]] -- same as print_errors\n");

		fprintf(out,

			"   [dump_redir [<nodename|nodeguid>]] -- dump the redirection table\n");

		fprintf(out,

			"   [clear_redir [<nodename|nodeguid>]] -- clear the redirection table\n");

		fprintf(out,

			"   [[set|clear]_rm_nodes] -- enable/disable the removal of \"inactive\" nodes from the DB\n"

			"                             Inactive nodes are those which no longer appear on the fabric\n");

		fprintf(out,

			"   [[set|clear]_query_cpi] -- enable/disable PerfMgrGet(ClassPortInfo)\n"

			"                             ClassPortInfo indicates hardware support for extended attributes such as PortCountersExtended\n");

		fprintf(out,

			"   [clear_inactive] -- Delete inactive nodes from the DB\n");

	}

}

static void help_pm(FILE *out, int detail)

{

	if (detail)

		help_perfmgr(out, detail);

}

#endif				/* ENABLE_OSM_PERF_MGR */

/* more help routines go here */

static void help_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	char *p_cmd;

	int i, found = 0;

	p_cmd = next_token(p_last);

	if (!p_cmd)

		help_command(out, 0);

	else {

		for (i = 1; console_cmds[i].name; i++) {

			if (!strcmp(p_cmd, console_cmds[i].name)) {

				found = 1;

				console_cmds[i].help_function(out, 1);

				break;

			}

		}

		if (!found) {

			fprintf(out, "%s : Command not found\n\n", p_cmd);

			help_command(out, 0);

		}

	}

}

static void loglevel_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	char *p_cmd;

	int level;

	p_cmd = next_token(p_last);

	if (!p_cmd)

		fprintf(out, "Current log level is 0x%x\n",

			osm_log_get_level(&p_osm->log));

	else {

		/* Handle x, 0x, and decimal specification of log level */

		if (!strncmp(p_cmd, "x", 1)) {

			p_cmd++;

			level = strtoul(p_cmd, NULL, 16);

		} else {

			if (!strncmp(p_cmd, "0x", 2)) {

				p_cmd += 2;

				level = strtoul(p_cmd, NULL, 16);

			} else

				level = strtol(p_cmd, NULL, 10);

		}

		if ((level >= 0) && (level < 256)) {

			fprintf(out, "Setting log level to 0x%x\n", level);

			osm_log_set_level(&p_osm->log, level);

		} else

			fprintf(out, "Invalid log level 0x%x\n", level);

	}

}

static void permodlog_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	FILE *fp;

	char buf[1024];

	if (p_osm->subn.opt.per_module_logging_file != NULL) {

		fp = fopen(p_osm->subn.opt.per_module_logging_file, "r");

		if (!fp) {

			if (errno == ENOENT)

				return;

			fprintf(out, "fopen(%s) failed: %s\n",

				p_osm->subn.opt.per_module_logging_file,

				strerror(errno));

			return;

		}

		fprintf(out, "Per module logging file: %s\n",

			p_osm->subn.opt.per_module_logging_file);

		while (fgets(buf, sizeof buf, fp) != NULL)

			fprintf(out, "%s", buf);

		fclose(fp);

		fprintf(out, "\n");

	}

}

static void priority_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	char *p_cmd;

	int priority;

	p_cmd = next_token(p_last);

	if (!p_cmd)

		fprintf(out, "Current sm-priority is %d\n",

			p_osm->subn.opt.sm_priority);

	else {

		priority = strtol(p_cmd, NULL, 0);

		if (0 > priority || 15 < priority)

			fprintf(out,

				"Invalid sm-priority %d; must be between 0 and 15\n",

				priority);

		else {

			fprintf(out, "Setting sm-priority to %d\n", priority);

			osm_set_sm_priority(&p_osm->sm, (uint8_t)priority);

		}

	}

}

static const char *sm_state_str(int state)

{

	switch (state) {

	case IB_SMINFO_STATE_DISCOVERING:

		return "Discovering";

	case IB_SMINFO_STATE_STANDBY:

		return "Standby    ";

	case IB_SMINFO_STATE_NOTACTIVE:

		return "Not Active ";

	case IB_SMINFO_STATE_MASTER:

		return "Master     ";

	}

	return "UNKNOWN    ";

}

static const char *sa_state_str(osm_sa_state_t state)

{

	switch (state) {

	case OSM_SA_STATE_INIT:

		return "Init";

	case OSM_SA_STATE_READY:

		return "Ready";

	}

	return "UNKNOWN";

}

static void dump_sms(osm_opensm_t * p_osm, FILE * out)

{

	osm_subn_t *p_subn = &p_osm->subn;

	osm_remote_sm_t *p_rsm;

	fprintf(out, "\n   Known SMs\n"

		     "   ---------\n");

	fprintf(out, "   Port GUID       SM State    Priority\n");

	fprintf(out, "   ---------       --------    --------\n");

	fprintf(out, "   0x%" PRIx64 " %s %d        SELF\n",

		cl_ntoh64(p_subn->sm_port_guid),

		sm_state_str(p_subn->sm_state),

		p_subn->opt.sm_priority);

	CL_PLOCK_ACQUIRE(p_osm->sm.p_lock);

	p_rsm = (osm_remote_sm_t *) cl_qmap_head(&p_subn->sm_guid_tbl);

	while (p_rsm != (osm_remote_sm_t *) cl_qmap_end(&p_subn->sm_guid_tbl)) {

		fprintf(out, "   0x%" PRIx64 " %s %d\n",

			cl_ntoh64(p_rsm->smi.guid),

			sm_state_str(ib_sminfo_get_state(&p_rsm->smi)),

			ib_sminfo_get_priority(&p_rsm->smi));

		p_rsm = (osm_remote_sm_t *) cl_qmap_next(&p_rsm->map_item);

	}

	CL_PLOCK_RELEASE(p_osm->sm.p_lock);

}

static void print_status(osm_opensm_t * p_osm, FILE * out)

{

	cl_list_item_t *item;

	if (out) {

		const char *re_str;

		cl_plock_acquire(&p_osm->lock);

		fprintf(out, "   OpenSM Version       : %s\n", p_osm->osm_version);

		fprintf(out, "   SM State             : %s\n",

			sm_state_str(p_osm->subn.sm_state));

		fprintf(out, "   SM Priority          : %d\n",

			p_osm->subn.opt.sm_priority);

		fprintf(out, "   SA State             : %s\n",

			sa_state_str(p_osm->sa.state));

		re_str = p_osm->routing_engine_used ?

			osm_routing_engine_type_str(p_osm->routing_engine_used->type) :

			osm_routing_engine_type_str(OSM_ROUTING_ENGINE_TYPE_NONE);

		fprintf(out, "   Routing Engine       : %s\n", re_str);

		fprintf(out, "   Loaded event plugins :");

		if (cl_qlist_head(&p_osm->plugin_list) ==

			cl_qlist_end(&p_osm->plugin_list)) {

			fprintf(out, " <none>");

		}

		for (item = cl_qlist_head(&p_osm->plugin_list);

		     item != cl_qlist_end(&p_osm->plugin_list);

		     item = cl_qlist_next(item))

			fprintf(out, " %s",

				((osm_epi_plugin_t *)item)->plugin_name);

		fprintf(out, "\n");

#ifdef ENABLE_OSM_PERF_MGR

		fprintf(out, "\n   PerfMgr state/sweep state : %s/%s\n",

			osm_perfmgr_get_state_str(&p_osm->perfmgr),

			osm_perfmgr_get_sweep_state_str(&p_osm->perfmgr));

#endif

		fprintf(out, "\n   MAD stats\n"

			"   ---------\n"

			"   QP0 MADs outstanding           : %u\n"

			"   QP0 MADs outstanding (on wire) : %u\n"

			"   QP0 MADs rcvd                  : %u\n"

			"   QP0 MADs sent                  : %u\n"

			"   QP0 unicasts sent              : %u\n"

			"   QP0 unknown MADs rcvd          : %u\n"

			"   SA MADs outstanding            : %u\n"

			"   SA MADs rcvd                   : %u\n"

			"   SA MADs sent                   : %u\n"

			"   SA unknown MADs rcvd           : %u\n"

			"   SA MADs ignored                : %u\n",

			(uint32_t)p_osm->stats.qp0_mads_outstanding,

			(uint32_t)p_osm->stats.qp0_mads_outstanding_on_wire,

			(uint32_t)p_osm->stats.qp0_mads_rcvd,

			(uint32_t)p_osm->stats.qp0_mads_sent,

			(uint32_t)p_osm->stats.qp0_unicasts_sent,

			(uint32_t)p_osm->stats.qp0_mads_rcvd_unknown,

			(uint32_t)p_osm->stats.sa_mads_outstanding,

			(uint32_t)p_osm->stats.sa_mads_rcvd,

			(uint32_t)p_osm->stats.sa_mads_sent,

			(uint32_t)p_osm->stats.sa_mads_rcvd_unknown,

			(uint32_t)p_osm->stats.sa_mads_ignored);

		fprintf(out, "\n   Subnet flags\n"

			"   ------------\n"

			"   Sweeping enabled               : %d\n"

			"   Sweep interval (seconds)       : %u\n"

			"   Ignore existing lfts           : %d\n"

			"   Subnet Init errors             : %d\n"

			"   In sweep hop 0                 : %d\n"

			"   First time master sweep        : %d\n"

			"   Coming out of standby          : %d\n",

			p_osm->subn.sweeping_enabled,

			p_osm->subn.opt.sweep_interval,

			p_osm->subn.ignore_existing_lfts,

			p_osm->subn.subnet_initialization_error,

			p_osm->subn.in_sweep_hop_0,

			p_osm->subn.first_time_master_sweep,

			p_osm->subn.coming_out_of_standby);

		dump_sms(p_osm, out);

		fprintf(out, "\n");

		cl_plock_release(&p_osm->lock);

	}

}

static int loop_command_check_time(void)

{

	time_t cur = time(NULL);

	if ((loop_command.previous + loop_command.delay_s) < cur) {

		loop_command.previous = cur;

		return 1;

	}

	return 0;

}

static void status_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	char *p_cmd;

	p_cmd = next_token(p_last);

	if (p_cmd) {

		if (strcmp(p_cmd, "loop") == 0) {

			fprintf(out, "Looping on status command...\n");

			fflush(out);

			loop_command.on = 1;

			loop_command.previous = time(NULL);

			loop_command.loop_function = print_status;

		} else {

			help_status(out, 1);

			return;

		}

	}

	print_status(p_osm, out);

}

static void resweep_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	char *p_cmd;

	p_cmd = next_token(p_last);

	if (!p_cmd ||

	    (strcmp(p_cmd, "heavy") != 0 && strcmp(p_cmd, "light") != 0)) {

		fprintf(out, "Invalid resweep command\n");

		help_resweep(out, 1);

	} else {

		if (strcmp(p_cmd, "heavy") == 0)

			p_osm->subn.force_heavy_sweep = TRUE;

		osm_opensm_sweep(p_osm);

	}

}

static void reroute_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	p_osm->subn.force_reroute = TRUE;

	osm_opensm_sweep(p_osm);

}

static void sweep_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	char *p_cmd;

	p_cmd = next_token(p_last);

	if (!p_cmd ||

	    (strcmp(p_cmd, "on") != 0 && strcmp(p_cmd, "off") != 0)) {

		fprintf(out, "Invalid sweep command\n");

		help_sweep(out, 1);

	} else {

		if (strcmp(p_cmd, "on") == 0)

			p_osm->subn.sweeping_enabled = TRUE;

		else

			p_osm->subn.sweeping_enabled = FALSE;

	}

}

static void logflush_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	char *p_cmd;

	p_cmd = next_token(p_last);

	if (!p_cmd ||

	    (strcmp(p_cmd, "on") != 0 && strcmp(p_cmd, "off") != 0)) {

		fprintf(out, "Invalid logflush command\n");

		help_sweep(out, 1);

	} else {

		if (strcmp(p_cmd, "on") == 0) {

			p_osm->log.flush = TRUE;

	                fflush(p_osm->log.out_port);

		} else

			p_osm->log.flush = FALSE;

	}

}

static void querylid_parse(char **p_last, osm_opensm_t * p_osm, FILE * out)

{

	unsigned int p = 0;

	uint16_t lid = 0;

	osm_port_t *p_port = NULL;

	char *p_cmd = next_token(p_last);

	if (!p_cmd) {

		fprintf(out, "no LID specified\n");

		help_querylid(out, 1);

		return;

	}

	lid = (uint16_t) strtoul(p_cmd, NULL, 0);

	cl_plock_acquire(&p_osm->lock);

	p_port = osm_get_port_by_lid_ho(&p_osm->subn, lid);

	if (!p_port)

		goto invalid_lid;

	fprintf(out, "Query results for LID %u\n", lid);

	fprintf(out,

		"   GUID                : 0x%016" PRIx64 "\n"

		"   Node Desc           : %s\n"

		"   Node Type           : %s\n"

		"   Num Ports           : %d\n",

		cl_ntoh64(p_port->guid),

		p_port->p_node->print_desc,

		ib_get_node_type_str(osm_node_get_type(p_port->p_node)),

		p_port->p_node->node_info.num_ports);

	if (p_port->p_node->sw)

		p = 0;

	else

		p = 1;

	for ( /* see above */ ; p < p_port->p_node->physp_tbl_size; p++) {

		fprintf(out,

			"   Port %u health       : %s\n",

			p,

			p_port->p_node->physp_table[p].

			healthy ? "OK" : "ERROR");

	}

	cl_plock_release(&p_osm->lock);

	return;

invalid_lid:

	cl_plock_release(&p_osm->lock);

	fprintf(out, "Invalid lid %d\n", lid);

	return;

}

/**

 * Data structures for the portstatus command

 */

typedef struct _port_report {

	struct _port_report *next;

	uint64_t node_guid;

	uint8_t port_num;

	char print_desc[IB_NODE_DESCRIPTION_SIZE + 1];

} port_report_t;

static void

__tag_port_report(port_report_t ** head, uint64_t node_guid,

		  uint8_t port_num, char *print_desc)

{

	port_report_t *rep = malloc(sizeof(*rep));

	if (!rep)

		return;

	rep->node_guid = node_guid;

	rep->port_num = port_num;

	memcpy(rep->print_desc, print_desc, IB_NODE_DESCRIPTION_SIZE + 1);

	rep->next = NULL;

	if (*head) {

		rep->next = *head;

		*head = rep;

	} else

		*head = rep;

}

static void __print_port_report(FILE * out, port_report_t * head)

{

	port_report_t *item = head;

	while (item != NULL) {

		fprintf(out, "      0x%016" PRIx64 " %d (%s)\n",

			item->node_guid, item->port_num, item->print_desc);

		port_report_t *next = item->next;

		free(item);

		item = next;

	}

}

typedef struct {

	uint8_t node_type_lim;	/* limit the results; 0 == ALL */

	uint64_t total_nodes;

	uint64_t total_ports;

	uint64_t ports_down;

	uint64_t ports_active;

	uint64_t ports_disabled;

	port_report_t *disabled_ports;

	uint64_t ports_1X;

	uint64_t ports_4X;

	uint64_t ports_8X;

	uint64_t ports_12X;

	uint64_t ports_2X;

	uint64_t ports_unknown_width;

	port_report_t *unknown_width_ports;

	uint64_t ports_unenabled_width;

	port_report_t *unenabled_width_ports;

	uint64_t ports_reduced_width;

	port_report_t *reduced_width_ports;

	uint64_t ports_sdr;

	uint64_t ports_ddr;

	uint64_t ports_qdr;

	uint64_t ports_fdr10;

	uint64_t ports_fdr;

	uint64_t ports_edr;

	uint64_t ports_hdr;

	uint64_t ports_unknown_speed;

	port_report_t *unknown_speed_ports;

	uint64_t ports_unenabled_speed;

	port_report_t *unenabled_speed_ports;

	uint64_t ports_reduced_speed;

	port_report_t *reduced_speed_ports;

} fabric_stats_t;

/**

 * iterator function to get portstatus on each node

 */

static void __get_stats(cl_map_item_t * const p_map_item, void *context)

{

	fabric_stats_t *fs = (fabric_stats_t *) context;

	osm_node_t *node = (osm_node_t *) p_map_item;

	osm_physp_t *physp0;

	ib_port_info_t *pi0;

	uint8_t num_ports = osm_node_get_num_physp(node);

	uint8_t port = 0;

	/* Skip nodes we are not interested in */

	if (fs->node_type_lim != 0

	    && fs->node_type_lim != node->node_info.node_type)

		return;

	fs->total_nodes++;

	if (osm_node_get_type(node) == IB_NODE_TYPE_SWITCH) {

		physp0 = osm_node_get_physp_ptr(node, 0);

		pi0 = &physp0->port_info;

	} else

		pi0 = NULL;

	for (port = 1; port < num_ports; port++) {

		osm_physp_t *phys = osm_node_get_physp_ptr(node, port);

		ib_port_info_t *pi = NULL;

		ib_mlnx_ext_port_info_t *epi = NULL;

		uint8_t active_speed = 0;

		uint8_t enabled_speed = 0;

		uint8_t active_width = 0;

		uint8_t enabled_width = 0;

		uint8_t port_state = 0;

		uint8_t port_phys_state = 0;

		if (!phys)

			continue;

		pi = &phys->port_info;

		epi = &phys->ext_port_info;

		if (!pi0)

			pi0 = pi;

		active_speed = ib_port_info_get_link_speed_active(pi);

		enabled_speed = ib_port_info_get_link_speed_enabled(pi);

		active_width = pi->link_width_active;

		enabled_width = pi->link_width_enabled;

		port_state = ib_port_info_get_port_state(pi);

		port_phys_state = ib_port_info_get_port_phys_state(pi);

		if (port_state == IB_LINK_DOWN)

			fs->ports_down++;

		else if (port_state == IB_LINK_ACTIVE)

			fs->ports_active++;

		if (port_phys_state == IB_PORT_PHYS_STATE_DISABLED) {

			__tag_port_report(&(fs->disabled_ports),

					  cl_ntoh64(node->node_info.node_guid),

					  port, node->print_desc);

			fs->ports_disabled++;

		}

		fs->total_ports++;

		if (port_state == IB_LINK_DOWN)

			continue;

		if (!(active_width & enabled_width)) {

			__tag_port_report(&(fs->unenabled_width_ports),

					  cl_ntoh64(node->node_info.node_guid),

					  port, node->print_desc);

			fs->ports_unenabled_width++;

		}

		else if ((enabled_width ^ active_width) > active_width) {

			__tag_port_report(&(fs->reduced_width_ports),

					  cl_ntoh64(node->node_info.node_guid),

					  port, node->print_desc);

			fs->ports_reduced_width++;

		}

		/* unenabled speed usually due to problems with force_link_speed */

		if (!(active_speed & enabled_speed)) {

			__tag_port_report(&(fs->unenabled_speed_ports),

					  cl_ntoh64(node->node_info.node_guid),

					  port, node->print_desc);

			fs->ports_unenabled_speed++;

		}

		else if ((enabled_speed ^ active_speed) > active_speed) {

			__tag_port_report(&(fs->reduced_speed_ports),

					  cl_ntoh64(node->node_info.node_guid),

					  port, node->print_desc);

			fs->ports_reduced_speed++;

		}

		switch (active_speed) {

		case IB_LINK_SPEED_ACTIVE_2_5:

			fs->ports_sdr++;

			break;

		case IB_LINK_SPEED_ACTIVE_5:

			fs->ports_ddr++;

			break;

		case IB_LINK_SPEED_ACTIVE_10:

			if (!(pi0->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS) ||

			    !ib_port_info_get_link_speed_ext_active(pi)) {

				if (epi->link_speed_active & FDR10)

					fs->ports_fdr10++;

				else {

					fs->ports_qdr++;

					/* check for speed reduced from FDR10 */

					if (epi->link_speed_enabled & FDR10) {

						__tag_port_report(&(fs->reduced_speed_ports),

								  cl_ntoh64(node->node_info.node_guid),

								  port, node->print_desc);

						fs->ports_reduced_speed++;

					}

				}

			}

			break;

		case IB_LINK_SPEED_ACTIVE_EXTENDED:

			break;

		default:

			__tag_port_report(&(fs->unknown_speed_ports),

					  cl_ntoh64(node->node_info.node_guid),

					  port, node->print_desc);

			fs->ports_unknown_speed++;

			break;

		}

		if (pi0->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS &&

		    ib_port_info_get_link_speed_ext_sup(pi) &&

		    (enabled_speed = ib_port_info_get_link_speed_ext_enabled(pi)) != IB_LINK_SPEED_EXT_DISABLE &&

		    active_speed == IB_LINK_SPEED_ACTIVE_10) {

			active_speed = ib_port_info_get_link_speed_ext_active(pi);

			if (!(active_speed & enabled_speed)) {

				__tag_port_report(&(fs->unenabled_speed_ports),

						  cl_ntoh64(node->node_info.node_guid),

						  port, node->print_desc);

				fs->ports_unenabled_speed++;

			}

			else if ((enabled_speed ^ active_speed) > active_speed) {

				__tag_port_report(&(fs->reduced_speed_ports),

						  cl_ntoh64(node->node_info.node_guid),