/****************************************************************************
* PROCEDURE: mbcsv_lib_init
*
* Description : This is the function which initalize the mbcsv libarary.
* This function creates an global lock, creates MBCSV linked
* list, etc.
*
* Arguments : req_info - Request info.
*
* Return Values : SA_AIS_OK/Failure code.
*
* Notes : None.
*****************************************************************************/
uint32_t mbcsv_lib_init(NCS_LIB_REQ_INFO *req_info)
{
NCS_PATRICIA_PARAMS pt_params;
uint32_t rc = SA_AIS_OK;
TRACE_ENTER();
if (mbcsv_cb.created == true) {
TRACE_LEAVE2("Lib init request failed: MBCA already created");
return SA_AIS_ERR_INIT;
}
/*
* Create global lock
*/
m_NCS_LOCK_INIT(&mbcsv_cb.global_lock);
/*
* Create patricia tree for the MBCA registration instance
*/
pt_params.key_size = sizeof(uint32_t);
if (ncs_patricia_tree_init(&mbcsv_cb.reg_list, &pt_params) != NCSCC_RC_SUCCESS) {
TRACE_4("pat tree init failed");
rc = SA_AIS_ERR_FAILED_OPERATION;
goto err1;
}
if (NCSCC_RC_SUCCESS != mbcsv_initialize_mbx_list()) {
TRACE_4("pat tree init for mailbox failed");
rc = SA_AIS_ERR_FAILED_OPERATION;
goto err2;
}
/*
* Create patricia tree for the peer list
*/
if (mbcsv_initialize_peer_list() != NCSCC_RC_SUCCESS) {
TRACE_4("pat tree init for peer list failed");
rc = SA_AIS_ERR_FAILED_OPERATION;
goto err3;
}
mbcsv_cb.created = true;
return rc;
/* Handle Different Error Situations */
err3:
ncs_patricia_tree_destroy(&mbcsv_cb.mbx_list);
m_NCS_LOCK_DESTROY(&mbcsv_cb.mbx_list_lock);
err2:
ncs_patricia_tree_destroy(&mbcsv_cb.reg_list);
err1:
m_NCS_LOCK_DESTROY(&mbcsv_cb.global_lock);
TRACE_LEAVE();
return rc;
}
void ncshm_delete(void)
{
uint32_t i, j;
HM_UNIT *unit;
gl_im_created--;
if (gl_im_created > 0)
return;
/* Destroy all the locks now. */
for (i = 0; i < HM_POOL_CNT; i++) {
if (m_NCS_LOCK_DESTROY(&gl_hm.lock[i]) != NCSCC_RC_SUCCESS) {
m_LEAP_DBG_SINK_VOID;
}
}
for (i = 0; i < HM_UNIT_CNT; i++) {
if ((unit = gl_hm.unit[i]) != NULL) {
for (j = 0; j < HM_BANK_CNT; j++) {
if (unit->cells[j] != NULL)
free(unit->cells[j]);
}
free(unit);
}
}
/* Memset the gl_hm data structure. */
memset(&gl_hm, 0, sizeof(HM_CORE));
/* ncshm_init(); */ /* put struct back in start state.. Why not?? */
}
/****************************************************************************
Name : eda_destroy
Description : This routine destroys the EDA control block.
Arguments : destroy_info - ptr to the destroy info
Return Values : None
Notes : None
******************************************************************************/
void eda_destroy(NCS_LIB_DESTROY *destroy_info)
{
EDA_CB *cb = 0;
TRACE_ENTER();
/* retrieve EDA CB */
cb = (EDA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDA, gl_eda_hdl);
if (!cb) {
TRACE_LEAVE2("global take handle failed: %u", gl_eda_hdl);
return;
}
/* delete the hdl db */
eda_hdl_list_del(&cb->eda_init_rec_list);
/* unregister with MDS */
eda_mds_finalize(cb);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
/* return EDA CB */
ncshm_give_hdl(gl_eda_hdl);
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, cb->cb_hdl);
/* free the control block */
m_MMGR_FREE_EDA_CB(cb);
/* reset the global cb handle */
gl_eda_hdl = 0;
TRACE_LEAVE();
return;
}
/***********************************************************************//**
* @brief This routine destroys the PLMA Control block.
*
* @param[in] destroy_info - A pointer to the NCS_LIB_DESTROY structure.
*
* @return NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
***************************************************************************/
uns32 plma_destroy(NCS_LIB_DESTROY *destroy_info)
{
PLMA_CB *plma_cb = plma_ctrlblk;
TRACE_ENTER();
/* MDS unregister. */
plma_mds_unregister();
/** flush the EDU handle */
m_NCS_EDU_HDL_FLUSH(&plma_cb->edu_hdl);
/** destroy the client tree */
plma_client_tree_destroy();
/** destroy the lock */
m_NCS_LOCK_DESTROY(&plma_cb->cb_lock);
/** make reference to plma_cb obsolete */
plma_ctrlblk = NULL;
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* Name : eds_se_lib_destroy
*
* Description : Invoked to destroy the EDS
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
static uint32_t eds_se_lib_destroy(NCS_LIB_REQ_INFO *req_info)
{
/** Code to destroy the EDS **/
EDS_CB *eds_cb;
m_INIT_CRITICAL;
TRACE_ENTER();
if (NULL == (eds_cb = (NCSCONTEXT)ncshm_take_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl))) {
LOG_ER("Handle take failed for global handle");
TRACE_LEAVE();
return (NCSCC_RC_FAILURE);
} else {
m_START_CRITICAL;
/** Lock EDA_CB
**/
m_NCS_LOCK(&eds_cb->cb_lock, NCS_LOCK_WRITE);
/* deregister from AMF */
saAmfComponentUnregister(eds_cb->amf_hdl, &eds_cb->comp_name, NULL);
/* End association from the AMF lib */
saAmfFinalize(eds_cb->amf_hdl);
/* Finalize with CLM */
saClmFinalize(eds_cb->clm_hdl);
/* Clean up all internal structures */
eds_remove_reglist_entry(eds_cb, 0, true);
/* Destroy the cb */
eds_cb_destroy(eds_cb);
/* Give back the handle */
ncshm_give_hdl(gl_eds_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_GLD, gl_eds_hdl);
/* Detach from IPC */
m_NCS_IPC_DETACH(&eds_cb->mbx, eds_clear_mbx, eds_cb);
/* Disconnect from MDS */
eds_mds_finalize(eds_cb);
/* Release the IPC */
m_NCS_IPC_RELEASE(&eds_cb->mbx, NULL);
/** UnLock EDA_CB
**/
m_NCS_UNLOCK(&eds_cb->cb_lock, NCS_LOCK_WRITE);
m_NCS_LOCK_DESTROY(&eds_cb->cb_lock);
m_MMGR_FREE_EDS_CB(eds_cb);
gl_eds_hdl = 0;
m_END_CRITICAL;
TRACE("eds-cb-lib destroy done .");
}
TRACE_LEAVE();
return (NCSCC_RC_SUCCESS);
}
/****************************************************************************
Name : ava_destroy
Description : This routine destroys the AvA control block.
Arguments : destroy_info - ptr to the destroy info
Return Values : None
Notes : None
******************************************************************************/
void ava_destroy(NCS_LIB_DESTROY *destroy_info)
{
AVA_CB *cb = 0;
uns32 rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* retrieve AvA CB */
cb = (AVA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_AVA, gl_ava_hdl);
if (!cb) {
LOG_ER("Unable to take handle for control block");
goto done;
}
/* delete the hdl db */
ava_hdl_del(cb);
TRACE_1("Deleted the handles DB");
/* unregister with MDS */
rc = ava_mds_unreg(cb);
if (NCSCC_RC_SUCCESS != rc)
TRACE_4("MDS unregistration failed");
else
TRACE_1("MDS unregistration success");
/* EDU cleanup */
m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);
TRACE_1("EDU cleanup failed");
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->lock);
TRACE_1("Destroying lock for control block failed");
/* return AvA CB */
ncshm_give_hdl(gl_ava_hdl);
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_AVA, cb->cb_hdl);
TRACE_1("Removing association with handle manager failed");
/* free the control block */
free(cb);
/* reset the global cb handle */
gl_ava_hdl = 0;
done:
TRACE_LEAVE();
return;
}
/****************************************************************************
Name : mqa_destroy
Description : This routine destroys the MQA control block.
Arguments : destroy_info - ptr to the destroy info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
static uns32 mqa_destroy(NCS_LIB_DESTROY *destroy_info)
{
MQA_CB *cb = 0;
/* validate the CB */
cb = (MQA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_MQA, gl_mqa_hdl);
if (!cb)
return NCSCC_RC_FAILURE;
/* return MQA CB */
ncshm_give_hdl(gl_mqa_hdl);
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_MQA, cb->agent_handle_id);
if (m_NCS_LOCK(&cb->cb_lock, NCS_LOCK_WRITE) != NCSCC_RC_SUCCESS) {
TRACE("mqa_destroy Failed to acquire lock");
return NCSCC_RC_FAILURE;
}
mqa_timer_table_destroy(cb);
/* Unregister with ASAPi */
mqa_asapi_unregister(cb);
/* MDS unregister. */
mqa_mds_unregister(cb);
m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);
mqa_queue_tree_destroy(cb);
/* delete all the client info */
mqa_client_tree_destroy(cb);
m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
/* de register with the flex log */
mqa_flx_log_dereg();
/* reset the global cb handle */
gl_mqa_hdl = 0;
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* PROCEDURE : mbcsv_lib_destroy
*
* Description : This is the function which destroys the MBCSV.
*
* Arguments : None.
*
* Return Values : SA_AIS_OK/Failure code.
*
* Notes : None.
*****************************************************************************/
uint32_t mbcsv_lib_destroy(void)
{
MBCSV_REG *mbc_reg;
SS_SVC_ID svc_id = 0;
SaAisErrorT rc = SA_AIS_OK;
TRACE_ENTER();
if (mbcsv_cb.created == false) {
TRACE_LEAVE2("Lib destroy request failed: Create MBCA before destroying");
return SA_AIS_ERR_EXIST;
}
m_NCS_LOCK(&mbcsv_cb.global_lock, NCS_LOCK_WRITE);
mbcsv_cb.created = false;
/*
* Walk through MBCSv reg list and destroy all the registration instances.
*/
while (NULL != (mbc_reg = (MBCSV_REG *)ncs_patricia_tree_getnext(&mbcsv_cb.reg_list, (const uint8_t *)&svc_id))) {
svc_id = mbc_reg->svc_id;
if (NCSCC_RC_SUCCESS != mbcsv_rmv_reg_inst((MBCSV_REG *)&mbcsv_cb.reg_list, mbc_reg)) {
/* Not required to return for failure, log the err message and go
ahead with cleanup */
TRACE_4("Failed to remove this service instance:%u", mbc_reg->svc_id);
}
}
ncs_patricia_tree_destroy(&mbcsv_cb.reg_list);
/*
* Call function which will destroy and free all the entries of the peer list.
*/
mbcsv_destroy_peer_list();
/*
* Call function which will destroy mail box list.
*/
mbcsv_destroy_mbx_list();
m_NCS_UNLOCK(&mbcsv_cb.global_lock, NCS_LOCK_WRITE);
m_NCS_LOCK_DESTROY(&mbcsv_cb.global_lock);
TRACE_LEAVE();
return rc;
}
/**************************************************************************\
* exec_mod_cb_destroy
*
* Description : Destroys module control block.
*
* Call Arguments : None
*
* Returns:
* SUCCESS/FAILURE : NCSCC_RC_SUCCESS / NCSCC_RC_FAILURE
*
* Notes:
*
\**************************************************************************/
uns32 exec_mod_cb_destroy(void)
{
SYSF_PID_LIST *exec_pid = NULL;
uns8 pid = 0;
if (module_cb.init == TRUE) {
module_cb.init = FALSE;
m_NCS_SIGNAL(SIGCHLD, SIG_DFL);
close(module_cb.write_fd);
close(module_cb.read_fd);
m_NCS_TASK_RELEASE(module_cb.em_task_handle);
m_NCS_LOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
while (NULL != (exec_pid = (SYSF_PID_LIST *)ncs_patricia_tree_getnext(&module_cb.pid_list,
(const uns8 *)&pid))) {
ncs_patricia_tree_del(&module_cb.pid_list, (NCS_PATRICIA_NODE *)exec_pid);
if (exec_pid->tmr_id != NULL)
m_NCS_TMR_DESTROY(exec_pid->tmr_id);
m_MMGR_FREE_PRO_EXC(exec_pid);
}
if (ncs_patricia_tree_destroy(&module_cb.pid_list) != NCSCC_RC_SUCCESS) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
m_NCS_UNLOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
}
m_NCS_LOCK_DESTROY(&module_cb.tree_lock);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : cpa_destroy
Description : This routine destroys the CPA control block.
Arguments : destroy_info - ptr to the destroy info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
static uint32_t cpa_destroy(NCS_LIB_DESTROY *destroy_info)
{
CPA_CB *cb = NULL;
/* validate the CB */
m_CPA_RETRIEVE_CB(cb);
if (!cb)
return NCSCC_RC_FAILURE;
/* MDS unregister. */
cpa_mds_unregister(cb);
m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);
/* Destroy the CPA database */
cpa_db_destroy(cb);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
/* return CPA CB Handle */
ncshm_give_hdl(cb->agent_handle_id);
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_CPA, cb->agent_handle_id);
TRACE_2("cpa lib destroy success ");
/* Memory leaks found in cpa_init.c */
m_MMGR_FREE_CPA_CB(cb);
/* reset the global cb handle */
gl_cpa_hdl = 0;
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : eda_destroy
Description : This routine destroys the EDA control block.
Arguments : destroy_info - ptr to the destroy info
Return Values : None
Notes : None
******************************************************************************/
void eda_destroy(NCS_LIB_DESTROY *destroy_info)
{
EDA_CB *cb = 0;
/* retrieve EDA CB */
cb = (EDA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDA, gl_eda_hdl);
if (!cb) {
m_LOG_EDSV_A(EDA_CB_HDL_TAKE_FAILED, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
return;
}
/* delete the hdl db */
eda_hdl_list_del(&cb->eda_init_rec_list);
/* unregister with MDS */
eda_mds_finalize(cb);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
/* de register with the flex log */
eda_flx_log_dereg();
/* return EDA CB */
ncshm_give_hdl(gl_eda_hdl);
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, cb->cb_hdl);
/* free the control block */
m_MMGR_FREE_EDA_CB(cb);
/* reset the global cb handle */
gl_eda_hdl = 0;
return;
}
/***********************************************************************//**
* @brief This routine creates and initializes the PLMA Control block.
*
* @param[in] create_info - A pointer to the structure that has creation
* parameters, if any, are provided to libraries
* in a command-line arguments style.
*
* @return NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
***************************************************************************/
uns32 plma_create(NCS_LIB_CREATE *create_info)
{
PLMA_CB *plma_cb;
uns32 rc = NCSCC_RC_SUCCESS;
if(!plma_ctrlblk){
plma_ctrlblk = &_plma_cb;
}
plma_cb = plma_ctrlblk;
TRACE_ENTER();
/** validate create info */
if (create_info == NULL){
LOG_ER("PLMA : INVALID create_info RECEIVED");
rc = NCSCC_RC_FAILURE;
goto end;
}
memset(plma_cb, 0, sizeof(PLMA_CB));
/** Initialize the PLMA_CB lock */
if (m_NCS_LOCK_INIT(&plma_cb->cb_lock) != NCSCC_RC_SUCCESS) {
LOG_ER("PLMA: cb_lock INIT FAILED");
rc = NCSCC_RC_FAILURE;
goto lock_fail;
}
/** initialize the client tree */
if (plma_client_tree_init() != NCSCC_RC_SUCCESS) {
LOG_ER("PLMA: CLIENT TREE INIT FAILED");
rc = NCSCC_RC_FAILURE;
goto cl_tree_init_fail;
}
/** initialize the group tree */
if (plma_group_tree_init() != NCSCC_RC_SUCCESS) {
LOG_ER("PLMA: GROUP INFO TREE INIT FAILED");
rc = NCSCC_RC_FAILURE;
goto gr_tree_init_fail;
}
/** register with MDS */
if (plma_mds_register() != NCSCC_RC_SUCCESS) {
LOG_ER("PLMA: MDS REGISTER FAILED");
rc = NCSCC_RC_FAILURE;
goto mds_reg_fail;
}
/** EDU initialisation */
if (m_NCS_EDU_HDL_INIT(&plma_cb->edu_hdl) != NCSCC_RC_SUCCESS) {
LOG_ER("PLMA: EDU HDL INIT FAILED");
rc = NCSCC_RC_FAILURE;
goto edu_init_fail;
}
plma_sync_with_plms();
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
edu_init_fail:
plma_mds_unregister();
mds_reg_fail:
plma_group_tree_destroy();
gr_tree_init_fail:
plma_client_tree_destroy();
cl_tree_init_fail:
/** destroy the lock */
m_NCS_LOCK_DESTROY(&plma_cb->cb_lock);
lock_fail:
/** make reference to plma_cb obsolete */
plma_ctrlblk = NULL;
end:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : cpa_create
Description : This routine creates & initializes the CPA control block.
Arguments : create_info - ptr to the create info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
static uint32_t cpa_create(NCS_LIB_CREATE *create_info)
{
CPA_CB *cb = NULL;
uint32_t rc;
/* validate create info */
if (create_info == NULL)
return NCSCC_RC_FAILURE;
/* Malloc the CB for CPA */
cb = m_MMGR_ALLOC_CPA_CB;
if (cb == NULL) {
TRACE_4("cpa mem alloc failed for CPA_CB");
goto cb_alloc_fail;
}
memset(cb, 0, sizeof(CPA_CB));
/* assign the CPA pool-id (used by hdl-mngr) */
cb->pool_id = NCS_HM_POOL_ID_COMMON;
/* create the association with hdl-mngr */
if (!(cb->agent_handle_id = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_CPA, (NCSCONTEXT)cb))) {
TRACE_4("cpa create failed int ncsshm_create_hdl");
goto hm_create_fail;
}
/*store the hdl in the global variable */
gl_cpa_hdl = cb->agent_handle_id;
/* get the process id */
cb->process_id = getpid();
/* initialize the cpa cb lock */
if (m_NCS_LOCK_INIT(&cb->cb_lock) != NCSCC_RC_SUCCESS) {
TRACE_4("cpa create failed in LOCK_INIT ");
goto lock_init_fail;
}
/* Initalize the CPA Trees & Linked lists */
rc = cpa_db_init(cb);
if (rc != NCSCC_RC_SUCCESS) {
/* No need to log here, already logged in cpa_db_init */
goto db_init_fail;
}
/* register with MDS */
if (cpa_mds_register(cb) != NCSCC_RC_SUCCESS) {
/* No need to log here, already logged in cpa_mds_register */
goto mds_reg_fail;
}
cpa_sync_with_cpnd(cb);
/* EDU initialisation */
if (m_NCS_EDU_HDL_INIT(&cb->edu_hdl) != NCSCC_RC_SUCCESS) {
TRACE_4("cpa create failed in EDU_INIT:");
goto edu_init_fail;
}
TRACE_1("cpa create sucess,Lib init success");
return NCSCC_RC_SUCCESS;
/* error8:
m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); */
edu_init_fail:
/* MDS unregister. */
cpa_mds_unregister(cb);
mds_reg_fail:
cb->is_cpnd_joined_clm = false;
cpa_db_destroy(cb);
db_init_fail:
/* destroy the lock */
cb->is_cpnd_joined_clm = false;
m_NCS_LOCK_DESTROY(&cb->cb_lock);
lock_init_fail:
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_CPA, cb->agent_handle_id);
gl_cpa_hdl = 0;
hm_create_fail:
/* Free the CB */
m_MMGR_FREE_CPA_CB(cb);
cb_alloc_fail:
return NCSCC_RC_FAILURE;
}
bool sysfTmrDestroy(void)
{
SYSF_TMR *tmr;
SYSF_TMR *free_tmr;
SYSF_TMR_PAT_NODE *tmp = NULL;
/* There is only ever one timer per instance */
m_NCS_LOCK(&gl_tcb.safe.free_lock, NCS_LOCK_WRITE);
gl_tcb.safe.dmy_free.next = NULL;
m_NCS_UNLOCK(&gl_tcb.safe.free_lock, NCS_LOCK_WRITE);
m_NCS_LOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE);
/* Create selection object */
m_NCS_SEL_OBJ_CREATE(&tmr_destroy_syn_obj);
tmr_destroying = true;
m_NCS_SEL_OBJ_IND(&gl_tcb.sel_obj);
/* Unlock the lock */
m_NCS_UNLOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE); /* critical region END */
/* Wait on Poll object */
osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(tmr_destroy_syn_obj), 20000);
m_NCS_LOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE);
tmr = &gl_tcb.safe.dmy_keep;
while (tmr->keep != NULL) {
free_tmr = tmr->keep;
tmr->keep = tmr->keep->keep;
m_NCS_MEM_FREE(free_tmr, NCS_MEM_REGION_PERSISTENT, NCS_SERVICE_ID_LEAP_TMR, 0);
}
while ((tmp = (SYSF_TMR_PAT_NODE *)ncs_patricia_tree_getnext(&gl_tcb.tmr_pat_tree, (uint8_t *)0)) != NULL) {
ncs_patricia_tree_del(&gl_tcb.tmr_pat_tree, (NCS_PATRICIA_NODE *)tmp);
m_NCS_MEM_FREE(tmp, NCS_MEM_REGION_PERSISTENT, NCS_SERVICE_ID_LEAP_TMR, 0);
}
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
m_NCS_SEL_OBJ_DESTROY(&gl_tcb.sel_obj);
/* Stop the dedicated thread that runs out of ncs_tmr_wait() */
m_NCS_TASK_RELEASE(gl_tcb.p_tsk_hdl);
tmr_destroying = false;
m_NCS_SEL_OBJ_DESTROY(&tmr_destroy_syn_obj);
m_NCS_UNLOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE); /* critical region END */
/* don't destroy the lock (but remember that you could!).
* m_NCS_LOCK_DESTROY (&l_tcb.lock);
*/
m_NCS_LOCK_DESTROY(&gl_tcb.safe.enter_lock);
m_NCS_LOCK_DESTROY(&gl_tcb.safe.free_lock);
ncs_tmr_create_done = false;
return true;
}
/****************************************************************************
Name : mqa_create
Description : This routine creates & initializes the MQA control block.
Arguments : create_info - ptr to the create info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
static uns32 mqa_create(NCS_LIB_CREATE *create_info)
{
MQA_CB *cb = &mqa_cb;
uns32 rc = NCSCC_RC_SUCCESS;
/* validate create info */
if (create_info == NULL)
return NCSCC_RC_FAILURE;
/* Register with Logging subsystem */
mqa_flx_log_reg();
memset(cb, 0, sizeof(MQA_CB));
/* assign the MQA pool-id (used by hdl-mngr) */
cb->pool_id = NCS_HM_POOL_ID_COMMON;
/* create the association with hdl-mngr */
if (!(cb->agent_handle_id = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_MQA, (NCSCONTEXT)cb))) {
m_LOG_MQSV_A(MQA_CREATE_HANDLE_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__);
goto error1;
}
m_LOG_MQSV_A(MQA_CREATE_HANDLE_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, 1, __FILE__, __LINE__);
/* everything went off well.. store the hdl in the global variable */
gl_mqa_hdl = cb->agent_handle_id;
/* get the process id */
cb->process_id = getpid();
/* initialize the mqa cb lock */
if ((rc = m_NCS_LOCK_INIT(&cb->cb_lock)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_CB_LOCK_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__);
goto error2;
}
m_LOG_MQSV_A(MQA_CB_LOCK_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__);
/* initialize the client tree */
if ((rc = mqa_client_tree_init(cb)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_CLIENT_TREE_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
goto error3;
}
m_LOG_MQSV_A(MQA_CLIENT_TREE_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__);
/* initialize the queue tree */
if ((rc = mqa_queue_tree_init(cb)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_QUEUE_TREE_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
goto error4;
}
m_LOG_MQSV_A(MQA_QUEUE_TREE_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__);
/* EDU initialisation */
if ((rc = m_NCS_EDU_HDL_INIT(&cb->edu_hdl)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_EDU_HDL_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
goto error5;
}
m_LOG_MQSV_A(MQA_EDU_HDL_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__);
/* register with MDS */
if ((rc = mqa_mds_register(cb)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_MDS_REGISTER_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
goto error6;
} else
m_LOG_MQSV_A(MQA_MDS_REGISTER_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_INFO, rc, __FILE__, __LINE__);
/* Update clm_node_joined flag to 1 */
cb->clm_node_joined = 1;
mqa_sync_with_mqd(cb);
mqa_sync_with_mqnd(cb);
/* initialize the timeout linked list */
if ((rc = mqa_timer_table_init(cb)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_TIMER_TABLE_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
goto error7;
}
if ((rc = mqa_asapi_register(cb)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_REGISTER_WITH_ASAPi_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__,
__LINE__);
goto error8;
}
return NCSCC_RC_SUCCESS;
error8:
mqa_timer_table_destroy(cb);
error7:
/* MDS unregister. */
mqa_mds_unregister(cb);
error6:
m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);
error5:
/* delete the tree */
mqa_queue_tree_destroy(cb);
error4:
/* delete the tree */
mqa_client_tree_destroy(cb);
error3:
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
error2:
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_MQA, cb->agent_handle_id);
error1:
/* de register with the flex log */
mqa_flx_log_dereg();
return NCSCC_RC_FAILURE;
}
/****************************************************************************
Name : eda_create
Description : This routine creates & initializes the EDA control block.
Arguments : create_info - ptr to the create info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 eda_create(NCS_LIB_CREATE *create_info)
{
EDA_CB *cb = 0;
uns32 rc = NCSCC_RC_SUCCESS;
if (NULL == create_info)
return NCSCC_RC_FAILURE;
/* Register with the Logging subsystem */
eda_flx_log_reg();
/* allocate EDA cb */
if (NULL == (cb = m_MMGR_ALLOC_EDA_CB)) {
m_LOG_EDSV_A(EDA_MEMALLOC_FAILED, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
rc = NCSCC_RC_FAILURE;
goto error;
}
memset(cb, 0, sizeof(EDA_CB));
/* assign the EDA pool-id (used by hdl-mngr) */
cb->pool_id = NCS_HM_POOL_ID_COMMON;
/* create the association with hdl-mngr */
if (0 == (cb->cb_hdl = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_EDA, (NCSCONTEXT)cb))) {
m_LOG_EDSV_A(EDA_CB_HDL_CREATE_FAILED, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
rc = NCSCC_RC_FAILURE;
goto error;
}
/* get the process id */
cb->prc_id = getpid();
/* initialize the eda cb lock */
m_NCS_LOCK_INIT(&cb->cb_lock);
m_NCS_LOCK_INIT(&cb->eds_sync_lock);
/* Store the cb hdl in the global variable */
gl_eda_hdl = cb->cb_hdl;
/* register with MDS */
if ((NCSCC_RC_SUCCESS != (rc = eda_mds_init(cb)))) {
m_LOG_EDSV_A(EDA_MDS_INIT_FAILED, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__, 0);
rc = NCSCC_RC_FAILURE;
goto error;
}
eda_sync_with_eds(cb);
cb->node_status = SA_CLM_NODE_JOINED;
return rc;
error:
if (cb) {
/* remove the association with hdl-mngr */
if (cb->cb_hdl)
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, cb->cb_hdl);
/* delete the eda init instances */
eda_hdl_list_del(&cb->eda_init_rec_list);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
/* free the control block */
m_MMGR_FREE_EDA_CB(cb);
}
return rc;
}
/****************************************************************************
Name : avnd_cb_destroy
Description : This routine destroys AvND control block.
Arguments : cb - ptr to AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 avnd_cb_destroy(AVND_CB *cb)
{
uns32 rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/*** destroy all databases ***/
/* We should delete external SU-SI first */
#ifdef NCS_AVND_MBCSV_CKPT
if (NCSCC_RC_SUCCESS != (rc = avnd_ext_comp_data_clean_up(cb, TRUE)))
goto done;
#endif
/* destroy comp db */
if (NCSCC_RC_SUCCESS != (rc = avnd_compdb_destroy(cb)))
goto done;
/* destroy su db */
if (NCSCC_RC_SUCCESS != (rc = avnd_sudb_destroy(cb)))
goto done;
/* destroy healthcheck db */
if (NCSCC_RC_SUCCESS != (rc = avnd_hcdb_destroy(cb)))
goto done;
/* destroy pg db */
if (NCSCC_RC_SUCCESS != (rc = avnd_pgdb_destroy(cb)))
goto done;
/* Clean PID monitoring list */
avnd_pid_mon_list_destroy(cb);
/* destroy nodeid to mds dest db */
if (NCSCC_RC_SUCCESS != (rc = avnd_nodeid_to_mdsdest_map_db_destroy(cb)))
goto done;
/* destroy available internode comp db */
if (NCSCC_RC_SUCCESS != (rc = avnd_internode_avail_comp_db_destroy(cb)))
goto done;
/* destroy DND list */
avnd_dnd_list_destroy(cb);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->lock);
TRACE("Destroyed the cb lock");
/* destroy the PID monitor lock */
m_NCS_LOCK_DESTROY(&cb->mon_lock);
/* detach & destroy AvND mailbox */
rc = avnd_mbx_destroy(cb);
if (NCSCC_RC_SUCCESS != rc)
goto done;
cb = NULL;
TRACE("finalized the control block");
done:
if (NCSCC_RC_SUCCESS != rc)
LOG_ER("cleanup failed");
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : ava_create
Description : This routine creates & initializes the AvA control block.
Arguments : create_info - ptr to the create info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 ava_create(NCS_LIB_CREATE *create_info)
{
AVA_CB *cb = 0;
NCS_SEL_OBJ_SET set;
uns32 rc = NCSCC_RC_SUCCESS, timeout = 300;
EDU_ERR err;
TRACE_ENTER();
/* allocate AvA cb */
if (!(cb = calloc(1, sizeof(AVA_CB)))) {
LOG_ER("AVA Create: Calloc failed");
rc = NCSCC_RC_FAILURE;
goto error;
}
/* fetch the comp name from the env variable */
if (getenv("SA_AMF_COMPONENT_NAME")) {
if (strlen(getenv("SA_AMF_COMPONENT_NAME")) < SA_MAX_NAME_LENGTH) {
strcpy((char *)cb->comp_name.value, getenv("SA_AMF_COMPONENT_NAME"));
cb->comp_name.length = (uns16)strlen((char *)cb->comp_name.value);
m_AVA_FLAG_SET(cb, AVA_FLAG_COMP_NAME);
TRACE("Component name = %s",cb->comp_name.value);
} else {
TRACE_2("Length of SA_AMF_COMPONENT_NAME exceeds SA_MAX_NAME_LENGTH bytes");
rc = NCSCC_RC_FAILURE;
goto error;
}
}
/* assign the AvA pool-id (used by hdl-mngr) */
cb->pool_id = NCS_HM_POOL_ID_COMMON;
/* create the association with hdl-mngr */
if (!(cb->cb_hdl = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_AVA, (NCSCONTEXT)cb))) {
LOG_ER("Unable to create handle for control block");
rc = NCSCC_RC_FAILURE;
goto error;
}
TRACE("Created handle for the control block");
/* initialize the AvA cb lock */
m_NCS_LOCK_INIT(&cb->lock);
TRACE("Initialized the AVA control block lock");
/* EDU initialisation */
m_NCS_EDU_HDL_INIT(&cb->edu_hdl);
TRACE("EDU Initialization success");
rc = m_NCS_EDU_COMPILE_EDP(&cb->edu_hdl, avsv_edp_nda_msg, &err);
if (rc != NCSCC_RC_SUCCESS) {
TRACE_4("EDU Compilation failed");
goto error;
}
/* create the sel obj (for mds sync) */
m_NCS_SEL_OBJ_CREATE(&cb->sel_obj);
/* initialize the hdl db */
if (NCSCC_RC_SUCCESS != ava_hdl_init(&cb->hdl_db)) {
TRACE_4("AVA Handles DB initialization failed");
rc = NCSCC_RC_FAILURE;
goto error;
}
TRACE("AVA Handles DB created successfully");
m_NCS_SEL_OBJ_ZERO(&set);
m_NCS_SEL_OBJ_SET(cb->sel_obj, &set);
m_AVA_FLAG_SET(cb, AVA_FLAG_FD_VALID);
/* register with MDS */
if ((NCSCC_RC_SUCCESS != ava_mds_reg(cb))) {
LOG_ER("AVA MDS Registration failed");
rc = NCSCC_RC_FAILURE;
goto error;
}
TRACE("AVA MDS Registration success");
TRACE_1("Waiting on select till AMF Node Director is up");
/* block until mds detects avnd */
m_NCS_SEL_OBJ_SELECT(cb->sel_obj, &set, 0, 0, &timeout);
/* reset the fd validity flag */
m_NCS_LOCK(&cb->lock, NCS_LOCK_WRITE);
m_AVA_FLAG_RESET(cb, AVA_FLAG_FD_VALID);
m_NCS_UNLOCK(&cb->lock, NCS_LOCK_WRITE);
/* This sel obj is no more used */
m_NCS_SEL_OBJ_DESTROY(cb->sel_obj);
/* everything went off well.. store the cb hdl in the global variable */
gl_ava_hdl = cb->cb_hdl;
TRACE_LEAVE();
return rc;
error:
if (cb) {
/* remove the association with hdl-mngr */
if (cb->cb_hdl)
ncshm_destroy_hdl(NCS_SERVICE_ID_AVA, cb->cb_hdl);
/* delete the hdl db */
ava_hdl_del(cb);
/* Flush the edu hdl */
m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->lock);
/* free the control block */
free(cb);
}
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : mqa_create
Description : This routine creates & initializes the MQA control block.
Arguments : create_info - ptr to the create info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
static uint32_t mqa_create(NCS_LIB_CREATE *create_info)
{
MQA_CB *cb = &mqa_cb;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* validate create info */
if (create_info == NULL)
return NCSCC_RC_FAILURE;
memset(cb, 0, sizeof(MQA_CB));
/* assign the MQA pool-id (used by hdl-mngr) */
cb->pool_id = NCS_HM_POOL_ID_COMMON;
/* create the association with hdl-mngr */
if (!(cb->agent_handle_id = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_MQA, (NCSCONTEXT)cb))) {
TRACE_2("Handle Registration Failed");
return NCSCC_RC_FAILURE;
}
TRACE_1("Handle Registration Success");
/* everything went off well.. store the hdl in the global variable */
gl_mqa_hdl = cb->agent_handle_id;
/* get the process id */
cb->process_id = getpid();
/* initialize the mqa cb lock */
if ((rc = m_NCS_LOCK_INIT(&cb->cb_lock)) != NCSCC_RC_SUCCESS) {
TRACE_2("Cotnrol Block Lock Initialisation Failed eith return value %d", rc);
goto error1;
}
TRACE_1("Control Block lock initialization Success");
/* initialize the client tree */
if ((rc = mqa_client_tree_init(cb)) != NCSCC_RC_SUCCESS) {
TRACE_2("FAILURE: Client database Initialization Failed");
goto error2;
}
TRACE_1("Client Database Initialization Success");
/* initialize the queue tree */
if ((rc = mqa_queue_tree_init(cb)) != NCSCC_RC_SUCCESS) {
TRACE_2("FAILURE: Queue database Initialization Failed");
goto error3;
}
TRACE_1("Queue Database Initialization Success");
/* EDU initialisation */
if ((rc = m_NCS_EDU_HDL_INIT(&cb->edu_hdl)) != NCSCC_RC_SUCCESS) {
TRACE_2("Edu Handle Initialization Failed");
goto error4;
}
TRACE_1("EDU Handle Initialization Success");
/* register with MDS */
if ((rc = mqa_mds_register(cb)) != NCSCC_RC_SUCCESS) {
TRACE_2("FAILURE: MDS registration Failed");
goto error5;
} else
TRACE_1("MDS Registration Success");
/* Update clm_node_joined flag to 1 */
cb->clm_node_joined = 1;
mqa_sync_with_mqd(cb);
mqa_sync_with_mqnd(cb);
/* initialize the timeout linked list */
if ((rc = mqa_timer_table_init(cb)) != NCSCC_RC_SUCCESS) {
TRACE_2("FAILURE: Tmr Initialization Failed");
goto error6;
}
if ((rc = mqa_asapi_register(cb)) != NCSCC_RC_SUCCESS) {
TRACE_2("FAILURE: Registration with ASAPi Failed");
goto error7;
}
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
error7:
mqa_timer_table_destroy(cb);
error6:
/* MDS unregister. */
mqa_mds_unregister(cb);
error5:
m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);
error4:
/* delete the tree */
mqa_queue_tree_destroy(cb);
error3:
/* delete the tree */
mqa_client_tree_destroy(cb);
error2:
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
error1:
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_MQA, cb->agent_handle_id);
return NCSCC_RC_FAILURE;
}
/****************************************************************************
Name : eda_create
Description : This routine creates & initializes the EDA control block.
Arguments : create_info - ptr to the create info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uint32_t eda_create(NCS_LIB_CREATE *create_info)
{
EDA_CB *cb = 0;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
if (NULL == create_info) {
TRACE_LEAVE2("create_info is NULL");
return NCSCC_RC_FAILURE;
}
/* allocate EDA cb */
if (NULL == (cb = m_MMGR_ALLOC_EDA_CB)) {
TRACE_4("malloc failed");
rc = NCSCC_RC_FAILURE;
goto error;
}
memset(cb, 0, sizeof(EDA_CB));
/* assign the EDA pool-id (used by hdl-mngr) */
cb->pool_id = NCS_HM_POOL_ID_COMMON;
/* create the association with hdl-mngr */
if (0 == (cb->cb_hdl = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_EDA, (NCSCONTEXT)cb))) {
TRACE_4("create handle failed");
rc = NCSCC_RC_FAILURE;
goto error;
}
/* get the process id */
cb->prc_id = getpid();
/* initialize the eda cb lock */
m_NCS_LOCK_INIT(&cb->cb_lock);
m_NCS_LOCK_INIT(&cb->eds_sync_lock);
/* Store the cb hdl in the global variable */
gl_eda_hdl = cb->cb_hdl;
TRACE_1("global eda library handle is: %u", gl_eda_hdl);
/* register with MDS */
if ((NCSCC_RC_SUCCESS != (rc = eda_mds_init(cb)))) {
TRACE_4("mds init failed");
rc = NCSCC_RC_FAILURE;
goto error;
}
eda_sync_with_eds(cb);
cb->node_status = SA_CLM_NODE_JOINED;
TRACE_LEAVE2("Default local node membership status: %u", cb->node_status);
return rc;
error:
if (cb) {
/* remove the association with hdl-mngr */
if (cb->cb_hdl)
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, cb->cb_hdl);
/* delete the eda init instances */
eda_hdl_list_del(&cb->eda_init_rec_list);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
/* free the control block */
m_MMGR_FREE_EDA_CB(cb);
}
TRACE_LEAVE();
return rc;
}
