/******************************************************************************
Name : avnd_nodeid_mdsdest_rec_add
Description : This routine adds 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_add(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 already exists, Rec Add Failed: MdsDest:%lld, NodeId:%u",
mds_dest, node_id);
return NCSCC_RC_FAILURE;
} else {
rec = malloc(sizeof(AVND_NODEID_TO_MDSDEST_MAP));
if (rec == NULL) {
return NCSCC_RC_FAILURE;
} else {
rec->node_id = node_id;
rec->mds_dest = mds_dest;
rec->tree_node.bit = 0;
rec->tree_node.key_info = (uns8 *)&(rec->node_id);
res = ncs_patricia_tree_add(&cb->nodeid_mdsdest_db, &rec->tree_node);
if (NCSCC_RC_SUCCESS != res) {
LOG_ER("Couldn't add nodeid_mdsdest rec, patricia add failed:MdsDest:%lld, NodeId:%u",
mds_dest, node_id);
free(rec);
return res;
}
} /* Else of if(rec == NULL) */
} /* Else of if(rec != NULL) */
return res;
}
/****************************************************************************
Name : mqa_queue_tree_find_and_add
Description : This routine adds the new queue to the queue tree
Arguments :
mqa_cb : pointer to the mqa control block.
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.
MQA_CLIENT_INFO *client_info : Info about the client.
SaMsgQueueOpenFlagsT openFlags :
If flag == true, openFlags is IN parameter.
If flag != true, openFlags is ignored.
Return Values : returns the MQA_QUEUE_INFO node.
Notes : None
******************************************************************************/
MQA_QUEUE_INFO *mqa_queue_tree_find_and_add(MQA_CB *mqa_cb,
SaMsgQueueHandleT hdl_id,
bool flag, MQA_CLIENT_INFO *client_info, SaMsgQueueOpenFlagsT openFlags)
{
MQA_QUEUE_INFO *queue_info = NULL;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* read lock taken by the caller. */
queue_info = (MQA_QUEUE_INFO *)ncs_patricia_tree_get(&mqa_cb->mqa_queue_tree, (uint8_t *)&hdl_id);
if (flag == true) {
/* create and allocate the memory */
if (!queue_info) {
queue_info = (MQA_QUEUE_INFO *)m_MMGR_ALLOC_MQA_QUEUE_INFO;
if (!queue_info) {
TRACE_2("Queue database creation failed");
return NULL;
}
memset(queue_info, 0, sizeof(MQA_QUEUE_INFO));
queue_info->queueHandle = hdl_id;
queue_info->openFlags = openFlags;
queue_info->client_info = client_info;
queue_info->patnode.key_info = (uint8_t *)&queue_info->queueHandle;
queue_info->msg_get_count = 0;
if ((rc =
ncs_patricia_tree_add(&mqa_cb->mqa_queue_tree,
&queue_info->patnode)) != NCSCC_RC_SUCCESS) {
TRACE_2("Queue database Registration Failed");
m_MMGR_FREE_MQA_QUEUE_INFO(queue_info);
return NULL;
}
}
}
TRACE_LEAVE();
return queue_info;
}
/****************************************************************************
* Name : gld_add_glnd_node
* Description : Adds node_details info to the gld_cb and initilizes
node_details->rsc_info_tree
*
* Arguments :GLSV_GLD_CB, glnd_mds_dest
*
* Return Values :
*
* Notes : None.
*****************************************************************************/
GLSV_GLD_GLND_DETAILS *gld_add_glnd_node(GLSV_GLD_CB *gld_cb, MDS_DEST glnd_mds_dest)
{
GLSV_GLD_GLND_DETAILS *node_details;
NCS_PATRICIA_PARAMS params = { sizeof(uint32_t) };
TRACE_ENTER2("glnd_mds_dest %" PRIx64, glnd_mds_dest);
/* Need to add the node details */
node_details = m_MMGR_ALLOC_GLSV_GLD_GLND_DETAILS;
if (node_details == NULL) {
LOG_CR("Node details alloc failed: Error %s", strerror(errno));
assert(0);
}
memset(node_details, 0, sizeof(GLSV_GLD_GLND_DETAILS));
memcpy(&node_details->dest_id, &glnd_mds_dest, sizeof(MDS_DEST));
node_details->node_id = m_NCS_NODE_ID_FROM_MDS_DEST(glnd_mds_dest);
node_details->status = GLND_OPERATIONAL_STATE;
TRACE("EVT Processing MDS GLND UP: node_id %u", node_details->node_id);
/* Initialize the pat tree for resource info */
if ((ncs_patricia_tree_init(&node_details->rsc_info_tree, ¶ms))
!= NCSCC_RC_SUCCESS) {
LOG_ER("Patricia tree init failed");
m_MMGR_FREE_GLSV_GLD_GLND_DETAILS(node_details);
node_details = NULL;
goto end;
}
node_details->pat_node.key_info = (uint8_t *)&node_details->node_id;
if (ncs_patricia_tree_add(&gld_cb->glnd_details, &node_details->pat_node)
!= NCSCC_RC_SUCCESS) {
LOG_ER("Patricia tree add failed");
m_MMGR_FREE_GLSV_GLD_GLND_DETAILS(node_details);
node_details = NULL;
goto end;
}
end:
TRACE_LEAVE2("Node id %u",node_details->node_id);
return node_details;
}
/****************************************************************************
Name : mqa_queue_tree_find_and_add
Description : This routine adds the new queue to the queue tree
Arguments :
mqa_cb : pointer to the mqa control block.
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.
MQA_CLIENT_INFO *client_info : Info about the client.
SaMsgQueueOpenFlagsT openFlags :
If flag == TRUE, openFlags is IN parameter.
If flag != TRUE, openFlags is ignored.
Return Values : returns the MQA_QUEUE_INFO node.
Notes : None
******************************************************************************/
MQA_QUEUE_INFO *mqa_queue_tree_find_and_add(MQA_CB *mqa_cb,
SaMsgQueueHandleT hdl_id,
NCS_BOOL flag, MQA_CLIENT_INFO *client_info, SaMsgQueueOpenFlagsT openFlags)
{
MQA_QUEUE_INFO *queue_info = NULL;
uns32 rc = NCSCC_RC_SUCCESS;
/* read lock taken by the caller. */
queue_info = (MQA_QUEUE_INFO *)ncs_patricia_tree_get(&mqa_cb->mqa_queue_tree, (uns8 *)&hdl_id);
if (flag == TRUE) {
/* create and allocate the memory */
if (!queue_info) {
queue_info = (MQA_QUEUE_INFO *)m_MMGR_ALLOC_MQA_QUEUE_INFO;
if (!queue_info) {
m_LOG_MQSV_A(MQA_QUEUE_ALLOC_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__,
__LINE__);
return NULL;
}
memset(queue_info, 0, sizeof(MQA_QUEUE_INFO));
queue_info->queueHandle = hdl_id;
queue_info->openFlags = openFlags;
queue_info->client_info = client_info;
queue_info->patnode.key_info = (uns8 *)&queue_info->queueHandle;
queue_info->msg_get_count = 0;
if ((rc =
ncs_patricia_tree_add(&mqa_cb->mqa_queue_tree,
&queue_info->patnode)) != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_QUEUE_TREE_ADD_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc,
__FILE__, __LINE__);
m_MMGR_FREE_MQA_QUEUE_INFO(queue_info);
return NULL;
}
}
}
return queue_info;
}
static uint32_t dtm_intranode_create_pid_info(int fd)
{
DTM_INTRANODE_PID_INFO *pid_node = NULL;
TRACE_ENTER();
if (NULL == (pid_node = calloc(1, sizeof(DTM_INTRANODE_PID_INFO)))) {
TRACE("\nMemory allocation failed for DTM_INTRANODE_PID_INFO");
return NCSCC_RC_FAILURE;
}
pid_node->accepted_fd = fd;
pid_node->pid = 0; /* Yet to be filled from the PID Message which is yet to come */
pid_node->node_id = m_NCS_GET_NODE_ID;
pid_node->fd_node.key_info = (uint8_t *)&pid_node->accepted_fd;
if (m_NCS_IPC_CREATE(&pid_node->mbx) != NCSCC_RC_SUCCESS) {
/* Mail box creation failed */
TRACE("Mailbox creation failed,dtm_accept msg");
free(pid_node);
return NCSCC_RC_FAILURE;
} else {
NCS_SEL_OBJ obj;
/* Code added for attaching the mailbox */
if (NCSCC_RC_SUCCESS != m_NCS_IPC_ATTACH(&pid_node->mbx)) {
TRACE("\nMailbox attach failed,dtm_intranode_process_pid_msg");
m_NCS_IPC_RELEASE(&pid_node->mbx, NULL);
free(pid_node);
return NCSCC_RC_FAILURE;
}
obj = m_NCS_IPC_GET_SEL_OBJ(&pid_node->mbx);
/* retreive the corresponding fd for mailbox */
pid_node->mbx_fd = m_GET_FD_FROM_SEL_OBJ(obj); /* extract and fill value needs to be extracted */
}
ncs_patricia_tree_add(&dtm_intranode_cb->dtm_intranode_fd_list, (NCS_PATRICIA_NODE *)&pid_node->fd_node);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : cpd_ckpt_reploc_node_add
Description : This routine adds the new node to ckpt_tree.
Arguments : ckpt_tree - Checkpoint Tree.
ckpt_node - checkpoint Node.
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : The caller takes the cb lock before calling this function
******************************************************************************/
uns32 cpd_ckpt_reploc_node_add(NCS_PATRICIA_TREE *ckpt_reploc_tree, CPD_CKPT_REPLOC_INFO *ckpt_reploc_node,
SaAmfHAStateT ha_state, SaImmOiHandleT immOiHandle)
{
SaAisErrorT err = SA_AIS_OK;
SaNameT replica_dn;
memset(&replica_dn, 0, sizeof(SaNameT));
/* Add the imm runtime object */
if (ha_state == SA_AMF_HA_ACTIVE) {
err = create_runtime_replica_object(ckpt_reploc_node, immOiHandle);
if (err != SA_AIS_OK) {
cpd_log(NCSFL_SEV_ERROR, "create_runtime_replica_object failed %u\n", err);
return NCSCC_RC_FAILURE;
}
}
ckpt_reploc_node->rep_key.ckpt_name.length = m_NCS_OS_HTONS(ckpt_reploc_node->rep_key.ckpt_name.length);
/* node name is obtained from cluster info which always returns in network order, so no need of the conversion for the node_name length */
ckpt_reploc_node->rep_key.node_name.length = m_NCS_OS_HTONS(ckpt_reploc_node->rep_key.node_name.length);
ckpt_reploc_node->patnode.key_info = (uns8 *)&ckpt_reploc_node->rep_key;
if (ncs_patricia_tree_add(ckpt_reploc_tree, &ckpt_reploc_node->patnode) != NCSCC_RC_SUCCESS) {
/* m_LOG_CPD_HEADLINE(CPD_CKPT_REPLOC_INFO_ADD_FAILED, NCSFL_SEV_ERROR); */
/* delete reploc imm runtime object */
if (ha_state == SA_AMF_HA_ACTIVE) {
cpd_create_association_class_dn(&ckpt_reploc_node->rep_key.node_name,
&ckpt_reploc_node->rep_key.ckpt_name, "safReplica", &replica_dn);
if (immutil_saImmOiRtObjectDelete(immOiHandle, &replica_dn) != SA_AIS_OK) {
cpd_log(NCSFL_SEV_ERROR, "Deleting run time object %s FAILED", replica_dn.value);
return NCSCC_RC_FAILURE;
}
return NCSCC_RC_FAILURE;
}
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : cpd_cpnd_info_node_add
Description : This routine adds the new node to ckpt_tree.
Arguments : ckpt_tree - Checkpoint Tree.
ckpt_node - checkpoint Node.
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : The caller takes the cb lock before calling this function
******************************************************************************/
uns32 cpd_cpnd_info_node_find_add(NCS_PATRICIA_TREE *cpnd_tree, MDS_DEST *dest,
CPD_CPND_INFO_NODE **cpnd_info_node, NCS_BOOL *add_flag)
{
/*MDS_DEST key; */
NODE_ID key;
memset(&key, 0, sizeof(NODE_ID));
/* Fill the Key */
key = m_NCS_NODE_ID_FROM_MDS_DEST((*dest));
*cpnd_info_node = (CPD_CPND_INFO_NODE *)
ncs_patricia_tree_get(cpnd_tree, (uns8 *)&key);
if ((*cpnd_info_node == NULL) && (*add_flag == TRUE)) {
*cpnd_info_node = m_MMGR_ALLOC_CPD_CPND_INFO_NODE;
if (*cpnd_info_node == NULL) {
m_LOG_CPD_CL(CPD_CPND_INFO_ALLOC_FAILED, CPD_FC_MEMFAIL, NCSFL_SEV_ERROR, __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
}
memset((*cpnd_info_node), '\0', sizeof(CPD_CPND_INFO_NODE));
/* Store the client_info pointer as msghandle. */
(*cpnd_info_node)->cpnd_dest = *dest;
(*cpnd_info_node)->cpnd_key = m_NCS_NODE_ID_FROM_MDS_DEST((*dest));
/* (*cpnd_info_node)->patnode.key_info = (uns8*)&(m_NCS_NODE_ID_FROM_MDS_DEST((*cpnd_info_node)->cpnd_dest)); */
(*cpnd_info_node)->patnode.key_info = (uns8 *)&((*cpnd_info_node)->cpnd_key);
if (ncs_patricia_tree_add(cpnd_tree, &(*cpnd_info_node)->patnode) != NCSCC_RC_SUCCESS) {
m_LOG_CPD_FCL(CPD_CPND_INFO_NODE_FAILED, CPD_FC_HDLN, NCSFL_SEV_ERROR, *dest, __FILE__,
__LINE__);
return NCSCC_RC_FAILURE;
}
*add_flag = FALSE;
}
return NCSCC_RC_SUCCESS;
}
/****************************************************************************\
PROCEDURE NAME : mqd_red_db_node_add
DESCRIPTION : This routines adds the Object node into the Tree
ARGUMENTS : pMqd - MQD Controll block pointer
pNode - Nodeinfo Node
RETURNS : SUCCESS - All went well
FAILURE - internal processing didn't like something.
\****************************************************************************/
uns32 mqd_red_db_node_add(MQD_CB *pMqd, MQD_ND_DB_NODE *pNode)
{
/*m_HTON_SANAMET_LEN(pNode->info.nodeid); */
pNode->node.key_info = (uns8 *)&pNode->info.nodeid;
return ncs_patricia_tree_add(&pMqd->node_db, (NCS_PATRICIA_NODE *)&pNode->node);
} /* End of mqd_red_db_node_add() */
uns32 dta_reg_svc(NCS_BIND_SVC *bind_svc)
{
DTA_CB *inst = &dta_cb;
DTSV_MSG msg;
REG_TBL_ENTRY *svc;
/*uns32 send_pri; */
SS_SVC_ID svc_id = bind_svc->svc_id;
if (inst->created == FALSE) {
return m_DTA_DBG_SINK_SVC(NCSCC_RC_FAILURE,
"dta_reg_svc: DTA does not exist. First create DTA before registering your service.",
svc_id);
}
if ((strlen(bind_svc->svc_name) + 1) > DTSV_SVC_NAME_MAX)
return m_DTA_DBG_SINK_SVC(NCSCC_RC_FAILURE,
"dta_reg_svc: Service name supplied in registration is either too long or not properly initialized",
svc_id);
m_DTA_LK(&inst->lock);
/* Search the patricia tree for exisiting entries */
/*if ((svc = (REG_TBL_ENTRY *) ncs_find_item(&inst->reg_tbl,
(NCSCONTEXT)&svc_id, dta_match_service)) != NULL) */
if ((svc = (REG_TBL_ENTRY *)ncs_patricia_tree_get(&inst->reg_tbl, (const uns8 *)&svc_id)) != NULL) {
m_DTA_UNLK(&inst->lock);
return m_DTA_DBG_SINK_SVC(NCSCC_RC_FAILURE,
"dta_reg_svc: Service is already registered with DTSv", svc_id);
}
svc = m_MMGR_ALLOC_DTA_REG_TBL;
if (svc == NULL) {
m_DTA_UNLK(&inst->lock);
return m_DTA_DBG_SINK_SVC(NCSCC_RC_FAILURE, "dta_reg_svc: Memory allocation failed", svc_id);
}
memset(svc, 0, sizeof(REG_TBL_ENTRY));
svc->svc_id = svc_id;
svc->log_msg = FALSE;
svc->enable_log = TRUE;
/* Restricting bufferring of logs till NOTICE level severity only */
svc->severity_bit_map = 0xFC;
svc->category_bit_map = 0xFFFFFFFF;
svc->version = bind_svc->version;
strcpy(svc->svc_name, bind_svc->svc_name);
svc->node.key_info = (uns8 *)&svc->svc_id;
/* Add to the patricia tree */
if (ncs_patricia_tree_add(&inst->reg_tbl, (NCS_PATRICIA_NODE *)svc) != NCSCC_RC_SUCCESS) {
m_MMGR_FREE_DTA_REG_TBL(svc);
m_DTA_UNLK(&inst->lock);
return m_DTA_DBG_SINK_SVC(NCSCC_RC_FAILURE,
"dta_reg_svc: Failed to add service registration entry in patricia tree",
svc_id);
}
/*
* Check whether DTS exist. If DTS does not exist then we will send
* registration information to DTS at later time when DTS comes up.
* For buffering of log messages apply defaults and return success.
*/
if (inst->dts_exist == FALSE) {
m_DTA_UNLK(&inst->lock);
return NCSCC_RC_SUCCESS;
}
memset(&msg, '\0', sizeof(DTSV_MSG));
dta_fill_reg_msg(&msg, svc_id, svc->version, svc->svc_name, DTA_REGISTER_SVC);
m_DTA_UNLK(&inst->lock);
/* Always register async */
if (dta_mds_async_send(&msg, inst) != NCSCC_RC_SUCCESS)
return m_DTA_DBG_SINK_SVC(NCSCC_RC_FAILURE, "dta_reg_svc: MDS async send failed", svc_id);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************\
* Function: dtsv_ckpt_add_rmv_updt_dta_dest
*
* Purpose: Add new DTA entry if action is ADD, remove node from the tree if
* action is to remove and update data if request is to update.
*
* Input: cb - CB pointer.
* avnd - Decoded structur.
* action - ADD/RMV/UPDT
* key - SVC_KEY of the service associated with DTA being added/updated
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES: ADD will add to the Patricia tree. ADD also modifies svc_reg patricia
* tree by adding to svc_reg's v_cd_list.
* UPDT is not used.
* RMV will remove dta frm patricia tree and modify svc_reg patricia tree * only on DTA going down.
* Service de-regs are handled by svc_reg async updates.
*
* As per this IR param key is not passed in network order
\**************************************************************************/
uns32 dtsv_ckpt_add_rmv_updt_dta_dest(DTS_CB *cb, DTA_DEST_LIST *dtadest, NCS_MBCSV_ACT_TYPE action, SVC_KEY key)
{
uns32 status = NCSCC_RC_SUCCESS;
DTA_DEST_LIST *to_reg = NULL, *del_reg = NULL;
DTS_SVC_REG_TBL *svc = NULL;
OP_DEVICE *device = NULL;
MDS_DEST dta_key;
SVC_ENTRY *svc_entry = NULL;
SVC_KEY svc_key = {0, 0}, nt_key = {0, 0};
if (dtadest == NULL) {
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dtsv_ckpt_add_rmv_updt_dta_dest: DTA_DEST_LIST ptr is NULL");
}
dta_key = dtadest->dta_addr;
switch (action) {
case NCS_MBCSV_ACT_ADD:
{
SYSF_ASCII_SPECS *spec_entry = NULL;
ASCII_SPEC_INDEX spec_key;
SPEC_ENTRY *per_dta_svc_spec = NULL;
ASCII_SPEC_LIB *lib_hdl = NULL;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
/* Find svc entry in svc_tbl patricia tree */
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);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, (uns32)dta_key);
/*Service should have already been added to patricia tree */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: No service entry in Patricia Tree");
/*For cold-sync also, svc_reg cold sync has to happen prior to this */
}
/* Check if dta is already present in dta_dest patricia tree */
if ((to_reg =
(DTA_DEST_LIST *)ncs_patricia_tree_get(&cb->dta_list, (const uns8 *)&dta_key)) == NULL) {
to_reg = m_MMGR_ALLOC_VCARD_TBL;
if (to_reg == 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_dta_dest: Memory allocation failed");
}
memset(to_reg, '\0', sizeof(DTA_DEST_LIST));
/* Update the fields of DTA_DEST_LIST */
to_reg->dta_addr = dtadest->dta_addr;
to_reg->dta_up = dtadest->dta_up;
to_reg->updt_req = dtadest->updt_req;
to_reg->dta_num_svcs = 0;
/*ncs_create_queue(&to_reg->svc_list); */
to_reg->node.key_info = (uns8 *)&to_reg->dta_addr;
to_reg->svc_list = NULL;
if (ncs_patricia_tree_add(&cb->dta_list, (NCS_PATRICIA_NODE *)&to_reg->node) !=
NCSCC_RC_SUCCESS) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_ADD_FAIL, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta_key),
(uns32)dta_key);
if (NULL != to_reg)
m_MMGR_FREE_VCARD_TBL(to_reg);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Failed to add DTA list in Patricia tree");
}
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_ADD_SUCC, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta_key),
(uns32)dta_key);
} else {
/* Not an error condition - DTA entry might already exist */
/* Adjust the pointer to to_reg with the offset */
to_reg = (DTA_DEST_LIST *)((long)to_reg - DTA_DEST_LIST_OFFSET);
/* Also check if dta-svc relationship already exists */
/* If it does then just break frm this case & return */
if (dts_find_dta(svc, &dta_key) != NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return status;
}
}
/* If svc entry found, just add it to the dta */
dts_add_svc_to_dta(to_reg, svc);
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_ADD, key.ss_svc_id, key.node, (uns32)dta_key);
/* Now add dta into the svc->v_cd_list */
dts_enqueue_dta(svc, to_reg);
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_ADD, key.ss_svc_id, key.node, (uns32)dta_key);
/* Version support : Call to function to load ASCII_SPEC
* library. This function will load all versioning enabled
* ASCII_SPEC libraries.
*/
/* First check whether CB last_spec_loaded has valid svc_name or not
* If not, then break else continue to load library
*/
if (*cb->last_spec_loaded.svc_name == 0) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
break;
}
lib_hdl =
(ASCII_SPEC_LIB *)dts_ascii_spec_load(cb->last_spec_loaded.svc_name,
cb->last_spec_loaded.version, 1);
/* memset the spec_key first before filling it up */
memset(&spec_key, '\0', sizeof(ASCII_SPEC_INDEX));
spec_key.svc_id = svc->ntwk_key.ss_svc_id;
spec_key.ss_ver = cb->last_spec_loaded.version;
/*Check if ASCII_SPEC table for this service is already loaded.
* If no, read the config file */
if ((spec_entry =
(SYSF_ASCII_SPECS *)ncs_patricia_tree_get(&cb->svcid_asciispec_tree,
(const uns8 *)&spec_key)) == NULL) {
/* If ASCII_SPEC table is versioning enabled, this means
* service name & version specified was incorrect.
*/
dts_log(NCSFL_SEV_ERROR, "\n Service cribbing : %d\n", svc->my_key.ss_svc_id);
fflush(stdout);
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: ASCII_SPEC library couldn't be loaded. Check service name & version no. across ASCII_SPEC tables, registration parameters & library name.");
} else {
/* Add an ASCII_SPEC entry for each service registration.
* So any log message will directly index to this entry and
* get the relevant spec pointer to use.
*/
per_dta_svc_spec = m_MMGR_ALLOC_DTS_SVC_SPEC;
if (per_dta_svc_spec == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_ADD_FAIL, 0, m_NCS_NODE_ID_FROM_MDS_DEST(dta_key),
(uns32)dta_key);
/* Do rest of cleanup, cleaning service regsitration table etc */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Memory allocation failed");
}
memset(per_dta_svc_spec, '\0', sizeof(SPEC_ENTRY));
per_dta_svc_spec->dta_addr = dta_key;
per_dta_svc_spec->spec_struct = spec_entry;
per_dta_svc_spec->lib_struct = lib_hdl;
strcpy(per_dta_svc_spec->svc_name, cb->last_spec_loaded.svc_name);
/* Add to the svc reg tbl's spec list */
per_dta_svc_spec->next_spec_entry = svc->spec_list; /* point next to the rest of list */
svc->spec_list = per_dta_svc_spec; /*Add new struct to start of list */
/* Increment use count */
spec_entry->use_count++;
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
/* Yet not using UPDT for DTA_DEST_LIST */
case NCS_MBCSV_ACT_UPDATE:
{
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if ((to_reg =
(DTA_DEST_LIST *)ncs_patricia_tree_get(&cb->dta_list, (const uns8 *)&dta_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_dta_dest: NCS_MBCSV_ACT_UPDATE - DTA entry does not exist in Patricia Tree");
}
to_reg = (DTA_DEST_LIST *)((long)to_reg - DTA_DEST_LIST_OFFSET);
to_reg->dta_addr = dtadest->dta_addr;
to_reg->dta_up = dtadest->dta_up;
to_reg->updt_req = dtadest->updt_req;
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
case NCS_MBCSV_ACT_RMV:
{
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if ((to_reg =
(DTA_DEST_LIST *)ncs_patricia_tree_get(&cb->dta_list, (const uns8 *)&dta_key)) != NULL) {
to_reg = (DTA_DEST_LIST *)((long)to_reg - DTA_DEST_LIST_OFFSET);
svc_entry = to_reg->svc_list;
/* Remove dta entry frm the svc->v_cd_lists for all svcs */
while (svc_entry != NULL) {
svc = svc_entry->svc;
if (svc != NULL) {
svc_key = svc->my_key;
/* Network order key added */
nt_key = svc->ntwk_key;
}
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);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Service entry not found in Patricia tree");
}
/* remove dta from svc->v_cd_list */
if ((del_reg = (DTA_DEST_LIST *)dts_dequeue_dta(svc, to_reg)) == NULL) {
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV_FAIL, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Don't return failure, continue rmeoving service frm dta */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Failed to remove dta entry frm svc->v_cd_list");
} else
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Versioning support: Remove spec entry corresponding to the
* DTA from svc's spec_list.
*/
if (dts_del_spec_frm_svc(svc, dta_key, NULL) != NCSCC_RC_SUCCESS) {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Unable to remove spec entry");
}
/*Point to next entry before deleting svc frm svc_list */
svc_entry = svc_entry->next_in_dta_entry;
/* remove svc from dta->svc_list */
if ((svc = (DTS_SVC_REG_TBL *)dts_del_svc_frm_dta(to_reg, svc)) == NULL) {
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV_FAIL, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Don't return, continue */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_dta_dest: Failed to delete svc from dta->svc_list");
} else
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
/* Check if svc entry is required or not */
if (svc->dta_count == 0) {
if (&svc->device.cir_buffer != NULL)
dts_circular_buffer_free(&svc->device.cir_buffer);
device = &svc->device;
m_DTS_FREE_FILE_LIST(device);
ncs_patricia_tree_del(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_RMVD, svc_key.ss_svc_id, svc_key.node,
(uns32)to_reg->dta_addr);
if (svc != NULL)
m_MMGR_FREE_SVC_REG_TBL(svc);
}
} /*end of while svc!=NULL */
/* Now delete the dta entry */
if (to_reg->svc_list == NULL) {
ncs_patricia_tree_del(&cb->dta_list, (NCS_PATRICIA_NODE *)&to_reg->node);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_RMV_SUCC, 0,
m_NCS_NODE_ID_FROM_MDS_DEST(to_reg->dta_addr),
(uns32)to_reg->dta_addr);
if (NULL != to_reg)
m_MMGR_FREE_VCARD_TBL(to_reg);
}
} else {
/* Not an error condition */
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
default:
/* Log error */
status = NCSCC_RC_FAILURE;
}
return status;
}
/****************************************************************************\
* Function: dtsv_ckpt_add_rmv_updt_svc_reg
*
* Purpose: Add new entry if action is ADD, remove from the table if
* action is to remove and update data if request is to update.
*
* Input: cb - CB pointer.
* svcreg - pointer to SVC REG table structure.
* action - ADD/RMV/UPDT
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES: ADD takes care of forming the node entry for DTS_SVC_REG_TBL as well
* as forming the individual service node.
* ADD just adds svc_reg to DTA Patricia tree.
* Hence, DTS_SVC_REG_TBL Async update(ADD) needs to be sent after
* modification on the DTA Patricia tree in active DTS.
* UPDT takes care of the changes in policy/filtering settings.
* DTS_SVC_REG_TBL ADD happens before DTA_DEST_LIST ADD.
* DTS_SVC_REG_TBL RMV takes care of removing svc entries from all DTAs
* in its v_cd_list.
\**************************************************************************/
uns32 dtsv_ckpt_add_rmv_updt_svc_reg(DTS_CB *cb, DTS_SVC_REG_TBL *svcreg,
NCS_MBCSV_ACT_TYPE action)
{
uns32 status = NCSCC_RC_SUCCESS;
DTS_SVC_REG_TBL *svc_ptr = NULL, *node_reg_ptr = NULL;
DTA_DEST_LIST *to_reg = NULL;
SVC_KEY nt_key, key;
OP_DEVICE *device = NULL;
DTA_ENTRY *dta_entry = NULL;
MDS_DEST *vkey = NULL;
switch (action) {
case NCS_MBCSV_ACT_ADD:
{
/*
* add new SVC_REG entry into pat tree.
*/
key.node = svcreg->my_key.node;
key.ss_svc_id = 0;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(svcreg->my_key.node);
nt_key.ss_svc_id = 0;
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
/* Check whether the Node exist in the node registration table
* if yes, do nothing else create new entry in table and
* fill the datastructure*/
if ((node_reg_ptr =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) == NULL) {
node_reg_ptr = m_MMGR_ALLOC_SVC_REG_TBL;
if (node_reg_ptr == 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_svc_reg: Memory allocation failed");
}
memset(node_reg_ptr, '\0', sizeof(DTS_SVC_REG_TBL));
/* Check for NULL value of svcreg parameter, if not NULL
Copy the attributes of the node passed by decoder */
node_reg_ptr->my_key.node = key.node;
node_reg_ptr->my_key.ss_svc_id = 0;
/* Network order key added */
node_reg_ptr->ntwk_key = nt_key;
node_reg_ptr->node.key_info = (uns8 *)&node_reg_ptr->ntwk_key;
node_reg_ptr->v_cd_list = NULL;
node_reg_ptr->dta_count = 0;
node_reg_ptr->my_node = node_reg_ptr;
if (svcreg->my_key.ss_svc_id == 0) { /*updt for node entry */
/*cold sync update for node entry, set attributes accordingly */
m_DTS_SET_SVC_REG_TBL(node_reg_ptr, svcreg);
} else {
/*async update for new svc_reg, so initialize node param */
node_reg_ptr->per_node_logging = NODE_LOGGING;
/* Copy attributes of node policy & op device */
node_reg_ptr->svc_policy.enable = NODE_ENABLE;
node_reg_ptr->svc_policy.category_bit_map = NODE_CATEGORY_FILTER;
node_reg_ptr->svc_policy.severity_bit_map = NODE_SEVERITY_FILTER;
node_reg_ptr->svc_policy.log_dev = NODE_LOG_DEV;
node_reg_ptr->svc_policy.log_file_size = NODE_LOGFILE_SIZE;
node_reg_ptr->svc_policy.file_log_fmt = NODE_FILE_LOG_FMT;
node_reg_ptr->svc_policy.cir_buff_size = NODE_CIR_BUFF_SIZE;
node_reg_ptr->svc_policy.buff_log_fmt = NODE_BUFF_LOG_FMT;
node_reg_ptr->device.new_file = TRUE;
node_reg_ptr->device.file_open = FALSE;
node_reg_ptr->device.last_rec_id = 0;
}
/* Add the node to the patricia tree */
if (ncs_patricia_tree_add(&cb->svc_tbl, (NCS_PATRICIA_NODE *)node_reg_ptr) !=
NCSCC_RC_SUCCESS) {
/* Attempt to add node was unsuccessful */
if (NULL != node_reg_ptr)
m_MMGR_FREE_SVC_REG_TBL(node_reg_ptr);
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_SVCREG_ADD_FAIL(DTS_EV_SVC_REG_ENT_ADD_FAIL, key.ss_svc_id, key.node,
0);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_FAILED, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Failed to add node registration in Patricia tree");
}
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_ADD, key.ss_svc_id, key.node, 0);
}
/*end of creating new entry for node */
key.ss_svc_id = svcreg->my_key.ss_svc_id;
/* Network order key added */
nt_key.ss_svc_id = m_NCS_OS_HTONL(svcreg->my_key.ss_svc_id);
/* Check whether the Service exist in the service registration
* table. If yes, then add the DTA v-card in the v-card queue.
* If NO then create new entry in the table. Initialize it with
* the default.Enqueue the v-card in the v-card table. */
if ((svc_ptr =
(DTS_SVC_REG_TBL *)ncs_patricia_tree_get(&cb->svc_tbl, (const uns8 *)&nt_key)) != NULL) {
/* Do nothing */
m_LOG_DTS_EVT(DTS_EV_SVC_ALREADY_REG, key.ss_svc_id, key.node, 0);
} /* end of if svc_ptr */
else {
/* Add to patricia tree; then create link list and add the new
* element to it */
svc_ptr = m_MMGR_ALLOC_SVC_REG_TBL;
if (svc_ptr == 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_svc_reg : Memory allocation failed");
}
memset(svc_ptr, '\0', sizeof(DTS_SVC_REG_TBL));
svc_ptr->my_key.ss_svc_id = key.ss_svc_id;
svc_ptr->my_key.node = key.node;
/* Network order key added */
svc_ptr->ntwk_key = nt_key;
svc_ptr->node.key_info = (uns8 *)&svc_ptr->ntwk_key;
svc_ptr->v_cd_list = NULL;
svc_ptr->dta_count = 0;
svc_ptr->my_node = node_reg_ptr;
m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg);
if (ncs_patricia_tree_add(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc_ptr) !=
NCSCC_RC_SUCCESS) {
/* Attempt to add node was unsuccessful */
if (NULL != svc_ptr)
m_MMGR_FREE_SVC_REG_TBL(svc_ptr);
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_SVCREG_ADD_FAIL(DTS_EV_SVC_REG_ENT_ADD_FAIL, key.ss_svc_id, key.node,
0);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_FAILED, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Failed to add service entry in patricia tree");
}
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_ADD, key.ss_svc_id, key.node, 0);
svc_ptr->device.last_rec_id = svcreg->device.last_rec_id;
m_LOG_DTS_EVT(DTS_EV_SVC_REG_SUCCESSFUL, key.ss_svc_id, key.node, 0);
} /*end of else */
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
}
break;
case NCS_MBCSV_ACT_UPDATE:
{
if (NULL != svcreg) {
key = svcreg->my_key;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if (svcreg->my_key.ss_svc_id == 0) { /*Node policy change */
/* update the policy for all services in the node */
if ((svc_ptr =
(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);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Node entry not found in the patricia tree");
}
/* Update this node first */
m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_UPDT, key.ss_svc_id, key.node, 0);
if (cb->cli_bit_map != 0) {
while ((svc_ptr != NULL) && (svc_ptr->my_key.node == key.node)) {
switch (cb->cli_bit_map) {
case osafDtsvNodeMessageLogging_ID:
if (svcreg->per_node_logging == FALSE)
svc_ptr->device.new_file = TRUE;
break;
case osafDtsvNodeCategoryBitMap_ID:
svc_ptr->svc_policy.category_bit_map =
svcreg->svc_policy.category_bit_map;
break;
case osafDtsvNodeLoggingState_ID:
svc_ptr->svc_policy.enable =
svcreg->svc_policy.enable;
break;
case osafDtsvNodeSeverityBitMap_ID:
svc_ptr->svc_policy.severity_bit_map =
svcreg->svc_policy.severity_bit_map;
break;
default:
/* Do nothing, it should not hit this */
break;
} /*end of switch */
nt_key = svc_ptr->ntwk_key;
/*m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg); */
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_UPDT, key.ss_svc_id, key.node,
0);
svc_ptr =
(DTS_SVC_REG_TBL *)dts_get_next_svc_entry(&cb->svc_tbl,
(SVC_KEY *)
&nt_key);
} /*end of while */
/* Re-set the cli_bit_map for subsequent policy changes */
cb->cli_bit_map = 0;
} /*end of if cli_bit_map */
} else { /*Service policy change */
if ((svc_ptr =
(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);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, 0);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg : Service entry not found in the patricia tree");
} else {
m_DTS_SET_SVC_REG_TBL(svc_ptr, svcreg);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_UPDT, key.ss_svc_id, key.node, 0);
}
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
} else {
return NCSCC_RC_FAILURE;
}
}
break;
case NCS_MBCSV_ACT_RMV:
{
SPEC_CKPT spec_info;
if (NULL != svcreg) {
key.node = svcreg->my_key.node;
key.ss_svc_id = svcreg->my_key.ss_svc_id;
/* Network order key added */
nt_key.node = m_NCS_OS_HTONL(key.node);
nt_key.ss_svc_id = m_NCS_OS_HTONL(key.ss_svc_id);
m_DTS_LK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_LOCKED, &cb->lock);
if ((svc_ptr =
(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);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_NOTFOUND, key.ss_svc_id, key.node, 0);
/* Return Success, since svc is already not present */
return m_DTS_DBG_SINK(NCSCC_RC_SUCCESS,
"dtsv_ckpt_add_rmv_updt_svc_reg : Service entry not found in patricia tree");
}
/*The DTA to be removed from svc_reg->v_cd_list is stored in
* DTS_CB's svc_rmv_mds_dest.
* If svc_rmv_mds_dest is 0, then the svc->dta_count should already
* be zero else there's an error.
* If svc_rmv_mds_dest is not zero, then it is async update for
* svc unregister. In this case, remove the DTA with MDS_DEST
* the same as cb->svc_rmv_mds_dest from
* svc_ptr->v-cd_list, also remove svc entry from dta->svc_list.
*/
if (cb->svc_rmv_mds_dest == 0) {
if (svc_ptr->dta_count == 0) {
if (&svc_ptr->device.cir_buffer != NULL)
dts_circular_buffer_free(&svc_ptr->device.cir_buffer);
device = &svc_ptr->device;
/* Cleanup the DTS_FILE_LIST datastructure for svc */
m_DTS_FREE_FILE_LIST(device);
ncs_patricia_tree_del(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc_ptr);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_RMVD, key.ss_svc_id, key.node, 0);
if (NULL != svc_ptr)
m_MMGR_FREE_SVC_REG_TBL(svc_ptr);
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
return NCSCC_RC_SUCCESS;
} else {
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_FAILED, key.ss_svc_id, key.node, 0);
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_svc_reg: Either MDS_DEST for async update is wrong or database is inconsistent");
}
} /*end of if(cb->svc_rmv_mds_dest == 0) */
else {
vkey = &cb->svc_rmv_mds_dest;
dta_entry = svc_ptr->v_cd_list;
/* iterate through v_cd_list to find the dta to be removed */
while (dta_entry != NULL) {
to_reg = dta_entry->dta;
/* Point to next dta entry before deletion */
dta_entry = dta_entry->next_in_svc_entry;
/*Check if the MDS_DEST for the dta to be removed matches */
if (dts_find_reg(vkey, to_reg) == TRUE) {
if ((svc_ptr =
(DTS_SVC_REG_TBL *)dts_del_svc_frm_dta(to_reg,
svc_ptr)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV_FAIL, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_FAILED, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Unable to remove svc reg entry from dta's list");
}
m_LOG_DTS_EVT(DTS_EV_DTA_SVC_RMV, key.ss_svc_id, key.node,
(uns32)to_reg->dta_addr);
/* Remove dta entry frm svc_ptr->v_cd_list */
if ((to_reg =
(DTA_DEST_LIST *)dts_dequeue_dta(svc_ptr,
to_reg)) == NULL) {
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV_FAIL, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_FAILED, key.ss_svc_id,
key.node, (uns32)to_reg->dta_addr);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Unable to remove adest entry");
}
m_LOG_DTS_EVT(DTS_EV_SVC_DTA_RMV, key.ss_svc_id, key.node,
(uns32)to_reg->dta_addr);
memset(&spec_info, '\0', sizeof(SPEC_CKPT));
/* Versioning support : Remove spec entry corresponding to
* the DTA from svc's spec_list. */
if (dts_del_spec_frm_svc(svc_ptr, *vkey, &spec_info) !=
NCSCC_RC_SUCCESS) {
m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dtsv_ckpt_add_rmv_updt_svc_reg: Unable to remove spec entry");
}
/* Call function to unload the ASCII_SPEC library if
* use_count of the library has become 0.
*/
dts_ascii_spec_load(spec_info.svc_name, spec_info.version, 0);
/* If dta svc queue is empty delete dta frm patricia tree */
if (to_reg->svc_list == NULL) {
/*ncs_destroy_queue(&to_reg->svc_list); */
ncs_patricia_tree_del(&cb->dta_list,
(NCS_PATRICIA_NODE *)
&to_reg->node);
m_LOG_DTS_EVT(DTS_EV_DTA_DEST_RMV_SUCC, 0, key.node,
(uns32)to_reg->dta_addr);
if (NULL != to_reg)
m_MMGR_FREE_VCARD_TBL(to_reg);
}
/*Since the dta is found and deleted exit the while loop */
break;
} /*end of if(dts_find_reg() == TRUE) */
} /*end of while */
} /*end of else (cb->svc_rmv_mds_dest == 0) */
/* Do NOT attempt deletion of service entries while
* it's still syncing with Active DTS esp. if its still yet to
* get the data for DTA LIST. Because until then SVC<->DTA
* mapping won't be established.
* In that case all services which have dta_count = 0 will be
* cleaned at the end of completion of DTA list data-sync.
*/
if ((cb->in_sync == FALSE) && (cb->cold_sync_done < DTSV_CKPT_DTA_DEST_LIST_CONFIG)) {
/* Whatever is needed has been done so return success */
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_SUCCESSFUL, key.ss_svc_id, key.node, 0);
return NCSCC_RC_SUCCESS;
}
/* Delete svc entry when dta_count is zero
*/
else if (svc_ptr->dta_count == 0) {
/* No need of policy handles */
/* Now delete the svc entry from the patricia tree */
/*ncshm_destroy_hdl(NCS_SERVICE_ID_DTSV, svc_ptr->svc_hdl);
m_LOG_DTS_EVT(DTS_EV_SVC_POLCY_HDL_DES, key.ss_svc_id, key.node, 0); */
if (&svc_ptr->device.cir_buffer != NULL)
dts_circular_buffer_free(&svc_ptr->device.cir_buffer);
device = &svc_ptr->device;
/* Cleanup the DTS_FILE_LIST datastructure for svc */
m_DTS_FREE_FILE_LIST(device);
ncs_patricia_tree_del(&cb->svc_tbl, (NCS_PATRICIA_NODE *)svc_ptr);
m_LOG_DTS_EVT(DTS_EV_SVC_REG_ENT_RMVD, key.ss_svc_id, key.node, 0);
if (NULL != svc_ptr)
m_MMGR_FREE_SVC_REG_TBL(svc_ptr);
}
m_DTS_UNLK(&cb->lock);
m_LOG_DTS_LOCK(DTS_LK_UNLOCKED, &cb->lock);
m_LOG_DTS_EVT(DTS_EV_SVC_DEREG_SUCCESSFUL, key.ss_svc_id, key.node, 0);
} else {
return NCSCC_RC_FAILURE;
}
}
break;
default:
/* Log error */
return NCSCC_RC_FAILURE;
}
return status;
}
static void svctype_db_add(AVD_SVC_TYPE *svct)
{
unsigned int rc = ncs_patricia_tree_add(&svctype_db, &svct->tree_node);
assert (rc == NCSCC_RC_SUCCESS);
}
/******************************************************************************
Name : avnd_internode_comp_add
Description : This routine adds an internode component in
internode_avail_comp_db.
Arguments : ptree - ptr to the patricia tree of data base.
name - ptr to the component name.
node id - node id of the component.
rc - out param for operation result
pxy_for_ext_comp - Whether this is a proxy for external
component.
comp_is_proxy - Whether internode component is proxy or
proxied. 1 is for proxy, 0 is for proxied.
Return Values : Pointer to AVND_COMP data structure
Notes : None
******************************************************************************/
AVND_COMP *avnd_internode_comp_add(NCS_PATRICIA_TREE *ptree, SaNameT *name,
NODE_ID node_id, uns32 *rc, NCS_BOOL pxy_for_ext_comp, NCS_BOOL comp_is_proxy)
{
AVND_COMP *comp = 0;
*rc = SA_AIS_OK;
/* verify if this component is already present in the db */
if (NULL != (comp = m_AVND_COMPDB_REC_GET(*ptree, *name))) {
/* This is a proxy and already proxying at least one component.
So, no problem. */
*rc = SA_AIS_ERR_EXIST;
TRACE_1("avnd_internode_comp_add already exists. %s and NodeId:%u",
name->value, node_id);
return comp;
}
/* a fresh comp... */
comp = calloc(1, sizeof(AVND_COMP));
if (!comp) {
*rc = SA_AIS_ERR_NO_MEMORY;
goto err;
}
/* update the comp-name (patricia key) */
memcpy(&comp->name, name, sizeof(SaNameT));
comp->pres = SA_AMF_PRESENCE_UNINSTANTIATED;
if (0 == node_id) {
/* This means this is an external component. */
m_AVND_COMP_TYPE_SET_EXT_CLUSTER(comp);
}
m_AVND_COMP_TYPE_SET_INTER_NODE(comp);
if (TRUE == pxy_for_ext_comp) {
m_AVND_PROXY_FOR_EXT_COMP_SET(comp);
}
if (TRUE == comp_is_proxy) {
m_AVND_COMP_TYPE_PROXY_SET(comp);
} else if (FALSE == comp_is_proxy) {
m_AVND_COMP_TYPE_PROXIED_SET(comp);
}
comp->node_id = node_id;
/* initialize proxied list */
avnd_pxied_list_init(comp);
/* Add to the patricia tree. */
comp->tree_node.bit = 0;
comp->tree_node.key_info = (uns8 *)&comp->name;
*rc = ncs_patricia_tree_add(ptree, &comp->tree_node);
if (NCSCC_RC_SUCCESS != *rc) {
*rc = SA_AIS_ERR_NO_MEMORY;
goto err;
}
TRACE_1("avnd_internode_comp_add:%s nodeid:%u, pxy_for_ext_comp:%u,comp_is_proxy:%u",
comp->name.value, node_id, pxy_for_ext_comp, comp_is_proxy);
return comp;
err:
if (comp) {
avnd_comp_delete(comp);
}
LOG_ER("avnd_internode_comp_add failed.%s: NodeId:%u", name->value, node_id);
return 0;
}
static void cstype_add_to_model(avd_cstype_t *cst)
{
unsigned int rc = ncs_patricia_tree_add(&cstype_db, &cst->tree_node);
assert(rc == NCSCC_RC_SUCCESS);
}
/****************************************************************************\
* Name: dts_apps_ascii_spec_load *
* *
* Description: To load/unload the Application specific ASCII Spec table in DTS *
* *
* Arguments: uns8* - Name of the Configuration File *
* uns32 - what_to_do *
* 1 - REGISTER the ASCII Spec table *
* 0 - UNREGISTER the ASCII spec table *
* *
* Returns: NCSCC_RC_SUCCESS - everything is OK *
* NCSCC_RC_FAILURE - failure *
\****************************************************************************/
uns32 dts_apps_ascii_spec_load(uns8 *file_name, uns32 what_to_do)
{
/* get the instruments ready */
FILE *fp = NULL;
char lib_name[DTS_MAX_LIBNAME] = { 0 };
char func_name[DTS_MAX_FUNCNAME] = { 0 };
int32 nargs = 0;
uns32 status = NCSCC_RC_SUCCESS;
uns32 (*reg_unreg_routine) () = NULL;
char *dl_error = NULL;
NCS_LIB_REQ_INFO req_info;
ASCII_SPEC_LIB *lib_entry;
NCS_OS_DLIB_HDL *lib_hdl = NULL;
char dbg_str[DTS_MAX_LIB_DBG];
/* open the file */
fp = fopen((char *)file_name, "r");
if (fp == NULL) {
/* inform that there is no such file, and return */
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_apps_ascii_spec_load: Unable to load the file");
}
/* continue till the you reach the end of the file */
while (((nargs = fscanf(fp, "%s %s", lib_name, func_name)) == 2) && (nargs != EOF)) {
/* Check if lib is already loaded or not */
if ((lib_entry =
(ASCII_SPEC_LIB *)ncs_patricia_tree_get(&dts_cb.libname_asciispec_tree,
(const uns8 *)lib_name)) != NULL) {
memset(func_name, 0, DTS_MAX_FUNCNAME);
memset(lib_name, 0, DTS_MAX_LIBNAME);
continue;
}
/* Load the library if REGISTRATION is to be peformed */
if (what_to_do == 1) {
lib_hdl = m_NCS_OS_DLIB_LOAD(lib_name, m_NCS_OS_DLIB_ATTR);
if ((dl_error = m_NCS_OS_DLIB_ERROR()) != NULL) {
/* log the error returned from dlopen() */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_apps_ascii_spec_load: Unable to load library.");
dts_log(NCSFL_SEV_ERROR, "\ndts_apps_ascii_spec_load(): m_NCS_OS_DLIB_LOAD() failed: %s\n", lib_name);
reg_unreg_routine = NULL;
lib_hdl = NULL;
memset(func_name, 0, DTS_MAX_FUNCNAME);
memset(lib_name, 0, DTS_MAX_LIBNAME);
continue;
}
}
/* load the symbol into DTS Engine process space */
reg_unreg_routine = m_NCS_OS_DLIB_SYMBOL(lib_hdl, func_name);
if ((dl_error = m_NCS_OS_DLIB_ERROR()) != NULL) {
/* log the error returned from dlopen() */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_apps_ascii_spec_load: Unable to load symbol");
dts_log
(NCSFL_SEV_ERROR, "\ndts_apps_ascii_spec_load(): m_NCS_OS_DLIB_SYMBOL() failed(lib name, func name, error): %s, %s, %s\n",
lib_name, func_name, dl_error);
reg_unreg_routine = NULL;
lib_hdl = NULL;
memset(func_name, 0, DTS_MAX_FUNCNAME);
memset(lib_name, 0, DTS_MAX_LIBNAME);
continue;
}
/* do the INIT/DEINIT now... */
if (reg_unreg_routine != NULL) {
memset(&req_info, 0, sizeof(NCS_LIB_REQ_INFO));
req_info.i_op = NCS_LIB_REQ_CREATE;
/* do the registration */
status = (*reg_unreg_routine) (&req_info);
if (status != NCSCC_RC_SUCCESS) {
/* log the error */
sprintf(dbg_str, "ASCII spec registration failed for - %s", lib_name);
m_LOG_DTS_DBGSTR_NAME(DTS_GLOBAL, dbg_str, 0, 0);
} else {
/* log the success, and the function name */
/* Create patricia tree entry for ascii_spec lib name */
lib_entry = m_MMGR_ALLOC_DTS_LIBNAME;
if (lib_entry == NULL) {
fclose(fp);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_apps_ascii_spec_load: Memory allocation for patricia node failed");
}
memset(lib_entry, '\0', sizeof(ASCII_SPEC_LIB));
strcpy((char *)lib_entry->lib_name, lib_name);
lib_entry->libname_node.key_info = (uns8 *)lib_entry->lib_name;
lib_entry->lib_hdl = lib_hdl;
lib_entry->use_count++;
/* Add node to patricia tree table */
if (ncs_patricia_tree_add
(&dts_cb.libname_asciispec_tree,
(NCS_PATRICIA_NODE *)lib_entry) != NCSCC_RC_SUCCESS) {
fclose(fp);
m_MMGR_FREE_DTS_LIBNAME(lib_entry);
return m_DTS_DBG_SINK(NCSCC_RC_FAILURE,
"dts_apps_ascii_spec_load: Failed to add node to paticia tree");
}
} /*end of else */
}
/*end of if reg_unreg_routine != NULL */
reg_unreg_routine = NULL;
lib_hdl = NULL;
memset(func_name, 0, DTS_MAX_FUNCNAME);
memset(lib_name, 0, DTS_MAX_LIBNAME);
} /* for all the libraries - end of while */
if (nargs != EOF) {
/* log the error */
m_DTS_DBG_SINK(NCSCC_RC_FAILURE, "dts_apps_ascii_spec_load: Config file is corrupted.");
/* set the return code */
status = NCSCC_RC_FAILURE;
}
/* close the file */
fclose(fp);
return status;
}
/****************************************************************************\
PROCEDURE NAME : mqd_db_node_add
DESCRIPTION : This routines adds the Object node into the Tree
ARGUMENTS : pMqd - MQD Controll block pointer
pNode - Object Node
RETURNS : SUCCESS - All went well
FAILURE - internal processing didn't like something.
\****************************************************************************/
uns32 mqd_db_node_add(MQD_CB *pMqd, MQD_OBJ_NODE *pNode)
{
/*m_HTON_SANAMET_LEN(pNode->oinfo.name.length); */
pNode->node.key_info = (uns8 *)&pNode->oinfo.name;
return ncs_patricia_tree_add(&pMqd->qdb, (NCS_PATRICIA_NODE *)&pNode->node);
} /* End of mqd_db_node_add() */
