void osm_slvl_rec_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *p_rcvd_mad;
const ib_slvl_table_record_t *p_rcvd_rec;
const osm_port_t *p_port = NULL;
cl_qlist_t rec_list;
osm_slvl_search_ctxt_t context;
ib_api_status_t status = IB_SUCCESS;
ib_net64_t comp_mask;
osm_physp_t *p_req_physp;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_rcvd_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec =
(ib_slvl_table_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
comp_mask = p_rcvd_mad->comp_mask;
CL_ASSERT(p_rcvd_mad->attr_id == IB_MAD_ATTR_SLVL_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (p_rcvd_mad->method != IB_MAD_METHOD_GET &&
p_rcvd_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 2604: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(p_rcvd_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 2603: "
"Cannot find requester physical port\n");
goto Exit;
}
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = p_rcvd_mad->comp_mask;
context.sa = sa;
context.in_port_num = p_rcvd_rec->in_port_num;
context.p_req_physp = p_req_physp;
cl_plock_acquire(sa->p_lock);
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Got Query Lid:%u(%02X), In-Port:0x%02X(%02X), Out-Port:0x%02X(%02X)\n",
cl_ntoh16(p_rcvd_rec->lid),
(comp_mask & IB_SLVL_COMPMASK_LID) != 0,
p_rcvd_rec->in_port_num,
(comp_mask & IB_SLVL_COMPMASK_IN_PORT) != 0,
p_rcvd_rec->out_port_num,
(comp_mask & IB_SLVL_COMPMASK_OUT_PORT) != 0);
/*
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_SLVL_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 2608: "
"No port found with LID %u\n",
cl_ntoh16(p_rcvd_rec->lid));
}
}
if (status == IB_SUCCESS) {
/* if we have a unique port - no need for a port search */
if (p_port)
/* this does the loop on all the port phys ports */
sa_slvl_by_comp_mask(sa, p_port, &context);
else
cl_qmap_apply_func(&sa->p_subn->port_guid_tbl,
sa_slvl_by_comp_mask_cb, &context);
}
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_slvl_table_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_lftr_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *p_rcvd_mad;
const ib_lft_record_t *p_rcvd_rec;
cl_qlist_t rec_list;
osm_lftr_search_ctxt_t context;
osm_physp_t *p_req_physp;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_rcvd_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec = (ib_lft_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
CL_ASSERT(p_rcvd_mad->attr_id == IB_MAD_ATTR_LFT_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (p_rcvd_mad->method != IB_MAD_METHOD_GET &&
p_rcvd_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4408: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(p_rcvd_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 4407: "
"Cannot find requester physical port\n");
goto Exit;
}
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Requester port GUID 0x%" PRIx64 "\n",
cl_ntoh64(osm_physp_get_port_guid(p_req_physp)));
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = p_rcvd_mad->comp_mask;
context.sa = sa;
context.p_req_physp = p_req_physp;
cl_plock_acquire(sa->p_lock);
/* Go over all switches */
cl_qmap_apply_func(&sa->p_subn->sw_guid_tbl, lftr_rcv_by_comp_mask,
&context);
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_lft_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
void osm_pkey_rec_rcv_process(IN void *ctx, IN void *data)
{
osm_sa_t *sa = ctx;
osm_madw_t *p_madw = data;
const ib_sa_mad_t *p_rcvd_mad;
const ib_pkey_table_record_t *p_rcvd_rec;
const osm_port_t *p_port = NULL;
const ib_pkey_table_t *p_pkey;
cl_qlist_t rec_list;
osm_pkey_search_ctxt_t context;
ib_api_status_t status = IB_SUCCESS;
ib_net64_t comp_mask;
osm_physp_t *p_req_physp;
CL_ASSERT(sa);
OSM_LOG_ENTER(sa->p_log);
CL_ASSERT(p_madw);
p_rcvd_mad = osm_madw_get_sa_mad_ptr(p_madw);
p_rcvd_rec =
(ib_pkey_table_record_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
comp_mask = p_rcvd_mad->comp_mask;
CL_ASSERT(p_rcvd_mad->attr_id == IB_MAD_ATTR_PKEY_TBL_RECORD);
/* we only support SubnAdmGet and SubnAdmGetTable methods */
if (p_rcvd_mad->method != IB_MAD_METHOD_GET &&
p_rcvd_mad->method != IB_MAD_METHOD_GETTABLE) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4605: "
"Unsupported Method (%s)\n",
ib_get_sa_method_str(p_rcvd_mad->method));
osm_sa_send_error(sa, p_madw, IB_MAD_STATUS_UNSUP_METHOD_ATTR);
goto Exit;
}
/*
p922 - P_KeyTableRecords shall only be provided in response
to trusted requests.
Check that the requester is a trusted one.
*/
if (p_rcvd_mad->sm_key != sa->p_subn->opt.sa_key) {
/* This is not a trusted requester! */
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4608: "
"Request from non-trusted requester: "
"Given SM_Key:0x%016" PRIx64 "\n",
cl_ntoh64(p_rcvd_mad->sm_key));
osm_sa_send_error(sa, p_madw, IB_SA_MAD_STATUS_REQ_INVALID);
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 4604: "
"Cannot find requester physical port\n");
goto Exit;
}
p_pkey = (ib_pkey_table_t *) ib_sa_mad_get_payload_ptr(p_rcvd_mad);
cl_qlist_init(&rec_list);
context.p_rcvd_rec = p_rcvd_rec;
context.p_list = &rec_list;
context.comp_mask = p_rcvd_mad->comp_mask;
context.sa = sa;
context.block_num = p_rcvd_rec->block_num;
context.p_req_physp = p_req_physp;
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Got Query Lid:%u(%02X), Block:0x%02X(%02X), Port:0x%02X(%02X)\n",
cl_ntoh16(p_rcvd_rec->lid),
(comp_mask & IB_PKEY_COMPMASK_LID) != 0, p_rcvd_rec->port_num,
(comp_mask & IB_PKEY_COMPMASK_PORT) != 0, p_rcvd_rec->block_num,
(comp_mask & IB_PKEY_COMPMASK_BLOCK) != 0);
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_PKEY_COMPMASK_LID) {
status = osm_get_port_by_base_lid(sa->p_subn, p_rcvd_rec->lid,
&p_port);
if (status != IB_SUCCESS || p_port == NULL) {
status = IB_NOT_FOUND;
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 460B: "
"No port found with LID %u\n",
cl_ntoh16(p_rcvd_rec->lid));
}
}
if (status == IB_SUCCESS) {
/* if we got a unique port - no need for a port search */
if (p_port)
/* this does the loop on all the port phys ports */
__osm_sa_pkey_by_comp_mask(sa, p_port, &context);
else
cl_qmap_apply_func(&sa->p_subn->port_guid_tbl,
__osm_sa_pkey_by_comp_mask_cb,
&context);
}
cl_plock_release(sa->p_lock);
osm_sa_respond(sa, p_madw, sizeof(ib_pkey_table_record_t), &rec_list);
Exit:
OSM_LOG_EXIT(sa->p_log);
}
/**********************************************************************
Initiates a lightweight sweep of the subnet.
Used during normal sweeps after the subnet is up.
**********************************************************************/
static ib_api_status_t state_mgr_light_sweep_start(IN osm_sm_t * sm)
{
ib_api_status_t status = IB_SUCCESS;
osm_bind_handle_t h_bind;
cl_qmap_t *p_sw_tbl;
cl_map_item_t *p_next;
osm_node_t *p_node;
osm_physp_t *p_physp;
uint8_t port_num;
OSM_LOG_ENTER(sm->p_log);
p_sw_tbl = &sm->p_subn->sw_guid_tbl;
/*
* First, get the bind handle.
*/
h_bind = osm_sm_mad_ctrl_get_bind_handle(&sm->mad_ctrl);
if (h_bind == OSM_BIND_INVALID_HANDLE) {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"No bound ports. Deferring sweep...\n");
status = IB_INVALID_STATE;
goto _exit;
}
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE, "INITIATING LIGHT SWEEP");
CL_PLOCK_ACQUIRE(sm->p_lock);
cl_qmap_apply_func(p_sw_tbl, state_mgr_get_sw_info, sm);
CL_PLOCK_RELEASE(sm->p_lock);
CL_PLOCK_ACQUIRE(sm->p_lock);
cl_qmap_apply_func(&sm->p_subn->node_guid_tbl, state_mgr_get_node_desc,
sm);
CL_PLOCK_RELEASE(sm->p_lock);
/* now scan the list of physical ports that were not down but have no remote port */
CL_PLOCK_ACQUIRE(sm->p_lock);
p_next = cl_qmap_head(&sm->p_subn->node_guid_tbl);
while (p_next != cl_qmap_end(&sm->p_subn->node_guid_tbl)) {
p_node = (osm_node_t *) p_next;
p_next = cl_qmap_next(p_next);
for (port_num = 1; port_num < osm_node_get_num_physp(p_node);
port_num++) {
p_physp = osm_node_get_physp_ptr(p_node, port_num);
if (p_physp && (osm_physp_get_port_state(p_physp) !=
IB_LINK_DOWN)
&& !osm_physp_get_remote(p_physp)) {
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3315: "
"Unknown remote side for node 0x%016"
PRIx64
" (%s) port %u. Adding to light sweep sampling list\n",
cl_ntoh64(osm_node_get_node_guid
(p_node)),
p_node->print_desc, port_num);
osm_dump_dr_path(sm->p_log,
osm_physp_get_dr_path_ptr
(p_physp), OSM_LOG_ERROR);
state_mgr_get_remote_port_info(sm, p_physp);
}
}
}
cl_qmap_apply_func(&sm->p_subn->sm_guid_tbl, query_sm_info, sm);
CL_PLOCK_RELEASE(sm->p_lock);
_exit:
OSM_LOG_EXIT(sm->p_log);
return status;
}
static void do_sweep(osm_sm_t * sm)
{
ib_api_status_t status;
osm_remote_sm_t *p_remote_sm;
unsigned config_parsed = 0;
if (sm->p_subn->force_heavy_sweep) {
if (osm_subn_rescan_conf_files(sm->p_subn) < 0)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 331A: "
"osm_subn_rescan_conf_file failed\n");
else
config_parsed = 1;
}
if (sm->p_subn->sm_state != IB_SMINFO_STATE_MASTER &&
sm->p_subn->sm_state != IB_SMINFO_STATE_DISCOVERING)
return;
if (sm->p_subn->coming_out_of_standby)
/*
* Need to force re-write of sm_base_lid to all ports
* to do that we want all the ports to be considered
* foreign
*/
state_mgr_clean_known_lids(sm);
sm->master_sm_found = 0;
/*
* If we already have switches, then try a light sweep.
* Otherwise, this is probably our first discovery pass
* or we are connected in loopback. In both cases do a
* heavy sweep.
* Note: If we are connected in loopback we want a heavy
* sweep, since we will not be getting any traps if there is
* a lost connection.
*/
/* if we are in DISCOVERING state - this means it is either in
* initializing or wake up from STANDBY - run the heavy sweep */
if (cl_qmap_count(&sm->p_subn->sw_guid_tbl)
&& sm->p_subn->sm_state != IB_SMINFO_STATE_DISCOVERING
&& sm->p_subn->opt.force_heavy_sweep == FALSE
&& sm->p_subn->force_heavy_sweep == FALSE
&& sm->p_subn->force_reroute == FALSE
&& sm->p_subn->subnet_initialization_error == FALSE
&& (state_mgr_light_sweep_start(sm) == IB_SUCCESS)) {
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
if (!sm->p_subn->force_heavy_sweep) {
if (sm->p_subn->opt.sa_db_dump &&
!osm_sa_db_file_dump(sm->p_subn->p_osm))
osm_opensm_report_event(sm->p_subn->p_osm,
OSM_EVENT_ID_SA_DB_DUMPED, NULL);
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"LIGHT SWEEP COMPLETE");
return;
}
}
/*
* Unicast cache should be invalidated if there were errors
* during initialization or if subnet re-route is requested.
*/
if (sm->p_subn->opt.use_ucast_cache &&
(sm->p_subn->subnet_initialization_error ||
sm->p_subn->force_reroute || sm->p_subn->coming_out_of_standby))
osm_ucast_cache_invalidate(&sm->ucast_mgr);
/*
* If we don't need to do a heavy sweep and we want to do a reroute,
* just reroute only.
*/
if (cl_qmap_count(&sm->p_subn->sw_guid_tbl)
&& sm->p_subn->sm_state != IB_SMINFO_STATE_DISCOVERING
&& sm->p_subn->opt.force_heavy_sweep == FALSE
&& sm->p_subn->force_heavy_sweep == FALSE
&& sm->p_subn->force_reroute == TRUE
&& sm->p_subn->subnet_initialization_error == FALSE) {
/* Reset flag */
sm->p_subn->force_reroute = FALSE;
/* Re-program the switches fully */
sm->p_subn->ignore_existing_lfts = TRUE;
if (osm_ucast_mgr_process(&sm->ucast_mgr)) {
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"REROUTE FAILED");
return;
}
osm_qos_setup(sm->p_subn->p_osm);
/* Reset flag */
sm->p_subn->ignore_existing_lfts = FALSE;
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
if (!sm->p_subn->subnet_initialization_error) {
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"REROUTE COMPLETE");
osm_opensm_report_event(sm->p_subn->p_osm,
OSM_EVENT_ID_UCAST_ROUTING_DONE, NULL);
return;
}
}
osm_opensm_report_event(sm->p_subn->p_osm,
OSM_EVENT_ID_HEAVY_SWEEP_START, NULL);
/* go to heavy sweep */
repeat_discovery:
/* First of all - unset all flags */
sm->p_subn->force_heavy_sweep = FALSE;
sm->p_subn->force_reroute = FALSE;
sm->p_subn->subnet_initialization_error = FALSE;
/* Reset tracking values in case limiting component got removed
* from fabric. */
sm->p_subn->min_ca_mtu = IB_MAX_MTU;
sm->p_subn->min_ca_rate = IB_MAX_RATE;
sm->p_subn->min_data_vls = IB_MAX_NUM_VLS - 1;
/* rescan configuration updates */
if (!config_parsed && osm_subn_rescan_conf_files(sm->p_subn) < 0)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 331A: "
"osm_subn_rescan_conf_file failed\n");
if (sm->p_subn->sm_state != IB_SMINFO_STATE_MASTER)
sm->p_subn->need_update = 1;
status = state_mgr_sweep_hop_0(sm);
if (status != IB_SUCCESS ||
wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
if (state_mgr_is_sm_port_down(sm) == TRUE) {
if (sm->p_subn->last_sm_port_state) {
sm->p_subn->last_sm_port_state = 0;
osm_log(sm->p_log, OSM_LOG_SYS, "SM port is down\n");
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"SM PORT DOWN");
}
/* Run the drop manager - we want to clear all records */
osm_drop_mgr_process(sm);
/* Move to DISCOVERING state */
if (sm->p_subn->sm_state != IB_SMINFO_STATE_DISCOVERING)
osm_sm_state_mgr_process(sm, OSM_SM_SIGNAL_DISCOVER);
osm_opensm_report_event(sm->p_subn->p_osm,
OSM_EVENT_ID_STATE_CHANGE, NULL);
return;
} else {
if (!sm->p_subn->last_sm_port_state) {
sm->p_subn->last_sm_port_state = 1;
osm_log(sm->p_log, OSM_LOG_SYS, "SM port is up\n");
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"SM PORT UP");
}
}
status = state_mgr_sweep_hop_1(sm);
if (status != IB_SUCCESS ||
wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
/* discovery completed - check other sm presence */
if (sm->master_sm_found) {
/*
* Call the sm_state_mgr with signal
* MASTER_OR_HIGHER_SM_DETECTED_DONE
*/
osm_sm_state_mgr_process(sm,
OSM_SM_SIGNAL_MASTER_OR_HIGHER_SM_DETECTED);
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"ENTERING STANDBY STATE");
/* notify master SM about us */
osm_send_trap144(sm, 0);
osm_opensm_report_event(sm->p_subn->p_osm,
OSM_EVENT_ID_STATE_CHANGE, NULL);
return;
}
/* if new sweep requested - don't bother with the rest */
if (sm->p_subn->force_heavy_sweep)
goto repeat_discovery;
osm_opensm_report_event(sm->p_subn->p_osm,
OSM_EVENT_ID_HEAVY_SWEEP_DONE, NULL);
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE, "HEAVY SWEEP COMPLETE");
/* If we are MASTER - get the highest remote_sm, and
* see if it is higher than our local sm.
*/
if (sm->p_subn->sm_state == IB_SMINFO_STATE_MASTER) {
p_remote_sm = state_mgr_get_highest_sm(sm);
if (p_remote_sm != NULL) {
/* report new ports (trap 64) before leaving MASTER */
state_mgr_report_new_ports(sm);
/* need to handover the mastership
* to the remote sm, and move to standby */
state_mgr_send_handover(sm, p_remote_sm);
osm_sm_state_mgr_process(sm,
OSM_SM_SIGNAL_HANDOVER_SENT);
return;
} else {
/* We are the highest sm - check to see if there is
* a remote SM that is in master state. */
p_remote_sm = state_mgr_exists_other_master_sm(sm);
if (p_remote_sm != NULL) {
/* There is a remote SM that is master.
* need to wait for that SM to relinquish control
* of its portion of the subnet. C14-60.2.1.
* Also - need to start polling on that SM. */
sm->p_polling_sm = p_remote_sm;
osm_sm_state_mgr_process(sm,
OSM_SM_SIGNAL_WAIT_FOR_HANDOVER);
return;
}
}
}
/* Need to continue with lid assignment */
osm_drop_mgr_process(sm);
/*
* If we are not MASTER already - this means that we are
* in discovery state. call osm_sm_state_mgr with signal
* DISCOVERY_COMPLETED
*/
if (sm->p_subn->sm_state == IB_SMINFO_STATE_DISCOVERING)
osm_sm_state_mgr_process(sm, OSM_SM_SIGNAL_DISCOVERY_COMPLETED);
osm_pkey_mgr_process(sm->p_subn->p_osm);
/* try to restore SA DB (this should be before lid_mgr
because we may want to disable clients reregistration
when SA DB is restored) */
osm_sa_db_file_load(sm->p_subn->p_osm);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"PKEY and QOS setup completed - STARTING SM LID CONFIG");
osm_lid_mgr_process_sm(&sm->lid_mgr);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"SM LID ASSIGNMENT COMPLETE - STARTING SUBNET LID CONFIG");
state_mgr_notify_lid_change(sm);
osm_lid_mgr_process_subnet(&sm->lid_mgr);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
/* At this point we need to check the consistency of
* the port_lid_tbl under the subnet. There might be
* errors in it if PortInfo Set requests didn't reach
* their destination. */
state_mgr_check_tbl_consistency(sm);
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"LID ASSIGNMENT COMPLETE - STARTING SWITCH TABLE CONFIG");
/*
* Proceed with unicast forwarding table configuration; if it fails
* return early to wait for a trap or the next sweep interval.
*/
if (!sm->ucast_mgr.cache_valid ||
osm_ucast_cache_process(&sm->ucast_mgr))
if (osm_ucast_mgr_process(&sm->ucast_mgr))
return;
osm_qos_setup(sm->p_subn->p_osm);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
/* cleanup switch lft buffers */
cl_qmap_apply_func(&sm->p_subn->sw_guid_tbl, cleanup_switch, sm->p_log);
/* We are done setting all LFTs so clear the ignore existing.
* From now on, as long as we are still master, we want to
* take into account these lfts. */
sm->p_subn->ignore_existing_lfts = FALSE;
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"SWITCHES CONFIGURED FOR UNICAST");
osm_opensm_report_event(sm->p_subn->p_osm,
OSM_EVENT_ID_UCAST_ROUTING_DONE, NULL);
if (!sm->p_subn->opt.disable_multicast) {
osm_mcast_mgr_process(sm, TRUE);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"SWITCHES CONFIGURED FOR MULTICAST");
}
/*
* The LINK_PORTS state is required since we cannot count on
* the port state change MADs to succeed. This is an artifact
* of the spec defining state change from state X to state X
* as an error. The hardware then is not required to process
* other parameters provided by the Set(PortInfo) Packet.
*/
osm_link_mgr_process(sm, IB_LINK_NO_CHANGE);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"LINKS PORTS CONFIGURED - SET LINKS TO ARMED STATE");
osm_link_mgr_process(sm, IB_LINK_ARMED);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"LINKS ARMED - SET LINKS TO ACTIVE STATE");
osm_link_mgr_process(sm, IB_LINK_ACTIVE);
if (wait_for_pending_transactions(&sm->p_subn->p_osm->stats))
return;
/*
* The sweep completed!
*/
/*
* Send trap 64 on newly discovered endports
*/
state_mgr_report_new_ports(sm);
/* in any case we zero this flag */
sm->p_subn->coming_out_of_standby = FALSE;
/* If there were errors - then the subnet is not really up */
if (sm->p_subn->subnet_initialization_error == TRUE) {
osm_log(sm->p_log, OSM_LOG_SYS,
"Errors during initialization\n");
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_ERROR,
"ERRORS DURING INITIALIZATION");
} else {
sm->p_subn->need_update = 0;
osm_dump_all(sm->p_subn->p_osm);
state_mgr_up_msg(sm);
sm->p_subn->first_time_master_sweep = FALSE;
if (osm_log_is_active(sm->p_log, OSM_LOG_VERBOSE) ||
sm->p_subn->opt.sa_db_dump)
osm_sa_db_file_dump(sm->p_subn->p_osm);
}
/*
* Finally signal the subnet up event
*/
cl_event_signal(&sm->subnet_up_event);
osm_opensm_report_event(sm->p_subn->p_osm, OSM_EVENT_ID_SUBNET_UP,
NULL);
/* if we got a signal to force heavy sweep or errors
* in the middle of the sweep - try another sweep. */
if (sm->p_subn->force_heavy_sweep
|| sm->p_subn->subnet_initialization_error)
osm_sm_signal(sm, OSM_SIGNAL_SWEEP);
}
int osm_ucast_mgr_build_lid_matrices(IN osm_ucast_mgr_t * p_mgr)
{
uint32_t i;
uint32_t iteration_max;
cl_qmap_t *p_sw_guid_tbl;
p_sw_guid_tbl = &p_mgr->p_subn->sw_guid_tbl;
OSM_LOG(p_mgr->p_log, OSM_LOG_VERBOSE,
"Starting switches' Min Hop Table Assignment\n");
/*
Set up the weighting factors for the routing.
*/
cl_qmap_apply_func(p_sw_guid_tbl, set_default_hop_wf, NULL);
if (p_mgr->p_subn->opt.hop_weights_file) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Fetching hop weight factor file \'%s\'\n",
p_mgr->p_subn->opt.hop_weights_file);
if (parse_node_map(p_mgr->p_subn->opt.hop_weights_file,
set_hop_wf, p_mgr)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 3A05: "
"cannot parse hop_weights_file \'%s\'\n",
p_mgr->p_subn->opt.hop_weights_file);
}
}
/*
Set the switch matrices for each switch's own port 0 LID(s)
then set the lid matrices for the each switch's leaf nodes.
*/
cl_qmap_apply_func(p_sw_guid_tbl, ucast_mgr_process_hop_0_1, p_mgr);
/*
Get the switch matrices for each switch's neighbors.
This process requires a number of iterations equal to
the number of switches in the subnet minus 1.
In each iteration, a switch learns the lid/port/hop
information (as contained by a switch's lid matrix) from
its immediate neighbors. After each iteration, a switch
(and it's neighbors) know more routing information than
it did on the previous iteration.
Thus, by repeatedly absorbing the routing information of
neighbor switches, every switch eventually learns how to
route all LIDs on the subnet.
Note that there may not be any switches in the subnet if
we are in simple p2p configuration.
*/
iteration_max = cl_qmap_count(p_sw_guid_tbl);
/*
If there are switches in the subnet, iterate until the lid
matrix has been constructed. Otherwise, just immediately
indicate we're done if no switches exist.
*/
if (iteration_max) {
iteration_max--;
/*
we need to find out when the propagation of
hop counts has relaxed. So this global variable
is preset to 0 on each iteration and if
if non of the switches was set will exit the
while loop
*/
p_mgr->some_hop_count_set = TRUE;
for (i = 0; (i < iteration_max) && p_mgr->some_hop_count_set;
i++) {
p_mgr->some_hop_count_set = FALSE;
cl_qmap_apply_func(p_sw_guid_tbl,
ucast_mgr_process_neighbors, p_mgr);
}
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Min-hop propagated in %d steps\n", i);
}
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);
}
/**********************************************************************
Initiates a thorough sweep of the subnet.
Used when there is suspicion that something on the subnet has changed.
**********************************************************************/
static ib_api_status_t state_mgr_sweep_hop_0(IN osm_sm_t * sm)
{
ib_api_status_t status;
osm_dr_path_t dr_path;
osm_bind_handle_t h_bind;
uint8_t path_array[IB_SUBNET_PATH_HOPS_MAX];
OSM_LOG_ENTER(sm->p_log);
memset(path_array, 0, sizeof(path_array));
/*
* First, get the bind handle.
*/
h_bind = osm_sm_mad_ctrl_get_bind_handle(&sm->mad_ctrl);
if (h_bind != OSM_BIND_INVALID_HANDLE) {
OSM_LOG_MSG_BOX(sm->p_log, OSM_LOG_VERBOSE,
"INITIATING HEAVY SWEEP");
/*
* Start the sweep by clearing the port counts, then
* get our own NodeInfo at 0 hops.
*/
CL_PLOCK_ACQUIRE(sm->p_lock);
cl_qmap_apply_func(&sm->p_subn->node_guid_tbl,
state_mgr_reset_node_count, sm);
cl_qmap_apply_func(&sm->p_subn->port_guid_tbl,
state_mgr_reset_port_count, sm);
cl_qmap_apply_func(&sm->p_subn->sw_guid_tbl,
state_mgr_reset_switch_count, sm);
/* Set the in_sweep_hop_0 flag in subn to be TRUE.
* This will indicate the sweeping not 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 somehow not to continue
* the sweeping. */
sm->p_subn->in_sweep_hop_0 = TRUE;
CL_PLOCK_RELEASE(sm->p_lock);
osm_dr_path_init(&dr_path, 0, path_array);
CL_PLOCK_ACQUIRE(sm->p_lock);
status = osm_req_get(sm, &dr_path, IB_MAD_ATTR_NODE_INFO, 0,
CL_DISP_MSGID_NONE, NULL);
CL_PLOCK_RELEASE(sm->p_lock);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR, "ERR 3305: "
"Request for NodeInfo failed (%s)\n",
ib_get_err_str(status));
} else {
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"No bound ports. Deferring sweep...\n");
status = IB_INVALID_STATE;
}
OSM_LOG_EXIT(sm->p_log);
return status;
}
