/****************************************************************************
* 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;
}
/****************************************************************************\
* Function: dtsv_ckpt_add_rmv_updt_dts_log
*
* Purpose: Add new entry to device's DTS_FILE_LIST if action is ADD,
* remove if action is to remove.
*
* Input: cb - CB pointer.
* su - Decoded structur.
* action - ADD/RMV/UPDT
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES:
*
\**************************************************************************/
uns32 dtsv_ckpt_add_rmv_updt_dts_log(DTS_CB *cb, DTS_LOG_CKPT_DATA *data, NCS_MBCSV_ACT_TYPE action)
{
DTS_SVC_REG_TBL *svc = NULL;
OP_DEVICE *device = NULL;
SVC_KEY nt_key;
if (data == NULL)
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dtsv_ckpt_add_rmv_updt_dts_log: NULL pointer passed");
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(data->key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(data->key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if (data->key.node == 0) /*global policy device */
device = &cb->g_policy.device;
else if (data->key.ss_svc_id == 0) { /*node policy device */
if ((svc = (DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dts_log: Node entry doesn't exist");
}
device = &svc->device;
} else { /*service policy device */
if ((svc = (DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dts_log: Service entry doesn't exist");
}
device = &svc->device;
}
switch (action) {
case NCS_MBCSV_ACT_ADD:
break;
case NCS_MBCSV_ACT_RMV:
{
m_LOG_DTS_LOGDEL(data->key.node, data->key.ss_svc_id, device->log_file_list.num_of_files);
m_DTS_RMV_LL_ENTRY(device);
}
break;
default:
/* Log error */
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return NCSCC_RC_FAILURE;
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* Name : gld_rsc_close
*
* Description : This is the function is invoked when a rsc_close event is
* is sent from a GLND. 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 : evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t gld_rsc_close(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->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_SUCCESS;
TRACE_ENTER2("component name %s", gld_cb->comp_name.value);
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->fr_dest_id);
if ((evt == GLSV_GLD_EVT_NULL) || (gld_cb == NULL)){
rc = NCSCC_RC_FAILURE;
goto end;
}
orphan_flag = 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("Event from unknown glnd: node_id %u ", node_id);
rc = NCSCC_RC_FAILURE;
goto end;
}
glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_get(&node_details->rsc_info_tree,
(uint8_t *)&evt->info.rsc_details.rsc_id);
if ((glnd_rsc == NULL) || (glnd_rsc->rsc_info == NULL)) {
LOG_ER("Rsc operation for unopened rsc: rsc_id %u node_id %u ",
evt->info.rsc_details.rsc_id, node_details->node_id);
goto end;
}
TRACE("EVT Processing rsc close rsc_id %u node_id %u", glnd_rsc->rsc_info->rsc_id,
node_details->node_id);
if (glnd_rsc->rsc_info->saf_rsc_no_of_users > 0)
glnd_rsc->rsc_info->saf_rsc_no_of_users = glnd_rsc->rsc_info->saf_rsc_no_of_users - 1;
/*Checkkpoint resource close event */
glsv_gld_a2s_ckpt_rsc_details(gld_cb, evt->evt_type, evt->info.rsc_details, node_details->dest_id,
evt->info.rsc_details.lcl_ref_cnt);
if (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);
end:
TRACE_LEAVE2("Return value %u", rc);
return rc;
}
/****************************************************************************
Description : This routine finds the checkpoint node.
Arguments : ckpt_tree - Ckpt Tree.
ckpt_hdl - Checkpoint Handle
Return Values : ckpt_node - Checkpoint Node
NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : The caller takes the cb lock before calling this function
******************************************************************************/
uns32 cpd_ckpt_node_get(NCS_PATRICIA_TREE *ckpt_tree, SaCkptCheckpointHandleT *ckpt_hdl, CPD_CKPT_INFO_NODE **ckpt_node)
{
*ckpt_node = (CPD_CKPT_INFO_NODE *)
ncs_patricia_tree_get(ckpt_tree, (uns8 *)ckpt_hdl);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : immd_immnd_info_node_find_add
Description : This routine adds the new node to immnd_tree.
Arguments : immnd_tree - IMMND Tree.
immnd_info_node - IMMND Node.
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
*****************************************************************************/
uns32 immd_immnd_info_node_find_add(NCS_PATRICIA_TREE *immnd_tree,
MDS_DEST *dest, IMMD_IMMND_INFO_NODE **immnd_info_node, NCS_BOOL *add_flag)
{
NODE_ID key;
memset(&key, 0, sizeof(NODE_ID));
/* Fill the Key */
key = m_NCS_NODE_ID_FROM_MDS_DEST((*dest));
*immnd_info_node = (IMMD_IMMND_INFO_NODE *)
ncs_patricia_tree_get(immnd_tree, (uns8 *)&key);
if ((*immnd_info_node == NULL) && (*add_flag == TRUE)) {
*immnd_info_node = calloc(1, sizeof(IMMD_IMMND_INFO_NODE));
if (*immnd_info_node == NULL) {
LOG_ER("IMMD - calloc returned NULL");
return NCSCC_RC_FAILURE;
}
(*immnd_info_node)->immnd_dest = *dest;
(*immnd_info_node)->immnd_key = m_NCS_NODE_ID_FROM_MDS_DEST((*dest));
(*immnd_info_node)->patnode.key_info = (uns8 *)&((*immnd_info_node)->immnd_key);
if (ncs_patricia_tree_add(immnd_tree, &(*immnd_info_node)->patnode) != NCSCC_RC_SUCCESS) {
LOG_ER("ncs_patricia_tree_add FAILED");
free(*immnd_info_node);
*immnd_info_node = NULL;
return NCSCC_RC_FAILURE;
}
*add_flag = FALSE;
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : mqa_queue_tree_delete_node
Description : This routine adds the deletes the queue from the queue tree
Arguments : queue_info - pointer to the queue node.
Return Values : NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
Notes : None
******************************************************************************/
uint32_t mqa_queue_tree_delete_node(MQA_CB *mqa_cb, SaMsgQueueHandleT hdl_id)
{
MQA_QUEUE_INFO *queue_info = NULL;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
queue_info = (MQA_QUEUE_INFO *)ncs_patricia_tree_get(&mqa_cb->mqa_queue_tree, (uint8_t *)&hdl_id);
if (!queue_info) {
TRACE_2("FAILURE: Adding the queue in the queue tree is failed");
return NCSCC_RC_FAILURE;
}
/* delete from the tree */
if ((rc = ncs_patricia_tree_del(&mqa_cb->mqa_queue_tree, &queue_info->patnode)) != NCSCC_RC_SUCCESS)
TRACE_2("Queue database Deregistration Failed");
if (queue_info->task_handle != 0) {
/* m_NCS_TASK_STOP(queue_info->task_handle);
m_NCS_TASK_RELEASE(queue_info->task_handle); */
}
/* free the mem */
m_MMGR_FREE_MQA_QUEUE_INFO(queue_info);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* Name : gld_rsc_set_orphan
*
* Description : Instruction from the GLND to set the orphan flag
*
* Arguments : evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uns32 gld_rsc_set_orphan(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->gld_cb;
GLSV_GLD_GLND_DETAILS *node_details;
uns32 node_id;
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->fr_dest_id);
if ((evt == GLSV_GLD_EVT_NULL) || (gld_cb == NULL))
return NCSCC_RC_FAILURE;
/* Find if the node details are available */
if ((node_details = (GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details,
(uns8 *)&node_id)) == NULL) {
m_LOG_GLD_HEADLINE(GLD_UNKNOWN_GLND_EVT, NCSFL_SEV_NOTICE, __FILE__, __LINE__, node_id);
return NCSCC_RC_FAILURE;
}
m_LOG_GLD_EVT(GLD_EVT_SET_ORPHAN, NCSFL_SEV_INFO, __FILE__, __LINE__, 0, node_details->node_id);
if (gld_rsc_ref_set_orphan
(node_details, evt->info.rsc_details.rsc_id, evt->info.rsc_details.orphan,
evt->info.rsc_details.lck_mode) == NCSCC_RC_SUCCESS) {
/* Checkpoint rsc_details */
glsv_gld_a2s_ckpt_rsc_details(gld_cb, evt->evt_type, evt->info.rsc_details, node_details->dest_id,
evt->info.rsc_details.lcl_ref_cnt);
return NCSCC_RC_SUCCESS;
} else
return NCSCC_RC_FAILURE;
}
/****************************************************************************
Name : mqa_track_tree_find_and_add
Description : This routine adds/searches the new group track element to the
client tree.
Arguments :
client_info : pointer to the mqa client.
hdl_id : the handle id.
flag : true/false if true create the new node if node
doesn't exist.FALSE -> search for an existing node.
Return Values : returns the MQA_TRACK_INFO node.
Notes : The caller takes the cb lock before calling this function
******************************************************************************/
MQA_TRACK_INFO *mqa_track_tree_find_and_add(MQA_CLIENT_INFO *client_info, SaNameT *group, bool flag)
{
MQA_TRACK_INFO *track_info = NULL;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
track_info = (MQA_TRACK_INFO *)ncs_patricia_tree_get(&client_info->mqa_track_tree, (uint8_t *)group->value);
if (flag == true) {
/* create and allocate the memory */
if (!track_info) {
track_info = (MQA_TRACK_INFO *)m_MMGR_ALLOC_MQA_TRACK_INFO;
if (!track_info) {
TRACE_2("Track database creation failed");
return NULL;
}
memset(track_info, 0, sizeof(MQA_TRACK_INFO));
track_info->queueGroupName = *group;
track_info->patnode.key_info = (uint8_t *)track_info->queueGroupName.value;
if ((rc = ncs_patricia_tree_add(&client_info->mqa_track_tree,
&track_info->patnode)) != NCSCC_RC_SUCCESS) {
TRACE_2("Track Database Registration Failed");
if (track_info->notificationBuffer.notification)
m_MMGR_FREE_MQA_TRACK_BUFFER_INFO(track_info->notificationBuffer.notification);
m_MMGR_FREE_MQA_TRACK_INFO(track_info);
return NULL;
}
}
}
TRACE_LEAVE();
return track_info;
}
/******************************************************************************
Name : avnd_nodeid_mdsdest_rec_del
Description : This routine delete NODE_ID to MDS_DEST record for a particular
AvND.
Arguments : cb - ptr to the AvND control block.
mds_dest - Mds dest of AvND coming up.
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 avnd_nodeid_mdsdest_rec_del(AVND_CB *cb, MDS_DEST mds_dest)
{
AVND_NODEID_TO_MDSDEST_MAP *rec = NULL;
NODE_ID node_id = 0;
uns32 res = NCSCC_RC_SUCCESS;
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(mds_dest);
rec = (AVND_NODEID_TO_MDSDEST_MAP *)ncs_patricia_tree_get(&cb->nodeid_mdsdest_db, (uns8 *)&(node_id));
if (rec == NULL) {
LOG_ER("nodeid_mdsdest rec doesn't exist, Rec del failed: MdsDest:%lld NodeId:%u",
mds_dest, node_id);
return NCSCC_RC_FAILURE;
} else {
res = ncs_patricia_tree_del(&cb->nodeid_mdsdest_db, &rec->tree_node);
if (NCSCC_RC_SUCCESS != res) {
LOG_ER("Couldn't del nodeid_mdsdest rec, patricia del failed: MdsDest:%lld,NodeId:%u, res%u",
mds_dest, node_id, res);
return res;
}
} /* Else of if(rec == NULL) */
free(rec);
return res;
}
/****************************************************************************\
PROCEDURE NAME : mqd_qgrp_cnt_get_evt_process
DESCRIPTION : This routine process the qcount get event .
ARGUMENTS : pMqd - MQD Control block pointer
pEvt - Event structure
RETURNS : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
\*****************************************************************************/
static uint32_t mqd_qgrp_cnt_get_evt_process(MQD_CB *pMqd, MQSV_EVT *pevt)
{
MQD_OBJ_NODE *pObjNode = 0;
MQSV_EVT rsp;
uint32_t rc = NCSCC_RC_SUCCESS;
MQSV_CTRL_EVT_QGRP_CNT *qgrp_cnt_info = &pevt->msg.mqd_ctrl.info.qgrp_cnt_info;
TRACE_ENTER();
memset(&rsp, 0, sizeof(MQSV_EVT));
if (pMqd->ha_state == SA_AMF_HA_ACTIVE) {
rsp.type = MQSV_EVT_MQND_CTRL;
rsp.msg.mqnd_ctrl.type = MQND_CTRL_EVT_QGRP_CNT_RSP;
rsp.msg.mqnd_ctrl.info.qgrp_cnt_info.info.queueName = qgrp_cnt_info->info.queueName;
pObjNode = (MQD_OBJ_NODE *)ncs_patricia_tree_get(&pMqd->qdb, (uint8_t *)&qgrp_cnt_info->info.queueName);
if (pObjNode) {
rsp.msg.mqnd_ctrl.info.qgrp_cnt_info.error = SA_AIS_OK;
rsp.msg.mqnd_ctrl.info.qgrp_cnt_info.info.noOfQueueGroupMemOf = pObjNode->oinfo.ilist.count;
} else {
rsp.msg.mqnd_ctrl.info.qgrp_cnt_info.error = SA_AIS_ERR_NOT_EXIST;
rsp.msg.mqnd_ctrl.info.qgrp_cnt_info.info.noOfQueueGroupMemOf = 0;
}
rc = mqd_mds_send_rsp(pMqd, &pevt->sinfo, &rsp);
}
TRACE_LEAVE2(" return code %u", rc);
return rc;
}
/****************************************************************************
Name : mqa_track_tree_find_and_add
Description : This routine adds/searches the new group track element to the
client tree.
Arguments :
client_info : pointer to the mqa client.
hdl_id : the handle id.
flag : TRUE/FALSE if TRUE create the new node if node
doesn't exist.FALSE -> search for an existing node.
Return Values : returns the MQA_TRACK_INFO node.
Notes : The caller takes the cb lock before calling this function
******************************************************************************/
MQA_TRACK_INFO *mqa_track_tree_find_and_add(MQA_CLIENT_INFO *client_info, SaNameT *group, NCS_BOOL flag)
{
MQA_TRACK_INFO *track_info = NULL;
uns32 rc = NCSCC_RC_SUCCESS;
track_info = (MQA_TRACK_INFO *)ncs_patricia_tree_get(&client_info->mqa_track_tree, (uns8 *)group->value);
if (flag == TRUE) {
/* create and allocate the memory */
if (!track_info) {
track_info = (MQA_TRACK_INFO *)m_MMGR_ALLOC_MQA_TRACK_INFO;
if (!track_info) {
m_LOG_MQSV_A(MQA_TRACK_ALLOC_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__,
__LINE__);
return NULL;
}
memset(track_info, 0, sizeof(MQA_TRACK_INFO));
track_info->queueGroupName = *group;
track_info->patnode.key_info = (uns8 *)track_info->queueGroupName.value;
if ((rc = ncs_patricia_tree_add(&client_info->mqa_track_tree,
&track_info->patnode)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_TRACK_TREE_ADD_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc,
__FILE__, __LINE__);
if (track_info->notificationBuffer.notification)
m_MMGR_FREE_MQA_TRACK_BUFFER_INFO(track_info->notificationBuffer.notification);
m_MMGR_FREE_MQA_TRACK_INFO(track_info);
return NULL;
}
}
}
return track_info;
}
/****************************************************************************
* Name : gld_rsc_set_orphan
*
* Description : Instruction from the GLND to set the orphan flag
*
* Arguments : evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t gld_rsc_set_orphan(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->gld_cb;
GLSV_GLD_GLND_DETAILS *node_details;
uint32_t node_id;
uint32_t rc = NCSCC_RC_FAILURE;
TRACE_ENTER();
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->fr_dest_id);
if ((evt == GLSV_GLD_EVT_NULL) || (gld_cb == NULL))
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("Event from unknown glnd: node_id %u", node_id);
goto end;
}
TRACE("EVT Processing set orphan: node_id %u ", node_details->node_id);
if (gld_rsc_ref_set_orphan
(node_details, evt->info.rsc_details.rsc_id, evt->info.rsc_details.orphan,
evt->info.rsc_details.lck_mode) == NCSCC_RC_SUCCESS) {
/* Checkpoint rsc_details */
glsv_gld_a2s_ckpt_rsc_details(gld_cb, evt->evt_type, evt->info.rsc_details, node_details->dest_id,
evt->info.rsc_details.lcl_ref_cnt);
rc = NCSCC_RC_SUCCESS;
}
end:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : mqa_track_tree_find_and_del
Description : This routine deletes a new group track element to the
client tree.
Arguments :
client_info : pointer to the mqa client.
group : the group name to delete from track list.
Return Values : returns status of deletion, true if deleted, false otherwise
Notes : The caller takes the cb lock before calling this function
******************************************************************************/
bool mqa_track_tree_find_and_del(MQA_CLIENT_INFO *client_info, SaNameT *group)
{
MQA_TRACK_INFO *track_info = NULL;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
track_info = (MQA_TRACK_INFO *)ncs_patricia_tree_get(&client_info->mqa_track_tree, (uint8_t *)group->value);
if (!track_info)
return false;
if ((rc = ncs_patricia_tree_del(&client_info->mqa_track_tree, &track_info->patnode)) != NCSCC_RC_SUCCESS) {
TRACE_2("Track Database Deregistration Failed");
if (track_info->notificationBuffer.notification)
m_MMGR_FREE_MQA_TRACK_BUFFER_INFO(track_info->notificationBuffer.notification);
m_MMGR_FREE_MQA_TRACK_INFO(track_info);
return false;
}
if (track_info->notificationBuffer.notification)
m_MMGR_FREE_MQA_TRACK_BUFFER_INFO(track_info->notificationBuffer.notification);
m_MMGR_FREE_MQA_TRACK_INFO(track_info);
TRACE_LEAVE();
return true;
}
/****************************************************************************\
PROCEDURE NAME : mqd_nd_status_evt_process
DESCRIPTION : This routine process the MQND status event.
ARGUMENTS : pMqd - MQD Control block pointer
nd_info - ND information
RETURNS : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
\*****************************************************************************/
static uns32 mqd_nd_status_evt_process(MQD_CB *pMqd, MQD_ND_STATUS_INFO *nd_info)
{
uns32 rc = NCSCC_RC_SUCCESS;
void *ptr = 0;
MQD_ND_DB_NODE *pNdNode = 0;
SaTimeT timeout = m_NCS_CONVERT_SATIME_TO_TEN_MILLI_SEC(MQD_ND_EXPIRY_TIME_STANDBY);
NODE_ID node_id = 0;
MQD_A2S_MSG msg;
TRACE("MQND status:MDS EVT :processing %d", m_NCS_NODE_ID_FROM_MDS_DEST(nd_info->dest));
/* Process MQND Related events */
if (nd_info->is_up == FALSE) {
pNdNode = m_MMGR_ALLOC_MQD_ND_DB_NODE;
if (pNdNode == NULL) {
rc = NCSCC_RC_FAILURE;
m_LOG_MQSV_D(MQD_MEMORY_ALLOC_FAIL, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__,
__LINE__);
return rc;
}
memset(pNdNode, 0, sizeof(MQD_ND_DB_NODE));
pNdNode->info.nodeid = m_NCS_NODE_ID_FROM_MDS_DEST(nd_info->dest);
pNdNode->info.is_restarted = FALSE;
pNdNode->info.timer.type = MQD_ND_TMR_TYPE_EXPIRY;
pNdNode->info.timer.tmr_id = 0;
pNdNode->info.timer.nodeid = pNdNode->info.nodeid;
pNdNode->info.timer.uarg = pMqd->hdl;
pNdNode->info.timer.is_active = FALSE;
mqd_red_db_node_add(pMqd, pNdNode);
mqd_tmr_start(&pNdNode->info.timer, timeout);
if (pMqd->ha_state == SA_AMF_HA_ACTIVE)
mqd_nd_down_update_info(pMqd, nd_info->dest);
TRACE("MDS DOWN PROCESSED ON %d DONE", pMqd->ha_state);
} else {
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(nd_info->dest);
pNdNode = (MQD_ND_DB_NODE *)ncs_patricia_tree_get(&pMqd->node_db, (uns8 *)&node_id);
if (pNdNode) {
mqd_tmr_stop(&pNdNode->info.timer);
pNdNode->info.is_restarted = TRUE;
pNdNode->info.dest = nd_info->dest;
if (pMqd->ha_state == SA_AMF_HA_ACTIVE) {
mqd_red_db_node_del(pMqd, pNdNode);
mqd_nd_restart_update_dest_info(pMqd, nd_info->dest);
/* Send an async update event to standby MQD */
memset(&msg, 0, sizeof(MQD_A2S_MSG));
msg.type = MQD_A2S_MSG_TYPE_MQND_STATEVT;
msg.info.nd_stat_evt.nodeid = m_NCS_NODE_ID_FROM_MDS_DEST(nd_info->dest);
msg.info.nd_stat_evt.is_restarting = nd_info->is_up;
msg.info.nd_stat_evt.downtime = nd_info->event_time;
ptr = &(msg.info.nd_stat_evt);
mqd_a2s_async_update(pMqd, MQD_A2S_MSG_TYPE_MQND_STATEVT,
(void *)(&msg.info.nd_stat_evt));
}
}
TRACE("MDS UP PROCESSED ON %d DONE", pMqd->ha_state);
}
return rc;
}
static uint32_t ncs_tmr_add_pat_node(SYSF_TMR *tmr)
{
SYSF_TMR_PAT_NODE *temp_tmr_pat_node = NULL;
temp_tmr_pat_node = (SYSF_TMR_PAT_NODE *)ncs_patricia_tree_get(&gl_tcb.tmr_pat_tree, (uint8_t *)&tmr->key);
if (temp_tmr_pat_node == (SYSF_TMR_PAT_NODE *)NULL) {
temp_tmr_pat_node = (SYSF_TMR_PAT_NODE *)m_NCS_MEM_ALLOC(sizeof(SYSF_TMR_PAT_NODE),
NCS_MEM_REGION_PERSISTENT,
NCS_SERVICE_ID_LEAP_TMR, 0);
memset(temp_tmr_pat_node, '\0', sizeof(SYSF_TMR_PAT_NODE));
temp_tmr_pat_node->key = tmr->key;
temp_tmr_pat_node->pat_node.key_info = (uint8_t *)&temp_tmr_pat_node->key;
ncs_patricia_tree_add(&gl_tcb.tmr_pat_tree, (NCS_PATRICIA_NODE *)&temp_tmr_pat_node->pat_node);
}
if (temp_tmr_pat_node->tmr_list_start == NULL) {
temp_tmr_pat_node->tmr_list_end = temp_tmr_pat_node->tmr_list_start = tmr;
} else {
temp_tmr_pat_node->tmr_list_end->next = tmr;
temp_tmr_pat_node->tmr_list_end = tmr;
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************\
PROCEDURE NAME : mqd_timer_expiry_evt_process
DESCRIPTION : This routine process the comp specific message.
ARGUMENTS : pMqd - MQD Control block pointer
nodeid - NODE ID
RETURNS : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
\*****************************************************************************/
uns32 mqd_timer_expiry_evt_process(MQD_CB *pMqd, NODE_ID *nodeid)
{
MQD_ND_DB_NODE *pNdNode = 0;
MQD_OBJ_NODE *pNode = 0;
MQD_A2S_MSG msg;
uns32 rc = NCSCC_RC_SUCCESS;
m_LOG_MQSV_D(MQD_TMR_EXPIRED, NCSFL_LC_TIMER, NCSFL_SEV_NOTICE, NCS_PTR_TO_UNS32_CAST(nodeid), __FILE__,
__LINE__);
pNdNode = (MQD_ND_DB_NODE *)ncs_patricia_tree_get(&pMqd->node_db, (uns8 *)nodeid);
/* We need to scan the entire database and remove the track inforamtion
* pertaining to the user
*/
if (pNdNode == NULL) {
rc = NCSCC_RC_FAILURE;
return rc;
}
if (pMqd->ha_state == SA_AMF_HA_ACTIVE) {
if (pNdNode->info.timer.tmr_id != TMR_T_NULL) {
m_NCS_TMR_DESTROY(pNdNode->info.timer.tmr_id);
pNdNode->info.timer.tmr_id = TMR_T_NULL;
}
pNode = (MQD_OBJ_NODE *)ncs_patricia_tree_getnext(&pMqd->qdb, (uns8 *)0);
while (pNode) {
ASAPi_DEREG_INFO dereg;
SaNameT name;
memset(&dereg, 0, sizeof(ASAPi_DEREG_INFO));
name = pNode->oinfo.name;
if (m_NCS_NODE_ID_FROM_MDS_DEST(pNode->oinfo.info.q.dest) == pNdNode->info.nodeid) {
dereg.objtype = ASAPi_OBJ_QUEUE;
dereg.queue = pNode->oinfo.name;
rc = mqd_asapi_dereg_hdlr(pMqd, &dereg, NULL);
}
pNode = (MQD_OBJ_NODE *)ncs_patricia_tree_getnext(&pMqd->qdb, (uns8 *)&name);
}
/* Send an async Update to the standby */
memset(&msg, 0, sizeof(MQD_A2S_MSG));
msg.type = MQD_A2S_MSG_TYPE_MQND_TIMER_EXPEVT;
msg.info.nd_tmr_exp_evt.nodeid = pNdNode->info.nodeid;
/* Send async update to the standby for MQD redundancy */
mqd_a2s_async_update(pMqd, MQD_A2S_MSG_TYPE_MQND_TIMER_EXPEVT, (void *)(&msg.info.nd_tmr_exp_evt));
if (pNdNode)
mqd_red_db_node_del(pMqd, pNdNode);
TRACE("MQND TMR EXPIRY PROCESSED ON ACTIVE");
} else if (pMqd->ha_state == SA_AMF_HA_STANDBY) {
pNdNode->info.timer.is_expired = TRUE;
TRACE("MQND TMR EXPIRY PROCESSED ON STANDBY");
}
return rc;
} /* End of mqd_timer_expiry_evt_process() */
/****************************************************************************
* Name : gld_rsc_close
*
* Description : This is the function is invoked when a rsc_close event is
* is sent from a GLND. 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 : evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uns32 gld_rsc_close(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->gld_cb;
GLSV_GLD_GLND_DETAILS *node_details;
GLSV_GLD_GLND_RSC_REF *glnd_rsc;
NCS_BOOL orphan_flag;
uns32 node_id;
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->fr_dest_id);
if ((evt == GLSV_GLD_EVT_NULL) || (gld_cb == NULL))
return NCSCC_RC_FAILURE;
orphan_flag = 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,
(uns8 *)&node_id)) == NULL) {
m_LOG_GLD_HEADLINE(GLD_UNKNOWN_GLND_EVT, NCSFL_SEV_NOTICE, __FILE__, __LINE__, node_id);
return NCSCC_RC_FAILURE;
}
glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_get(&node_details->rsc_info_tree,
(uns8 *)&evt->info.rsc_details.rsc_id);
if ((glnd_rsc == NULL) || (glnd_rsc->rsc_info == NULL)) {
m_LOG_GLD_LCK_OPER(GLD_OPER_RSC_OPER_ERROR, NCSFL_SEV_ERROR, __FILE__, __LINE__, "",
evt->info.rsc_details.rsc_id, node_details->node_id);
return NCSCC_RC_SUCCESS;
}
m_LOG_GLD_EVT(GLD_EVT_RSC_CLOSE, NCSFL_SEV_INFO, __FILE__, __LINE__, glnd_rsc->rsc_info->rsc_id,
node_details->node_id);
if (glnd_rsc->rsc_info->saf_rsc_no_of_users > 0)
glnd_rsc->rsc_info->saf_rsc_no_of_users = glnd_rsc->rsc_info->saf_rsc_no_of_users - 1;
/*Checkkpoint resource close event */
glsv_gld_a2s_ckpt_rsc_details(gld_cb, evt->evt_type, evt->info.rsc_details, node_details->dest_id,
evt->info.rsc_details.lcl_ref_cnt);
if (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);
return NCSCC_RC_SUCCESS;
}
AVD_APP *avd_app_get(const SaNameT *dn)
{
SaNameT tmp = {0};
tmp.length = dn->length;
memcpy(tmp.value, dn->value, tmp.length);
return (AVD_APP *)ncs_patricia_tree_get(&app_db, (uns8 *)&tmp);
}
/****************************************************************************
Name : cpd_ckpt_reploc_get
Description : This routine finds the checkpoint node.
Arguments : ckpt_reploc_tree - Ckpt Tree.
ckpt_name - Checkpoint Name
Return Values : ckpt_reploc_node - Checkpoint Node
NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : The caller takes the cb lock before calling this function
******************************************************************************/
uns32 cpd_ckpt_reploc_get(NCS_PATRICIA_TREE *ckpt_reploc_tree,
CPD_REP_KEY_INFO *key_info, CPD_CKPT_REPLOC_INFO **ckpt_reploc_node)
{
key_info->ckpt_name.length = m_NCS_OS_HTONS(key_info->ckpt_name.length);
key_info->node_name.length = m_NCS_OS_HTONS(key_info->node_name.length);
*ckpt_reploc_node = (CPD_CKPT_REPLOC_INFO *)ncs_patricia_tree_get(ckpt_reploc_tree, (uns8 *)key_info);
return NCSCC_RC_SUCCESS;
}
AVD_SVC_TYPE *avd_svctype_get(const SaNameT *dn)
{
SaNameT tmp = {0};
tmp.length = dn->length;
memcpy(tmp.value, dn->value, tmp.length);
return (AVD_SVC_TYPE *)ncs_patricia_tree_get(&svctype_db, (uns8 *)&tmp);
}
/**
* Lookup object using name in DB
* @param dn
*
* @return avd_cstype_t*
*/
avd_cstype_t *avd_cstype_get(const SaNameT *dn)
{
SaNameT tmp = {0};
tmp.length = dn->length;
memcpy(tmp.value, dn->value, tmp.length);
return (avd_cstype_t *)ncs_patricia_tree_get(&cstype_db, (uns8 *)&tmp);
}
/****************************************************************************
* Name : mqnd_qname_node_get
*
* Description : Function to get the queue node from Tree.
*
* Arguments : MQND_CB *cb, - MQND Control Block
* SaNameT qname - queue handle
*
* Return Values : MQND_QNAME_NODE** o_qnode - Queu Node at MQND
*
* Notes : None.
*****************************************************************************/
void mqnd_qname_node_get(MQND_CB *cb, SaNameT qname, MQND_QNAME_NODE **o_qnode)
{
*o_qnode = NULL;
if (cb->is_qname_db_up) {
if (qname.length)
qname.length = m_HTON_SANAMET_LEN(qname.length);
*o_qnode = (MQND_QNAME_NODE *)ncs_patricia_tree_get(&cb->qname_db, (uns8 *)&qname);
}
return;
}
/**************************************************************************\
*
* give_exec_mod_cb
*
* Description: Task to handle the signals.
*
* Synopsis:
*
* Call Arguments:
* pid - Process ID for which timeout has occurrend.
*
* Returns:
* None.
*
* Notes:
*
\**************************************************************************/
void give_exec_mod_cb(int pid, uns32 status, int type)
{
NCS_OS_PROC_EXECUTE_TIMED_CB_INFO cb_info;
SYSF_PID_LIST *exec_pid;
m_NCS_LOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
memset(&cb_info, '\0', sizeof(NCS_OS_PROC_EXECUTE_TIMED_CB_INFO));
if (NULL != (exec_pid = (SYSF_PID_LIST *)ncs_patricia_tree_get(&module_cb.pid_list, (const uns8 *)&pid))) {
if (SYSF_EXEC_INFO_TIME_OUT == type) {
cb_info.exec_stat.value = NCS_OS_PROC_EXIT_WAIT_TIMEOUT;
/*printf("\n%d Process terminated, callback given\n",exec_pid->pid); */
m_NCS_OS_PROCESS_TERMINATE(exec_pid->pid);
exec_pid->exec_info_type = SYSF_EXEC_INFO_TIME_OUT;
cb_info.exec_stat.info.exit_with_code.exit_code = WEXITSTATUS(status);
} else {
/* Initialize the exit-code value. May be overridden below */
cb_info.exec_stat.info.exit_with_code.exit_code = WEXITSTATUS(status);
/* First stop timer */
exec_pid->exec_info_type = SYSF_EXEC_INFO_SIG_CHLD;
ncs_exc_mdl_stop_timer(exec_pid);
/* Earlier "status = status >>8" now replaced with WEXITSTATUS macro */
if (WIFEXITED(status) && (WEXITSTATUS(status) == 128)) {
cb_info.exec_stat.value = NCS_OS_PROC_EXEC_FAIL;
} else if (WIFEXITED(status) && (WEXITSTATUS(status) == 0)) {
cb_info.exec_stat.value = NCS_OS_PROC_EXIT_NORMAL;
} else if (WIFSIGNALED(status)) {
cb_info.exec_stat.value = NCS_OS_PROC_EXIT_ON_SIGNAL;
cb_info.exec_stat.info.exit_on_signal.signal_num = WTERMSIG(status);
} else { /* Just consider it to tbe EXIT-WITH-CODE .... */
cb_info.exec_stat.value = NCS_OS_PROC_EXIT_WITH_CODE;
}
}
cb_info.i_usr_hdl = exec_pid->usr_hdl;
cb_info.i_exec_hdl = exec_pid->exec_hdl;
exec_pid->exec_cb(&cb_info);
if (type != SYSF_EXEC_INFO_TIME_OUT) {
/* Remove entry from pat tree */
ncs_patricia_tree_del(&module_cb.pid_list, (NCS_PATRICIA_NODE *)exec_pid);
m_MMGR_FREE_PRO_EXC(exec_pid);
}
}
m_NCS_UNLOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
}
/****************************************************************************
* Name : gld_mds_glnd_down
*
* Description : MDS indicated that a glnd has gone down
*
* Arguments : evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t gld_mds_glnd_down(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->gld_cb;
GLSV_GLD_GLND_DETAILS *node_details = NULL;
GLSV_GLD_RSC_INFO *rsc_info;
uint32_t node_id;
uint32_t rc = NCSCC_RC_FAILURE;
TRACE_ENTER2("mds identification %u",gld_cb->my_dest_id );
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->info.glnd_mds_info.mds_dest_id);
if ((evt == GLSV_GLD_EVT_NULL) || (gld_cb == NULL))
goto end;
memcpy(&evt->fr_dest_id, &evt->info.glnd_mds_info.mds_dest_id, sizeof(MDS_DEST)
);
if ((node_details = (GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details,
(uint8_t *)&node_id)) == NULL) {
TRACE_1("Resource details is empty for glnd on node_id %u ", node_id);
rc = NCSCC_RC_SUCCESS;
goto end;
}
node_details->status = GLND_RESTART_STATE;
TRACE("EVT Processing MDS GLND DOWN: node_id %u", node_details->node_id);
memcpy(&node_details->restart_timer.mdest_id, &node_details->dest_id, sizeof(MDS_DEST));
/* Start GLSV_GLD_GLND_RESTART_TIMEOUT timer */
gld_start_tmr(gld_cb, &node_details->restart_timer, GLD_TMR_NODE_RESTART_TIMEOUT, GLD_NODE_RESTART_TIMEOUT, 0);
/* Check whether this node is master for any resource, if yes send the status to all
the
non master nodes */
if (gld_cb->ha_state == SA_AMF_HA_ACTIVE) {
/* Check whether this node is master for any resource, if yes send the status to all the non master nodes */
rsc_info = gld_cb->rsc_info;
while (rsc_info != NULL) {
if (rsc_info->node_list) {
if (rsc_info->node_list->node_id == node_details->node_id)
gld_snd_master_status(gld_cb, rsc_info, GLND_RESOURCE_MASTER_RESTARTED);
}
rsc_info = rsc_info->next;
}
/* If this node is non master for any resource, then send node status to the master */
gld_process_send_non_master_status(gld_cb, node_details, GLND_RESTART_STATE);
}
end:
TRACE_LEAVE2("Return value: %u", rc);
return rc;
}
/*****************************************************************************
PROCEDURE NAME : gld_process_tmr_node_restart_wait_timeout
DESCRIPTION :
ARGUMENTS :gld_cb - ptr to the GLD control block
evt - ptr to the event.
RETURNS :NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
NOTES : None
*****************************************************************************/
static uint32_t gld_process_tmr_node_restart_wait_timeout(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->gld_cb;
GLSV_GLD_GLND_DETAILS *node_details;
GLSV_GLD_GLND_RSC_REF *glnd_rsc;
SaLckResourceIdT rsc_id;
uint32_t node_id;
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->info.tmr.mdest_id);
TRACE_ENTER2("Node restart wait timer expired: node_id %u", node_id);
if ((node_details =
(GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details, (uint8_t *)&node_id)) == NULL) {
LOG_ER("Evenr from unknown glnd: node_id %u", node_id);
return NCSCC_RC_FAILURE;
}
if (gld_cb->ha_state == SA_AMF_HA_ACTIVE) {
/* checkpoint node_details */
glsv_gld_a2s_ckpt_node_details(gld_cb, node_details->dest_id, GLSV_GLD_EVT_GLND_DOWN);
/* If this node is non master for any resource, then send node status to the master */
gld_process_send_non_master_status(gld_cb, node_details, GLND_DOWN_STATE);
/* Remove the reference to each of the resource referred by this node */
glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uint8_t *)0);
if (glnd_rsc) {
rsc_id = glnd_rsc->rsc_id;
while (glnd_rsc) {
gld_rsc_rmv_node_ref(gld_cb, glnd_rsc->rsc_info, glnd_rsc, node_details,
glnd_rsc->rsc_info->can_orphan);
glnd_rsc =
(GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree,
(uint8_t *)&rsc_id);
if (glnd_rsc)
rsc_id = glnd_rsc->rsc_id;
}
}
/* Now delete this node details node */
if (ncs_patricia_tree_del(&gld_cb->glnd_details, (NCS_PATRICIA_NODE *)node_details) != NCSCC_RC_SUCCESS) {
LOG_ER("Patricia tree del failed: node_id %u",
node_details->node_id);
} else {
m_MMGR_FREE_GLSV_GLD_GLND_DETAILS(node_details);
TRACE("Node getting removed on active: node_id %u", node_id);
}
} else {
node_details->status = GLND_DOWN_STATE;
}
return NCSCC_RC_SUCCESS;
}
/******************************************************************************
Name : avnd_get_mds_dest_from_nodeid
Description : This routine return mds dest of AvND for a particular node id.
Arguments : cb - ptr to the AvND control block.
mds_dest - Mds dest of AvND coming up.
Return Values : 0/mds dest.
Notes : None
******************************************************************************/
MDS_DEST avnd_get_mds_dest_from_nodeid(AVND_CB *cb, NODE_ID node_id)
{
AVND_NODEID_TO_MDSDEST_MAP *rec = NULL;
rec = (AVND_NODEID_TO_MDSDEST_MAP *)ncs_patricia_tree_get(&cb->nodeid_mdsdest_db, (uns8 *)&(node_id));
if (rec == NULL) {
LOG_ER("nodeid_mdsdest rec doesn't exist, Rec get failed: NodeId:%u",node_id);
return 0;
}
return rec->mds_dest;
}
/*****************************************************************************
PROCEDURE NAME : gld_process_tmr_node_restart_wait_timeout
DESCRIPTION :
ARGUMENTS :gld_cb - ptr to the GLD control block
evt - ptr to the event.
RETURNS :NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
NOTES : None
*****************************************************************************/
static uns32 gld_process_tmr_node_restart_wait_timeout(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->gld_cb;
GLSV_GLD_GLND_DETAILS *node_details;
GLSV_GLD_GLND_RSC_REF *glnd_rsc;
SaLckResourceIdT rsc_id;
uns32 node_id;
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(evt->info.tmr.mdest_id);
m_LOG_GLD_HEADLINE(GLD_ND_RESTART_WAIT_TMR_EXP, NCSFL_SEV_NOTICE, __FILE__, __LINE__, node_id);
if ((node_details =
(GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details, (uns8 *)&node_id)) == NULL) {
m_LOG_GLD_HEADLINE(GLD_UNKNOWN_GLND_EVT, NCSFL_SEV_NOTICE, __FILE__, __LINE__, node_id);
return NCSCC_RC_FAILURE;
}
if (gld_cb->ha_state == SA_AMF_HA_ACTIVE) {
/* checkpoint node_details */
glsv_gld_a2s_ckpt_node_details(gld_cb, node_details->dest_id, GLSV_GLD_EVT_GLND_DOWN);
/* If this node is non master for any resource, then send node status to the master */
gld_process_send_non_master_status(gld_cb, node_details, GLND_DOWN_STATE);
/* Remove the reference to each of the resource referred by this node */
glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uns8 *)0);
if (glnd_rsc) {
rsc_id = glnd_rsc->rsc_id;
while (glnd_rsc) {
gld_rsc_rmv_node_ref(gld_cb, glnd_rsc->rsc_info, glnd_rsc, node_details,
glnd_rsc->rsc_info->can_orphan);
glnd_rsc =
(GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree,
(uns8 *)&rsc_id);
if (glnd_rsc)
rsc_id = glnd_rsc->rsc_id;
}
}
/* Now delete this node details node */
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);
} else {
m_MMGR_FREE_GLSV_GLD_GLND_DETAILS(node_details);
m_LOG_GLD_HEADLINE(GLD_ACTIVE_RMV_NODE, NCSFL_SEV_NOTICE, __FILE__, __LINE__, node_id);
}
} else {
node_details->status = GLND_DOWN_STATE;
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* 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 cpd_clm_cluster_track_cb(const SaClmClusterNotificationBufferT *notificationBuffer,
SaUint32T numberOfMembers, SaAisErrorT error)
{
CPD_CB *cb;
SaClmNodeIdT node_id;
CPD_CPND_INFO_NODE *cpnd_info_node = NULL;
NODE_ID key;
uns32 counter = 0;
/* 1. Get the CPD_CB */
m_CPD_RETRIEVE_CB(cb);
if (cb == NULL) {
return;
} else {
/* 2. Check the HA_STATE */
for (counter = 0; counter < notificationBuffer->numberOfItems; counter++) {
if (notificationBuffer->notification[counter].clusterChange == SA_CLM_NODE_LEFT) {
if (cb->ha_state == SA_AMF_HA_ACTIVE) {
node_id = notificationBuffer->notification[counter].clusterNode.nodeId;
key = node_id;
cpnd_info_node = (CPD_CPND_INFO_NODE *)
ncs_patricia_tree_get(&cb->cpnd_tree, (uns8 *)&key);
if (cpnd_info_node) {
cpd_process_cpnd_down(cb, &cpnd_info_node->cpnd_dest);
}
} else if (cb->ha_state == SA_AMF_HA_STANDBY) {
node_id = notificationBuffer->notification[counter].clusterNode.nodeId;
key = node_id;
cpnd_info_node = (CPD_CPND_INFO_NODE *)
ncs_patricia_tree_get(&cb->cpnd_tree, (uns8 *)&key);
if (cpnd_info_node) {
cpnd_info_node->timer_state = 2;
}
}
}
}
}
m_CPD_GIVEUP_CB;
return;
}
/**
* Function to get the pid info using pid
*
* @param pid
*
* @return NCSCC_RC_SUCCESS
* @return NCSCC_RC_FAILURE
*
*/
DTM_INTRANODE_PID_INFO *dtm_intranode_get_pid_info_using_pid(uint32_t pid)
{
DTM_INTRANODE_PID_INFO *node = NULL;
node =
(DTM_INTRANODE_PID_INFO *) ncs_patricia_tree_get(&dtm_intranode_cb->dtm_intranode_pid_list, (uint8_t *)&pid);
/* Adjust the pointer */
if (NULL != node) {
node = (DTM_INTRANODE_PID_INFO *) (((char *)node)
- (((char *)&(((DTM_INTRANODE_PID_INFO *) 0)->pid_node))
- ((char *)((DTM_INTRANODE_PID_INFO *) 0))));
}
return node;
}
