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; }