/****************************************************************************
* Name : gld_se_lib_init
*
* Description : Invoked to Initialize the GLD
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
uns32 gld_se_lib_init(NCS_LIB_REQ_INFO *req_info)
{
GLSV_GLD_CB *gld_cb;
SaAisErrorT amf_error;
uns32 res = NCSCC_RC_SUCCESS;
SaAmfHealthcheckKeyT Healthy;
int8 *health_key;
/* Register with Logging subsystem */
if (NCS_GLSV_LOG == 1)
gld_flx_log_reg();
/* Allocate and initialize the control block */
gld_cb = m_MMGR_ALLOC_GLSV_GLD_CB;
if (gld_cb == NULL) {
m_LOG_GLD_MEMFAIL(GLD_CB_ALLOC_FAILED, __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
}
memset(gld_cb, 0, sizeof(GLSV_GLD_CB));
/* TBD- Pool id is to be set */
gl_gld_hdl = gld_cb->my_hdl = ncshm_create_hdl(gld_cb->hm_poolid, NCS_SERVICE_ID_GLD, (NCSCONTEXT)gld_cb);
if (0 == gld_cb->my_hdl) {
m_LOG_GLD_HEADLINE(GLD_CREATE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
/* Initialize the cb parameters */
if (gld_cb_init(gld_cb) != NCSCC_RC_SUCCESS) {
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
/* Initialize amf framework */
if (gld_amf_init(gld_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
}
m_LOG_GLD_SVC_PRVDR(GLD_AMF_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/* Bind to MDS */
if (gld_mds_init(gld_cb) != NCSCC_RC_SUCCESS) {
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
} else
m_LOG_GLD_SVC_PRVDR(GLD_MDS_INSTALL_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/* Initialise with the MBCSV service */
if (glsv_gld_mbcsv_register(gld_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
} else {
m_LOG_GLD_MBCSV(GLD_MBCSV_INIT_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
}
/* register glsv with imm */
amf_error = gld_imm_init(gld_cb);
if (amf_error != SA_AIS_OK) {
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
gld_log(NCSFL_SEV_ERROR, "Imm Init Failed %u\n", amf_error);
return NCSCC_RC_FAILURE;
}
/* TASK CREATION AND INITIALIZING THE MAILBOX */
if ((m_NCS_IPC_CREATE(&gld_cb->mbx) != NCSCC_RC_SUCCESS) ||
(m_NCS_IPC_ATTACH(&gld_cb->mbx) != NCSCC_RC_SUCCESS) ||
(m_NCS_TASK_CREATE((NCS_OS_CB)gld_main_process,
&gld_cb->mbx, "GLD", m_GLD_TASK_PRIORITY,
m_GLD_STACKSIZE,
&gld_cb->task_hdl) != NCSCC_RC_SUCCESS) ||
(m_NCS_TASK_START(gld_cb->task_hdl) != NCSCC_RC_SUCCESS)) {
m_LOG_GLD_HEADLINE(GLD_IPC_TASK_INIT, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return (NCSCC_RC_FAILURE);
}
m_NCS_EDU_HDL_INIT(&gld_cb->edu_hdl);
/* register GLD component with AvSv */
amf_error = saAmfComponentRegister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL);
if (amf_error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__);
m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
return NCSCC_RC_FAILURE;
} else
m_LOG_GLD_SVC_PRVDR(GLD_AMF_REG_SUCCESS, NCSFL_SEV_INFO, __FILE__, __LINE__);
/** start the AMF health check **/
memset(&Healthy, 0, sizeof(Healthy));
health_key = (int8 *)getenv("GLSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
if (strlen("A1B2") < sizeof(Healthy.key))
strncpy((char *)Healthy.key, "A1B2", sizeof(Healthy.key));
m_LOG_GLD_HEADLINE(GLD_HEALTH_KEY_DEFAULT_SET, NCSFL_SEV_INFO, __FILE__, __LINE__, 0);
} else {
if (strlen((char *)health_key) < sizeof(Healthy.key))
strncpy((char *)Healthy.key, (char *)health_key, SA_AMF_HEALTHCHECK_KEY_MAX - 1);
}
Healthy.keyLen = strlen((char *)Healthy.key);
amf_error = saAmfHealthcheckStart(gld_cb->amf_hdl, &gld_cb->comp_name, &Healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_FAILOVER);
if (amf_error != SA_AIS_OK) {
m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__);
saAmfComponentUnregister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL);
m_NCS_EDU_HDL_FLUSH(&gld_cb->edu_hdl);
m_NCS_TASK_RELEASE(gld_cb->task_hdl);
m_NCS_IPC_RELEASE(&gld_cb->mbx, NULL);
saImmOiFinalize(gld_cb->immOiHandle);
glsv_gld_mbcsv_unregister(gld_cb);
gld_mds_shut(gld_cb);
saAmfFinalize(gld_cb->amf_hdl);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
} else
m_LOG_GLD_SVC_PRVDR(GLD_AMF_HLTH_CHK_START_DONE, NCSFL_SEV_INFO, __FILE__, __LINE__);
return (res);
}
/****************************************************************************
Name : ntfa_hdl_rec_add
Description : This routine adds the handle record to the ntfa cb.
Arguments : cb - ptr tot he NTFA control block
reg_cbks - ptr to the set of registered callbacks
client_id - obtained from NTFS.
Return Values : ptr to the ntfa handle record
Notes : None
******************************************************************************/
ntfa_client_hdl_rec_t *ntfa_hdl_rec_add(ntfa_cb_t *cb, const SaNtfCallbacksT *reg_cbks, uns32 client_id)
{
ntfa_client_hdl_rec_t *rec = calloc(1, sizeof(ntfa_client_hdl_rec_t));
if (rec == NULL) {
TRACE("calloc failed");
goto done;
}
/* create the association with hdl-mngr */
if (0 == (rec->local_hdl = ncshm_create_hdl(NCS_HM_POOL_ID_COMMON, NCS_SERVICE_ID_NTFA, (NCSCONTEXT)rec))) {
TRACE("ncshm_create_hdl failed");
goto err_free;
}
/* store the registered callbacks */
if (reg_cbks)
memcpy((void *)&rec->reg_cbk, (void *)reg_cbks, sizeof(SaNtfCallbacksT));
/** Associate with the client_id obtained from NTFS
**/
rec->ntfs_client_id = client_id;
/** Initialize and attach the IPC/Priority queue
**/
if (m_NCS_IPC_CREATE(&rec->mbx) != NCSCC_RC_SUCCESS) {
TRACE("m_NCS_IPC_CREATE failed");
goto err_destroy_hdl;
}
if (m_NCS_IPC_ATTACH(&rec->mbx) != NCSCC_RC_SUCCESS) {
TRACE("m_NCS_IPC_ATTACH failed");
goto err_ipc_release;
}
/** Add this to the Link List of
** CLIENT_HDL_RECORDS for this NTFA_CB
**/
pthread_mutex_lock(&cb->cb_lock);
/* add this to the start of the list */
rec->next = cb->client_list;
cb->client_list = rec;
pthread_mutex_unlock(&cb->cb_lock);
goto done;
err_ipc_release:
(void)m_NCS_IPC_RELEASE(&rec->mbx, NULL);
err_destroy_hdl:
ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, rec->local_hdl);
err_free:
free(rec);
rec = NULL;
done:
return rec;
}
/****************************************************************************
Name : eda_hdl_rec_add
Description : This routine adds the handle record to the eda cb.
Arguments : cb - ptr tot he EDA control block
reg_cbks - ptr to the set of registered callbacks
reg_id - obtained from EDS.
version - version of the client.
Return Values : ptr to the eda handle record
Notes : None
******************************************************************************/
EDA_CLIENT_HDL_REC *eda_hdl_rec_add(EDA_CB **eda_cb, const SaEvtCallbacksT *reg_cbks, uns32 reg_id, SaVersionT version)
{
EDA_CLIENT_HDL_REC *rec = 0;
/* allocate the hdl rec */
if (NULL == (rec = m_MMGR_ALLOC_EDA_CLIENT_HDL_REC)) {
m_LOG_EDSV_A(EDA_MEMALLOC_FAILED, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
goto error;
}
memset(rec, '\0', sizeof(EDA_CLIENT_HDL_REC));
/* create the association with hdl-mngr */
if (0 == (rec->local_hdl = ncshm_create_hdl((*eda_cb)->pool_id, NCS_SERVICE_ID_EDA, (NCSCONTEXT)rec))) {
m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
goto error;
}
/* store the registered callbacks */
if (reg_cbks)
memcpy((void *)&rec->reg_cbk, (void *)reg_cbks, sizeof(SaEvtCallbacksT));
/** Associate with the reg_id obtained from EDS
**/
rec->eds_reg_id = reg_id;
rec->version.releaseCode = version.releaseCode;
rec->version.majorVersion = version.majorVersion;
rec->version.minorVersion = version.minorVersion;
/** Initialize and attach the IPC/Priority queue
**/
if (m_NCS_IPC_CREATE(&rec->mbx) != NCSCC_RC_SUCCESS) {
m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
goto error;
}
if (m_NCS_IPC_ATTACH(&rec->mbx) != NCSCC_RC_SUCCESS) {
m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
goto error;
}
/** Add this to the Link List of
** CLIENT_HDL_RECORDS for this EDA_CB
**/
m_NCS_LOCK(&((*eda_cb)->cb_lock), NCS_LOCK_WRITE);
/* add this to the start of the list */
rec->next = (*eda_cb)->eda_init_rec_list;
(*eda_cb)->eda_init_rec_list = rec;
m_NCS_UNLOCK(&((*eda_cb)->cb_lock), NCS_LOCK_WRITE);
return rec;
error:
if (rec) {
/* remove the association with hdl-mngr */
if (rec->local_hdl)
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, rec->local_hdl);
/** detach and release the IPC
**/
m_NCS_IPC_DETACH(&rec->mbx, eda_clear_mbx, NULL);
m_NCS_IPC_RELEASE(&rec->mbx, NULL);
m_MMGR_FREE_EDA_CLIENT_HDL_REC(rec);
}
return NULL;
}
/****************************************************************************
* Name : eds_se_lib_init
*
* Description : Invoked to Initialize the EDS
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
static uint32_t eds_se_lib_init(NCS_LIB_REQ_INFO *req_info)
{
EDS_CB *eds_cb;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* Allocate and initialize the control block */
if (NULL == (eds_cb = m_MMGR_ALLOC_EDS_CB)) {
LOG_CR("malloc failed for control block");
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
memset(eds_cb, '\0', sizeof(EDS_CB));
/* Obtain the hdl for EDS_CB from hdl-mgr */
gl_eds_hdl = eds_cb->my_hdl = ncshm_create_hdl(1, NCS_SERVICE_ID_EDS, (NCSCONTEXT)eds_cb);
if (0 == eds_cb->my_hdl) {
LOG_ER("Handle create failed for global eds handle");
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
m_MMGR_FREE_EDS_CB(eds_cb);
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
/* initialize the eds cb lock */
m_NCS_LOCK_INIT(&eds_cb->cb_lock);
/* Initialize eds control block */
if (NCSCC_RC_SUCCESS != (rc = eds_cb_init(eds_cb))) {
/* Destroy the hdl for this CB */
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
/* clean up the CB */
m_MMGR_FREE_EDS_CB(eds_cb);
/* log the error */
TRACE_4("EDS control block init failed");
TRACE_LEAVE();
return rc;
}
m_NCS_EDU_HDL_INIT(&eds_cb->edu_hdl);
/* Create the mbx to communicate with the EDS thread */
if (NCSCC_RC_SUCCESS != (rc = m_NCS_IPC_CREATE(&eds_cb->mbx))) {
LOG_ER("EDS IPC mailbox create failed");
/* Release EDU handle */
m_NCS_EDU_HDL_FLUSH(&eds_cb->edu_hdl);
/* Destroy the hdl for this CB */
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
/* Free the control block */
m_MMGR_FREE_EDS_CB(eds_cb);
TRACE_LEAVE();
return rc;
}
/* Attach the IPC to the created thread */
m_NCS_IPC_ATTACH(&eds_cb->mbx);
/* Bind to MDS */
if (NCSCC_RC_SUCCESS != (rc = eds_mds_init(eds_cb))) {
TRACE_4("eds mds init failed");
m_NCS_IPC_RELEASE(&eds_cb->mbx, NULL);
/* Release EDU handle */
m_NCS_EDU_HDL_FLUSH(&eds_cb->edu_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
m_MMGR_FREE_EDS_CB(eds_cb);
TRACE_LEAVE();
return rc;
}
/* Initialize and Register with CLM */
rc = eds_clm_init(eds_cb);
if (rc != SA_AIS_OK) {
TRACE_4("CLM Init failed. Exiting");
exit(EXIT_FAILURE);
}
/* Initialize and Register with AMF */
rc = eds_amf_register(eds_cb);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("AMF Init failed: Exiting.");
exit(EXIT_FAILURE);
}
/* Initialize mbcsv interface */
if (NCSCC_RC_SUCCESS != (rc = eds_mbcsv_init(eds_cb))) {
LOG_ER("eds mbcsv init failed");
/* Log it */
}
TRACE("eds init done.");
TRACE_LEAVE();
return (rc);
}
/****************************************************************************
* Name : glnd_cb_create
*
* Description : This will create the CB and create the internal structures
*
* Arguments : pool id - pool id for the handle manager
*
* Return Values : GLND CB Pointer
*
* Notes : None.
*****************************************************************************/
GLND_CB *glnd_cb_create(uns32 pool_id)
{
GLND_CB *glnd_cb = NULL;
NCS_PATRICIA_PARAMS params = { 0 };
SaAmfHealthcheckKeyT healthy;
int8 *health_key = NULL;
SaAisErrorT amf_error;
/* register with the Log service */
glnd_flx_log_reg();
/* allocate the memory */
glnd_cb = m_MMGR_ALLOC_GLND_CB;
if (!glnd_cb) {
m_LOG_GLND_MEMFAIL(GLND_CB_ALLOC_FAILED, __FILE__, __LINE__);
glnd_flx_log_dereg();
return NULL;
}
memset(glnd_cb, 0, sizeof(GLND_CB));
glnd_cb->pool_id = pool_id;
/* create the handle */
glnd_cb->cb_hdl_id = ncshm_create_hdl((uns8)pool_id, NCS_SERVICE_ID_GLND, (NCSCONTEXT)glnd_cb);
if (!glnd_cb->cb_hdl_id) {
m_LOG_GLND_HEADLINE(GLND_CB_TAKE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto hdl_err;
}
/* create the internal strucutures */
/* create the client Tree */
params.key_size = sizeof(SaLckHandleT);
params.info_size = 0;
if ((ncs_patricia_tree_init(&glnd_cb->glnd_client_tree, ¶ms)) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_CLIENT_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto client_err;
}
/* create the agent tree */
params.key_size = sizeof(MDS_DEST);
params.info_size = 0;
if ((ncs_patricia_tree_init(&glnd_cb->glnd_agent_tree, ¶ms)) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_AGENT_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto agent_err;
}
/* create the Resource tree */
params.key_size = sizeof(SaLckResourceIdT);
params.info_size = 0;
if ((ncs_patricia_tree_init(&glnd_cb->glnd_res_tree, ¶ms)) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_RSC_TREE_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto res_err;
}
/* create the mail box and attach it */
if (m_NCS_IPC_CREATE(&glnd_cb->glnd_mbx) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_IPC_CREATE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto mbx_create_err;
}
if (m_NCS_IPC_ATTACH(&glnd_cb->glnd_mbx) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_IPC_ATTACH_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto mbx_attach_err;
}
/* EDU initialisation */
m_NCS_EDU_HDL_INIT(&glnd_cb->glnd_edu_hdl);
/* resigter with the MDS */
if (glnd_mds_register(glnd_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_MDS_REGISTER_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto mds_err;
} else
m_LOG_GLND_HEADLINE(GLND_MDS_REGISTER_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
/* Initialise with the AMF service */
if (glnd_amf_init(glnd_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_AMF_INIT_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto amf_init_err;
} else
m_LOG_GLND_HEADLINE(GLND_AMF_INIT_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
/* register with the AMF service */
if (glnd_amf_register(glnd_cb) != NCSCC_RC_SUCCESS) {
m_LOG_GLND_HEADLINE(GLND_AMF_REGISTER_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
goto amf_reg_err;
} else
m_LOG_GLND_HEADLINE(GLND_AMF_REGISTER_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
/* everything went off well.. store the hdl in the global variable */
gl_glnd_hdl = glnd_cb->cb_hdl_id;
/* start the AMF Health Check */
memset(&healthy, 0, sizeof(healthy));
health_key = (int8 *)getenv("GLSV_ENV_HEALTHCHECK_KEY");
if (health_key == NULL) {
if (strlen("A1B2") < sizeof(healthy.key))
strncpy((char *)healthy.key, "A1B2", sizeof(healthy.key));
/* TBD Log the info */
} else {
if (strlen((char *)health_key) <= sizeof(healthy.key))
strncpy((char *)healthy.key, (char *)health_key, SA_AMF_HEALTHCHECK_KEY_MAX - 1);
}
healthy.keyLen = strlen((char *)healthy.key);
amf_error = saAmfHealthcheckStart(glnd_cb->amf_hdl, &glnd_cb->comp_name, &healthy,
SA_AMF_HEALTHCHECK_AMF_INVOKED, SA_AMF_COMPONENT_RESTART);
if (amf_error != SA_AIS_OK) {
m_LOG_GLND_HEADLINE(GLND_AMF_HEALTHCHECK_START_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__);
} else
m_LOG_GLND_HEADLINE(GLND_AMF_HEALTHCHECK_START_SUCCESS, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
if (glnd_cb->node_state != GLND_CLIENT_INFO_GET_STATE) {
TRACE("setting the state as GLND_OPERATIONAL_STATE");
/* GLND HAS STRTED */
glnd_cb->node_state = GLND_OPERATIONAL_STATE;
}
/*create a shared memory segment to Checkpint Resource info, lck_info & backup_event info */
if (glnd_shm_create(glnd_cb) != NCSCC_RC_SUCCESS)
goto glnd_shm_create_fail;
return glnd_cb;
glnd_shm_create_fail:
glnd_amf_deregister(glnd_cb);
amf_reg_err:
glnd_amf_de_init(glnd_cb);
amf_init_err:
glnd_mds_unregister(glnd_cb);
mds_err:
m_NCS_EDU_HDL_FLUSH(&glnd_cb->glnd_edu_hdl);
m_NCS_IPC_DETACH(&glnd_cb->glnd_mbx, glnd_cleanup_mbx, glnd_cb);
mbx_attach_err:
m_NCS_IPC_RELEASE(&glnd_cb->glnd_mbx, NULL);
mbx_create_err:
ncs_patricia_tree_destroy(&glnd_cb->glnd_res_tree);
res_err:
ncs_patricia_tree_destroy(&glnd_cb->glnd_agent_tree);
agent_err:
ncs_patricia_tree_destroy(&glnd_cb->glnd_client_tree);
client_err:
ncshm_destroy_hdl(NCS_SERVICE_ID_GLND, glnd_cb->cb_hdl_id);
hdl_err:
glnd_flx_log_dereg();
/* free the control block */
m_MMGR_FREE_GLND_CB(glnd_cb);
return NULL;
}
/****************************************************************************
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;
}
