/***********************************************************************//**
* @brief This function is for PLMA to sync with PLMS when it gets
* MDS callback.
*
* @return Returns nothing.
***************************************************************************/
void plma_sync_with_plms()
{
PLMA_CB *cb = plma_ctrlblk;
TRACE_ENTER();
m_NCS_LOCK(&cb->cb_lock, NCS_LOCK_WRITE);
if (cb->plms_svc_up) {
TRACE("Plms is up");
m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);
return;
}
cb->plms_sync_awaited = true;
m_NCS_SEL_OBJ_CREATE(&cb->sel_obj);
m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);
/** Await indication from MDS saying PLMS is up */
osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(cb->sel_obj), 30000);
/* Destroy the sync - object */
m_NCS_LOCK(&cb->cb_lock, NCS_LOCK_WRITE);
cb->plms_sync_awaited = false;
m_NCS_SEL_OBJ_DESTROY(cb->sel_obj);
m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);
TRACE_LEAVE();
return;
}
/********************************************************************
Name : mqa_sync_with_mqnd
Description : This is for MQA to sync with MQND when it gets MDS callback
**********************************************************************/
static void mqa_sync_with_mqnd(MQA_CB *cb)
{
TRACE_ENTER();
m_NCS_LOCK(&cb->mqnd_sync_lock, NCS_LOCK_WRITE);
if (cb->is_mqnd_up) {
TRACE_1("MQND is already up with the MQA");
m_NCS_UNLOCK(&cb->mqnd_sync_lock, NCS_LOCK_WRITE);
return;
}
cb->mqnd_sync_awaited = true;
m_NCS_SEL_OBJ_CREATE(&cb->mqnd_sync_sel);
m_NCS_UNLOCK(&cb->mqnd_sync_lock, NCS_LOCK_WRITE);
/* Await indication from MDS saying MQND is up */
osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(cb->mqnd_sync_sel), 30000);
/* Destroy the sync - object */
m_NCS_LOCK(&cb->mqnd_sync_lock, NCS_LOCK_WRITE);
cb->mqnd_sync_awaited = false;
m_NCS_SEL_OBJ_DESTROY(cb->mqnd_sync_sel);
m_NCS_UNLOCK(&cb->mqnd_sync_lock, NCS_LOCK_WRITE);
TRACE_1("MQND synced up with the MQA");
TRACE_LEAVE();
return;
}
/********************************************************************
Name : cpa_sync_with_cpnd
Description : This is for CPA to sync with CPND when it gets MDS callback
**********************************************************************/
void cpa_sync_with_cpnd(CPA_CB *cb)
{
m_NCS_LOCK(&cb->cpnd_sync_lock, NCS_LOCK_WRITE);
if (cb->is_cpnd_up) {
m_NCS_UNLOCK(&cb->cpnd_sync_lock, NCS_LOCK_WRITE);
return;
}
cb->cpnd_sync_awaited = true;
m_NCS_SEL_OBJ_CREATE(&cb->cpnd_sync_sel);
m_NCS_UNLOCK(&cb->cpnd_sync_lock, NCS_LOCK_WRITE);
/* Await indication from MDS saying CPND is up */
osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(cb->cpnd_sync_sel), 30000);
/* Destroy the sync - object */
m_NCS_LOCK(&cb->cpnd_sync_lock, NCS_LOCK_WRITE);
cb->cpnd_sync_awaited = false;
m_NCS_SEL_OBJ_DESTROY(&cb->cpnd_sync_sel);
m_NCS_UNLOCK(&cb->cpnd_sync_lock, NCS_LOCK_WRITE);
return;
}
/***************************************************************************
* Name : plms_hrb
*
*
* Description : This thread forwards the HPI request sent from PLM to HPID
* This thread is spawned by PLM main task.It receives requests
* from PLM main thread through MDS and invokes appropriate
* HPI call
*
* Arguments :
* Return Values :
*****************************************************************************/
static void *plms_hrb(void)
{
PLMS_HRB_CB *cb = hrb_cb;
PLMS_HPI_REQ *hpi_req = NULL;
NCS_SEL_OBJ mbx_fd = m_NCS_IPC_GET_SEL_OBJ(&cb->mbx);
TRACE_ENTER();
/* Wait on condition variable for the HA role from PLMS main thread */
pthread_mutex_lock(&hrb_ha_state.mutex);
if(hrb_ha_state.state != SA_AMF_HA_ACTIVE){
TRACE("hrb waiting on cond variable for Active state");
pthread_cond_wait(&hrb_ha_state.cond,&hrb_ha_state.mutex);
}
pthread_mutex_unlock(&hrb_ha_state.mutex);
while (osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(mbx_fd), -1) != -1) {
/* process the Mail box */
/* Process messages delivered on mailbox */
while(NULL != (hpi_req =
(PLMS_HPI_REQ *)m_NCS_IPC_NON_BLK_RECEIVE(&cb->mbx,hpi_req))){
/*Process the received message*/
hrb_process_hpi_req(hpi_req);
if(hpi_req->entity_path)
free(hpi_req->entity_path);
free(hpi_req);
}
if(hrb_ha_state.state != SA_AMF_HA_ACTIVE){
/* Wait on condition variable for the HA role from
PLMS main thread */
LOG_NO("HRB:Received Standby state, thread going \
to block till Active state is set");
pthread_mutex_lock(&hrb_ha_state.mutex);
if(hrb_ha_state.state != SA_AMF_HA_ACTIVE){
TRACE("hrb waiting on cond variable for \
Active state");
pthread_cond_wait(&hrb_ha_state.cond,
&hrb_ha_state.mutex);
}
pthread_mutex_unlock(&hrb_ha_state.mutex);
}
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;
}
uint32_t mds_lib_req(NCS_LIB_REQ_INFO *req)
{
char *p_field = NULL;
uint32_t node_id = 0, cluster_id, mds_tipc_ref = 0; /* this mds tipc ref is random num part of the TIPC id */
uint32_t status = NCSCC_RC_SUCCESS;
NCS_SEL_OBJ destroy_ack_obj;
char *ptr;
switch (req->i_op) {
case NCS_LIB_REQ_CREATE:
mds_mutex_init_once();
osaf_mutex_lock_ordie(&gl_mds_library_mutex);
if (gl_mds_mcm_cb != NULL) {
syslog(LOG_ERR, "MDS_LIB_CREATE : MDS is already initialized");
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return NCSCC_RC_FAILURE;
}
/* Initialize mcm database */
mds_mcm_init();
/* Extract parameters from req and fill adest and pcon_id */
/* Get Node_id */
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv, "NODE_ID=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("NODE_ID="), "%d", &node_id) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in NODE_ID argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
/* Get Cluster_id */
p_field = NULL;
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv,
"CLUSTER_ID=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("CLUSTER_ID="), "%d", &cluster_id) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in CLUSTER_ID argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
/* Get tipc_mcast_enabled */
if ((ptr = getenv("MDS_TIPC_MCAST_ENABLED")) != NULL) {
tipc_mcast_enabled = atoi(ptr);
if (tipc_mcast_enabled != false)
tipc_mcast_enabled = true;
m_MDS_LOG_DBG("MDS_TIPC_MCAST_ENABLED: %d Set argument \n",tipc_mcast_enabled);
}
/* to use cluster id in mds prefix? */
/* Get gl_mds_log_level */
/* setting MDS_LOG_LEVEL from environment variable if given */
if ((ptr = getenv("MDS_LOG_LEVEL")) != NULL) {
gl_mds_log_level = atoi(ptr);
} else {
p_field = NULL;
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv,
"MDS_LOG_LEVEL=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("MDS_LOG_LEVEL="), "%d", &gl_mds_log_level) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in MDS_LOG_LEVEL argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
}
/* gl_mds_log_level consistency check */
if (gl_mds_log_level > 5 || gl_mds_log_level < 1) {
/* gl_mds_log_level specified is outside range so reset to Default = 3 */
gl_mds_log_level = 3;
}
/* Get gl_mds_checksum */
/* setting MDS_CHECKSUM from environment variable if given */
if ((ptr = getenv("MDS_CHECKSUM")) != NULL) {
gl_mds_checksum = atoi(ptr);
} else {
p_field = NULL;
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv,
"MDS_CHECKSUM=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("MDS_CHECKSUM="), "%d", &gl_mds_checksum) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in MDS_CHECKSUM argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
}
/* gl_mds_checksum consistency check */
if (gl_mds_checksum != 1) {
/* gl_mds_checksum specified is not 1 so reset to 0 */
gl_mds_checksum = 0;
}
/*****************************/
/* Timer value Configuration */
/*****************************/
/* Get Subscription timer value */
p_field = NULL;
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv,
"SUBSCRIPTION_TMR_VAL=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("SUBSCRIPTION_TMR_VAL="), "%d", &MDS_SUBSCRIPTION_TMR_VAL) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in SUBSCRIPTION_TMR_VAL argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
/* Get Await Active timer value */
p_field = NULL;
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv,
"AWAIT_ACTIVE_TMR_VAL=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("AWAIT_ACTIVE_TMR_VAL="), "%d", &MDS_AWAIT_ACTIVE_TMR_VAL) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in AWAIT_ACTIVE_TMR_VAL argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
/* Get Quiesced timer value */
p_field = NULL;
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv,
"QUIESCED_TMR_VAL=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("QUIESCED_TMR_VAL="), "%d", &MDS_QUIESCED_TMR_VAL) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in QUIESCED_TMR_VAL argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
/* Get Reassembly timer value */
p_field = NULL;
p_field = (char *)ncs_util_search_argv_list(req->info.create.argc, req->info.create.argv,
"REASSEMBLE_TMR_VAL=");
if (p_field != NULL) {
if (sscanf(p_field + strlen("REASSEMBLE_TMR_VAL="), "%d", &MDTM_REASSEMBLE_TMR_VAL) != 1) {
syslog(LOG_ERR, "MDS_LIB_CREATE : Problem in REASSEMBLE_TMR_VAL argument\n");
mds_mcm_destroy();
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
}
mds_init_transport();
/* Invoke MDTM-INIT. */
status = mds_mdtm_init(node_id, &mds_tipc_ref);
if (status != NCSCC_RC_SUCCESS) {
/* todo cleanup */
return NCSCC_RC_FAILURE;
}
gl_mds_mcm_cb->adest = m_MDS_GET_ADEST_FROM_NODE_ID_AND_PROCESS_ID(node_id, mds_tipc_ref);
get_adest_details(gl_mds_mcm_cb->adest, gl_mds_mcm_cb->adest_details);
/* Initialize logging */
{
char buff[50], pref[50];
snprintf(buff, sizeof(buff), PKGLOGDIR "/mds.log");
memset(pref, 0 ,sizeof(pref));
mds_log_init(buff, pref);
}
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
break;
case NCS_LIB_REQ_DESTROY:
/* STEP 1: Invoke MDTM-Destroy. */
/* mds_mdtm_destroy (); */
/* STEP 2: Destroy MCM-CB; */
/* ncs_patricia_tree_destroy(&gl_mds_mcm_cb->vdest_list); */
/* m_MMGR_FREE_MDS_CB(gl_mds_mcm_cb); */
m_NCS_SEL_OBJ_CREATE(&destroy_ack_obj);
/* Post a dummy message to MDS thread to guarantee that it
wakes up (and thereby sees the destroy_ind) */
if (mds_destroy_event(destroy_ack_obj) == NCSCC_RC_FAILURE) {
m_NCS_SEL_OBJ_DESTROY(&destroy_ack_obj);
return NCSCC_RC_FAILURE;
}
/* Wait for indication from MDS thread that it is ok to kill it */
osaf_poll_one_fd(m_GET_FD_FROM_SEL_OBJ(destroy_ack_obj), 70000); /* 70 seconds */
m_MDS_LOG_DBG("LIB_DESTROY:Destroy ack from MDS thread in 70 s");
/* Take the lock before killing the thread */
osaf_mutex_lock_ordie(&gl_mds_library_mutex);
/* Now two things have happened
(1) MDS thread has acked the destroy-event. So it will do no further things beyound
MDS unlock
(2) We have obtained MDS-Lock. So, even the un-lock by MDS thead is completed
Now we can proceed with the systematic destruction of MDS internal Data */
/* Free the objects related to destroy-indication. The destroy mailbox event
will be automatically freed by MDS processing or during MDS mailbox
destruction. Since we will be destroying the MDS-thread, the following
selection-object can no longer be accessed. Hence, it is safe and correct
to destroy it now */
m_NCS_SEL_OBJ_DESTROY(&destroy_ack_obj);
memset(&destroy_ack_obj, 0, sizeof(destroy_ack_obj)); /* Destroy info */
/* Sanity check */
if (gl_mds_mcm_cb == NULL) {
syslog(LOG_ERR, "MDS_LIB_DESTROY : MDS is already Destroyed");
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
return NCSCC_RC_FAILURE;
}
status = mds_mdtm_destroy();
if (status != NCSCC_RC_SUCCESS) {
/* todo anything? */
}
status = mds_mcm_destroy();
if (status != NCSCC_RC_SUCCESS) {
/* todo anything? */
}
/* Just Unlock the lock, Lock is never destroyed */
osaf_mutex_unlock_ordie(&gl_mds_library_mutex);
break;
default:
break;
}
return NCSCC_RC_SUCCESS;
}
