/****************************************************************************
Name : eda_find_subsc_validity
Description : This routine finds out whether the callback
is for valid subscriber or not .
Arguments : cb - ptr to the EDA control block
cbk_msg - ptr to the callback msg
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
static uns32 eda_find_subsc_validity(EDA_CB *cb, EDSV_MSG *cbk_msg)
{
EDA_CHANNEL_HDL_REC *chan_hdl_rec = NULL;
EDA_EVENT_HDL_REC *evt_hdl_rec = NULL;
EDSV_EDA_EVT_DELIVER_CBK_PARAM *evt_dlv_param = &cbk_msg->info.cbk_info.param.evt_deliver_cbk;
SaEvtEventHandleT eventHandle = evt_dlv_param->event_hdl;
/** Lookup the hdl rec
**/
/* retrieve event hdl record */
if (NULL == (evt_hdl_rec = (EDA_EVENT_HDL_REC *)ncshm_take_hdl(NCS_SERVICE_ID_EDA, eventHandle))) {
m_LOG_EDSV_A(EDA_FAILURE, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, eventHandle, __FILE__, __LINE__, 0);
return NCSCC_RC_FAILURE;
}
if (evt_hdl_rec->parent_chan) { /* Check if channel still exists */
if (evt_hdl_rec->parent_chan->channel_hdl) {
/* retrieve the eda channel hdl record */
if (NULL !=
(chan_hdl_rec =
(EDA_CHANNEL_HDL_REC *)ncshm_take_hdl(NCS_SERVICE_ID_EDA,
evt_hdl_rec->parent_chan->channel_hdl))) {
if (NULL != eda_find_subsc_by_subsc_id(chan_hdl_rec, evt_dlv_param->sub_id)) {
ncshm_give_hdl(eventHandle);
ncshm_give_hdl(chan_hdl_rec->channel_hdl);
return NCSCC_RC_SUCCESS;
} else {
if (chan_hdl_rec->subsc_list) {
ncshm_give_hdl(eventHandle);
ncshm_give_hdl(chan_hdl_rec->channel_hdl);
return NCSCC_RC_SUCCESS;
} else {
/** Lock EDA_CB synchronize access with MDS thread.
**/
m_NCS_LOCK(&cb->cb_lock, NCS_LOCK_WRITE);
/** Delete this evt record from the
** list of events
**/
if (NCSCC_RC_SUCCESS !=
eda_event_hdl_rec_del(&chan_hdl_rec->chan_event_anchor,
evt_hdl_rec)) {
ncshm_give_hdl(eventHandle);
}
m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);
ncshm_give_hdl(chan_hdl_rec->channel_hdl);
return NCSCC_RC_FAILURE;
}
}
}
}
}
ncshm_give_hdl(eventHandle);
return NCSCC_RC_FAILURE;
}
void print_resource_cb_info() {
GLND_CB *glnd_cb;
GLND_RESOURCE_INFO *glnd_rsc;
uint32_t res = NCSCC_RC_SUCCESS;
uint8_t *key=NULL;
printf("print_resource_cb_info %x\n",glnd_rsc);
glnd_cb = (GLND_CB*)ncshm_take_hdl(NCS_SERVICE_ID_GLND, gl_glnd_hdl);
if ( glnd_cb == NULL) {
printf(" GLND Startup failed ...\n");
return;
} else {
printf("GLND Startup Success ... %x\n",glnd_cb);
}
glnd_rsc=(GLND_RESOURCE_INFO *)ncs_patricia_tree_getnext(&glnd_cb->glnd_res_tree,(uint8_t *)0);
while(glnd_rsc != NULL) {
printf("\n********************************************\n");
printf("GLND RSC INFORMATION %x\n",glnd_rsc);
printf("GLND RSC ID %x\n",glnd_rsc->resource_id);
printf("GLND RSC NAME %s\n",glnd_rsc->resource_name.value);
printf("GLND RSC MASTER NODE_ID %d\n",glnd_rsc->master_mds_dest.node_id);
printf("Locks on this resource ...\n");
printf("\n********************************************\n");
key=(uint8_t *)&glnd_rsc->resource_id;
glnd_rsc=(GLND_RESOURCE_INFO *)ncs_patricia_tree_getnext(&glnd_cb->glnd_res_tree,key);
}
}
/****************************************************************************
* Name : eds_proc_quiesced_ack_evt
*
* Description : This is the function which is called when eds receives an
* quiesced ack event from MDS
*
* Arguments : evt - Message that was posted to the EDS Mail box.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t eds_proc_quiesced_ack_evt(EDSV_EDS_EVT *evt)
{
EDS_CB *cb;
TRACE_ENTER();
/* Retrieve the cb handle */
if (NULL == (cb = (EDS_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, evt->cb_hdl))) {
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
if (cb->is_quisced_set == true) {
cb->ha_state = SA_AMF_HA_QUIESCED;
/* Inform MBCSV of HA state change */
if (eds_mbcsv_change_HA_state(cb) != NCSCC_RC_SUCCESS) {
TRACE("EDS-MBCSV change role failed");
}
/* Update control block */
saAmfResponse(cb->amf_hdl, cb->amf_invocation_id, SA_AIS_OK);
cb->is_quisced_set = false;
/* Give the cb handle back */
ncshm_give_hdl(evt->cb_hdl);
} else {
TRACE("Quiesced set is false");
ncshm_give_hdl(evt->cb_hdl);
}
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
uint32_t tet_glnd_testcase_3(SaNameT rscName)
{
GLSV_GLD_EVT gld_evt;
uint32_t ret;
GLND_CB *glnd_cb=0;
glnd_cb = (GLND_CB *)ncshm_take_hdl(NCS_SERVICE_ID_GLND,gl_glnd_hdl);
if (!glnd_cb)
{
printf(" Unable to retrieve GLND_CB ..\n");
return NCSCC_RC_FAILURE;
}
memset(&gld_evt,0,sizeof(GLSV_GLD_EVT));
gld_evt.evt_type = GLSV_GLD_EVT_RSC_OPEN;
memcpy(&gld_evt.info.rsc_open_info.rsc_name, \
&rscName,sizeof(SaNameT));
ret=glnd_mds_msg_send_gld(glnd_cb,&gld_evt,glnd_cb->gld_mdest_id);
if ( ret != NCSCC_RC_SUCCESS) {
printf(" Unable to send GLSV_GLD_EVT_RSC_OPEN message \n");
}
}
/****************************************************************************
* Name : cpnd_saf_health_chk_callback
*
* Description : This function SAF callback function which will be called
* when the AMF framework needs to health for the component.
*
* Arguments : invocation - This parameter designated a particular
* invocation of this callback function. The
* invoke process return invocation when it
* responds to the Availability Management
* FrameWork using the saAmfResponse()
* function.
* compName - A pointer to the name of the component
* whose readiness stae the Availability
* Management Framework is setting.
* checkType - The type of healthcheck to be executed.
*
* Return Values : None
*
* Notes : At present we are just support a simple liveness check.
*****************************************************************************/
void
cpnd_saf_health_chk_callback(SaInvocationT invocation, const SaNameT *compName, const SaAmfHealthcheckKeyT *checkType)
{
CPND_CB *cpnd_cb = NULL;
SaAisErrorT error = SA_AIS_OK;
uns32 cb_hdl = m_CPND_GET_CB_HDL;
/* Get the CB from the handle */
cpnd_cb = ncshm_take_hdl(NCS_SERVICE_ID_CPND, cb_hdl);
if (!cpnd_cb) {
m_LOG_CPND_CL(CPND_CB_HDL_TAKE_FAILED, CPND_FC_HDLN, NCSFL_SEV_ERROR, __FILE__, __LINE__);
return;
}
if (saAmfResponse(cpnd_cb->amf_hdl, invocation, error) != SA_AIS_OK) {
m_LOG_CPND_CL(CPND_AMF_RESPONSE_FAILED, CPND_FC_HDLN, NCSFL_SEV_ERROR, __FILE__, __LINE__);
ncshm_give_hdl(cb_hdl);
return;
}
/* giveup the handle */
ncshm_give_hdl(cb_hdl);
return;
}
/****************************************************************************
* Name : eds_process_evt
*
* Description : This is the function which is called when eds receives an
* event of any kind.
*
* Arguments : msg - Message that was posted to the EDS Mail box.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
uint32_t eds_process_evt(EDSV_EDS_EVT *evt)
{
EDS_CB *cb;
TRACE_ENTER();
/* Retrieve the cb handle */
if (NULL == (cb = (EDS_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, evt->cb_hdl))) {
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
if (cb->ha_state == SA_AMF_HA_ACTIVE) {
if ((evt->evt_type >= EDSV_EDS_EVT_BASE) && (evt->evt_type <= EDSV_EDS_RET_TIMER_EXP)) {
/** Invoke the evt dispatcher **/
eds_edsv_top_level_evt_dispatch_tbl[evt->evt_type] (evt);
} else if (evt->evt_type == EDSV_EVT_QUIESCED_ACK) {
eds_proc_quiesced_ack_evt(evt);
} else
TRACE("Event processing failed");
} else {
if ((evt->evt_type == EDSV_EDS_RET_TIMER_EXP) || (evt->evt_type == EDSV_EDS_EVT_EDA_DOWN))
/** Invoke the evt dispatcher **/
eds_edsv_top_level_evt_dispatch_tbl[evt->evt_type] (evt);
}
ncshm_give_hdl(evt->cb_hdl);
/* Free the event */
if (NULL != evt)
eds_evt_destroy(evt);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
static uint32_t eds_proc_eda_api_msg(EDSV_EDS_EVT *evt)
{
EDS_CB *cb;
TRACE_ENTER();
if ((evt->info.msg.info.api_info.type >= EDSV_API_BASE_MSG) &&
(evt->info.msg.info.api_info.type < EDSV_API_MAX)) {
/* Retrieve the cb handle */
if (NULL == (cb = (EDS_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, evt->cb_hdl))) {
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
if (eds_eda_api_msg_dispatcher[evt->info.msg.info.api_info.type] (cb, evt) != NCSCC_RC_SUCCESS) {
ncshm_give_hdl(evt->cb_hdl);
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
/* Give the cb handle back */
ncshm_give_hdl(evt->cb_hdl);
} else
LOG_ER("Invalid API event received from agent dest %" PRIx64, evt->fr_dest);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : eda_destroy
Description : This routine destroys the EDA control block.
Arguments : destroy_info - ptr to the destroy info
Return Values : None
Notes : None
******************************************************************************/
void eda_destroy(NCS_LIB_DESTROY *destroy_info)
{
EDA_CB *cb = 0;
TRACE_ENTER();
/* retrieve EDA CB */
cb = (EDA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDA, gl_eda_hdl);
if (!cb) {
TRACE_LEAVE2("global take handle failed: %u", gl_eda_hdl);
return;
}
/* delete the hdl db */
eda_hdl_list_del(&cb->eda_init_rec_list);
/* unregister with MDS */
eda_mds_finalize(cb);
/* destroy the lock */
m_NCS_LOCK_DESTROY(&cb->cb_lock);
/* return EDA CB */
ncshm_give_hdl(gl_eda_hdl);
/* remove the association with hdl-mngr */
ncshm_destroy_hdl(NCS_SERVICE_ID_EDA, cb->cb_hdl);
/* free the control block */
m_MMGR_FREE_EDA_CB(cb);
/* reset the global cb handle */
gl_eda_hdl = 0;
TRACE_LEAVE();
return;
}
/*****************************************************************************
PROCEDURE NAME : glnd_resource_req_node_del
DESCRIPTION : deletes the Resource request node
ARGUMENTS :glnd_cb - ptr to the GLND control block
RETURNS :The pointer to the resource req node info on success.
else returns NULL.
NOTES : Delete the returned pointer immediately.
*****************************************************************************/
void glnd_resource_req_node_del(GLND_CB *glnd_cb, uint32_t res_req_hdl)
{
GLND_RESOURCE_REQ_LIST *res_req_info;
res_req_info = (GLND_RESOURCE_REQ_LIST *)ncshm_take_hdl(NCS_SERVICE_ID_GLND, res_req_hdl);
if (res_req_info != NULL) {
/* delete it from the list and return the pointer */
if (glnd_cb->res_req_list == res_req_info)
glnd_cb->res_req_list = glnd_cb->res_req_list->next;
if (res_req_info->prev)
res_req_info->prev->next = res_req_info->next;
if (res_req_info->next)
res_req_info->next->prev = res_req_info->prev;
glnd_stop_tmr(&res_req_info->timeout);
ncshm_give_hdl(res_req_hdl);
/* destroy the handle */
ncshm_destroy_hdl(NCS_SERVICE_ID_GLND, res_req_info->res_req_hdl_id);
/* free the memory */
m_MMGR_FREE_GLND_RESOURCE_REQ_LIST(res_req_info);
}
return;
}
/****************************************************************************
* Name : eds_se_lib_destroy
*
* Description : Invoked to destroy the EDS
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
static uint32_t eds_se_lib_destroy(NCS_LIB_REQ_INFO *req_info)
{
/** Code to destroy the EDS **/
EDS_CB *eds_cb;
m_INIT_CRITICAL;
TRACE_ENTER();
if (NULL == (eds_cb = (NCSCONTEXT)ncshm_take_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl))) {
LOG_ER("Handle take failed for global handle");
TRACE_LEAVE();
return (NCSCC_RC_FAILURE);
} else {
m_START_CRITICAL;
/** Lock EDA_CB
**/
m_NCS_LOCK(&eds_cb->cb_lock, NCS_LOCK_WRITE);
/* deregister from AMF */
saAmfComponentUnregister(eds_cb->amf_hdl, &eds_cb->comp_name, NULL);
/* End association from the AMF lib */
saAmfFinalize(eds_cb->amf_hdl);
/* Finalize with CLM */
saClmFinalize(eds_cb->clm_hdl);
/* Clean up all internal structures */
eds_remove_reglist_entry(eds_cb, 0, true);
/* Destroy the cb */
eds_cb_destroy(eds_cb);
/* Give back the handle */
ncshm_give_hdl(gl_eds_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_GLD, gl_eds_hdl);
/* Detach from IPC */
m_NCS_IPC_DETACH(&eds_cb->mbx, eds_clear_mbx, eds_cb);
/* Disconnect from MDS */
eds_mds_finalize(eds_cb);
/* Release the IPC */
m_NCS_IPC_RELEASE(&eds_cb->mbx, NULL);
/** UnLock EDA_CB
**/
m_NCS_UNLOCK(&eds_cb->cb_lock, NCS_LOCK_WRITE);
m_NCS_LOCK_DESTROY(&eds_cb->cb_lock);
m_MMGR_FREE_EDS_CB(eds_cb);
gl_eds_hdl = 0;
m_END_CRITICAL;
TRACE("eds-cb-lib destroy done .");
}
TRACE_LEAVE();
return (NCSCC_RC_SUCCESS);
}
/****************************************************************************
Name : mqnd_mds_callback
Description : This callback routine will be called by MDS on event arrival
Arguments : info - pointer to the mds callback info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
static uns32 mqnd_mds_callback(struct ncsmds_callback_info *info)
{
MQND_CB *cb = NULL;
uns32 rc = NCSCC_RC_SUCCESS;
if (info == NULL) {
rc = NCSCC_RC_FAILURE;
return rc;
}
cb = (MQND_CB *)ncshm_take_hdl(NCS_SERVICE_ID_MQND, (uns32)info->i_yr_svc_hdl);
if (!cb) {
rc = NCSCC_RC_FAILURE;
m_LOG_MQSV_ND(MQND_CB_HDL_TAKE_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
return rc;
}
switch (info->i_op) {
case MDS_CALLBACK_COPY:
mqnd_mds_cpy(cb, &info->info.cpy);
break;
case MDS_CALLBACK_ENC:
rc = mqnd_mds_enc(cb, &info->info.enc);
break;
case MDS_CALLBACK_DEC:
rc = mqnd_mds_dec(cb, &info->info.dec);
break;
case MDS_CALLBACK_ENC_FLAT:
rc = mqnd_mds_enc(cb, &info->info.enc_flat);
break;
case MDS_CALLBACK_DEC_FLAT:
rc = mqnd_mds_dec(cb, &info->info.dec_flat);
break;
case MDS_CALLBACK_RECEIVE:
rc = mqnd_mds_rcv(cb, &info->info.receive);
break;
case MDS_CALLBACK_SVC_EVENT:
rc = mqnd_mds_svc_evt(cb, &info->info.svc_evt);
break;
case MDS_CALLBACK_DIRECT_RECEIVE:
rc = mqnd_mds_direct_rcv(cb, &info->info.direct_receive);
break;
default:
rc = NCSCC_RC_FAILURE;
break;
}
if (rc == NCSCC_RC_SUCCESS)
m_LOG_MQSV_ND(MQND_MDS_CLBK_COMPLETE, NCSFL_LC_MQSV_INIT, NCSFL_SEV_INFO, info->i_op, __FILE__,
__LINE__);
else
m_LOG_MQSV_ND(MQND_MDS_CLBK_COMPLETE, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, info->i_op, __FILE__,
__LINE__);
ncshm_give_hdl((uns32)info->i_yr_svc_hdl);
return rc;
}
/****************************************************************************
Name : cpa_mds_callback
Description : This callback routine will be called by MDS on event arrival
Arguments : info - pointer to the mds callback info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 cpa_mds_callback(struct ncsmds_callback_info *info)
{
CPA_CB *cpa_cb = NULL;
uns32 rc = NCSCC_RC_FAILURE;
if (info == NULL)
return rc;
cpa_cb = (CPA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_CPA, gl_cpa_hdl);
if (!cpa_cb) {
m_LOG_CPA_CCLL(CPA_PROC_FAILED, NCSFL_LC_CKPT_MGMT, NCSFL_SEV_ERROR, "mds_callback:HDL_TAKE", __FILE__,
__LINE__, rc);
return m_LEAP_DBG_SINK(rc);
}
switch (info->i_op) {
case MDS_CALLBACK_COPY:
rc = NCSCC_RC_FAILURE;
break;
case MDS_CALLBACK_ENC_FLAT:
rc = cpa_mds_enc_flat(cpa_cb, &info->info.enc_flat);
break;
case MDS_CALLBACK_DEC_FLAT:
rc = cpa_mds_dec_flat(cpa_cb, &info->info.dec_flat);
break;
case MDS_CALLBACK_RECEIVE:
rc = cpa_mds_rcv(cpa_cb, &info->info.receive);
break;
case MDS_CALLBACK_SVC_EVENT:
rc = cpa_mds_svc_evt(cpa_cb, &info->info.svc_evt);
break;
case MDS_CALLBACK_ENC:
rc = cpa_mds_enc(cpa_cb, &info->info.enc);
break;
case MDS_CALLBACK_DEC:
rc = cpa_mds_dec(cpa_cb, &info->info.dec);
break;
default:
m_LOG_CPA_CCLL(CPA_PROC_FAILED, NCSFL_LC_CKPT_MGMT, NCSFL_SEV_INFO, "mds_callback:unknown_op", __FILE__,
__LINE__, rc);
break;
}
if (rc != NCSCC_RC_SUCCESS) {
m_LOG_CPA_CCLL(CPA_PROC_FAILED, NCSFL_LC_CKPT_MGMT, NCSFL_SEV_INFO, "mds_callback", __FILE__, __LINE__,
rc);
}
ncshm_give_hdl(gl_cpa_hdl);
return rc;
}
/****************************************************************************
* Name : eds_proc_ret_tmr_exp_evt
*
* Description : This is the function which is called when eds receives any
* a retention tmr expiry evt
*
* Arguments : evt - Evt that was posted to the EDS Mail box.
*
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t eds_proc_ret_tmr_exp_evt(EDSV_EDS_EVT *evt)
{
EDS_RETAINED_EVT_REC *ret_evt;
uint32_t rc = NCSCC_RC_SUCCESS;
EDS_CB *eds_cb;
TRACE_ENTER();
/* retrieve retained evt */
if (NULL == (eds_cb = (EDS_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, evt->cb_hdl))) {
TRACE_LEAVE2("take handle failed for cb");
return NCSCC_RC_FAILURE;
}
/* retrieve retained evt */
if (NULL == (ret_evt = (EDS_RETAINED_EVT_REC *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, evt->info.tmr_info.opq_hdl))) {
TRACE_LEAVE2("take handle failed for retained evt rec.");
return NCSCC_RC_FAILURE;
}
m_NCS_LOCK(&eds_cb->cb_lock, NCS_LOCK_WRITE);
/** store the chan id as we would need it
** after the event is freed
**/
/* CHECKPOINT:
if ( EDS_CB->ha_state == standby)
compose a EDSV_CKPT_RETENTION_TIME_CLEAR_MSG and send to standby peer.
*/
/** This also frees the event **/
rc = eds_clear_retained_event(eds_cb,
ret_evt->chan_id, ret_evt->retd_evt_chan_open_id, ret_evt->event_id, true);
m_NCS_UNLOCK(&eds_cb->cb_lock, NCS_LOCK_WRITE);
if (NCSCC_RC_SUCCESS != rc) {
ncshm_give_hdl(evt->info.tmr_info.opq_hdl);
ncshm_give_hdl(evt->cb_hdl);
TRACE_LEAVE();
return rc;
}
ncshm_give_hdl(evt->cb_hdl);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : ava_hdl_cbk_dispatch_one
Description : This routine dispatches one pending callback.
Arguments : cb - ptr to the AvA control block
hdl_rec - ptr to the handle record
Return Values : SA_AIS_OK/SA_AIS_ERR_<CODE>
Notes : None.
******************************************************************************/
uint32_t ava_hdl_cbk_dispatch_one(AVA_CB **cb, AVA_HDL_REC **hdl_rec)
{
AVA_PEND_RESP *list_resp = &(*hdl_rec)->pend_resp;
AVA_PEND_CBK_REC *rec = 0;
uint32_t hdl = (*hdl_rec)->hdl;
SaAmfCallbacksT reg_cbk;
uint32_t rc = SA_AIS_OK;
TRACE_ENTER();
memset(®_cbk, 0, sizeof(SaAmfCallbacksT));
memcpy(®_cbk, &(*hdl_rec)->reg_cbk, sizeof(SaAmfCallbacksT));
/* pop the rec from the mailbox queue */
rec = (AVA_PEND_CBK_REC *)m_NCS_IPC_NON_BLK_RECEIVE(&(*hdl_rec)->callbk_mbx, NULL);
if (rec) {
if (rec->cbk_info->type != AVSV_AMF_PG_TRACK) {
/* push this record into pending response list */
m_AVA_HDL_PEND_RESP_PUSH(list_resp, (AVA_PEND_RESP_REC *)rec);
m_AVA_HDL_CBK_REC_IN_DISPATCH_SET(rec);
}
/* release the cb lock & return the hdls to the hdl-mngr */
m_NCS_UNLOCK(&(*cb)->lock, NCS_LOCK_WRITE);
ncshm_give_hdl(hdl);
/* process the callback list record */
ava_hdl_cbk_rec_prc(rec->cbk_info, ®_cbk);
m_NCS_LOCK(&(*cb)->lock, NCS_LOCK_WRITE);
if (0 == (*hdl_rec = ncshm_take_hdl(NCS_SERVICE_ID_AVA, hdl))) {
/* hdl is already finalized */
ava_hdl_cbk_rec_del(rec);
TRACE_LEAVE2("Handle is already finalized");
return rc;
}
/* if we are done with this rec, free it */
if ((rec->cbk_info->type != AVSV_AMF_PG_TRACK) && m_AVA_HDL_IS_CBK_RESP_DONE(rec)) {
m_AVA_HDL_PEND_RESP_POP(list_resp, rec, rec->cbk_info->inv);
ava_hdl_cbk_rec_del(rec);
} else if (rec->cbk_info->type == AVSV_AMF_PG_TRACK) {
/* PG Track cbk do not have any response */
ava_hdl_cbk_rec_del(rec);
} else {
m_AVA_HDL_CBK_REC_IN_DISPATCH_RESET(rec);
}
}
else
TRACE_3("No record to process the dispatch()");
TRACE_LEAVE();
return rc;
}
/****************************************************************************
* Name : glsv_gld_standby_rsc_close
*
* Description : This is the function is invoked when a rsc_close event is
* is sent from avtive GLD to standby GLD. This function will
* remove references to
* to this resource from the mentioned node. If the resource
* is not referred any longer then the data structures are freed
* up.
*
* Arguments : async_evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t glsv_gld_standby_rsc_close(GLSV_GLD_A2S_CKPT_EVT *async_evt)
{
GLSV_GLD_CB *gld_cb;
GLSV_GLD_GLND_DETAILS *node_details;
GLSV_GLD_GLND_RSC_REF *glnd_rsc;
bool orphan_flag;
uint32_t node_id;
uint32_t rc = NCSCC_RC_FAILURE;
TRACE_ENTER();
if (async_evt == NULL)
goto end;
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(async_evt->info.rsc_details.mdest_id);
if ((gld_cb = (NCSCONTEXT)ncshm_take_hdl(NCS_SERVICE_ID_GLD, gl_gld_hdl))
== NULL) {
LOG_ER("Handle take failed");
goto end;
}
orphan_flag = async_evt->info.rsc_details.orphan;
/* Find if the node details are available */
if ((node_details =
(GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details, (uint8_t *)&node_id)) == NULL) {
LOG_ER("Patricia tree get failed: node_id %u", node_id);
goto error;
}
glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_get(&node_details->rsc_info_tree,
(uint8_t *)&async_evt->info.rsc_details.rsc_id);
if (glnd_rsc == NULL) {
LOG_ER("Patricia tree get failed");
goto error;
}
glnd_rsc->rsc_info->saf_rsc_no_of_users = glnd_rsc->rsc_info->saf_rsc_no_of_users - 1;
if (async_evt->info.rsc_details.lcl_ref_cnt == 0)
gld_rsc_rmv_node_ref(gld_cb, glnd_rsc->rsc_info, glnd_rsc, node_details, orphan_flag);
TRACE_1("GLD a2s evt rsc close success: rsc_id %u node_id %u",
async_evt->info.rsc_details.rsc_id, node_id);
ncshm_give_hdl(gld_cb->my_hdl);
rc = NCSCC_RC_SUCCESS;
goto end;
error:
LOG_ER("GLD a2s evt rsc close failed: rsc_id %u node_id %u",
async_evt->info.rsc_details.rsc_id, node_id);
ncshm_give_hdl(gld_cb->my_hdl);
end:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
* Name : glsv_gld_glnd_operational
*
* Description : MDS indicated that a glnd has gone down
*
* Arguments : async_evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t glsv_gld_standby_glnd_operational(GLSV_GLD_A2S_CKPT_EVT *async_evt)
{
GLSV_GLD_CB *gld_cb = NULL;
GLSV_GLD_GLND_DETAILS *node_details = NULL;
GLSV_GLD_RSC_INFO *rsc_info = NULL;
GLSV_NODE_LIST *node_list = NULL;
uint32_t node_id;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
if (async_evt == NULL) {
rc = NCSCC_RC_FAILURE;
goto end;
}
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(async_evt->info.glnd_mds_info.mdest_id);
if ((gld_cb = (NCSCONTEXT)ncshm_take_hdl(NCS_SERVICE_ID_GLD, gl_gld_hdl))
== NULL) {
LOG_ER("Handle take failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
if ((node_details = (GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details,
(uint8_t *)&node_id)) != NULL) {
memcpy(&node_details->dest_id, &async_evt->info.glnd_mds_info.mdest_id, sizeof(MDS_DEST));
/* Cancel the restart timer if started */
gld_stop_tmr(&node_details->restart_timer);
node_details->status = GLND_OPERATIONAL_STATE;
rsc_info = gld_cb->rsc_info;
while (rsc_info != NULL) {
node_list = rsc_info->node_list;
while (node_list != NULL) {
if (node_list->node_id == node_id) {
memcpy(&node_list->dest_id, &async_evt->info.glnd_mds_info.mdest_id,
sizeof(MDS_DEST));
}
node_list = node_list->next;
}
rsc_info = rsc_info->next;
}
}
ncshm_give_hdl(gld_cb->my_hdl);
end:
TRACE_LEAVE();
return rc;
}
void print_glnd_cb() {
GLND_CB *cb;
GLSV_GLND_EVT *glnd_evt;
glnd_evt = m_MMGR_ALLOC_GLND_EVT;
memset(glnd_evt,0,sizeof(GLSV_GLND_EVT));
glnd_evt->type = GLSV_GLND_EVT_CB_DUMP;
cb = (GLND_CB*)ncshm_take_hdl(NCS_SERVICE_ID_GLND, m_GLND_RETRIEVE_GLND_CB_HDL);
glnd_evt->glnd_hdl = cb->cb_hdl_id;
m_NCS_IPC_SEND(&cb->glnd_mbx, glnd_evt, MDS_SEND_PRIORITY_MEDIUM);
ncshm_give_hdl(gl_glnd_hdl);
}
/****************************************************************************
* Name : cpd_amf_comp_terminate_callback
*
* Description : This function SAF callback function which will be called
* when the AMF framework needs to terminate GLSV. This does
* all required to destroy GLSV(except to unregister from AMF)
*
* Arguments : invocation - This parameter designated a particular
* invocation of this callback function. The
* invoke process return invocation when it
* responds to the Avilability Management
* FrameWork using the saAmfResponse()
* function.
* compName - A pointer to the name of the component
* whose readiness stae the Availability
* Management Framework is setting.
*
* Return Values : None
*
* Notes : At present we are just support a simple liveness check.
*****************************************************************************/
void cpd_amf_comp_terminate_callback(SaInvocationT invocation, const SaNameT *compName)
{
CPD_CB *cb = 0;
SaAisErrorT saErr = SA_AIS_OK;
TRACE_ENTER();
cb = ncshm_take_hdl(NCS_SERVICE_ID_CPD, gl_cpd_cb_hdl);
if (cb) {
saAmfResponse(cb->amf_hdl, invocation, saErr);
ncshm_give_hdl(cb->cpd_hdl);
}
LOG_NO("Received AMF component terminate callback, exiting");
TRACE_LEAVE();
exit(0);
}
/*****************************************************************************
PROCEDURE NAME : eds_tmr_exp
DESCRIPTION : EDS timer expiry callback routine.It sends corresponding
timer events to EDS.
ARGUMENTS : uarg - ptr to the EDS timer block
RETURNS : void
NOTES : None
*****************************************************************************/
void eds_tmr_exp(void *uarg)
{
EDS_CB *eds_cb = 0;
EDS_TMR *tmr = (EDS_TMR *)uarg;
EDSV_EDS_EVT *evt = 0;
uns32 temp_tmr_hdl;
temp_tmr_hdl = tmr->cb_hdl;
/* retrieve EDS CB */
if (NULL == (eds_cb = (EDS_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, tmr->cb_hdl))) {
m_LOG_EDSV_S(EDS_CB_TAKE_HANDLE_FAILED, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__, 0);
return;
}
if (tmr->is_active) {
tmr->is_active = FALSE;
/* Destroy the timer if it exists.. */
if (tmr->tmr_id != TMR_T_NULL) {
m_NCS_TMR_DESTROY(tmr->tmr_id);
tmr->tmr_id = TMR_T_NULL;
}
/* create & send the timer event */
evt = m_MMGR_ALLOC_EDSV_EDS_EVT;
if (evt) {
memset(evt, '\0', sizeof(EDSV_EDS_EVT));
/* assign the timer evt */
evt->evt_type = eds_tmr_evt_map(tmr->type);
evt->info.tmr_info.opq_hdl = tmr->opq_hdl;
evt->cb_hdl = tmr->cb_hdl;
if (NCSCC_RC_FAILURE == m_NCS_IPC_SEND(&eds_cb->mbx, evt, NCS_IPC_PRIORITY_HIGH)) {
m_LOG_EDSV_S(EDS_TIMER_STOP_FAIL, NCSFL_LC_EDSV_INIT, NCSFL_SEV_ERROR, evt->cb_hdl,
__FILE__, __LINE__, evt->evt_type);
eds_evt_destroy(evt);
}
}
}
/* return EDS CB */
ncshm_give_hdl(temp_tmr_hdl);
return;
}
/****************************************************************************
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;
}
/****************************************************************************
PROCEDURE NAME : cpd_saf_hlth_chk_cb
DESCRIPTION : This function SAF callback function which will be called
when the AMF framework needs to health for the component.
ARGUMENTS : invocation - This parameter designated a particular
invocation of this callback function. The
invoke process return invocation when it
responds to the Avilability Management
FrameWork using the saAmfResponse()
function.
compName - A pointer to the name of the component
whose readiness stae the Availability
Management Framework is setting.
checkType - The type of healthcheck to be executed.
RETURNS : None
NOTES : At present we are just support a simple liveness check.
*****************************************************************************/
void cpd_saf_hlth_chk_cb(SaInvocationT invocation, const SaNameT *compName, SaAmfHealthcheckKeyT *checkType)
{
CPD_CB *cb = 0;
SaAisErrorT saErr = SA_AIS_OK;
/* Get the COntrol Block Pointer */
cb = ncshm_take_hdl(NCS_SERVICE_ID_CPD, gl_cpd_cb_hdl);
if (cb) {
saAmfResponse(cb->amf_hdl, invocation, saErr);
ncshm_give_hdl(cb->cpd_hdl);
} else {
LOG_ER("Failed to retrieve cpd handle %u",gl_cpd_cb_hdl);
}
return;
} /* End of cpd_saf_hlth_chk_cb() */
/*****************************************************************************
PROCEDURE NAME : eds_tmr_exp
DESCRIPTION : EDS timer expiry callback routine.It sends corresponding
timer events to EDS.
ARGUMENTS : uarg - ptr to the EDS timer block
RETURNS : void
NOTES : None
*****************************************************************************/
void eds_tmr_exp(void *uarg)
{
EDS_CB *eds_cb = 0;
EDS_TMR *tmr = (EDS_TMR *)uarg;
EDSV_EDS_EVT *evt = 0;
uint32_t temp_tmr_hdl;
temp_tmr_hdl = tmr->cb_hdl;
/* retrieve EDS CB */
if (NULL == (eds_cb = (EDS_CB *)ncshm_take_hdl(NCS_SERVICE_ID_EDS, tmr->cb_hdl))) {
LOG_ER("Global take handle failed");
return;
}
if (tmr->is_active) {
tmr->is_active = false;
/* Destroy the timer if it exists.. */
if (tmr->tmr_id != TMR_T_NULL) {
m_NCS_TMR_DESTROY(tmr->tmr_id);
tmr->tmr_id = TMR_T_NULL;
}
/* create & send the timer event */
evt = m_MMGR_ALLOC_EDSV_EDS_EVT;
if (evt) {
memset(evt, '\0', sizeof(EDSV_EDS_EVT));
/* assign the timer evt */
evt->evt_type = eds_tmr_evt_map(tmr->type);
evt->info.tmr_info.opq_hdl = tmr->opq_hdl;
evt->cb_hdl = tmr->cb_hdl;
if (NCSCC_RC_FAILURE == m_NCS_IPC_SEND(&eds_cb->mbx, evt, NCS_IPC_PRIORITY_HIGH)) {
LOG_ER("IPC send failed for timer event");
eds_evt_destroy(evt);
}
}
}
/* return EDS CB */
ncshm_give_hdl(temp_tmr_hdl);
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 : avnd_evt_tmr_su_err_esc
Description : This routine handles the the expiry of the 'su error
escalation' timer. It indicates the end of the comp/su
restart probation period for the SU.
Arguments : cb - ptr to the AvND control block
evt - ptr to the AvND event
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_evt_tmr_su_err_esc_evh(AVND_CB *cb, AVND_EVT *evt)
{
AVND_SU *su;
uns32 rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* retrieve avnd cb */
if (0 == (su = (AVND_SU *)ncshm_take_hdl(NCS_SERVICE_ID_AVND, (uns32)evt->info.tmr.opq_hdl))) {
LOG_CR("Unable to retrieve handle");
goto done;
}
TRACE("'%s'", su->name.value);
if (NCSCC_RC_SUCCESS == m_AVND_CHECK_FOR_STDBY_FOR_EXT_COMP(cb, su->su_is_external))
goto done;
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_ERR_ESC_TMR);
switch (su->su_err_esc_level) {
case AVND_ERR_ESC_LEVEL_0:
su->comp_restart_cnt = 0;
su->su_err_esc_level = AVND_ERR_ESC_LEVEL_0;
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_COMP_RESTART_CNT);
break;
case AVND_ERR_ESC_LEVEL_1:
su->su_restart_cnt = 0;
su->su_err_esc_level = AVND_ERR_ESC_LEVEL_0;
cb->node_err_esc_level = AVND_ERR_ESC_LEVEL_0;
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_RESTART_CNT);
break;
case AVND_ERR_ESC_LEVEL_2:
cb->su_failover_cnt = 0;
su->su_err_esc_level = AVND_ERR_ESC_LEVEL_0;
cb->node_err_esc_level = AVND_ERR_ESC_LEVEL_0;
break;
default:
assert(0);
}
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_ERR_ESC_LEVEL);
done:
if (su)
ncshm_give_hdl((uns32)evt->info.tmr.opq_hdl);
TRACE_LEAVE();
return rc;
}
/*****************************************************************************
PROCEDURE NAME : gld_tmr_exp
DESCRIPTION : GLD timer expiry callback routine.It sends corresponding
timer events to GLD.
ARGUMENTS : uarg - ptr to the GLD timer block
RETURNS : void
NOTES : None
*****************************************************************************/
void gld_tmr_exp(void *uarg)
{
GLSV_GLD_CB *cb = 0;
GLD_TMR *tmr = (GLD_TMR *)uarg;
GLSV_GLD_EVT *evt = 0;
uns32 cb_hdl;
cb_hdl = tmr->cb_hdl;
/* retrieve GLD CB */
cb = (GLSV_GLD_CB *)ncshm_take_hdl(NCS_SERVICE_ID_GLD, tmr->cb_hdl);
if (!cb) {
m_LOG_GLD_HEADLINE(GLD_TAKE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
return;
}
tmr->is_active = FALSE;
/* create & send the timer event */
evt = m_MMGR_ALLOC_GLSV_GLD_EVT;
if (evt == GLSV_GLD_EVT_NULL) {
m_LOG_GLD_MEMFAIL(GLD_EVT_ALLOC_FAILED, __FILE__, __LINE__);
ncshm_give_hdl(cb_hdl);
return;
}
memset(evt, 0, sizeof(GLSV_GLD_EVT));
if (evt) {
/* assign the timer evt */
evt->evt_type = gld_tmr_evt_map(tmr->type);
evt->info.tmr.opq_hdl = tmr->opq_hdl;
evt->info.tmr.resource_id = tmr->resource_id;
memcpy(&evt->info.tmr.mdest_id, &tmr->mdest_id, sizeof(MDS_DEST));
evt->gld_cb = cb;
/* Push the event and we are done */
if (m_NCS_IPC_SEND(&cb->mbx, evt, NCS_IPC_PRIORITY_NORMAL) == NCSCC_RC_FAILURE) {
m_LOG_GLD_HEADLINE(GLD_IPC_SEND_FAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
gld_evt_destroy(evt);
ncshm_give_hdl(cb_hdl);
return;
}
}
/* return GLD CB */
ncshm_give_hdl(cb_hdl);
return;
}
/****************************************************************************
* Name : glsv_gld_standby_rsc_set_orphan
*
* Description : Instruction from the GLND to set the orphan flag
*
* Arguments : async_evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t glsv_gld_standby_rsc_set_orphan(GLSV_GLD_A2S_CKPT_EVT *async_evt)
{
GLSV_GLD_CB *gld_cb;
GLSV_GLD_GLND_DETAILS *node_details;
uint32_t node_id;
uint32_t rc = NCSCC_RC_FAILURE;
TRACE_ENTER();
if (async_evt == NULL)
goto end;
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(async_evt->info.rsc_details.mdest_id);
if ((gld_cb = (NCSCONTEXT)ncshm_take_hdl(NCS_SERVICE_ID_GLD, gl_gld_hdl))
== NULL) {
LOG_ER("Handle take failed");
goto end;
}
/* Find if the node details are available */
if ((node_details =
(GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details, (uint8_t *)&node_id)) == NULL) {
LOG_ER("Patricia tree get failed: node_id %u", node_id);
goto error;
}
if (gld_rsc_ref_set_orphan(node_details, async_evt->info.rsc_details.rsc_id,
async_evt->info.rsc_details.orphan,
async_evt->info.rsc_details.lck_mode) == NCSCC_RC_SUCCESS) {
TRACE_1("GLD a2s evt set orphan success: rsc_id %u node_id %u",
async_evt->info.rsc_details.rsc_id, node_id);
ncshm_give_hdl(gld_cb->my_hdl);
rc = NCSCC_RC_SUCCESS;
goto end;
} else
goto error;
error:
LOG_ER("GLD a2s evt set orphan failed: rsc_id %u node_id %u",
async_evt->info.rsc_details.rsc_id, node_id);
ncshm_give_hdl(gld_cb->my_hdl);
end:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
* Name : gld_dump_cb
*
* Description : This is the function dumps the contents of the control block.
*
* Arguments : gld_cb - Pointer to the control block
*
* Return Values : None.
*
* Notes : None.
*****************************************************************************/
void gld_dump_cb()
{
GLSV_GLD_CB *gld_cb = NULL;
GLSV_GLD_GLND_DETAILS *node_details;
MDS_DEST mds_dest_id;
GLSV_GLD_RSC_INFO *rsc_info;
SaLckResourceIdT rsc_id = 0;
uns32 node_id = 0;
gld_cb = (NCSCONTEXT)ncshm_take_hdl(NCS_SERVICE_ID_GLD, gl_gld_hdl);
if (!gld_cb) {
m_LOG_GLD_HEADLINE(GLD_TAKE_HANDLE_FAILED, NCSFL_SEV_ERROR, __FILE__, __LINE__, 0);
return;
}
memset(&mds_dest_id, 0, sizeof(MDS_DEST));
TRACE("************ GLD CB info *************** ");
/* print Amf Info */
TRACE("AMF HA state : %d ", gld_cb->ha_state);
/* print the Node details */
TRACE("GLND info :");
while ((node_details = (GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_getnext(&gld_cb->glnd_details,
(uns8 *)&node_id))) {
node_id = node_details->node_id;
TRACE("Node Id - :%d ", node_details->node_id);
}
/* print the Resource details */
while ((rsc_info = (GLSV_GLD_RSC_INFO *)ncs_patricia_tree_getnext(&gld_cb->rsc_info_id, (uns8 *)&rsc_id))) {
GLSV_NODE_LIST *list;
rsc_id = rsc_info->rsc_id;
TRACE("Resource Id - : %d Resource Name - %.10s ", (uns32)rsc_info->rsc_id, rsc_info->lck_name.value);
TRACE("Can Orphan - %d Mode - %d ", rsc_info->can_orphan, (uns32)rsc_info->orphan_lck_mode);
list = rsc_info->node_list;
TRACE("List of Nodes :");
while (list != NULL) {
TRACE("%d ", m_NCS_NODE_ID_FROM_MDS_DEST(list->dest_id));
list = list->next;
}
}
ncshm_give_hdl(gl_gld_hdl);
TRACE("************************************************** ");
}
/****************************************************************************
* Name : cpd_amf_csi_rmv_callback
*
* Description : TBD
*
*
* Return Values : None
*****************************************************************************/
void
cpd_amf_csi_rmv_callback(SaInvocationT invocation,
const SaNameT *compName, const SaNameT *csiName, SaAmfCSIFlagsT csiFlags)
{
CPD_CB *cb = 0;
SaAisErrorT saErr = SA_AIS_OK;
TRACE_ENTER();
cb = ncshm_take_hdl(NCS_SERVICE_ID_CPD, gl_cpd_cb_hdl);
if (cb) {
saAmfResponse(cb->amf_hdl, invocation, saErr);
ncshm_give_hdl(cb->cpd_hdl);
}
TRACE_2("cpd amf csi rmv cb invoked");
TRACE_LEAVE();
return;
}
void cpnd_saf_csi_set_cb(SaInvocationT invocation,
const SaNameT *compName, SaAmfHAStateT haState, SaAmfCSIDescriptorT csiDescriptor)
{
CPND_CB *cb = NULL;
SaAisErrorT saErr = SA_AIS_OK;
cb = ncshm_take_hdl(NCS_SERVICE_ID_CPND, gl_cpnd_cb_hdl);
if (cb) {
cb->ha_state = haState; /* Set the HA State */
saAmfResponse(cb->amf_hdl, invocation, saErr);
ncshm_give_hdl(gl_cpnd_cb_hdl);
m_LOG_CPND_CL(CPND_CSI_CB_INVOKED, CPND_FC_GENERIC, NCSFL_SEV_NOTICE, __FILE__, __LINE__);
} else {
m_LOG_CPND_CL(CPND_CB_RETRIEVAL_FAILED, CPND_FC_HDLN, NCSFL_SEV_ERROR, __FILE__, __LINE__);
}
return;
} /* End of cpnd_saf_csi_set_cb() */
/****************************************************************************
* Name : mqd_timer_expiry
*
* Description : This function which is registered with the OS tmr function,
* which will post a message to the corresponding mailbox
* depending on the component type.
*
*****************************************************************************/
void mqd_timer_expiry(NCSCONTEXT uarg)
{
MQD_TMR *tmr = (MQD_TMR *)uarg;
NCS_IPC_PRIORITY priority = NCS_IPC_PRIORITY_HIGH;
MQD_CB *cb;
MQSV_EVT *evt = 0;
uns32 mqd_hdl;
if (tmr != NULL) {
mqd_hdl = tmr->uarg;
if (tmr->is_active)
tmr->is_active = FALSE;
/* Destroy the timer if it exists.. */
if (tmr->tmr_id != TMR_T_NULL) {
m_NCS_TMR_DESTROY(tmr->tmr_id);
tmr->tmr_id = TMR_T_NULL;
}
/* post a message to the corresponding component */
if ((cb = (MQD_CB *)ncshm_take_hdl(NCS_SERVICE_ID_MQD, mqd_hdl))
!= NULL) {
evt = m_MMGR_ALLOC_MQSV_EVT(NCS_SERVICE_ID_MQD);
if (evt == NULL) {
m_LOG_MQSV_D(MQD_MEMORY_ALLOC_FAIL, NCSFL_LC_TIMER, NCSFL_SEV_ERROR, 0, __FILE__,
__LINE__);
return;
}
memset(evt, 0, sizeof(MQSV_EVT));
evt->type = MQSV_EVT_MQD_CTRL;
evt->msg.mqd_ctrl.type = MQD_MSG_TMR_EXPIRY;
evt->msg.mqd_ctrl.info.tmr_info.nodeid = tmr->nodeid;
evt->msg.mqd_ctrl.info.tmr_info.type = tmr->type;
/* Post the event to MQD Thread */
m_NCS_IPC_SEND(&cb->mbx, evt, priority);
ncshm_give_hdl(mqd_hdl);
}
}
return;
}