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); } }