static char *ibsystat_serv(void)
{
void *umad;
void *mad;
int attr, mod, size;
DEBUG("starting to serve...");
while ((umad = mad_receive_via(buf, -1, srcport))) {
if (umad_status(buf)) {
DEBUG("drop mad with status %x: %s", umad_status(buf),
strerror(umad_status(buf)));
continue;
}
mad = umad_get_mad(umad);
attr = mad_get_field(mad, 0, IB_MAD_ATTRID_F);
mod = mad_get_field(mad, 0, IB_MAD_ATTRMOD_F);
DEBUG("got packet: attr 0x%x mod 0x%x", attr, mod);
size =
mk_reply(attr, (uint8_t *) mad + IB_VENDOR_RANGE2_DATA_OFFS,
sizeof(buf) - umad_size() -
IB_VENDOR_RANGE2_DATA_OFFS);
if (server_respond(umad, IB_VENDOR_RANGE2_DATA_OFFS + size) < 0)
DEBUG("respond failed");
}
DEBUG("server out");
return 0;
}
void out_ids(ibnd_node_t * node, int group, char *chname, char *out_prefix)
{
uint64_t sysimgguid =
mad_get_field64(node->info, 0, IB_NODE_SYSTEM_GUID_F);
fprintf(f, "\n%svendid=0x%x\n", out_prefix ? out_prefix : "",
mad_get_field(node->info, 0, IB_NODE_VENDORID_F));
fprintf(f, "%sdevid=0x%x\n", out_prefix ? out_prefix : "",
mad_get_field(node->info, 0, IB_NODE_DEVID_F));
if (sysimgguid)
fprintf(f, "%ssysimgguid=0x%" PRIx64,
out_prefix ? out_prefix : "", sysimgguid);
if (group && node->chassis && node->chassis->chassisnum) {
fprintf(f, "\t\t# Chassis %d", node->chassis->chassisnum);
if (chname)
fprintf(f, " (%s)", clean_nodedesc(chname));
if (ibnd_is_xsigo_tca(node->guid) && node->ports[1] &&
node->ports[1]->remoteport)
fprintf(f, " slot %d",
node->ports[1]->remoteport->portnum);
}
if (sysimgguid ||
(group && node->chassis && node->chassis->chassisnum))
fprintf(f, "\n");
}
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);
}
static void getAllMCMemberRecords(AllocFunction alloc, void *allocUd,
int fd, int agent, UInt16 smLid,
SInt32 *numMRs, struct MCMemberRecord **MRs)
{
UInt8 umad[256];
UInt8 *buf = NULL;
SInt64 len;
SInt32 status;
SInt64 i, n;
SInt32 offset;
struct _MCMemberRecord *p;
const SInt32 timeout = 1000;
fillMAD_Get_MCMemberRecord(umad, sizeof(umad), smLid, 0, __LINE__);
libibumad_Send_MAD(fd, agent, umad, sizeof(umad), timeout, 0);
libibumad_Recv_MAD(alloc, allocUd, fd, &buf, &len, timeout);
status = mad_get_field(umad_get_mad(buf), 0, IB_MAD_STATUS_F);
if (UNLIKELY(0 != status)) {
FATAL("status is %d", status);
}
/* RMPP packets.
*/
offset = mad_get_field(umad_get_mad(buf), 0, IB_SA_ATTROFFS_F);
if (UNLIKELY(0 == offset)) {
FATAL("SA attribute offset is zero.");
}
n = (len - IB_SA_DATA_OFFS)/(offset << 3); /* offset is in 8 byte units */
*numMRs = n;
*MRs = alloc(allocUd, NULL, 0, (*numMRs)*sizeof(struct MCMemberRecord));
for (i = 0 ; i < n; ++i) {
p = (struct _MCMemberRecord *)((UInt8 *)umad_get_mad(buf) + IB_SA_DATA_OFFS + i*(offset << 3));
memcpy((*MRs)[i].mgid, p->mgid, 16);
memcpy((*MRs)[i].portGid, p->portGid, 16);
(*MRs)[i].qkey = ntoh32(p->qkey);
(*MRs)[i].mlid = ntoh16(p->mlid);
(*MRs)[i].mtu = p->mtu;
(*MRs)[i].tclass = p->tclass;
(*MRs)[i].pkey = ntoh16(p->pkey);
(*MRs)[i].rate = p->rate;
(*MRs)[i].packetLife = p->packetLife;
/* FIXME
(*MRs)[i].serviceLevel = p->serviceLevel;
(*MRs)[i].flowLabel = ntoh32(p->flowLabel);
(*MRs)[i].hopLimit = p->hopLimit;
*/
(*MRs)[i].scope = (p->scope_joinState & 0xf0) >> 4;
(*MRs)[i].joinState = p->scope_joinState & 0x0f;
(*MRs)[i].proxyJoin = p->proxyJoin;
}
buf = alloc(allocUd, buf, len, 0);
}
static int rereg_recv_all(int port, int agent, ib_portid_t * dport,
struct guid_trid *list, unsigned cnt)
{
uint8_t *umad, *mad;
int len = umad_size() + 256;
uint64_t trid;
unsigned n, method, status;
unsigned i;
info("rereg_recv_all...\n");
umad = calloc(1, len);
if (!umad) {
err("cannot alloc mem for umad: %s\n", strerror(errno));
return -1;
}
n = 0;
while (rereg_recv(port, agent, dport, umad, len, TMO) > 0) {
dbg("rereg_recv_all: done %d\n", n);
n++;
mad = umad_get_mad(umad);
method = mad_get_field(mad, 0, IB_MAD_METHOD_F);
status = mad_get_field(mad, 0, IB_MAD_STATUS_F);
if (status)
dbg("MAD status %x, method %x\n", status, method);
if (status &&
(method & 0x7f) == (IB_MAD_METHOD_GET_RESPONSE & 0x7f)) {
trid = mad_get_field64(mad, 0, IB_MAD_TRID_F);
for (i = 0; i < cnt; i++)
if (trid == list[i].trid)
break;
if (i == cnt) {
err("cannot find trid 0x%016" PRIx64 "\n",
trid);
continue;
}
info("guid 0x%016" PRIx64
": method = %x status = %x. Resending\n",
ntohll(list[i].guid), method, status);
rereg_port_gid(port, agent, dport, umad, len,
list[i].gid);
list[i].trid =
mad_get_field64(umad_get_mad(umad), 0,
IB_MAD_TRID_F);
}
}
info("rereg_recv_all: got %u responses\n", n);
free(umad);
return 0;
}
static int sim_ctl_get_vendor(Client * cl, struct sim_ctl * ctl)
{
struct sim_vendor *v = (void *)ctl->data;
v->vendor_id =
mad_get_field(cl->port->node->nodeinfo, 0, IB_NODE_VENDORID_F);
v->vendor_part_id =
mad_get_field(cl->port->node->nodeinfo, 0, IB_NODE_DEVID_F);
v->hw_ver =
mad_get_field(cl->port->node->nodeinfo, 0, IB_NODE_REVISION_F);
v->fw_ver = 1;
return 0;
}
static void getOneLinearForwardingTable(AllocFunction alloc, void *allocUd,
int fd, int agent, UInt16 smLid,
UInt16 lid, struct LinearForwardingTable *LFT)
{
UInt8 umad[256];
UInt8 *buf = NULL;
SInt64 len;
SInt32 status;
SInt64 i, n;
SInt32 j, offset;
struct _LinearForwardingTableRecord *p;
const SInt32 timeout = 1000;
/* Build the transaction id from the lid to ensure that we have unique transaction ids
* when looping over multiple lids.
*/
fillMAD_Get_LFTRecord(umad, sizeof(umad), smLid, lid, __LINE__ + lid);
libibumad_Send_MAD(fd, agent, umad, sizeof(umad), timeout, 0);
libibumad_Recv_MAD(alloc, allocUd, fd, &buf, &len, timeout);
status = mad_get_field(umad_get_mad(buf), 0, IB_MAD_STATUS_F);
if (UNLIKELY(0 != status)) {
FATAL("status is %d", status);
}
/* RMPP packets.
*/
offset = mad_get_field(umad_get_mad(buf), 0, IB_SA_ATTROFFS_F);
if (UNLIKELY(0 == offset)) {
FATAL("SA attribute offset is zero.");
}
n = (len - IB_SA_DATA_OFFS)/(offset << 3); /* offset is in 8 byte units */
LFT->len = 64*n;
LFT->lft = alloc(allocUd, NULL, 0, LFT->len*sizeof(UInt16));
for (i = 0 ; i < n; ++i) {
p = (struct _LinearForwardingTableRecord *)((UInt8 *)umad_get_mad(buf) + IB_SA_DATA_OFFS + i*(offset << 3));
LFT->lid = ntoh16(p->lid);
for (j = 0; j < 64; ++j) {
LFT->lft[64*ntoh16(p->block) + j] = p->lft[j];
}
}
buf = alloc(allocUd, buf, len, 0);
}
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 getAllNodeRecords(AllocFunction alloc, void *allocUd,
int fd, int agent, UInt16 smLid,
SInt32 *numNRs, struct NodeRecord **NRs)
{
UInt8 umad[256];
UInt8 *buf = NULL;
SInt64 len;
SInt32 status;
SInt64 i, n;
SInt32 offset;
struct _NodeRecord *p;
const SInt32 timeout = 1000;
fillMAD_Get_NodeRecord(umad, sizeof(umad), smLid, 0, __LINE__);
libibumad_Send_MAD(fd, agent, umad, sizeof(umad), timeout, 0);
libibumad_Recv_MAD(alloc, allocUd, fd, &buf, &len, timeout);
status = mad_get_field(umad_get_mad(buf), 0, IB_MAD_STATUS_F);
if (UNLIKELY(0 != status)) {
FATAL("status is %d", status);
}
/* RMPP packets.
*/
offset = mad_get_field(umad_get_mad(buf), 0, IB_SA_ATTROFFS_F);
if (UNLIKELY(0 == offset)) {
FATAL("SA attribute offset is zero.");
}
n = (len - IB_SA_DATA_OFFS)/(offset << 3); /* offset is in 8 byte units */
*numNRs = n;
*NRs = alloc(allocUd, NULL, 0, (*numNRs)*sizeof(struct NodeRecord));
for (i = 0 ; i < n; ++i) {
p = (struct _NodeRecord *)((UInt8 *)umad_get_mad(buf) + IB_SA_DATA_OFFS + i*(offset << 3));
(*NRs)[i].lid = ntoh16(p->lid);
(*NRs)[i].nodeType = p->nodeType;
(*NRs)[i].numPorts = p->numPorts;
(*NRs)[i].sysGuid = ntoh64(p->sysGuid);
(*NRs)[i].nodeGuid = ntoh64(p->nodeGuid);
(*NRs)[i].portGuid = ntoh64(p->portGuid);
memcpy((*NRs)[i].info, p->info, 64*sizeof(UInt8));
}
buf = alloc(allocUd, buf, len, 0);
}
static int server_respond(void *umad, int size)
{
ib_rpc_t rpc = { 0 };
ib_rmpp_hdr_t rmpp = { 0 };
ib_portid_t rport;
uint8_t *mad = umad_get_mad(umad);
ib_mad_addr_t *mad_addr;
if (!(mad_addr = umad_get_mad_addr(umad)))
return -1;
memset(&rport, 0, sizeof(rport));
rport.lid = ntohs(mad_addr->lid);
rport.qp = ntohl(mad_addr->qpn);
rport.qkey = ntohl(mad_addr->qkey);
rport.sl = mad_addr->sl;
if (!rport.qkey && rport.qp == 1)
rport.qkey = IB_DEFAULT_QP1_QKEY;
rpc.mgtclass = mad_get_field(mad, 0, IB_MAD_MGMTCLASS_F);
rpc.method = IB_MAD_METHOD_GET | IB_MAD_RESPONSE;
rpc.attr.id = mad_get_field(mad, 0, IB_MAD_ATTRID_F);
rpc.attr.mod = mad_get_field(mad, 0, IB_MAD_ATTRMOD_F);
rpc.oui = mad_get_field(mad, 0, IB_VEND2_OUI_F);
rpc.trid = mad_get_field64(mad, 0, IB_MAD_TRID_F);
if (size > IB_MAD_SIZE)
rmpp.flags = IB_RMPP_FLAG_ACTIVE;
DEBUG("responding %d bytes to %s, attr 0x%x mod 0x%x qkey %x",
size, portid2str(&rport), rpc.attr.id, rpc.attr.mod, rport.qkey);
if (mad_build_pkt(umad, &rpc, &rport, &rmpp, 0) < 0)
return -1;
if (ibdebug > 1)
xdump(stderr, "mad respond pkt\n", mad, IB_MAD_SIZE);
if (umad_send(mad_rpc_portid(srcport),
mad_rpc_class_agent(srcport, rpc.mgtclass), umad, size,
rpc.timeout, 0) < 0) {
DEBUG("send failed; %m");
return -1;
}
return 0;
}
static int recv_mlnx_ext_port_info(smp_engine_t * engine, ibnd_smp_t * smp,
uint8_t * mad, void *cb_data)
{
ibnd_fabric_t *fabric = ((ibnd_scan_t *) engine->user_data)->fabric;
ibnd_node_t *node = cb_data;
ibnd_port_t *port;
uint8_t *ext_port_info = mad + IB_SMP_DATA_OFFS;
uint8_t port_num, local_port;
port_num = (uint8_t) mad_get_field(mad, 0, IB_MAD_ATTRMOD_F);
port = node->ports[port_num];
if (!port) {
IBND_ERROR("Failed to find 0x%" PRIx64 " port %u\n",
node->guid, port_num);
return -1;
}
memcpy(port->ext_info, ext_port_info, sizeof(port->ext_info));
local_port = (uint8_t) mad_get_field(port->info, 0, IB_PORT_LOCAL_PORT_F);
debug_port(&smp->path, port);
if (port_num && mad_get_field(port->info, 0, IB_PORT_PHYS_STATE_F)
== IB_PORT_PHYS_STATE_LINKUP
&& ((node->type == IB_NODE_SWITCH && port_num != local_port) ||
(node == fabric->from_node && port_num == fabric->from_portnum))) {
int rc = 0;
ib_portid_t path = smp->path;
if (node->type != IB_NODE_SWITCH &&
node == fabric->from_node &&
path.drpath.cnt > 1)
rc = retract_dpath(engine, &path);
else {
/* we can't proceed through an HCA with DR */
if (path.lid == 0 || node->type == IB_NODE_SWITCH)
rc = extend_dpath(engine, &path, port_num);
}
if (rc > 0) {
struct ni_cbdata * cbdata = malloc(sizeof(*cbdata));
cbdata->node = node;
cbdata->port_num = port_num;
query_node_info(engine, &path, cbdata);
}
}
return 0;
}
static void getOneNodeRecord(AllocFunction alloc, void *allocUd,
int fd, int agent, UInt16 smLid,
UInt16 lid, struct NodeRecord *NR)
{
UInt8 umad[256];
UInt8 *buf = NULL;
SInt64 len;
SInt32 status;
SInt64 n;
SInt32 offset;
struct _NodeRecord *p;
const SInt32 timeout = 1000;
fillMAD_Get_NodeRecord(umad, sizeof(umad), smLid, lid, __LINE__ + lid);
libibumad_Send_MAD(fd, agent, umad, sizeof(umad), timeout, 0);
libibumad_Recv_MAD(alloc, allocUd, fd, &buf, &len, timeout);
status = mad_get_field(umad_get_mad(buf), 0, IB_MAD_STATUS_F);
if (UNLIKELY(0 != status)) {
FATAL("status is %d", status);
}
/* RMPP packets.
*/
offset = mad_get_field(umad_get_mad(buf), 0, IB_SA_ATTROFFS_F);
if (UNLIKELY(0 == offset)) {
FATAL("SA attribute offset is zero.");
}
n = (len - IB_SA_DATA_OFFS)/(offset << 3); /* offset is in 8 byte units */
if (UNLIKELY(1 != n)) {
FATAL("Expected one node record but found %d in answer", n);
}
p = (struct _NodeRecord *)((UInt8 *)umad_get_mad(buf) + IB_SA_DATA_OFFS + 0*(offset << 3));
NR->lid = ntoh16(p->lid);
NR->nodeType = p->nodeType;
NR->numPorts = p->numPorts;
NR->sysGuid = ntoh64(p->sysGuid);
NR->nodeGuid = ntoh64(p->nodeGuid);
NR->portGuid = ntoh64(p->portGuid);
memcpy(NR->info, p->info, 64*sizeof(UInt8));
buf = alloc(allocUd, buf, len, 0);
}
void leaveMCGroup(AllocFunction alloc, void *allocUd, char *CA, SInt16 port, UInt8 *mgid)
{
int fd, agent;
UInt16 smLid;
UInt8 umad[256];
SInt32 status;
SInt32 err;
UInt8 *buf = NULL;
SInt64 len;
UInt8 portGid[16];
setup(CA, port, &fd, &agent);
smLid = subnetManagerLocalIdentifier(CA, port);
err = portGlobalIdentifier(CA, port, 0, portGid);
if (UNLIKELY(0 != err)) {
FATAL("portGlobalIdentifier() failed.");
}
const SInt32 timeout = 1000;
fillMAD_Delete_MCMemberRecord(umad, sizeof(umad), smLid, 0, __LINE__, mgid, portGid);
libibumad_Send_MAD(fd, agent, umad, sizeof(umad), timeout, 0);
libibumad_Recv_MAD(alloc, allocUd, fd, &buf, &len, timeout);
status = mad_get_field(umad_get_mad(buf), 0, IB_MAD_STATUS_F);
if (UNLIKELY(0 != status)) {
FATAL("status is %d", status);
}
done(fd);
buf = alloc(allocUd, buf, len, 0);
}
static int sim_ctl_get_pkeys(Client * cl, struct sim_ctl * ctl)
{
Port *port = cl->port;
unsigned size = (port->node->sw && port->portnum) ?
mad_get_field(port->node->sw->switchinfo, 0,
IB_SW_PARTITION_ENFORCE_CAP_F) :
mad_get_field(port->node->nodeinfo, 0, IB_NODE_PARTITION_CAP_F);
size *= sizeof(port->pkey_tbl[0]);
if (size > sizeof(ctl->data))
size = sizeof(ctl->data);
memcpy(ctl->data, port->pkey_tbl, size);
if (size < sizeof(ctl->data))
memset(ctl->data + size, 0, sizeof(ctl->data) - size);
return 0;
}
char *ibnd_get_chassis_type(ibnd_node_t * node)
{
int chassis_type;
if (!node) {
IBND_DEBUG("node parameter NULL\n");
return NULL;
}
if (!node->chassis)
return NULL;
chassis_type = mad_get_field(node->info, 0, IB_NODE_VENDORID_F);
switch (chassis_type)
{
case VTR_VENDOR_ID: /* Voltaire chassis */
{
if (node->ch_type == UNRESOLVED_CT || node->ch_type > ISR4200_CT)
return NULL;
return ChassisTypeStr[node->ch_type];
}
case MLX_VENDOR_ID:
{
if (node->ch_type_str[0] == '\0')
return NULL;
return node->ch_type_str;
}
default:
{
break;
}
}
return NULL;
}
void *
mad_rpc_rmpp(const void *port_id, ib_rpc_t *rpc, ib_portid_t *dport,
ib_rmpp_hdr_t *rmpp, void *data)
{
const struct ibmad_port *p = port_id;
int status, len;
uint8_t sndbuf[1024], rcvbuf[1024], *mad;
memset(sndbuf, 0, umad_size() + IB_MAD_SIZE);
DEBUG("rmpp %p data %p", rmpp, data);
if ((len = mad_build_pkt(sndbuf, rpc, dport, rmpp, data)) < 0)
return 0;
if ((len = _do_madrpc(p->port_id, sndbuf, rcvbuf,
p->class_agents[rpc->mgtclass],
len, rpc->timeout)) < 0) {
IBWARN("_do_madrpc failed; dport (%s)", portid2str(dport));
return 0;
}
mad = umad_get_mad(rcvbuf);
if ((status = mad_get_field(mad, 0, IB_MAD_STATUS_F)) != 0) {
ERRS("MAD completed with error status 0x%x; dport (%s)",
status, portid2str(dport));
return 0;
}
if (ibdebug) {
IBWARN("data offs %d sz %d", rpc->dataoffs, rpc->datasz);
xdump(stderr, "rmpp mad data\n", mad + rpc->dataoffs,
rpc->datasz);
}
if (rmpp) {
rmpp->flags = mad_get_field(mad, 0, IB_SA_RMPP_FLAGS_F);
if ((rmpp->flags & 0x3) &&
mad_get_field(mad, 0, IB_SA_RMPP_VERS_F) != 1) {
IBWARN("bad rmpp version");
return 0;
}
rmpp->type = mad_get_field(mad, 0, IB_SA_RMPP_TYPE_F);
rmpp->status = mad_get_field(mad, 0, IB_SA_RMPP_STATUS_F);
DEBUG("rmpp type %d status %d", rmpp->type, rmpp->status);
rmpp->d1.u = mad_get_field(mad, 0, IB_SA_RMPP_D1_F);
rmpp->d2.u = mad_get_field(mad, 0, IB_SA_RMPP_D2_F);
}
if (data)
memcpy(data, mad + rpc->dataoffs, rpc->datasz);
rpc->recsz = mad_get_field(mad, 0, IB_SA_ATTROFFS_F);
return data;
}
static int rereg_query_all(int port, int agent, ib_portid_t * dport,
struct guid_trid *list, unsigned cnt)
{
uint8_t *umad, *mad;
int len = umad_size() + 256;
unsigned method, status;
unsigned i;
int ret;
info("rereg_query_all...\n");
umad = calloc(1, len);
if (!umad) {
err("cannot alloc mem for umad: %s\n", strerror(errno));
return -1;
}
for (i = 0; i < cnt; i++) {
ret = rereg_send(port, agent, dport, umad, len,
IB_MAD_METHOD_GET, list[i].gid);
if (ret < 0) {
err("query_all: rereg_send failed.\n");
continue;
}
ret = rereg_recv(port, agent, dport, umad, len, TMO);
if (ret < 0) {
err("query_all: rereg_recv failed.\n");
continue;
}
mad = umad_get_mad(umad);
method = mad_get_field(mad, 0, IB_MAD_METHOD_F);
status = mad_get_field(mad, 0, IB_MAD_STATUS_F);
if (status)
info("guid 0x%016" PRIx64 ": status %x, method %x\n",
ntohll(list[i].guid), status, method);
}
info("rereg_query_all: %u queried.\n", cnt);
free(umad);
return 0;
}
static void debug_port(ib_portid_t * portid, ibnd_port_t * port)
{
char width[64], speed[64];
int iwidth;
int ispeed, fdr10, espeed;
uint8_t *info;
uint32_t cap_mask;
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);
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;
IBND_DEBUG
("portid %s portnum %d: base lid %d state %d physstate %d %s %s %s %s\n",
portid2str(portid), port->portnum, port->base_lid,
mad_get_field(port->info, 0, IB_PORT_STATE_F),
mad_get_field(port->info, 0, IB_PORT_PHYS_STATE_F),
mad_dump_val(IB_PORT_LINK_WIDTH_ACTIVE_F, width, 64, &iwidth),
mad_dump_val(IB_PORT_LINK_SPEED_ACTIVE_F, speed, 64, &ispeed),
(fdr10 & FDR10) ? "FDR10" : "",
mad_dump_val(IB_PORT_LINK_SPEED_EXT_ACTIVE_F, speed, 64, &espeed));
}
static uint16_t get_node_type(ib_portid_t * port)
{
uint16_t node_type = IB_NODE_TYPE_CA;
uint8_t data[IB_SMP_DATA_SIZE] = { 0 };
if (smp_query_via(data, port, IB_ATTR_NODE_INFO, 0, 0, srcport))
node_type = (uint16_t) mad_get_field(data, 0, IB_NODE_TYPE_F);
return node_type;
}
static uint32_t get_cap_mask(ib_portid_t * port)
{
uint8_t data[IB_SMP_DATA_SIZE] = { 0 };
uint32_t cap_mask = 0;
if (smp_query_via(data, port, IB_ATTR_PORT_INFO, 0, 0, srcport))
cap_mask = (uint32_t) mad_get_field(data, 0, IB_PORT_CAPMASK_F);
return cap_mask;
}
static int is_mlnx_ext_port_info_supported(ibnd_port_t * port)
{
uint16_t devid = (uint16_t) mad_get_field(port->node->info, 0, IB_NODE_DEVID_F);
if (devid == 0xc738)
return 1;
if (devid >= 0x1003 && devid <= 0x1011)
return 1;
return 0;
}
static uint64_t get_chassisguid(ibnd_node_t * node)
{
uint32_t vendid = mad_get_field(node->info, 0, IB_NODE_VENDORID_F);
uint64_t sysimgguid =
mad_get_field64(node->info, 0, IB_NODE_SYSTEM_GUID_F);
if (vendid == TS_VENDOR_ID || vendid == SS_VENDOR_ID)
return topspin_chassisguid(sysimgguid);
else if (vendid == XS_VENDOR_ID || ibnd_is_xsigo_guid(sysimgguid))
return xsigo_chassisguid(node);
else
return sysimgguid;
}
/*
* Return 1 if node is a switch, else zero.
*/
static int get_node_info(ib_portid_t * dest, uint8_t * data)
{
int node_type;
if (!smp_query_via(data, dest, IB_ATTR_NODE_INFO, 0, 0, srcport))
IBEXIT("smp query nodeinfo failed");
node_type = mad_get_field(data, 0, IB_NODE_TYPE_F);
if (node_type == IB_NODE_SWITCH) /* Switch NodeType ? */
return 1;
else
return 0;
}
static int
get_node_info(ib_portid_t *dest, uint8_t *data)
{
int node_type;
if (!smp_query(data, dest, IB_ATTR_NODE_INFO, 0, 0))
return -1;
node_type = mad_get_field(data, 0, IB_NODE_TYPE_F);
if (node_type == IB_NODE_SWITCH) /* Switch NodeType ? */
return 0;
else
return 1;
}
static void set_issm(Port *port, unsigned issm)
{
uint32_t old_capmask, capmask;
capmask = mad_get_field(port->portinfo, 0, IB_PORT_CAPMASK_F);
old_capmask = capmask;
if (issm)
capmask |= CAPMASK_ISSM;
else
capmask &= ~CAPMASK_ISSM;
mad_set_field(port->portinfo, 0, IB_PORT_CAPMASK_F, capmask);
if (old_capmask != capmask && capmask&(CAPMASK_ISNOTICE|CAPMASK_ISTRAP)
&& capmask&CAPMASK_ISCAPMASKTRAP)
send_trap(port, TRAP_144);
}
static int get_port_info(ib_portid_t * dest, uint8_t * data, int portnum,
int is_switch)
{
uint8_t smp[IB_SMP_DATA_SIZE];
uint8_t *info;
int cap_mask;
if (is_switch) {
if (!smp_query_via(smp, dest, IB_ATTR_PORT_INFO, 0, 0, srcport))
IBEXIT("smp query port 0 portinfo failed");
info = smp;
} else
info = data;
if (!smp_query_via(data, dest, IB_ATTR_PORT_INFO, portnum, 0, srcport))
IBEXIT("smp query portinfo failed");
cap_mask = mad_get_field(info, 0, IB_PORT_CAPMASK_F);
return (cap_mask & CL_NTOH32(IB_PORT_CAP_HAS_EXT_SPEEDS));
}
void *
mad_rpc(const void *port_id, ib_rpc_t *rpc, ib_portid_t *dport, void *payload,
void *rcvdata)
{
const struct ibmad_port *p = port_id;
int status, len;
uint8_t sndbuf[1024], rcvbuf[1024], *mad;
len = 0;
memset(sndbuf, 0, umad_size() + IB_MAD_SIZE);
if ((len = mad_build_pkt(sndbuf, rpc, dport, 0, payload)) < 0)
return 0;
if ((len = _do_madrpc(p->port_id, sndbuf, rcvbuf,
p->class_agents[rpc->mgtclass],
len, rpc->timeout)) < 0) {
IBWARN("_do_madrpc failed; dport (%s)", portid2str(dport));
return 0;
}
mad = umad_get_mad(rcvbuf);
if ((status = mad_get_field(mad, 0, IB_DRSMP_STATUS_F)) != 0) {
ERRS("MAD completed with error status 0x%x; dport (%s)",
status, portid2str(dport));
return 0;
}
if (ibdebug) {
IBWARN("data offs %d sz %d", rpc->dataoffs, rpc->datasz);
xdump(stderr, "mad data\n", mad + rpc->dataoffs, rpc->datasz);
}
if (rcvdata)
memcpy(rcvdata, mad + rpc->dataoffs, rpc->datasz);
return rcvdata;
}
char *ibnd_get_chassis_slot_str(ibnd_node_t * node, char *str, size_t size)
{
int vendor_id;
if (!node) {
IBND_DEBUG("node parameter NULL\n");
return NULL;
}
/* Currently, only if Voltaire or Mellanox chassis */
vendor_id = mad_get_field(node->info, 0,IB_NODE_VENDORID_F);
if ((vendor_id != VTR_VENDOR_ID) && (vendor_id != MLX_VENDOR_ID))
return NULL;
if (!node->chassis)
return NULL;
if (node->ch_slot == UNRESOLVED_CS || node->ch_slot > SRBD_CS)
return NULL;
if (!str)
return NULL;
snprintf(str, size, "%s %d Chip %d", ChassisSlotTypeStr[node->ch_slot],
node->ch_slotnum, node->ch_anafanum);
return str;
}
static void getLIDFromGUID(AllocFunction alloc, void *allocUd,
int fd, int agent, UInt16 smLid, UInt64 guid, UInt16 *lid)
{
UInt8 umad[256];
UInt8 *buf = NULL;
SInt64 len;
SInt32 status;
const SInt32 timeout = 1000;
fillMAD_Get_PathRecord(umad, sizeof(umad), smLid, guid, __LINE__ + guid);
libibumad_Send_MAD(fd, agent, umad, sizeof(umad), timeout, 0);
libibumad_Recv_MAD(alloc, allocUd, fd, &buf, &len, timeout);
status = mad_get_field(umad_get_mad(buf), 0, IB_MAD_STATUS_F);
if (UNLIKELY(0 != status)) {
FATAL("status is %d", status);
}
mad_decode_field((UInt8 *)umad_get_mad(buf) + IB_SA_DATA_OFFS, IB_SA_PR_DLID_F, lid);
buf = alloc(allocUd, buf, len, 0);
}
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);
}
}
