void cl_event_wheel_unreg(IN cl_event_wheel_t * const p_event_wheel,
IN uint64_t key)
{
cl_event_wheel_reg_info_t *p_event;
cl_map_item_t *p_map_item;
CL_DBG("cl_event_wheel_unreg: " "Removing key:0x%" PRIx64 "\n", key);
cl_spinlock_acquire(&p_event_wheel->lock);
p_map_item = cl_qmap_get(&p_event_wheel->events_map, key);
if (p_map_item != cl_qmap_end(&p_event_wheel->events_map)) {
/* we found such an item. */
p_event =
PARENT_STRUCT(p_map_item, cl_event_wheel_reg_info_t,
map_item);
/* remove the item from the qlist */
cl_qlist_remove_item(&p_event_wheel->events_wheel,
&(p_event->list_item));
/* remove the item from the qmap */
cl_qmap_remove_item(&p_event_wheel->events_map,
&(p_event->map_item));
CL_DBG("cl_event_wheel_unreg: Removed key:0x%" PRIx64 "\n",
key);
/* free the item */
free(p_event);
} else {
CL_DBG("cl_event_wheel_unreg: did not find key:0x%" PRIx64
"\n", key);
}
cl_spinlock_release(&p_event_wheel->lock);
}
/**********************************************************************
* Internal call db->lock should be held when calling
**********************************************************************/
static inline db_node_t *get(perfmgr_db_t * db, uint64_t guid)
{
cl_map_item_t *rc = cl_qmap_get(&db->pc_data, guid);
const cl_map_item_t *end = cl_qmap_end(&db->pc_data);
if (rc == end)
return NULL;
return (db_node_t *) rc;
}
static cache_switch_t *cache_get_sw(osm_ucast_mgr_t * p_mgr, uint16_t lid_ho)
{
cache_switch_t *p_cache_sw = (cache_switch_t *)
cl_qmap_get(&p_mgr->cache_sw_tbl, lid_ho);
if (p_cache_sw == (cache_switch_t *)
cl_qmap_end(&p_mgr->cache_sw_tbl))
p_cache_sw = NULL;
return p_cache_sw;
}
/*
* This function gets port entry pointer from DB
*
* @param[in] port_id - port ID
*
* @return pointer to port_entry, NULL if not found
*/
static struct mlag_lacp_entry *
lacp_entry_get(unsigned long port_id)
{
cl_map_item_t *map_item = NULL;
struct mlag_lacp_entry *lacp_entry = NULL;
map_item = cl_qmap_get(&(mlag_lacp_db.port_map), (uint64_t)port_id);
if (map_item != cl_qmap_end(&(mlag_lacp_db.port_map))) {
lacp_entry = PARENT_STRUCT(map_item, struct mlag_lacp_entry, map_item);
}
static uint16_t generate_pkey(osm_subn_t * p_subn)
{
uint16_t pkey;
cl_qmap_t *m = &p_subn->prtn_pkey_tbl;
while (global_pkey_counter < cl_ntoh16(IB_DEFAULT_PARTIAL_PKEY) - 1) {
pkey = ++global_pkey_counter;
pkey = cl_hton16(pkey);
if (cl_qmap_get(m, pkey) == cl_qmap_end(m))
return pkey;
}
return 0;
}
ib_api_status_t
osm_transaction_mgr_get_madw_for_tid(IN osm_vendor_t * const p_vend,
IN ib_mad_t * const p_mad,
OUT osm_madw_t ** req_madw_p)
{
osm_transaction_mgr_t *trans_mgr_p;
osm_madw_req_t *osm_madw_req_p;
cl_map_item_t *p_map_item;
uint64_t key;
OSM_LOG_ENTER(p_vend->p_log);
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
*req_madw_p = NULL;
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_get_madw_for_tid: "
"Looking for TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
key = (uint64_t) p_mad->trans_id;
cl_spinlock_acquire(&(trans_mgr_p->transaction_mgr_lock));
p_map_item = cl_qmap_get(trans_mgr_p->madw_by_tid_map_p, key);
if (p_map_item != cl_qmap_end(trans_mgr_p->madw_by_tid_map_p)) {
/* we found such an item. */
/* get the osm_madw_req_p */
osm_madw_req_p =
PARENT_STRUCT(p_map_item, osm_madw_req_t, map_item);
/* Since the Transaction was looked up and provided for */
/* processing we retire it */
cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
&(osm_madw_req_p->list_item));
/* remove the item from the qmap */
cl_qmap_remove_item(trans_mgr_p->madw_by_tid_map_p,
&(osm_madw_req_p->map_item));
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_get_madw_for_tid: "
"Removed TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
*req_madw_p = osm_madw_req_p->p_madw;
}
cl_spinlock_release(&(trans_mgr_p->transaction_mgr_lock));
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_get_madw_for_tid: "
"Got MADW:%p.\n", *req_madw_p);
OSM_LOG_EXIT(p_vend->p_log);
return (IB_SUCCESS);
}
ib_api_status_t
osm_transaction_mgr_erase_madw(IN osm_vendor_t * const p_vend,
IN ib_mad_t * p_mad)
{
osm_transaction_mgr_t *trans_mgr_p;
osm_madw_req_t *osm_madw_req_p;
uint64_t key;
cl_map_item_t *p_map_item;
OSM_LOG_ENTER(p_vend->p_log);
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
key = (uint64_t) p_mad->trans_id;
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_erase_madw: "
"Removing TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
cl_spinlock_acquire(&trans_mgr_p->transaction_mgr_lock);
p_map_item = cl_qmap_get(trans_mgr_p->madw_by_tid_map_p, key);
if (p_map_item != cl_qmap_end(trans_mgr_p->madw_by_tid_map_p)) {
/* we found such an item. */
/* get the osm_madw_req_p */
osm_madw_req_p =
PARENT_STRUCT(p_map_item, osm_madw_req_t, map_item);
/* remove the item from the qlist */
cl_qlist_remove_item(trans_mgr_p->madw_reqs_list_p,
&(osm_madw_req_p->list_item));
/* remove the item from the qmap */
cl_qmap_remove_item(trans_mgr_p->madw_by_tid_map_p,
&(osm_madw_req_p->map_item));
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_erase_madw: "
"Removed TID:<0x%" PRIx64 ">.\n", p_mad->trans_id);
/* free the item */
free(osm_madw_req_p);
} else {
osm_log(p_vend->p_log, OSM_LOG_DEBUG,
"osm_transaction_mgr_erase_madw: "
"osm_transaction_mgr_erase_madw:<0x%" PRIx64
"> NOT FOUND.\n", p_mad->trans_id);
}
cl_spinlock_release(&trans_mgr_p->transaction_mgr_lock);
OSM_LOG_EXIT(p_vend->p_log);
return (IB_SUCCESS);
}
/**********************************************************************
* print node data to fp
**********************************************************************/
void
perfmgr_db_print_by_guid(perfmgr_db_t * db, uint64_t nodeguid, FILE *fp,
char *port, int err_only)
{
cl_map_item_t *node;
cl_plock_acquire(&db->lock);
node = cl_qmap_get(&db->pc_data, nodeguid);
if (node != cl_qmap_end(&db->pc_data))
dump_node_hr((db_node_t *)node, fp, port, err_only);
else
fprintf(fp, "Node 0x%" PRIx64 " not found...\n", nodeguid);
cl_plock_release(&db->lock);
}
char *remap_node_name(nn_map_t * map, uint64_t target_guid, char *nodedesc)
{
char *rc = NULL;
name_map_item_t *item = NULL;
if (!map)
goto done;
item = (name_map_item_t *) cl_qmap_get(map, target_guid);
if (item != (name_map_item_t *) cl_qmap_end(map))
rc = strdup(item->name);
done:
if (rc == NULL)
rc = strdup(clean_nodedesc(nodedesc));
return (rc);
}
ib_api_status_t
__osmv_txnmgr_lookup(IN osmv_txn_mgr_t * p_tx_mgr,
IN uint64_t key, OUT osmv_txn_ctx_t ** pp_txn)
{
ib_api_status_t status = IB_SUCCESS;
cl_map_item_t *p_item;
cl_map_obj_t *p_obj;
uint64_t tmp_key;
OSM_LOG_ENTER(p_tx_mgr->p_log);
CL_ASSERT(p_tx_mgr);
CL_ASSERT(pp_txn);
osm_log(p_tx_mgr->p_log, OSM_LOG_DEBUG,
"__osmv_txnmgr_lookup: "
"Looking for key: 0x%llX in map ptr:%p\n", key,
p_tx_mgr->p_txn_map);
p_item = cl_qmap_head(p_tx_mgr->p_txn_map);
while (p_item != cl_qmap_end(p_tx_mgr->p_txn_map)) {
tmp_key = cl_qmap_key(p_item);
osm_log(p_tx_mgr->p_log, OSM_LOG_DEBUG,
"__osmv_txnmgr_lookup: "
"Found key 0x%llX \n", tmp_key);
p_item = cl_qmap_next(p_item);
}
p_item = cl_qmap_get(p_tx_mgr->p_txn_map, key);
if (cl_qmap_end(p_tx_mgr->p_txn_map) == p_item) {
status = IB_NOT_FOUND;
} else {
p_obj = PARENT_STRUCT(p_item, cl_map_obj_t, item);
*pp_txn = cl_qmap_obj(p_obj);
}
OSM_LOG_EXIT(p_tx_mgr->p_log);
return status;
}
Status_t
sm_routing_makeModule(const char * name, RoutingModule_t ** module)
{
cl_map_item_t * it;
*module = NULL;
if (name == NULL || strlen(name) == 0)
return VSTATUS_ILLPARM;
if ((it = cl_qmap_get(&moduleFacMap, UGLY_CHAR_U64(name))) == cl_qmap_end(&moduleFacMap))
return VSTATUS_BAD;
routing_mod_factory fac = cl_qmap_obj((const cl_map_obj_t * const) it);
Status_t s;
if ((s = vs_pool_alloc(&sm_pool, sizeof(RoutingModule_t), (void*)module)) != VSTATUS_OK) {
return s;
}
memset(*module, 0, sizeof(RoutingModule_t));
return fac(*module);
}
uint32_t cl_event_wheel_num_regs(IN cl_event_wheel_t * const p_event_wheel,
IN uint64_t key)
{
cl_event_wheel_reg_info_t *p_event;
cl_map_item_t *p_map_item;
uint32_t num_regs = 0;
/* try to find the key in the map */
CL_DBG("cl_event_wheel_num_regs: Looking for key:0x%" PRIx64 "\n", key);
cl_spinlock_acquire(&p_event_wheel->lock);
p_map_item = cl_qmap_get(&p_event_wheel->events_map, key);
if (p_map_item != cl_qmap_end(&p_event_wheel->events_map)) {
/* ok so we can simply return it's num_regs */
p_event =
PARENT_STRUCT(p_map_item, cl_event_wheel_reg_info_t,
map_item);
num_regs = p_event->num_regs;
}
cl_spinlock_release(&p_event_wheel->lock);
return (num_regs);
}
Status_t
sm_routing_addModuleFac(const char * name, routing_mod_factory fac)
{
Status_t s;
cl_map_obj_t * wrp = NULL;
if (name == NULL || strlen(name) == 0 || fac == NULL)
return VSTATUS_ILLPARM;
if (cl_qmap_get(&moduleFacMap, UGLY_CHAR_U64(name)) != cl_qmap_end(&moduleFacMap))
return VSTATUS_BAD;
if ((s = vs_pool_alloc(&sm_pool, sizeof(cl_map_obj_t), (void*)&wrp)) != VSTATUS_OK)
return s;
memset(wrp, 0, sizeof(*wrp));
wrp->p_object = fac;
if (cl_qmap_insert(&moduleFacMap, UGLY_CHAR_U64(name), &wrp->item) == NULL)
return VSTATUS_BAD;
return VSTATUS_OK;
}
static ib_api_status_t mpr_rcv_get_path_parms(IN osm_sa_t * sa,
IN const ib_multipath_rec_t *
p_mpr,
IN const osm_alias_guid_t * p_src_alias_guid,
IN const osm_alias_guid_t * p_dest_alias_guid,
IN const uint16_t dest_lid_ho,
IN const ib_net64_t comp_mask,
OUT osm_path_parms_t * p_parms)
{
const osm_node_t *p_node;
const osm_physp_t *p_physp, *p_physp0;
const osm_physp_t *p_src_physp;
const osm_physp_t *p_dest_physp;
const osm_prtn_t *p_prtn = NULL;
const ib_port_info_t *p_pi, *p_pi0;
ib_slvl_table_t *p_slvl_tbl;
ib_api_status_t status = IB_SUCCESS;
uint8_t mtu;
uint8_t rate;
uint8_t pkt_life;
uint8_t required_mtu;
uint8_t required_rate;
ib_net16_t required_pkey;
uint8_t required_sl;
uint8_t required_pkt_life;
ib_net16_t dest_lid;
int hops = 0;
int in_port_num = 0;
uint8_t i;
osm_qos_level_t *p_qos_level = NULL;
uint16_t valid_sl_mask = 0xffff;
OSM_LOG_ENTER(sa->p_log);
dest_lid = cl_hton16(dest_lid_ho);
p_dest_physp = p_dest_alias_guid->p_base_port->p_physp;
p_physp = p_src_alias_guid->p_base_port->p_physp;
p_src_physp = p_physp;
p_pi = &p_physp->port_info;
mtu = ib_port_info_get_mtu_cap(p_pi);
rate = ib_port_info_compute_rate(p_pi,
p_pi->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS);
/*
Mellanox Tavor device performance is better using 1K MTU.
If required MTU and MTU selector are such that 1K is OK
and at least one end of the path is Tavor we override the
port MTU with 1K.
*/
if (sa->p_subn->opt.enable_quirks &&
sa_multipath_rec_apply_tavor_mtu_limit(p_mpr,
p_src_alias_guid->p_base_port,
p_dest_alias_guid->p_base_port,
comp_mask))
if (mtu > IB_MTU_LEN_1024) {
mtu = IB_MTU_LEN_1024;
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Optimized Path MTU to 1K for Mellanox Tavor device\n");
}
/*
Walk the subnet object from source to destination,
tracking the most restrictive rate and mtu values along the way...
If source port node is a switch, then p_physp should
point to the port that routes the destination lid
*/
p_node = osm_physp_get_node_ptr(p_physp);
if (p_node->sw) {
/*
* Source node is a switch.
* Make sure that p_physp points to the out port of the
* switch that routes to the destination lid (dest_lid_ho)
*/
p_physp = osm_switch_get_route_by_lid(p_node->sw, dest_lid);
if (p_physp == 0) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4514: "
"Can't find routing to LID %u on switch %s "
"(GUID 0x%016"PRIx64")\n", dest_lid_ho,
p_node->print_desc,
cl_ntoh64(osm_node_get_node_guid(p_node)));
status = IB_NOT_FOUND;
goto Exit;
}
}
if (sa->p_subn->opt.qos) {
/*
* Whether this node is switch or CA, the IN port for
* the sl2vl table is 0, because this is a source node.
*/
p_slvl_tbl = osm_physp_get_slvl_tbl(p_physp, 0);
/* update valid SLs that still exist on this route */
for (i = 0; i < IB_MAX_NUM_VLS; i++) {
if (valid_sl_mask & (1 << i) &&
ib_slvl_table_get(p_slvl_tbl, i) == IB_DROP_VL)
valid_sl_mask &= ~(1 << i);
}
if (!valid_sl_mask) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"All the SLs lead to VL15 on this path\n");
status = IB_NOT_FOUND;
goto Exit;
}
}
/*
* Same as above
*/
p_node = osm_physp_get_node_ptr(p_dest_physp);
if (p_node->sw) {
/*
* if destination is switch, we want p_dest_physp to point to port 0
*/
p_dest_physp =
osm_switch_get_route_by_lid(p_node->sw, dest_lid);
if (p_dest_physp == 0) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4515: "
"Can't find routing to LID %u on switch %s "
"(GUID 0x%016"PRIx64")\n", dest_lid_ho,
p_node->print_desc,
cl_ntoh64(osm_node_get_node_guid(p_node)));
status = IB_NOT_FOUND;
goto Exit;
}
}
/*
* Now go through the path step by step
*/
while (p_physp != p_dest_physp) {
int tmp_pnum = p_physp->port_num;
p_node = osm_physp_get_node_ptr(p_physp);
p_physp = osm_physp_get_remote(p_physp);
if (p_physp == 0) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4505: "
"Can't find remote phys port of %s (GUID "
"0x%016"PRIx64") port %d "
"while routing to LID %u",
p_node->print_desc,
cl_ntoh64(osm_node_get_node_guid(p_node)),
tmp_pnum,
dest_lid_ho);
status = IB_ERROR;
goto Exit;
}
/* update number of hops traversed */
hops++;
if (hops > MAX_HOPS) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4520: "
"Path from GUID 0x%016" PRIx64 " (%s) to"
" lid %u GUID 0x%016" PRIx64 " (%s) needs"
" more than %d hops, max %d hops allowed\n",
cl_ntoh64(osm_physp_get_port_guid(p_src_physp)),
p_src_physp->p_node->print_desc, dest_lid_ho,
cl_ntoh64(osm_physp_get_port_guid
(p_dest_physp)),
p_dest_physp->p_node->print_desc, hops,
MAX_HOPS);
status = IB_NOT_FOUND;
goto Exit;
}
in_port_num = osm_physp_get_port_num(p_physp);
/*
This is point to point case (no switch in between)
*/
if (p_physp == p_dest_physp)
break;
p_node = osm_physp_get_node_ptr(p_physp);
if (!p_node->sw) {
/*
There is some sort of problem in the subnet object!
If this isn't a switch, we should have reached
the destination by now!
*/
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4503: "
"Internal error, bad path while routing "
"from %s (GUID: 0x%016"PRIx64") port %d "
"to %s (GUID: 0x%016"PRIx64") port %d; "
"ended at %s port %d\n",
p_src_alias_guid->p_base_port->p_node->print_desc,
cl_ntoh64(p_src_alias_guid->p_base_port->p_node->node_info.node_guid),
p_src_alias_guid->p_base_port->p_physp->port_num,
p_dest_alias_guid->p_base_port->p_node->print_desc,
cl_ntoh64(p_dest_alias_guid->p_base_port->p_node->node_info.node_guid),
p_dest_alias_guid->p_base_port->p_physp->port_num,
p_node->print_desc,
p_physp->port_num);
status = IB_ERROR;
goto Exit;
}
/*
Check parameters for the ingress port in this switch.
*/
p_pi = &p_physp->port_info;
if (mtu > ib_port_info_get_mtu_cap(p_pi))
mtu = ib_port_info_get_mtu_cap(p_pi);
p_physp0 = osm_node_get_physp_ptr((osm_node_t *)p_node, 0);
p_pi0 = &p_physp0->port_info;
if (ib_path_compare_rates(rate,
ib_port_info_compute_rate(p_pi,
p_pi0->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS)) > 0)
rate = ib_port_info_compute_rate(p_pi,
p_pi0->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS);
/*
Continue with the egress port on this switch.
*/
p_physp = osm_switch_get_route_by_lid(p_node->sw, dest_lid);
if (p_physp == 0) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4516: "
"Dead end path on switch "
"%s (GUID: 0x%016"PRIx64") to LID %u\n",
p_node->print_desc,
cl_ntoh64(osm_node_get_node_guid(p_node)),
dest_lid_ho);
status = IB_ERROR;
goto Exit;
}
p_pi = &p_physp->port_info;
if (mtu > ib_port_info_get_mtu_cap(p_pi))
mtu = ib_port_info_get_mtu_cap(p_pi);
p_physp0 = osm_node_get_physp_ptr((osm_node_t *)p_node, 0);
p_pi0 = &p_physp0->port_info;
if (ib_path_compare_rates(rate,
ib_port_info_compute_rate(p_pi,
p_pi0->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS)) > 0)
rate = ib_port_info_compute_rate(p_pi,
p_pi0->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS);
if (sa->p_subn->opt.qos) {
/*
* Check SL2VL table of the switch and update valid SLs
*/
p_slvl_tbl =
osm_physp_get_slvl_tbl(p_physp, in_port_num);
for (i = 0; i < IB_MAX_NUM_VLS; i++) {
if (valid_sl_mask & (1 << i) &&
ib_slvl_table_get(p_slvl_tbl,
i) == IB_DROP_VL)
valid_sl_mask &= ~(1 << i);
}
if (!valid_sl_mask) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"All the SLs lead to VL15 "
"on this path\n");
status = IB_NOT_FOUND;
goto Exit;
}
}
}
/*
p_physp now points to the destination
*/
p_pi = &p_physp->port_info;
if (mtu > ib_port_info_get_mtu_cap(p_pi))
mtu = ib_port_info_get_mtu_cap(p_pi);
if (ib_path_compare_rates(rate,
ib_port_info_compute_rate(p_pi,
p_pi->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS)) > 0)
rate = ib_port_info_compute_rate(p_pi,
p_pi->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS);
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"Path min MTU = %u, min rate = %u\n", mtu, rate);
/*
* Get QoS Level object according to the MultiPath request
* and adjust MultiPath parameters according to QoS settings
*/
if (sa->p_subn->opt.qos && sa->p_subn->p_qos_policy &&
(p_qos_level =
osm_qos_policy_get_qos_level_by_mpr(sa->p_subn->p_qos_policy,
p_mpr, p_src_physp,
p_dest_physp, comp_mask))) {
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"MultiPathRecord request matches QoS Level '%s' (%s)\n",
p_qos_level->name,
p_qos_level->use ? p_qos_level->use : "no description");
if (p_qos_level->mtu_limit_set
&& (mtu > p_qos_level->mtu_limit))
mtu = p_qos_level->mtu_limit;
if (p_qos_level->rate_limit_set
&& (ib_path_compare_rates(rate, p_qos_level->rate_limit) > 0))
rate = p_qos_level->rate_limit;
if (p_qos_level->sl_set) {
required_sl = p_qos_level->sl;
if (!(valid_sl_mask & (1 << required_sl))) {
status = IB_NOT_FOUND;
goto Exit;
}
}
}
/*
Determine if these values meet the user criteria
*/
/* we silently ignore cases where only the MTU selector is defined */
if ((comp_mask & IB_MPR_COMPMASK_MTUSELEC) &&
(comp_mask & IB_MPR_COMPMASK_MTU)) {
required_mtu = ib_multipath_rec_mtu(p_mpr);
switch (ib_multipath_rec_mtu_sel(p_mpr)) {
case 0: /* must be greater than */
if (mtu <= required_mtu)
status = IB_NOT_FOUND;
break;
case 1: /* must be less than */
if (mtu >= required_mtu) {
/* adjust to use the highest mtu
lower then the required one */
if (required_mtu > 1)
mtu = required_mtu - 1;
else
status = IB_NOT_FOUND;
}
break;
case 2: /* exact match */
if (mtu < required_mtu)
status = IB_NOT_FOUND;
else
mtu = required_mtu;
break;
case 3: /* largest available */
/* can't be disqualified by this one */
break;
default:
/* if we're here, there's a bug in ib_multipath_rec_mtu_sel() */
CL_ASSERT(FALSE);
status = IB_ERROR;
break;
}
}
if (status != IB_SUCCESS)
goto Exit;
/* we silently ignore cases where only the Rate selector is defined */
if ((comp_mask & IB_MPR_COMPMASK_RATESELEC) &&
(comp_mask & IB_MPR_COMPMASK_RATE)) {
required_rate = ib_multipath_rec_rate(p_mpr);
switch (ib_multipath_rec_rate_sel(p_mpr)) {
case 0: /* must be greater than */
if (ib_path_compare_rates(rate, required_rate) <= 0)
status = IB_NOT_FOUND;
break;
case 1: /* must be less than */
if (ib_path_compare_rates(rate, required_rate) >= 0) {
/* adjust the rate to use the highest rate
lower then the required one */
rate = ib_path_rate_get_prev(required_rate);
if (!rate)
status = IB_NOT_FOUND;
}
break;
case 2: /* exact match */
if (ib_path_compare_rates(rate, required_rate))
status = IB_NOT_FOUND;
else
rate = required_rate;
break;
case 3: /* largest available */
/* can't be disqualified by this one */
break;
default:
/* if we're here, there's a bug in ib_multipath_rec_mtu_sel() */
CL_ASSERT(FALSE);
status = IB_ERROR;
break;
}
}
if (status != IB_SUCCESS)
goto Exit;
/* Verify the pkt_life_time */
/* According to spec definition IBA 1.2 Table 205 PacketLifeTime description,
for loopback paths, packetLifeTime shall be zero. */
if (p_src_alias_guid->p_base_port == p_dest_alias_guid->p_base_port)
pkt_life = 0; /* loopback */
else if (p_qos_level && p_qos_level->pkt_life_set)
pkt_life = p_qos_level->pkt_life;
else
pkt_life = sa->p_subn->opt.subnet_timeout;
/* we silently ignore cases where only the PktLife selector is defined */
if ((comp_mask & IB_MPR_COMPMASK_PKTLIFETIMESELEC) &&
(comp_mask & IB_MPR_COMPMASK_PKTLIFETIME)) {
required_pkt_life = ib_multipath_rec_pkt_life(p_mpr);
switch (ib_multipath_rec_pkt_life_sel(p_mpr)) {
case 0: /* must be greater than */
if (pkt_life <= required_pkt_life)
status = IB_NOT_FOUND;
break;
case 1: /* must be less than */
if (pkt_life >= required_pkt_life) {
/* adjust the lifetime to use the highest possible
lower then the required one */
if (required_pkt_life > 1)
pkt_life = required_pkt_life - 1;
else
status = IB_NOT_FOUND;
}
break;
case 2: /* exact match */
if (pkt_life < required_pkt_life)
status = IB_NOT_FOUND;
else
pkt_life = required_pkt_life;
break;
case 3: /* smallest available */
/* can't be disqualified by this one */
break;
default:
/* if we're here, there's a bug in ib_path_rec_pkt_life_sel() */
CL_ASSERT(FALSE);
status = IB_ERROR;
break;
}
}
if (status != IB_SUCCESS)
goto Exit;
/*
* set Pkey for this MultiPath record request
*/
if (comp_mask & IB_MPR_COMPMASK_RAWTRAFFIC &&
cl_ntoh32(p_mpr->hop_flow_raw) & (1 << 31))
required_pkey =
osm_physp_find_common_pkey(p_src_physp, p_dest_physp,
sa->p_subn->opt.allow_both_pkeys);
else if (comp_mask & IB_MPR_COMPMASK_PKEY) {
/*
* MPR request has a specific pkey:
* Check that source and destination share this pkey.
* If QoS level has pkeys, check that this pkey exists
* in the QoS level pkeys.
* MPR returned pkey is the requested pkey.
*/
required_pkey = p_mpr->pkey;
if (!osm_physp_share_this_pkey
(p_src_physp, p_dest_physp, required_pkey,
sa->p_subn->opt.allow_both_pkeys)) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4518: "
"Ports src 0x%016"PRIx64" (%s port %d) "
"and dst 0x%016"PRIx64" (%s port %d) "
"do not share the specified PKey 0x%04x\n",
cl_ntoh64(osm_physp_get_port_guid(p_src_physp)),
p_src_physp->p_node->print_desc,
p_src_physp->port_num,
cl_ntoh64(osm_physp_get_port_guid
(p_dest_physp)),
p_dest_physp->p_node->print_desc,
p_dest_physp->port_num,
cl_ntoh16(required_pkey));
status = IB_NOT_FOUND;
goto Exit;
}
if (p_qos_level && p_qos_level->pkey_range_len &&
!osm_qos_level_has_pkey(p_qos_level, required_pkey)) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 451C: "
"Ports src 0x%016"PRIx64" (%s port %d) "
"and dst 0x%016"PRIx64" (%s port %d) "
"do not share specified PKey (0x%04x) as "
"defined by QoS level \"%s\"\n",
cl_ntoh64(osm_physp_get_port_guid(p_src_physp)),
p_src_physp->p_node->print_desc,
p_src_physp->port_num,
cl_ntoh64(osm_physp_get_port_guid
(p_dest_physp)),
p_dest_physp->p_node->print_desc,
p_dest_physp->port_num,
cl_ntoh16(required_pkey),
p_qos_level->name);
status = IB_NOT_FOUND;
goto Exit;
}
} else if (p_qos_level && p_qos_level->pkey_range_len) {
/*
* MPR request doesn't have a specific pkey, but QoS level
* has pkeys - get shared pkey from QoS level pkeys
*/
required_pkey = osm_qos_level_get_shared_pkey(p_qos_level,
p_src_physp,
p_dest_physp,
sa->p_subn->opt.allow_both_pkeys);
if (!required_pkey) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 451D: "
"Ports src 0x%016"PRIx64" (%s port %d) "
"and dst 0x%016"PRIx64" (%s port %d) "
"do not share a PKey as defined by QoS "
"level \"%s\"\n",
cl_ntoh64(osm_physp_get_port_guid(p_src_physp)),
p_src_physp->p_node->print_desc,
p_src_physp->port_num,
cl_ntoh64(osm_physp_get_port_guid
(p_dest_physp)),
p_dest_physp->p_node->print_desc,
p_dest_physp->port_num,
p_qos_level->name);
status = IB_NOT_FOUND;
goto Exit;
}
} else {
/*
* Neither MPR request nor QoS level have pkey.
* Just get any shared pkey.
*/
required_pkey =
osm_physp_find_common_pkey(p_src_physp, p_dest_physp,
sa->p_subn->opt.allow_both_pkeys);
if (!required_pkey) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 4519: "
"Ports src 0x%016"PRIx64" (%s port %d) "
"and dst 0x%016"PRIx64" (%s port %d) "
"do not have any shared PKeys\n",
cl_ntoh64(osm_physp_get_port_guid(p_src_physp)),
p_src_physp->p_node->print_desc,
p_src_physp->port_num,
cl_ntoh64(osm_physp_get_port_guid
(p_dest_physp)),
p_dest_physp->p_node->print_desc,
p_dest_physp->port_num);
status = IB_NOT_FOUND;
goto Exit;
}
}
if (required_pkey) {
p_prtn =
(osm_prtn_t *) cl_qmap_get(&sa->p_subn->prtn_pkey_tbl,
required_pkey &
cl_ntoh16((uint16_t) ~ 0x8000));
if (p_prtn ==
(osm_prtn_t *) cl_qmap_end(&sa->p_subn->prtn_pkey_tbl))
p_prtn = NULL;
}
/*
* Set MultiPathRecord SL.
*/
if (comp_mask & IB_MPR_COMPMASK_SL) {
/*
* Specific SL was requested
*/
required_sl = ib_multipath_rec_sl(p_mpr);
if (p_qos_level && p_qos_level->sl_set &&
p_qos_level->sl != required_sl) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 451E: "
"QoS constraints: required MultiPathRecord SL "
"(%u) doesn't match QoS policy \"%s\" SL (%u) "
"[%s port %d <-> %s port %d]\n", required_sl,
p_qos_level->name,
p_qos_level->sl,
p_src_alias_guid->p_base_port->p_node->print_desc,
p_src_alias_guid->p_base_port->p_physp->port_num,
p_dest_alias_guid->p_base_port->p_node->print_desc,
p_dest_alias_guid->p_base_port->p_physp->port_num);
status = IB_NOT_FOUND;
goto Exit;
}
} else if (p_qos_level && p_qos_level->sl_set) {
/*
* No specific SL was requested,
* but there is an SL in QoS level.
*/
required_sl = p_qos_level->sl;
if (required_pkey && p_prtn && p_prtn->sl != p_qos_level->sl)
OSM_LOG(sa->p_log, OSM_LOG_DEBUG,
"QoS level SL (%u) overrides partition SL (%u)\n",
p_qos_level->sl, p_prtn->sl);
} else if (required_pkey) {
/*
* No specific SL in request or in QoS level - use partition SL
*/
p_prtn =
(osm_prtn_t *) cl_qmap_get(&sa->p_subn->prtn_pkey_tbl,
required_pkey &
cl_ntoh16((uint16_t) ~ 0x8000));
if (!p_prtn) {
required_sl = OSM_DEFAULT_SL;
/* this may be possible when pkey tables are created somehow in
previous runs or things are going wrong here */
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 451A: "
"No partition found for PKey 0x%04x - "
"using default SL %d "
"[%s port %d <-> %s port %d]\n",
cl_ntoh16(required_pkey), required_sl,
p_src_alias_guid->p_base_port->p_node->print_desc,
p_src_alias_guid->p_base_port->p_physp->port_num,
p_dest_alias_guid->p_base_port->p_node->print_desc,
p_dest_alias_guid->p_base_port->p_physp->port_num);
} else
required_sl = p_prtn->sl;
} else if (sa->p_subn->opt.qos) {
if (valid_sl_mask & (1 << OSM_DEFAULT_SL))
required_sl = OSM_DEFAULT_SL;
else {
for (i = 0; i < IB_MAX_NUM_VLS; i++)
if (valid_sl_mask & (1 << i))
break;
required_sl = i;
}
} else
required_sl = OSM_DEFAULT_SL;
if (sa->p_subn->opt.qos && !(valid_sl_mask & (1 << required_sl))) {
OSM_LOG(sa->p_log, OSM_LOG_ERROR, "ERR 451F: "
"Selected SL (%u) leads to VL15 "
"[%s port %d <-> %s port %d]\n",
required_sl,
p_src_alias_guid->p_base_port->p_node->print_desc,
p_src_alias_guid->p_base_port->p_physp->port_num,
p_dest_alias_guid->p_base_port->p_node->print_desc,
p_dest_alias_guid->p_base_port->p_physp->port_num);
status = IB_NOT_FOUND;
goto Exit;
}
/* reset pkey when raw traffic */
if (comp_mask & IB_MPR_COMPMASK_RAWTRAFFIC &&
cl_ntoh32(p_mpr->hop_flow_raw) & (1 << 31))
required_pkey = 0;
p_parms->mtu = mtu;
p_parms->rate = rate;
p_parms->pkey = required_pkey;
p_parms->pkt_life = pkt_life;
p_parms->sl = required_sl;
p_parms->hops = hops;
OSM_LOG(sa->p_log, OSM_LOG_DEBUG, "MultiPath params:"
" mtu = %u, rate = %u, packet lifetime = %u,"
" pkey = 0x%04X, sl = %u, hops = %u\n", mtu, rate,
pkt_life, cl_ntoh16(required_pkey), required_sl, hops);
Exit:
OSM_LOG_EXIT(sa->p_log);
return status;
}
static void
__osm_pi_rcv_process_endport(IN osm_sm_t * sm,
IN osm_physp_t * const p_physp,
IN const ib_port_info_t * const p_pi)
{
osm_madw_context_t context;
ib_api_status_t status;
ib_net64_t port_guid;
uint8_t rate, mtu;
cl_qmap_t *p_sm_tbl;
osm_remote_sm_t *p_sm;
OSM_LOG_ENTER(sm->p_log);
port_guid = osm_physp_get_port_guid(p_physp);
/* HACK extended port 0 should be handled too! */
if (osm_physp_get_port_num(p_physp) != 0) {
/* track the minimal endport MTU and rate */
mtu = ib_port_info_get_mtu_cap(p_pi);
if (mtu < sm->p_subn->min_ca_mtu) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Setting endport minimal MTU to:%u defined by port:0x%"
PRIx64 "\n", mtu, cl_ntoh64(port_guid));
sm->p_subn->min_ca_mtu = mtu;
}
rate = ib_port_info_compute_rate(p_pi);
if (rate < sm->p_subn->min_ca_rate) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Setting endport minimal rate to:%u defined by port:0x%"
PRIx64 "\n", rate, cl_ntoh64(port_guid));
sm->p_subn->min_ca_rate = rate;
}
}
if (port_guid == sm->p_subn->sm_port_guid) {
/*
We received the PortInfo for our own port.
*/
if (!(p_pi->capability_mask & IB_PORT_CAP_IS_SM))
/*
Set the IS_SM bit to indicate our port hosts an SM.
*/
__osm_pi_rcv_set_sm(sm, p_physp);
} else {
p_sm_tbl = &sm->p_subn->sm_guid_tbl;
if (p_pi->capability_mask & IB_PORT_CAP_IS_SM) {
/*
* Before querying the SM - we want to make sure we
* clean its state, so if the querying fails we
* recognize that this SM is not active.
*/
p_sm = (osm_remote_sm_t *) cl_qmap_get(p_sm_tbl, port_guid);
if (p_sm != (osm_remote_sm_t *) cl_qmap_end(p_sm_tbl))
/* clean it up */
p_sm->smi.pri_state = 0xF0 & p_sm->smi.pri_state;
if (sm->p_subn->opt.ignore_other_sm)
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Ignoring SM on port 0x%" PRIx64 "\n",
cl_ntoh64(port_guid));
else {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Detected another SM. Requesting SMInfo"
"\n\t\t\t\tPort 0x%" PRIx64 "\n",
cl_ntoh64(port_guid));
/*
This port indicates it's an SM and
it's not our own port.
Acquire the SMInfo Attribute.
*/
memset(&context, 0, sizeof(context));
context.smi_context.set_method = FALSE;
context.smi_context.port_guid = port_guid;
status = osm_req_get(sm,
osm_physp_get_dr_path_ptr
(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 0F05: "
"Failure requesting SMInfo (%s)\n",
ib_get_err_str(status));
}
} else {
p_sm = (osm_remote_sm_t *) cl_qmap_remove(p_sm_tbl, port_guid);
if (p_sm != (osm_remote_sm_t *) cl_qmap_end(p_sm_tbl))
free(p_sm);
}
}
OSM_LOG_EXIT(sm->p_log);
}
cl_status_t cl_event_wheel_reg(IN cl_event_wheel_t * const p_event_wheel,
IN const uint64_t key,
IN const uint64_t aging_time_usec,
IN cl_pfn_event_aged_cb_t pfn_callback,
IN void *const context)
{
cl_event_wheel_reg_info_t *p_event;
uint64_t timeout;
uint32_t to;
cl_status_t cl_status = CL_SUCCESS;
cl_list_item_t *prev_event_list_item;
cl_map_item_t *p_map_item;
/* Get the lock on the manager */
cl_spinlock_acquire(&(p_event_wheel->lock));
cl_event_wheel_dump(p_event_wheel);
/* Make sure such a key does not exists */
p_map_item = cl_qmap_get(&p_event_wheel->events_map, key);
if (p_map_item != cl_qmap_end(&p_event_wheel->events_map)) {
CL_DBG("cl_event_wheel_reg: Already exists key:0x%"
PRIx64 "\n", key);
/* already there - remove it from the list as it is getting a new time */
p_event =
PARENT_STRUCT(p_map_item, cl_event_wheel_reg_info_t,
map_item);
/* remove the item from the qlist */
cl_qlist_remove_item(&p_event_wheel->events_wheel,
&p_event->list_item);
/* and the qmap */
cl_qmap_remove_item(&p_event_wheel->events_map,
&p_event->map_item);
} else {
/* make a new one */
p_event = (cl_event_wheel_reg_info_t *)
malloc(sizeof(cl_event_wheel_reg_info_t));
p_event->num_regs = 0;
}
p_event->key = key;
p_event->aging_time = aging_time_usec;
p_event->pfn_aged_callback = pfn_callback;
p_event->context = context;
p_event->num_regs++;
CL_DBG("cl_event_wheel_reg: Registering event key:0x%" PRIx64
" aging in %u [msec]\n", p_event->key,
(uint32_t) ((p_event->aging_time - cl_get_time_stamp()) / 1000));
/* If the list is empty - need to start the timer */
if (cl_is_qlist_empty(&p_event_wheel->events_wheel)) {
/* Edward Bortnikov 03/29/2003
* ++TBD Consider moving the timer manipulation behind the list manipulation.
*/
/* calculate the new timeout */
timeout =
(p_event->aging_time - cl_get_time_stamp() + 500) / 1000;
/* stop the timer if it is running */
/* Edward Bortnikov 03/29/2003
* Don't call cl_timer_stop() because it spins forever.
* cl_timer_start() will invoke cl_timer_stop() by itself.
*
* The problematic scenario is when __cl_event_wheel_callback()
* is in race condition with this code. It sets timer.in_timer_cb
* to TRUE and then blocks on p_event_wheel->lock. Following this,
* the call to cl_timer_stop() hangs. Following this, the whole system
* enters into a deadlock.
*
* cl_timer_stop(&p_event_wheel->timer);
*/
/* The timeout for the cl_timer_start should be given as uint32_t.
if there is an overflow - warn about it. */
to = (uint32_t) timeout;
if (timeout > (uint32_t) timeout) {
to = 0xffffffff; /* max 32 bit timer */
CL_DBG("cl_event_wheel_reg: timeout requested is "
"too large. Using timeout: %u\n", to);
}
/* start the timer to the timeout [msec] */
cl_status = cl_timer_start(&p_event_wheel->timer, to);
if (cl_status != CL_SUCCESS) {
CL_DBG("cl_event_wheel_reg : ERR 6203: "
"Failed to start timer\n");
goto Exit;
}
}
/* insert the object to the qlist and the qmap */
/* BUT WE MUST INSERT IT IN A SORTED MANNER */
prev_event_list_item =
cl_qlist_find_from_tail(&p_event_wheel->events_wheel,
__event_will_age_before,
&p_event->aging_time);
cl_qlist_insert_next(&p_event_wheel->events_wheel,
prev_event_list_item, &p_event->list_item);
cl_qmap_insert(&p_event_wheel->events_map, key, &(p_event->map_item));
Exit:
cl_spinlock_release(&p_event_wheel->lock);
return cl_status;
}
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);
}
static void pi_rcv_process_endport(IN osm_sm_t * sm, IN osm_physp_t * p_physp,
IN const ib_port_info_t * p_pi)
{
osm_madw_context_t context;
ib_api_status_t status;
ib_net64_t port_guid;
int extended;
uint8_t rate, mtu, mpb;
unsigned data_vls;
cl_qmap_t *p_sm_tbl;
osm_remote_sm_t *p_sm;
OSM_LOG_ENTER(sm->p_log);
port_guid = osm_physp_get_port_guid(p_physp);
/* HACK extended port 0 should be handled too! */
if (osm_physp_get_port_num(p_physp) != 0 &&
ib_port_info_get_port_state(p_pi) != IB_LINK_DOWN) {
/* track the minimal endport MTU, rate, and operational VLs */
mtu = ib_port_info_get_mtu_cap(p_pi);
if (mtu < sm->p_subn->min_ca_mtu) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Setting endport minimal MTU to:%u defined by port:0x%"
PRIx64 "\n", mtu, cl_ntoh64(port_guid));
sm->p_subn->min_ca_mtu = mtu;
}
extended = p_pi->capability_mask & IB_PORT_CAP_HAS_EXT_SPEEDS;
rate = ib_port_info_compute_rate(p_pi, extended);
if (ib_path_compare_rates(rate, sm->p_subn->min_ca_rate) < 0) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Setting endport minimal rate to:%u defined by port:0x%"
PRIx64 "\n", rate, cl_ntoh64(port_guid));
sm->p_subn->min_ca_rate = rate;
}
data_vls = 1U << (ib_port_info_get_vl_cap(p_pi) - 1);
if (data_vls > 1U << (sm->p_subn->opt.max_op_vls - 1))
data_vls = 1U << (sm->p_subn->opt.max_op_vls - 1);
if (data_vls >= IB_MAX_NUM_VLS)
data_vls = IB_MAX_NUM_VLS - 1;
if ((uint8_t)data_vls < sm->p_subn->min_data_vls) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Setting endport minimal data VLs to:%u defined by port:0x%"
PRIx64 "\n", data_vls, cl_ntoh64(port_guid));
sm->p_subn->min_data_vls = data_vls;
}
}
/* Check M_Key vs M_Key protect, can we control the port ? */
mpb = ib_port_info_get_mpb(p_pi);
if (mpb > 0 && p_pi->m_key == 0) {
OSM_LOG(sm->p_log, OSM_LOG_INFO,
"Port 0x%" PRIx64 " has unknown M_Key, protection level %u\n",
cl_ntoh64(port_guid), mpb);
}
if (port_guid != sm->p_subn->sm_port_guid) {
p_sm_tbl = &sm->p_subn->sm_guid_tbl;
if (p_pi->capability_mask & IB_PORT_CAP_IS_SM) {
/*
* Before querying the SM - we want to make sure we
* clean its state, so if the querying fails we
* recognize that this SM is not active.
*/
p_sm =
(osm_remote_sm_t *) cl_qmap_get(p_sm_tbl,
port_guid);
if (p_sm != (osm_remote_sm_t *) cl_qmap_end(p_sm_tbl))
/* clean it up */
p_sm->smi.pri_state =
0xF0 & p_sm->smi.pri_state;
if (sm->p_subn->opt.ignore_other_sm)
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Ignoring SM on port 0x%" PRIx64 "\n",
cl_ntoh64(port_guid));
else {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Detected another SM. Requesting SMInfo "
"from port 0x%" PRIx64 "\n",
cl_ntoh64(port_guid));
/*
This port indicates it's an SM and
it's not our own port.
Acquire the SMInfo Attribute.
*/
memset(&context, 0, sizeof(context));
context.smi_context.set_method = FALSE;
context.smi_context.port_guid = port_guid;
status = osm_req_get(sm,
osm_physp_get_dr_path_ptr
(p_physp),
IB_MAD_ATTR_SM_INFO, 0,
FALSE,
ib_port_info_get_m_key(&p_physp->port_info),
CL_DISP_MSGID_NONE,
&context);
if (status != IB_SUCCESS)
OSM_LOG(sm->p_log, OSM_LOG_ERROR,
"ERR 0F05: "
"Failure requesting SMInfo (%s) "
"from port 0x%" PRIx64 "\n",
ib_get_err_str(status),
cl_ntoh64(port_guid));
}
} else {
p_sm =
(osm_remote_sm_t *) cl_qmap_remove(p_sm_tbl,
port_guid);
if (p_sm != (osm_remote_sm_t *) cl_qmap_end(p_sm_tbl))
free(p_sm);
}
}
OSM_LOG_EXIT(sm->p_log);
}
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;
}