/****************************************************************************
Name : avnd_mon_task_create
Description : This routine creates & starts AvND Passive monitoring task.
Arguments : None.
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 avnd_mon_task_create(void)
{
uns32 rc;
/* create avnd task */
rc = m_NCS_TASK_CREATE((NCS_OS_CB)avnd_mon_process, NULL,
"AVND_MON", m_AVND_TASK_PRIORITY, m_AVND_STACKSIZE, &gl_avnd_mon_task_hdl);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("Passive Monitoring thread CREATE failed");
goto err;
}
TRACE_1("Created Passive Monitoring thread");
/* now start the task */
rc = m_NCS_TASK_START(gl_avnd_mon_task_hdl);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("Passive Monitoring thread START failed");
goto err;
}
TRACE_1("Started Passive Monitoring thread");
return rc;
err:
/* destroy the task */
if (gl_avnd_mon_task_hdl) {
/* release the task */
m_NCS_TASK_RELEASE(gl_avnd_mon_task_hdl);
gl_avnd_mon_task_hdl = 0;
}
return rc;
}
/****************************************************************************
Name : avnd_mbx_create
Description : This routine creates & attaches AvND mailbox.
Arguments : cb - ptr to AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 avnd_mbx_create(AVND_CB *cb)
{
uns32 rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* create the mail box */
rc = m_NCS_IPC_CREATE(&cb->mbx);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("AvND Mailbox creation failed");
goto err;
}
TRACE("AvND mailbox creation success");
/* attach the mail box */
rc = m_NCS_IPC_ATTACH(&cb->mbx);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("AvND mailbox attach failed");
goto err;
}
TRACE_LEAVE2("AvND mailbox attach success");
return rc;
err:
/* destroy the mailbox */
if (cb->mbx)
avnd_mbx_destroy(cb);
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : ava_hdl_rec_add
Description : This routine adds the handle record to the handle db.
Arguments : cb - ptr tot he AvA control block
hdl_db - ptr to the hdl db
reg_cbks - ptr to the set of registered callbacks
Return Values : ptr to the handle record
Notes : None
******************************************************************************/
AVA_HDL_REC *ava_hdl_rec_add(AVA_CB *cb, AVA_HDL_DB *hdl_db, const SaAmfCallbacksT *reg_cbks)
{
AVA_HDL_REC *rec = 0;
TRACE_ENTER();
/* allocate the hdl rec */
if (!(rec = calloc(1, sizeof(AVA_HDL_REC)))) {
LOG_CR("Error occurred calling calloc");
osafassert(0);
}
/* create the association with hdl-mngr */
if (!(rec->hdl = ncshm_create_hdl(cb->pool_id, NCS_SERVICE_ID_AVA, (NCSCONTEXT)rec))) {
LOG_CR("Error occurred during creation of handle");
osafassert(0);
}
/* store the registered callbacks */
if (reg_cbks)
memcpy((void *)&rec->reg_cbk, (void *)reg_cbks, sizeof(SaAmfCallbacksT));
/* add the record to the hdl db */
rec->hdl_node.key_info = (uint8_t *)&rec->hdl;
if (ncs_patricia_tree_add(&hdl_db->hdl_db_anchor, &rec->hdl_node)
!= NCSCC_RC_SUCCESS) {
LOG_CR("Patricia tree add failed ");
osafassert(0);
}
/* update the no of records */
hdl_db->num++;
TRACE_LEAVE2("Handle = %x successfully added to Handle DB, num hdls = %d",rec->hdl,hdl_db->num);
return rec;
}
/****************************************************************************\
* Function: avnd_enqueue_async_update_msgs
*
* Purpose: Enqueue async update messages.
*
* Input: cb - AVND CB pointer.
* dec - Decode message content pointer.
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES:
*
*
\**************************************************************************/
static uns32 avnd_enqueue_async_update_msgs(AVND_CB *cb, NCS_MBCSV_CB_DEC *dec)
{
AVND_ASYNC_UPDT_MSG_QUEUE *updt_msg;
TRACE_ENTER();
/*
* This is a FIFO queue. Add message at the tail of the queue.
*/
if (NULL == (updt_msg = calloc(1, sizeof(AVND_ASYNC_UPDT_MSG_QUEUE)))) {
/* Log error */
LOG_CR("calloc failed for AVND_ASYNC_UPDT_MSG_QUEUE");
return NCSCC_RC_FAILURE;
}
updt_msg->dec = *dec;
/* Add this message in our FIFO queue */
if (!(cb->async_updt_msgs.async_updt_queue))
cb->async_updt_msgs.async_updt_queue = (updt_msg);
else
cb->async_updt_msgs.tail->next = (updt_msg);
cb->async_updt_msgs.tail = (updt_msg);
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : avnd_pgdb_destroy
Description : This routine destroys the PG database.
Arguments : cb - ptr to the AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_pgdb_destroy(AVND_CB *cb)
{
AVND_PG *pg = 0;
uns32 rc = NCSCC_RC_SUCCESS;
/* scan & delete each pg rec */
while (0 != (pg = (AVND_PG *)ncs_patricia_tree_getnext(&cb->pgdb, (uns8 *)0))) {
/* delete the record */
rc = avnd_pgdb_rec_del(cb, &pg->csi_name);
if (NCSCC_RC_SUCCESS != rc)
goto err;
}
/* finally destroy patricia tree */
rc = ncs_patricia_tree_destroy(&cb->pgdb);
if (NCSCC_RC_SUCCESS != rc)
goto err;
TRACE("PG DB destroy success");
return rc;
err:
LOG_CR("PG DB destroy failed");
return rc;
}
/****************************************************************************
Name : avnd_mds_red_send
Description : This routine sends the mds message to specified AvD.
Arguments : cb - ptr to the AvND control block
msg - ptr to the message
dest - ptr to the MDS destination
adest - ptr to the MDS adest(anchor)
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : This funtion as of now is only used to send the ACK-NACK msg
to AvD. This funtion is introduced to overcome the problem
of MDS dropping a msg when the role has changed but MDS in
AvND has not updated its tables about the role change.
Due to this problem MDS will try to send the msg to old
active which may not be there in the system and hence the
msg will be dropped.
With this funtion we are sending msg to the new active AvD
directly, without looking for its MDS role as seen by AvND.
******************************************************************************/
uns32 avnd_mds_red_send(AVND_CB *cb, AVND_MSG *msg, MDS_DEST *dest, MDS_DEST *adest)
{
NCSMDS_INFO mds_info;
MDS_SEND_INFO *send_info = &mds_info.info.svc_send;
MDS_SENDTYPE_RED_INFO *send = &send_info->info.red;
uns32 rc = NCSCC_RC_SUCCESS;
TRACE_ENTER2("Msg type '%u'", msg->type);
/* populate the mds params */
memset(&mds_info, 0, sizeof(NCSMDS_INFO));
mds_info.i_mds_hdl = cb->mds_hdl;
mds_info.i_svc_id = NCSMDS_SVC_ID_AVND;
mds_info.i_op = MDS_SEND;
send_info->i_msg = (NCSCONTEXT)msg;
send_info->i_priority = MDS_SEND_PRIORITY_MEDIUM;
/* this is be used only for ACK NACK for AVD */
if (msg->type != AVND_MSG_AVD)
assert(0);
send_info->i_to_svc = NCSMDS_SVC_ID_AVD;
send_info->i_sendtype = MDS_SENDTYPE_RED;
send->i_to_vdest = *dest;
send->i_to_anc = *adest; /* assumption-:ADEST is same as anchor */
/* send the message */
rc = ncsmds_api(&mds_info);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("AVND MDS send failed: Msg type = %u, vdest = %llu, anchor = %llu",msg->type,send->i_to_vdest,send->i_to_anc);
TRACE_LEAVE2("rc '%u'", rc);
return rc;
}
/****************************************************************************
Name : avnd_mds_vdest_reg
Description : This routine registers the AVND Service with MDS for VDEST.
It does the following:
a) Gets the MDS handle & AvND MDS address
b) installs AvND service with MDS
c) Subscribes to MDS events
Arguments : cb - ptr to the AVND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : MDS messages are not used, we are only interested in MBCSV
messages.
******************************************************************************/
uns32 avnd_mds_vdest_reg(AVND_CB *cb)
{
NCSVDA_INFO vda_info;
NCSMDS_INFO svc_to_mds_info;
memset(&vda_info, '\0', sizeof(NCSVDA_INFO));
cb->avnd_mbcsv_vaddr = AVND_VDEST_ID;
vda_info.req = NCSVDA_VDEST_CREATE;
vda_info.info.vdest_create.i_persistent = FALSE;
vda_info.info.vdest_create.i_policy = NCS_VDEST_TYPE_DEFAULT;
vda_info.info.vdest_create.i_create_type = NCSVDA_VDEST_CREATE_SPECIFIC;
vda_info.info.vdest_create.info.specified.i_vdest = cb->avnd_mbcsv_vaddr;
/* create Vdest address */
if (ncsvda_api(&vda_info) != NCSCC_RC_SUCCESS) {
LOG_CR("Vdest Creation failed");
return NCSCC_RC_FAILURE;
}
/* store the info returned by MDS */
cb->avnd_mbcsv_vaddr_pwe_hdl = vda_info.info.vdest_create.o_mds_pwe1_hdl;
cb->avnd_mbcsv_vaddr_hdl = vda_info.info.vdest_create.o_mds_vdest_hdl;
memset(&svc_to_mds_info, '\0', sizeof(NCSMDS_INFO));
/* Install on mds VDEST */
svc_to_mds_info.i_mds_hdl = cb->avnd_mbcsv_vaddr_pwe_hdl;
svc_to_mds_info.i_svc_id = NCSMDS_SVC_ID_AVND_CNTLR;
svc_to_mds_info.i_op = MDS_INSTALL;
svc_to_mds_info.info.svc_install.i_install_scope = NCSMDS_SCOPE_NONE;
svc_to_mds_info.info.svc_install.i_svc_cb = avnd_mds_cbk;
svc_to_mds_info.info.svc_install.i_mds_q_ownership = FALSE;
svc_to_mds_info.info.svc_install.i_mds_svc_pvt_ver = AVND_MDS_SUB_PART_VERSION;
if (ncsmds_api(&svc_to_mds_info) != NCSCC_RC_SUCCESS) {
memset(&vda_info, '\0', sizeof(NCSVDA_INFO));
vda_info.req = NCSVDA_VDEST_DESTROY;
vda_info.info.vdest_destroy.i_vdest = cb->avnd_mbcsv_vaddr;
ncsvda_api(&vda_info);
LOG_CR("Mds Installation failed");
return NCSCC_RC_FAILURE;
}
return NCSCC_RC_SUCCESS;
}
/************************************************************************************
* Name :glsv_gld_mbcsv_dec_sync_resp
*
* Description : Decode the message at Standby for cold sync and update the database
* Arguments : NCS_MBCSV_CB_ARG - MBCSv callback argument
*
* Return Values : Success / Error
*************************************************************************************/
static uint32_t glsv_gld_mbcsv_dec_sync_resp(GLSV_GLD_CB *gld_cb, NCS_MBCSV_CB_ARG *arg)
{
uint8_t *ptr, num_of_ckpts, data[16];
GLSV_GLD_A2S_RSC_DETAILS *rsc_info;
uint32_t count = 0, rc = NCSCC_RC_SUCCESS, num_of_async_upd;
EDU_ERR ederror = 0;
GLSV_A2S_NODE_LIST *node_list, *tmp1_node_list;
TRACE_ENTER();
if (arg->info.decode.i_uba.ub == NULL) { /* There is no data */
goto end;
}
/* Allocate memory */
rsc_info = m_MMGR_ALLOC_GLSV_GLD_A2S_RSC_DETAILS;
if (rsc_info == NULL) {
LOG_CR("Rsc info alloc failed: Error %s", strerror(errno));
assert(0);
}
memset(rsc_info, 0, sizeof(GLSV_GLD_A2S_RSC_DETAILS));
/* 1. Decode the 1st uint8_t region , we will get the num of ckpts */
ptr = ncs_dec_flatten_space(&arg->info.decode.i_uba, data, sizeof(uint8_t));
num_of_ckpts = ncs_decode_8bit(&ptr);
ncs_dec_skip_space(&arg->info.decode.i_uba, sizeof(uint8_t));
/* Decode the data */
while (count < num_of_ckpts) {
rc = m_NCS_EDU_EXEC(&gld_cb->edu_hdl, glsv_edp_gld_evt_a2s_rsc_details, &arg->info.decode.i_uba,
EDP_OP_TYPE_DEC, &rsc_info, &ederror);
if (rc != NCSCC_RC_SUCCESS) {
goto end;
}
rc = gld_sb_proc_data_rsp(gld_cb, rsc_info);
count++;
memset(rsc_info, 0, sizeof(GLSV_GLD_A2S_RSC_DETAILS));
}
/* Get the async update count */
ptr = ncs_dec_flatten_space(&arg->info.decode.i_uba, data, sizeof(uint32_t));
num_of_async_upd = ncs_decode_32bit(&ptr);
gld_cb->gld_async_cnt = num_of_async_upd;
/* New code */
node_list = rsc_info->node_list;
while (node_list != NULL) {
tmp1_node_list = node_list;
node_list = node_list->next;
m_MMGR_FREE_GLSV_NODE_LIST(tmp1_node_list);
}
m_MMGR_FREE_GLSV_GLD_A2S_RSC_DETAILS(rsc_info);
end:
TRACE_LEAVE();
return rc;
}
uint32_t mqnd_shm_create(MQND_CB *cb)
{
NCS_OS_POSIX_SHM_REQ_INFO mqnd_open_req;
uint32_t rc = NCSCC_RC_SUCCESS;
char shm_name[] = SHM_NAME;
MQND_SHM_VERSION mqnd_shm_version;
TRACE_ENTER();
cb->mqnd_shm.max_open_queues = cb->gl_msg_max_no_of_q;
memset(&mqnd_open_req, '\0', sizeof(mqnd_open_req));
/* Initializing shared memory version */
memset(&mqnd_shm_version, '\0', sizeof(mqnd_shm_version));
mqnd_shm_version.shm_version = MQSV_MQND_SHM_VERSION;
mqnd_open_req.type = NCS_OS_POSIX_SHM_REQ_OPEN;
mqnd_open_req.info.open.i_size =
sizeof(MQND_SHM_VERSION) + (sizeof(MQND_QUEUE_CKPT_INFO) * cb->mqnd_shm.max_open_queues);
mqnd_open_req.info.open.i_offset = 0;
mqnd_open_req.info.open.i_name = shm_name;
mqnd_open_req.info.open.i_map_flags = MAP_SHARED;
mqnd_open_req.info.open.o_addr = NULL;
mqnd_open_req.info.open.i_flags = O_RDWR;
rc = ncs_os_posix_shm(&mqnd_open_req);
if (rc == NCSCC_RC_FAILURE) {
/* INITIALLY IT FAILS SO CREATE A SHARED MEMORY */
mqnd_open_req.info.open.i_flags = O_CREAT | O_RDWR;
rc = ncs_os_posix_shm(&mqnd_open_req);
if (rc == NCSCC_RC_FAILURE) {
LOG_CR("Creation of shared memory segment failed");
return rc;
} else {
memset(mqnd_open_req.info.open.o_addr, 0,
sizeof(MQND_SHM_VERSION) +
(sizeof(MQND_QUEUE_CKPT_INFO) * (cb->mqnd_shm.max_open_queues)));
TRACE_1("First time starting the MQND");
cb->is_restart_done = true;
TRACE("Firsttime Openingthe Ckpt");
cb->is_create_ckpt = true;
memcpy(mqnd_open_req.info.open.o_addr, &mqnd_shm_version, sizeof(mqnd_shm_version));
}
} else
cb->is_create_ckpt = false;
/* Store Shared memory start address which contains MQSV Sharedmemory version */
cb->mqnd_shm.shm_start_addr = mqnd_open_req.info.open.o_addr;
/* Store Shared memory base address which is used by MQSV to checkpoint queue informaition */
cb->mqnd_shm.shm_base_addr = mqnd_open_req.info.open.o_addr + sizeof(mqnd_shm_version);
TRACE_LEAVE();
return rc;
}
/************************************************************************************
* Name : cpd_a2s_ckpt_create
* Description : This routine will update the CPD_MBCSV_MSG (message) which has
* to be sent to Standby for checkpoint create Async Update
* Input Values : CPD_CB , CPD_CKPT_INFO_NODE - CPD checkpoint node
* Return Values : SA_AIS_OK if success else return appropriate error
*
* Notes : The information present in the ckpt_node is copied into cpd_msg(which has to be sent to Standby )
**************************************************************************************************************/
uint32_t cpd_a2s_ckpt_create(CPD_CB *cb, CPD_CKPT_INFO_NODE *ckpt_node)
{
CPD_MBCSV_MSG cpd_msg;
SaAisErrorT rc = SA_AIS_OK;
uint32_t count = 0;
TRACE_ENTER();
memset(&cpd_msg, '\0', sizeof(CPD_MBCSV_MSG));
cpd_msg.type = CPD_A2S_MSG_CKPT_CREATE;
cpd_msg.info.ckpt_create.ckpt_name = ckpt_node->ckpt_name;
cpd_msg.info.ckpt_create.ckpt_id = ckpt_node->ckpt_id;
cpd_msg.info.ckpt_create.ckpt_attrib = ckpt_node->attributes;
cpd_msg.info.ckpt_create.is_unlink_set = ckpt_node->is_unlink_set;
cpd_msg.info.ckpt_create.create_time = ckpt_node->create_time;
cpd_msg.info.ckpt_create.num_users = ckpt_node->num_users;
cpd_msg.info.ckpt_create.num_readers = ckpt_node->num_readers;
cpd_msg.info.ckpt_create.num_writers = ckpt_node->num_writers;
cpd_msg.info.ckpt_create.num_sections = ckpt_node->num_sections;
cpd_msg.info.ckpt_create.is_active_exists = ckpt_node->is_active_exists;
if (cpd_msg.info.ckpt_create.is_active_exists)
cpd_msg.info.ckpt_create.active_dest = ckpt_node->active_dest;
if (ckpt_node->dest_cnt) {
CPD_NODE_REF_INFO *node_list = ckpt_node->node_list;
cpd_msg.info.ckpt_create.dest_cnt = ckpt_node->dest_cnt;
cpd_msg.info.ckpt_create.dest_list = m_MMGR_ALLOC_CPSV_CPND_DEST_INFO(ckpt_node->dest_cnt);
if (cpd_msg.info.ckpt_create.dest_list == NULL) {
LOG_CR("cpd cpnd dest info memory allocation failed");
rc = SA_AIS_ERR_NO_MEMORY;
goto end;
} else {
memset(cpd_msg.info.ckpt_create.dest_list, '\0',
(sizeof(CPSV_CPND_DEST_INFO) * ckpt_node->dest_cnt));
for (count = 0; count < ckpt_node->dest_cnt; count++) {
cpd_msg.info.ckpt_create.dest_list[count].dest = node_list->dest;
node_list = node_list->next;
}
}
}
/* send it to MBCSv */
rc = cpd_mbcsv_async_update(cb, &cpd_msg);
if (rc != SA_AIS_OK)
TRACE_4("cpd A2S ckpt create async failed for ckptid :%llx",ckpt_node->ckpt_id);
else
TRACE_1("cpd A2S ckpt create async success for ckptid :%llx",ckpt_node->ckpt_id);
if (cpd_msg.info.ckpt_create.dest_list)
m_MMGR_FREE_CPSV_CPND_DEST_INFO(cpd_msg.info.ckpt_create.dest_list);
end:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : avnd_pgdb_rec_add
Description : This routine adds a record to the PG database.
Arguments : cb - ptr to the AvND control block
csi_name - ptr to the csi-name
rc - ptr to the operation result
Return Values : ptr to the pg rec, if successful
0, otherwise
Notes : None.
******************************************************************************/
AVND_PG *avnd_pgdb_rec_add(AVND_CB *cb, SaNameT *csi_name, uns32 *rc)
{
AVND_PG *pg = 0;
/* verify if this pg is already present in the db */
if (0 != m_AVND_PGDB_REC_GET(cb->pgdb, *csi_name)) {
*rc = AVND_ERR_DUP_PG;
goto err;
}
/* a fresh pg... */
pg = calloc(1, sizeof(AVND_PG));
if (!pg) {
*rc = AVND_ERR_NO_MEMORY;
goto err;
}
/* update the csi-name (patricia key) */
pg->csi_name = *csi_name;
/* until avd acknowldges it's presence, it doesn't exit */
pg->is_exist = FALSE;
/* initialize the mem-list */
pg->mem_list.order = NCS_DBLIST_ANY_ORDER;
pg->mem_list.cmp_cookie = avsv_dblist_saname_cmp;
pg->mem_list.free_cookie = 0;
/* initialize the track-list */
pg->trk_list.order = NCS_DBLIST_ANY_ORDER;
pg->trk_list.cmp_cookie = avnd_pgdb_trk_key_cmp;
pg->trk_list.free_cookie = 0;
/* add to the patricia tree */
pg->tree_node.bit = 0;
pg->tree_node.key_info = (uns8 *)&pg->csi_name;
*rc = ncs_patricia_tree_add(&cb->pgdb, &pg->tree_node);
if (NCSCC_RC_SUCCESS != *rc) {
*rc = AVND_ERR_TREE;
goto err;
}
TRACE("PG DB record added: CSI = %s",csi_name->value);
return pg;
err:
if (pg)
free(pg);
LOG_CR("PG DB record addition failed: CSI = %s",csi_name->value);
return 0;
}
/*****************************************************************************
PROCEDURE NAME : glnd_resource_req_node_add
DESCRIPTION : Adds the Resource request node
ARGUMENTS :glnd_cb - ptr to the GLND control block
rsc_info - ptr to the resource request info.
RETURNS :The pointer to the resource req node info on success.
else returns NULL.
NOTES : None
*****************************************************************************/
GLND_RESOURCE_REQ_LIST *glnd_resource_req_node_add(GLND_CB *glnd_cb,
GLSV_EVT_RSC_INFO *rsc_info,
MDS_SYNC_SND_CTXT *mds_ctxt, SaLckResourceIdT lcl_resource_id)
{
GLND_RESOURCE_REQ_LIST *res_req_info;
res_req_info = (GLND_RESOURCE_REQ_LIST *)m_MMGR_ALLOC_GLND_RESOURCE_REQ_LIST;
if (!res_req_info) {
LOG_CR("GLND Rsc req list alloc failed: Error %s", strerror(errno));
assert(0);
}
memset(res_req_info, 0, sizeof(GLND_RESOURCE_REQ_LIST));
res_req_info->res_req_hdl_id = ncshm_create_hdl((uint8_t)glnd_cb->pool_id,
NCS_SERVICE_ID_GLND, (NCSCONTEXT)res_req_info);
if (!res_req_info->res_req_hdl_id) {
LOG_ER("GLND Rsc req create handle failed");
m_MMGR_FREE_GLND_RESOURCE_REQ_LIST(res_req_info);
return NULL;
}
memcpy(&res_req_info->resource_name, &rsc_info->resource_name, sizeof(SaNameT));
res_req_info->client_handle_id = rsc_info->client_handle_id;
res_req_info->invocation = rsc_info->invocation;
res_req_info->agent_mds_dest = rsc_info->agent_mds_dest;
res_req_info->call_type = rsc_info->call_type;
res_req_info->glnd_res_mds_ctxt = *mds_ctxt;
res_req_info->lcl_resource_id = lcl_resource_id;
/* add it to the list */
if (glnd_cb->res_req_list != NULL) {
res_req_info->next = glnd_cb->res_req_list;
glnd_cb->res_req_list->prev = res_req_info;
glnd_cb->res_req_list = res_req_info;
} else {
glnd_cb->res_req_list = res_req_info;
}
/* start the timeout timer */
if (rsc_info->call_type == GLSV_SYNC_CALL) {
glnd_start_tmr(glnd_cb, &res_req_info->timeout,
GLND_TMR_RES_REQ_TIMEOUT, rsc_info->timeout, (uint32_t)res_req_info->res_req_hdl_id);
} else {
glnd_start_tmr(glnd_cb, &res_req_info->timeout,
GLND_TMR_RES_REQ_TIMEOUT,
GLSV_LOCK_DEFAULT_TIMEOUT, (uint32_t)res_req_info->res_req_hdl_id);
}
return res_req_info;
}
/****************************************************************************\
PROCEDURE NAME : mqd_db_node_create
DESCRIPTION : This routines create the Object node from the Tree, and
initializes all the resources.
ARGUMENTS : pMqd - MQD Controll block pointer
pNode - Object Node
RETURNS : SUCCESS - All went well
FAILURE - internal processing didn't like something.
\****************************************************************************/
uint32_t mqd_red_db_node_create(MQD_CB *pMqd, MQD_ND_DB_NODE **o_pnode)
{
MQD_ND_DB_NODE *pNode = 0;
pNode = m_MMGR_ALLOC_MQD_ND_DB_NODE;
if (!pNode) {
LOG_CR("%s:%u: Failed To Allocate Memory", __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
}
memset(pNode, 0, sizeof(MQD_ND_DB_NODE));
*o_pnode = pNode;
return NCSCC_RC_SUCCESS;
} /* End of mqd_red_db_node_create() */
uint32_t mqnd_shm_destroy(MQND_CB *cb)
{
NCS_OS_POSIX_SHM_REQ_INFO mqnd_dest_req;
uint32_t rc = NCSCC_RC_SUCCESS;
char shm_name[] = SHM_NAME;
mqnd_dest_req.type = NCS_OS_POSIX_SHM_REQ_UNLINK;
mqnd_dest_req.info.unlink.i_name = shm_name;
rc = ncs_os_posix_shm(&mqnd_dest_req);
if (rc != NCSCC_RC_SUCCESS);
LOG_CR("Destroying the shared memory segment failed");
return rc;
}
/****************************************************************************
Name : avnd_evt_tmr_su_err_esc
Description : This routine handles the the expiry of the 'su error
escalation' timer. It indicates the end of the comp/su
restart probation period for the SU.
Arguments : cb - ptr to the AvND control block
evt - ptr to the AvND event
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_evt_tmr_su_err_esc_evh(AVND_CB *cb, AVND_EVT *evt)
{
AVND_SU *su;
uns32 rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* retrieve avnd cb */
if (0 == (su = (AVND_SU *)ncshm_take_hdl(NCS_SERVICE_ID_AVND, (uns32)evt->info.tmr.opq_hdl))) {
LOG_CR("Unable to retrieve handle");
goto done;
}
TRACE("'%s'", su->name.value);
if (NCSCC_RC_SUCCESS == m_AVND_CHECK_FOR_STDBY_FOR_EXT_COMP(cb, su->su_is_external))
goto done;
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_ERR_ESC_TMR);
switch (su->su_err_esc_level) {
case AVND_ERR_ESC_LEVEL_0:
su->comp_restart_cnt = 0;
su->su_err_esc_level = AVND_ERR_ESC_LEVEL_0;
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_COMP_RESTART_CNT);
break;
case AVND_ERR_ESC_LEVEL_1:
su->su_restart_cnt = 0;
su->su_err_esc_level = AVND_ERR_ESC_LEVEL_0;
cb->node_err_esc_level = AVND_ERR_ESC_LEVEL_0;
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_RESTART_CNT);
break;
case AVND_ERR_ESC_LEVEL_2:
cb->su_failover_cnt = 0;
su->su_err_esc_level = AVND_ERR_ESC_LEVEL_0;
cb->node_err_esc_level = AVND_ERR_ESC_LEVEL_0;
break;
default:
assert(0);
}
m_AVND_SEND_CKPT_UPDT_ASYNC_UPDT(cb, su, AVND_CKPT_SU_ERR_ESC_LEVEL);
done:
if (su)
ncshm_give_hdl((uns32)evt->info.tmr.opq_hdl);
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : avnd_pgdb_init
Description : This routine initializes the PG database.
Arguments : cb - ptr to the AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_pgdb_init(AVND_CB *cb)
{
NCS_PATRICIA_PARAMS params;
uns32 rc = NCSCC_RC_SUCCESS;
memset(¶ms, 0, sizeof(NCS_PATRICIA_PARAMS));
params.key_size = sizeof(SaNameT);
rc = ncs_patricia_tree_init(&cb->pgdb, ¶ms);
if (NCSCC_RC_SUCCESS == rc)
TRACE("PG DB create success");
else
LOG_CR("PG DB create failed");
return rc;
}
/****************************************************************************
Name : avnd_mds_unreg
Description : This routine unregisters the AVND Service from MDS.
Arguments : cb - ptr to the AVND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_mds_unreg(AVND_CB *cb)
{
NCSMDS_INFO mds_info;
uns32 rc = NCSCC_RC_SUCCESS;
memset(&mds_info, 0, sizeof(NCSMDS_INFO));
mds_info.i_mds_hdl = cb->mds_hdl;
mds_info.i_svc_id = NCSMDS_SVC_ID_AVND;
mds_info.i_op = MDS_UNINSTALL;
rc = ncsmds_api(&mds_info);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("Unregistration with MDS failed");
else
TRACE("Unregistration with MDS success");
return rc;
}
/****************************************************************************
* Name : mqd_timer_expiry
*
* Description : This function which is registered with the OS tmr function,
* which will post a message to the corresponding mailbox
* depending on the component type.
*
*****************************************************************************/
void mqd_timer_expiry(NCSCONTEXT uarg)
{
MQD_TMR *tmr = (MQD_TMR *)uarg;
NCS_IPC_PRIORITY priority = NCS_IPC_PRIORITY_HIGH;
MQD_CB *cb;
MQSV_EVT *evt = 0;
uint32_t mqd_hdl;
if (tmr != NULL) {
mqd_hdl = tmr->uarg;
if (tmr->is_active)
tmr->is_active = false;
/* Destroy the timer if it exists.. */
if (tmr->tmr_id != TMR_T_NULL) {
m_NCS_TMR_DESTROY(tmr->tmr_id);
tmr->tmr_id = TMR_T_NULL;
}
/* post a message to the corresponding component */
if ((cb = (MQD_CB *)ncshm_take_hdl(NCS_SERVICE_ID_MQD, mqd_hdl))
!= NULL) {
evt = m_MMGR_ALLOC_MQSV_EVT(NCS_SERVICE_ID_MQD);
if (evt == NULL) {
LOG_CR("%s:%u: Failed To Allocate Memory", __FILE__, __LINE__);
return;
}
memset(evt, 0, sizeof(MQSV_EVT));
evt->type = MQSV_EVT_MQD_CTRL;
evt->msg.mqd_ctrl.type = MQD_MSG_TMR_EXPIRY;
evt->msg.mqd_ctrl.info.tmr_info.nodeid = tmr->nodeid;
evt->msg.mqd_ctrl.info.tmr_info.type = tmr->type;
/* Post the event to MQD Thread */
m_NCS_IPC_SEND(&cb->mbx, evt, priority);
ncshm_give_hdl(mqd_hdl);
}
}
return;
}
/****************************************************************************
* 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 : glsv_gld_mbcsv_enc_warm_sync_rsp
* Description : To encode the message that is to be sent to Standby at the time of warm sync
* Arguments : GLSV_GLD_CB, NCS_MBCSV_CB_ARG - Mbcsv callback argument
*
* Return Values : Success / Error
*
* Notes : This is called at the active side
************************************************************************************************/
static uint32_t glsv_gld_mbcsv_enc_warm_sync_rsp(GLSV_GLD_CB *gld_cb, NCS_MBCSV_CB_ARG *arg)
{
uint32_t rc = NCSCC_RC_SUCCESS;
uint8_t *wsync_ptr;
TRACE_ENTER();
/* Reserve space to send the async update counter */
wsync_ptr = ncs_enc_reserve_space(&arg->info.encode.io_uba, sizeof(uint32_t));
if (wsync_ptr == NULL) {
LOG_CR("GLD enc reserve space failed: Error %s", strerror(errno));
assert(0);
}
/* SEND THE ASYNC UPDATE COUNTER */
ncs_enc_claim_space(&arg->info.encode.io_uba, sizeof(uint32_t));
ncs_encode_32bit(&wsync_ptr, gld_cb->gld_async_cnt);
arg->info.encode.io_msg_type = NCS_MBCSV_MSG_WARM_SYNC_RESP_COMPLETE;
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : avnd_pgdb_rec_del
Description : This routine deletes a PG record from the PG database.
Arguments : cb - ptr to the AvND control block
csi_name - ptr to the csi-name
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_pgdb_rec_del(AVND_CB *cb, SaNameT *csi_name)
{
AVND_PG *pg = 0;
uns32 rc = NCSCC_RC_SUCCESS;
/* get the pg record */
pg = m_AVND_PGDB_REC_GET(cb->pgdb, *csi_name);
if (!pg) {
rc = AVND_ERR_NO_PG;
goto err;
}
/* delete the mem-list */
avnd_pgdb_mem_rec_del_all(cb, pg);
/* delete the track-list */
avnd_pgdb_trk_rec_del_all(cb, pg);
/* remove from the patricia tree */
rc = ncs_patricia_tree_del(&cb->pgdb, &pg->tree_node);
if (NCSCC_RC_SUCCESS != rc) {
rc = AVND_ERR_TREE;
goto err;
}
TRACE("PG DB record deleted: CSI = %s",csi_name->value);
/* free the memory */
free(pg);
return rc;
err:
LOG_CR("PG DB record deletion failed: CSI = %s",csi_name->value);
return rc;
}
/****************************************************************************
* Name : gld_send_res_master_info
*
* Description : This function sends resource-master details to the GLND after it restarts
*
* Arguments : GLSV_GLD_CB, GLSV_GLD_GLND_DETAILS
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t gld_send_res_master_info(GLSV_GLD_CB *gld_cb, GLSV_GLD_GLND_DETAILS *node_details, MDS_DEST dest_id)
{
GLSV_GLD_GLND_RSC_REF *glnd_rsc = NULL;
GLSV_GLD_GLND_DETAILS *master_node_details = NULL;
GLSV_GLND_EVT glnd_evt;
NCSMDS_INFO snd_mds;
uint32_t index = 0;
uint32_t no_of_glnd_res = 0;
GLSV_NODE_LIST *temp_node_list = NULL;
GLSV_GLD_GLND_DETAILS *non_master_node_details = NULL;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
if (gld_cb == NULL)
goto end;
memset(&snd_mds, '\0', sizeof(NCSMDS_INFO));
memset(&glnd_evt, '\0', sizeof(GLSV_GLND_EVT));
glnd_evt.type = GLSV_GLND_EVT_RSC_MASTER_INFO;
if (node_details) {
glnd_rsc = (GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uint8_t *)0);
while (glnd_rsc) {
no_of_glnd_res++;
glnd_rsc =
(GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree,
(uint8_t *)&glnd_rsc->rsc_id);
}
glnd_evt.info.rsc_master_info.no_of_res = no_of_glnd_res;
if (glnd_evt.info.rsc_master_info.no_of_res > 0) {
glnd_evt.info.rsc_master_info.rsc_master_list =
m_MMGR_ALLOC_GLND_RES_MASTER_LIST_INFO(no_of_glnd_res);
if (glnd_evt.info.rsc_master_info.rsc_master_list == NULL) {
LOG_CR("Memory Alloc Failure: Error %s", strerror(errno)); /* Log the error */
assert(0);
}
memset(glnd_evt.info.rsc_master_info.rsc_master_list, 0,
(sizeof(GLSV_GLND_RSC_MASTER_INFO_LIST) * no_of_glnd_res));
glnd_rsc =
(GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree, (uint8_t *)0);
while (glnd_rsc) {
/* Get the master node for this resource */
master_node_details =
(GLSV_GLD_GLND_DETAILS *)ncs_patricia_tree_get(&gld_cb->glnd_details,
(uint8_t *)&glnd_rsc->
rsc_info->node_list->node_id);
if (master_node_details) {
glnd_evt.info.rsc_master_info.rsc_master_list[index].rsc_id = glnd_rsc->rsc_id;
glnd_evt.info.rsc_master_info.rsc_master_list[index].master_dest_id =
glnd_rsc->rsc_info->node_list->dest_id;
glnd_evt.info.rsc_master_info.rsc_master_list[index].master_status =
master_node_details->status;
index++;
/*If this node is master for this resource, send all the non masters info of this resource to the master */
if (master_node_details->node_id == node_details->node_id) {
temp_node_list = glnd_rsc->rsc_info->node_list->next;
while (temp_node_list) {
non_master_node_details = (GLSV_GLD_GLND_DETAILS *)
ncs_patricia_tree_get(&gld_cb->glnd_details, (uint8_t *)
&temp_node_list->node_id);
if (non_master_node_details) {
gld_process_send_non_master_info(gld_cb, glnd_rsc,
non_master_node_details,
non_master_node_details->status);
} else {
LOG_ER("Patricia tree get failed: node_id %u",
temp_node_list->node_id);
}
temp_node_list = temp_node_list->next;
}
}
} else {
LOG_ER("Patricia tree get failed: node_id %u ", glnd_rsc->rsc_info->node_list->node_id);
}
glnd_rsc =
(GLSV_GLD_GLND_RSC_REF *)ncs_patricia_tree_getnext(&node_details->rsc_info_tree,
(uint8_t *)&glnd_rsc->rsc_id);
}
}
}
snd_mds.i_mds_hdl = gld_cb->mds_handle;
snd_mds.i_svc_id = NCSMDS_SVC_ID_GLD;
snd_mds.i_op = MDS_SEND;
snd_mds.info.svc_send.i_msg = (NCSCONTEXT)&glnd_evt;
snd_mds.info.svc_send.i_to_svc = NCSMDS_SVC_ID_GLND;
snd_mds.info.svc_send.i_priority = MDS_SEND_PRIORITY_HIGH;
snd_mds.info.svc_send.i_sendtype = MDS_SENDTYPE_SND;
snd_mds.info.svc_send.info.snd.i_to_dest = dest_id;
if (ncsmds_api(&snd_mds) != NCSCC_RC_SUCCESS) {
LOG_ER("MDS Send failed");
rc = NCSCC_RC_FAILURE;
goto end;
}
if (no_of_glnd_res > 0)
m_MMGR_FREE_GLND_RES_MASTER_LIST_INFO(glnd_evt.info.rsc_master_info.rsc_master_list);
end:
TRACE_LEAVE();
return rc;
}
/****************************************************************************
Name : avnd_mds_cbk
Description : This routine is a callback routine that is provided to MDS.
MDS calls this routine for encode, decode, copy, receive &
service event notification operations.
Arguments : info - ptr to the MDS callback info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_mds_cbk(NCSMDS_CALLBACK_INFO *info)
{
AVND_CB *cb = avnd_cb;
uns32 rc = NCSCC_RC_SUCCESS;
if (!info)
goto done;
switch (info->i_op) {
case MDS_CALLBACK_RECEIVE:
{
rc = avnd_mds_rcv(cb, &info->info.receive);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS receive callback failed");
}
break;
case MDS_CALLBACK_COPY:
{
rc = avnd_mds_cpy(cb, &info->info.cpy);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS copy callback failed");
}
break;
case MDS_CALLBACK_SVC_EVENT:
{
rc = avnd_mds_svc_evt(cb, &info->info.svc_evt);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS service event callback failed");
}
break;
case MDS_CALLBACK_ENC:
{
rc = avnd_mds_enc(cb, &info->info.enc);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS encode callback failed");
}
break;
case MDS_CALLBACK_ENC_FLAT:
{
rc = avnd_mds_flat_enc(cb, &info->info.enc_flat);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS encode flat callback failed");
}
break;
case MDS_CALLBACK_DEC:
{
rc = avnd_mds_dec(cb, &info->info.dec);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS decode callback failed");
}
break;
case MDS_CALLBACK_DEC_FLAT:
{
rc = avnd_mds_flat_dec(cb, &info->info.dec_flat);
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS decode flat callback failed");
}
break;
case MDS_CALLBACK_QUIESCED_ACK:
{
rc = avnd_mds_quiesced_process(cb);;
if (NCSCC_RC_SUCCESS != rc)
LOG_CR("MDS Quiesced Ack callback failed");
else
TRACE("MDS Quiesced Ack callback success");
}
break;
default:
assert(0);
break;
}
done:
return rc;
}
/****************************************************************************
* Name : eds_se_lib_init
*
* Description : Invoked to Initialize the EDS
*
*
* Arguments :
* Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE..
*
* Notes : None.
*****************************************************************************/
static uint32_t eds_se_lib_init(NCS_LIB_REQ_INFO *req_info)
{
EDS_CB *eds_cb;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
/* Allocate and initialize the control block */
if (NULL == (eds_cb = m_MMGR_ALLOC_EDS_CB)) {
LOG_CR("malloc failed for control block");
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
memset(eds_cb, '\0', sizeof(EDS_CB));
/* Obtain the hdl for EDS_CB from hdl-mgr */
gl_eds_hdl = eds_cb->my_hdl = ncshm_create_hdl(1, NCS_SERVICE_ID_EDS, (NCSCONTEXT)eds_cb);
if (0 == eds_cb->my_hdl) {
LOG_ER("Handle create failed for global eds handle");
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
m_MMGR_FREE_EDS_CB(eds_cb);
TRACE_LEAVE();
return NCSCC_RC_FAILURE;
}
/* initialize the eds cb lock */
m_NCS_LOCK_INIT(&eds_cb->cb_lock);
/* Initialize eds control block */
if (NCSCC_RC_SUCCESS != (rc = eds_cb_init(eds_cb))) {
/* Destroy the hdl for this CB */
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
/* clean up the CB */
m_MMGR_FREE_EDS_CB(eds_cb);
/* log the error */
TRACE_4("EDS control block init failed");
TRACE_LEAVE();
return rc;
}
m_NCS_EDU_HDL_INIT(&eds_cb->edu_hdl);
/* Create the mbx to communicate with the EDS thread */
if (NCSCC_RC_SUCCESS != (rc = m_NCS_IPC_CREATE(&eds_cb->mbx))) {
LOG_ER("EDS IPC mailbox create failed");
/* Release EDU handle */
m_NCS_EDU_HDL_FLUSH(&eds_cb->edu_hdl);
/* Destroy the hdl for this CB */
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
/* Free the control block */
m_MMGR_FREE_EDS_CB(eds_cb);
TRACE_LEAVE();
return rc;
}
/* Attach the IPC to the created thread */
m_NCS_IPC_ATTACH(&eds_cb->mbx);
/* Bind to MDS */
if (NCSCC_RC_SUCCESS != (rc = eds_mds_init(eds_cb))) {
TRACE_4("eds mds init failed");
m_NCS_IPC_RELEASE(&eds_cb->mbx, NULL);
/* Release EDU handle */
m_NCS_EDU_HDL_FLUSH(&eds_cb->edu_hdl);
ncshm_destroy_hdl(NCS_SERVICE_ID_EDS, gl_eds_hdl);
gl_eds_hdl = 0;
m_MMGR_FREE_EDS_CB(eds_cb);
TRACE_LEAVE();
return rc;
}
/* Initialize and Register with CLM */
rc = eds_clm_init(eds_cb);
if (rc != SA_AIS_OK) {
TRACE_4("CLM Init failed. Exiting");
exit(EXIT_FAILURE);
}
/* Initialize and Register with AMF */
rc = eds_amf_register(eds_cb);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("AMF Init failed: Exiting.");
exit(EXIT_FAILURE);
}
/* Initialize mbcsv interface */
if (NCSCC_RC_SUCCESS != (rc = eds_mbcsv_init(eds_cb))) {
LOG_ER("eds mbcsv init failed");
/* Log it */
}
TRACE("eds init done.");
TRACE_LEAVE();
return (rc);
}
void proc_callback_rsp(smfd_cb_t *cb, SMFSV_EVT *evt)
{
SMF_EVT *cbk_rsp = &evt->info.smfd.event.cbk_rsp;
uns32 rc = NCSCC_RC_SUCCESS;
SMFSV_EVT *new_evt;
TRACE_ENTER();
if (cbk_rsp->evt_type == SMF_CLBK_EVT) {
/* Ignore, log and return, SMF-D should not receive this */
TRACE_LEAVE2("Received SMF_CLBK_EVT, which should not be the case");
return;
}
else if (cbk_rsp->evt_type == SMF_RSP_EVT) {
SMFD_SMFND_ADEST_INVID_MAP *prev=NULL, *temp = smfd_cb->smfnd_list;
TRACE_2("Received evt_type: %d, inv_id: %llu, err: %d", cbk_rsp->evt_type,
cbk_rsp->evt.resp_evt.inv_id, cbk_rsp->evt.resp_evt.err);
while (temp != NULL) {
if (temp->inv_id == cbk_rsp->evt.resp_evt.inv_id)
{
/* check the response */
TRACE_2("found the node with inv_id: %llu", cbk_rsp->evt.resp_evt.inv_id);
if (cbk_rsp->evt.resp_evt.err == SA_AIS_ERR_FAILED_OPERATION) {
temp->no_of_cbks = 0;
}
else if (cbk_rsp->evt.resp_evt.err == SA_AIS_OK) {
temp->no_of_cbks--;
}
if (temp->no_of_cbks == 0) {
/* all responses are received for this inv_id */
TRACE("last response received, cleaning up the node");
if (prev == NULL) {
smfd_cb->smfnd_list = smfd_cb->smfnd_list->next_invid;
}
else {
prev->next_invid = temp->next_invid;
}
#if 0
/* send the consolidated response to camp/proc thread */
if (temp->proc == NULL) {
/* callback was invoked from campaign thread */
SmfCampaignThread *camp_thread = SmfCampaignThread::instance();
rc = m_NCS_IPC_SEND(&camp_thread->m_resp_mbx,
cbk_rsp->resp_evt,
NCS_IPC_PRIORITY_HIGH);
if (rc != NCSCC_RC_SUCCESS) {
LOG_CR("IPC send failed %d, %s", rc, strerror(errno));
}
}
else {
/* callback invoked from procedure thread */
rc = m_NCS_IPC_SEND(&temp->proc->m_resp_mbx,
cbk_rsp->resp_evt,
NCS_IPC_PRIORITY_HIGH);
if (rc != NCSCC_RC_SUCCESS) {
LOG_CR("IPC send failed %d, %s", rc, strerror(errno));
}
}
#endif
new_evt = (SMFSV_EVT *)calloc (1, sizeof(SMFSV_EVT));
memcpy (new_evt, evt, sizeof(SMFSV_EVT));
rc = m_NCS_IPC_SEND(temp->cbk_mbx,
new_evt,
NCS_IPC_PRIORITY_HIGH);
if (rc != NCSCC_RC_SUCCESS) {
LOG_CR("IPC send failed %d, %s", rc, strerror(errno));
}
free(temp);
break; /* from the while, otherwise return from function */
}
}
prev = temp;
temp = temp->next_invid;
}
}
TRACE_LEAVE();
return;
}
/****************************************************************************\
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 uint32_t mqd_nd_status_evt_process(MQD_CB *pMqd, MQD_ND_STATUS_INFO *nd_info)
{
uint32_t rc = NCSCC_RC_SUCCESS;
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_ENTER2("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) {
node_id = m_NCS_NODE_ID_FROM_MDS_DEST(nd_info->dest);
pNdNode = (MQD_ND_DB_NODE *)ncs_patricia_tree_get(&pMqd->node_db, (uint8_t *)&node_id);
if (!pNdNode) {
pNdNode = m_MMGR_ALLOC_MQD_ND_DB_NODE;
if (pNdNode == NULL) {
LOG_CR("%s:%u: Failed To Allocate Memory", __FILE__, __LINE__);
rc = NCSCC_RC_FAILURE;
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);
} else {
TRACE_2("Deleting the nd node from MQD");
mqd_red_db_node_del(pMqd, pNdNode);
}
if (pMqd->ha_state == SA_AMF_HA_ACTIVE)
mqd_nd_down_update_info(pMqd, nd_info->dest);
TRACE_1("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, (uint8_t *)&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;
mqd_a2s_async_update(pMqd, MQD_A2S_MSG_TYPE_MQND_STATEVT,
(void *)(&msg.info.nd_stat_evt));
}
}
TRACE_1("MDS UP PROCESSED ON %d DONE", pMqd->ha_state);
}
TRACE_LEAVE();
return rc;
}
/****************************************************************************\
* Function: avnd_mbcsv_process_dec_cb
*
* Purpose: AVND MBCSV decode call back function.
*
* Input: arg - MBCSV callback argument pointer.
*
* Returns: NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
*
* NOTES:
*
*
\**************************************************************************/
static uns32 avnd_mbcsv_process_dec_cb(AVND_CB *cb, NCS_MBCSV_CB_ARG *arg)
{
uns32 status = NCSCC_RC_SUCCESS;
TRACE_ENTER2("msg_type %u and i_reo_type %u",arg->info.decode.i_msg_type, arg->info.decode.i_reo_type);
switch (arg->info.decode.i_msg_type) {
case NCS_MBCSV_MSG_ASYNC_UPDATE:
{
/* Decode Async update message */
if (AVND_STBY_IN_SYNC == cb->stby_sync_state) {
if (AVND_SYNC_COMMIT != arg->info.decode.i_reo_type) {
/*
* Enqueue async update message till sync commit message is
* received from the Active.
*/
avnd_enqueue_async_update_msgs(cb, &arg->info.decode);
} else {
/*
* we have received sync commit message. So process all async
* ckpt updates received till now.
*/
avnd_dequeue_async_update_msgs(cb, TRUE);
}
} else {
/* Nothing is there to decode in this case */
if (AVND_SYNC_COMMIT == arg->info.decode.i_reo_type)
return status;
/*
* Cold sync is in progress, then drop the async update for which
* cold sync response are yet to come.
*/
if (NCSCC_RC_SUCCESS != avnd_validate_reo_type_in_csync(cb,
arg->info.decode.i_reo_type)) {
LOG_ER("Cold Sync on:validate_reo_type failed for %u",arg->info.decode.i_reo_type);
/* Free userbuff and return without decoding */
ncs_reset_uba(&arg->info.decode.i_uba);
break;
}
/*
* During cold sync operation or in case of warm sync failure
* and standby require to be sync-up, process the async updates as and
* when they received. Dont enqueue them.
*/
if (arg->info.decode.i_reo_type < AVND_CKPT_MSG_MAX)
status =
avnd_dec_ckpt_data_func_list[arg->info.decode.i_reo_type] (cb,
&arg->
info.decode);
else {
LOG_ER("%s Invalid reo type %u",__FUNCTION__,arg->info.decode.i_reo_type);
status = NCSCC_RC_FAILURE;
}
}
}
break;
case NCS_MBCSV_MSG_COLD_SYNC_REQ:
{
/*
* Decode Cold Sync request message
* Nothing is there to decode.
*/
}
break;
case NCS_MBCSV_MSG_COLD_SYNC_RESP:
case NCS_MBCSV_MSG_COLD_SYNC_RESP_COMPLETE:
{
/* Decode Cold Sync Response message */
status = avnd_decode_cold_sync_rsp(cb, &arg->info.decode);
if (NCSCC_RC_SUCCESS != status) {
if (NCSCC_RC_SUCCESS != avnd_ext_comp_data_clean_up(cb, FALSE)) {
/* Log Error ; FATAL; It should never happen unless there is a bug. */
LOG_CR("%s, %u,External component data cleanup failed",__FUNCTION__,__LINE__);
}
LOG_ER("%s, invalid reo type %u",__FUNCTION__,arg->info.decode.i_reo_type);
status = NCSCC_RC_FAILURE;
break;
}
/*
* If we have received cold sync complete message then mark standby
* as in sync.
*/
if ((NCS_MBCSV_MSG_COLD_SYNC_RESP_COMPLETE == arg->info.decode.i_msg_type) &&
(NCSCC_RC_SUCCESS == status)) {
cb->stby_sync_state = AVND_STBY_IN_SYNC;
TRACE("avnd_mbcsv_process_dec_cb: Cold Sync Completed");
}
cb->synced_reo_type = arg->info.decode.i_reo_type;
}
break;
case NCS_MBCSV_MSG_WARM_SYNC_REQ:
{
/*
* Decode Warm Sync Request message
* Nothing is there to decode.
*/
}
break;
case NCS_MBCSV_MSG_WARM_SYNC_RESP:
case NCS_MBCSV_MSG_WARM_SYNC_RESP_COMPLETE:
{
/* Decode Warm Sync Response message */
status = avnd_decode_warm_sync_rsp(cb, &arg->info.decode);
/* If we find mismatch in data or warm sync fails set in_sync to FALSE */
if (NCSCC_RC_FAILURE == status) {
LOG_ER("avnd_mbcsv_process_dec_cb: warm sync decode failed");
cb->stby_sync_state = AVND_STBY_OUT_OF_SYNC;
}
}
break;
case NCS_MBCSV_MSG_DATA_REQ:
{
/* Decode Data request message */
status = avnd_decode_data_req(cb, &arg->info.decode);
}
break;
case NCS_MBCSV_MSG_DATA_RESP:
case NCS_MBCSV_MSG_DATA_RESP_COMPLETE:
{
/* Decode Data response and data response complete message */
status = avnd_decode_data_sync_rsp(cb, &arg->info.decode);
if (NCSCC_RC_SUCCESS != status) {
if (NCSCC_RC_SUCCESS != avnd_ext_comp_data_clean_up(cb, FALSE)) {
/* Log Error ; FATAL; It should never happen unless there is a bug. */
LOG_CR("%s, %u,External component data cleanup failed",__FUNCTION__,__LINE__);
break;
}
/*
* Now send data request, which will sync Standby with Active.
*/
if (NCSCC_RC_SUCCESS != avnd_send_data_req(cb)) {
LOG_ER("AVND send data req: failed");
break;
}
break;
}
if (NCS_MBCSV_MSG_DATA_RESP_COMPLETE == arg->info.decode.i_msg_type) {
cb->stby_sync_state = AVND_STBY_IN_SYNC;
TRACE("avnd_mbcsv_process_dec_cb: Data Sync Completed");
}
}
break;
default:
LOG_ER("%s, Invalid message type: %u",__FUNCTION__,arg->info.decode.i_msg_type);
status = NCSCC_RC_FAILURE;
break;
}
TRACE_LEAVE2("%u", status);
return status;
}
/****************************************************************************
Name : avnd_mds_reg
Description : This routine registers the AVND Service with MDS. It does
the following:
a) Gets the MDS handle & AvND MDS address
b) installs AvND service with MDS
c) Subscribes to MDS events
Arguments : cb - ptr to the AVND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 avnd_mds_reg(AVND_CB *cb)
{
NCSMDS_INFO mds_info;
NCSADA_INFO ada_info;
MDS_SVC_ID svc_ids[2];
uns32 rc = NCSCC_RC_SUCCESS;
/* get the mds-hdl & avnd mds address */
rc = avnd_mds_param_get(cb);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MDS param get failed");
return NCSCC_RC_FAILURE;
}
TRACE("MDS param get success");
/* fill common fields */
memset(&mds_info, 0, sizeof(NCSMDS_INFO));
mds_info.i_mds_hdl = cb->mds_hdl;
mds_info.i_svc_id = NCSMDS_SVC_ID_AVND;
/*** install avnd service with mds ***/
mds_info.i_op = MDS_INSTALL;
mds_info.info.svc_install.i_mds_q_ownership = FALSE;
mds_info.info.svc_install.i_svc_cb = avnd_mds_cbk;
mds_info.info.svc_install.i_install_scope = NCSMDS_SCOPE_NONE;
mds_info.info.svc_install.i_mds_svc_pvt_ver = AVND_MDS_SUB_PART_VERSION;
rc = ncsmds_api(&mds_info);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MDS install failed");
goto done;
}
TRACE("MDS install success");
/*** subscribe to mds events ***/
mds_info.i_op = MDS_SUBSCRIBE;
mds_info.info.svc_subscribe.i_svc_ids = svc_ids;
/* subscribe to events from avd */
mds_info.info.svc_subscribe.i_scope = NCSMDS_SCOPE_NONE;
mds_info.info.svc_subscribe.i_num_svcs = 1;
svc_ids[0] = NCSMDS_SVC_ID_AVD;
rc = ncsmds_api(&mds_info);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MDS subscription for AVD events failed");
goto done;
}
TRACE("MDS subscription for AVD events success");
/* subscribe to events from ava */
mds_info.info.svc_subscribe.i_scope = NCSMDS_SCOPE_INTRANODE;
mds_info.info.svc_subscribe.i_num_svcs = 1;
svc_ids[0] = NCSMDS_SVC_ID_AVA;
rc = ncsmds_api(&mds_info);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MDS subscription for AVA events failed");
goto done;
}
TRACE("MDS subscription for AVA events success");
/* Subscribe for AvND itself. Will be used for External/Inernode proxy support */
mds_info.i_op = MDS_SUBSCRIBE;
mds_info.info.svc_subscribe.i_svc_ids = svc_ids;
/* subscribe to events from avd */
mds_info.info.svc_subscribe.i_scope = NCSMDS_SCOPE_NONE;
mds_info.info.svc_subscribe.i_num_svcs = 1;
svc_ids[0] = NCSMDS_SVC_ID_AVND;
rc = ncsmds_api(&mds_info);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MDS subscription for AVND events failed");
goto done;
}
TRACE("MDS subscription for AVND events success");
/* Subscribe for Controller AvND Vdest.
It will be used for External Comp support */
mds_info.i_op = MDS_SUBSCRIBE;
mds_info.info.svc_subscribe.i_svc_ids = svc_ids;
/* subscribe to events from avd */
mds_info.info.svc_subscribe.i_scope = NCSMDS_SCOPE_NONE;
mds_info.info.svc_subscribe.i_num_svcs = 1;
svc_ids[0] = NCSMDS_SVC_ID_AVND_CNTLR;
rc = ncsmds_api(&mds_info);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MDS subscription for Controller AVND vdest failed");
goto done;
}
TRACE("MDS subscription for Controller AVND vdest success");
/* get the handle from MDS */
memset(&ada_info, 0, sizeof(ada_info));
ada_info.req = NCSADA_GET_HDLS;
rc = ncsada_api(&ada_info);
if (rc != NCSCC_RC_SUCCESS) {
goto done;
}
/* Temp: For AvD down handling */
cb->is_avd_down = FALSE;
done:
if (NCSCC_RC_SUCCESS != rc)
rc = avnd_mds_unreg(cb);
return rc;
}
/****************************************************************************
Name : avnd_ext_intf_create
Description : This routine initialize external interfaces (logging
service being the exception).
Arguments : cb - ptr to AvND control block
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
uns32 avnd_ext_intf_create(AVND_CB *cb)
{
uns32 rc = NCSCC_RC_SUCCESS;
EDU_ERR err = EDU_NORMAL;
TRACE_ENTER();
/* EDU initialisation */
m_NCS_EDU_HDL_INIT(&cb->edu_hdl);
rc = m_NCS_EDU_COMPILE_EDP(&cb->edu_hdl, avsv_edp_dnd_msg, &err);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("%u, EDU compilation failed",__LINE__);
goto err;
}
m_NCS_EDU_HDL_INIT(&cb->edu_hdl_avnd);
rc = m_NCS_EDU_COMPILE_EDP(&cb->edu_hdl_avnd, avsv_edp_ndnd_msg, &err);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("%u, EDU compilation failed",__LINE__);
goto err;
}
m_NCS_EDU_HDL_INIT(&cb->edu_hdl_ava);
rc = m_NCS_EDU_COMPILE_EDP(&cb->edu_hdl_ava, avsv_edp_nda_msg, &err);
if (rc != NCSCC_RC_SUCCESS) {
LOG_ER("%u, EDU compilation failed",__LINE__);
goto err;
}
TRACE("EDU Init success");
/* MDS registration */
rc = avnd_mds_reg(cb);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MDS registration failed");
goto err;
}
TRACE("MDS registration success");
#if FIXME
if (cb->type == AVSV_AVND_CARD_SYS_CON) {
rc = avnd_mds_mbcsv_reg(cb);
if (NCSCC_RC_SUCCESS != rc) {
LOG_CR("MBCSv registration failed");
goto err;
}
}
#endif
TRACE_LEAVE();
return rc;
err:
/* destroy external interfaces */
avnd_ext_intf_destroy(cb);
TRACE_LEAVE();
return rc;
}
/**************************************************************************************************************
* Name : glnd_shm_open
*
* Description : To create a shared memory segment to store res_info lock_info & backup_evt
*
* Arguments : GLND_CB *cb
* char shm_name[]
*
* Return Values : SUCCESS/FAILURE
* Notes : None
**************************************************************************************************************/
static uint32_t glnd_shm_open(GLND_CB *cb, char *shm_name)
{
NCS_OS_POSIX_SHM_REQ_INFO glnd_open_req;
uint64_t shm_size;
uint32_t rc = NCSCC_RC_SUCCESS;
GLND_SHM_VERSION glnd_shm_version;
/* Initializing shared memory vesion */
memset(&glnd_shm_version, '\0', sizeof(glnd_shm_version));
glnd_shm_version.shm_version = GLSV_GLND_SHM_VERSION;
/*Set the shared memory size to be created */
if (memcmp(shm_name, RES_SHM_NAME, strlen(shm_name)) == 0)
shm_size = sizeof(GLND_RESTART_RES_INFO) * GLND_RESOURCE_INFO_CKPT_MAX_SECTIONS;
if (memcmp(shm_name, LCK_SHM_NAME, strlen(shm_name)) == 0)
shm_size = sizeof(GLND_RESTART_RES_LOCK_LIST_INFO) * GLND_RES_LOCK_INFO_CKPT_MAX_SECTIONS;
if (memcmp(shm_name, EVT_SHM_NAME, strlen(shm_name)) == 0)
shm_size = sizeof(GLSV_RESTART_BACKUP_EVT_INFO) * GLND_BACKUP_EVT_CKPT_MAX_SECTIONS;
memset(&glnd_open_req, '\0', sizeof(glnd_open_req));
glnd_open_req.type = NCS_OS_POSIX_SHM_REQ_OPEN;
glnd_open_req.info.open.i_size = shm_size;
glnd_open_req.info.open.i_offset = 0;
glnd_open_req.info.open.i_name = shm_name;
glnd_open_req.info.open.i_map_flags = MAP_SHARED;
glnd_open_req.info.open.o_addr = NULL;
glnd_open_req.info.open.i_flags = O_RDWR;
rc = ncs_os_posix_shm(&glnd_open_req);
if (rc == NCSCC_RC_FAILURE) {
/* Initially Shared memory open fails so create a shared memory */
glnd_open_req.info.open.i_flags = (unsigned int)O_CREAT | O_RDWR;
rc = ncs_os_posix_shm(&glnd_open_req);
if (rc == NCSCC_RC_FAILURE) {
LOG_CR("GLND shm create failure: rc %u Error %s ", rc, strerror(errno));
assert(0);
} else {
TRACE_1("GLND shm create success: rc %u", rc);
if (memcmp(shm_name, RES_SHM_NAME, strlen(shm_name)) == 0) {
/* Store the shared memory base address */
cb->shm_base_addr = glnd_open_req.info.open.o_addr;
memcpy(glnd_open_req.info.open.o_addr, &glnd_shm_version, sizeof(glnd_shm_version));
/* Stor the Resource shared memory base address */
cb->glnd_res_shm_base_addr = glnd_open_req.info.open.o_addr + sizeof(glnd_shm_version);
}
if (memcmp(shm_name, LCK_SHM_NAME, strlen(shm_name)) == 0)
cb->glnd_lck_shm_base_addr = glnd_open_req.info.open.o_addr;
if (memcmp(shm_name, EVT_SHM_NAME, strlen(shm_name)) == 0)
cb->glnd_evt_shm_base_addr = glnd_open_req.info.open.o_addr;
/* Set the the state of GLND as GLND_OPERATIONAL_STATE */
cb->node_state = GLND_OPERATIONAL_STATE;
}
} else {
TRACE_1("GLND shm open success: rc %u", rc);
if (memcmp(shm_name, RES_SHM_NAME, strlen(shm_name)) == 0) {
/* Store the shared memory base address */
cb->shm_base_addr = glnd_open_req.info.open.o_addr;
memcpy(glnd_open_req.info.open.o_addr, &glnd_shm_version, sizeof(glnd_shm_version));
/* Store the Resource shared memory base address */
cb->glnd_res_shm_base_addr = glnd_open_req.info.open.o_addr + sizeof(glnd_shm_version);
}
if (memcmp(shm_name, LCK_SHM_NAME, strlen(shm_name)) == 0)
cb->glnd_lck_shm_base_addr = glnd_open_req.info.open.o_addr;
if (memcmp(shm_name, EVT_SHM_NAME, strlen(shm_name)) == 0)
cb->glnd_evt_shm_base_addr = glnd_open_req.info.open.o_addr;
/* Set the the state of GLND as GLND_CLIENT_INFO_GET_STATE */
cb->node_state = GLND_CLIENT_INFO_GET_STATE;
}
return rc;
}
