/**
* This function inits lacp DB, it allocates MLAG_MAX_PORTS
* port entries in pool
*
* @return 0 when successful, otherwise ERROR
*/
int
lacp_db_init(void)
{
int err = 0;
cl_status_t cl_status = CL_SUCCESS;
cl_status = cl_qpool_init(&(mlag_lacp_db.port_pool),
MLAG_MAX_PORTS, MLAG_MAX_PORTS, 0,
sizeof(struct mlag_lacp_entry), lacp_entry_init,
lacp_entry_deinit, NULL );
if (cl_status != CL_SUCCESS) {
err = -ENOMEM;
MLAG_BAIL_ERROR_MSG(err, "Failed to Init LACP DB port pool\n");
}
cl_qmap_init(&(mlag_lacp_db.port_map));
cl_status = cl_qpool_init(&(mlag_lacp_db.pending_pool),
MLAG_MAX_PORTS, MLAG_MAX_PORTS, 0,
sizeof(struct lacp_pending_entry),
pending_entry_init, pending_entry_deinit, NULL );
if (cl_status != CL_SUCCESS) {
err = -ENOMEM;
MLAG_BAIL_ERROR_MSG(err, "Failed to Init LACP DB pending pool\n");
}
cl_qmap_init(&(mlag_lacp_db.pending_map));
mlag_lacp_db.local_sys_id = 0;
mlag_lacp_db.master_sys_id = 0;
bail:
return err;
}
nn_map_t *
open_node_name_map(char *node_name_map)
{
nn_map_t *map;
if (!node_name_map) {
#ifdef HAVE_DEFAULT_NODENAME_MAP
struct stat buf;
node_name_map = HAVE_DEFAULT_NODENAME_MAP;
if (stat(node_name_map, &buf))
return NULL;
#else
return NULL;
#endif /* HAVE_DEFAULT_NODENAME_MAP */
}
map = malloc(sizeof(*map));
if (!map)
return NULL;
cl_qmap_init(map);
if (parse_node_map(node_name_map, map_name, map)) {
fprintf(stderr,
"WARNING failed to open node name map \"%s\" (%s)\n",
node_name_map, strerror(errno));
close_node_name_map(map);
return NULL;
}
return map;
}
/** =========================================================================
*/
perfmgr_db_t *perfmgr_db_construct(osm_perfmgr_t *perfmgr)
{
perfmgr_db_t *db = malloc(sizeof(*db));
if (!db)
return NULL;
cl_qmap_init(&db->pc_data);
cl_plock_construct(&db->lock);
cl_plock_init(&db->lock);
db->perfmgr = perfmgr;
return db;
}
cl_status_t cl_event_wheel_init(IN cl_event_wheel_t * const p_event_wheel)
{
cl_status_t cl_status = CL_SUCCESS;
/* initialize */
p_event_wheel->p_external_lock = NULL;
p_event_wheel->closing = FALSE;
cl_status = cl_spinlock_init(&(p_event_wheel->lock));
if (cl_status != CL_SUCCESS)
return cl_status;
cl_qlist_init(&p_event_wheel->events_wheel);
cl_qmap_init(&p_event_wheel->events_map);
/* init the timer with timeout */
cl_status = cl_timer_init(&p_event_wheel->timer, __cl_event_wheel_callback, p_event_wheel); /* cb context */
return cl_status;
}
nn_map_t *open_node_name_map(char *node_name_map)
{
nn_map_t *map;
char linebuf[PARSE_NODE_MAP_BUFLEN + 1];
if (!node_name_map) {
#ifdef HAVE_DEFAULT_NODENAME_MAP
struct stat buf;
node_name_map = HAVE_DEFAULT_NODENAME_MAP;
if (stat(node_name_map, &buf))
return NULL;
#else
return NULL;
#endif /* HAVE_DEFAULT_NODENAME_MAP */
}
map = malloc(sizeof(*map));
if (!map)
return NULL;
cl_qmap_init(map);
memset(linebuf, '\0', PARSE_NODE_MAP_BUFLEN + 1);
if (parse_node_map_wrap(node_name_map, map_name, map,
linebuf, PARSE_NODE_MAP_BUFLEN)) {
if (errno == EIO) {
fprintf(stderr,
"WARNING failed to parse node name map "
"\"%s\"\n",
node_name_map);
fprintf(stderr,
"WARNING failed line: \"%s\"\n",
linebuf);
}
else
fprintf(stderr,
"WARNING failed to open node name map "
"\"%s\" (%s)\n",
node_name_map, strerror(errno));
close_node_name_map(map);
return NULL;
}
return map;
}
ib_api_status_t osm_ucast_mgr_init(IN osm_ucast_mgr_t * p_mgr, IN osm_sm_t * sm)
{
ib_api_status_t status = IB_SUCCESS;
OSM_LOG_ENTER(sm->p_log);
osm_ucast_mgr_construct(p_mgr);
p_mgr->sm = sm;
p_mgr->p_log = sm->p_log;
p_mgr->p_subn = sm->p_subn;
p_mgr->p_lock = sm->p_lock;
if (sm->p_subn->opt.use_ucast_cache)
cl_qmap_init(&p_mgr->cache_sw_tbl);
OSM_LOG_EXIT(p_mgr->p_log);
return status;
}
void osm_transaction_mgr_init(IN osm_vendor_t * const p_vend)
{
cl_status_t cl_status;
osm_transaction_mgr_t *trans_mgr_p;
OSM_LOG_ENTER(p_vend->p_log);
CL_ASSERT(p_vend->p_transaction_mgr == NULL);
(osm_transaction_mgr_t *) p_vend->p_transaction_mgr =
(osm_transaction_mgr_t *) malloc(sizeof(osm_transaction_mgr_t));
trans_mgr_p = (osm_transaction_mgr_t *) p_vend->p_transaction_mgr;
/* construct lock object */
cl_spinlock_construct(&(trans_mgr_p->transaction_mgr_lock));
CL_ASSERT(cl_spinlock_init(&(trans_mgr_p->transaction_mgr_lock)) ==
CL_SUCCESS);
/* initialize the qlist */
trans_mgr_p->madw_reqs_list_p =
(cl_qlist_t *) malloc(sizeof(cl_qlist_t));
cl_qlist_init(trans_mgr_p->madw_reqs_list_p);
/* initialize the qmap */
trans_mgr_p->madw_by_tid_map_p =
(cl_qmap_t *) malloc(sizeof(cl_qmap_t));
cl_qmap_init(trans_mgr_p->madw_by_tid_map_p);
/* create the timer used by the madw_req_list */
cl_timer_construct(&(trans_mgr_p->madw_list_timer));
/* init the timer with timeout. */
cl_status = cl_timer_init(&trans_mgr_p->madw_list_timer,
__osm_transaction_mgr_callback, p_vend);
if (cl_status != CL_SUCCESS) {
osm_log(p_vend->p_log, OSM_LOG_ERROR,
"osm_transaction_mgr_init : ERROR 1000: "
"Failed to initialize madw_reqs_list timer\n");
}
OSM_LOG_EXIT(p_vend->p_log);
}
ib_api_status_t
osmv_txnmgr_init(IN osmv_txn_mgr_t * p_tx_mgr,
IN osm_log_t * p_log, IN cl_spinlock_t * p_lock)
{
cl_status_t cl_st = CL_SUCCESS;
p_tx_mgr->p_event_wheel = malloc(sizeof(cl_event_wheel_t));
if (!p_tx_mgr->p_event_wheel) {
return IB_INSUFFICIENT_MEMORY;
}
memset(p_tx_mgr->p_event_wheel, 0, sizeof(cl_event_wheel_t));
cl_event_wheel_construct(p_tx_mgr->p_event_wheel);
/* NOTE! We are using an extended constructor.
* We tell the Event Wheel run in a non-protected manner in the reg/unreg calls,
* and acquire an external lock in the asynchronous callback.
*/
cl_st = cl_event_wheel_init_ex(p_tx_mgr->p_event_wheel, p_lock);
if (cl_st != CL_SUCCESS) {
free(p_tx_mgr->p_event_wheel);
return (ib_api_status_t) cl_st;
}
p_tx_mgr->p_txn_map = malloc(sizeof(cl_qmap_t));
if (!p_tx_mgr->p_txn_map) {
cl_event_wheel_destroy(p_tx_mgr->p_event_wheel);
free(p_tx_mgr->p_event_wheel);
return IB_INSUFFICIENT_MEMORY;
}
memset(p_tx_mgr->p_txn_map, 0, sizeof(cl_qmap_t));
cl_qmap_init(p_tx_mgr->p_txn_map);
p_tx_mgr->p_log = p_log;
return cl_st;
}
