/**************************************************************************** Name : avnd_ext_intf_destroy Description : This routine destroys external interfaces (logging service being the exception). Arguments : cb - ptr to AvND control block Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ uns32 avnd_ext_intf_destroy(AVND_CB *cb) { uns32 rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); /* MDS unregistration */ rc = avnd_mds_unreg(cb); if (NCSCC_RC_SUCCESS != rc) goto done; /* EDU cleanup */ m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl_avnd); m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl_ava); /* NTFA Finalize */ rc = saNtfFinalize(cb->ntfHandle); if (rc != SA_AIS_OK) { LOG_ER("saNtfFinalize Failed (%u)", rc); } done: TRACE_LEAVE(); return rc; }
/***********************************************************************//** * @brief This routine destroys the PLMA Control block. * * @param[in] destroy_info - A pointer to the NCS_LIB_DESTROY structure. * * @return NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE. ***************************************************************************/ uns32 plma_destroy(NCS_LIB_DESTROY *destroy_info) { PLMA_CB *plma_cb = plma_ctrlblk; TRACE_ENTER(); /* MDS unregister. */ plma_mds_unregister(); /** flush the EDU handle */ m_NCS_EDU_HDL_FLUSH(&plma_cb->edu_hdl); /** destroy the client tree */ plma_client_tree_destroy(); /** destroy the lock */ m_NCS_LOCK_DESTROY(&plma_cb->cb_lock); /** make reference to plma_cb obsolete */ plma_ctrlblk = NULL; TRACE_LEAVE(); return NCSCC_RC_SUCCESS; }
/**************************************************************************** Name : ava_destroy Description : This routine destroys the AvA control block. Arguments : destroy_info - ptr to the destroy info Return Values : None Notes : None ******************************************************************************/ void ava_destroy(NCS_LIB_DESTROY *destroy_info) { AVA_CB *cb = 0; uns32 rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); /* retrieve AvA CB */ cb = (AVA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_AVA, gl_ava_hdl); if (!cb) { LOG_ER("Unable to take handle for control block"); goto done; } /* delete the hdl db */ ava_hdl_del(cb); TRACE_1("Deleted the handles DB"); /* unregister with MDS */ rc = ava_mds_unreg(cb); if (NCSCC_RC_SUCCESS != rc) TRACE_4("MDS unregistration failed"); else TRACE_1("MDS unregistration success"); /* EDU cleanup */ m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); TRACE_1("EDU cleanup failed"); /* destroy the lock */ m_NCS_LOCK_DESTROY(&cb->lock); TRACE_1("Destroying lock for control block failed"); /* return AvA CB */ ncshm_give_hdl(gl_ava_hdl); /* remove the association with hdl-mngr */ ncshm_destroy_hdl(NCS_SERVICE_ID_AVA, cb->cb_hdl); TRACE_1("Removing association with handle manager failed"); /* free the control block */ free(cb); /* reset the global cb handle */ gl_ava_hdl = 0; done: TRACE_LEAVE(); return; }
/**************************************************************************** Name : mqa_destroy Description : This routine destroys the MQA control block. Arguments : destroy_info - ptr to the destroy info Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ static uns32 mqa_destroy(NCS_LIB_DESTROY *destroy_info) { MQA_CB *cb = 0; /* validate the CB */ cb = (MQA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_MQA, gl_mqa_hdl); if (!cb) return NCSCC_RC_FAILURE; /* return MQA CB */ ncshm_give_hdl(gl_mqa_hdl); /* remove the association with hdl-mngr */ ncshm_destroy_hdl(NCS_SERVICE_ID_MQA, cb->agent_handle_id); if (m_NCS_LOCK(&cb->cb_lock, NCS_LOCK_WRITE) != NCSCC_RC_SUCCESS) { TRACE("mqa_destroy Failed to acquire lock"); return NCSCC_RC_FAILURE; } mqa_timer_table_destroy(cb); /* Unregister with ASAPi */ mqa_asapi_unregister(cb); /* MDS unregister. */ mqa_mds_unregister(cb); m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); mqa_queue_tree_destroy(cb); /* delete all the client info */ mqa_client_tree_destroy(cb); m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE); /* destroy the lock */ m_NCS_LOCK_DESTROY(&cb->cb_lock); /* de register with the flex log */ mqa_flx_log_dereg(); /* reset the global cb handle */ gl_mqa_hdl = 0; return NCSCC_RC_SUCCESS; }
/**************************************************************************** * 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 : cpa_destroy Description : This routine destroys the CPA control block. Arguments : destroy_info - ptr to the destroy info Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ static uint32_t cpa_destroy(NCS_LIB_DESTROY *destroy_info) { CPA_CB *cb = NULL; /* validate the CB */ m_CPA_RETRIEVE_CB(cb); if (!cb) return NCSCC_RC_FAILURE; /* MDS unregister. */ cpa_mds_unregister(cb); m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); /* Destroy the CPA database */ cpa_db_destroy(cb); /* destroy the lock */ m_NCS_LOCK_DESTROY(&cb->cb_lock); /* return CPA CB Handle */ ncshm_give_hdl(cb->agent_handle_id); /* remove the association with hdl-mngr */ ncshm_destroy_hdl(NCS_SERVICE_ID_CPA, cb->agent_handle_id); TRACE_2("cpa lib destroy success "); /* Memory leaks found in cpa_init.c */ m_MMGR_FREE_CPA_CB(cb); /* reset the global cb handle */ gl_cpa_hdl = 0; return NCSCC_RC_SUCCESS; }
/**************************************************************************** Name : mqa_create Description : This routine creates & initializes the MQA control block. Arguments : create_info - ptr to the create info Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ static uint32_t mqa_create(NCS_LIB_CREATE *create_info) { MQA_CB *cb = &mqa_cb; uint32_t rc = NCSCC_RC_SUCCESS; TRACE_ENTER(); /* validate create info */ if (create_info == NULL) return NCSCC_RC_FAILURE; memset(cb, 0, sizeof(MQA_CB)); /* assign the MQA pool-id (used by hdl-mngr) */ cb->pool_id = NCS_HM_POOL_ID_COMMON; /* create the association with hdl-mngr */ if (!(cb->agent_handle_id = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_MQA, (NCSCONTEXT)cb))) { TRACE_2("Handle Registration Failed"); return NCSCC_RC_FAILURE; } TRACE_1("Handle Registration Success"); /* everything went off well.. store the hdl in the global variable */ gl_mqa_hdl = cb->agent_handle_id; /* get the process id */ cb->process_id = getpid(); /* initialize the mqa cb lock */ if ((rc = m_NCS_LOCK_INIT(&cb->cb_lock)) != NCSCC_RC_SUCCESS) { TRACE_2("Cotnrol Block Lock Initialisation Failed eith return value %d", rc); goto error1; } TRACE_1("Control Block lock initialization Success"); /* initialize the client tree */ if ((rc = mqa_client_tree_init(cb)) != NCSCC_RC_SUCCESS) { TRACE_2("FAILURE: Client database Initialization Failed"); goto error2; } TRACE_1("Client Database Initialization Success"); /* initialize the queue tree */ if ((rc = mqa_queue_tree_init(cb)) != NCSCC_RC_SUCCESS) { TRACE_2("FAILURE: Queue database Initialization Failed"); goto error3; } TRACE_1("Queue Database Initialization Success"); /* EDU initialisation */ if ((rc = m_NCS_EDU_HDL_INIT(&cb->edu_hdl)) != NCSCC_RC_SUCCESS) { TRACE_2("Edu Handle Initialization Failed"); goto error4; } TRACE_1("EDU Handle Initialization Success"); /* register with MDS */ if ((rc = mqa_mds_register(cb)) != NCSCC_RC_SUCCESS) { TRACE_2("FAILURE: MDS registration Failed"); goto error5; } else TRACE_1("MDS Registration Success"); /* Update clm_node_joined flag to 1 */ cb->clm_node_joined = 1; mqa_sync_with_mqd(cb); mqa_sync_with_mqnd(cb); /* initialize the timeout linked list */ if ((rc = mqa_timer_table_init(cb)) != NCSCC_RC_SUCCESS) { TRACE_2("FAILURE: Tmr Initialization Failed"); goto error6; } if ((rc = mqa_asapi_register(cb)) != NCSCC_RC_SUCCESS) { TRACE_2("FAILURE: Registration with ASAPi Failed"); goto error7; } TRACE_LEAVE(); return NCSCC_RC_SUCCESS; error7: mqa_timer_table_destroy(cb); error6: /* MDS unregister. */ mqa_mds_unregister(cb); error5: m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); error4: /* delete the tree */ mqa_queue_tree_destroy(cb); error3: /* delete the tree */ mqa_client_tree_destroy(cb); error2: /* destroy the lock */ m_NCS_LOCK_DESTROY(&cb->cb_lock); error1: /* remove the association with hdl-mngr */ ncshm_destroy_hdl(NCS_SERVICE_ID_MQA, cb->agent_handle_id); return NCSCC_RC_FAILURE; }
/**************************************************************************** Name : ava_create Description : This routine creates & initializes the AvA control block. Arguments : create_info - ptr to the create info Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ uns32 ava_create(NCS_LIB_CREATE *create_info) { AVA_CB *cb = 0; NCS_SEL_OBJ_SET set; uns32 rc = NCSCC_RC_SUCCESS, timeout = 300; EDU_ERR err; TRACE_ENTER(); /* allocate AvA cb */ if (!(cb = calloc(1, sizeof(AVA_CB)))) { LOG_ER("AVA Create: Calloc failed"); rc = NCSCC_RC_FAILURE; goto error; } /* fetch the comp name from the env variable */ if (getenv("SA_AMF_COMPONENT_NAME")) { if (strlen(getenv("SA_AMF_COMPONENT_NAME")) < SA_MAX_NAME_LENGTH) { strcpy((char *)cb->comp_name.value, getenv("SA_AMF_COMPONENT_NAME")); cb->comp_name.length = (uns16)strlen((char *)cb->comp_name.value); m_AVA_FLAG_SET(cb, AVA_FLAG_COMP_NAME); TRACE("Component name = %s",cb->comp_name.value); } else { TRACE_2("Length of SA_AMF_COMPONENT_NAME exceeds SA_MAX_NAME_LENGTH bytes"); rc = NCSCC_RC_FAILURE; goto error; } } /* assign the AvA pool-id (used by hdl-mngr) */ cb->pool_id = NCS_HM_POOL_ID_COMMON; /* create the association with hdl-mngr */ if (!(cb->cb_hdl = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_AVA, (NCSCONTEXT)cb))) { LOG_ER("Unable to create handle for control block"); rc = NCSCC_RC_FAILURE; goto error; } TRACE("Created handle for the control block"); /* initialize the AvA cb lock */ m_NCS_LOCK_INIT(&cb->lock); TRACE("Initialized the AVA control block lock"); /* EDU initialisation */ m_NCS_EDU_HDL_INIT(&cb->edu_hdl); TRACE("EDU Initialization success"); rc = m_NCS_EDU_COMPILE_EDP(&cb->edu_hdl, avsv_edp_nda_msg, &err); if (rc != NCSCC_RC_SUCCESS) { TRACE_4("EDU Compilation failed"); goto error; } /* create the sel obj (for mds sync) */ m_NCS_SEL_OBJ_CREATE(&cb->sel_obj); /* initialize the hdl db */ if (NCSCC_RC_SUCCESS != ava_hdl_init(&cb->hdl_db)) { TRACE_4("AVA Handles DB initialization failed"); rc = NCSCC_RC_FAILURE; goto error; } TRACE("AVA Handles DB created successfully"); m_NCS_SEL_OBJ_ZERO(&set); m_NCS_SEL_OBJ_SET(cb->sel_obj, &set); m_AVA_FLAG_SET(cb, AVA_FLAG_FD_VALID); /* register with MDS */ if ((NCSCC_RC_SUCCESS != ava_mds_reg(cb))) { LOG_ER("AVA MDS Registration failed"); rc = NCSCC_RC_FAILURE; goto error; } TRACE("AVA MDS Registration success"); TRACE_1("Waiting on select till AMF Node Director is up"); /* block until mds detects avnd */ m_NCS_SEL_OBJ_SELECT(cb->sel_obj, &set, 0, 0, &timeout); /* reset the fd validity flag */ m_NCS_LOCK(&cb->lock, NCS_LOCK_WRITE); m_AVA_FLAG_RESET(cb, AVA_FLAG_FD_VALID); m_NCS_UNLOCK(&cb->lock, NCS_LOCK_WRITE); /* This sel obj is no more used */ m_NCS_SEL_OBJ_DESTROY(cb->sel_obj); /* everything went off well.. store the cb hdl in the global variable */ gl_ava_hdl = cb->cb_hdl; TRACE_LEAVE(); return rc; error: if (cb) { /* remove the association with hdl-mngr */ if (cb->cb_hdl) ncshm_destroy_hdl(NCS_SERVICE_ID_AVA, cb->cb_hdl); /* delete the hdl db */ ava_hdl_del(cb); /* Flush the edu hdl */ m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); /* destroy the lock */ m_NCS_LOCK_DESTROY(&cb->lock); /* free the control block */ free(cb); } TRACE_LEAVE(); return rc; }
/**************************************************************************** Name : mqa_create Description : This routine creates & initializes the MQA control block. Arguments : create_info - ptr to the create info Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE Notes : None ******************************************************************************/ static uns32 mqa_create(NCS_LIB_CREATE *create_info) { MQA_CB *cb = &mqa_cb; uns32 rc = NCSCC_RC_SUCCESS; /* validate create info */ if (create_info == NULL) return NCSCC_RC_FAILURE; /* Register with Logging subsystem */ mqa_flx_log_reg(); memset(cb, 0, sizeof(MQA_CB)); /* assign the MQA pool-id (used by hdl-mngr) */ cb->pool_id = NCS_HM_POOL_ID_COMMON; /* create the association with hdl-mngr */ if (!(cb->agent_handle_id = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_MQA, (NCSCONTEXT)cb))) { m_LOG_MQSV_A(MQA_CREATE_HANDLE_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__); goto error1; } m_LOG_MQSV_A(MQA_CREATE_HANDLE_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, 1, __FILE__, __LINE__); /* everything went off well.. store the hdl in the global variable */ gl_mqa_hdl = cb->agent_handle_id; /* get the process id */ cb->process_id = getpid(); /* initialize the mqa cb lock */ if ((rc = m_NCS_LOCK_INIT(&cb->cb_lock)) != NCSCC_RC_SUCCESS) { m_LOG_MQSV_A(MQA_CB_LOCK_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__); goto error2; } m_LOG_MQSV_A(MQA_CB_LOCK_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__); /* initialize the client tree */ if ((rc = mqa_client_tree_init(cb)) != NCSCC_RC_SUCCESS) { m_LOG_MQSV_A(MQA_CLIENT_TREE_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__); goto error3; } m_LOG_MQSV_A(MQA_CLIENT_TREE_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__); /* initialize the queue tree */ if ((rc = mqa_queue_tree_init(cb)) != NCSCC_RC_SUCCESS) { m_LOG_MQSV_A(MQA_QUEUE_TREE_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__); goto error4; } m_LOG_MQSV_A(MQA_QUEUE_TREE_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__); /* EDU initialisation */ if ((rc = m_NCS_EDU_HDL_INIT(&cb->edu_hdl)) != NCSCC_RC_SUCCESS) { m_LOG_MQSV_A(MQA_EDU_HDL_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__); goto error5; } m_LOG_MQSV_A(MQA_EDU_HDL_INIT_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_NOTICE, rc, __FILE__, __LINE__); /* register with MDS */ if ((rc = mqa_mds_register(cb)) != NCSCC_RC_SUCCESS) { m_LOG_MQSV_A(MQA_MDS_REGISTER_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__); goto error6; } else m_LOG_MQSV_A(MQA_MDS_REGISTER_SUCCESS, NCSFL_LC_MQSV_INIT, NCSFL_SEV_INFO, rc, __FILE__, __LINE__); /* Update clm_node_joined flag to 1 */ cb->clm_node_joined = 1; mqa_sync_with_mqd(cb); mqa_sync_with_mqnd(cb); /* initialize the timeout linked list */ if ((rc = mqa_timer_table_init(cb)) != NCSCC_RC_SUCCESS) { m_LOG_MQSV_A(MQA_TIMER_TABLE_INIT_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__); goto error7; } if ((rc = mqa_asapi_register(cb)) != NCSCC_RC_SUCCESS) { m_LOG_MQSV_A(MQA_REGISTER_WITH_ASAPi_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__); goto error8; } return NCSCC_RC_SUCCESS; error8: mqa_timer_table_destroy(cb); error7: /* MDS unregister. */ mqa_mds_unregister(cb); error6: m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl); error5: /* delete the tree */ mqa_queue_tree_destroy(cb); error4: /* delete the tree */ mqa_client_tree_destroy(cb); error3: /* destroy the lock */ m_NCS_LOCK_DESTROY(&cb->cb_lock); error2: /* remove the association with hdl-mngr */ ncshm_destroy_hdl(NCS_SERVICE_ID_MQA, cb->agent_handle_id); error1: /* de register with the flex log */ mqa_flx_log_dereg(); return NCSCC_RC_FAILURE; }
/**************************************************************************** * 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; }