bool sysfTmrCreate(void)
{
NCS_PATRICIA_PARAMS pat_param;
uint32_t rc = NCSCC_RC_SUCCESS;
if (ncs_tmr_create_done == false)
ncs_tmr_create_done = true;
else
return true;
/* Empty Timer Service control block. */
memset(&gl_tcb, '\0', sizeof(SYSF_TMR_CB));
/* put local persistent guard in start state */
ncslpg_create(&gl_tcb.persist);
/* Initialize the locks */
m_NCS_LOCK_INIT(&gl_tcb.safe.enter_lock);
m_NCS_LOCK_INIT(&gl_tcb.safe.free_lock);
memset((void *)&pat_param, 0, sizeof(NCS_PATRICIA_PARAMS));
pat_param.key_size = sizeof(uint64_t);
rc = ncs_patricia_tree_init(&gl_tcb.tmr_pat_tree, &pat_param);
if (rc != NCSCC_RC_SUCCESS) {
return NCSCC_RC_FAILURE;
}
rc = m_NCS_SEL_OBJ_CREATE(&gl_tcb.sel_obj);
if (rc != NCSCC_RC_SUCCESS) {
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
return NCSCC_RC_FAILURE;
}
tmr_destroying = false;
/* create expiry thread */
int policy = SCHED_RR; /*root defaults */
int max_prio = sched_get_priority_max(policy);
int min_prio = sched_get_priority_min(policy);
int prio_val = ((max_prio - min_prio) * 0.87);
if (m_NCS_TASK_CREATE((NCS_OS_CB)ncs_tmr_wait,
0,
(char *)"OSAF_TMR",
prio_val, policy, NCS_TMR_STACKSIZE, &gl_tcb.p_tsk_hdl) != NCSCC_RC_SUCCESS) {
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
m_NCS_SEL_OBJ_DESTROY(&gl_tcb.sel_obj);
return false;
}
if (m_NCS_TASK_START(gl_tcb.p_tsk_hdl) != NCSCC_RC_SUCCESS) {
m_NCS_TASK_RELEASE(gl_tcb.p_tsk_hdl);
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
m_NCS_SEL_OBJ_DESTROY(&gl_tcb.sel_obj);
return false;
}
return true;
}
/****************************************************************************
* PROCEDURE: mbcsv_lib_init
*
* Description : This is the function which initalize the mbcsv libarary.
* This function creates an global lock, creates MBCSV linked
* list, etc.
*
* Arguments : req_info - Request info.
*
* Return Values : SA_AIS_OK/Failure code.
*
* Notes : None.
*****************************************************************************/
uint32_t mbcsv_lib_init(NCS_LIB_REQ_INFO *req_info)
{
NCS_PATRICIA_PARAMS pt_params;
uint32_t rc = SA_AIS_OK;
TRACE_ENTER();
if (mbcsv_cb.created == true) {
TRACE_LEAVE2("Lib init request failed: MBCA already created");
return SA_AIS_ERR_INIT;
}
/*
* Create global lock
*/
m_NCS_LOCK_INIT(&mbcsv_cb.global_lock);
/*
* Create patricia tree for the MBCA registration instance
*/
pt_params.key_size = sizeof(uint32_t);
if (ncs_patricia_tree_init(&mbcsv_cb.reg_list, &pt_params) != NCSCC_RC_SUCCESS) {
TRACE_4("pat tree init failed");
rc = SA_AIS_ERR_FAILED_OPERATION;
goto err1;
}
if (NCSCC_RC_SUCCESS != mbcsv_initialize_mbx_list()) {
TRACE_4("pat tree init for mailbox failed");
rc = SA_AIS_ERR_FAILED_OPERATION;
goto err2;
}
/*
* Create patricia tree for the peer list
*/
if (mbcsv_initialize_peer_list() != NCSCC_RC_SUCCESS) {
TRACE_4("pat tree init for peer list failed");
rc = SA_AIS_ERR_FAILED_OPERATION;
goto err3;
}
mbcsv_cb.created = true;
return rc;
/* Handle Different Error Situations */
err3:
ncs_patricia_tree_destroy(&mbcsv_cb.mbx_list);
m_NCS_LOCK_DESTROY(&mbcsv_cb.mbx_list_lock);
err2:
ncs_patricia_tree_destroy(&mbcsv_cb.reg_list);
err1:
m_NCS_LOCK_DESTROY(&mbcsv_cb.global_lock);
TRACE_LEAVE();
return rc;
}
/****************************************************************************
* Name : eds_cb_destroy
*
* Description : This function destroys the EDS_CB including the
* Patricia trees.
*
*
* Arguments : eds_cb * - Pointer to the EDS_CB.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
void eds_cb_destroy(EDS_CB *eds_cb)
{
ncs_patricia_tree_destroy(&eds_cb->eda_reg_list);
/* Check if other lists are deleted as well */
ncs_patricia_tree_destroy(&eds_cb->eds_cname_list);
ncs_patricia_tree_destroy(&eds_cb->eds_cluster_nodes_list);
return;
}
NCS_BOOL sysfTmrCreate(void)
{
NCS_PATRICIA_PARAMS pat_param;
uns32 rc = NCSCC_RC_SUCCESS;
if (ncs_tmr_create_done == FALSE)
ncs_tmr_create_done = TRUE;
else
return TRUE;
/* Empty Timer Service control block. */
memset(&gl_tcb, '\0', sizeof(SYSF_TMR_CB));
/* put local persistent guard in start state */
ncslpg_create(&gl_tcb.persist);
/* Initialize the locks */
m_NCS_LOCK_INIT(&gl_tcb.safe.enter_lock);
m_NCS_LOCK_INIT(&gl_tcb.safe.free_lock);
memset((void *)&pat_param, 0, sizeof(NCS_PATRICIA_PARAMS));
pat_param.key_size = sizeof(uns64);
rc = ncs_patricia_tree_init(&gl_tcb.tmr_pat_tree, &pat_param);
if (rc != NCSCC_RC_SUCCESS) {
return NCSCC_RC_FAILURE;
}
rc = m_NCS_SEL_OBJ_CREATE(&gl_tcb.sel_obj);
if (rc != NCSCC_RC_SUCCESS) {
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
return NCSCC_RC_FAILURE;
}
tmr_destroying = FALSE;
/* create expiry thread */
if (m_NCS_TASK_CREATE((NCS_OS_CB)ncs_tmr_wait,
0,
NCS_TMR_TASKNAME,
NCS_TMR_PRIORITY, NCS_TMR_STACKSIZE, &gl_tcb.p_tsk_hdl) != NCSCC_RC_SUCCESS) {
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
m_NCS_SEL_OBJ_DESTROY(gl_tcb.sel_obj);
return FALSE;
}
if (m_NCS_TASK_START(gl_tcb.p_tsk_hdl) != NCSCC_RC_SUCCESS) {
m_NCS_TASK_RELEASE(gl_tcb.p_tsk_hdl);
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
m_NCS_SEL_OBJ_DESTROY(gl_tcb.sel_obj);
return FALSE;
}
return TRUE;
}
/*****************************************************************************\
*
* PROCEDURE NAME: dta_svc_create
*
* DESCRIPTION: Create an instance of DTA, set configuration profile to
* default, install this DTA with MDS and subscribe to DTS
* events.
*
* RETURNS: SUCCESS - All went well
* FAILURE - something went wrong. Turn on m_DTA_DBG_SINK()
* for details.
*
\*****************************************************************************/
uns32 dta_svc_create(NCSDTA_CREATE *create)
{
/* Create a new structure and initialize all its fields */
DTA_CB *inst = &dta_cb;
NCS_PATRICIA_PARAMS pt_params;
m_DTA_LK_INIT;
m_DTA_LK_CREATE(&inst->lock);
m_DTA_LK(&inst->lock);
inst->created = TRUE;
inst->dts_exist = FALSE;
/* Versioning changes */
inst->act_dts_ver = DTA_MIN_ACT_DTS_MDS_SUB_PART_VER;
pt_params.key_size = sizeof(SS_SVC_ID);
/*Create a Patricia tree for the DTA registration table instead of queue */
if (ncs_patricia_tree_init(&inst->reg_tbl, &pt_params) != NCSCC_RC_SUCCESS) {
inst->created = FALSE;
m_DTA_UNLK(&inst->lock);
m_DTA_LK_DLT(&inst->lock);
return m_DTA_DBG_SINK(NCSCC_RC_FAILURE, "dta_svc_create: Patricia tree init failed");
}
/*
* Get ADEST handle and then register with MDS.
*/
if (dta_get_ada_hdl() != NCSCC_RC_SUCCESS) {
inst->created = FALSE;
ncs_patricia_tree_destroy(&inst->reg_tbl);
m_DTA_UNLK(&inst->lock);
m_DTA_LK_DLT(&inst->lock);
return m_DTA_DBG_SINK(NCSCC_RC_FAILURE, "dta_svc_create: Get ADEST handle failed");
}
/* 3_0_b versioning changes - Subscribe to MDS with dta_mds_version */
inst->dta_mds_version = DTA_MDS_SUB_PART_VERSION;
if (dta_mds_install_and_subscribe() != NCSCC_RC_SUCCESS) {
inst->created = FALSE;
ncs_patricia_tree_destroy(&inst->reg_tbl);
m_DTA_UNLK(&inst->lock);
m_DTA_LK_DLT(&inst->lock);
return m_DTA_DBG_SINK(NCSCC_RC_FAILURE, "dta_svc_create: MDS install and subscribe failed");
}
m_DTA_UNLK(&inst->lock);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : avnd_pgdb_destroy
Description : This routine destroys the PG database.
Arguments : cb - ptr to the AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_pgdb_destroy(AVND_CB *cb)
{
AVND_PG *pg = 0;
uns32 rc = NCSCC_RC_SUCCESS;
/* scan & delete each pg rec */
while (0 != (pg = (AVND_PG *)ncs_patricia_tree_getnext(&cb->pgdb, (uns8 *)0))) {
/* delete the record */
rc = avnd_pgdb_rec_del(cb, &pg->csi_name);
if (NCSCC_RC_SUCCESS != rc)
goto err;
}
/* finally destroy patricia tree */
rc = ncs_patricia_tree_destroy(&cb->pgdb);
if (NCSCC_RC_SUCCESS != rc)
goto err;
TRACE("PG DB destroy success");
return rc;
err:
LOG_CR("PG DB destroy failed");
return rc;
}
/****************************************************************************
Name : avnd_internode_avail_comp_db_destroy
Description : This routine destroys the available internode components database.
It deletes all the components records from the database.
Arguments : cb - ptr to the AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_internode_avail_comp_db_destroy(AVND_CB *cb)
{
AVND_COMP *comp = 0;
uns32 rc = NCSCC_RC_SUCCESS;
/* scan & delete each su */
while (0 != (comp = (AVND_COMP *)ncs_patricia_tree_getnext(&cb->internode_avail_comp_db, (uns8 *)0))) {
/* delete the record */
m_AVND_SEND_CKPT_UPDT_ASYNC_RMV(cb, comp, AVND_CKPT_COMP_CONFIG);
rc = avnd_internode_comp_del(cb, &cb->internode_avail_comp_db, &comp->name);
if (NCSCC_RC_SUCCESS != rc)
goto err;
}
/* finally destroy patricia tree */
rc = ncs_patricia_tree_destroy(&cb->internode_avail_comp_db);
if (NCSCC_RC_SUCCESS != rc)
goto err;
return rc;
err:
LOG_ER("internode_avail_comp_db_destroy failed");
return rc;
}
/****************************************************************************
Name : avnd_nodeid_to_mdsdest_map_db_destroy
Description : This routine destroys the node_id to mds dest mapping database.
It deletes all the mapping records from the database.
Arguments : cb - ptr to the AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_nodeid_to_mdsdest_map_db_destroy(AVND_CB *cb)
{
AVND_NODEID_TO_MDSDEST_MAP *mapping = 0;
uns32 rc = NCSCC_RC_SUCCESS;
/* scan & delete each su */
while (0 != (mapping =
(AVND_NODEID_TO_MDSDEST_MAP *)ncs_patricia_tree_getnext(&cb->nodeid_mdsdest_db, (uns8 *)0))) {
/* delete the record */
rc = avnd_nodeid_mdsdest_rec_del(cb, mapping->mds_dest);
if (NCSCC_RC_SUCCESS != rc)
goto err;
}
/* finally destroy patricia tree */
rc = ncs_patricia_tree_destroy(&cb->nodeid_mdsdest_db);
if (NCSCC_RC_SUCCESS != rc)
goto err;
return rc;
err:
LOG_ER("nodeid_to_mdsdest_map_db_destroy failed");
return rc;
}
/****************************************************************************
* 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 : cpd_ckpt_reploc_destroy
Description : This routine cleans up the Checkpoint node from tree
Arguments : CPD_CB *cb - CPD Control Block.
: CPD_CKPT_REPLOC_INFO *ckpt_reploc_node - Local Ckeckpoint Node.
Return Values : None
Notes : None
******************************************************************************/
void cpd_ckpt_reploc_tree_destroy(CPD_CB *cb)
{
if (!cb->is_ckpt_reploc_up)
return;
cpd_ckpt_reploc_cleanup(cb);
ncs_patricia_tree_destroy(&cb->ckpt_reploc_tree);
return;
}
/****************************************************************************
Name : immd_immnd_info_tree_destroy
Description : This routine destroys the IMMD lcl ckpt tree.
Arguments : IMMD_CB *cb - IMMD Control Block.
Return Values : None
*****************************************************************************/
void immd_immnd_info_tree_destroy(IMMD_CB *cb)
{
if (!cb->is_immnd_tree_up)
return;
/* cleanup the client tree */
immd_immnd_info_tree_cleanup(cb);
/* destroy the tree */
ncs_patricia_tree_destroy(&cb->immnd_tree);
return;
}
/****************************************************************************
Name : cpd_cpnd_info_tree_destroy
Description : This routine destroys the CPD lcl ckpt tree.
Arguments : CPD_CB *cb - CPD Control Block.
Return Values : None
Notes : None
******************************************************************************/
void cpd_cpnd_info_tree_destroy(CPD_CB *cb)
{
if (!cb->is_cpnd_tree_up)
return;
/* cleanup the client tree */
cpd_cpnd_info_tree_cleanup(cb);
/* destroy the tree */
ncs_patricia_tree_destroy(&cb->cpnd_tree);
return;
}
/****************************************************************************
* PROCEDURE : mbcsv_lib_destroy
*
* Description : This is the function which destroys the MBCSV.
*
* Arguments : None.
*
* Return Values : SA_AIS_OK/Failure code.
*
* Notes : None.
*****************************************************************************/
uint32_t mbcsv_lib_destroy(void)
{
MBCSV_REG *mbc_reg;
SS_SVC_ID svc_id = 0;
SaAisErrorT rc = SA_AIS_OK;
TRACE_ENTER();
if (mbcsv_cb.created == false) {
TRACE_LEAVE2("Lib destroy request failed: Create MBCA before destroying");
return SA_AIS_ERR_EXIST;
}
m_NCS_LOCK(&mbcsv_cb.global_lock, NCS_LOCK_WRITE);
mbcsv_cb.created = false;
/*
* Walk through MBCSv reg list and destroy all the registration instances.
*/
while (NULL != (mbc_reg = (MBCSV_REG *)ncs_patricia_tree_getnext(&mbcsv_cb.reg_list, (const uint8_t *)&svc_id))) {
svc_id = mbc_reg->svc_id;
if (NCSCC_RC_SUCCESS != mbcsv_rmv_reg_inst((MBCSV_REG *)&mbcsv_cb.reg_list, mbc_reg)) {
/* Not required to return for failure, log the err message and go
ahead with cleanup */
TRACE_4("Failed to remove this service instance:%u", mbc_reg->svc_id);
}
}
ncs_patricia_tree_destroy(&mbcsv_cb.reg_list);
/*
* Call function which will destroy and free all the entries of the peer list.
*/
mbcsv_destroy_peer_list();
/*
* Call function which will destroy mail box list.
*/
mbcsv_destroy_mbx_list();
m_NCS_UNLOCK(&mbcsv_cb.global_lock, NCS_LOCK_WRITE);
m_NCS_LOCK_DESTROY(&mbcsv_cb.global_lock);
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : mqa_client_tree_destroy
Description : This routine destroys the MQA client tree.
Arguments : destroy_info - ptr to the destroy info
Return Values : None
Notes : None
******************************************************************************/
static void mqa_client_tree_destroy(MQA_CB *mqa_cb)
{
uns32 rc = NCSCC_RC_SUCCESS;
/* take the cb lock */
if ((rc = m_NCS_LOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_CLIENT_TREE_DESTROY_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__,
__LINE__);
return;
}
/* cleanup the client tree */
mqa_client_tree_cleanup(mqa_cb);
/* destroy the tree */
ncs_patricia_tree_destroy(&mqa_cb->mqa_client_tree);
/* giveup the cb lock */
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
return;
}
/****************************************************************************
* Name : gld_cb_destroy
*
* Description : This function is invoked at destroy time. This function will
* free all the dynamically allocated memory
*
* Arguments : gld_cb - GLD control block pointer.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* Notes : None.
*****************************************************************************/
uns32 gld_cb_destroy(GLSV_GLD_CB *gld_cb)
{
GLSV_GLD_GLND_DETAILS *node_details;
GLSV_GLD_RSC_INFO *rsc_info;
GLSV_NODE_LIST *node_list;
GLSV_GLD_GLND_RSC_REF *glnd_rsc;
/* destroy the patricia trees */
while ((node_details = (GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_getnext(&gld_cb->glnd_details, (uns8 *)0))) {
while ((glnd_rsc =
(GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uns8 *)0))) {
if (ncs_patricia_tree_del(&node_details->rsc_info_tree, (NCS_PATRICIA_NODE *)glnd_rsc) !=
NCSCC_RC_SUCCESS) {
m_LOG_GLD_HEADLINE(GLD_PATRICIA_TREE_DEL_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__,
0);
return NCSCC_RC_FAILURE;
}
m_MMGR_FREE_GLSV_GLD_GLND_RSC_REF(glnd_rsc);
}
ncs_patricia_tree_destroy(&node_details->rsc_info_tree);
if (ncs_patricia_tree_del(&gld_cb->glnd_details, (NCS_PATRICIA_NODE *)node_details) != NCSCC_RC_SUCCESS) {
m_LOG_GLD_HEADLINE(GLD_PATRICIA_TREE_DEL_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__,
node_details->node_id);
return NCSCC_RC_FAILURE;
}
m_MMGR_FREE_GLSV_GLD_GLND_DETAILS(node_details);
}
while ((rsc_info = (GLSV_GLD_RSC_INFO *)ncs_patricia_tree_getnext(&gld_cb->rsc_info_id, (uns8 *)0))) {
/* Free the node list */
while (rsc_info->node_list != NULL) {
node_list = rsc_info->node_list;
rsc_info->node_list = node_list->next;
m_MMGR_FREE_GLSV_NODE_LIST(node_list);
}
gld_free_rsc_info(gld_cb, rsc_info);
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : ava_hdl_del
Description : This routine deletes the handle database.
Arguments : cb - ptr to the AvA control block
Return Values : None
Notes : None
******************************************************************************/
void ava_hdl_del(AVA_CB *cb)
{
AVA_HDL_DB *hdl_db = &cb->hdl_db;
AVA_HDL_REC *hdl_rec = 0;
TRACE_ENTER();
/* scan the entire handle db & delete each record */
while ((hdl_rec = (AVA_HDL_REC *)
ncs_patricia_tree_getnext(&hdl_db->hdl_db_anchor, 0))) {
ava_hdl_rec_del(cb, hdl_db, &hdl_rec);
}
/* there shouldn't be any record left */
osafassert(!hdl_db->num);
/* destroy the hdl db tree */
ncs_patricia_tree_destroy(&hdl_db->hdl_db_anchor);
TRACE_LEAVE();
return;
}
/****************************************************************************
Name : mqa_client_tree_destroy
Description : This routine destroys the MQA client tree.
Arguments : destroy_info - ptr to the destroy info
Return Values : None
Notes : None
******************************************************************************/
static void mqa_client_tree_destroy(MQA_CB *mqa_cb)
{
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* take the cb lock */
if ((rc = m_NCS_LOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE)) != NCSCC_RC_SUCCESS) {
TRACE_2("FAILURE: Client database Finalization Failed");
return;
}
/* cleanup the client tree */
mqa_client_tree_cleanup(mqa_cb);
/* destroy the tree */
ncs_patricia_tree_destroy(&mqa_cb->mqa_client_tree);
/* giveup the cb lock */
m_NCS_UNLOCK(&mqa_cb->cb_lock, NCS_LOCK_WRITE);
TRACE_LEAVE();
return;
}
/****************************************************************************
Name : mqa_client_tree_delete_node
Description : This routine adds the deletes the client from the client tree
Arguments : client_info - pointer to the client node.
Return Values : NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
Notes : None
******************************************************************************/
uint32_t mqa_client_tree_delete_node(MQA_CB *mqa_cb, MQA_CLIENT_INFO *client_info)
{
MQA_TRACK_INFO *track_info;
SaNameT *temp_ptr = 0;
SaNameT temp_name;
uint8_t *value = NULL;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* scan the entire group track db & delete each record */
while ((track_info = (MQA_TRACK_INFO *)ncs_patricia_tree_getnext(&client_info->mqa_track_tree, value))) {
/* delete the track info */
temp_name = track_info->queueGroupName;
temp_ptr = &temp_name;
value = temp_ptr->value;
/* delete from the tree */
if ((rc = ncs_patricia_tree_del(&client_info->mqa_track_tree,
&track_info->patnode)) != NCSCC_RC_SUCCESS)
TRACE_2("Track Database Deregistration Failed");
/* free the mem */
if (track_info->notificationBuffer.notification)
m_MMGR_FREE_MQA_TRACK_BUFFER_INFO(track_info->notificationBuffer.notification);
m_MMGR_FREE_MQA_TRACK_INFO(track_info);
}
/* destroy the tree */
ncs_patricia_tree_destroy(&client_info->mqa_track_tree);
/* delete from the tree */
if ((rc = ncs_patricia_tree_del(&mqa_cb->mqa_client_tree, &client_info->patnode)) != NCSCC_RC_SUCCESS)
TRACE_2("Client database Deregistration Failed");
/* free the mem */
m_MMGR_FREE_MQA_CLIENT_INFO(client_info);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/**************************************************************************\
* exec_mod_cb_destroy
*
* Description : Destroys module control block.
*
* Call Arguments : None
*
* Returns:
* SUCCESS/FAILURE : NCSCC_RC_SUCCESS / NCSCC_RC_FAILURE
*
* Notes:
*
\**************************************************************************/
uns32 exec_mod_cb_destroy(void)
{
SYSF_PID_LIST *exec_pid = NULL;
uns8 pid = 0;
if (module_cb.init == TRUE) {
module_cb.init = FALSE;
m_NCS_SIGNAL(SIGCHLD, SIG_DFL);
close(module_cb.write_fd);
close(module_cb.read_fd);
m_NCS_TASK_RELEASE(module_cb.em_task_handle);
m_NCS_LOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
while (NULL != (exec_pid = (SYSF_PID_LIST *)ncs_patricia_tree_getnext(&module_cb.pid_list,
(const uns8 *)&pid))) {
ncs_patricia_tree_del(&module_cb.pid_list, (NCS_PATRICIA_NODE *)exec_pid);
if (exec_pid->tmr_id != NULL)
m_NCS_TMR_DESTROY(exec_pid->tmr_id);
m_MMGR_FREE_PRO_EXC(exec_pid);
}
if (ncs_patricia_tree_destroy(&module_cb.pid_list) != NCSCC_RC_SUCCESS) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
m_NCS_UNLOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
}
m_NCS_LOCK_DESTROY(&module_cb.tree_lock);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : mqa_client_tree_delete_node
Description : This routine adds the deletes the client from the client tree
Arguments : client_info - pointer to the client node.
Return Values : NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
Notes : None
******************************************************************************/
uns32 mqa_client_tree_delete_node(MQA_CB *mqa_cb, MQA_CLIENT_INFO *client_info)
{
MQA_TRACK_INFO *track_info;
SaNameT *temp_ptr = 0;
SaNameT temp_name;
uns8 *value = NULL;
uns32 rc = NCSCC_RC_SUCCESS;
/* scan the entire group track db & delete each record */
while ((track_info = (MQA_TRACK_INFO *)ncs_patricia_tree_getnext(&client_info->mqa_track_tree, value))) {
/* delete the track info */
temp_name = track_info->queueGroupName;
temp_ptr = &temp_name;
value = temp_ptr->value;
/* delete from the tree */
if ((rc = ncs_patricia_tree_del(&client_info->mqa_track_tree,
&track_info->patnode)) != NCSCC_RC_SUCCESS)
m_LOG_MQSV_A(MQA_TRACK_TREE_DEL_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__,
__LINE__);
/* free the mem */
if (track_info->notificationBuffer.notification)
m_MMGR_FREE_MQA_TRACK_BUFFER_INFO(track_info->notificationBuffer.notification);
m_MMGR_FREE_MQA_TRACK_INFO(track_info);
}
/* destroy the tree */
ncs_patricia_tree_destroy(&client_info->mqa_track_tree);
/* delete from the tree */
if ((rc = ncs_patricia_tree_del(&mqa_cb->mqa_client_tree, &client_info->patnode)) != NCSCC_RC_SUCCESS)
m_LOG_MQSV_A(MQA_CLIENT_TREE_DEL_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
/* free the mem */
m_MMGR_FREE_MQA_CLIENT_INFO(client_info);
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;
}
bool sysfTmrDestroy(void)
{
SYSF_TMR *tmr;
SYSF_TMR *free_tmr;
SYSF_TMR_PAT_NODE *tmp = NULL;
/* There is only ever one timer per instance */
m_NCS_LOCK(&gl_tcb.safe.free_lock, NCS_LOCK_WRITE);
gl_tcb.safe.dmy_free.next = NULL;
m_NCS_UNLOCK(&gl_tcb.safe.free_lock, NCS_LOCK_WRITE);
m_NCS_LOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE);
/* Create selection object */
m_NCS_SEL_OBJ_CREATE(&tmr_destroy_syn_obj);
tmr_destroying = true;
m_NCS_SEL_OBJ_IND(&gl_tcb.sel_obj);
/* Unlock the lock */
m_NCS_UNLOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE); /* critical region END */
/* Wait on Poll object */
osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(tmr_destroy_syn_obj), 20000);
m_NCS_LOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE);
tmr = &gl_tcb.safe.dmy_keep;
while (tmr->keep != NULL) {
free_tmr = tmr->keep;
tmr->keep = tmr->keep->keep;
m_NCS_MEM_FREE(free_tmr, NCS_MEM_REGION_PERSISTENT, NCS_SERVICE_ID_LEAP_TMR, 0);
}
while ((tmp = (SYSF_TMR_PAT_NODE *)ncs_patricia_tree_getnext(&gl_tcb.tmr_pat_tree, (uint8_t *)0)) != NULL) {
ncs_patricia_tree_del(&gl_tcb.tmr_pat_tree, (NCS_PATRICIA_NODE *)tmp);
m_NCS_MEM_FREE(tmp, NCS_MEM_REGION_PERSISTENT, NCS_SERVICE_ID_LEAP_TMR, 0);
}
ncs_patricia_tree_destroy(&gl_tcb.tmr_pat_tree);
m_NCS_SEL_OBJ_DESTROY(&gl_tcb.sel_obj);
/* Stop the dedicated thread that runs out of ncs_tmr_wait() */
m_NCS_TASK_RELEASE(gl_tcb.p_tsk_hdl);
tmr_destroying = false;
m_NCS_SEL_OBJ_DESTROY(&tmr_destroy_syn_obj);
m_NCS_UNLOCK(&gl_tcb.safe.enter_lock, NCS_LOCK_WRITE); /* critical region END */
/* don't destroy the lock (but remember that you could!).
* m_NCS_LOCK_DESTROY (&l_tcb.lock);
*/
m_NCS_LOCK_DESTROY(&gl_tcb.safe.enter_lock);
m_NCS_LOCK_DESTROY(&gl_tcb.safe.free_lock);
ncs_tmr_create_done = false;
return true;
}
/****************************************************************************
* Name : 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;
}
/*****************************************************************************
*
* PROCEDURE NAME: dta_svc_destroy
*
* DESCRIPTION: Destroy an instance of DTA. Withdraw from MDS and free
* this DTA_CB and tend to other resource recovery issues.
*
* Arguments : destroy : Information require for destroy.
*
* RETURNS: SUCCESS - all went well.
* FAILURE - something went wrong. Turn on m_DTA_DBG_SINK()
* for details.
*
*****************************************************************************/
uns32 dta_svc_destroy(NCSDTA_DESTROY *destroy)
{
DTA_CB *inst = &dta_cb;
uns32 retval = NCSCC_RC_SUCCESS;
REG_TBL_ENTRY *svc;
if (inst->created == FALSE)
return m_DTA_DBG_SINK(NCSCC_RC_FAILURE, "dta_svc_destroy: DTA does not exist. First create DTA.");
m_DTA_LK(&inst->lock);
/* Clear the local datastructures */
while ((svc = (REG_TBL_ENTRY *)ncs_patricia_tree_getnext(&inst->reg_tbl, NULL)) != NULL) {
ncs_patricia_tree_del(&inst->reg_tbl, (NCS_PATRICIA_NODE *)svc);
m_MMGR_FREE_DTA_REG_TBL(svc);
}
/*Destroy the patricia tree created */
ncs_patricia_tree_destroy(&inst->reg_tbl);
/* Clear the logs buffered in DTA */
{
DTA_LOG_BUFFER *list = &dta_cb.log_buffer;
DTA_BUFFERED_LOG *buf;
uns32 i, count;
DTSV_MSG *msg;
if ((list == NULL) || (list->num_of_logs == 0)) {
/* Don't print anythig, service users don't like DBG SINKs */
} else {
count = list->num_of_logs;
for (i = 0; i < count; i++) {
if (!list->head) {
list->tail = NULL;
break;
}
buf = list->head;
list->head = list->head->next;
msg = buf->buf_msg;
if (msg->data.data.msg.log_msg.uba.start != NULL)
m_MMGR_FREE_BUFR_LIST(msg->data.data.msg.log_msg.uba.start);
m_MMGR_FREE_OCT(msg->data.data.msg.log_msg.hdr.fmat_type);
if (0 != msg)
m_MMGR_FREE_DTSV_MSG(msg);
m_MMGR_FREE_DTA_BUFFERED_LOG(buf);
list->num_of_logs--;
} /*end of for */
} /*end of else */
}
m_DTA_UNLK(&inst->lock);
/* Uninstall DTA from MDS */
if (dta_mds_uninstall() != NCSCC_RC_SUCCESS) {
retval = m_DTA_DBG_SINK(NCSCC_RC_FAILURE, "dta_svc_destroy: MDS uninstall failed.");
}
inst->created = FALSE;
m_DTA_LK_DLT(&inst->lock);
return retval;
}
