/****************************************************************************
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 : 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 : 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 : 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);
}
/**
* This function initializes the DTMS_CB including the Patricia trees
*
* @param dtms_cb
*
* @return NCSCC_RC_SUCCESS
* @return NCSCC_RC_FAILURE
*
*/
uns32 dtm_cb_init(DTM_INTERNODE_CB * dtms_cb)
{
NCS_PATRICIA_PARAMS nodeid_param;
NCS_PATRICIA_PARAMS comm_socket_param;
NCS_PATRICIA_PARAMS ipaddr_param;
TRACE_ENTER();
memset(&nodeid_param, 0, sizeof(NCS_PATRICIA_PARAMS));
memset(&comm_socket_param, 0, sizeof(NCS_PATRICIA_PARAMS));
memset(&ipaddr_param, 0, sizeof(NCS_PATRICIA_PARAMS));
nodeid_param.key_size = sizeof(uns32);
comm_socket_param.key_size = sizeof(uns32);
ipaddr_param.key_size = IPV6_ADDR_UNS8_CNT;
/* Initialize patricia tree for nodeid list */
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtms_cb->nodeid_tree, &nodeid_param)) {
LOG_ER("DTM: ncs_patricia_tree_init FAILED");
return NCSCC_RC_FAILURE;
}
/* Initialize comm_socket patricia tree */
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtms_cb->comm_sock_tree, &comm_socket_param)) {
LOG_ER("DTM:ncs_patricia_tree_init FAILED");
return NCSCC_RC_FAILURE;
}
/* Initialize comm_socket patricia tree */
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtms_cb->ip_addr_tree, &ipaddr_param)) {
LOG_ER("DTM:ncs_patricia_tree_init FAILED");
return NCSCC_RC_FAILURE;
}
if (m_NCS_IPC_CREATE(&dtms_cb->mbx) != NCSCC_RC_SUCCESS) {
/* Mail box creation failed */
LOG_ER("DTM:IPC create FAILED");
return NCSCC_RC_FAILURE;
} else {
NCS_SEL_OBJ obj;
if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&dtms_cb->mbx)) {
m_NCS_IPC_RELEASE(&dtms_cb->mbx, NULL);
LOG_ER("DTM: Internode Mailbox Attach failed");
return NCSCC_RC_FAILURE;
}
obj = m_NCS_IPC_GET_SEL_OBJ(&dtms_cb->mbx);
/* retreive the corresponding fd for mailbox and fill it in cb */
dtms_cb->mbx_fd = m_GET_FD_FROM_SEL_OBJ(obj); /* extract and fill value needs to be extracted */
}
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : glsv_gla_callback_queue_init
Description : This routine is used to initialize the queue for the callbacks.
Arguments : client_info - pointer to the client info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 glsv_gla_callback_queue_init(GLA_CLIENT_INFO *client_info)
{
if (m_NCS_IPC_CREATE(&client_info->callbk_mbx) == NCSCC_RC_SUCCESS) {
if (m_NCS_IPC_ATTACH(&client_info->callbk_mbx) == NCSCC_RC_SUCCESS) {
return NCSCC_RC_SUCCESS;
}
m_NCS_IPC_RELEASE(&client_info->callbk_mbx, NULL);
}
m_LOG_GLA_SYS_CALL(GLA_GET_SEL_OBJ_FAIL, __FILE__, __LINE__, client_info->lock_handle_id);
return NCSCC_RC_FAILURE;
}
/***************************************************************************
@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 : 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);
}
static uint32_t dtm_intranode_create_pid_info(int fd)
{
DTM_INTRANODE_PID_INFO *pid_node = NULL;
TRACE_ENTER();
if (NULL == (pid_node = calloc(1, sizeof(DTM_INTRANODE_PID_INFO)))) {
TRACE("\nMemory allocation failed for DTM_INTRANODE_PID_INFO");
return NCSCC_RC_FAILURE;
}
pid_node->accepted_fd = fd;
pid_node->pid = 0; /* Yet to be filled from the PID Message which is yet to come */
pid_node->node_id = m_NCS_GET_NODE_ID;
pid_node->fd_node.key_info = (uint8_t *)&pid_node->accepted_fd;
if (m_NCS_IPC_CREATE(&pid_node->mbx) != NCSCC_RC_SUCCESS) {
/* Mail box creation failed */
TRACE("Mailbox creation failed,dtm_accept msg");
free(pid_node);
return NCSCC_RC_FAILURE;
} else {
NCS_SEL_OBJ obj;
/* Code added for attaching the mailbox */
if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&pid_node->mbx)) {
TRACE("\nMailbox attach failed,dtm_intranode_process_pid_msg");
m_NCS_IPC_RELEASE(&pid_node->mbx, NULL);
free(pid_node);
return NCSCC_RC_FAILURE;
}
obj = m_NCS_IPC_GET_SEL_OBJ(&pid_node->mbx);
/* retreive the corresponding fd for mailbox */
pid_node->mbx_fd = m_GET_FD_FROM_SEL_OBJ(obj); /* extract and fill value needs to be extracted */
}
ncs_patricia_tree_add(&dtm_intranode_cb->dtm_intranode_fd_list, (NCS_PATRICIA_NODE *)&pid_node->fd_node);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
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;
}
/***************************************************************************
@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;
}
/**
* Function to init the intranode processing
*
*
* @return NCSCC_RC_SUCCESS
* @return NCSCC_RC_FAILURE
*
*/
uint32_t dtm_intra_processing_init(char *node_ip, DTM_IP_ADDR_TYPE i_addr_family)
{
int servlen, size = DTM_INTRANODE_SOCK_SIZE; /* For socket fd and server len */
struct sockaddr_un serv_addr; /* For Unix Sock address */
char server_ux_name[255];
NCS_PATRICIA_PARAMS pat_tree_params;
struct sockaddr_in serveraddr;
struct sockaddr_in6 serveraddr6;
int flags;
TRACE_ENTER();
/* UNIX is default transport for intranode */
dtm_socket_domain = AF_UNIX;
if (NULL == (dtm_intranode_cb = calloc(1, sizeof(DTM_INTRANODE_CB)))) {
LOG_ER("DTM: Memory allocation failed for dtm_intranode_cb");
return NCSCC_RC_FAILURE;
}
dtm_intranode_cb->sock_domain = dtm_socket_domain;
/* Open a socket, If socket opens to fail return Error */
dtm_intranode_cb->server_sockfd = socket(dtm_socket_domain, SOCK_STREAM, 0);
if (dtm_intranode_cb->server_sockfd < 0) {
LOG_ER("DTM: Socket creation failed err :%s ", strerror(errno));
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
/*Make the socket Non-Blocking for accepting */
if ((flags = fcntl(dtm_intranode_cb->server_sockfd, F_GETFL, NULL)) < 0) {
LOG_ER("DTM :fcntl(F_SETFL, O_NONBLOCK) err :%s ", strerror(errno));
return false;
}
flags |= O_NONBLOCK;
if(fcntl(dtm_intranode_cb->server_sockfd, F_SETFL, flags) < 0) {
/*Non-Blocking Options hasnt been set, what shall we do now */
LOG_ER("DTM: Socket NON Block set failed err :%s ", strerror(errno));
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
/* Increase the socket buffer size */
if (setsockopt(dtm_intranode_cb->server_sockfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)) != 0) {
LOG_ER("DTM: Unable to set the SO_RCVBUF err :%s ", strerror(errno));
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
if (setsockopt(dtm_intranode_cb->server_sockfd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)) != 0) {
LOG_ER("DTM: Unable to set the SO_SNDBUF err :%s ", strerror(errno));
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
dtm_intranode_cb->nodeid = m_NCS_GET_NODE_ID;
bzero((char *)&serv_addr, sizeof(serv_addr));
if (dtm_socket_domain == AF_UNIX) {
#define UX_SOCK_NAME_PREFIX PKGLOCALSTATEDIR "/osaf_dtm_intra_server"
sprintf(server_ux_name, "%s", UX_SOCK_NAME_PREFIX);
serv_addr.sun_family = AF_UNIX;
strcpy(serv_addr.sun_path, server_ux_name);
unlink(serv_addr.sun_path);
servlen = strlen(serv_addr.sun_path) + sizeof(serv_addr.sun_family);
/* Bind the created socket here with the address NODEID,
* if bind fails return error by the closing the
* created socket*/
if (bind(dtm_intranode_cb->server_sockfd, (struct sockaddr *)&serv_addr, servlen) < 0) {
LOG_ER("DTM: Bind failed err :%s ", strerror(errno));
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
if (chmod(UX_SOCK_NAME_PREFIX, (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) < 0) {
LOG_ER("chmod %s failed - %s", UX_SOCK_NAME_PREFIX, strerror(errno));
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
} else {
if (dtm_socket_domain == AF_INET) {
memset(&serveraddr, 0, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(DTM_INTRA_SERVER_PORT);
serveraddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
if (bind(dtm_intranode_cb->server_sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr) ) < 0) {
LOG_ER("DTM: Bind failed err :%s ", strerror(errno));
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
} else {
memset(&serveraddr6, 0, sizeof(serveraddr6));
serveraddr6.sin6_family = AF_INET6;
serveraddr.sin_port = htons(DTM_INTRA_SERVER_PORT);
inet_pton(AF_INET6, "localhost", &serveraddr6.sin6_addr);
if (bind(dtm_intranode_cb->server_sockfd, (struct sockaddr *)&serveraddr6, sizeof(serveraddr6) ) < 0) {
LOG_ER("DTM_INTRA: Bind failed");
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
}
}
listen(dtm_intranode_cb->server_sockfd, 20);
memset(&pat_tree_params, 0, sizeof(pat_tree_params));
pat_tree_params.key_size = sizeof(uint32_t);
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_intranode_pid_list, &pat_tree_params)) {
LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list");
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
pat_tree_params.key_size = sizeof(int);
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_intranode_fd_list, &pat_tree_params)) {
LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list");
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
pat_tree_params.key_size = sizeof(uint32_t);
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_svc_subscr_list, &pat_tree_params)) {
LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list");
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
pat_tree_params.key_size = sizeof(uint32_t);
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_init(&dtm_intranode_cb->dtm_svc_install_list, &pat_tree_params)) {
LOG_ER("DTM: ncs_patricia_tree_init failed for dtm_intranode_pid_list");
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
dtm_intranode_add_self_node_to_node_db(dtm_intranode_cb->nodeid, node_ip, i_addr_family);
if (m_NCS_IPC_CREATE(&dtm_intranode_cb->mbx) != NCSCC_RC_SUCCESS) {
/* Mail box creation failed */
LOG_ER("DTM : Intranode Mailbox Creation failed");
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
} else {
NCS_SEL_OBJ obj;
/* Code added for attaching the mailbox, to eliminate the DBG Print at sysf_ipc.c: 640 */
if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&dtm_intranode_cb->mbx)) {
m_NCS_IPC_RELEASE(&dtm_intranode_cb->mbx, NULL);
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
LOG_ER("DTM: Intranode Mailbox Attach failed");
return NCSCC_RC_FAILURE;
}
obj = m_NCS_IPC_GET_SEL_OBJ(&dtm_intranode_cb->mbx);
/* retreive the corresponding fd for mailbox and fill it in cb */
dtm_intranode_cb->mbx_fd = m_GET_FD_FROM_SEL_OBJ(obj); /* extract and fill value needs to be extracted */
}
dtm_intranode_add_poll_fdlist(dtm_intranode_cb->server_sockfd, POLLIN);
dtm_intranode_add_poll_fdlist(dtm_intranode_cb->mbx_fd, POLLIN);
if (dtm_intranode_create_rcv_task(dtm_intranode_cb->task_hdl) != NCSCC_RC_SUCCESS) {
LOG_ER("MDS:MDTM: Receive Task Creation Failed in MDTM_INIT\n");
close(dtm_intranode_cb->server_sockfd);
free(dtm_intranode_cb);
return NCSCC_RC_FAILURE;
}
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* 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 : 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 : 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 : 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;
}
