static int extend_dpath(smp_engine_t * engine, ib_portid_t * portid,
int nextport)
{
ibnd_scan_t *scan = engine->user_data;
ibnd_fabric_t *fabric = scan->fabric;
if (scan->cfg->max_hops &&
fabric->maxhops_discovered > scan->cfg->max_hops)
return 0;
if (portid->lid) {
/* If we were LID routed we need to set up the drslid */
if (!scan->selfportid.lid)
if (ib_resolve_self_via(&scan->selfportid, NULL, NULL,
scan->ibmad_port) < 0) {
IBND_ERROR("Failed to resolve self\n");
return -1;
}
portid->drpath.drslid = (uint16_t) scan->selfportid.lid;
portid->drpath.drdlid = 0xFFFF;
}
if (add_port_to_dpath(&portid->drpath, nextport) < 0) {
IBND_ERROR("add port %d to DR path failed; %s\n", nextport,
portid2str(portid));
return -1;
}
if (((unsigned) portid->drpath.cnt - scan->initial_hops) >
fabric->maxhops_discovered)
fabric->maxhops_discovered++;
return 1;
}
int ib_resolve_portid_str_via(ib_portid_t * portid, char *addr_str,
enum MAD_DEST dest_type, ib_portid_t * sm_id,
const struct ibmad_port *srcport)
{
ibmad_gid_t gid;
uint64_t guid;
int lid;
char *routepath;
ib_portid_t selfportid = { 0 };
int selfport = 0;
memset(portid, 0, sizeof *portid);
switch (dest_type) {
case IB_DEST_LID:
lid = strtol(addr_str, 0, 0);
if (!IB_LID_VALID(lid))
return -1;
return ib_portid_set(portid, lid, 0, 0);
case IB_DEST_DRPATH:
if (str2drpath(&portid->drpath, addr_str, 0, 0) < 0)
return -1;
return 0;
case IB_DEST_GUID:
if (!(guid = strtoull(addr_str, 0, 0)))
return -1;
/* keep guid in portid? */
return ib_resolve_guid_via(portid, &guid, sm_id, 0, srcport);
case IB_DEST_DRSLID:
lid = strtol(addr_str, &routepath, 0);
routepath++;
if (!IB_LID_VALID(lid))
return -1;
ib_portid_set(portid, lid, 0, 0);
/* handle DR parsing and set DrSLID to local lid */
if (ib_resolve_self_via(&selfportid, &selfport, 0, srcport) < 0)
return -1;
if (str2drpath(&portid->drpath, routepath, selfportid.lid, 0) <
0)
return -1;
return 0;
case IB_DEST_GID:
if (inet_pton(AF_INET6, addr_str, &gid) <= 0)
return -1;
return ib_resolve_gid_via(portid, gid, sm_id, 0, srcport);
default:
IBWARN("bad dest_type %d", dest_type);
}
return -1;
}
/**
* 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;
}
/*
* _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
ib_resolve_self(ib_portid_t *portid, int *portnum, ibmad_gid_t *gid)
{
return ib_resolve_self_via (portid, portnum, gid, NULL);
}
