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