static void nd_rcv_process_nd(IN osm_sm_t * sm, IN osm_node_t * p_node,
IN const ib_node_desc_t * p_nd)
{
char *tmp_desc;
char print_desc[IB_NODE_DESCRIPTION_SIZE + 1];
OSM_LOG_ENTER(sm->p_log);
memcpy(&p_node->node_desc.description, p_nd, sizeof(*p_nd));
/* also set up a printable version */
memcpy(print_desc, p_nd, sizeof(*p_nd));
print_desc[IB_NODE_DESCRIPTION_SIZE] = '\0';
tmp_desc = remap_node_name(sm->p_subn->p_osm->node_name_map,
cl_ntoh64(osm_node_get_node_guid(p_node)),
print_desc);
/* make a copy for this node to "own" */
if (p_node->print_desc)
free(p_node->print_desc);
p_node->print_desc = tmp_desc;
#ifdef ENABLE_OSM_PERF_MGR
/* update the perfmgr entry if available */
osm_perfmgr_update_nodename(&sm->p_subn->p_osm->perfmgr,
cl_ntoh64(osm_node_get_node_guid(p_node)),
p_node->print_desc);
#endif /* ENABLE_OSM_PERF_MGR */
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Node 0x%" PRIx64 ", Description = %s\n",
cl_ntoh64(osm_node_get_node_guid(p_node)), p_node->print_desc);
OSM_LOG_EXIT(sm->p_log);
}
static char *node_desc(ib_portid_t * dest, char **argv, int argc)
{
int node_type, l;
uint64_t node_guid;
char nd[IB_SMP_DATA_SIZE] = { 0 };
uint8_t data[IB_SMP_DATA_SIZE] = { 0 };
char dots[128];
char *nodename = NULL;
if (!smp_query_via(data, dest, IB_ATTR_NODE_INFO, 0, 0, srcport))
return "node info query failed";
mad_decode_field(data, IB_NODE_TYPE_F, &node_type);
mad_decode_field(data, IB_NODE_GUID_F, &node_guid);
if (!smp_query_via(nd, dest, IB_ATTR_NODE_DESC, 0, 0, srcport))
return "node desc query failed";
nodename = remap_node_name(node_name_map, node_guid, nd);
l = strlen(nodename);
if (l < 32) {
memset(dots, '.', 32 - l);
dots[32 - l] = '\0';
} else {
dots[0] = '.';
dots[1] = '\0';
}
printf("Node Description:%s%s\n", dots, nodename);
free(nodename);
return 0;
}
static void dump_endnode(int dump, char *prompt, Node * node, Port * port)
{
char *nodename = NULL;
if (!dump)
return;
if (dump == 1) {
fprintf(f, "%s {0x%016" PRIx64 "}[%d]\n",
prompt, node->nodeguid,
node->type == IB_NODE_SWITCH ? 0 : port->portnum);
return;
}
nodename =
remap_node_name(node_name_map, node->nodeguid, node->nodedesc);
fprintf(f, "%s %s {0x%016" PRIx64 "} portnum %d lid %u-%u \"%s\"\n",
prompt,
(node->type <= IB_NODE_MAX ? node_type_str[node->type] : "???"),
node->nodeguid,
node->type == IB_NODE_SWITCH ? 0 : port->portnum, port->lid,
port->lid + (1 << port->lmc) - 1, nodename);
free(nodename);
}
static void nd_rcv_process_nd(IN osm_sm_t * sm, IN osm_node_t * p_node,
IN const ib_node_desc_t * p_nd)
{
char *tmp_desc;
char print_desc[IB_NODE_DESCRIPTION_SIZE + 1];
OSM_LOG_ENTER(sm->p_log);
memcpy(&p_node->node_desc.description, p_nd, sizeof(*p_nd));
/* also set up a printable version */
memcpy(print_desc, p_nd, sizeof(*p_nd));
print_desc[IB_NODE_DESCRIPTION_SIZE] = '\0';
tmp_desc = remap_node_name(sm->p_subn->p_osm->node_name_map,
cl_ntoh64(osm_node_get_node_guid(p_node)),
print_desc);
/* make a copy for this node to "own" */
if (p_node->print_desc)
free(p_node->print_desc);
p_node->print_desc = tmp_desc;
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Node 0x%" PRIx64 "\n\t\t\t\tDescription = %s\n",
cl_ntoh64(osm_node_get_node_guid(p_node)), p_node->print_desc);
OSM_LOG_EXIT(sm->p_log);
}
void list_node(ibnd_node_t * node, void *user_data)
{
char *node_type;
char *nodename = remap_node_name(node_name_map, node->guid,
node->nodedesc);
switch (node->type) {
case IB_NODE_SWITCH:
node_type = "Switch";
break;
case IB_NODE_CA:
node_type = "Ca";
break;
case IB_NODE_ROUTER:
node_type = "Router";
break;
default:
node_type = "???";
break;
}
fprintf(f,
"%s\t : 0x%016" PRIx64
" ports %d devid 0x%x vendid 0x%x \"%s\"\n", node_type,
node->guid, node->numports, mad_get_field(node->info, 0,
IB_NODE_DEVID_F),
mad_get_field(node->info, 0, IB_NODE_VENDORID_F), nodename);
free(nodename);
}
void out_switch_detail(ibnd_node_t * node, char *sw_prefix)
{
char *nodename = NULL;
nodename = remap_node_name(node_name_map, node->guid, node->nodedesc);
fprintf(f, "%sSwitch\t%d %s\t\t# \"%s\" %s port 0 lid %d lmc %d",
sw_prefix ? sw_prefix : "", node->numports, node_name(node),
nodename, node->smaenhsp0 ? "enhanced" : "base",
node->smalid, node->smalmc);
free(nodename);
}
void out_ca_port(ibnd_port_t * port, int group, char *out_prefix)
{
char *str = NULL;
char *rem_nodename = NULL;
uint32_t iwidth = mad_get_field(port->info, 0,
IB_PORT_LINK_WIDTH_ACTIVE_F);
uint32_t ispeed = mad_get_field(port->info, 0,
IB_PORT_LINK_SPEED_ACTIVE_F);
uint32_t fdr10 = mad_get_field(port->ext_info, 0,
IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F);
uint32_t cap_mask, espeed;
fprintf(f, "%s[%d]", out_prefix ? out_prefix : "", port->portnum);
if (port->node->type != IB_NODE_SWITCH)
fprintf(f, "(%" PRIx64 ") ", port->guid);
fprintf(f, "\t%s[%d]",
node_name(port->remoteport->node), port->remoteport->portnum);
str = out_ext_port(port->remoteport, group);
if (str)
fprintf(f, "%s", str);
if (port->remoteport->node->type != IB_NODE_SWITCH)
fprintf(f, " (%" PRIx64 ") ", port->remoteport->guid);
rem_nodename = remap_node_name(node_name_map,
port->remoteport->node->guid,
port->remoteport->node->nodedesc);
cap_mask = mad_get_field(port->info, 0, IB_PORT_CAPMASK_F);
if (cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_EXT_SPEEDS))
espeed = mad_get_field(port->info, 0,
IB_PORT_LINK_SPEED_EXT_ACTIVE_F);
else
espeed = 0;
fprintf(f, "\t\t# lid %d lmc %d \"%s\" lid %d %s%s",
port->base_lid, port->lmc, rem_nodename,
port->remoteport->node->type == IB_NODE_SWITCH ?
port->remoteport->node->smalid :
port->remoteport->base_lid,
dump_linkwidth_compat(iwidth),
(ispeed != 4 && !espeed) ?
dump_linkspeed_compat(ispeed) :
dump_linkspeedext_compat(espeed, ispeed, fdr10));
if (full_info)
fprintf(f, " s=%d w=%d", ispeed, iwidth);
fprintf(f, "\n");
free(rem_nodename);
}
static void dump_route(int dump, Node * node, int outport, Port * port)
{
char *nodename = NULL;
if (!dump && !ibverbose)
return;
nodename =
remap_node_name(node_name_map, node->nodeguid, node->nodedesc);
if (dump == 1)
fprintf(f, "[%d] -> {0x%016" PRIx64 "}[%d]\n",
outport, port->portguid, port->portnum);
else
fprintf(f, "[%d] -> %s port {0x%016" PRIx64
"}[%d] lid %u-%u \"%s\"\n", outport,
(node->type <=
IB_NODE_MAX ? node_type_str[node->type] : "???"),
port->portguid, port->portnum, port->lid,
port->lid + (1 << port->lmc) - 1, nodename);
free(nodename);
}
void dump_ports_report(ibnd_node_t * node, void *user_data)
{
int p = 0;
ibnd_port_t *port = NULL;
char *nodename = NULL;
char *rem_nodename = NULL;
/* for each port */
for (p = node->numports, port = node->ports[p]; p > 0;
port = node->ports[--p]) {
uint32_t iwidth, ispeed, fdr10, espeed, cap_mask;
uint8_t *info = NULL;
if (port == NULL)
continue;
iwidth =
mad_get_field(port->info, 0, IB_PORT_LINK_WIDTH_ACTIVE_F);
ispeed =
mad_get_field(port->info, 0, IB_PORT_LINK_SPEED_ACTIVE_F);
if (port->node->type == IB_NODE_SWITCH) {
if (port->node->ports[0])
info = (uint8_t *)&port->node->ports[0]->info;
}
else
info = (uint8_t *)&port->info;
if (info) {
cap_mask = mad_get_field(info, 0, IB_PORT_CAPMASK_F);
if (cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_EXT_SPEEDS))
espeed = mad_get_field(port->info, 0,
IB_PORT_LINK_SPEED_EXT_ACTIVE_F);
else
espeed = 0;
} else {
ispeed = 0;
iwidth = 0;
espeed = 0;
}
fdr10 = mad_get_field(port->ext_info, 0,
IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F);
nodename = remap_node_name(node_name_map,
port->node->guid,
port->node->nodedesc);
fprintf(stdout, "%2s %5d %2d 0x%016" PRIx64 " %s %s",
ports_nt_str_compat(node),
node->type ==
IB_NODE_SWITCH ? node->smalid : port->base_lid,
port->portnum, port->guid,
dump_linkwidth_compat(iwidth),
(ispeed != 4 && !espeed) ?
dump_linkspeed_compat(ispeed) :
dump_linkspeedext_compat(espeed, ispeed, fdr10));
if (port->remoteport) {
rem_nodename = remap_node_name(node_name_map,
port->remoteport->node->guid,
port->remoteport->node->nodedesc);
fprintf(stdout,
" - %2s %5d %2d 0x%016" PRIx64
" ( '%s' - '%s' )\n",
ports_nt_str_compat(port->remoteport->node),
port->remoteport->node->type == IB_NODE_SWITCH ?
port->remoteport->node->smalid :
port->remoteport->base_lid,
port->remoteport->portnum,
port->remoteport->guid, nodename, rem_nodename);
free(rem_nodename);
} else
fprintf(stdout, "%36s'%s'\n", "", nodename);
free(nodename);
}
}
void out_switch_port(ibnd_port_t * port, int group, char *out_prefix)
{
char *ext_port_str = NULL;
char *rem_nodename = NULL;
uint32_t iwidth = mad_get_field(port->info, 0,
IB_PORT_LINK_WIDTH_ACTIVE_F);
uint32_t ispeed = mad_get_field(port->info, 0,
IB_PORT_LINK_SPEED_ACTIVE_F);
uint32_t fdr10 = mad_get_field(port->ext_info, 0,
IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F);
uint32_t cap_mask, espeed;
DEBUG("port %p:%d remoteport %p\n", port, port->portnum,
port->remoteport);
fprintf(f, "%s[%d]", out_prefix ? out_prefix : "", port->portnum);
ext_port_str = out_ext_port(port, group);
if (ext_port_str)
fprintf(f, "%s", ext_port_str);
rem_nodename = remap_node_name(node_name_map,
port->remoteport->node->guid,
port->remoteport->node->nodedesc);
ext_port_str = out_ext_port(port->remoteport, group);
if (!port->node->ports[0]) {
cap_mask = 0;
ispeed = 0;
espeed = 0;
} else {
cap_mask = mad_get_field(port->node->ports[0]->info, 0,
IB_PORT_CAPMASK_F);
if (cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_EXT_SPEEDS))
espeed = mad_get_field(port->info, 0,
IB_PORT_LINK_SPEED_EXT_ACTIVE_F);
else
espeed = 0;
}
fprintf(f, "\t%s[%d]%s",
node_name(port->remoteport->node), port->remoteport->portnum,
ext_port_str ? ext_port_str : "");
if (port->remoteport->node->type != IB_NODE_SWITCH)
fprintf(f, "(%" PRIx64 ") ", port->remoteport->guid);
fprintf(f, "\t\t# \"%s\" lid %d %s%s",
rem_nodename,
port->remoteport->node->type == IB_NODE_SWITCH ?
port->remoteport->node->smalid :
port->remoteport->base_lid,
dump_linkwidth_compat(iwidth),
(ispeed != 4 && !espeed) ?
dump_linkspeed_compat(ispeed) :
dump_linkspeedext_compat(espeed, ispeed, fdr10));
if (full_info)
fprintf(f, " s=%d w=%d", ispeed, iwidth);
if (ibnd_is_xsigo_tca(port->remoteport->guid))
fprintf(f, " slot %d", port->portnum);
else if (ibnd_is_xsigo_hca(port->remoteport->guid))
fprintf(f, " (scp)");
fprintf(f, "\n");
free(rem_nodename);
}
void print_node(ibnd_node_t * node, void *user_data)
{
int header_printed = 0;
int p = 0;
int startport = 1;
int type = 0;
int all_port_sup = 0;
ib_portid_t portid = { 0 };
uint16_t cap_mask = 0;
char *node_name = NULL;
switch (node->type) {
case IB_NODE_SWITCH:
type = PRINT_SWITCH;
break;
case IB_NODE_CA:
type = PRINT_CA;
break;
case IB_NODE_ROUTER:
type = PRINT_ROUTER;
break;
}
if ((type & node_type_to_print) == 0)
return;
if (node->type == IB_NODE_SWITCH && node->smaenhsp0)
startport = 0;
node_name = remap_node_name(node_name_map, node->guid, node->nodedesc);
if (node->type == IB_NODE_SWITCH) {
ib_portid_set(&portid, node->smalid, 0, 0);
p = 0;
} else {
for (p = 1; p <= node->numports; p++) {
if (node->ports[p]) {
ib_portid_set(&portid,
node->ports[p]->base_lid,
0, 0);
break;
}
}
}
if ((query_cap_mask(&portid, node_name, p, &cap_mask) == 0) &&
(cap_mask & IB_PM_ALL_PORT_SELECT))
all_port_sup = 1;
if (data_counters_only) {
for (p = startport; p <= node->numports; p++) {
if (node->ports[p]) {
if (node->type == IB_NODE_SWITCH)
ib_portid_set(&portid, node->smalid, 0, 0);
else
ib_portid_set(&portid, node->ports[p]->base_lid,
0, 0);
print_data_cnts(&portid, cap_mask, node_name, node, p,
&header_printed);
summary.ports_checked++;
if (!all_port_sup)
clear_port(&portid, cap_mask, node_name, p);
}
}
} else {
if (all_port_sup)
if (!print_errors(&portid, cap_mask, node_name, node,
0xFF, &header_printed)) {
summary.ports_checked += node->numports;
goto clear;
}
for (p = startport; p <= node->numports; p++) {
if (node->ports[p]) {
if (node->type == IB_NODE_SWITCH)
ib_portid_set(&portid, node->smalid, 0, 0);
else
ib_portid_set(&portid, node->ports[p]->base_lid,
0, 0);
print_errors(&portid, cap_mask, node_name, node, p,
&header_printed);
summary.ports_checked++;
if (!all_port_sup)
clear_port(&portid, cap_mask, node_name, p);
}
}
}
clear:
summary.nodes_checked++;
if (all_port_sup)
clear_port(&portid, cap_mask, node_name, 0xFF);
free(node_name);
}
static void print_port_config(char *node_name, ibnd_node_t * node, int portnum)
{
char width[64], speed[64], state[64], physstate[64];
char remote_str[256];
char link_str[256];
char width_msg[256];
char speed_msg[256];
char ext_port_str[256];
int iwidth, ispeed, fdr10, espeed, istate, iphystate, cap_mask;
uint8_t *info;
ibnd_port_t *port = node->ports[portnum];
if (!port)
return;
iwidth = mad_get_field(port->info, 0, IB_PORT_LINK_WIDTH_ACTIVE_F);
ispeed = mad_get_field(port->info, 0, IB_PORT_LINK_SPEED_ACTIVE_F);
fdr10 = mad_get_field(port->ext_info, 0,
IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F) & FDR10;
if (port->node->type == IB_NODE_SWITCH)
info = (uint8_t *)&port->node->ports[0]->info;
else
info = (uint8_t *)&port->info;
cap_mask = mad_get_field(info, 0, IB_PORT_CAPMASK_F);
if (cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_EXT_SPEEDS))
espeed = mad_get_field(port->info, 0,
IB_PORT_LINK_SPEED_EXT_ACTIVE_F);
else
espeed = 0;
istate = mad_get_field(port->info, 0, IB_PORT_STATE_F);
iphystate = mad_get_field(port->info, 0, IB_PORT_PHYS_STATE_F);
remote_str[0] = '\0';
link_str[0] = '\0';
width_msg[0] = '\0';
speed_msg[0] = '\0';
/* C14-24.2.1 states that a down port allows for invalid data to be
* returned for all PortInfo components except PortState and
* PortPhysicalState */
if (istate != IB_LINK_DOWN) {
if (!espeed) {
if (fdr10)
sprintf(speed, "10.0 Gbps (FDR10)");
else
mad_dump_val(IB_PORT_LINK_SPEED_ACTIVE_F, speed,
64, &ispeed);
} else
mad_dump_val(IB_PORT_LINK_SPEED_EXT_ACTIVE_F, speed,
64, &espeed);
snprintf(link_str, 256, "(%3s %18s %6s/%8s)",
mad_dump_val(IB_PORT_LINK_WIDTH_ACTIVE_F, width, 64, &iwidth),
speed,
mad_dump_val(IB_PORT_STATE_F, state, 64, &istate),
mad_dump_val(IB_PORT_PHYS_STATE_F, physstate, 64, &iphystate));
} else {
snprintf(link_str, 256, "( %6s/%8s)",
mad_dump_val(IB_PORT_STATE_F, state, 64, &istate),
mad_dump_val(IB_PORT_PHYS_STATE_F, physstate, 64, &iphystate));
}
if (port->remoteport) {
char *rem_node_name = NULL;
if (port->remoteport->ext_portnum)
snprintf(ext_port_str, 256, "%d",
port->remoteport->ext_portnum);
else
ext_port_str[0] = '\0';
get_max_msg(width_msg, speed_msg, 256, port);
rem_node_name = remap_node_name(node_name_map,
port->remoteport->node->guid,
port->remoteport->node->
nodedesc);
snprintf(remote_str, 256,
"0x%016" PRIx64 " %6d %4d[%2s] \"%s\" (%s %s)\n",
port->remoteport->guid,
port->remoteport->base_lid ? port->remoteport->
base_lid : port->remoteport->node->smalid,
port->remoteport->portnum, ext_port_str, rem_node_name,
width_msg, speed_msg);
free(rem_node_name);
} else
snprintf(remote_str, 256, " [ ] \"\" ( )\n");
if (port->ext_portnum)
snprintf(ext_port_str, 256, "%d", port->ext_portnum);
else
ext_port_str[0] = '\0';
if (node->type == IB_NODE_SWITCH)
printf(" Link info: %6d", node->smalid);
else
printf(" Link info: %6d", port->base_lid);
printf("%4d[%2s] ==%s==> %s",
port->portnum, ext_port_str, link_str, remote_str);
}
/** =========================================================================
*/
static int
report_error(mysql_connection_t *conn, char *mask_str)
{
int rc = 0;
unsigned int num_fields;
unsigned int num_rows, i;
MYSQL_RES *res;
MYSQL_ROW row;
mask_val_t *mask_vals = parse_mask(mask_str);
if (QUERY(conn,
"select pe.SymbolErrors, pe.LinkRecovers,"
" pe.LinkDowned, pe.RcvErrors, pe.RcvRemotePhysErrors,"
" pe.RcvSwitchRelayErrors, pe.XmtDiscards,"
" pe.XmtConstraintErrors, pe.RcvConstraintErrors,"
" pe.LinkIntegrityErrors, pe.ExcBufOverrunErrors,"
" pe.VL15Dropped, n.name, pe.port, n.guid,"
" pd.xmit_data, pd.rcv_data, pd.xmit_pkts, pd.rcv_pkts,"
" pd.unicast_xmit_pkts, pd.unicast_rcv_pkts,"
" pd.multicast_xmit_pkts, pd.multicast_rcv_pkts, "
" pd.port "
" from "
" port_errors as pe,nodes as n,port_data_counters as pd "
" where"
" n.guid=pe.guid and n.guid=pd.guid and pe.port=pd.port;"
)) {
fprintf(stderr, "Failed to query node errors\n");
return (1);
}
res = mysql_store_result(conn->conn);
if ((num_fields = mysql_num_fields(res)) != 24) {
fprintf(stderr, "%s:%d Failed to query node errors %d != 24\n",
__FUNCTION__, __LINE__, num_fields);
rc = 1;
goto free_res;
}
num_rows = mysql_num_rows(res);
if (num_rows == 0) {
fprintf(stderr, "Failed to find any nodes in DB\n");
rc = 1;
goto free_res;
}
for (i = 0; i < num_rows; i++) {
uint64_t SymbolErrors;
uint64_t LinkRecovers;
uint64_t LinkDowned;
uint64_t RcvErrors;
uint64_t RcvRemotePhysErrors;
uint64_t RcvSwitchRelayErrors;
uint64_t XmtDiscards;
uint64_t XmtConstraintErrors;
uint64_t RcvConstraintErrors;
uint64_t LinkIntegrityErrors;
uint64_t ExcBufOverrunErrors;
uint64_t VL15Dropped;
uint64_t total = 0;
row = mysql_fetch_row(res);
SymbolErrors = COL_TO_UINT64(0);
total += CHECK_MASK(SymbolErrors, mask_vals);
LinkRecovers = COL_TO_UINT64(1);
total += CHECK_MASK(LinkRecovers, mask_vals);
LinkDowned = COL_TO_UINT64(2);
total += CHECK_MASK(LinkDowned, mask_vals);
RcvErrors = COL_TO_UINT64(3);
total += CHECK_MASK(RcvErrors, mask_vals);
RcvRemotePhysErrors = COL_TO_UINT64(4);
total += CHECK_MASK(RcvRemotePhysErrors, mask_vals);
RcvSwitchRelayErrors = COL_TO_UINT64(5);
total += CHECK_MASK(RcvSwitchRelayErrors, mask_vals);
XmtDiscards = COL_TO_UINT64(6);
total += CHECK_MASK(XmtDiscards, mask_vals);
XmtConstraintErrors = COL_TO_UINT64(7);
total += CHECK_MASK(XmtConstraintErrors, mask_vals);
RcvConstraintErrors = COL_TO_UINT64(8);
total += CHECK_MASK(RcvConstraintErrors, mask_vals);
LinkIntegrityErrors = COL_TO_UINT64(9);
total += CHECK_MASK(LinkIntegrityErrors, mask_vals);
ExcBufOverrunErrors = COL_TO_UINT64(10);
total += CHECK_MASK(ExcBufOverrunErrors, mask_vals);
VL15Dropped = COL_TO_UINT64(11);
total += CHECK_MASK(VL15Dropped, mask_vals);
if (total > 0) {
char node_desc[65];
char *node_name = NULL;
strncpy(node_desc, row[12], 64);
node_name = remap_node_name(node_name_map, COL_TO_UINT64(14), node_desc);
print_report_error_res(node_name, row, total);
free(node_name);
}
}
free_res:
mysql_free_result(res);
return (rc);
}
/** =========================================================================
* Port <= 0 indicates "all" ports
*/
static int
report(mysql_connection_t *conn, char *node, int port)
{
int rc = 0;
unsigned int num_fields;
unsigned int num_rows, i;
MYSQL_RES *res;
MYSQL_ROW row;
#define CLAUSE_SIZE (256)
char node_clause[CLAUSE_SIZE];
char port_clause[CLAUSE_SIZE];
if (node) {
/* check to see if the node is specified by name or guid */
uint64_t guid = strtoull(node, NULL, 0);
if (guid == 0)
guid = get_guid_for_name(node_name_map, node);
if (guid == 0) {
snprintf(node_clause, CLAUSE_SIZE,
" and n.name=\"%s\"", node);
} else {
snprintf(node_clause, CLAUSE_SIZE,
" and n.guid=%"PRIuLEAST64, guid);
}
} else {
node_clause[0] = '\0';
}
if (port > 0) {
snprintf(port_clause, CLAUSE_SIZE, " and pe.port=%d", port);
} else {
port_clause[0] = '\0';
}
if (QUERY(conn,
"select pe.SymbolErrors, pe.LinkRecovers,"
" pe.LinkDowned, pe.RcvErrors, pe.RcvRemotePhysErrors,"
" pe.RcvSwitchRelayErrors, pe.XmtDiscards,"
" pe.XmtConstraintErrors, pe.RcvConstraintErrors,"
" pe.LinkIntegrityErrors, pe.ExcBufOverrunErrors,"
" pe.VL15Dropped, n.name, pe.port, n.guid,"
" pd.xmit_data, pd.rcv_data, pd.xmit_pkts, pd.rcv_pkts,"
" pd.unicast_xmit_pkts, pd.unicast_rcv_pkts,"
" pd.multicast_xmit_pkts, pd.multicast_rcv_pkts, "
" pd.port "
" from "
" port_errors as pe,nodes as n,port_data_counters as pd "
" where"
" n.guid=pe.guid and n.guid=pd.guid and pe.port=pd.port %s %s;",
node_clause,
port_clause)) {
fprintf(stderr, "Failed to query node errors");
if (node) {
fprintf(stderr, " for \"%s\"", node);
} else {
fprintf(stderr, "\n");
}
return (1);
}
res = mysql_store_result(conn->conn);
if ((num_fields = mysql_num_fields(res)) != 24) {
fprintf(stderr, "%s:%d Failed to query node errors %d != 24\n",
__FUNCTION__, __LINE__, num_fields);
rc = 1;
goto free_res;
}
num_rows = mysql_num_rows(res);
if (num_rows == 0) {
if (node) {
if (port <= 0) {
fprintf(stderr, "Node \"%s\" (port %s) not found in DB\n",
node, "\"all\"");
} else {
fprintf(stderr, "Node \"%s\" (port %d) not found in DB\n",
node, port);
}
} else {
fprintf(stderr, "Failed to find any nodes in DB\n");
}
rc = 1;
goto free_res;
}
for (i = 0; i < num_rows; i++) {
char node_desc[65];
char *node_name = NULL;
row = mysql_fetch_row(res);
strncpy(node_desc, row[12], 64);
node_name = remap_node_name(node_name_map, COL_TO_UINT64(14), node_desc);
if (skummee_output) {
clean_node_name(node_name);
print_report_line_res(node_name, row);
} else
print_report_res(node_name, row);
free(node_name);
}
free_res:
mysql_free_result(res);
return (rc);
}
static int
query_status(mysql_connection_t *conn)
{
int rc = 0;
unsigned int num_fields;
unsigned int num_rows, i;
uint64_t errors = 0;
MYSQL_RES *res;
MYSQL_ROW row;
#if HAVE_LIBGENDERS
genders_t genders_handle;
char **nodes = NULL;
int num_nodes = 0;
switch_error_sum_t switch_error_sum;
memset(&switch_error_sum, 0, (sizeof switch_error_sum));
#endif
/* issue the query join for any errors */
if (QUERY(conn,
"select pe.SymbolErrors, pe.LinkRecovers,"
" pe.LinkDowned, pe.RcvErrors, pe.RcvRemotePhysErrors,"
" pe.RcvSwitchRelayErrors, pe.XmtDiscards,"
" pe.XmtConstraintErrors, pe.RcvConstraintErrors,"
" pe.LinkIntegrityErrors, pe.ExcBufOverrunErrors,"
" pe.VL15Dropped, n.name, pe.port, n.guid"
" from port_errors as pe,nodes as n where n.guid=pe.guid;")) {
fprintf(stderr, "Failed to query node errors\n");
return (1);
}
res = mysql_store_result(conn->conn);
if ((num_fields = mysql_num_fields(res)) != 15) {
fprintf(stderr, "%s:%d Failed to query status %d != 14\n",
__FUNCTION__, __LINE__, num_fields);
rc = 1;
goto free_res;
}
num_rows = mysql_num_rows(res);
#if HAVE_LIBGENDERS
genders_handle = genders_handle_create();
if (!genders_handle || genders_load_data(genders_handle, NULL)) {
fprintf(stderr, "Genders load failed: %s\n", genders_handle ?
genders_errormsg(genders_handle)
: "handle creation failed");
goto genders_open_fail;
}
#endif
/* The basic algo is to sum up all the errors and report them together */
for (i = 0; i < num_rows; i++) {
char node_desc[65];
char *node_name = NULL;
row = mysql_fetch_row(res);
/* add up all the errors reported. */
errors = 0;
errors += COL_TO_UINT64(0);
errors += COL_TO_UINT64(1);
errors += COL_TO_UINT64(2);
errors += COL_TO_UINT64(3);
errors += COL_TO_UINT64(4);
errors += COL_TO_UINT64(5);
errors += COL_TO_UINT64(6);
errors += COL_TO_UINT64(7);
errors += COL_TO_UINT64(8);
errors += COL_TO_UINT64(9);
errors += COL_TO_UINT64(10);
errors += COL_TO_UINT64(11);
#if HAVE_LIBGENDERS
if (sum_fabric_errors && !genders_isnode(genders_handle, row[12])) {
switch_error_sum.SymbolErrors += COL_TO_UINT64(0);
switch_error_sum.LinkRecovers += COL_TO_UINT64(1);
switch_error_sum.LinkDowned += COL_TO_UINT64(2);
switch_error_sum.RcvErrors += COL_TO_UINT64(3);
switch_error_sum.RcvRemotePhysErrors += COL_TO_UINT64(4);
switch_error_sum.RcvSwitchRelayErrors += COL_TO_UINT64(5);
switch_error_sum.XmtDiscards += COL_TO_UINT64(6);
switch_error_sum.XmtConstraintErrors += COL_TO_UINT64(7);
switch_error_sum.RcvConstraintErrors += COL_TO_UINT64(8);
switch_error_sum.LinkIntegrityErrors += COL_TO_UINT64(9);
switch_error_sum.ExcBufOverrunErrors += COL_TO_UINT64(10);
switch_error_sum.VL15Dropped += COL_TO_UINT64(11);
}
#endif
strncpy(node_desc, row[12], 64);
node_name = remap_node_name(node_name_map, COL_TO_UINT64(14), node_desc);
clean_node_name(node_name);
printf("%s,ibport%s-error_sum,%"PRIuLEAST64"\n",
node_name, row[13], errors);
free(node_name);
}
#if HAVE_LIBGENDERS
if (sum_fabric_errors) {
printf("%s,SymbolErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.SymbolErrors);
printf("%s,SymbolErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.SymbolErrors);
printf("%s,LinkRecovers_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.LinkRecovers);
printf("%s,LinkRecovers_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.LinkRecovers);
printf("%s,LinkDowned_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.LinkDowned);
printf("%s,LinkDowned_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.LinkDowned);
printf("%s,RcvErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvErrors);
printf("%s,RcvErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvErrors);
printf("%s,RcvRemotePhysErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvRemotePhysErrors);
printf("%s,RcvRemotePhysErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvRemotePhysErrors);
printf("%s,RcvSwitchRelayErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvSwitchRelayErrors);
printf("%s,RcvSwitchRelayErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvSwitchRelayErrors);
printf("%s,XmtDiscards_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.XmtDiscards);
printf("%s,XmtDiscards_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.XmtDiscards);
printf("%s,XmtConstraintErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.XmtConstraintErrors);
printf("%s,XmtConstraintErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.XmtConstraintErrors);
printf("%s,RcvConstraintErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvConstraintErrors);
printf("%s,RcvConstraintErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.RcvConstraintErrors);
printf("%s,LinkIntegrityErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.LinkIntegrityErrors);
printf("%s,LinkIntegrityErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.LinkIntegrityErrors);
printf("%s,ExcBufOverrunErrors_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.ExcBufOverrunErrors);
printf("%s,ExcBufOverrunErrors_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.ExcBufOverrunErrors);
printf("%s,VL15Dropped_sum,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.VL15Dropped);
printf("%s,VL15Dropped_sum_counter,%"PRIuLEAST64"\n",
IB_SWITCH_TOTAL_NODE_NAME,
switch_error_sum.VL15Dropped);
}
genders_open_fail:
genders_handle_destroy(genders_handle);
#endif
free_res:
mysql_free_result(res);
return (rc);
}
