static void query_sm_info(cl_map_item_t * item, void *cxt)
{
osm_madw_context_t context;
osm_remote_sm_t *r_sm = cl_item_obj(item, r_sm, map_item);
osm_sm_t *sm = cxt;
ib_api_status_t ret;
osm_port_t *p_port;
p_port= osm_get_port_by_guid(sm->p_subn, r_sm->smi.guid);
if (p_port == NULL) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3340: "
"No port object on given sm object\n");
return;
}
context.smi_context.port_guid = r_sm->smi.guid;
context.smi_context.set_method = FALSE;
context.smi_context.light_sweep = TRUE;
ret = osm_req_get(sm, osm_physp_get_dr_path_ptr(p_port->p_physp),
IB_MAD_ATTR_SM_INFO, 0, CL_DISP_MSGID_NONE, &context);
if (ret != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3314: "
"Failure requesting SMInfo (%s)\n",
ib_get_err_str(ret));
}
ib_api_status_t osm_prtn_add_port(osm_log_t * p_log, osm_subn_t * p_subn,
osm_prtn_t * p, ib_net64_t guid,
boolean_t full, boolean_t indx0)
{
ib_api_status_t status = IB_SUCCESS;
cl_map_t *p_tbl;
osm_port_t *p_port;
osm_physp_t *p_physp;
p_port = osm_get_port_by_guid(p_subn, guid);
if (!p_port) {
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"port 0x%" PRIx64 " not found\n", cl_ntoh64(guid));
return status;
}
p_physp = p_port->p_physp;
if (!p_physp) {
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"no physical for port 0x%" PRIx64 "\n",
cl_ntoh64(guid));
return status;
}
/* Set the pkey to be inserted to block 0 index 0 */
if (indx0) {
OSM_LOG(p_log, OSM_LOG_VERBOSE, "Setting pkey 0x%04x at indx0 "
"for port 0x%" PRIx64 "\n",
cl_ntoh16(p->pkey), cl_ntoh64(guid));
osm_pkey_tbl_set_indx0_pkey(p_log, p->pkey, full,
&p_physp->pkeys);
} else if (ib_pkey_get_base(p_physp->pkeys.indx0_pkey) ==
ib_pkey_get_base(p->pkey))
p_physp->pkeys.indx0_pkey = 0;
p_tbl = (full == TRUE) ? &p->full_guid_tbl : &p->part_guid_tbl;
if (p_subn->opt.allow_both_pkeys) {
if (cl_map_remove(p_tbl, guid))
OSM_LOG(p_log, OSM_LOG_VERBOSE, "port 0x%" PRIx64
" already in partition \'%s\' (0x%04x) full %d."
" Will overwrite\n",
cl_ntoh64(guid), p->name, cl_ntoh16(p->pkey),
full);
} else {
if (cl_map_remove(&p->part_guid_tbl, guid) ||
cl_map_remove(&p->full_guid_tbl, guid))
OSM_LOG(p_log, OSM_LOG_VERBOSE, "port 0x%" PRIx64
" already in partition \'%s\' (0x%04x)."
" Will overwrite\n",
cl_ntoh64(guid), p->name, cl_ntoh16(p->pkey));
}
if (cl_map_insert(p_tbl, guid, p_physp) == NULL)
return IB_INSUFFICIENT_MEMORY;
return status;
}
/**********************************************************************
Returns true if the SM port is down.
The SM's port object must exist in the port_guid table.
**********************************************************************/
static boolean_t state_mgr_is_sm_port_down(IN osm_sm_t * sm)
{
ib_net64_t port_guid;
osm_port_t *p_port;
osm_physp_t *p_physp;
uint8_t state;
OSM_LOG_ENTER(sm->p_log);
port_guid = sm->p_subn->sm_port_guid;
/*
* If we don't know our own port guid yet, assume the port is down.
*/
if (port_guid == 0) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3308: "
"SM port GUID unknown\n");
state = IB_LINK_DOWN;
goto Exit;
}
CL_ASSERT(port_guid);
CL_PLOCK_ACQUIRE(sm->p_lock);
p_port = osm_get_port_by_guid(sm->p_subn, port_guid);
if (!p_port) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3309: "
"SM port with GUID:%016" PRIx64 " is unknown\n",
cl_ntoh64(port_guid));
state = IB_LINK_DOWN;
CL_PLOCK_RELEASE(sm->p_lock);
goto Exit;
}
p_physp = p_port->p_physp;
CL_ASSERT(p_physp);
if (p_port->p_node->sw &&
!ib_switch_info_is_enhanced_port0(&p_port->p_node->sw->switch_info))
state = IB_LINK_ACTIVE; /* base SP0 */
else
state = osm_physp_get_port_state(p_physp);
CL_PLOCK_RELEASE(sm->p_lock);
Exit:
OSM_LOG_EXIT(sm->p_log);
return (state == IB_LINK_DOWN);
}
static void sm_state_mgr_send_master_sm_info_req(osm_sm_t * sm)
{
osm_madw_context_t context;
const osm_port_t *p_port;
ib_api_status_t status;
OSM_LOG_ENTER(sm->p_log);
memset(&context, 0, sizeof(context));
if (sm->p_subn->sm_state == IB_SMINFO_STATE_STANDBY) {
/*
* We are in STANDBY state - this means we need to poll the
* master SM (according to master_guid).
* Send a query of SubnGet(SMInfo) to the subn
* master_sm_base_lid object.
*/
p_port = osm_get_port_by_guid(sm->p_subn, sm->master_sm_guid);
} else {
/*
* We are not in STANDBY - this means we are in MASTER state -
* so we need to poll the SM that is saved in p_polling_sm
* under sm.
* Send a query of SubnGet(SMInfo) to that SM.
*/
p_port = sm->p_polling_sm->p_port;
}
if (p_port == NULL) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3203: "
"No port object for GUID 0x%016" PRIx64 "\n",
cl_ntoh64(sm->master_sm_guid));
goto Exit;
}
context.smi_context.port_guid = p_port->guid;
context.smi_context.set_method = FALSE;
status = osm_req_get(sm, osm_physp_get_dr_path_ptr(p_port->p_physp),
IB_MAD_ATTR_SM_INFO, 0, CL_DISP_MSGID_NONE,
&context);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3204: "
"Failure requesting SMInfo (%s)\n",
ib_get_err_str(status));
Exit:
OSM_LOG_EXIT(sm->p_log);
}
static void sa_smir_by_comp_mask(IN osm_sa_t * sa,
IN const osm_remote_sm_t * p_rem_sm,
osm_smir_search_ctxt_t * p_ctxt)
{
const ib_sminfo_record_t *const p_rcvd_rec = p_ctxt->p_rcvd_rec;
const osm_physp_t *const p_req_physp = p_ctxt->p_req_physp;
ib_net64_t const comp_mask = p_ctxt->comp_mask;
osm_port_t *p_port;
OSM_LOG_ENTER(sa->p_log);
if (comp_mask & IB_SMIR_COMPMASK_GUID) {
if (p_rem_sm->smi.guid != p_rcvd_rec->sm_info.guid)
goto Exit;
}
if (comp_mask & IB_SMIR_COMPMASK_PRIORITY) {
if (ib_sminfo_get_priority(&p_rem_sm->smi) !=
ib_sminfo_get_priority(&p_rcvd_rec->sm_info))
goto Exit;
}
if (comp_mask & IB_SMIR_COMPMASK_SMSTATE) {
if (ib_sminfo_get_state(&p_rem_sm->smi) !=
ib_sminfo_get_state(&p_rcvd_rec->sm_info))
goto Exit;
}
/* Implement any other needed search cases */
p_port = osm_get_port_by_guid(sa->p_subn, p_rem_sm->smi.guid);
if (p_port == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2810: "
"No port for remote sm\n");
goto Exit;
}
smir_rcv_new_smir(sa, p_port, p_ctxt->p_list,
p_rem_sm->smi.guid, p_rem_sm->smi.act_count,
p_rem_sm->smi.pri_state, p_req_physp);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
static uint16_t remap_lid(osm_opensm_t * p_osm, uint16_t lid, ib_net64_t guid)
{
osm_port_t *p_port;
uint16_t min_lid, max_lid;
uint8_t lmc;
p_port = osm_get_port_by_guid(&p_osm->subn, guid);
if (!p_port) {
OSM_LOG(&p_osm->log, OSM_LOG_VERBOSE,
"cannot find port guid 0x%016" PRIx64
" , will use the same lid\n", cl_ntoh64(guid));
return lid;
}
osm_port_get_lid_range_ho(p_port, &min_lid, &max_lid);
if (min_lid <= lid && lid <= max_lid)
return lid;
lmc = osm_port_get_lmc(p_port);
return min_lid + (lid & ((1 << lmc) - 1));
}
static void add_sw_endports_to_order_list(osm_switch_t * sw,
osm_ucast_mgr_t * m)
{
osm_port_t *port;
osm_physp_t *p;
int i;
for (i = 1; i < sw->num_ports; i++) {
p = osm_node_get_physp_ptr(sw->p_node, i);
if (p && p->p_remote_physp && !p->p_remote_physp->p_node->sw) {
port = osm_get_port_by_guid(m->p_subn,
p->p_remote_physp->
port_guid);
if (!port)
continue;
cl_qlist_insert_tail(&m->port_order_list,
&port->list_item);
port->flag = 1;
}
}
}
static int add_guid_to_order_list(void *ctx, uint64_t guid, char *p)
{
osm_ucast_mgr_t *m = ctx;
osm_port_t *port = osm_get_port_by_guid(m->p_subn, cl_hton64(guid));
if (!port) {
OSM_LOG(m->p_log, OSM_LOG_DEBUG,
"port guid not found: 0x%016" PRIx64 "\n", guid);
return 0;
}
if (port->flag) {
OSM_LOG(m->p_log, OSM_LOG_DEBUG,
"port guid specified multiple times 0x%016" PRIx64 "\n",
guid);
return 0;
}
cl_qlist_insert_tail(&m->port_order_list, &port->list_item);
port->flag = 1;
return 0;
}
void osm_smir_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *sad_mad;
const ib_sminfo_record_t *p_rcvd_rec;
const osm_port_t *p_port = NULL;
const ib_sm_info_t *p_smi;
cl_qlist_t rec_list;
osm_smir_search_ctxt_t context;
ib_api_status_t status = IB_SUCCESS;
ib_net64_t comp_mask;
ib_net64_t port_guid;
osm_physp_t *p_req_physp;
osm_port_t *local_port;
osm_remote_sm_t *p_rem_sm;
cl_qmap_t *p_sm_guid_tbl;
uint8_t pri_state;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
sad_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec = (ib_sminfo_record_t *) ib_sa_mad_get_payload_ptr(sad_mad);
comp_mask = sad_mad->comp_mask;
CL_ASSERT(sad_mad->attr_id == IB_MAD_ATTR_SMINFO_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (sad_mad->method != IB_MAD_METHOD_GET &&
sad_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2804: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(sad_mad->method));
osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
goto Exit;
}
/* update the requester physical port */
p_req_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
osm_madw_get_mad_addr_ptr
(p_madw));
if (p_req_physp == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2803: "
"Cannot find requester physical port\n");
goto Exit;
}
if (OSM_LOG_IS_ACTIVE_V2(sa->p_log, OSM_LOG_DEBUG)) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Requester port GUID 0x%" PRIx64 "\n",
cl_ntoh64(osm_physp_get_port_guid(p_req_physp)));
osm_dump_sm_info_record_v2(sa->p_log, p_rcvd_rec, FILE_ID, OSM_LOG_DEBUG);
}
p_smi = &p_rcvd_rec->sm_info;
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = sad_mad->comp_mask;
context.sa = sa;
context.p_req_physp = p_req_physp;
cl_plock_acquire(sa->p_lock);
/*
If the user specified a LID, it obviously narrows our
work load, since we don't have to search every port
*/
if (comp_mask & IB_SMIR_COMPMASK_LID) {
p_port = osm_get_port_by_lid(sa->p_subn, p_rcvd_rec->lid);
if (!p_port) {
status = IB_NOT_FOUND;
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2806: "
"No port found with LID %u\n",
cl_ntoh16(p_rcvd_rec->lid));
}
}
if (status == IB_SUCCESS) {
/* Handle our own SM first */
local_port = osm_get_port_by_guid(sa->p_subn,
sa->p_subn->sm_port_guid);
if (!local_port) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2809: "
"No port found with GUID 0x%016" PRIx64 "\n",
cl_ntoh64(sa->p_subn->sm_port_guid));
goto Exit;
}
if (!p_port || local_port == p_port) {
if (FALSE ==
osm_physp_share_pkey(sa->p_log, p_req_physp,
local_port->p_physp,
sa->p_subn->opt.allow_both_pkeys)) {
cl_plock_release(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2805: "
"Cannot get SMInfo record due to pkey violation\n");
goto Exit;
}
/* Check that other search components specified match */
if ((comp_mask & IB_SMIR_COMPMASK_GUID) &&
sa->p_subn->sm_port_guid != p_smi->guid)
goto Remotes;
if ((comp_mask & IB_SMIR_COMPMASK_PRIORITY) &&
sa->p_subn->opt.sm_priority !=
ib_sminfo_get_priority(p_smi))
goto Remotes;
if ((comp_mask & IB_SMIR_COMPMASK_SMSTATE) &&
sa->p_subn->sm_state != ib_sminfo_get_state(p_smi))
goto Remotes;
/* Now, add local SMInfo to list */
pri_state = sa->p_subn->sm_state & 0x0F;
pri_state |= (sa->p_subn->opt.sm_priority & 0x0F) << 4;
smir_rcv_new_smir(sa, local_port, context.p_list,
sa->p_subn->sm_port_guid,
cl_ntoh32(sa->p_subn->p_osm->stats.
qp0_mads_sent), pri_state,
p_req_physp);
}
Remotes:
if (p_port && p_port != local_port) {
/* Find remote SM corresponding to p_port */
port_guid = osm_port_get_guid(p_port);
p_sm_guid_tbl = &sa->p_subn->sm_guid_tbl;
p_rem_sm =
(osm_remote_sm_t *) cl_qmap_get(p_sm_guid_tbl,
port_guid);
if (p_rem_sm !=
(osm_remote_sm_t *) cl_qmap_end(p_sm_guid_tbl))
sa_smir_by_comp_mask(sa, p_rem_sm, &context);
else
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 280A: "
"No remote SM for GUID 0x%016" PRIx64
"\n", cl_ntoh64(port_guid));
} else {
/* Go over all other known (remote) SMs */
cl_qmap_apply_func(&sa->p_subn->sm_guid_tbl,
sa_smir_by_comp_mask_cb, &context);
}
}
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_sminfo_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
int osm_send_trap144(osm_sm_t * sm, ib_net16_t local)
{
osm_madw_t *madw;
ib_smp_t *smp;
ib_mad_notice_attr_t *ntc;
osm_port_t *port, *smport;
ib_port_info_t *pi;
port = osm_get_port_by_guid(sm->p_subn, sm->p_subn->sm_port_guid);
if (!port) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR,
"ERR 1104: cannot find SM port by guid 0x%" PRIx64 "\n",
cl_ntoh64(sm->p_subn->sm_port_guid));
return -1;
}
pi = &port->p_physp->port_info;
/* don't bother with sending trap when SMA supports this */
if (!local &&
pi->capability_mask&(IB_PORT_CAP_HAS_TRAP|IB_PORT_CAP_HAS_CAP_NTC))
return 0;
smport = osm_get_port_by_guid(sm->p_subn, sm->master_sm_guid);
if (!smport) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR,
"ERR 1106: cannot find master SM port by guid 0x%" PRIx64 "\n",
cl_ntoh64(sm->master_sm_guid));
return -1;
}
madw = osm_mad_pool_get(sm->p_mad_pool,
osm_sm_mad_ctrl_get_bind_handle(&sm->mad_ctrl),
MAD_BLOCK_SIZE, NULL);
if (madw == NULL) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR,
"ERR 1105: Unable to acquire MAD\n");
return -1;
}
madw->mad_addr.dest_lid = smport->p_physp->port_info.base_lid;
madw->mad_addr.addr_type.smi.source_lid = pi->base_lid;
madw->resp_expected = TRUE;
madw->fail_msg = CL_DISP_MSGID_NONE;
smp = osm_madw_get_smp_ptr(madw);
memset(smp, 0, sizeof(*smp));
smp->base_ver = 1;
smp->mgmt_class = IB_MCLASS_SUBN_LID;
smp->class_ver = 1;
smp->method = IB_MAD_METHOD_TRAP;
smp->trans_id = cl_hton64((uint64_t) cl_atomic_inc(&sm->sm_trans_id)
& (uint64_t)(0xFFFFFFFF));
if (smp->trans_id == 0)
smp->trans_id = cl_hton64((uint64_t) cl_atomic_inc(&sm->sm_trans_id)
& (uint64_t)(0xFFFFFFFF));
smp->attr_id = IB_MAD_ATTR_NOTICE;
ntc = (ib_mad_notice_attr_t *) smp->data;
ntc->generic_type = 0x80 | IB_NOTICE_TYPE_INFO;
ib_notice_set_prod_type_ho(ntc, osm_node_get_type(port->p_node));
ntc->g_or_v.generic.trap_num = cl_hton16(SM_LOCAL_CHANGES_TRAP); /* 144 */
ntc->issuer_lid = pi->base_lid;
ntc->data_details.ntc_144.lid = pi->base_lid;
ntc->data_details.ntc_144.local_changes = local ?
TRAP_144_MASK_OTHER_LOCAL_CHANGES : 0;
ntc->data_details.ntc_144.new_cap_mask = pi->capability_mask;
ntc->data_details.ntc_144.change_flgs = local;
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Sending Trap 144, TID 0x%" PRIx64 " to SM lid %u\n",
cl_ntoh64(smp->trans_id), cl_ntoh16(madw->mad_addr.dest_lid));
osm_vl15_post(sm->p_vl15, madw);
return 0;
}
/**********************************************************************
o13-14.1.1: Except for Set(InformInfo) requests with Inform-
Info:LIDRangeBegin=0xFFFF, managers that support event forwarding
shall, upon receiving a Set(InformInfo), verify that the requester
originating the Set(InformInfo) and a Trap() source identified by Inform-
can access each other - can use path record to verify that.
**********************************************************************/
static boolean_t
__validate_ports_access_rights(IN osm_sa_t * sa,
IN osm_infr_t * p_infr_rec)
{
boolean_t valid = TRUE;
osm_physp_t *p_requester_physp;
osm_port_t *p_port;
osm_physp_t *p_physp;
ib_net64_t portguid;
ib_net16_t lid_range_begin;
ib_net16_t lid_range_end;
ib_net16_t lid;
const cl_ptr_vector_t *p_tbl;
ib_gid_t zero_gid;
OSM_LOG_ENTER(sa->p_log);
/* get the requester physp from the request address */
p_requester_physp = osm_get_physp_by_mad_addr(sa->p_log, sa->p_subn,
&p_infr_rec->report_addr);
memset(&zero_gid, 0, sizeof(zero_gid));
if (memcmp(&(p_infr_rec->inform_record.inform_info.gid),
&zero_gid, sizeof(ib_gid_t))) {
/* a gid is defined */
portguid =
p_infr_rec->inform_record.inform_info.gid.unicast.
interface_id;
p_port = osm_get_port_by_guid(sa->p_subn, portguid);
if (p_port == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4301: "
"Invalid port guid: 0x%016" PRIx64 "\n",
cl_ntoh64(portguid));
valid = FALSE;
goto Exit;
}
/* get the destination InformInfo physical port */
p_physp = p_port->p_physp;
/* make sure that the requester and destination port can access each other
according to the current partitioning. */
if (!osm_physp_share_pkey
(sa->p_log, p_physp, p_requester_physp)) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"port and requester don't share pkey\n");
valid = FALSE;
goto Exit;
}
} else {
/* gid is zero - check if LID range is defined */
lid_range_begin =
cl_ntoh16(p_infr_rec->inform_record.inform_info.
lid_range_begin);
/* if lid is 0xFFFF - meaning all endports managed by the manager */
if (lid_range_begin == 0xFFFF)
goto Exit;
lid_range_end =
cl_ntoh16(p_infr_rec->inform_record.inform_info.
lid_range_end);
/* lid_range_end is set to zero if no range desired. In this case -
just make it equal to the lid_range_begin. */
if (lid_range_end == 0)
lid_range_end = lid_range_begin;
/* go over all defined lids within the range and make sure that the
requester port can access them according to current partitioning. */
for (lid = lid_range_begin; lid <= lid_range_end; lid++) {
p_tbl = &sa->p_subn->port_lid_tbl;
if (cl_ptr_vector_get_size(p_tbl) > lid)
p_port = cl_ptr_vector_get(p_tbl, lid);
else {
/* lid requested is out of range */
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4302: "
"Given LID (%u) is out of range:%u\n",
lid, cl_ptr_vector_get_size(p_tbl));
valid = FALSE;
goto Exit;
}
if (p_port == NULL)
continue;
p_physp = p_port->p_physp;
/* make sure that the requester and destination port can access
each other according to the current partitioning. */
if (!osm_physp_share_pkey
(sa->p_log, p_physp, p_requester_physp)) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"port and requester don't share pkey\n");
valid = FALSE;
goto Exit;
}
}
}
Exit:
OSM_LOG_EXIT(sa->p_log);
return valid;
}
static void lftr_rcv_by_comp_mask(IN cl_map_item_t * p_map_item, IN void *cxt)
{
const osm_lftr_search_ctxt_t *p_ctxt = cxt;
const osm_switch_t *p_sw = (osm_switch_t *) p_map_item;
const ib_lft_record_t *const p_rcvd_rec = p_ctxt->p_rcvd_rec;
osm_sa_t *sa = p_ctxt->sa;
ib_net64_t const comp_mask = p_ctxt->comp_mask;
const osm_physp_t *const p_req_physp = p_ctxt->p_req_physp;
osm_port_t *p_port;
uint16_t min_lid_ho, max_lid_ho;
uint16_t min_block, max_block, block;
const osm_physp_t *p_physp;
/* In switches, the port guid is the node guid. */
p_port = osm_get_port_by_guid(sa->p_subn,
p_sw->p_node->node_info.port_guid);
if (!p_port) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4405: "
"Failed to find Port by Node Guid:0x%016" PRIx64
"\n", cl_ntoh64(p_sw->p_node->node_info.node_guid));
return;
}
/* check that the requester physp and the current physp are under
the same partition. */
p_physp = p_port->p_physp;
if (!p_physp) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4406: "
"Failed to find default physical Port by Node Guid:0x%016"
PRIx64 "\n",
cl_ntoh64(p_sw->p_node->node_info.node_guid));
return;
}
if (!osm_physp_share_pkey(sa->p_log, p_req_physp,
p_physp, sa->p_subn->opt.allow_both_pkeys))
return;
/* get the port 0 of the switch */
osm_port_get_lid_range_ho(p_port, &min_lid_ho, &max_lid_ho);
/* compare the lids - if required */
if (comp_mask & IB_LFTR_COMPMASK_LID) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Comparing lid:%u to port lid range: %u .. %u\n",
cl_ntoh16(p_rcvd_rec->lid), min_lid_ho, max_lid_ho);
/* ok we are ready for range check */
if (min_lid_ho > cl_ntoh16(p_rcvd_rec->lid) ||
max_lid_ho < cl_ntoh16(p_rcvd_rec->lid))
return;
}
/* now we need to decide which blocks to output */
max_block = osm_switch_get_max_block_id_in_use(p_sw);
if (comp_mask & IB_LFTR_COMPMASK_BLOCK) {
min_block = cl_ntoh16(p_rcvd_rec->block_num);
if (min_block > max_block)
return;
max_block = min_block;
} else /* use as many blocks as "in use" */
min_block = 0;
/* so we can add these blocks one by one ... */
for (block = min_block; block <= max_block; block++)
lftr_rcv_new_lftr(sa, p_sw, p_ctxt->p_list,
osm_port_get_base_lid(p_port), block);
}
void osm_pi_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_port_info_t *p_pi;
ib_smp_t *p_smp;
osm_port_t *p_port;
osm_physp_t *p_physp;
osm_dr_path_t *p_dr_path;
osm_node_t *p_node;
osm_pi_context_t *p_context;
ib_net64_t port_guid, node_guid;
uint8_t port_num;
CL_ASSERT(sm);
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_context = osm_madw_get_pi_context_ptr(p_madw);
p_pi = ib_smp_get_payload_ptr(p_smp);
CL_ASSERT(p_smp->attr_id == IB_MAD_ATTR_PORT_INFO);
/*
* Attribute modifier has already been validated upon MAD receive,
* which means that port_num has to be valid - it originated from
* the request attribute modifier.
*/
port_num = (uint8_t) cl_ntoh32(p_smp->attr_mod);
port_guid = p_context->port_guid;
node_guid = p_context->node_guid;
osm_dump_port_info_v2(sm->p_log, node_guid, port_guid, port_num, p_pi,
FILE_ID, OSM_LOG_DEBUG);
/* On receipt of client reregister, clear the reregister bit so
reregistering won't be sent again and again */
if (p_context->set_method &&
(ib_port_info_get_client_rereg(p_pi) || p_context->client_rereg)) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Client reregister received on response\n");
ib_port_info_set_client_rereg(p_pi, 0);
p_context->client_rereg = FALSE;
}
/*
we might get a response during a light sweep looking for a change in
the status of a remote port that did not respond in earlier sweeps.
So if the context of the Get was light_sweep - we do not need to
do anything with the response - just flag that we need a heavy sweep
*/
if (p_context->light_sweep == TRUE) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Got light sweep response from remote port of parent node "
"GUID 0x%" PRIx64 " port 0x%016" PRIx64
", Commencing heavy sweep\n",
cl_ntoh64(node_guid), cl_ntoh64(port_guid));
sm->p_subn->force_heavy_sweep = TRUE;
sm->p_subn->ignore_existing_lfts = TRUE;
goto Exit;
}
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_port = osm_get_port_by_guid(sm->p_subn, port_guid);
if (PF(!p_port)) {
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F06: "
"No port object for port with GUID 0x%" PRIx64
"\n\t\t\t\tfor parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
goto Exit;
}
p_node = p_port->p_node;
CL_ASSERT(p_node);
if (PF(p_pi->local_port_num > p_node->node_info.num_ports)) {
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F15: "
"Received PortInfo for port GUID 0x%" PRIx64 " is "
"non-compliant and is being ignored since the "
"local port num %u > num ports %u\n",
cl_ntoh64(port_guid), p_pi->local_port_num,
p_node->node_info.num_ports);
goto Exit;
}
/*
If we were setting the PortInfo, then receiving
this attribute was not part of sweeping the subnet.
In this case, just update the PortInfo attribute.
In an unfortunate blunder, the IB spec defines the
return method for Set() as a GetResp(). Thus, we can't
use the method (what would have been SetResp()) to determine
our course of action. So, we have to carry this extra
boolean around to determine if we were doing Get() or Set().
*/
if (p_context->set_method)
pi_rcv_process_set(sm, p_node, port_num, p_madw);
else {
/*
This PortInfo arrived because we did a Get() method,
most likely due to a subnet sweep in progress.
*/
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Discovered port num %u with GUID 0x%" PRIx64
" for parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
port_num, cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
p_physp = osm_node_get_physp_ptr(p_node, port_num);
CL_ASSERT(p_physp);
/* Update the directed route path to this port
in case the old path is no longer usable. */
p_dr_path = osm_physp_get_dr_path_ptr(p_physp);
osm_dr_path_init(p_dr_path, p_smp->hop_count,
p_smp->initial_path);
p_physp->need_update = osm_pi_rcv_update_self(sm, p_physp, p_pi);
switch (osm_node_get_type(p_node)) {
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_ROUTER:
if (!p_node->physp_discovered[port_num]) {
p_port->discovery_count++;
p_node->physp_discovered[port_num] = 1;
}
p_physp->need_update = osm_pi_rcv_update_neighbor(p_physp);
pi_rcv_process_ca_or_router_port(sm, p_node, p_physp,
p_pi);
break;
case IB_NODE_TYPE_SWITCH:
if (!p_node->physp_discovered[port_num]) {
p_port->discovery_count++;
p_node->physp_discovered[port_num] = 1;
}
if (port_num == 0)
pi_rcv_process_switch_port0(sm, p_node,
p_physp, p_pi);
else
pi_rcv_process_switch_ext_port(sm, p_node,
p_physp, p_pi);
break;
default:
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F07: "
"Unknown node type %u with GUID 0x%" PRIx64
"\n", osm_node_get_type(p_node),
cl_ntoh64(node_guid));
break;
}
/*
Get the tables on the physp.
*/
if (p_physp->need_update || (p_node->sw &&
p_node->sw->need_update))
pi_rcv_get_pkey_slvl_vla_tables(sm, p_node, p_physp);
}
CL_PLOCK_RELEASE(sm->p_lock);
Exit:
/*
Release the lock before jumping here!!
*/
OSM_LOG_EXIT(sm->p_log);
}
static void
__osm_mftr_rcv_by_comp_mask(IN cl_map_item_t * const p_map_item,
IN void *context)
{
const osm_mftr_search_ctxt_t *const p_ctxt =
(osm_mftr_search_ctxt_t *) context;
osm_switch_t *const p_sw = (osm_switch_t *) p_map_item;
const ib_mft_record_t *const p_rcvd_rec = p_ctxt->p_rcvd_rec;
osm_sa_t *sa = p_ctxt->sa;
ib_net64_t const comp_mask = p_ctxt->comp_mask;
const osm_physp_t *const p_req_physp = p_ctxt->p_req_physp;
osm_port_t *p_port;
uint16_t min_lid_ho, max_lid_ho;
uint16_t position_block_num_ho;
uint16_t min_block, max_block, block;
const osm_physp_t *p_physp;
uint8_t min_position, max_position, position;
/* In switches, the port guid is the node guid. */
p_port =
osm_get_port_by_guid(sa->p_subn, p_sw->p_node->node_info.port_guid);
if (!p_port) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4A05: "
"Failed to find Port by Node Guid:0x%016" PRIx64
"\n", cl_ntoh64(p_sw->p_node->node_info.node_guid));
return;
}
/* check that the requester physp and the current physp are under
the same partition. */
p_physp = p_port->p_physp;
if (!p_physp) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4A06: "
"Failed to find default physical Port by Node Guid:0x%016"
PRIx64 "\n",
cl_ntoh64(p_sw->p_node->node_info.node_guid));
return;
}
if (!osm_physp_share_pkey(sa->p_log, p_req_physp, p_physp))
return;
/* get the port 0 of the switch */
osm_port_get_lid_range_ho(p_port, &min_lid_ho, &max_lid_ho);
/* compare the lids - if required */
if (comp_mask & IB_MFTR_COMPMASK_LID) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Comparing lid:%u to port lid range: %u .. %u\n",
cl_ntoh16(p_rcvd_rec->lid), min_lid_ho, max_lid_ho);
/* ok we are ready for range check */
if (min_lid_ho > cl_ntoh16(p_rcvd_rec->lid) ||
max_lid_ho < cl_ntoh16(p_rcvd_rec->lid))
return;
}
if (!osm_switch_supports_mcast(p_sw))
return;
/* Are there any blocks in use ? */
if (osm_switch_get_mft_max_block_in_use(p_sw) == -1)
return;
position_block_num_ho = cl_ntoh16(p_rcvd_rec->position_block_num);
/* now we need to decide which blocks to output */
if (comp_mask & IB_MFTR_COMPMASK_BLOCK) {
max_block = min_block =
position_block_num_ho & IB_MCAST_BLOCK_ID_MASK_HO;
if (max_block > osm_switch_get_mft_max_block_in_use(p_sw))
return;
} else {
/* use as many blocks as needed */
min_block = 0;
max_block = osm_switch_get_mft_max_block_in_use(p_sw);
}
/* need to decide which positions to output */
if (comp_mask & IB_MFTR_COMPMASK_POSITION) {
min_position = max_position =
(position_block_num_ho & 0xF000) >> 12;
if (max_position > osm_switch_get_mft_max_position(p_sw))
return;
} else {
/**********************************************************************
* Send SubnSet(SMInfo) SMP with HANDOVER attribute to the
* remote_sm indicated.
**********************************************************************/
static void state_mgr_send_handover(IN osm_sm_t * sm, IN osm_remote_sm_t * p_sm)
{
uint8_t payload[IB_SMP_DATA_SIZE];
ib_sm_info_t *p_smi = (ib_sm_info_t *) payload;
osm_madw_context_t context;
const osm_port_t *p_port;
ib_api_status_t status;
OSM_LOG_ENTER(sm->p_log);
/*
* Send a query of SubnSet(SMInfo) HANDOVER to the remote sm given.
*/
memset(&context, 0, sizeof(context));
p_port = osm_get_port_by_guid(sm->p_subn, p_sm->smi.guid);
if (p_port == NULL) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3316: "
"No port object on given remote_sm object\n");
goto Exit;
}
/* update the master_guid in the sm_state_mgr object according to */
/* the guid of the port where the new Master SM should reside. */
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Handing over mastership. Updating sm_state_mgr master_guid: %016"
PRIx64 " (node %s)\n", cl_ntoh64(p_port->guid),
p_port->p_node ? p_port->p_node->print_desc : "UNKNOWN");
sm->master_sm_guid = p_port->guid;
context.smi_context.port_guid = p_port->guid;
context.smi_context.set_method = TRUE;
p_smi->guid = sm->p_subn->sm_port_guid;
p_smi->act_count = cl_hton32(sm->p_subn->p_osm->stats.qp0_mads_sent);
p_smi->pri_state = (uint8_t) (sm->p_subn->sm_state |
sm->p_subn->opt.sm_priority << 4);
/*
* Return 0 for the SM key unless we authenticate the requester
* as the master SM.
*/
if (ib_sminfo_get_state(&p_sm->smi) == IB_SMINFO_STATE_MASTER) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Responding to master SM with real sm_key\n");
p_smi->sm_key = sm->p_subn->opt.sm_key;
} else {
/* The requester is not authenticated as master - set sm_key to zero */
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Responding to SM not master with zero sm_key\n");
p_smi->sm_key = 0;
}
CL_PLOCK_ACQUIRE(sm->p_lock);
status = osm_req_set(sm, osm_physp_get_dr_path_ptr(p_port->p_physp),
payload, sizeof(payload), IB_MAD_ATTR_SM_INFO,
IB_SMINFO_ATTR_MOD_HANDOVER, CL_DISP_MSGID_NONE,
&context);
CL_PLOCK_RELEASE(sm->p_lock);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3317: "
"Failure requesting SMInfo (%s)\n",
ib_get_err_str(status));
Exit:
OSM_LOG_EXIT(sm->p_log);
}
/**********************************************************************
The plock must be held before calling this function.
**********************************************************************/
static ib_net64_t req_determine_mkey(IN osm_sm_t * sm,
IN const osm_dr_path_t * p_path)
{
osm_node_t *p_node;
osm_port_t *p_sm_port;
osm_physp_t *p_physp;
ib_net64_t dest_port_guid = 0, m_key;
uint8_t hop;
OSM_LOG_ENTER(sm->p_log);
p_physp = NULL;
p_sm_port = osm_get_port_by_guid(sm->p_subn, sm->p_subn->sm_port_guid);
/* hop_count == 0: destination port guid is SM */
if (p_path->hop_count == 0) {
dest_port_guid = sm->p_subn->sm_port_guid;
goto Remote_Guid;
}
if (p_sm_port) {
p_node = p_sm_port->p_node;
if (osm_node_get_type(p_node) == IB_NODE_TYPE_SWITCH)
p_physp = osm_node_get_physp_ptr(p_node, p_path->path[1]);
else
p_physp = p_sm_port->p_physp;
}
/* hop_count == 1: outgoing physp is SM physp */
for (hop = 2; p_physp && hop <= p_path->hop_count; hop++) {
p_physp = p_physp->p_remote_physp;
if (!p_physp)
break;
p_node = p_physp->p_node;
p_physp = osm_node_get_physp_ptr(p_node, p_path->path[hop]);
}
/* At this point, p_physp points at the outgoing physp on the
last hop, or NULL if we don't know it.
*/
if (!p_physp) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR,
"ERR 1107: Outgoing physp is null on non-hop_0!\n");
osm_dump_dr_path_v2(sm->p_log, p_path, FILE_ID, OSM_LOG_ERROR);
dest_port_guid = 0;
goto Remote_Guid;
}
if (p_physp->p_remote_physp) {
dest_port_guid = p_physp->p_remote_physp->port_guid;
goto Remote_Guid;
}
OSM_LOG(sm->p_log, OSM_LOG_DEBUG, "Target port guid unknown, "
"using persistent DB\n");
if (!osm_db_neighbor_get(sm->p_subn->p_neighbor,
cl_ntoh64(p_physp->port_guid),
p_physp->port_num,
&dest_port_guid, NULL)) {
dest_port_guid = cl_hton64(dest_port_guid);
}
Remote_Guid:
if (dest_port_guid) {
if (!osm_db_guid2mkey_get(sm->p_subn->p_g2m,
cl_ntoh64(dest_port_guid), &m_key)) {
m_key = cl_hton64(m_key);
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Found mkey for guid 0x%"
PRIx64 "\n", cl_ntoh64(dest_port_guid));
} else {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Target port mkey unknown, using default\n");
m_key = sm->p_subn->opt.m_key;
}
} else {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Target port guid unknown, using default\n");
m_key = sm->p_subn->opt.m_key;
}
OSM_LOG_EXIT(sm->p_log);
return m_key;
}
/**********************************************************************
Sweeps the node 1 hop away.
This sets off a "chain reaction" that causes discovery of the subnet.
Used when there is suspicion that something on the subnet has changed.
**********************************************************************/
static ib_api_status_t state_mgr_sweep_hop_1(IN osm_sm_t * sm)
{
ib_api_status_t status = IB_SUCCESS;
osm_bind_handle_t h_bind;
osm_madw_context_t context;
osm_node_t *p_node;
osm_port_t *p_port;
osm_physp_t *p_physp;
osm_dr_path_t *p_dr_path;
osm_dr_path_t hop_1_path;
ib_net64_t port_guid;
uint8_t port_num;
uint8_t path_array[IB_SUBNET_PATH_HOPS_MAX];
uint8_t num_ports;
osm_physp_t *p_ext_physp;
OSM_LOG_ENTER(sm->p_log);
/*
* First, get our own port and node objects.
*/
port_guid = sm->p_subn->sm_port_guid;
CL_ASSERT(port_guid);
/* Set the in_sweep_hop_0 flag in subn to be FALSE.
* This will indicate the sweeping to continue beyond the
* the current node.
* This is relevant for the case of SM on switch, since in the
* switch info we need to signal that the sweeping should
* continue through the switch. */
sm->p_subn->in_sweep_hop_0 = FALSE;
p_port = osm_get_port_by_guid(sm->p_subn, port_guid);
if (!p_port) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3310: "
"No SM port object\n");
status = IB_ERROR;
goto Exit;
}
p_node = p_port->p_node;
CL_ASSERT(p_node);
port_num = ib_node_info_get_local_port_num(&p_node->node_info);
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Probing hop 1 on local port %u\n", port_num);
p_physp = osm_node_get_physp_ptr(p_node, port_num);
CL_ASSERT(p_physp);
p_dr_path = osm_physp_get_dr_path_ptr(p_physp);
h_bind = osm_dr_path_get_bind_handle(p_dr_path);
CL_ASSERT(h_bind != OSM_BIND_INVALID_HANDLE);
memset(path_array, 0, sizeof(path_array));
/* the hop_1 operations depend on the type of our node.
* Currently - legal nodes that can host SM are SW and CA */
switch (osm_node_get_type(p_node)) {
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_ROUTER:
memset(&context, 0, sizeof(context));
context.ni_context.node_guid = osm_node_get_node_guid(p_node);
context.ni_context.port_num = port_num;
path_array[1] = port_num;
osm_dr_path_init(&hop_1_path, h_bind, 1, path_array);
status = osm_req_get(sm, &hop_1_path, IB_MAD_ATTR_NODE_INFO, 0,
CL_DISP_MSGID_NONE, &context);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3311: "
"Request for NodeInfo failed (%s)\n",
ib_get_err_str(status));
break;
case IB_NODE_TYPE_SWITCH:
/* Need to go over all the ports of the switch, and send a
* node_info from them. This doesn't include the port 0 of the
* switch, which hosts the SM.
* Note: We'll send another switchInfo on port 0, since if no
* ports are connected, we still want to get some response, and
* have the subnet come up.
*/
num_ports = osm_node_get_num_physp(p_node);
for (port_num = 1; port_num < num_ports; port_num++) {
/* go through the port only if the port is not DOWN */
p_ext_physp = osm_node_get_physp_ptr(p_node, port_num);
if (p_ext_physp && ib_port_info_get_port_state
(&(p_ext_physp->port_info)) > IB_LINK_DOWN) {
memset(&context, 0, sizeof(context));
context.ni_context.node_guid =
osm_node_get_node_guid(p_node);
context.ni_context.port_num = port_num;
path_array[1] = port_num;
osm_dr_path_init(&hop_1_path, h_bind, 1,
path_array);
status = osm_req_get(sm, &hop_1_path,
IB_MAD_ATTR_NODE_INFO, 0,
CL_DISP_MSGID_NONE,
&context);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR,
"ERR 3312: "
"Request for NodeInfo failed (%s)\n",
ib_get_err_str(status));
}
}
break;
default:
OSM_LOG(sm->p_log, OSM_LOG_ERROR,
"ERR 3313: Unknown node type %d (%s)\n",
osm_node_get_type(p_node), p_node->print_desc);
}
Exit:
OSM_LOG_EXIT(sm->p_log);
return status;
}
int osm_sa_db_file_load(osm_opensm_t * p_osm)
{
char line[1024];
char *file_name;
FILE *file;
int ret = 0;
osm_mgrp_t *p_mgrp = NULL;
unsigned rereg_clients = 0;
unsigned lineno;
if (!p_osm->subn.first_time_master_sweep) {
OSM_LOG(&p_osm->log, OSM_LOG_VERBOSE,
"Not first sweep - skip SA DB restore\n");
return 0;
}
file_name = p_osm->subn.opt.sa_db_file;
if (!file_name) {
OSM_LOG(&p_osm->log, OSM_LOG_VERBOSE,
"sa db file name is not specifed. Skip restore\n");
return 0;
}
file = fopen(file_name, "r");
if (!file) {
OSM_LOG(&p_osm->log, OSM_LOG_ERROR | OSM_LOG_SYS, "ERR 4C02: "
"Can't open sa db file \'%s\'. Skip restoring\n",
file_name);
return -1;
}
OSM_LOG(&p_osm->log, OSM_LOG_VERBOSE,
"Restoring SA DB from file \'%s\'\n",
file_name);
lineno = 0;
while (fgets(line, sizeof(line) - 1, file) != NULL) {
char *p;
uint8_t val;
lineno++;
p = line;
while (isspace(*p))
p++;
if (*p == '#')
continue;
if (!strncmp(p, "MC Group", 8)) {
ib_member_rec_t mcm_rec;
ib_net16_t mlid;
unsigned well_known = 0;
p_mgrp = NULL;
memset(&mcm_rec, 0, sizeof(mcm_rec));
PARSE_AHEAD(p, net16, " 0x", &mlid);
if (strstr(p, "well known"))
well_known = 1;
PARSE_AHEAD(p, net64, " mgid=0x",
&mcm_rec.mgid.unicast.prefix);
PARSE_AHEAD(p, net64, ":0x",
&mcm_rec.mgid.unicast.interface_id);
PARSE_AHEAD(p, net64, " port_gid=0x",
&mcm_rec.port_gid.unicast.prefix);
PARSE_AHEAD(p, net64, ":0x",
&mcm_rec.port_gid.unicast.interface_id);
PARSE_AHEAD(p, net32, " qkey=0x", &mcm_rec.qkey);
PARSE_AHEAD(p, net16, " mlid=0x", &mcm_rec.mlid);
PARSE_AHEAD(p, net8, " mtu=0x", &mcm_rec.mtu);
PARSE_AHEAD(p, net8, " tclass=0x", &mcm_rec.tclass);
PARSE_AHEAD(p, net16, " pkey=0x", &mcm_rec.pkey);
PARSE_AHEAD(p, net8, " rate=0x", &mcm_rec.rate);
PARSE_AHEAD(p, net8, " pkt_life=0x", &mcm_rec.pkt_life);
PARSE_AHEAD(p, net32, " sl_flow_hop=0x",
&mcm_rec.sl_flow_hop);
PARSE_AHEAD(p, net8, " scope_state=0x",
&mcm_rec.scope_state);
PARSE_AHEAD(p, net8, " proxy_join=0x", &val);
mcm_rec.proxy_join = val;
p_mgrp = load_mcgroup(p_osm, mlid, &mcm_rec,
well_known);
if (!p_mgrp)
rereg_clients = 1;
if (cl_ntoh16(mlid) > p_osm->sm.mlids_init_max)
p_osm->sm.mlids_init_max = cl_ntoh16(mlid);
} else if (p_mgrp && !strncmp(p, "mcm_port", 8)) {
ib_member_rec_t mcmr;
ib_net64_t guid;
osm_port_t *port;
boolean_t proxy;
PARSE_AHEAD(p, net64, " port_gid=0x",
&mcmr.port_gid.unicast.prefix);
PARSE_AHEAD(p, net64, ":0x",
&mcmr.port_gid.unicast.interface_id);
PARSE_AHEAD(p, net8, " scope_state=0x", &mcmr.scope_state);
PARSE_AHEAD(p, net8, " proxy_join=0x", &val);
proxy = val;
guid = mcmr.port_gid.unicast.interface_id;
port = osm_get_port_by_guid(&p_osm->subn, guid);
if (port &&
cl_qmap_get(&p_mgrp->mcm_port_tbl, guid) ==
cl_qmap_end(&p_mgrp->mcm_port_tbl) &&
!osm_mgrp_add_port(&p_osm->subn, &p_osm->log,
p_mgrp, port, &mcmr, proxy))
rereg_clients = 1;
} else if (!strncmp(p, "Service Record:", 15)) {
ib_service_record_t s_rec;
uint32_t modified_time, lease_period;
p_mgrp = NULL;
memset(&s_rec, 0, sizeof(s_rec));
PARSE_AHEAD(p, net64, " id=0x", &s_rec.service_id);
PARSE_AHEAD(p, net64, " gid=0x",
&s_rec.service_gid.unicast.prefix);
PARSE_AHEAD(p, net64, ":0x",
&s_rec.service_gid.unicast.interface_id);
PARSE_AHEAD(p, net16, " pkey=0x", &s_rec.service_pkey);
PARSE_AHEAD(p, net32, " lease=0x",
&s_rec.service_lease);
PARSE_AHEAD(p, net64, " key=0x",
(ib_net64_t *) (&s_rec.service_key[0]));
PARSE_AHEAD(p, net64, ":0x",
(ib_net64_t *) (&s_rec.service_key[8]));
PARSE_AHEAD(p, string64, " name=", s_rec.service_name);
PARSE_AHEAD(p, net64, " data8=0x",
(ib_net64_t *) (&s_rec.service_data8[0]));
PARSE_AHEAD(p, net64, ":0x",
(ib_net64_t *) (&s_rec.service_data8[8]));
PARSE_AHEAD(p, net64, " data16=0x",
(ib_net64_t *) (&s_rec.service_data16[0]));
PARSE_AHEAD(p, net64, ":0x",
(ib_net64_t *) (&s_rec.service_data16[4]));
PARSE_AHEAD(p, net64, " data32=0x",
(ib_net64_t *) (&s_rec.service_data32[0]));
PARSE_AHEAD(p, net64, ":0x",
(ib_net64_t *) (&s_rec.service_data32[2]));
PARSE_AHEAD(p, net64, " data64=0x",
&s_rec.service_data64[0]);
PARSE_AHEAD(p, net64, ":0x", &s_rec.service_data64[1]);
PARSE_AHEAD(p, net32, " modified_time=0x",
&modified_time);
PARSE_AHEAD(p, net32, " lease_period=0x",
&lease_period);
if (load_svcr(p_osm, &s_rec, cl_ntoh32(modified_time),
cl_ntoh32(lease_period)))
rereg_clients = 1;
} else if (!strncmp(p, "InformInfo Record:", 18)) {
ib_inform_info_record_t i_rec;
osm_mad_addr_t rep_addr;
ib_net16_t val16;
p_mgrp = NULL;
memset(&i_rec, 0, sizeof(i_rec));
memset(&rep_addr, 0, sizeof(rep_addr));
PARSE_AHEAD(p, net64, " subscriber_gid=0x",
&i_rec.subscriber_gid.unicast.prefix);
PARSE_AHEAD(p, net64, ":0x",
&i_rec.subscriber_gid.unicast.interface_id);
PARSE_AHEAD(p, net16, " subscriber_enum=0x",
&i_rec.subscriber_enum);
PARSE_AHEAD(p, net64, " gid=0x",
&i_rec.inform_info.gid.unicast.prefix);
PARSE_AHEAD(p, net64, ":0x",
&i_rec.inform_info.gid.unicast.
interface_id);
PARSE_AHEAD(p, net16, " lid_range_begin=0x",
&i_rec.inform_info.lid_range_begin);
PARSE_AHEAD(p, net16, " lid_range_end=0x",
&i_rec.inform_info.lid_range_end);
PARSE_AHEAD(p, net8, " is_generic=0x",
&i_rec.inform_info.is_generic);
PARSE_AHEAD(p, net8, " subscribe=0x",
&i_rec.inform_info.subscribe);
PARSE_AHEAD(p, net16, " trap_type=0x",
&i_rec.inform_info.trap_type);
PARSE_AHEAD(p, net16, " trap_num=0x",
&i_rec.inform_info.g_or_v.generic.trap_num);
PARSE_AHEAD(p, net32, " qpn_resp_time_val=0x",
&i_rec.inform_info.g_or_v.generic.
qpn_resp_time_val);
PARSE_AHEAD(p, net32, " node_type=0x",
(uint32_t *) & i_rec.inform_info.g_or_v.
generic.reserved2);
PARSE_AHEAD(p, net16, " rep_addr: lid=0x",
&rep_addr.dest_lid);
PARSE_AHEAD(p, net8, " path_bits=0x",
&rep_addr.path_bits);
PARSE_AHEAD(p, net8, " static_rate=0x",
&rep_addr.static_rate);
PARSE_AHEAD(p, net32, " remote_qp=0x",
&rep_addr.addr_type.gsi.remote_qp);
PARSE_AHEAD(p, net32, " remote_qkey=0x",
&rep_addr.addr_type.gsi.remote_qkey);
PARSE_AHEAD(p, net16, " pkey_ix=0x", &val16);
rep_addr.addr_type.gsi.pkey_ix = cl_ntoh16(val16);
PARSE_AHEAD(p, net8, " sl=0x",
&rep_addr.addr_type.gsi.service_level);
if (load_infr(p_osm, &i_rec, &rep_addr))
rereg_clients = 1;
}
}
/*
* If loading succeeded, do whatever 'no_clients_rereg' says.
* If loading failed at some point, turn off the 'no_clients_rereg'
* option (turn on re-registration requests).
*/
if (rereg_clients)
p_osm->subn.opt.no_clients_rereg = FALSE;
/* We've just finished loading SA DB file - clear the "dirty" flag */
p_osm->sa.dirty = FALSE;
_error:
fclose(file);
return ret;
}
static void
__osm_sa_inform_info_rec_by_comp_mask(IN osm_sa_t * sa,
IN const osm_infr_t * const p_infr,
osm_iir_search_ctxt_t * const p_ctxt)
{
const ib_inform_info_record_t *p_rcvd_rec = NULL;
ib_net64_t comp_mask;
ib_net64_t portguid;
osm_port_t *p_subscriber_port;
osm_physp_t *p_subscriber_physp;
const osm_physp_t *p_req_physp;
osm_iir_item_t *p_rec_item;
OSM_LOG_ENTER(sa->p_log);
p_rcvd_rec = p_ctxt->p_rcvd_rec;
comp_mask = p_ctxt->comp_mask;
p_req_physp = p_ctxt->p_req_physp;
if (comp_mask & IB_IIR_COMPMASK_SUBSCRIBERGID &&
memcmp(&p_infr->inform_record.subscriber_gid,
&p_ctxt->subscriber_gid,
sizeof(p_infr->inform_record.subscriber_gid)))
goto Exit;
if (comp_mask & IB_IIR_COMPMASK_ENUM &&
p_infr->inform_record.subscriber_enum != p_ctxt->subscriber_enum)
goto Exit;
/* Implement any other needed search cases */
/* Ensure pkey is shared before returning any records */
portguid = p_infr->inform_record.subscriber_gid.unicast.interface_id;
p_subscriber_port = osm_get_port_by_guid(sa->p_subn, portguid);
if (p_subscriber_port == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 430D: "
"Invalid subscriber port guid: 0x%016" PRIx64 "\n",
cl_ntoh64(portguid));
goto Exit;
}
/* get the subscriber InformInfo physical port */
p_subscriber_physp = p_subscriber_port->p_physp;
/* make sure that the requester and subscriber port can access each other
according to the current partitioning. */
if (!osm_physp_share_pkey
(sa->p_log, p_req_physp, p_subscriber_physp)) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"requester and subscriber ports don't share pkey\n");
goto Exit;
}
p_rec_item = malloc(sizeof(*p_rec_item));
if (p_rec_item == NULL) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 430E: "
"rec_item alloc failed\n");
goto Exit;
}
memcpy((void *)&p_rec_item->rec, (void *)&p_infr->inform_record,
sizeof(ib_inform_info_record_t));
cl_qlist_insert_tail(p_ctxt->p_list, &p_rec_item->list_item);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
static void ucast_cache_validate(osm_ucast_mgr_t * p_mgr)
{
cache_switch_t *p_cache_sw;
cache_switch_t *p_remote_cache_sw;
unsigned port_num;
unsigned max_ports;
uint8_t remote_node_type;
uint16_t lid_ho;
uint16_t remote_lid_ho;
osm_switch_t *p_sw;
osm_switch_t *p_remote_sw;
osm_node_t *p_node;
osm_physp_t *p_physp;
osm_physp_t *p_remote_physp;
osm_port_t *p_remote_port;
cl_qmap_t *p_sw_tbl;
OSM_LOG_ENTER(p_mgr->p_log);
if (!p_mgr->cache_valid)
goto Exit;
/* If there are no switches in the subnet, we are done */
p_sw_tbl = &p_mgr->p_subn->sw_guid_tbl;
if (cl_qmap_count(p_sw_tbl) == 0) {
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
/*
* Scan all the physical switch ports in the subnet.
* If the port need_update flag is on, check whether
* it's just some node/port reset or a cached topology
* change. Otherwise the cache is invalid.
*/
for (p_sw = (osm_switch_t *) cl_qmap_head(p_sw_tbl);
p_sw != (osm_switch_t *) cl_qmap_end(p_sw_tbl);
p_sw = (osm_switch_t *) cl_qmap_next(&p_sw->map_item)) {
p_node = p_sw->p_node;
lid_ho = cl_ntoh16(osm_node_get_base_lid(p_node, 0));
p_cache_sw = cache_get_sw(p_mgr, lid_ho);
max_ports = osm_node_get_num_physp(p_node);
/* skip port 0 */
for (port_num = 1; port_num < max_ports; port_num++) {
p_physp = osm_node_get_physp_ptr(p_node, port_num);
if (!p_physp || !p_physp->p_remote_physp ||
!osm_physp_link_exists(p_physp,
p_physp->p_remote_physp))
/* no valid link */
continue;
/*
* While scanning all the physical ports in the subnet,
* mark corresponding leaf switches in the cache.
*/
if (p_cache_sw &&
!p_cache_sw->dropped &&
!cache_sw_is_leaf(p_cache_sw) &&
p_physp->p_remote_physp->p_node &&
osm_node_get_type(p_physp->p_remote_physp->
p_node) != IB_NODE_TYPE_SWITCH)
cache_sw_set_leaf(p_cache_sw);
if (!p_physp->need_update)
continue;
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Checking switch lid %u, port %u\n",
lid_ho, port_num);
p_remote_physp = osm_physp_get_remote(p_physp);
remote_node_type =
osm_node_get_type(p_remote_physp->p_node);
if (remote_node_type == IB_NODE_TYPE_SWITCH)
remote_lid_ho =
cl_ntoh16(osm_node_get_base_lid
(p_remote_physp->p_node, 0));
else
remote_lid_ho =
cl_ntoh16(osm_node_get_base_lid
(p_remote_physp->p_node,
osm_physp_get_port_num
(p_remote_physp)));
if (!p_cache_sw ||
port_num >= p_cache_sw->num_ports ||
!p_cache_sw->ports[port_num].remote_lid_ho) {
/*
* There is some uncached change on the port.
* In general, the reasons might be as follows:
* - switch reset
* - port reset (or port down/up)
* - quick connection location change
* - new link (or new switch)
*
* First two reasons allow cache usage, while
* the last two reasons should invalidate cache.
*
* In case of quick connection location change,
* cache would have been invalidated by
* osm_ucast_cache_check_new_link() function.
*
* In case of new link between two known nodes,
* cache also would have been invalidated by
* osm_ucast_cache_check_new_link() function.
*
* Another reason is cached link between two
* known switches went back. In this case the
* osm_ucast_cache_check_new_link() function would
* clear both sides of the link from the cache
* during the discovery process, so effectively
* this would be equivalent to port reset.
*
* So three possible reasons remain:
* - switch reset
* - port reset (or port down/up)
* - link of a new switch
*
* To validate cache, we need to check only the
* third reason - link of a new node/switch:
* - If this is the local switch that is new,
* then it should have (p_sw->need_update == 2).
* - If the remote node is switch and it's new,
* then it also should have
* (p_sw->need_update == 2).
* - If the remote node is CA/RTR and it's new,
* then its port should have is_new flag on.
*/
if (p_sw->need_update == 2) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"New switch found (lid %u)\n",
lid_ho);
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
if (remote_node_type == IB_NODE_TYPE_SWITCH) {
p_remote_sw =
p_remote_physp->p_node->sw;
if (p_remote_sw->need_update == 2) {
/* this could also be case of
switch coming back with an
additional link that it
didn't have before */
OSM_LOG(p_mgr->p_log,
OSM_LOG_DEBUG,
"New switch/link found (lid %u)\n",
remote_lid_ho);
osm_ucast_cache_invalidate
(p_mgr);
goto Exit;
}
} else {
/*
* Remote node is CA/RTR.
* Get p_port of the remote node and
* check its p_port->is_new flag.
*/
p_remote_port =
osm_get_port_by_guid(p_mgr->p_subn,
osm_physp_get_port_guid
(p_remote_physp));
if (p_remote_port->is_new) {
OSM_LOG(p_mgr->p_log,
OSM_LOG_DEBUG,
"New CA/RTR found (lid %u)\n",
remote_lid_ho);
osm_ucast_cache_invalidate
(p_mgr);
goto Exit;
}
}
} else {
/*
* The change on the port is cached.
* In general, the reasons might be as follows:
* - link between two known nodes went back
* - one or more nodes went back, causing all
* the links to reappear
*
* If it was link that went back, then this case
* would have been taken care of during the
* discovery by osm_ucast_cache_check_new_link(),
* so it's some node that went back.
*/
if ((p_cache_sw->ports[port_num].is_leaf &&
remote_node_type == IB_NODE_TYPE_SWITCH) ||
(!p_cache_sw->ports[port_num].is_leaf &&
remote_node_type != IB_NODE_TYPE_SWITCH)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Remote node type change on switch lid %u, port %u\n",
lid_ho, port_num);
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
if (p_cache_sw->ports[port_num].remote_lid_ho !=
remote_lid_ho) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Remote lid change on switch lid %u, port %u"
"(was %u, now %u)\n",
lid_ho, port_num,
p_cache_sw->ports[port_num].
remote_lid_ho, remote_lid_ho);
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
/*
* We don't care who is the node that has
* reappeared in the subnet (local or remote).
* What's important that the cached link matches
* the real fabrics link.
* Just clean it from cache.
*/
p_cache_sw->ports[port_num].remote_lid_ho = 0;
p_cache_sw->ports[port_num].is_leaf = FALSE;
if (p_cache_sw->dropped) {
cache_restore_ucast_info(p_mgr,
p_cache_sw,
p_sw);
p_cache_sw->dropped = FALSE;
}
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Restored link from cache: lid %u, port %u to lid %u\n",
lid_ho, port_num, remote_lid_ho);
}
}
}
/* Remove all the cached switches that
have all their ports restored */
cache_cleanup_switches(p_mgr);
/*
* Done scanning all the physical switch ports in the subnet.
* Now we need to check the other side:
* Scan all the cached switches and their ports:
* - If the cached switch is missing in the subnet
* (dropped flag is on), check that it's a leaf switch.
* If it's not a leaf, the cache is invalid, because
* cache can tolerate only leaf switch removal.
* - If the cached switch exists in fabric, check all
* its cached ports. These cached ports represent
* missing link in the fabric.
* The missing links that can be tolerated are:
* + link to missing CA/RTR
* + link to missing leaf switch
*/
for (p_cache_sw = (cache_switch_t *) cl_qmap_head(&p_mgr->cache_sw_tbl);
p_cache_sw != (cache_switch_t *) cl_qmap_end(&p_mgr->cache_sw_tbl);
p_cache_sw =
(cache_switch_t *) cl_qmap_next(&p_cache_sw->map_item)) {
if (p_cache_sw->dropped) {
if (!cache_sw_is_leaf(p_cache_sw)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Missing non-leaf switch (lid %u)\n",
cache_sw_get_base_lid_ho(p_cache_sw));
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Missing leaf switch (lid %u) - "
"continuing validation\n",
cache_sw_get_base_lid_ho(p_cache_sw));
continue;
}
for (port_num = 1; port_num < p_cache_sw->num_ports; port_num++) {
if (!p_cache_sw->ports[port_num].remote_lid_ho)
continue;
if (p_cache_sw->ports[port_num].is_leaf) {
CL_ASSERT(cache_sw_is_leaf(p_cache_sw));
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Switch lid %u, port %u: missing link to CA/RTR - "
"continuing validation\n",
cache_sw_get_base_lid_ho(p_cache_sw),
port_num);
continue;
}
p_remote_cache_sw = cache_get_sw(p_mgr,
p_cache_sw->
ports[port_num].
remote_lid_ho);
if (!p_remote_cache_sw || !p_remote_cache_sw->dropped) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Switch lid %u, port %u: missing link to existing switch\n",
cache_sw_get_base_lid_ho(p_cache_sw),
port_num);
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
if (!cache_sw_is_leaf(p_remote_cache_sw)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Switch lid %u, port %u: missing link to non-leaf switch\n",
cache_sw_get_base_lid_ho(p_cache_sw),
port_num);
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
/*
* At this point we know that the missing link is to
* a leaf switch. However, one case deserves a special
* treatment. If there was a link between two leaf
* switches, then missing leaf switch might break
* routing. It is possible that there are routes
* that use leaf switches to get from switch to switch
* and not just to get to the CAs behind the leaf switch.
*/
if (cache_sw_is_leaf(p_cache_sw) &&
cache_sw_is_leaf(p_remote_cache_sw)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Switch lid %u, port %u: missing leaf-2-leaf link\n",
cache_sw_get_base_lid_ho(p_cache_sw),
port_num);
osm_ucast_cache_invalidate(p_mgr);
goto Exit;
}
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Switch lid %u, port %u: missing remote leaf switch - "
"continuing validation\n",
cache_sw_get_base_lid_ho(p_cache_sw),
port_num);
}
}
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG, "Unicast cache is valid\n");
ucast_cache_dump(p_mgr);
Exit:
OSM_LOG_EXIT(p_mgr->p_log);
} /* osm_ucast_cache_validate() */
/**********************************************************************
The plock must be held before calling this function.
**********************************************************************/
static void ni_rcv_process_existing_ca_or_router(IN osm_sm_t * sm,
IN osm_node_t * p_node,
IN const osm_madw_t * p_madw)
{
ib_node_info_t *p_ni;
ib_smp_t *p_smp;
osm_port_t *p_port;
osm_port_t *p_port_check;
uint8_t port_num;
osm_dr_path_t *p_dr_path;
osm_alias_guid_t *p_alias_guid, *p_alias_guid_check;
OSM_LOG_ENTER(sm->p_log);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_ni = ib_smp_get_payload_ptr(p_smp);
port_num = ib_node_info_get_local_port_num(p_ni);
/*
Determine if we have encountered this node through a
previously undiscovered port. If so, build the new
port object.
*/
p_port = osm_get_port_by_guid(sm->p_subn, p_ni->port_guid);
if (!p_port) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Creating new port object with GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
osm_node_init_physp(p_node, port_num, p_madw);
p_port = osm_port_new(p_ni, p_node);
if (PF(p_port == NULL)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D04: "
"Unable to create new port object\n");
goto Exit;
}
/*
Add the new port object to the database.
*/
p_port_check =
(osm_port_t *) cl_qmap_insert(&sm->p_subn->port_guid_tbl,
p_ni->port_guid,
&p_port->map_item);
if (PF(p_port_check != p_port)) {
/*
We should never be here!
Somehow, this port GUID already exists in the table.
*/
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D12: "
"Port 0x%" PRIx64 " already in the database!\n",
cl_ntoh64(p_ni->port_guid));
osm_port_delete(&p_port);
goto Exit;
}
p_alias_guid = osm_alias_guid_new(p_ni->port_guid,
p_port);
if (PF(!p_alias_guid)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D11: "
"alias guid memory allocation failed"
" for port GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
goto alias_done;
}
/* insert into alias guid table */
p_alias_guid_check =
(osm_alias_guid_t *) cl_qmap_insert(&sm->p_subn->alias_port_guid_tbl,
p_alias_guid->alias_guid,
&p_alias_guid->map_item);
if (p_alias_guid_check != p_alias_guid) {
/* alias GUID is a duplicate */
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D13: "
"Duplicate alias port GUID 0x%" PRIx64 "\n",
cl_ntoh64(p_ni->port_guid));
osm_alias_guid_delete(&p_alias_guid);
osm_port_delete(&p_port);
goto Exit;
}
alias_done:
/* If we are a master, then this means the port is new on the subnet.
Mark it as new - need to send trap 64 for these ports.
The condition that we are master is true, since if we are in discovering
state (meaning we woke up from standby or we are just initializing),
then these ports may be new to us, but are not new on the subnet.
If we are master, then the subnet as we know it is the updated one,
and any new ports we encounter should cause trap 64. C14-72.1.1 */
if (sm->p_subn->sm_state == IB_SMINFO_STATE_MASTER)
p_port->is_new = 1;
} else {
osm_physp_t *p_physp = osm_node_get_physp_ptr(p_node, port_num);
if (PF(p_physp == NULL)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0D1C: "
"No physical port found for node GUID 0x%"
PRIx64 " port %u. Might be duplicate port GUID\n",
cl_ntoh64(p_node->node_info.node_guid),
port_num);
goto Exit;
}
/*
Update the DR Path to the port,
in case the old one is no longer available.
*/
p_dr_path = osm_physp_get_dr_path_ptr(p_physp);
osm_dr_path_init(p_dr_path, p_smp->hop_count,
p_smp->initial_path);
}
ni_rcv_get_port_info(sm, p_node, p_madw);
Exit:
OSM_LOG_EXIT(sm->p_log);
}
void osm_pi_rcv_process(IN void *context, IN void *data)
{
osm_sm_t *sm = context;
osm_madw_t *p_madw = data;
ib_port_info_t *p_pi;
ib_smp_t *p_smp;
osm_port_t *p_port;
osm_physp_t *p_physp;
osm_dr_path_t *p_dr_path;
osm_node_t *p_node;
osm_pi_context_t *p_context;
ib_net64_t port_guid;
ib_net64_t node_guid;
uint8_t port_num;
OSM_LOG_ENTER(sm->p_log);
CL_ASSERT(sm);
CL_ASSERT(p_madw);
p_smp = osm_madw_get_smp_ptr(p_madw);
p_context = osm_madw_get_pi_context_ptr(p_madw);
p_pi = (ib_port_info_t *) ib_smp_get_payload_ptr(p_smp);
CL_ASSERT(p_smp->attr_id == IB_MAD_ATTR_PORT_INFO);
port_num = (uint8_t) cl_ntoh32(p_smp->attr_mod);
port_guid = p_context->port_guid;
node_guid = p_context->node_guid;
osm_dump_port_info(sm->p_log,
node_guid, port_guid, port_num, p_pi, OSM_LOG_DEBUG);
/* On receipt of client reregister, clear the reregister bit so
reregistering won't be sent again and again */
if (ib_port_info_get_client_rereg(p_pi)) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Client reregister received on response\n");
ib_port_info_set_client_rereg(p_pi, 0);
}
/*
we might get a response during a light sweep looking for a change in
the status of a remote port that did not respond in earlier sweeps.
So if the context of the Get was light_sweep - we do not need to
do anything with the response - just flag that we need a heavy sweep
*/
if (p_context->light_sweep == TRUE) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Got light sweep response from remote port of parent node "
"GUID 0x%" PRIx64 " port 0x%016" PRIx64
", Commencing heavy sweep\n",
cl_ntoh64(node_guid), cl_ntoh64(port_guid));
sm->p_subn->force_heavy_sweep = TRUE;
sm->p_subn->ignore_existing_lfts = TRUE;
goto Exit;
}
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
p_port = osm_get_port_by_guid(sm->p_subn, port_guid);
if (!p_port) {
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F06: "
"No port object for port with GUID 0x%" PRIx64
"\n\t\t\t\tfor parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
goto Exit;
}
p_node = p_port->p_node;
CL_ASSERT(p_node);
/*
If we were setting the PortInfo, then receiving
this attribute was not part of sweeping the subnet.
In this case, just update the PortInfo attribute.
In an unfortunate blunder, the IB spec defines the
return method for Set() as a GetResp(). Thus, we can't
use the method (what would have been SetResp()) to determine
our course of action. So, we have to carry this extra
boolean around to determine if we were doing Get() or Set().
*/
if (p_context->set_method)
osm_pi_rcv_process_set(sm, p_node, port_num, p_madw);
else {
p_port->discovery_count++;
/*
This PortInfo arrived because we did a Get() method,
most likely due to a subnet sweep in progress.
*/
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Discovered port num %u with GUID 0x%" PRIx64
" for parent node GUID 0x%" PRIx64
", TID 0x%" PRIx64 "\n",
port_num, cl_ntoh64(port_guid),
cl_ntoh64(node_guid), cl_ntoh64(p_smp->trans_id));
p_physp = osm_node_get_physp_ptr(p_node, port_num);
/*
Determine if we encountered a new Physical Port.
If so, initialize the new Physical Port then
continue processing as normal.
*/
if (!p_physp) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Initializing port number %u\n", port_num);
p_physp = &p_node->physp_table[port_num];
osm_physp_init(p_physp,
port_guid,
port_num,
p_node,
osm_madw_get_bind_handle(p_madw),
p_smp->hop_count, p_smp->initial_path);
} else {
/*
Update the directed route path to this port
in case the old path is no longer usable.
*/
p_dr_path = osm_physp_get_dr_path_ptr(p_physp);
osm_dr_path_init(p_dr_path,
osm_madw_get_bind_handle(p_madw),
p_smp->hop_count, p_smp->initial_path);
}
/* if port just inited or reached INIT state (external reset)
request update for port related tables */
p_physp->need_update =
(ib_port_info_get_port_state(p_pi) == IB_LINK_INIT ||
p_physp->need_update > 1) ? 1 : 0;
switch (osm_node_get_type(p_node)) {
case IB_NODE_TYPE_CA:
case IB_NODE_TYPE_ROUTER:
__osm_pi_rcv_process_ca_or_router_port(sm,
p_node, p_physp,
p_pi);
break;
case IB_NODE_TYPE_SWITCH:
__osm_pi_rcv_process_switch_port(sm,
p_node, p_physp, p_pi);
break;
default:
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 0F07: "
"Unknown node type %u with GUID 0x%" PRIx64
"\n", osm_node_get_type(p_node),
cl_ntoh64(node_guid));
break;
}
/*
Get the tables on the physp.
*/
if (p_physp->need_update || sm->p_subn->need_update)
__osm_pi_rcv_get_pkey_slvl_vla_tables(sm, p_node,
p_physp);
}
CL_PLOCK_RELEASE(sm->p_lock);
Exit:
/*
Release the lock before jumping here!!
*/
OSM_LOG_EXIT(sm->p_log);
}
