/****************************************************************************
Name : ntfa_hdl_rec_del
Description : This routine deletes the a client handle record from
a list of client hdl records.
Arguments : NTFA_CLIENT_HDL_REC **list_head
NTFA_CLIENT_HDL_REC *rm_node
Return Values : None
Notes : The selection object is destroyed after all the means to
access the handle record (ie. hdl db tree or hdl mngr) is
removed. This is to disallow the waiting thread to access
the hdl rec while other thread executes saAmfFinalize on it.
******************************************************************************/
uns32 ntfa_hdl_rec_del(ntfa_client_hdl_rec_t **list_head, ntfa_client_hdl_rec_t *rm_node)
{
uns32 rc = NCSCC_RC_FAILURE;
ntfa_client_hdl_rec_t *list_iter = *list_head;
TRACE_ENTER();
/* TODO: free all resources allocated by the client */
/* If the to be removed record is the first record */
if (list_iter == rm_node) {
*list_head = rm_node->next;
/** detach & release the IPC
**/
m_NCS_IPC_DETACH(&rm_node->mbx, ntfa_clear_mbx, NULL);
m_NCS_IPC_RELEASE(&rm_node->mbx, NULL);
ncshm_give_hdl(rm_node->local_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, rm_node->local_hdl);
/** Free the channel records off this hdl
**/
ntfa_notification_hdl_rec_list_del(&rm_node->notification_list);
/** free the hdl rec
**/
free(rm_node);
rc = NCSCC_RC_SUCCESS;
goto out;
} else { /* find the rec */
while (NULL != list_iter) {
if (list_iter->next == rm_node) {
list_iter->next = rm_node->next;
/** detach & release the IPC */
m_NCS_IPC_DETACH(&rm_node->mbx, ntfa_clear_mbx, NULL);
m_NCS_IPC_RELEASE(&rm_node->mbx, NULL);
ncshm_give_hdl(rm_node->local_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_NTFA, rm_node->local_hdl);
/** Free the channel records off this ntfa_hdl */
ntfa_notification_hdl_rec_list_del(&rm_node->notification_list);
/** free the hdl rec */
free(rm_node);
rc = NCSCC_RC_SUCCESS;
goto out;
}
/* move onto the next one */
list_iter = list_iter->next;
}
}
TRACE("failed");
out:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : eda_hdl_rec_del
Description : This routine deletes the a client handle record from
a list of client hdl records.
Arguments : EDA_CLIENT_HDL_REC **list_head
EDA_CLIENT_HDL_REC *rm_node
Return Values : None
Notes : The selection object is destroyed after all the means to
access the handle record (ie. hdl db tree or hdl mngr) is
removed. This is to disallow the waiting thread to access
the hdl rec while other thread executes saAmfFinalize on it.
******************************************************************************/
uns32 eda_hdl_rec_del(EDA_CLIENT_HDL_REC **list_head, EDA_CLIENT_HDL_REC *rm_node)
{
/* Find the client hdl record in the list of records */
EDA_CLIENT_HDL_REC *list_iter = *list_head;
/* If the to be removed record is the first record */
if (list_iter == rm_node) {
*list_head = rm_node->next;
/** detach & release the IPC
**/
m_NCS_IPC_DETACH(&rm_node->mbx, eda_clear_mbx, NULL);
m_NCS_IPC_RELEASE(&rm_node->mbx, NULL);
ncshm_give_hdl(rm_node->local_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, rm_node->local_hdl);
/** Free the channel records off this hdl
**/
eda_channel_hdl_rec_list_del(&rm_node->chan_list);
/** free the hdl rec
**/
m_MMGR_FREE_EDA_CLIENT_HDL_REC(rm_node);
return NCSCC_RC_SUCCESS;
} else { /* find the rec */
while (NULL != list_iter) {
if (list_iter->next == rm_node) {
list_iter->next = rm_node->next;
/** detach & release the IPC
**/
m_NCS_IPC_DETACH(&rm_node->mbx, eda_clear_mbx, NULL);
m_NCS_IPC_RELEASE(&rm_node->mbx, NULL);
ncshm_give_hdl(rm_node->local_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, rm_node->local_hdl);
/** Free the channel records off this eda_hdl
**/
eda_channel_hdl_rec_list_del(&rm_node->chan_list);
/** free the hdl rec
**/
m_MMGR_FREE_EDA_CLIENT_HDL_REC(rm_node);
return NCSCC_RC_SUCCESS;
}
/* move onto the next one */
list_iter = list_iter->next;
}
}
m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
return NCSCC_RC_FAILURE;
}
/****************************************************************************
* Name : dts_lib_destroy
*
* Description : This is the function which destroy's the DTS lib.
* This function releases the Task and the IPX mail Box.
*
* Arguments : None.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
uns32 dts_lib_destroy(void)
{
/*#if (DTS_SIM_TEST_ENV == 1)
if (dts_cb.amf_init == FALSE)
{*/
DTS_LM_ARG arg;
/* Destroy the DTS CB */
arg.i_op = DTS_LM_OP_DESTROY;
arg.info.destroy.i_meaningless = (void *)0x1234;
if (dts_lm(&arg) != NCSCC_RC_SUCCESS) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_destroy: Failed to destroy DTS CB");
}
/*}
#endif */
m_NCS_TASK_STOP(dts_cb.task_handle);
m_NCS_TASK_RELEASE(dts_cb.task_handle);
m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, &dts_cb);
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
return NCSCC_RC_SUCCESS;
}
/***********************************************************************
* Name : plms_hrb_finalize
*
* Description : This function un-registers with MDS, detaches mailbox
* and terminates the HRB thread
*
* Arguments :
*
* Return Values :NCSCC_RC_SUCCESS
* NCSCC_RC_FAILURE
*
* Notes : None.
***********************************************************************/
SaUint32T plms_hrb_finalize()
{
PLMS_HRB_CB *cb = hrb_cb;
SaUint32T rc;
/* detach the mail box */
if ((rc = m_NCS_IPC_DETACH(&cb->mbx, hrb_cleanup_mbx, NULL))
!= NCSCC_RC_SUCCESS)
LOG_ER("m_NCS_IPC_DETACH failed with error:%d",rc);
/* delete the mailbox */
if ((rc = m_NCS_IPC_RELEASE(&cb->mbx, NULL)) != NCSCC_RC_SUCCESS)
LOG_ER("HRB:m_NCS_IPC_DETACH failed with error:%d",rc);
/* derigister with the MDS */
if ((rc = hrb_mds_finalize()) != NCSCC_RC_SUCCESS)
LOG_ER("hrb_mds_finalize failed with error:%d",rc);
/* Kill the HRB thread */
pthread_cancel(cb->thread_id);
TRACE("exiing plms_hrb_finalize with ret value:%d",rc);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : ava_hdl_rec_del
Description : This routine deletes the handle record.
Arguments : cb - ptr tot he AvA control block
hdl_db - ptr to the hdl db
hdl_rec - ptr to the hdl record
Return Values : None
Notes : The selection object is destroyed after all the means to
access the handle record (ie. hdl db tree or hdl mngr) is
removed. This is to disallow the waiting thread to access
the hdl rec while other thread executes saAmfFinalize on it.
******************************************************************************/
void ava_hdl_rec_del(AVA_CB *cb, AVA_HDL_DB *hdl_db, AVA_HDL_REC **_hdl_rec)
{
AVA_HDL_REC *hdl_rec = *_hdl_rec;
uint32_t hdl = hdl_rec->hdl;
TRACE_ENTER();
/* pop the hdl rec */
ncs_patricia_tree_del(&hdl_db->hdl_db_anchor, &hdl_rec->hdl_node);
/* detach the mail box */
m_NCS_IPC_DETACH(&hdl_rec->callbk_mbx, ava_hdl_cbk_ipc_mbx_del, hdl_rec);
/* delete the mailbox */
m_NCS_IPC_RELEASE(&hdl_rec->callbk_mbx, NULL);
/* clean the pend resp list */
ava_hdl_pend_resp_list_del(cb, &hdl_rec->pend_resp);
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_AVA, hdl_rec->hdl);
/* free the hdl rec */
free(hdl_rec);
*_hdl_rec = NULL;
/* update the no of records */
hdl_db->num--;
TRACE_LEAVE2("Handle = %x, successfully deleted from Handle DB, num handles = %d",hdl, hdl_db->num);
return;
}
/****************************************************************************
* 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 : glsv_gla_callback_queue_destroy
Description : This routine is used to destroy the queue for the callbacks.
Arguments : client_info - pointer to the client info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
void glsv_gla_callback_queue_destroy(GLA_CLIENT_INFO *client_info)
{
/* detach the mail box */
m_NCS_IPC_DETACH(&client_info->callbk_mbx, gla_client_cleanup_mbx, client_info);
/* delete the mailbox */
m_NCS_IPC_RELEASE(&client_info->callbk_mbx, NULL);
}
/***************************************************************************
@brief : saSmfFinalize
@param[in] : smfHandle - Handle returned by successful intialize.
@return : SA_AIS_OK if successful otherwise appropiate err code.
*****************************************************************************/
SaAisErrorT saSmfFinalize(SaSmfHandleT smfHandle)
{
SMFA_CB *cb = &_smfa_cb;
SMFA_CLIENT_INFO *client_info;
TRACE_ENTER2("Handle: %llu",smfHandle);
if (cb->is_finalized){
LOG_ER("SMFA: Already finalized. Bad handle %llu.",smfHandle);
TRACE_LEAVE();
return SA_AIS_ERR_BAD_HANDLE;
}
if (NCSCC_RC_SUCCESS != m_NCS_LOCK(&cb->cb_lock,NCS_LOCK_WRITE)){
LOG_ER("SMFA: Cb lock acquire FAILED.");
TRACE_LEAVE();
return SA_AIS_ERR_NO_RESOURCES;
}
/* Get the client info structure for the handle.*/
client_info = smfa_client_info_get(smfHandle);
if (NULL == client_info){
LOG_ER("SMFA: Could not retrieve client info, Bad handle %llu.",smfHandle);
m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);
TRACE_LEAVE();
return SA_AIS_ERR_BAD_HANDLE;
}
/* Free all the scope info registered for this client.*/
smfa_client_info_clean(client_info);
/* Release the MBX.*/
m_NCS_IPC_DETACH(&client_info->cbk_mbx,smfa_client_mbx_clnup,client_info);
m_NCS_IPC_RELEASE(&client_info->cbk_mbx,NULL);
/* Clear the list cb->cbk_list for this handle.*/
smfa_cbk_list_cleanup(smfHandle);
/* Remove the client from the cb.*/
smfa_client_info_rmv(client_info->client_hdl);
m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);
/* If last client, then destroy the agent CB.*/
if (NCSCC_RC_SUCCESS != smfa_finalize()){
TRACE_LEAVE();
return SA_AIS_ERR_LIBRARY;
}
TRACE_LEAVE();
return SA_AIS_OK;
}
/****************************************************************************
* Name : amf_comp_terminate_callback
*
* Description : This is the callback function which will be called
* when the AMF framework needs to terminate LGS. This does
* all required to destroy LGS(except to unregister from AMF)
*
* Arguments : invocation - This parameter designated a particular
* invocation of this callback function. The
* invoke process return invocation when it
* responds to the Availability Management
* FrameWork using the saAmfResponse()
* function.
* compName - A pointer to the name of the component
* whose readiness state the Availability
* Management Framework is setting.
*
* Return Values : None
*
* Notes : None
*****************************************************************************/
static void amf_comp_terminate_callback(SaInvocationT invocation, const SaNameT *compName)
{
TRACE_ENTER();
saAmfResponse(lgs_cb->amf_hdl, invocation, SA_AIS_OK);
/* Detach from IPC */
m_NCS_IPC_DETACH(&lgs_mbx, NULL, lgs_cb);
/* Disconnect from MDS */
lgs_mds_finalize(lgs_cb);
sleep(1);
LOG_NO("Received AMF component terminate callback, exiting");
exit(0);
}
/****************************************************************************
* Name : glnd_cb_destroy
*
* Description : Destroy the CB
*
* Arguments : glnd_cb - GLND control block pointer.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
uns32 glnd_cb_destroy(GLND_CB *glnd_cb)
{
GLND_AGENT_INFO *agent_info;
/* destroy the handle */
if (glnd_cb->cb_hdl_id) {
m_GLND_GIVEUP_GLND_CB;
ncshm_destroy_hdl(NCS_SERVICE_ID_GLND, glnd_cb->cb_hdl_id);
}
/* detach the mail box */
if (m_NCS_IPC_DETACH(&glnd_cb->glnd_mbx, glnd_cleanup_mbx, glnd_cb) != NCSCC_RC_SUCCESS)
return NCSCC_RC_FAILURE;
/* delete the mailbox */
if (m_NCS_IPC_RELEASE(&glnd_cb->glnd_mbx, NULL) != NCSCC_RC_SUCCESS)
return NCSCC_RC_FAILURE;
/* delete all the internal structures */
/* delete the trees */
for (agent_info = (GLND_AGENT_INFO *)ncs_patricia_tree_getnext(&glnd_cb->glnd_agent_tree, (uns8 *)0);
agent_info != NULL;
agent_info = (GLND_AGENT_INFO *)ncs_patricia_tree_getnext(&glnd_cb->glnd_agent_tree, (uns8 *)0)) {
glnd_agent_node_del(glnd_cb, agent_info);
}
ncs_patricia_tree_destroy(&glnd_cb->glnd_agent_tree);
ncs_patricia_tree_destroy(&glnd_cb->glnd_client_tree);
ncs_patricia_tree_destroy(&glnd_cb->glnd_res_tree);
/* deresigter with the MDS */
glnd_mds_unregister(glnd_cb);
/* EDU cleanup */
m_NCS_EDU_HDL_FLUSH(&glnd_cb->glnd_edu_hdl);
/* free the control block */
m_MMGR_FREE_GLND_CB(glnd_cb);
/* deregister with the log service */
glnd_flx_log_dereg();
/* reset the global cb handle */
gl_glnd_hdl = 0;
return (NCSCC_RC_SUCCESS);
}
/****************************************************************************
* Name : amf_comp_terminate_callback
*
* Description : This is the callback function which will be called
* when the AMF framework nentfs to terminate NTFS. This does
* all required to destroy NTFS(except to unregister from AMF)
*
* Arguments : invocation - This parameter designated a particular
* invocation of this callback function. The
* invoke process return invocation when it
* responds to the Avilability Management
* FrameWork using the saAmfResponse()
* function.
* compName - A pointer to the name of the component
* whose readiness stae the Availability
* Management Framework is setting.
*
* Return Values : None
*
* Notes : None
*****************************************************************************/
static void amf_comp_terminate_callback(SaInvocationT invocation, const SaNameT *compName)
{
SaAisErrorT rc=SA_AIS_OK;
TRACE_ENTER();
/* Stop imcnp (configuration notifier) */
if (stop_ntfimcn() != 0) {
rc = SA_AIS_ERR_FAILED_OPERATION;
LOG_ER("stop_ntfimcn() Fail");
}
saAmfResponse(ntfs_cb->amf_hdl, invocation, rc);
/* Detach from IPC */
m_NCS_IPC_DETACH(&ntfs_cb->mbx, NULL, ntfs_cb);
/* Disconnect from MDS */
ntfs_mds_finalize(ntfs_cb);
sleep(1);
LOG_ER("Received AMF component terminate callback, exiting");
exit(0);
}
/****************************************************************************
Name : avnd_mbx_destroy
Description : This routine destroys & detaches AvND mailbox.
Arguments : cb - ptr to AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 avnd_mbx_destroy(AVND_CB *cb)
{
uns32 rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* detach the mail box */
rc = m_NCS_IPC_DETACH(&cb->mbx, avnd_mbx_clean, cb);
if (NCSCC_RC_SUCCESS != rc) {
LOG_ER("Mailbox detatch failed");
goto done;
}
/* delete the mail box */
rc = m_NCS_IPC_RELEASE(&cb->mbx, 0);
if (NCSCC_RC_SUCCESS != rc) {
LOG_ER("Mailbox delete failed");
goto done;
}
done:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
* Name : plms_amf_comp_terminate_callback
*
* Description : This is the callback function which will be called
* when the AMF framework needs to terminate PLMS. This does
* all required operations to destroy PLMS(except to
* unregister from AMF)
*
* Arguments : invocation - This parameter designated a particular
* invocation of this callback function. The
* invoke process return invocation when it
* responds to the Avilability Management
* FrameWork using the saAmfResponse()
* function.
* compName - A pointer to the name of the component
* whose readiness stae the Availability
* Management Framework is setting.
*
* Return Values : None
*
* Notes : At present we are just support a simple liveness check.
*****************************************************************************/
void plms_amf_comp_terminate_callback(SaInvocationT invocation, const SaNameT
*compName)
{
PLMS_CB *cb = plms_cb;
SaAisErrorT error = SA_AIS_OK;
TRACE_ENTER();
m_NCS_LOCK(&cb->cb_lock,NCS_LOCK_WRITE);
saAmfResponse(cb->amf_hdl, invocation, error);
/* FIXME : Clean up all internal structures */
/* Detach from IPC */
m_NCS_IPC_DETACH(&cb->mbx, NULL, cb);
/* Disconnect from MDS */
plms_mds_unregister();
m_NCS_UNLOCK(&cb->cb_lock,NCS_LOCK_WRITE);
/* Destroy the cb */
sleep(1);
LOG_NO("Received AMF component terminate callback, exiting");
exit(0);
}
/****************************************************************************
* Name : gld_se_lib_destroy
*
* Description : Invoked to destroy the GLD
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
uns32 gld_se_lib_destroy(NCS_LIB_REQ_INFO *req_info)
{
GLSV_GLD_CB *gld_cb;
if ((gld_cb = (NCSCONTEXT)ncshm_take_hdl(NCS_SERVICE_ID_GLD, gl_gld_hdl))
== NULL) {
m_LOG_GLD_HEADLINE(GLD_TAKE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
return (NCSCC_RC_FAILURE);
} else {
/* Disconnect from MDS */
gld_mds_shut(gld_cb);
saAmfComponentUnregister(gld_cb->amf_hdl, &gld_cb->comp_name, (SaNameT *)NULL);
saAmfFinalize(gld_cb->amf_hdl);
ncshm_give_hdl(gl_gld_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_GLD, gl_gld_hdl);
m_NCS_IPC_DETACH(&gld_cb->mbx, gld_clear_mbx, gld_cb);
gld_cb_destroy(gld_cb);
m_MMGR_FREE_GLSV_GLD_CB(gld_cb);
}
return (NCSCC_RC_SUCCESS);
}
/****************************************************************************
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;
}
/***************************************************************************
@brief : saSmfInitialize. Even if no cbk is registered, we create
MBX for the client as we have to return the sel obj later.
@param[out] : smfHandle - Will have a valid handle if initialization is
successful.
@param[in] : smfCallbacks - Cbks to be registered.
@param[in] : version - Supported smf-api version.
@return : SA_AIS_OK if successful otherwise appropiate err code.
*****************************************************************************/
SaAisErrorT saSmfInitialize(SaSmfHandleT *smfHandle,
const SaSmfCallbacksT *smfCallbacks,
SaVersionT *version)
{
SMFA_CB *cb = &_smfa_cb;
SMFA_CLIENT_INFO *client_info;
SaAisErrorT rc = SA_AIS_OK;
TRACE_ENTER();
if (!smfHandle || !version){
LOG_ER("SMFA: smfHandle or version is NULL.");
return SA_AIS_ERR_INVALID_PARAM;
}
if (!m_SMFA_VERSION_VALIDATE(version)){
LOG_ER("SMFA: Unsupported version. ReleaseCode: %c, MajorVersion: %x",
version->releaseCode,version->majorVersion);
version->releaseCode = SMF_RELEASE_CODE;
version->majorVersion = SMF_MAJOR_VERSION;
version->minorVersion = SMF_MINOR_VERSION;
TRACE_LEAVE();
return SA_AIS_ERR_VERSION;
}
version->minorVersion = SMF_MINOR_VERSION;
if (NCSCC_RC_SUCCESS != smfa_init()){
LOG_ER("smfa_init() FAILED.");
ncs_agents_shutdown();
TRACE_LEAVE();
return SA_AIS_ERR_LIBRARY;
}
client_info = (SMFA_CLIENT_INFO *)calloc(1,sizeof(SMFA_CLIENT_INFO));
if (NULL == client_info){
LOG_ER("SMFA client info: calloc FAILED, error: %s",strerror(errno));
rc = SA_AIS_ERR_NO_MEMORY;
goto smfa_init_failed;
}
/* Fill the handle.*/
if ( MAX_SMFA_HDL <= smfa_hdl){
smfa_hdl = 0;
}
smfa_hdl++;
client_info->client_hdl = smfa_hdl;
/* Fill the callback info. */
if (NULL != smfCallbacks)
client_info->reg_cbk = *smfCallbacks;
else
TRACE_2("SMFA: No cbk registered.");
/* Create MBX for this client.*/
if (NCSCC_RC_SUCCESS != m_NCS_IPC_CREATE(&client_info->cbk_mbx)){
LOG_ER("SMFA: MBX create FAILED.");
rc = SA_AIS_ERR_LIBRARY;
goto smfa_mbx_create_failed;
}else {
if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&client_info->cbk_mbx)){
LOG_ER("SMFA: MBX attach FAILED.");
rc = SA_AIS_ERR_LIBRARY;
goto smfa_mbx_attach_failed;
}
}
/* Add the client info to the database. */
if (NCSCC_RC_SUCCESS != m_NCS_LOCK(&cb->cb_lock,NCS_LOCK_WRITE)){
LOG_ER("SMFA: Cb lock acquire FAILED.");
rc = SA_AIS_ERR_NO_RESOURCES;
goto smfa_take_lock_failed;
}
smfa_client_info_add(client_info);
m_NCS_UNLOCK(&cb->cb_lock,NCS_LOCK_WRITE);
/* Initialization is successful. Pass the handle to the application.*/
*smfHandle = client_info->client_hdl;
TRACE_2("SMFA: Handle returned: %llu.",*smfHandle);
TRACE_LEAVE();
return SA_AIS_OK;
smfa_take_lock_failed:
m_NCS_IPC_DETACH(&client_info->cbk_mbx,smfa_client_mbx_clnup,client_info);
smfa_mbx_attach_failed:
m_NCS_IPC_RELEASE(&client_info->cbk_mbx,NULL);
smfa_mbx_create_failed:
if (client_info){
free(client_info);
client_info = NULL;
}
smfa_init_failed:
smfa_finalize();
TRACE_LEAVE();
return rc;
}
/*****************************************************************************
PROCEDURE NAME: main
DESCRIPTION: Main routine for FM
*****************************************************************************/
int main(int argc, char *argv[])
{
NCS_SEL_OBJ mbx_sel_obj, pipe_sel_obj, highest_sel_obj;
NCS_SEL_OBJ amf_sel_obj = {0, 0};
NCS_SEL_OBJ_SET sel_obj_set;
FM_EVT *fm_mbx_evt = NULL;
daemonize(argc, argv);
if (fm_agents_startup() != NCSCC_RC_SUCCESS) {
/* notify the NID */
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_agents_startup_failed;
}
/* Allocate memory for FM_CB. */
fm_cb = m_MMGR_ALLOC_FM_CB;
if (NULL == fm_cb) {
/* notify the NID */
syslog(LOG_ERR, "CB Allocation failed.");
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_agents_startup_failed;
}
memset(fm_cb, 0, sizeof(FM_CB));
/* Create CB handle */
gl_fm_hdl = ncshm_create_hdl(NCS_HM_POOL_ID_COMMON, NCS_SERVICE_ID_GFM, (NCSCONTEXT)fm_cb);
/* Take CB handle */
ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl);
if (fm_get_args(fm_cb) != NCSCC_RC_SUCCESS) {
/* notify the NID */
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_get_args_failed;
}
/* Create MBX. */
if (m_NCS_IPC_CREATE(&fm_cb->mbx) != NCSCC_RC_SUCCESS) {
syslog(LOG_ERR, "m_NCS_IPC_CREATE() failed.");
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_get_args_failed;
}
/* Attach MBX */
if (m_NCS_IPC_ATTACH(&fm_cb->mbx) != NCSCC_RC_SUCCESS) {
syslog(LOG_ERR, "m_NCS_IPC_ATTACH() failed.");
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_mbx_attach_failure;
}
/* MDS initialization */
if (fm_mds_init(fm_cb) != NCSCC_RC_SUCCESS) {
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_mds_init_failed;
}
/* RDA initialization */
if (fm_rda_init(fm_cb) != NCSCC_RC_SUCCESS) {
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_rda_init_failed;
}
/* Open FM pipe for receiving AMF up intimation */
if (fm_amf_open(&fm_cb->fm_amf_cb) != NCSCC_RC_SUCCESS) {
fm_nid_notify((uns32)NCSCC_RC_FAILURE);
goto fm_hpl_lib_init_failed;
}
/* Get mailbox selection object */
mbx_sel_obj = m_NCS_IPC_GET_SEL_OBJ(&fm_cb->mbx);
/* Get pipe selection object */
m_SET_FD_IN_SEL_OBJ(fm_cb->fm_amf_cb.pipe_fd, pipe_sel_obj);
/* Give CB hdl */
ncshm_give_hdl(gl_fm_hdl);
/* notify the NID */
fm_nid_notify(NCSCC_RC_SUCCESS);
/* clear selection object set */
m_NCS_SEL_OBJ_ZERO(&sel_obj_set);
/* Set only one pipe eelection object in set */
m_NCS_SEL_OBJ_SET(pipe_sel_obj, &sel_obj_set);
highest_sel_obj = pipe_sel_obj;
/* Wait for pipe selection object */
if (m_NCS_SEL_OBJ_SELECT(highest_sel_obj, &sel_obj_set, NULL, NULL, NULL) != -1) {
/* following if will be true only first time */
if (m_NCS_SEL_OBJ_ISSET(pipe_sel_obj, &sel_obj_set)) {
/* Take handle */
ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl);
/* Process the message received on pipe */
if (fm_amf_pipe_process_msg(&fm_cb->fm_amf_cb) != NCSCC_RC_SUCCESS)
goto done;
/* Get amf selection object */
m_SET_FD_IN_SEL_OBJ(fm_cb->fm_amf_cb.amf_fd, amf_sel_obj);
/* Release handle */
ncshm_give_hdl(gl_fm_hdl);
}
}
/* clear selection object set */
m_NCS_SEL_OBJ_ZERO(&sel_obj_set);
m_NCS_SEL_OBJ_SET(amf_sel_obj, &sel_obj_set);
m_NCS_SEL_OBJ_SET(mbx_sel_obj, &sel_obj_set);
highest_sel_obj = m_GET_HIGHER_SEL_OBJ(amf_sel_obj, mbx_sel_obj);
/* Wait infinitely on */
while ((m_NCS_SEL_OBJ_SELECT(highest_sel_obj, &sel_obj_set, NULL, NULL, NULL) != -1)) {
if (m_NCS_SEL_OBJ_ISSET(mbx_sel_obj, &sel_obj_set)) {
/* Take handle */
ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl);
fm_mbx_evt = (FM_EVT *)m_NCS_IPC_NON_BLK_RECEIVE(&fm_cb->mbx, msg);
if (fm_mbx_evt) {
fm_mbx_msg_handler(fm_cb, fm_mbx_evt);
}
/* Release handle */
ncshm_give_hdl(gl_fm_hdl);
}
if (m_NCS_SEL_OBJ_ISSET(amf_sel_obj, &sel_obj_set)) {
/* Take handle */
ncshm_take_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl);
/* Process the message received on amf selection object */
fm_amf_process_msg(&fm_cb->fm_amf_cb);
/* Release handle */
ncshm_give_hdl(gl_fm_hdl);
}
m_NCS_SEL_OBJ_SET(amf_sel_obj, &sel_obj_set);
m_NCS_SEL_OBJ_SET(mbx_sel_obj, &sel_obj_set);
highest_sel_obj = m_GET_HIGHER_SEL_OBJ(amf_sel_obj, mbx_sel_obj);
}
fm_amf_close(&fm_cb->fm_amf_cb);
fm_hpl_lib_init_failed:
fm_rda_finalize(fm_cb);
fm_rda_init_failed:
fm_mds_finalize(fm_cb);
fm_mds_init_failed:
m_NCS_IPC_DETACH(&fm_cb->mbx, NULL, NULL);
fm_mbx_attach_failure:
m_NCS_IPC_RELEASE(&fm_cb->mbx, NULL);
fm_get_args_failed:
ncshm_destroy_hdl(NCS_SERVICE_ID_GFM, gl_fm_hdl);
gl_fm_hdl = 0;
m_MMGR_FREE_FM_CB(fm_cb);
fm_agents_startup_failed:
fm_agents_shutdown();
done:
return 1;
}
/****************************************************************************
* Name : dts_lib_init
*
* Description : This is the function which initalize the dts libarary.
* This function creates an IPC mail Box and spawns DTS
* thread.
* This function initializes the CB, handle manager and MDS.
*
* Arguments : req_info - Request info.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
uns32 dts_lib_init(NCS_LIB_REQ_INFO *req_info)
{
NCSCONTEXT task_handle;
DTS_CB *inst = &dts_cb;
PCS_RDA_REQ pcs_rda_req;
uns32 rc = NCSCC_RC_SUCCESS;
memset(inst, 0, sizeof(DTS_CB));
#if (DTS_SIM_TEST_ENV == 1)
if ('n' == ncs_util_get_char_option(req_info->info.create.argc, req_info->info.create.argv, "DTS_TEST=")) {
inst->is_test = FALSE;
} else
inst->is_test = TRUE;
#endif
/* Initialize SAF stuff */
/* Fill in the Health check key */
strcpy((char *)inst->health_chk_key.key, DTS_AMF_HEALTH_CHECK_KEY);
inst->health_chk_key.keyLen = strlen((char *)inst->health_chk_key.key);
inst->invocationType = DTS_HB_INVOCATION_TYPE;
/* Recommended recovery is to failover */
inst->recommendedRecovery = DTS_RECOVERY;
/* RDA init */
memset(&pcs_rda_req, '\0', sizeof(pcs_rda_req));
pcs_rda_req.req_type = PCS_RDA_LIB_INIT;
rc = pcs_rda_request(&pcs_rda_req);
if (rc != PCSRDA_RC_SUCCESS) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: pcs_rda_request() failed for PCS_RDA_LIB_INIT");
}
/* Get initial role from RDA */
memset(&pcs_rda_req, '\0', sizeof(pcs_rda_req));
pcs_rda_req.req_type = PCS_RDA_GET_ROLE;
rc = pcs_rda_request(&pcs_rda_req);
if (rc != PCSRDA_RC_SUCCESS) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to get initial role from RDA");
}
/* Set initial role now */
switch (pcs_rda_req.info.io_role) {
case PCS_RDA_ACTIVE:
inst->ha_state = SA_AMF_HA_ACTIVE;
m_DTS_DBG_SINK(NCSCC_RC_SUCCESS, "DTS init role is ACTIVE");
m_LOG_DTS_API(DTS_INIT_ROLE_ACTIVE);
break;
case PCS_RDA_STANDBY:
inst->ha_state = SA_AMF_HA_STANDBY;
m_DTS_DBG_SINK(NCSCC_RC_SUCCESS, "DTS init role is STANDBY");
m_LOG_DTS_API(DTS_INIT_ROLE_STANDBY);
break;
default:
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to get initial role from RDA");
}
/* RDA finalize */
memset(&pcs_rda_req, '\0', sizeof(pcs_rda_req));
pcs_rda_req.req_type = PCS_RDA_LIB_DESTROY;
rc = pcs_rda_request(&pcs_rda_req);
if (rc != PCSRDA_RC_SUCCESS) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to perform lib destroy on RDA");
}
inst->in_sync = TRUE;
/* Attempt to open console device for logging */
inst->cons_fd = -1;
if ((inst->cons_fd = dts_cons_open(O_RDWR | O_NOCTTY)) < 0) {
/* Should we return frm here on failure?? I guess NOT */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to open console");
}
/* Create DTS mailbox */
if (m_NCS_IPC_CREATE(&gl_dts_mbx) != NCSCC_RC_SUCCESS) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to create DTS mail box");
}
if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&gl_dts_mbx)) {
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: IPC attach failed.");
}
#if (DTS_FLOW == 1)
/* Keeping count of messages in DTS mailbox */
if (NCSCC_RC_SUCCESS != m_NCS_IPC_CONFIG_USR_COUNTERS(&gl_dts_mbx, NCS_IPC_PRIORITY_LOW, &inst->msg_count)) {
m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst);
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_lib_init: Failed to initialize DTS msg counters with LEAP");
}
#endif
/* Smik - initialize the signal handler */
if ((dts_app_signal_install(SIGUSR1, dts_amf_sigusr1_handler)) == -1) {
m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst);
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to install signal handler");
}
{
DTS_LM_ARG arg;
memset(&arg, 0, sizeof(DTS_LM_ARG));
arg.i_op = DTS_LM_OP_CREATE;
arg.info.create.i_hmpool_id = NCS_HM_POOL_ID_COMMON;
arg.info.create.i_vrid = 1;
arg.info.create.task_handle = task_handle;
/* Now create and initialize DTS control block */
if (dts_lm(&arg) != NCSCC_RC_SUCCESS) {
m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst);
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to create and init DTS CB");
}
}
/* Create DTS's task */
if (m_NCS_TASK_CREATE((NCS_OS_CB)dts_do_evts,
&gl_dts_mbx, NCS_DTS_TASKNAME,
NCS_DTS_PRIORITY, NCS_DTS_STACKSIZE, &task_handle) != NCSCC_RC_SUCCESS) {
m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst);
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to create DTS thread.");
}
/* Start DTS task */
if (m_NCS_TASK_START(task_handle) != NCSCC_RC_SUCCESS) {
m_NCS_TASK_RELEASE(task_handle);
m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst);
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Failed to start DTS task");
}
inst->task_handle = task_handle;
if (dts_log_bind() != NCSCC_RC_SUCCESS) {
m_DTS_LK(&inst->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &inst->lock);
/* Do cleanup activities */
m_NCS_TASK_STOP(task_handle);
m_NCS_TASK_RELEASE(task_handle);
m_NCS_IPC_DETACH(&gl_dts_mbx, dts_clear_mbx, inst);
m_NCS_IPC_RELEASE(&gl_dts_mbx, NULL);
inst->created = FALSE;
dtsv_mbcsv_deregister(inst);
dts_mds_unreg(inst, TRUE);
dtsv_clear_asciispec_tree(inst);
dtsv_clear_libname_tree(inst);
ncs_patricia_tree_destroy(&inst->svcid_asciispec_tree);
ncs_patricia_tree_destroy(&inst->libname_asciispec_tree);
ncs_patricia_tree_destroy(&inst->svc_tbl);
ncs_patricia_tree_destroy(&inst->dta_list);
m_DTS_UNLK(&inst->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &inst->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_lib_init: Unable to bind DTS with DTSv");
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* 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;
}
