/**
* 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;
}
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 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;
}
}
/**********************************************************************
* 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;
}
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);
}
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;
}
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);
}
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;
}
}
}
/**********************************************************************
* 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;
}
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);
}
}
/** =========================================================================
*/
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 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);
}
static void
__osm_ucast_mgr_process_neighbor(IN osm_ucast_mgr_t * const p_mgr,
IN osm_switch_t * const p_this_sw,
IN osm_switch_t * const p_remote_sw,
IN const uint8_t port_num,
IN const uint8_t remote_port_num)
{
osm_switch_t *p_sw, *p_next_sw;
uint16_t lid_ho;
uint8_t hops;
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_next_sw = (osm_switch_t *) cl_qmap_head(&p_mgr->p_subn->sw_guid_tbl);
while (p_next_sw !=
(osm_switch_t *) cl_qmap_end(&p_mgr->p_subn->sw_guid_tbl)) {
p_sw = p_next_sw;
p_next_sw = (osm_switch_t *) cl_qmap_next(&p_sw->map_item);
lid_ho = osm_node_get_base_lid(p_sw->p_node, 0);
lid_ho = cl_ntoh16(lid_ho);
hops = osm_switch_get_least_hops(p_remote_sw, lid_ho);
if (hops == OSM_NO_PATH)
continue;
hops++;
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, hops) != 0)
OSM_LOG(p_mgr->p_log, OSM_LOG_ERROR,
"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);
}
int osm_ucast_cache_process(osm_ucast_mgr_t * p_mgr)
{
cl_qmap_t *tbl = &p_mgr->p_subn->sw_guid_tbl;
cl_map_item_t *item;
osm_switch_t *p_sw;
uint16_t lft_size;
if (!p_mgr->p_subn->opt.use_ucast_cache)
return 1;
ucast_cache_validate(p_mgr);
if (!p_mgr->cache_valid)
return 1;
OSM_LOG(p_mgr->p_log, OSM_LOG_INFO,
"Configuring switch tables using cached routing\n");
for (item = cl_qmap_head(tbl); item != cl_qmap_end(tbl);
item = cl_qmap_next(item)) {
p_sw = (osm_switch_t *) item;
if (p_sw->need_update) {
if (!p_sw->new_lft)
/* no new routing was recently calculated for this
switch, but the LFT needs to be updated anyway */
p_sw->new_lft = p_sw->lft;
lft_size = (p_sw->max_lid_ho / IB_SMP_DATA_SIZE + 1)
* IB_SMP_DATA_SIZE;
p_sw->lft = malloc(lft_size);
if (!p_sw->lft)
return IB_INSUFFICIENT_MEMORY;
p_sw->lft_size = lft_size;
memset(p_sw->lft, OSM_NO_PATH, p_sw->lft_size);
}
}
osm_ucast_mgr_set_fwd_tables(p_mgr);
return 0;
}
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 int ucast_mgr_setup_all_switches(osm_subn_t * p_subn)
{
osm_switch_t *p_sw;
uint16_t lids;
lids = (uint16_t) cl_ptr_vector_get_size(&p_subn->port_lid_tbl);
lids = lids ? lids - 1 : 0;
for (p_sw = (osm_switch_t *) cl_qmap_head(&p_subn->sw_guid_tbl);
p_sw != (osm_switch_t *) cl_qmap_end(&p_subn->sw_guid_tbl);
p_sw = (osm_switch_t *) cl_qmap_next(&p_sw->map_item))
if (osm_switch_prepare_path_rebuild(p_sw, lids)) {
OSM_LOG(&p_subn->p_osm->log, OSM_LOG_ERROR, "ERR 3A0B: "
"cannot setup switch 0x%016" PRIx64 "\n",
cl_ntoh64(osm_node_get_node_guid
(p_sw->p_node)));
return -1;
}
return 0;
}
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;
}
/* Dump out the complete state of the event wheel */
void __cl_event_wheel_dump(IN cl_event_wheel_t * const p_event_wheel)
{
cl_list_item_t *p_list_item;
cl_map_item_t *p_map_item;
cl_event_wheel_reg_info_t *p_event;
printf("************** Event Wheel Dump ***********************\n");
printf("Event Wheel List has %u items:\n",
cl_qlist_count(&p_event_wheel->events_wheel));
p_list_item = cl_qlist_head(&p_event_wheel->events_wheel);
while (p_list_item != cl_qlist_end(&p_event_wheel->events_wheel)) {
p_event =
PARENT_STRUCT(p_list_item, cl_event_wheel_reg_info_t,
list_item);
printf("Event key:0x%" PRIx64 " Context:%s NumRegs:%u\n",
p_event->key, (char *)p_event->context,
p_event->num_regs);
/* next */
p_list_item = cl_qlist_next(p_list_item);
}
printf("Event Map has %u items:\n",
cl_qmap_count(&p_event_wheel->events_map));
p_map_item = cl_qmap_head(&p_event_wheel->events_map);
while (p_map_item != cl_qmap_end(&p_event_wheel->events_map)) {
p_event =
PARENT_STRUCT(p_map_item, cl_event_wheel_reg_info_t,
map_item);
printf("Event key:0x%" PRIx64 " Context:%s NumRegs:%u\n",
p_event->key, (char *)p_event->context,
p_event->num_regs);
/* next */
p_map_item = cl_qmap_next(p_map_item);
}
}
static uint64_t
get_guid_for_name(nn_map_t * map, char *name)
{
cl_map_item_t *map_item = NULL;
for (map_item = cl_qmap_head(map);
map_item != cl_qmap_end(map);
map_item = cl_qmap_next(map_item)) {
name_map_item_t *item = (name_map_item_t *)map_item;
char *iname = item->name;
if (skummee_output) {
char tmp[256];
strncpy(tmp, item->name, 256);
clean_node_name(tmp);
iname = tmp;
}
if (strcmp(iname, name) == 0)
return (item->guid);
}
return (0);
}
static void lash_cleanup(lash_t * p_lash)
{
osm_subn_t *p_subn = &p_lash->p_osm->subn;
osm_switch_t *p_next_sw, *p_sw;
/* drop any existing references to old lash switches */
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);
p_sw->priv = NULL;
}
if (p_lash->switches) {
unsigned id;
for (id = 0; ((int)id) < p_lash->num_switches; id++)
if (p_lash->switches[id])
switch_delete(p_lash, p_lash->switches[id]);
free(p_lash->switches);
}
p_lash->switches = NULL;
}
static void sort_ports_by_switch_load(osm_ucast_mgr_t * m)
{
int i, num = cl_qmap_count(&m->p_subn->sw_guid_tbl);
void **s = malloc(num * sizeof(*s));
if (!s) {
OSM_LOG(m->p_log, OSM_LOG_ERROR, "ERR 3A0C: "
"No memory, skip by switch load sorting.\n");
return;
}
s[0] = cl_qmap_head(&m->p_subn->sw_guid_tbl);
for (i = 1; i < num; i++)
s[i] = cl_qmap_next(s[i - 1]);
for (i = 0; i < num; i++)
sw_count_endport_links(s[i]);
qsort(s, num, sizeof(*s), compar_sw_load);
for (i = 0; i < num; i++)
add_sw_endports_to_order_list(s[i], m);
free(s);
}
ib_api_status_t
__osmv_txnmgr_insert_txn(IN osmv_txn_mgr_t * p_tx_mgr,
IN osmv_txn_ctx_t * p_txn, IN uint64_t key)
{
cl_map_obj_t *p_obj = NULL;
cl_map_item_t *p_item;
uint64_t tmp_key;
CL_ASSERT(p_tx_mgr);
CL_ASSERT(p_txn);
key = osmv_txn_get_key(p_txn);
p_obj = malloc(sizeof(cl_map_obj_t));
if (NULL == p_obj)
return IB_INSUFFICIENT_MEMORY;
osm_log(p_tx_mgr->p_log, OSM_LOG_DEBUG,
"__osmv_txnmgr_insert_txn: "
"Inserting key: 0x%llX to map ptr:%p\n", key,
p_tx_mgr->p_txn_map);
memset(p_obj, 0, sizeof(cl_map_obj_t));
cl_qmap_set_obj(p_obj, p_txn);
/* assuming lookup with this key was made and the result was IB_NOT_FOUND */
cl_qmap_insert(p_tx_mgr->p_txn_map, key, &p_obj->item);
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_insert_txn: "
"Found key 0x%llX \n", tmp_key);
p_item = cl_qmap_next(p_item);
}
return IB_SUCCESS;
}
static int ucast_mgr_setup_all_switches(osm_subn_t * p_subn)
{
osm_switch_t *p_sw;
uint16_t lids;
lids = (uint16_t) cl_ptr_vector_get_size(&p_subn->port_lid_tbl);
lids = lids ? lids - 1 : 0;
for (p_sw = (osm_switch_t *) cl_qmap_head(&p_subn->sw_guid_tbl);
p_sw != (osm_switch_t *) cl_qmap_end(&p_subn->sw_guid_tbl);
p_sw = (osm_switch_t *) cl_qmap_next(&p_sw->map_item)) {
if (osm_switch_prepare_path_rebuild(p_sw, lids)) {
OSM_LOG(&p_subn->p_osm->log, OSM_LOG_ERROR, "ERR 3A0B: "
"cannot setup switch 0x%016" PRIx64 "\n",
cl_ntoh64(osm_node_get_node_guid
(p_sw->p_node)));
return -1;
}
if (p_sw->search_ordering_ports) {
free(p_sw->search_ordering_ports);
p_sw->search_ordering_ports = NULL;
}
}
if (p_subn->opt.port_search_ordering_file) {
OSM_LOG(&p_subn->p_osm->log, OSM_LOG_DEBUG,
"Fetching dimension ports file \'%s\'\n",
p_subn->opt.port_search_ordering_file);
if (parse_node_map(p_subn->opt.port_search_ordering_file,
set_search_ordering_ports, p_subn)) {
OSM_LOG(&p_subn->p_osm->log, OSM_LOG_ERROR, "ERR 3A0F: "
"cannot parse port_search_ordering_file \'%s\'\n",
p_subn->opt.port_search_ordering_file);
}
}
return 0;
}
int 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;
int ret = 0;
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 (link_mgr_process_node(sm, p_node, link_state))
ret = -1;
CL_PLOCK_RELEASE(sm->p_lock);
OSM_LOG_EXIT(sm->p_log);
return ret;
}
/**********************************************************************
* print node data to fp
**********************************************************************/
void
perfmgr_db_print_by_name(perfmgr_db_t * db, char *nodename, FILE *fp,
char *port, int err_only)
{
cl_map_item_t *item;
db_node_t *node;
cl_plock_acquire(&db->lock);
/* find the node */
item = cl_qmap_head(&db->pc_data);
while (item != cl_qmap_end(&db->pc_data)) {
node = (db_node_t *)item;
if (strcmp(node->node_name, nodename) == 0) {
dump_node_hr(node, fp, port, err_only);
goto done;
}
item = cl_qmap_next(item);
}
fprintf(fp, "Node %s not found...\n", nodename);
done:
cl_plock_release(&db->lock);
}
