/**
* This function deinits lacp DB
*
* @return 0 when successful, otherwise ERROR
*/
int
lacp_db_deinit(void)
{
int err = 0;
cl_map_item_t *map_item;
struct mlag_lacp_entry *lacp_entry;
struct lacp_pending_entry *pending_entry;
const cl_map_item_t *map_end = NULL;
map_item = cl_qmap_head(&(mlag_lacp_db.port_map));
map_end = cl_qmap_end(&(mlag_lacp_db.port_map));
while (map_item != map_end) {
lacp_entry = PARENT_STRUCT(map_item, struct mlag_lacp_entry, map_item);
MAP_ITEM_DEINIT(&(mlag_lacp_db.port_pool), lacp_entry);
map_item = cl_qmap_next(map_item);
}
cl_qmap_remove_all(&(mlag_lacp_db.port_map));
cl_qpool_destroy(&(mlag_lacp_db.port_pool));
map_item = cl_qmap_head(&(mlag_lacp_db.pending_map));
map_end = cl_qmap_end(&(mlag_lacp_db.pending_map));
while (map_item != map_end) {
pending_entry = PARENT_STRUCT(map_item, struct lacp_pending_entry,
map_item);
MAP_ITEM_DEINIT(&(mlag_lacp_db.pending_pool), pending_entry);
map_item = cl_qmap_next(map_item);
}
cl_qmap_remove_all(&(mlag_lacp_db.pending_map));
cl_qpool_destroy(&(mlag_lacp_db.pending_pool));
return err;
}
osm_signal_t osm_link_mgr_process(osm_sm_t * sm, IN const uint8_t link_state)
{
cl_qmap_t *p_node_guid_tbl;
osm_node_t *p_node;
osm_signal_t signal = OSM_SIGNAL_DONE;
OSM_LOG_ENTER(sm->p_log);
p_node_guid_tbl = &sm->p_subn->node_guid_tbl;
CL_PLOCK_EXCL_ACQUIRE(sm->p_lock);
for (p_node = (osm_node_t *) cl_qmap_head(p_node_guid_tbl);
p_node != (osm_node_t *) cl_qmap_end(p_node_guid_tbl);
p_node = (osm_node_t *) cl_qmap_next(&p_node->map_item)) {
if (__osm_link_mgr_process_node(sm, p_node, link_state) ==
OSM_SIGNAL_DONE_PENDING)
signal = OSM_SIGNAL_DONE_PENDING;
}
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG_EXIT(sm->p_log);
return (signal);
}
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);
}
/**********************************************************************
* Go over all the remote SMs (as updated in the sm_guid_tbl).
* Find if there is a remote sm that is a master SM.
* If there is a remote master SM - return a pointer to it,
* else - return NULL.
**********************************************************************/
static osm_remote_sm_t *state_mgr_exists_other_master_sm(IN osm_sm_t * sm)
{
cl_qmap_t *p_sm_tbl;
osm_remote_sm_t *p_sm;
osm_remote_sm_t *p_sm_res = NULL;
OSM_LOG_ENTER(sm->p_log);
p_sm_tbl = &sm->p_subn->sm_guid_tbl;
/* go over all the remote SMs */
for (p_sm = (osm_remote_sm_t *) cl_qmap_head(p_sm_tbl);
p_sm != (osm_remote_sm_t *) cl_qmap_end(p_sm_tbl);
p_sm = (osm_remote_sm_t *) cl_qmap_next(&p_sm->map_item)) {
/* If the sm is in MASTER state - return a pointer to it */
if (ib_sminfo_get_state(&p_sm->smi) == IB_SMINFO_STATE_MASTER) {
OSM_LOG(sm->p_log, OSM_LOG_VERBOSE,
"Found remote master SM with guid:0x%016" PRIx64
" (node %s)\n", cl_ntoh64(p_sm->smi.guid),
p_sm->p_port->p_node ? p_sm->p_port->p_node->
print_desc : "UNKNOWN");
p_sm_res = p_sm;
goto Exit;
}
}
Exit:
OSM_LOG_EXIT(sm->p_log);
return p_sm_res;
}
ib_api_status_t osm_prtn_add_all(osm_log_t * p_log, osm_subn_t * p_subn,
osm_prtn_t * p, unsigned type,
boolean_t full, boolean_t indx0)
{
cl_qmap_t *p_port_tbl = &p_subn->port_guid_tbl;
cl_map_item_t *p_item;
osm_port_t *p_port;
ib_api_status_t status = IB_SUCCESS;
p_item = cl_qmap_head(p_port_tbl);
while (p_item != cl_qmap_end(p_port_tbl)) {
p_port = (osm_port_t *) p_item;
p_item = cl_qmap_next(p_item);
if (!type || osm_node_get_type(p_port->p_node) == type) {
status = osm_prtn_add_port(p_log, p_subn, p,
osm_port_get_guid(p_port),
full, indx0);
if (status != IB_SUCCESS)
goto _err;
}
}
_err:
return status;
}
static void alloc_ports_priv(osm_ucast_mgr_t *mgr)
{
cl_qmap_t *port_tbl = &mgr->p_subn->port_guid_tbl;
struct osm_remote_guids_count *r;
osm_port_t *port;
cl_map_item_t *item;
unsigned lmc;
for (item = cl_qmap_head(port_tbl); item != cl_qmap_end(port_tbl);
item = cl_qmap_next(item)) {
port = (osm_port_t *)item;
lmc = ib_port_info_get_lmc(&port->p_physp->port_info);
if (!lmc)
continue;
r = malloc(sizeof(*r) + sizeof(r->guids[0]) * (1 << lmc));
if (!r) {
OSM_LOG(mgr->p_log, OSM_LOG_ERROR, "ERR 3A09: "
"cannot allocate memory to track remote"
" systems for lmc > 0\n");
port->priv = NULL;
continue;
}
memset(r, 0, sizeof(*r) + sizeof(r->guids[0]) * (1 << lmc));
port->priv = r;
}
}
void osm_ucast_cache_invalidate(osm_ucast_mgr_t * p_mgr)
{
cache_switch_t *p_sw;
cache_switch_t *p_next_sw;
OSM_LOG_ENTER(p_mgr->p_log);
if (!p_mgr->cache_valid)
goto Exit;
p_mgr->cache_valid = FALSE;
p_next_sw = (cache_switch_t *) cl_qmap_head(&p_mgr->cache_sw_tbl);
while (p_next_sw !=
(cache_switch_t *) cl_qmap_end(&p_mgr->cache_sw_tbl)) {
p_sw = p_next_sw;
p_next_sw = (cache_switch_t *) cl_qmap_next(&p_sw->map_item);
cache_sw_destroy(p_sw);
}
cl_qmap_remove_all(&p_mgr->cache_sw_tbl);
OSM_LOG(p_mgr->p_log, OSM_LOG_VERBOSE, "Unicast Cache invalidated\n");
Exit:
OSM_LOG_EXIT(p_mgr->p_log);
}
static void ucast_cache_dump(osm_ucast_mgr_t * p_mgr)
{
cache_switch_t *p_sw;
unsigned i;
OSM_LOG_ENTER(p_mgr->p_log);
if (!OSM_LOG_IS_ACTIVE_V2(p_mgr->p_log, OSM_LOG_DEBUG))
goto Exit;
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Dumping missing nodes/links as logged by unicast cache:\n");
for (p_sw = (cache_switch_t *) cl_qmap_head(&p_mgr->cache_sw_tbl);
p_sw != (cache_switch_t *) cl_qmap_end(&p_mgr->cache_sw_tbl);
p_sw = (cache_switch_t *) cl_qmap_next(&p_sw->map_item)) {
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"\t Switch lid %u %s%s\n",
cache_sw_get_base_lid_ho(p_sw),
(cache_sw_is_leaf(p_sw)) ? "[leaf switch] " : "",
(p_sw->dropped) ? "[whole switch missing]" : "");
for (i = 1; i < p_sw->num_ports; i++)
if (p_sw->ports[i].remote_lid_ho > 0)
OSM_LOG(p_mgr->p_log,
OSM_LOG_DEBUG,
"\t - port %u -> lid %u %s\n",
i, p_sw->ports[i].remote_lid_ho,
(p_sw->ports[i].is_leaf) ?
"[remote node is leaf]" : "");
}
Exit:
OSM_LOG_EXIT(p_mgr->p_log);
}
static void cache_cleanup_switches(osm_ucast_mgr_t * p_mgr)
{
cache_switch_t *p_sw;
cache_switch_t *p_next_sw;
unsigned port_num;
boolean_t found_port;
if (!p_mgr->cache_valid)
return;
p_next_sw = (cache_switch_t *) cl_qmap_head(&p_mgr->cache_sw_tbl);
while (p_next_sw !=
(cache_switch_t *) cl_qmap_end(&p_mgr->cache_sw_tbl)) {
p_sw = p_next_sw;
p_next_sw = (cache_switch_t *) cl_qmap_next(&p_sw->map_item);
found_port = FALSE;
for (port_num = 1; port_num < p_sw->num_ports; port_num++)
if (p_sw->ports[port_num].remote_lid_ho)
found_port = TRUE;
if (!found_port) {
cl_qmap_remove_item(&p_mgr->cache_sw_tbl,
&p_sw->map_item);
cache_sw_destroy(p_sw);
}
}
}
ib_api_status_t
__osmv_txnmgr_remove_txn(IN osmv_txn_mgr_t * p_tx_mgr,
IN uint64_t key, OUT osmv_txn_ctx_t ** pp_txn)
{
cl_map_obj_t *p_obj;
cl_map_item_t *p_item;
OSM_LOG_ENTER(p_tx_mgr->p_log);
CL_ASSERT(p_tx_mgr);
CL_ASSERT(pp_txn);
p_item = cl_qmap_remove(p_tx_mgr->p_txn_map, key);
if (p_item == cl_qmap_end(p_tx_mgr->p_txn_map)) {
osm_log(p_tx_mgr->p_log, OSM_LOG_ERROR,
"__osmv_txnmgr_remove_txn: ERR 6701: "
"Could not remove the transaction 0x%llX - "
"something is really wrong!\n", key);
OSM_LOG_EXIT(p_tx_mgr->p_log);
return IB_NOT_FOUND;
}
p_obj = PARENT_STRUCT(p_item, cl_map_obj_t, item);
*pp_txn = cl_qmap_obj(p_obj);
free(p_obj);
OSM_LOG_EXIT(p_tx_mgr->p_log);
return IB_SUCCESS;
}
static int updn_set_min_hop_table(IN updn_t * p_updn)
{
osm_subn_t *p_subn = &p_updn->p_osm->subn;
osm_log_t *p_log = &p_updn->p_osm->log;
osm_switch_t *p_sw;
cl_map_item_t *item;
OSM_LOG_ENTER(p_log);
/* Go over all the switches in the subnet - for each init their Min Hop
Table */
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"Init Min Hop Table of all switches [\n");
for (item = cl_qmap_head(&p_updn->p_osm->subn.sw_guid_tbl);
item != cl_qmap_end(&p_updn->p_osm->subn.sw_guid_tbl);
item = cl_qmap_next(item)) {
p_sw = (osm_switch_t *)item;
/* Clear Min Hop Table */
if (p_subn->opt.connect_roots)
updn_clear_non_root_hops(p_updn, p_sw);
else
osm_switch_clear_hops(p_sw);
}
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"Init Min Hop Table of all switches ]\n");
/* Now do the BFS for each port in the subnet */
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"BFS through all port guids in the subnet [\n");
for (item = cl_qmap_head(&p_updn->p_osm->subn.sw_guid_tbl);
item != cl_qmap_end(&p_updn->p_osm->subn.sw_guid_tbl);
item = cl_qmap_next(item)) {
p_sw = (osm_switch_t *)item;
updn_bfs_by_node(p_log, p_subn, p_sw);
}
OSM_LOG(p_log, OSM_LOG_VERBOSE,
"BFS through all port guids in the subnet ]\n");
/* Cleanup */
OSM_LOG_EXIT(p_log);
return 0;
}
/**********************************************************************
* 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);
}
perfmgr_db_err_t
perfmgr_db_delete_inactive(perfmgr_db_t * db, unsigned *cnt)
{
perfmgr_db_err_t rc = PERFMGR_EVENT_DB_SUCCESS;
int i = 0;
int num = 0;
uint64_t * guid_list = NULL;
cl_map_item_t * p_map_item = cl_qmap_head(&db->pc_data);
if (p_map_item == cl_qmap_end(&db->pc_data)) {
rc = PERFMGR_EVENT_DB_SUCCESS;
goto Done;
}
while (p_map_item != cl_qmap_end(&db->pc_data)) {
db_node_t *n = (db_node_t *)p_map_item;
if (n->active == FALSE) {
guid_list = realloc(guid_list,
sizeof(*guid_list) * (num+1));
if (!guid_list) {
num = 0;
rc = PERFMGR_EVENT_DB_NOMEM;
goto Done;
}
guid_list[num] = n->node_guid;
num++;
}
p_map_item = cl_qmap_next(p_map_item);
}
for (i = 0 ; i < num; i++)
perfmgr_db_delete_entry(db, guid_list[i]);
free(guid_list);
Done:
if (cnt)
*cnt = num;
return(rc);
}
static void ucast_mgr_pipeline_fwd_tbl(osm_ucast_mgr_t * p_mgr)
{
cl_qmap_t *tbl;
cl_map_item_t *item;
unsigned i, max_block = p_mgr->max_lid / IB_SMP_DATA_SIZE + 1;
tbl = &p_mgr->p_subn->sw_guid_tbl;
for (i = 0; i < max_block; i++)
for (item = cl_qmap_head(tbl); item != cl_qmap_end(tbl);
item = cl_qmap_next(item))
set_lft_block((osm_switch_t *)item, p_mgr, i);
}
perfmgr_db_err_t
perfmgr_db_delete_entry(perfmgr_db_t * db, uint64_t guid)
{
cl_map_item_t * rc = cl_qmap_remove(&db->pc_data, guid);
if (rc == cl_qmap_end(&db->pc_data))
return(PERFMGR_EVENT_DB_GUIDNOTFOUND);
db_node_t *pc_node = (db_node_t *)rc;
free_node(pc_node);
return(PERFMGR_EVENT_DB_SUCCESS);
}
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;
}
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;
}
static void free_ports_priv(osm_ucast_mgr_t * mgr)
{
cl_qmap_t *port_tbl = &mgr->p_subn->port_guid_tbl;
osm_port_t *port;
cl_map_item_t *item;
for (item = cl_qmap_head(port_tbl); item != cl_qmap_end(port_tbl);
item = cl_qmap_next(item)) {
port = (osm_port_t *) item;
if (port->priv) {
free(port->priv);
port->priv = NULL;
}
}
}
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);
}
/**********************************************************************
* Go over all remote SMs (as updated in the sm_guid_tbl).
* Find the one with the highest priority and lowest guid.
* Compare this SM to the local SM. If the local SM is higher -
* return NULL, if the remote SM is higher - return a pointer to it.
**********************************************************************/
static osm_remote_sm_t *state_mgr_get_highest_sm(IN osm_sm_t * sm)
{
cl_qmap_t *p_sm_tbl;
osm_remote_sm_t *p_sm = NULL;
osm_remote_sm_t *p_highest_sm;
uint8_t highest_sm_priority;
ib_net64_t highest_sm_guid;
osm_node_t *p_node;
OSM_LOG_ENTER(sm->p_log);
p_sm_tbl = &sm->p_subn->sm_guid_tbl;
/* Start with the local sm as the standard */
p_highest_sm = NULL;
highest_sm_priority = sm->p_subn->opt.sm_priority;
highest_sm_guid = sm->p_subn->sm_port_guid;
/* go over all the remote SMs */
for (p_sm = (osm_remote_sm_t *) cl_qmap_head(p_sm_tbl);
p_sm != (osm_remote_sm_t *) cl_qmap_end(p_sm_tbl);
p_sm = (osm_remote_sm_t *) cl_qmap_next(&p_sm->map_item)) {
/* If the sm is in NOTACTIVE state - continue */
if (ib_sminfo_get_state(&p_sm->smi) ==
IB_SMINFO_STATE_NOTACTIVE)
continue;
if (osm_sm_is_greater_than(ib_sminfo_get_priority(&p_sm->smi),
p_sm->smi.guid, highest_sm_priority,
highest_sm_guid)) {
/* the new p_sm is with higher priority - update the highest_sm */
/* to this sm */
p_highest_sm = p_sm;
highest_sm_priority =
ib_sminfo_get_priority(&p_sm->smi);
highest_sm_guid = p_sm->smi.guid;
}
}
if (p_highest_sm != NULL) {
p_node = osm_get_node_by_guid(sm->p_subn, p_highest_sm->smi.guid);
OSM_LOG(sm->p_log, OSM_LOG_DEBUG,
"Found higher SM with guid: %016" PRIx64 " (node %s)\n",
cl_ntoh64(p_highest_sm->smi.guid),
p_node ? p_node->print_desc : "UNKNOWN");
}
OSM_LOG_EXIT(sm->p_log);
return p_highest_sm;
}
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);
}
/** =========================================================================
*/
void perfmgr_db_destroy(perfmgr_db_t * db)
{
cl_map_item_t *item, *next_item;
if (db) {
item = cl_qmap_head(&db->pc_data);
while (item != cl_qmap_end(&db->pc_data)) {
next_item = cl_qmap_next(item);
free_node((db_node_t *)item);
item = next_item;
}
cl_plock_destroy(&db->lock);
free(db);
}
}
/**********************************************************************
* print all node data to fp
**********************************************************************/
void
perfmgr_db_print_all(perfmgr_db_t * db, FILE *fp, int err_only)
{
cl_map_item_t *item;
db_node_t *node;
cl_plock_acquire(&db->lock);
item = cl_qmap_head(&db->pc_data);
while (item != cl_qmap_end(&db->pc_data)) {
node = (db_node_t *)item;
dump_node_hr(node, fp, NULL, err_only);
item = cl_qmap_next(item);
}
cl_plock_release(&db->lock);
}
osm_prtn_t *osm_prtn_find_by_name(osm_subn_t * p_subn, const char *name)
{
cl_map_item_t *p_next;
osm_prtn_t *p;
p_next = cl_qmap_head(&p_subn->prtn_pkey_tbl);
while (p_next != cl_qmap_end(&p_subn->prtn_pkey_tbl)) {
p = (osm_prtn_t *) p_next;
p_next = cl_qmap_next(&p->map_item);
if (!strncmp(p->name, name, sizeof(p->name)))
return p;
}
return NULL;
}
static void process_switches(lash_t * p_lash)
{
osm_switch_t *p_sw, *p_next_sw;
osm_subn_t *p_subn = &p_lash->p_osm->subn;
/* Go through each switch and process it. i.e build the connection
structure required by LASH */
p_next_sw = (osm_switch_t *) cl_qmap_head(&p_subn->sw_guid_tbl);
while (p_next_sw != (osm_switch_t *) cl_qmap_end(&p_subn->sw_guid_tbl)) {
p_sw = p_next_sw;
p_next_sw = (osm_switch_t *) cl_qmap_next(&p_sw->map_item);
osm_lash_process_switch(p_lash, p_sw);
}
}
/**********************************************************************
* 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);
}
void close_node_name_map(nn_map_t * map)
{
name_map_item_t *item = NULL;
if (!map)
return;
item = (name_map_item_t *) cl_qmap_head(map);
while (item != (name_map_item_t *) cl_qmap_end(map)) {
item = (name_map_item_t *) cl_qmap_remove(map, item->guid);
free(item->name);
free(item);
item = (name_map_item_t *) cl_qmap_head(map);
}
free(map);
}
static void ucast_mgr_process_neighbor(IN osm_ucast_mgr_t * p_mgr,
IN osm_switch_t * p_this_sw,
IN osm_switch_t * p_remote_sw,
IN uint8_t port_num,
IN uint8_t remote_port_num)
{
osm_switch_t *p_sw;
cl_map_item_t *item;
uint16_t lid_ho;
uint16_t hops;
osm_physp_t *p;
OSM_LOG_ENTER(p_mgr->p_log);
OSM_LOG(p_mgr->p_log, OSM_LOG_DEBUG,
"Node 0x%" PRIx64 ", remote node 0x%" PRIx64
", port %u, remote port %u\n",
cl_ntoh64(osm_node_get_node_guid(p_this_sw->p_node)),
cl_ntoh64(osm_node_get_node_guid(p_remote_sw->p_node)),
port_num, remote_port_num);
p = osm_node_get_physp_ptr(p_this_sw->p_node, port_num);
for (item = cl_qmap_head(&p_mgr->p_subn->sw_guid_tbl);
item != cl_qmap_end(&p_mgr->p_subn->sw_guid_tbl);
item = cl_qmap_next(item)) {
p_sw = (osm_switch_t *) item;
lid_ho = cl_ntoh16(osm_node_get_base_lid(p_sw->p_node, 0));
hops = osm_switch_get_least_hops(p_remote_sw, lid_ho);
if (hops == OSM_NO_PATH)
continue;
hops += p->hop_wf;
if (hops <
osm_switch_get_hop_count(p_this_sw, lid_ho, port_num)) {
if (osm_switch_set_hops
(p_this_sw, lid_ho, port_num, (uint8_t) hops) != 0)
OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR, "ERR 3A03: "
"cannot set hops for lid %u at switch 0x%"
PRIx64 "\n", lid_ho,
cl_ntoh64(osm_node_get_node_guid
(p_this_sw->p_node)));
p_mgr->some_hop_count_set = TRUE;
}
}
OSM_LOG_EXIT(p_mgr->p_log);
}
