int main(int argc, char **argv)
{
int mgmt_classes[3] =
{ IB_SMI_CLASS, IB_SMI_DIRECT_CLASS, IB_SA_CLASS };
int sysstat_class = IB_VENDOR_OPENIB_SYSSTAT_CLASS;
ib_portid_t portid = { 0 };
int attr = IB_PING_ATTR;
char *err;
const struct ibdiag_opt opts[] = {
{"oui", 'o', 1, NULL, "use specified OUI number"},
{"Server", 'S', 0, NULL, "start in server mode"},
{0}
};
char usage_args[] = "<dest lid|guid> [<op>]";
ibdiag_process_opts(argc, argv, NULL, "DKy", opts, process_opt,
usage_args, NULL);
argc -= optind;
argv += optind;
if (!argc && !server)
ibdiag_show_usage();
if (argc > 1 && (attr = match_attr(argv[1])) < 0)
ibdiag_show_usage();
srcport = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 3);
if (!srcport)
IBEXIT("Failed to open '%s' port '%d'", ibd_ca, ibd_ca_port);
if (server) {
if (mad_register_server_via(sysstat_class, 1, 0, oui, srcport) <
0)
IBEXIT("can't serve class %d", sysstat_class);
host_ncpu = build_cpuinfo();
if ((err = ibsystat_serv()))
IBEXIT("ibssystat to %s: %s", portid2str(&portid),
err);
exit(0);
}
if (mad_register_client_via(sysstat_class, 1, srcport) < 0)
IBEXIT("can't register to sysstat class %d", sysstat_class);
if (resolve_portid_str(ibd_ca, ibd_ca_port, &portid, argv[0],
ibd_dest_type, ibd_sm_id, srcport) < 0)
IBEXIT("can't resolve destination port %s", argv[0]);
if ((err = ibsystat(&portid, attr)))
IBEXIT("ibsystat to %s: %s", portid2str(&portid), err);
mad_rpc_close_port(srcport);
exit(0);
}
/**
* initialize one IB port so that we are able to read values from it
*/
static int
init_ib_port( ib_port * portdata )
{
int mgmt_classes[4] = { IB_SMI_CLASS, IB_SMI_DIRECT_CLASS, IB_SA_CLASS,
IB_PERFORMANCE_CLASS
};
char *ca = 0;
static uint8_t pc[1024];
int mask = 0xFFFF;
srcport = mad_rpc_open_port( ca, portdata->port_number, mgmt_classes, 4 );
if ( !srcport ) {
fprintf( stderr, "Failed to open '%s' port '%d'\n", ca,
portdata->port_number );
exit( 1 );
}
if ( ib_resolve_self_via( &portid, &ibportnum, 0, srcport ) < 0 ) {
fprintf( stderr, "can't resolve self port\n" );
exit( 1 );
}
/* PerfMgt ClassPortInfo is a required attribute */
/* might be redundant, could be left out for fast implementation */
if ( !pma_query_via
( pc, &portid, ibportnum, ib_timeout, CLASS_PORT_INFO, srcport ) ) {
fprintf( stderr, "classportinfo query\n" );
exit( 1 );
}
if ( !performance_reset_via
( pc, &portid, ibportnum, mask, ib_timeout, IB_GSI_PORT_COUNTERS,
srcport ) ) {
fprintf( stderr, "perf reset\n" );
exit( 1 );
}
/* read the initial values */
mad_decode_field( pc, IB_PC_XMT_BYTES_F, &portdata->last_send_val );
portdata->sum_send_val = 0;
mad_decode_field( pc, IB_PC_RCV_BYTES_F, &portdata->last_recv_val );
portdata->sum_recv_val = 0;
portdata->is_initialized = 1;
return 0;
}
int main(int argc, char **argv)
{
char usage_args[1024];
int mgmt_classes[2] = { IB_SMI_CLASS, IB_SMI_DIRECT_CLASS };
char *trap_name = NULL;
int i, n, rc;
n = sprintf(usage_args, "[<trap_name>] [<error_port>]\n"
"\nArgument <trap_name> can be one of the following:\n");
for (i = 0; traps[i].trap_name; i++) {
n += snprintf(usage_args + n, sizeof(usage_args) - n,
" %s\n", traps[i].trap_name);
if (n >= sizeof(usage_args))
exit(-1);
}
snprintf(usage_args + n, sizeof(usage_args) - n,
"\n default behavior is to send \"%s\"", traps[0].trap_name);
ibdiag_process_opts(argc, argv, NULL, "DGKL", NULL, NULL,
usage_args, NULL);
argc -= optind;
argv += optind;
trap_name = argv[0] ? argv[0] : traps[0].trap_name;
if (argc > 1)
error_port = atoi(argv[1]);
madrpc_show_errors(1);
srcport = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 2);
if (!srcport)
IBEXIT("Failed to open '%s' port '%d'", ibd_ca, ibd_ca_port);
smp_mkey_set(srcport, ibd_mkey);
rc = process_send_trap(trap_name);
mad_rpc_close_port(srcport);
return rc;
}
int main(int argc, char **argv)
{
char *guid_file = "port_guids.list";
int mgmt_classes[2] = { IB_SMI_CLASS, IB_SMI_DIRECT_CLASS };
ib_portid_t dport_id;
int port, agent;
uint8_t *umad;
int len;
if (argc > 1)
guid_file = argv[1];
srcport = mad_rpc_open_port(NULL, 0, mgmt_classes, 2);
if (!srcport)
err("Failed to open port");
resolve_sm_portid(NULL, 0, &dport_id);
dport_id.qp = 1;
if (!dport_id.qkey)
dport_id.qkey = IB_DEFAULT_QP1_QKEY;
len = umad_size() + 256;
umad = calloc(1, len);
if (!umad) {
err("cannot alloc mem for umad: %s\n", strerror(errno));
return -1;
}
port = mad_rpc_portid(srcport);
agent = umad_register(port, IB_SA_CLASS, 2, 0, NULL);
rereg_and_test_port(guid_file, port, agent, &dport_id, TMO);
free(umad);
umad_unregister(port, agent);
umad_close_port(port);
umad_done();
return 0;
}
/*
* _read_ofed_values read the IB sensor and update last_update values and times
*/
static int _read_ofed_values(void)
{
static uint64_t last_update_xmtdata = 0;
static uint64_t last_update_rcvdata = 0;
static uint64_t last_update_xmtpkts = 0;
static uint64_t last_update_rcvpkts = 0;
static bool first = true;
int rc = SLURM_SUCCESS;
uint16_t cap_mask;
uint64_t send_val, recv_val, send_pkts, recv_pkts;
ofed_sens.last_update_time = ofed_sens.update_time;
ofed_sens.update_time = time(NULL);
if (first) {
char *ibd_ca = NULL;
int mgmt_classes[4] = {IB_SMI_CLASS, IB_SMI_DIRECT_CLASS,
IB_SA_CLASS, IB_PERFORMANCE_CLASS};
srcport = mad_rpc_open_port(ibd_ca, ofed_conf.port,
mgmt_classes, 4);
if (!srcport){
error("Failed to open '%s' port '%d'", ibd_ca,
ofed_conf.port);
debug("INFINIBAND: failed");
return SLURM_ERROR;
}
if (ib_resolve_self_via(&portid, &port, 0, srcport) < 0)
error("can't resolve self port %d", port);
memset(pc, 0, sizeof(pc));
if (!_slurm_pma_query_via(pc, &portid, port, ibd_timeout,
CLASS_PORT_INFO, srcport))
error("classportinfo query: %m");
memcpy(&cap_mask, pc + 2, sizeof(cap_mask));
if (!_slurm_pma_query_via(pc, &portid, port, ibd_timeout,
IB_GSI_PORT_COUNTERS_EXT, srcport)) {
error("ofed: %m");
return SLURM_ERROR;
}
mad_decode_field(pc, IB_PC_EXT_XMT_BYTES_F,
&last_update_xmtdata);
mad_decode_field(pc, IB_PC_EXT_RCV_BYTES_F,
&last_update_rcvdata);
mad_decode_field(pc, IB_PC_EXT_XMT_PKTS_F,
&last_update_xmtpkts);
mad_decode_field(pc, IB_PC_EXT_RCV_PKTS_F,
&last_update_rcvpkts);
if (debug_flags & DEBUG_FLAG_INFINIBAND)
info("%s ofed init", plugin_name);
first = 0;
return SLURM_SUCCESS;
}
memset(pc, 0, sizeof(pc));
memcpy(&cap_mask, pc + 2, sizeof(cap_mask));
if (!_slurm_pma_query_via(pc, &portid, port, ibd_timeout,
IB_GSI_PORT_COUNTERS_EXT, srcport)) {
error("ofed: %m");
return SLURM_ERROR;
}
mad_decode_field(pc, IB_PC_EXT_XMT_BYTES_F, &send_val);
mad_decode_field(pc, IB_PC_EXT_RCV_BYTES_F, &recv_val);
mad_decode_field(pc, IB_PC_EXT_XMT_PKTS_F, &send_pkts);
mad_decode_field(pc, IB_PC_EXT_RCV_PKTS_F, &recv_pkts);
ofed_sens.xmtdata = (send_val - last_update_xmtdata) * 4;
ofed_sens.total_xmtdata += ofed_sens.xmtdata;
ofed_sens.rcvdata = (recv_val - last_update_rcvdata) * 4;
ofed_sens.total_rcvdata += ofed_sens.rcvdata;
ofed_sens.xmtpkts = send_pkts - last_update_xmtpkts;
ofed_sens.total_xmtpkts += ofed_sens.xmtpkts;
ofed_sens.rcvpkts = recv_pkts - last_update_rcvpkts;
ofed_sens.total_rcvpkts += ofed_sens.rcvpkts;
last_update_xmtdata = send_val;
last_update_rcvdata = recv_val;
last_update_xmtpkts = send_pkts;
last_update_rcvpkts = recv_pkts;
return rc;
}
int main(int argc, char **argv)
{
char usage_args[1024];
int mgmt_classes[3] =
{ IB_SMI_CLASS, IB_SMI_DIRECT_CLASS, IB_SA_CLASS };
ib_portid_t portid = { 0 };
char *err;
op_fn_t *fn;
const match_rec_t *r;
int n;
const struct ibdiag_opt opts[] = {
{"combined", 'c', 0, NULL,
"use Combined route address argument"},
{"node-name-map", 1, 1, "<file>", "node name map file"},
{"extended", 'x', 0, NULL, "use extended speeds"},
{0}
};
const char *usage_examples[] = {
"portinfo 3 1\t\t\t\t# portinfo by lid, with port modifier",
"-G switchinfo 0x2C9000100D051 1\t# switchinfo by guid",
"-D nodeinfo 0\t\t\t\t# nodeinfo by direct route",
"-c nodeinfo 6 0,12\t\t\t# nodeinfo by combined route",
NULL
};
n = sprintf(usage_args, "<op> <dest dr_path|lid|guid> [op params]\n"
"\nSupported ops (and aliases, case insensitive):\n");
for (r = match_tbl; r->name; r++) {
n += snprintf(usage_args + n, sizeof(usage_args) - n,
" %s (%s) <addr>%s\n", r->name,
r->alias ? r->alias : "",
r->opt_portnum ? " [<portnum>]" : "");
if (n >= sizeof(usage_args))
exit(-1);
}
ibdiag_process_opts(argc, argv, NULL, NULL, opts, process_opt,
usage_args, usage_examples);
argc -= optind;
argv += optind;
if (argc < 2)
ibdiag_show_usage();
if (!(fn = match_op(match_tbl, argv[0])))
IBEXIT("operation '%s' not supported", argv[0]);
srcport = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 3);
if (!srcport)
IBEXIT("Failed to open '%s' port '%d'", ibd_ca, ibd_ca_port);
smp_mkey_set(srcport, ibd_mkey);
node_name_map = open_node_name_map(node_name_map_file);
if (ibd_dest_type != IB_DEST_DRSLID) {
if (resolve_portid_str(ibd_ca, ibd_ca_port, &portid, argv[1],
ibd_dest_type, ibd_sm_id, srcport) < 0)
IBEXIT("can't resolve destination port %s", argv[1]);
if ((err = fn(&portid, argv + 2, argc - 2)))
IBEXIT("operation %s: %s", argv[0], err);
} else {
char concat[64];
memset(concat, 0, 64);
snprintf(concat, sizeof(concat), "%s %s", argv[1], argv[2]);
if (resolve_portid_str(ibd_ca, ibd_ca_port, &portid, concat,
ibd_dest_type, ibd_sm_id, srcport) < 0)
IBEXIT("can't resolve destination port %s", concat);
if ((err = fn(&portid, argv + 3, argc - 3)))
IBEXIT("operation %s: %s", argv[0], err);
}
close_node_name_map(node_name_map);
mad_rpc_close_port(srcport);
exit(0);
}
int main(int argc, char **argv)
{
char usage_args[1024];
int mgmt_classes[3] = { IB_SMI_CLASS, IB_SA_CLASS, IB_CC_CLASS };
ib_portid_t portid = { 0 };
char *err;
op_fn_t *fn;
const match_rec_t *r;
int n;
const struct ibdiag_opt opts[] = {
{"cckey", 'c', 1, "<key>", "CC key"},
{0}
};
const char *usage_examples[] = {
"SwitchCongestionSetting 2 0x1F 0x1FFFFFFFFF 0x0 0xF 8 0 0:0 1\t# Configure Switch Congestion Settings",
"CACongestionSetting 1 0 0x3 150 1 0 0\t\t# Configure CA Congestion Settings to SL 0 and SL 1",
"CACongestionSetting 1 0 0x4 200 1 0 0\t\t# Configure CA Congestion Settings to SL 2",
"CongestionControlTable 1 63 0 0:0 0:1 ...\t# Configure first block of Congestion Control Table",
"CongestionControlTable 1 127 0 0:64 0:65 ...\t# Configure second block of Congestion Control Table",
NULL
};
n = sprintf(usage_args, "[-c key] <op> <lid|guid>\n"
"\nWARNING -- You should understand what you are "
"doing before using this tool. Misuse of this "
"tool could result in a broken fabric.\n"
"\nSupported ops (and aliases, case insensitive):\n");
for (r = match_tbl; r->name; r++) {
n += snprintf(usage_args + n, sizeof(usage_args) - n,
" %s (%s) <lid|guid>%s%s%s\n", r->name,
r->alias ? r->alias : "",
r->opt_portnum ? " <portnum>" : "",
r->ops_extra ? " " : "",
r->ops_extra ? r->ops_extra : "");
if (n >= sizeof(usage_args))
exit(-1);
}
ibdiag_process_opts(argc, argv, NULL, "DK", opts, process_opt,
usage_args, usage_examples);
argc -= optind;
argv += optind;
if (argc < 2)
ibdiag_show_usage();
if (!(fn = match_op(match_tbl, argv[0])))
IBEXIT("operation '%s' not supported", argv[0]);
srcport = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 3);
if (!srcport)
IBEXIT("Failed to open '%s' port '%d'", ibd_ca, ibd_ca_port);
smp_mkey_set(srcport, ibd_mkey);
if (resolve_portid_str(ibd_ca, ibd_ca_port, &portid, argv[1],
ibd_dest_type, ibd_sm_id, srcport) < 0)
IBEXIT("can't resolve destination %s", argv[1]);
if ((err = fn(&portid, argv + 2, argc - 2)))
IBEXIT("operation %s: %s", argv[0], err);
mad_rpc_close_port(srcport);
exit(0);
}
int main(int argc, char **argv)
{
int mgmt_classes[3] =
{ IB_SMI_CLASS, IB_SMI_DIRECT_CLASS, IB_SA_CLASS };
ib_portid_t portid = { 0 };
int port_op = -1;
int is_switch, is_peer_switch, espeed_cap, peer_espeed_cap;
int state, physstate, lwe, lws, lwa, lse, lss, lsa, lsee, lses, lsea,
fdr10s, fdr10e, fdr10a;
int peerlocalportnum, peerlwe, peerlws, peerlwa, peerlse, peerlss,
peerlsa, peerlsee, peerlses, peerlsea, peerfdr10s, peerfdr10e,
peerfdr10a;
int peerwidth, peerspeed, peerespeed;
uint8_t data[IB_SMP_DATA_SIZE] = { 0 };
uint8_t data2[IB_SMP_DATA_SIZE] = { 0 };
ib_portid_t peerportid = { 0 };
int portnum = 0;
ib_portid_t selfportid = { 0 };
int selfport = 0;
int changed = 0;
int i;
uint32_t vendorid, rem_vendorid;
uint16_t devid, rem_devid;
uint64_t val;
char *endp;
char usage_args[] = "<dest dr_path|lid|guid> <portnum> [<op>]\n"
"\nSupported ops: enable, disable, on, off, reset, speed, espeed, fdr10,\n"
"\twidth, query, down, arm, active, vls, mtu, lid, smlid, lmc,\n"
"\tmkey, mkeylease, mkeyprot\n";
const char *usage_examples[] = {
"3 1 disable\t\t\t# by lid",
"-G 0x2C9000100D051 1 enable\t# by guid",
"-D 0 1\t\t\t# (query) by direct route",
"3 1 reset\t\t\t# by lid",
"3 1 speed 1\t\t\t# by lid",
"3 1 width 1\t\t\t# by lid",
"-D 0 1 lid 0x1234 arm\t\t# by direct route",
NULL
};
ibdiag_process_opts(argc, argv, NULL, NULL, NULL, NULL,
usage_args, usage_examples);
argc -= optind;
argv += optind;
if (argc < 2)
ibdiag_show_usage();
srcport = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 3);
if (!srcport)
IBEXIT("Failed to open '%s' port '%d'", ibd_ca, ibd_ca_port);
smp_mkey_set(srcport, ibd_mkey);
if (resolve_portid_str(ibd_ca, ibd_ca_port, &portid, argv[0],
ibd_dest_type, ibd_sm_id, srcport) < 0)
IBEXIT("can't resolve destination port %s", argv[0]);
if (argc > 1)
portnum = strtol(argv[1], 0, 0);
for (i = 2; i < argc; i++) {
int j;
for (j = 0; j < NPORT_ARGS; j++) {
if (strcmp(argv[i], port_args[j].name))
continue;
port_args[j].set = 1;
if (!port_args[j].val) {
if (port_op >= 0)
IBEXIT("%s only one of: ",
"query, enable, disable, "
"reset, down, arm, active, "
"can be specified",
port_args[j].name);
port_op = j;
break;
}
if (++i >= argc)
IBEXIT("%s requires an additional parameter",
port_args[j].name);
val = strtoull(argv[i], 0, 0);
switch (j) {
case SPEED:
if (val > 15)
IBEXIT("invalid speed value %ld", val);
break;
case ESPEED:
if (val > 31)
IBEXIT("invalid extended speed value %ld", val);
break;
case FDR10SPEED:
if (val > 1)
IBEXIT("invalid fdr10 speed value %ld", val);
break;
case WIDTH:
if ((val > 31 && val != 255))
IBEXIT("invalid width value %ld", val);
break;
case VLS:
if (val == 0 || val > 5)
IBEXIT("invalid vls value %ld", val);
break;
case MTU:
if (val == 0 || val > 5)
IBEXIT("invalid mtu value %ld", val);
break;
case LID:
if (val == 0 || val >= 0xC000)
IBEXIT("invalid lid value 0x%lx", val);
break;
case SMLID:
if (val == 0 || val >= 0xC000)
IBEXIT("invalid smlid value 0x%lx",
val);
break;
case LMC:
if (val > 7)
IBEXIT("invalid lmc value %ld", val);
break;
case MKEY:
errno = 0;
val = strtoull(argv[i], &endp, 0);
if (errno || *endp != '\0') {
errno = 0;
val = strtoull(getpass("New M_Key: "),
&endp, 0);
if (errno || *endp != '\0') {
IBEXIT("Bad new M_Key\n");
}
}
/* All 64-bit values are legal */
break;
case MKEYLEASE:
if (val > 0xFFFF)
IBEXIT("invalid mkey lease time %ld", val);
break;
case MKEYPROT:
if (val > 3)
IBEXIT("invalid mkey protection bit setting %ld", val);
}
*port_args[j].val = val;
changed = 1;
break;
}
if (j == NPORT_ARGS)
IBEXIT("invalid operation: %s", argv[i]);
}
if (port_op < 0)
port_op = QUERY;
is_switch = get_node_info(&portid, data);
vendorid = (uint32_t) mad_get_field(data, 0, IB_NODE_VENDORID_F);
devid = (uint16_t) mad_get_field(data, 0, IB_NODE_DEVID_F);
if ((port_args[MKEY].set || port_args[MKEYLEASE].set ||
port_args[MKEYPROT].set) && is_switch && portnum != 0)
IBEXIT("Can't set M_Key fields on switch port != 0");
if (port_op != QUERY || changed)
printf("Initial %s PortInfo:\n", is_switch ? "Switch" : "CA/RT");
else
printf("%s PortInfo:\n", is_switch ? "Switch" : "CA/RT");
espeed_cap = get_port_info(&portid, data, portnum, is_switch);
show_port_info(&portid, data, portnum, espeed_cap, is_switch);
if (is_mlnx_ext_port_info_supported(vendorid, devid)) {
get_mlnx_ext_port_info(&portid, data2, portnum);
show_mlnx_ext_port_info(&portid, data2, portnum);
}
if (port_op != QUERY || changed) {
/*
* If we aren't setting the LID and the LID is the default,
* the SMA command will fail due to an invalid LID.
* Set it to something unlikely but valid.
*/
physstate = mad_get_field(data, 0, IB_PORT_PHYS_STATE_F);
val = mad_get_field(data, 0, IB_PORT_LID_F);
if (!port_args[LID].set && (!val || val == 0xFFFF))
mad_set_field(data, 0, IB_PORT_LID_F, 0x1234);
val = mad_get_field(data, 0, IB_PORT_SMLID_F);
if (!port_args[SMLID].set && (!val || val == 0xFFFF))
mad_set_field(data, 0, IB_PORT_SMLID_F, 0x1234);
mad_set_field(data, 0, IB_PORT_STATE_F, 0); /* NOP */
mad_set_field(data, 0, IB_PORT_PHYS_STATE_F, 0); /* NOP */
switch (port_op) {
case ON:
/* Enable only if state is Disable */
if(physstate != 3) {
printf("Port is already in enable state\n");
goto close_port;
}
case ENABLE:
case RESET:
/* Polling */
mad_set_field(data, 0, IB_PORT_PHYS_STATE_F, 2);
break;
case OFF:
case DISABLE:
printf("Disable may be irreversible\n");
mad_set_field(data, 0, IB_PORT_PHYS_STATE_F, 3);
break;
case DOWN:
mad_set_field(data, 0, IB_PORT_STATE_F, 1);
break;
case ARM:
mad_set_field(data, 0, IB_PORT_STATE_F, 3);
break;
case ACTIVE:
mad_set_field(data, 0, IB_PORT_STATE_F, 4);
break;
}
/* always set enabled speeds/width - defaults to NOP */
mad_set_field(data, 0, IB_PORT_LINK_SPEED_ENABLED_F, speed);
mad_set_field(data, 0, IB_PORT_LINK_SPEED_EXT_ENABLED_F, espeed);
mad_set_field(data, 0, IB_PORT_LINK_WIDTH_ENABLED_F, width);
if (port_args[VLS].set)
mad_set_field(data, 0, IB_PORT_OPER_VLS_F, vls);
if (port_args[MTU].set)
mad_set_field(data, 0, IB_PORT_NEIGHBOR_MTU_F, mtu);
if (port_args[LID].set)
mad_set_field(data, 0, IB_PORT_LID_F, lid);
if (port_args[SMLID].set)
mad_set_field(data, 0, IB_PORT_SMLID_F, smlid);
if (port_args[LMC].set)
mad_set_field(data, 0, IB_PORT_LMC_F, lmc);
if (port_args[FDR10SPEED].set) {
mad_set_field(data2, 0,
IB_MLNX_EXT_PORT_STATE_CHG_ENABLE_F,
FDR10);
mad_set_field(data2, 0,
IB_MLNX_EXT_PORT_LINK_SPEED_ENABLED_F,
fdr10);
set_mlnx_ext_port_info(&portid, data2, portnum);
}
if (port_args[MKEY].set)
mad_set_field64(data, 0, IB_PORT_MKEY_F, mkey);
if (port_args[MKEYLEASE].set)
mad_set_field(data, 0, IB_PORT_MKEY_LEASE_F,
mkeylease);
if (port_args[MKEYPROT].set)
mad_set_field(data, 0, IB_PORT_MKEY_PROT_BITS_F,
mkeyprot);
set_port_info(&portid, data, portnum, espeed_cap, is_switch);
} else if (is_switch && portnum) {
/* Now, make sure PortState is Active */
/* Or is PortPhysicalState LinkUp sufficient ? */
mad_decode_field(data, IB_PORT_STATE_F, &state);
mad_decode_field(data, IB_PORT_PHYS_STATE_F, &physstate);
if (state == 4) { /* Active */
mad_decode_field(data, IB_PORT_LINK_WIDTH_ENABLED_F,
&lwe);
mad_decode_field(data, IB_PORT_LINK_WIDTH_SUPPORTED_F,
&lws);
mad_decode_field(data, IB_PORT_LINK_WIDTH_ACTIVE_F,
&lwa);
mad_decode_field(data, IB_PORT_LINK_SPEED_SUPPORTED_F,
&lss);
mad_decode_field(data, IB_PORT_LINK_SPEED_ACTIVE_F,
&lsa);
mad_decode_field(data, IB_PORT_LINK_SPEED_ENABLED_F,
&lse);
mad_decode_field(data2,
IB_MLNX_EXT_PORT_LINK_SPEED_SUPPORTED_F,
&fdr10s);
mad_decode_field(data2,
IB_MLNX_EXT_PORT_LINK_SPEED_ENABLED_F,
&fdr10e);
mad_decode_field(data2,
IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F,
&fdr10a);
if (espeed_cap) {
mad_decode_field(data,
IB_PORT_LINK_SPEED_EXT_SUPPORTED_F,
&lses);
mad_decode_field(data,
IB_PORT_LINK_SPEED_EXT_ACTIVE_F,
&lsea);
mad_decode_field(data,
IB_PORT_LINK_SPEED_EXT_ENABLED_F,
&lsee);
}
/* Setup portid for peer port */
memcpy(&peerportid, &portid, sizeof(peerportid));
if (portid.lid == 0) {
peerportid.drpath.cnt++;
if (peerportid.drpath.cnt == IB_SUBNET_PATH_HOPS_MAX) {
IBEXIT("Too many hops");
}
} else {
peerportid.drpath.cnt = 1;
/* Set DrSLID to local lid */
if (resolve_self(ibd_ca, ibd_ca_port, &selfportid,
&selfport, 0) < 0)
IBEXIT("could not resolve self");
peerportid.drpath.drslid = (uint16_t) selfportid.lid;
peerportid.drpath.drdlid = 0xffff;
}
peerportid.drpath.p[peerportid.drpath.cnt] = (uint8_t) portnum;
/* Get peer port NodeInfo to obtain peer port number */
is_peer_switch = get_node_info(&peerportid, data);
rem_vendorid = (uint32_t) mad_get_field(data, 0, IB_NODE_VENDORID_F);
rem_devid = (uint16_t) mad_get_field(data, 0, IB_NODE_DEVID_F);
mad_decode_field(data, IB_NODE_LOCAL_PORT_F,
&peerlocalportnum);
printf("Peer PortInfo:\n");
/* Get peer port characteristics */
peer_espeed_cap = get_port_info(&peerportid, data,
peerlocalportnum,
is_peer_switch);
if (is_mlnx_ext_port_info_supported(rem_vendorid, rem_devid))
get_mlnx_ext_port_info(&peerportid, data2,
peerlocalportnum);
show_port_info(&peerportid, data, peerlocalportnum,
peer_espeed_cap, is_peer_switch);
if (is_mlnx_ext_port_info_supported(rem_vendorid, rem_devid))
show_mlnx_ext_port_info(&peerportid, data2,
peerlocalportnum);
mad_decode_field(data, IB_PORT_LINK_WIDTH_ENABLED_F,
&peerlwe);
mad_decode_field(data, IB_PORT_LINK_WIDTH_SUPPORTED_F,
&peerlws);
mad_decode_field(data, IB_PORT_LINK_WIDTH_ACTIVE_F,
&peerlwa);
mad_decode_field(data, IB_PORT_LINK_SPEED_SUPPORTED_F,
&peerlss);
mad_decode_field(data, IB_PORT_LINK_SPEED_ACTIVE_F,
&peerlsa);
mad_decode_field(data, IB_PORT_LINK_SPEED_ENABLED_F,
&peerlse);
mad_decode_field(data2,
IB_MLNX_EXT_PORT_LINK_SPEED_SUPPORTED_F,
&peerfdr10s);
mad_decode_field(data2,
IB_MLNX_EXT_PORT_LINK_SPEED_ENABLED_F,
&peerfdr10e);
mad_decode_field(data2,
IB_MLNX_EXT_PORT_LINK_SPEED_ACTIVE_F,
&peerfdr10a);
if (peer_espeed_cap) {
mad_decode_field(data,
IB_PORT_LINK_SPEED_EXT_SUPPORTED_F,
&peerlses);
mad_decode_field(data,
IB_PORT_LINK_SPEED_EXT_ACTIVE_F,
&peerlsea);
mad_decode_field(data,
IB_PORT_LINK_SPEED_EXT_ENABLED_F,
&peerlsee);
}
/* Now validate peer port characteristics */
/* Examine Link Width */
width = get_link_width(lwe, lws);
peerwidth = get_link_width(peerlwe, peerlws);
validate_width(width, peerwidth, lwa);
/* Examine Link Speeds */
speed = get_link_speed(lse, lss);
peerspeed = get_link_speed(peerlse, peerlss);
validate_speed(speed, peerspeed, lsa);
if (espeed_cap && peer_espeed_cap) {
espeed = get_link_speed_ext(lsee, lses);
peerespeed = get_link_speed_ext(peerlsee,
peerlses);
validate_extended_speed(espeed, peerespeed,
lsea);
} else {
if (fdr10e & FDR10 && peerfdr10e & FDR10) {
if (!(fdr10a & FDR10))
IBWARN("Peer ports operating at active speed %d rather than FDR10", lsa);
}
}
}
}
close_port:
mad_rpc_close_port(srcport);
exit(0);
}
int main(int argc, char **argv)
{
int mgmt_classes[1] = { IB_SA_CLASS };
int ping_class = IB_VENDOR_OPENIB_PING_CLASS;
uint64_t rtt;
char *err;
const struct ibdiag_opt opts[] = {
{"count", 'c', 1, "<num>", "stop after count packets"},
{"flood", 'f', 0, NULL, "flood destination"},
{"oui", 'o', 1, NULL, "use specified OUI number"},
{"Server", 'S', 0, NULL, "start in server mode"},
{0}
};
char usage_args[] = "<dest lid|guid>";
ibdiag_process_opts(argc, argv, NULL, "DKy", opts, process_opt,
usage_args, NULL);
argc -= optind;
argv += optind;
if (!argc && !server)
ibdiag_show_usage();
srcport = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 1);
if (!srcport)
IBEXIT("Failed to open '%s' port '%d'", ibd_ca, ibd_ca_port);
if (server) {
if (mad_register_server_via(ping_class, 0, 0, oui, srcport) < 0)
IBEXIT("can't serve class %d on this port",
ping_class);
get_host_and_domain(host_and_domain, sizeof host_and_domain);
if ((err = ibping_serv()))
IBEXIT("ibping to %s: %s", portid2str(&portid), err);
exit(0);
}
if (mad_register_client_via(ping_class, 0, srcport) < 0)
IBEXIT("can't register ping class %d on this port",
ping_class);
if (resolve_portid_str(ibd_ca, ibd_ca_port, &portid, argv[0],
ibd_dest_type, ibd_sm_id, srcport) < 0)
IBEXIT("can't resolve destination port %s", argv[0]);
signal(SIGINT, report);
signal(SIGTERM, report);
start = cl_get_time_stamp();
while (count-- > 0) {
ntrans++;
if ((rtt = ibping(&portid, flood)) == ~0ull) {
DEBUG("ibping to %s failed", portid2str(&portid));
lost++;
} else {
if (rtt < minrtt)
minrtt = rtt;
if (rtt > maxrtt)
maxrtt = rtt;
total_rtt += rtt;
replied++;
}
if (!flood)
sleep(1);
}
report(0);
mad_rpc_close_port(srcport);
exit(-1);
}
int main(int argc, char **argv)
{
struct ibnd_config config = { 0 };
int resolved = -1;
ib_portid_t portid = { 0 };
ib_portid_t self_portid = { 0 };
int rc = 0;
ibnd_fabric_t *fabric = NULL;
ib_gid_t self_gid;
int port = 0;
int mgmt_classes[4] = { IB_SMI_CLASS, IB_SMI_DIRECT_CLASS, IB_SA_CLASS,
IB_PERFORMANCE_CLASS
};
const struct ibdiag_opt opts[] = {
{"suppress", 's', 1, "<err1,err2,...>",
"suppress errors listed"},
{"suppress-common", 'c', 0, NULL,
"suppress some of the common counters"},
{"node-name-map", 1, 1, "<file>", "node name map file"},
{"port-guid", 'G', 1, "<port_guid>",
"report the node containing the port specified by <port_guid>"},
{"", 'S', 1, "<port_guid>",
"Same as \"-G\" for backward compatibility"},
{"Direct", 'D', 1, "<dr_path>",
"report the node containing the port specified by <dr_path>"},
{"skip-sl", 10, 0, NULL,"don't obtain SL to all destinations"},
{"report-port", 'r', 0, NULL,
"report port link information"},
{"threshold-file", 8, 1, NULL,
"specify an alternate threshold file, default: " DEF_THRES_FILE},
{"GNDN", 'R', 0, NULL,
"(This option is obsolete and does nothing)"},
{"data", 2, 0, NULL, "include data counters for ports with errors"},
{"switch", 3, 0, NULL, "print data for switches only"},
{"ca", 4, 0, NULL, "print data for CA's only"},
{"router", 5, 0, NULL, "print data for routers only"},
{"details", 6, 0, NULL, "include transmit discard details"},
{"counters", 9, 0, NULL, "print data counters only"},
{"clear-errors", 'k', 0, NULL,
"Clear error counters after read"},
{"clear-counts", 'K', 0, NULL,
"Clear data counters after read"},
{"load-cache", 7, 1, "<file>",
"filename of ibnetdiscover cache to load"},
{"outstanding_smps", 'o', 1, NULL,
"specify the number of outstanding SMP's which should be "
"issued during the scan"},
{0}
};
char usage_args[] = "";
memset(suppressed_fields, 0, sizeof suppressed_fields);
ibdiag_process_opts(argc, argv, &config, "cDGKLnRrSs", opts, process_opt,
usage_args, NULL);
argc -= optind;
argv += optind;
if (!node_type_to_print)
node_type_to_print = PRINT_ALL;
ibmad_port = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 4);
if (!ibmad_port)
IBEXIT("Failed to open port; %s:%d\n", ibd_ca, ibd_ca_port);
smp_mkey_set(ibmad_port, ibd_mkey);
if (ibd_timeout) {
mad_rpc_set_timeout(ibmad_port, ibd_timeout);
config.timeout_ms = ibd_timeout;
}
config.flags = ibd_ibnetdisc_flags;
config.mkey = ibd_mkey;
node_name_map = open_node_name_map(node_name_map_file);
if (dr_path && load_cache_file) {
fprintf(stderr, "Cannot specify cache and direct route path\n");
exit(-1);
}
if (resolve_self(ibd_ca, ibd_ca_port, &self_portid, &port, &self_gid.raw) < 0) {
IBEXIT("can't resolve self port %s", argv[0]);
goto close_port;
}
/* limit the scan the fabric around the target */
if (dr_path) {
if ((resolved =
resolve_portid_str(ibd_ca, ibd_ca_port, &portid, dr_path,
IB_DEST_DRPATH, NULL, ibmad_port)) < 0)
IBWARN("Failed to resolve %s; attempting full scan",
dr_path);
} else if (port_guid_str) {
if ((resolved =
resolve_portid_str(ibd_ca, ibd_ca_port, &portid,
port_guid_str, IB_DEST_GUID, ibd_sm_id,
ibmad_port)) < 0)
IBWARN("Failed to resolve %s; attempting full scan",
port_guid_str);
if(obtain_sl)
lid2sl_table[portid.lid] = portid.sl;
}
if (load_cache_file) {
if ((fabric = ibnd_load_fabric(load_cache_file, 0)) == NULL) {
fprintf(stderr, "loading cached fabric failed\n");
exit(-1);
}
} else {
if (resolved >= 0) {
if (!config.max_hops)
config.max_hops = 1;
if (!(fabric = ibnd_discover_fabric(ibd_ca, ibd_ca_port,
&portid, &config)))
IBWARN("Single node discover failed;"
" attempting full scan");
}
if (!fabric && !(fabric = ibnd_discover_fabric(ibd_ca,
ibd_ca_port,
NULL,
&config))) {
fprintf(stderr, "discover failed\n");
rc = -1;
goto close_port;
}
}
set_thresholds(threshold_file);
if (port_guid_str) {
ibnd_port_t *port = ibnd_find_port_guid(fabric, port_guid);
if (port)
print_node(port->node, NULL);
else
fprintf(stderr, "Failed to find node: %s\n",
port_guid_str);
} else if (dr_path) {
ibnd_port_t *port = ibnd_find_port_dr(fabric, dr_path);
uint8_t ni[IB_SMP_DATA_SIZE] = { 0 };
if (!smp_query_via(ni, &portid, IB_ATTR_NODE_INFO, 0,
ibd_timeout, ibmad_port)) {
rc = -1;
goto destroy_fabric;
}
mad_decode_field(ni, IB_NODE_PORT_GUID_F, &(port_guid));
port = ibnd_find_port_guid(fabric, port_guid);
if (port) {
if(obtain_sl)
if(path_record_query(self_gid,port->guid))
goto destroy_fabric;
print_node(port->node, NULL);
} else
fprintf(stderr, "Failed to find node: %s\n", dr_path);
} else {
if(obtain_sl)
if(path_record_query(self_gid,0))
goto destroy_fabric;
ibnd_iter_nodes(fabric, print_node, NULL);
}
rc = print_summary();
if (rc)
rc = 1;
destroy_fabric:
ibnd_destroy_fabric(fabric);
close_port:
mad_rpc_close_port(ibmad_port);
close_node_name_map(node_name_map);
exit(rc);
}
static void collect_hca_port(struct stats *stats, char *hca_name, int hca_port)
{
struct ibmad_port *mad_port = NULL;
int mad_timeout = 15;
int mad_classes[] = { IB_SMI_DIRECT_CLASS, IB_PERFORMANCE_CLASS, };
mad_port = mad_rpc_open_port(hca_name, hca_port, mad_classes, 2);
if (mad_port == NULL) {
ERROR("cannot open MAD port for HCA `%s' port %d\n", hca_name, hca_port);
goto out;
}
/* For reasons we don't understand, PMA queries can only be LID
addressed. But we don't know the LID of the switch to which the
HCA is connected, so we send a SMP on the directed route 0,1 and
ask the port to identify itself. */
ib_portid_t sw_port_id = {
.drpath = {
.cnt = 1,
.p = { 0, 1, },
},
};
uint8_t sw_info[64];
memset(sw_info, 0, sizeof(sw_info));
if (smp_query_via(sw_info, &sw_port_id, IB_ATTR_PORT_INFO, 0, mad_timeout, mad_port) == NULL) {
ERROR("cannot query port info: %m\n");
goto out;
}
int sw_lid, sw_port;
mad_decode_field(sw_info, IB_PORT_LID_F, &sw_lid);
mad_decode_field(sw_info, IB_PORT_LOCAL_PORT_F, &sw_port);
printf("IB_ATTR_PORT_INFO(drpath.p = {0, 1}): switch_lid %d, switch_local_port %d\n",
sw_lid, sw_port);
sw_port_id.lid = sw_lid;
uint8_t sw_pma[1024];
memset(sw_pma, 0, sizeof(sw_pma));
if (pma_query_via(sw_pma, &sw_port_id, sw_port, mad_timeout, IB_GSI_PORT_COUNTERS_EXT, mad_port) == NULL) {
ERROR("cannot query performance counters of switch LID %d, port %d: %m\n", sw_lid, sw_port);
goto out;
}
uint64_t sw_rx_bytes, sw_rx_packets, sw_tx_bytes, sw_tx_packets;
mad_decode_field(sw_pma, IB_PC_EXT_RCV_BYTES_F, &sw_rx_bytes);
mad_decode_field(sw_pma, IB_PC_EXT_RCV_PKTS_F, &sw_rx_packets);
mad_decode_field(sw_pma, IB_PC_EXT_XMT_BYTES_F, &sw_tx_bytes);
mad_decode_field(sw_pma, IB_PC_EXT_XMT_PKTS_F, &sw_tx_packets);
TRACE("sw_rx_bytes %lu, sw_rx_packets %lu, sw_tx_bytes %lu, sw_tx_packets %lu\n",
sw_rx_bytes, sw_rx_packets, sw_tx_bytes, sw_tx_packets);
/* The transposition of tx and rx is intentional: the switch port
receives what we send, and conversely. */
stats_set(stats, "rx_bytes", sw_tx_bytes);
stats_set(stats, "rx_packets", sw_tx_packets);
stats_set(stats, "tx_bytes", sw_rx_bytes);
stats_set(stats, "tx_packets", sw_rx_packets);
out:
if (mad_port != NULL)
mad_rpc_close_port(mad_port);
}
ibnd_fabric_t *ibnd_discover_fabric(char * ca_name, int ca_port,
ib_portid_t * from,
struct ibnd_config *cfg)
{
struct ibnd_config config = { 0 };
ibnd_fabric_t *fabric = NULL;
ib_portid_t my_portid = { 0 };
smp_engine_t engine;
ibnd_scan_t scan;
int nc = 2;
int mc[2] = { IB_SMI_CLASS, IB_SMI_DIRECT_CLASS };
/* If not specified start from "my" port */
if (!from)
from = &my_portid;
if (set_config(&config, cfg)) {
IBND_ERROR("Invalid ibnd_config\n");
return NULL;
}
fabric = calloc(1, sizeof(*fabric));
if (!fabric) {
IBND_ERROR("OOM: failed to calloc ibnd_fabric_t\n");
return NULL;
}
memset(fabric, 0, sizeof(*fabric));
memset(&scan.selfportid, 0, sizeof(scan.selfportid));
scan.fabric = fabric;
scan.cfg = &config;
scan.initial_hops = from->drpath.cnt;
if (smp_engine_init(&engine, ca_name, ca_port, &scan, &config)) {
free(fabric);
return (NULL);
}
scan.ibmad_port = mad_rpc_open_port(ca_name, ca_port, mc, nc);
if (!scan.ibmad_port) {
IBND_ERROR("can't open MAD port (%s:%d)\n", ca_name, ca_port);
smp_engine_destroy(&engine);
return (NULL);
}
mad_rpc_set_timeout(scan.ibmad_port, cfg->timeout_ms);
mad_rpc_set_retries(scan.ibmad_port, cfg->retries);
smp_mkey_set(scan.ibmad_port, cfg->mkey);
IBND_DEBUG("from %s\n", portid2str(from));
if (!query_node_info(&engine, from, NULL))
if (process_mads(&engine) != 0)
goto error;
fabric->total_mads_used = engine.total_smps;
fabric->maxhops_discovered += scan.initial_hops;
if (group_nodes(fabric))
goto error;
smp_engine_destroy(&engine);
mad_rpc_close_port(scan.ibmad_port);
return fabric;
error:
smp_engine_destroy(&engine);
mad_rpc_close_port(scan.ibmad_port);
ibnd_destroy_fabric(fabric);
return NULL;
}
