static int __init_dts(void)
{
NCS_LIB_REQ_INFO lib_create;
char *env;
/* Init LIB_CREATE request for Server */
memset(&lib_create, 0, sizeof(lib_create));
lib_create.i_op = NCS_LIB_REQ_CREATE;
lib_create.info.create.argc = 0;
lib_create.info.create.argv = NULL;
if (ncs_agents_startup() != NCSCC_RC_SUCCESS)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
/* DTSV default service severity level */
env = getenv("DTS_LOG_ALL");
if (env != NULL) {
if (atoi(env)) {
TRACE("\nINFO:DTS default service severity = ALL\n");
gl_severity_filter = GLOBAL_SEVERITY_FILTER_ALL;
}
}
TRACE("\nDTSV:DTS:ON");
if (dts_lib_req(&lib_create) != NCSCC_RC_SUCCESS) {
fprintf(stderr, "dts_lib_req FAILED\n");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
return (NCSCC_RC_SUCCESS);
}
/**************************************************************************\
*
* add_new_req_pid_in_list
*
* Description: Add new request in the list..
*
* Synopsis:
*
* Call Arguments:
* pid - Process ID for which timeout has occurrend.
*
* Returns:
* None.
*
* Notes:
*
\**************************************************************************/
uns32 add_new_req_pid_in_list(NCS_OS_PROC_EXECUTE_TIMED_INFO *req, uns32 pid)
{
SYSF_PID_LIST *list_entry;
if (module_cb.init == FALSE)
return m_LEAP_DBG_SINK(NCSCC_RC_SUCCESS);
if (NULL == (list_entry = m_MMGR_ALLOC_PRO_EXC))
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
list_entry->timeout_in_ms = req->i_timeout_in_ms;
list_entry->exec_cb = req->i_cb;
list_entry->usr_hdl = req->i_usr_hdl;
list_entry->exec_hdl = req->o_exec_hdl = NCS_PTR_TO_UNS64_CAST(list_entry);
list_entry->pid = pid;
list_entry->pat_node.key_info = (uns8 *)&list_entry->pid;
list_entry->exec_info_type = SYSF_EXEC_INFO_SIG_CHLD;
m_NCS_LOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
if (NCSCC_RC_SUCCESS != ncs_patricia_tree_add(&module_cb.pid_list, (NCS_PATRICIA_NODE *)list_entry)) {
m_MMGR_FREE_PRO_EXC(list_entry);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
ncs_exc_mdl_start_timer(list_entry);
m_NCS_UNLOCK(&module_cb.tree_lock, NCS_LOCK_WRITE);
return NCSCC_RC_SUCCESS;
}
uint32_t hm_init_pools(HM_PMGR *pmgr, HM_POOL *pool)
{
uint32_t i;
int32_t last_max = -1;
for (i = 0; i < HM_POOL_CNT; i++) {
/* force pool units to be contiguous & non-overlapping */
if (!((last_max + 1) == pool->min)) /* contiguous */
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
if (pool->max >= 256) /* greater than max units */
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
if (pool->min > pool->max) /* malformed range spec */
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
last_max = pool->max;
pmgr->curr = pool->min;
pmgr->max = pool->max;
pmgr++;
pool++;
}
return NCSCC_RC_SUCCESS;
}
static uint32_t vda_uninstantiate(NCS_LIB_REQ_INFO *req)
{
MDS_DEST gone_vdest;
bool is_named_vdest;
memset(&gone_vdest, 0, sizeof(gone_vdest));
/* STEP : Check for "reserved" instance names */
switch (mda_get_inst_name_type(&req->info.uninst.i_inst_name)) {
case MDA_INST_NAME_TYPE_UNNAMED_VDEST:
is_named_vdest = false;
break;
case MDA_INST_NAME_TYPE_NAMED_VDEST:
is_named_vdest = true;
break;
default:
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
if (is_named_vdest) {
return NCSCC_RC_FAILURE;
}
/* STEP : Create VDEST locally. */
if (vda_destroy_vdest_locally(req->info.uninst.i_inst_hdl) != NCSCC_RC_SUCCESS) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
return NCSCC_RC_FAILURE;
}
unsigned int ncs_patricia_tree_init(NCS_PATRICIA_TREE *const pTree, const NCS_PATRICIA_PARAMS *const pParams)
{
if (pParams == NULL)
return (unsigned int)m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
if ((pParams->key_size < 1)
|| (pParams->key_size > NCS_PATRICIA_MAX_KEY_SIZE)
) {
return (unsigned int)m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
pTree->params = *pParams;
/* Initialize the root node, which is actually part of the tree structure. */
pTree->root_node.key_info = (uint8_t *)0;
pTree->root_node.bit = -1;
pTree->root_node.left = pTree->root_node.right = &pTree->root_node;
if ((pTree->root_node.key_info = (NCS_PATRICIA_LEXICAL_STACK *)malloc(pTree->params.key_size)) == NULL) {
return (unsigned int)m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
memset(pTree->root_node.key_info, '\0', (uint32_t)pTree->params.key_size);
pTree->n_nodes = 0;
return NCSCC_RC_SUCCESS;
}
static int __init_mqnd(void)
{
NCS_LIB_REQ_INFO lib_create;
TRACE_ENTER();
/* Init LIB_CREATE request for Server */
memset(&lib_create, 0, sizeof(lib_create));
lib_create.i_op = NCS_LIB_REQ_CREATE;
lib_create.info.create.argc = 0;
lib_create.info.create.argv = NULL;
if (ncs_agents_startup() != NCSCC_RC_SUCCESS) {
TRACE_4("ncs_agents_startup failed");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
/* Init MQND */
printf("\nMQSV:MQND:ON");
if (mqnd_lib_req(&lib_create) != NCSCC_RC_SUCCESS) {
fprintf(stderr, "mqnd_lib_req FAILED\n");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
TRACE_LEAVE();
return (NCSCC_RC_SUCCESS);
}
/*****************************************************************************
PROCEDURE NAME: ncs_make_free_cells
DESCRIPTION: create a bunch of cells and put them in the free pool.
*****************************************************************************/
uint32_t hm_make_free_cells(HM_PMGR *pmgr)
{
HM_UNIT *unit;
HM_CELLS *cells;
HM_CELL *cell;
HM_HDL hdl;
uint32_t i;
unit = gl_hm.unit[pmgr->curr];
/* first time this pool has been used ?? */
if (unit == NULL) {
if ((unit = (HM_UNIT*) malloc(sizeof(HM_UNIT))) == NULL)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
memset(unit, 0, sizeof(HM_UNIT));
gl_hm.unit[pmgr->curr] = unit;
}
/* another million hdls used up ?? */
/* Check to see if BACKUP has caused random cell banks to be created */
while (unit->cells[unit->curr] != NULL) { /* BACKUP has been here!! */
/* Commenting as condition is always false and it was giving warnings */
++unit->curr;
}
/* Now go make HM_CELL_CNT (4096) new cells */
if ((cells = (HM_CELLS*) malloc(sizeof(HM_CELLS))) == NULL)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
memset(cells, 0, sizeof(HM_CELLS));
hdl.idx1 = pmgr->curr; /* set handle conditions */
hdl.idx2 = unit->curr;
hdl.seq_id = 0;
unit->cells[unit->curr++] = cells; /* update curr++ for next time */
for (i = 0; i < HM_CELL_CNT; i++) { /* carve um up and put in free-po0l */
hdl.idx3 = i;
cell = &(cells->cell[i]);
hm_free_cell(cell, &hdl, false);
}
return NCSCC_RC_SUCCESS;
}
/***************************************************************************
* Name : fm_fm_mds_dec
*
* Description : To decode GFM related messages
*
* Arguments : Ptr to the MDS callback info struct MDS_CALLBACK_DEC_INFO
*
* Return Values : NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
*
* Notes : None.
***************************************************************************/
static uint32_t fm_fm_mds_dec(MDS_CALLBACK_DEC_INFO *dec_info)
{
GFM_GFM_MSG *msg;
NCS_UBAID *uba;
uint8_t *data;
uint8_t data_buff[256];
if (NULL == dec_info->io_uba) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
msg = m_MMGR_ALLOC_FM_FM_MSG;
if (NULL == msg)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
memset(msg, 0, sizeof(GFM_GFM_MSG));
dec_info->o_msg = msg;
uba = dec_info->io_uba;
data = ncs_dec_flatten_space(uba, data_buff, sizeof(uint8_t));
if (NULL == data)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
msg->msg_type = (GFM_GFM_MSG_TYPE)ncs_decode_8bit(&data);
ncs_dec_skip_space(uba, sizeof(uint8_t));
switch (msg->msg_type) {
case GFM_GFM_EVT_NODE_INFO_EXCHANGE:
data = ncs_dec_flatten_space(uba, data_buff, 2 * sizeof(uint32_t));
if (data == NULL) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
msg->info.node_info.node_id = (uint32_t)ncs_decode_32bit(&data);
msg->info.node_info.node_name.length = (uint32_t)ncs_decode_32bit(&data);
ncs_dec_skip_space(uba, 2 * sizeof(uint32_t));
ncs_decode_n_octets_from_uba(uba, msg->info.node_info.node_name.value,
msg->info.node_info.node_name.length);
break;
default:
syslog(LOG_INFO, "fm_fm_mds_dec: Invalid msg for decoding.");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
break;
}
return NCSCC_RC_SUCCESS;
}
/*-------------------------------------------------------------------------*\
FUNCTION NAME : vda_create_vdest_locally (public)
\*-------------------------------------------------------------------------*/
uint32_t vda_create_vdest_locally(uint32_t i_pol, MDS_DEST *i_vdest, MDS_HDL *o_mds_vdest_hdl)
{
NCSMDS_ADMOP_INFO admop_info;
memset(&admop_info, 0, sizeof(admop_info));
/* STEP : We first check if the VDEST has already been created locally */
admop_info.i_op = MDS_ADMOP_VDEST_QUERY;
admop_info.info.vdest_query.i_local_vdest = *i_vdest;
if (ncsmds_adm_api(&admop_info) == NCSCC_RC_SUCCESS) {
/* VDEST already created */
MDA_TRACE1_ARG1("VDEST already created locally.\n");
*o_mds_vdest_hdl = admop_info.info.vdest_query.o_local_vdest_hdl;
return NCSCC_RC_SUCCESS;
}
/* STEP : We need to created the VDEST locally, because it is not already
created */
admop_info.i_op = MDS_ADMOP_VDEST_CREATE;
admop_info.info.vdest_create.i_vdest = *i_vdest;
admop_info.info.vdest_create.i_policy = i_pol;
/* Invoke MDS api */
if (ncsmds_adm_api(&admop_info) != NCSCC_RC_SUCCESS)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
*o_mds_vdest_hdl = admop_info.info.vdest_create.o_mds_vdest_hdl;
return NCSCC_RC_SUCCESS;
}
/***************************************************************************\
PRIVATE ADA FUNCTIONS
\***************************************************************************/
static uint32_t vda_create(NCS_LIB_REQ_INFO *req)
{
NCS_SPLR_REQ_INFO splr_req;
NCS_SPIR_REQ_INFO spir_req;
memset(&splr_req, 0, sizeof(splr_req));
/* STEP : Register VDA as a service provider */
splr_req.i_sp_abstract_name = m_VDA_SP_ABST_NAME;
splr_req.type = NCS_SPLR_REQ_REG;
splr_req.info.reg.instantiation_api = vda_lib_req;
splr_req.info.reg.instantiation_flags = NCS_SPLR_INSTANTIATION_PER_INST_NAME;
splr_req.info.reg.user_se_api = (NCSCONTEXT)ncsvda_api;
if (ncs_splr_api(&splr_req) != NCSCC_RC_SUCCESS) {
return NCSCC_RC_FAILURE;
}
/* STEP : Get the MDS-handle to the ADEST */
memset(&spir_req, 0, sizeof(spir_req));
spir_req.type = NCS_SPIR_REQ_LOOKUP_CREATE_INST;
spir_req.i_environment_id = 1;
spir_req.i_instance_name = m_MDS_SPIR_ADEST_NAME;
spir_req.i_sp_abstract_name = m_MDS_SP_ABST_NAME;
spir_req.info.lookup_create_inst.i_inst_attrs.number = 0;
if (ncs_spir_api(&spir_req) != NCSCC_RC_SUCCESS) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
gl_vda_info.mds_adest_pwe1_hdl = (MDS_HDL)spir_req.info.lookup_create_inst.o_handle;
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : ncs_mqa_startup
Description : This routine creates a MQSv agent infrastructure to interface
with MQSv service. Once the infrastructure is created from
then on use_count is incremented for every startup request.
Arguments : - NIL-
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
unsigned int ncs_mqa_startup(void)
{
NCS_LIB_REQ_INFO lib_create;
char *value = NULL;
osaf_mutex_lock_ordie(&s_agent_startup_mutex);
if (mqa_use_count > 0) {
/* Already created, so just increment the use_count */
mqa_use_count++;
osaf_mutex_unlock_ordie(&s_agent_startup_mutex);
return NCSCC_RC_SUCCESS;
}
/*** Init MQA ***/
memset(&lib_create, 0, sizeof(lib_create));
lib_create.i_op = NCS_LIB_REQ_CREATE;
if (mqa_lib_req(&lib_create) != NCSCC_RC_SUCCESS) {
osaf_mutex_unlock_ordie(&s_agent_startup_mutex);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
} else {
printf("\nMQSV:MQA:ON");
mqa_use_count = 1;
}
/* Initialize trace system first of all so we can see what is going. */
if ((value = getenv("MQA_TRACE_PATHNAME")) != NULL) {
logtrace_init("mqa", value, CATEGORY_ALL);
}
osaf_mutex_unlock_ordie(&s_agent_startup_mutex);
return NCSCC_RC_SUCCESS;
}
/*****************************************************************************
PROCEDURE NAME: ncshm_take_hdl
DESCRIPTION: If all validation stuff is in order return the associated
data that this hdl leads to.
*****************************************************************************/
NCSCONTEXT ncshm_take_hdl(NCS_SERVICE_ID id, uint32_t uhdl)
{
HM_CELL *cell = NULL;
HM_HDL *hdl = (HM_HDL *)&uhdl;
NCSCONTEXT data = NULL;
uint32_t pool_id = 0;
pool_id = m_HM_DETM_POOL_FRM_HDL(&uhdl);
if (pool_id >= HM_POOL_CNT)
return NULL;
m_NCS_LOCK(&gl_hm.lock[pool_id], NCS_LOCK_WRITE);
if ((cell = hm_find_cell(hdl)) != NULL) {
if ((cell->seq_id == hdl->seq_id) && ((NCS_SERVICE_ID)cell->svc_id == id) && (cell->busy == true)) {
if (++cell->use_ct == 0) {
m_LEAP_DBG_SINK(NCSCC_RC_FAILURE); /* Too many takes()s!! */
}
data = cell->data;
}
}
m_NCS_UNLOCK(&gl_hm.lock[pool_id], NCS_LOCK_WRITE);
return data;
}
/*****************************************************************************
PROCEDURE NAME: ncshm_give_hdl
DESCRIPTION: Inform Hdl Manager that you are done with associated
data.
*****************************************************************************/
void ncshm_give_hdl(uint32_t uhdl)
{
HM_CELL *cell = NULL;
HM_HDL *hdl = (HM_HDL *)&uhdl;
uint32_t pool_id = 0;
pool_id = m_HM_DETM_POOL_FRM_HDL(&uhdl);
if (pool_id >= HM_POOL_CNT)
return;
m_NCS_LOCK(&gl_hm.lock[pool_id], NCS_LOCK_WRITE);
if ((cell = hm_find_cell(hdl)) != NULL) {
if (cell->seq_id == hdl->seq_id) {
if (--cell->use_ct < 1) {
m_LEAP_DBG_SINK(NCSCC_RC_FAILURE); /* Client BUG..Too many give()s!! */
cell->use_ct++;
} else {
if ((cell->busy == false) && (cell->use_ct == 1))
hm_unblock_him(cell);
}
}
}
m_NCS_UNLOCK(&gl_hm.lock[pool_id], NCS_LOCK_WRITE);
}
uns32 ncs_decode_key(uns8 **stream, NCS_KEY *key)
{
uns8 len;
key->svc = *(*stream)++;
key->fmat = *(*stream)++;
key->type = *(*stream)++;
switch (key->fmat) {
case NCS_FMT_NUM:
key->val.num = ncs_decode_32bit(stream);
return 7;
break;
case NCS_FMT_STR:
len = *(*stream)++;
m_KEY_CHK_LEN(key->val.oct.len);
strncpy((char *)key->val.str, (char *)(*stream), len);
*stream = *stream + len; /* move pointer beyond what was consumed */
return (3 + len + 1);
break;
case NCS_FMT_OCT:
len = *(*stream)++;
m_KEY_CHK_LEN(key->val.oct.len);
key->val.oct.len = len;
memcpy(key->val.oct.data, *stream, len);
*stream = *stream + len; /* move pointer beyond what was consumed */
return (3 + len + 1);
break;
}
return m_LEAP_DBG_SINK(0);
}
/****************************************************************************
Name : ncs_eda_startup
Description : This routine creates a EDSv agent infrastructure to interface
with EDSv service. Once the infrastructure is created from
then on use_count is incremented for every startup request.
Arguments : - NIL-
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None
******************************************************************************/
unsigned int ncs_eda_startup(void)
{
NCS_LIB_REQ_INFO lib_create;
m_EDA_AGENT_LOCK;
if (eda_use_count > 0) {
/* Already created, so just increment the use_count */
eda_use_count++;
m_EDA_AGENT_UNLOCK;
return NCSCC_RC_SUCCESS;
}
/*** Init EDA ***/
memset(&lib_create, 0, sizeof(lib_create));
lib_create.i_op = NCS_LIB_REQ_CREATE;
if (ncs_eda_lib_req(&lib_create) != NCSCC_RC_SUCCESS) {
m_EDA_AGENT_UNLOCK;
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
} else {
m_NCS_DBG_PRINTF("\nEDSV:EDA:ON");
eda_use_count = 1;
}
m_EDA_AGENT_UNLOCK;
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
* Name : gld_quisced_process
*
* Description : Instruction from the GLND to set the orphan flag
*
* Arguments : evt - Event structure
*
* Return Values : NCSCC_RC_SUCCESS/ NCSCC_RC_FAILURE
*
* Notes : None.
*****************************************************************************/
static uint32_t gld_quisced_process(GLSV_GLD_EVT *evt)
{
GLSV_GLD_CB *gld_cb = evt->gld_cb;
SaAisErrorT saErr = SA_AIS_OK;
uint32_t rc = NCSCC_RC_SUCCESS;
TRACE_ENTER();
if ((evt == GLSV_GLD_EVT_NULL) || (gld_cb == NULL)){
rc = NCSCC_RC_FAILURE;
goto end;
}
if (gld_cb->is_quiasced) {
gld_cb->ha_state = SA_AMF_HA_QUIESCED;
/* Give up our IMM OI implementer role */
rc = immutil_saImmOiImplementerClear(gld_cb->immOiHandle);
if (rc != SA_AIS_OK) {
LOG_ER("saImmOiImplementerClear failed: err = %d", rc);
}
gld_cb->is_impl_set = false;
rc = glsv_gld_mbcsv_chgrole(gld_cb);
if (rc != NCSCC_RC_SUCCESS) {
m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
goto end;
}
saAmfResponse(gld_cb->amf_hdl, gld_cb->invocation, saErr);
gld_cb->is_quiasced = false;
}
end:
TRACE_LEAVE();
return rc;
}
/***********************************************************************//**
* @brief This routine creates a PLMSv agent infrastructure to interface
* with PLMSv service. Once the infrastructure is created from
* then on use_count is incremented for every startup request.
*
* @return NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE.
***************************************************************************/
uns32 ncs_plma_startup()
{
NCS_LIB_REQ_INFO lib_create;
TRACE_ENTER();
m_PLM_AGENT_LOCK;
if (plma_use_count > 0) {
/** Already created, so just increment the use_count */
plma_use_count++;
m_PLM_AGENT_UNLOCK;
return NCSCC_RC_SUCCESS;
}
/** Initialize PLMA library */
memset(&lib_create, 0, sizeof(lib_create));
lib_create.i_op = NCS_LIB_REQ_CREATE;
if (plma_lib_req(&lib_create) != NCSCC_RC_SUCCESS) {
m_PLM_AGENT_UNLOCK;
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}else{
/** Initialize the library for the first time */
m_NCS_DBG_PRINTF("\nPLMSV:PLMA:ON");
plma_use_count = 1;
}
m_PLM_AGENT_UNLOCK;
TRACE_LEAVE();
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : cpa_mds_callback
Description : This callback routine will be called by MDS on event arrival
Arguments : info - pointer to the mds callback info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 cpa_mds_callback(struct ncsmds_callback_info *info)
{
CPA_CB *cpa_cb = NULL;
uns32 rc = NCSCC_RC_FAILURE;
if (info == NULL)
return rc;
cpa_cb = (CPA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_CPA, gl_cpa_hdl);
if (!cpa_cb) {
m_LOG_CPA_CCLL(CPA_PROC_FAILED, NCSFL_LC_CKPT_MGMT, NCSFL_SEV_ERROR, "mds_callback:HDL_TAKE", __FILE__,
__LINE__, rc);
return m_LEAP_DBG_SINK(rc);
}
switch (info->i_op) {
case MDS_CALLBACK_COPY:
rc = NCSCC_RC_FAILURE;
break;
case MDS_CALLBACK_ENC_FLAT:
rc = cpa_mds_enc_flat(cpa_cb, &info->info.enc_flat);
break;
case MDS_CALLBACK_DEC_FLAT:
rc = cpa_mds_dec_flat(cpa_cb, &info->info.dec_flat);
break;
case MDS_CALLBACK_RECEIVE:
rc = cpa_mds_rcv(cpa_cb, &info->info.receive);
break;
case MDS_CALLBACK_SVC_EVENT:
rc = cpa_mds_svc_evt(cpa_cb, &info->info.svc_evt);
break;
case MDS_CALLBACK_ENC:
rc = cpa_mds_enc(cpa_cb, &info->info.enc);
break;
case MDS_CALLBACK_DEC:
rc = cpa_mds_dec(cpa_cb, &info->info.dec);
break;
default:
m_LOG_CPA_CCLL(CPA_PROC_FAILED, NCSFL_LC_CKPT_MGMT, NCSFL_SEV_INFO, "mds_callback:unknown_op", __FILE__,
__LINE__, rc);
break;
}
if (rc != NCSCC_RC_SUCCESS) {
m_LOG_CPA_CCLL(CPA_PROC_FAILED, NCSFL_LC_CKPT_MGMT, NCSFL_SEV_INFO, "mds_callback", __FILE__, __LINE__,
rc);
}
ncshm_give_hdl(gl_cpa_hdl);
return rc;
}
uint32_t ncslpg_create(NCSLPG_OBJ *pg)
{
if (pg->open == true)
m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
pg->open = true;
pg->inhere = 0;
return NCSCC_RC_SUCCESS;
}
HM_CELL *hm_find_cell(HM_HDL *hdl)
{
HM_UNIT *unit;
HM_CELLS *spot;
if ((unit = gl_hm.unit[hdl->idx1]) == NULL) {
m_LEAP_DBG_SINK(NULL);
return NULL;
}
if ((spot = unit->cells[hdl->idx2]) == NULL) {
m_LEAP_DBG_SINK(NULL);
return NULL;
}
return &(spot->cell[hdl->idx3]);
}
uns8 *ncs_flatten_n_octets(USRBUF *u, uns8 *os, uns32 count)
{
if (u == BNULL) {
m_LEAP_DBG_SINK(0);
return NULL;
}
return (uns8 *)m_MMGR_DATA_AT_START(u, count, (char *)os);
}
/***************************************************************************
* Name : fm_fm_mds_enc
*
* Description : To encode GFM related messages
*
* Arguments :Pointer to the MDS callback info struct MDS_CALLBACK_DEC_INFO
*
* Return Values : NCSCC_RC_FAILURE/NCSCC_RC_SUCCESS
*
* Notes : None.
***************************************************************************/
static uint32_t fm_fm_mds_enc(MDS_CALLBACK_ENC_INFO *enc_info)
{
GFM_GFM_MSG *msg;
NCS_UBAID *uba;
uint8_t *data;
if (NULL == enc_info)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
if ((NULL == enc_info->i_msg) || (NULL == enc_info->io_uba))
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
uba = enc_info->io_uba;
msg = (GFM_GFM_MSG *)enc_info->i_msg;
data = ncs_enc_reserve_space(uba, sizeof(uint8_t));
if (NULL == data)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
ncs_encode_8bit(&data, msg->msg_type);
ncs_enc_claim_space(uba, sizeof(uint8_t));
switch (msg->msg_type) {
case GFM_GFM_EVT_NODE_INFO_EXCHANGE:
data = ncs_enc_reserve_space(uba, (2 * sizeof(uint32_t)));
if (data == NULL) {
m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
ncs_encode_32bit(&data, msg->info.node_info.node_id);
ncs_encode_32bit(&data, msg->info.node_info.node_name.length);
ncs_enc_claim_space(uba, 2 * sizeof(uint32_t));
ncs_encode_n_octets_in_uba(uba, msg->info.node_info.node_name.value,
(uint32_t)msg->info.node_info.node_name.length);
break;
default:
syslog(LOG_INFO, "fm_fm_mds_enc: Invalid msg type for encode.");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
break;
}
return NCSCC_RC_SUCCESS;
}
static uint32_t vda_destroy(NCS_LIB_REQ_INFO *req)
{
NCS_SPLR_REQ_INFO splr_req;
NCS_SPIR_REQ_INFO spir_req;
NCSMDS_INFO svc_info;
if (vda_vdest_create == true) {
/* STEP : Uninstall from ADEST with MDS as service NCSMDS_SVC_ID_VDA. */
memset(&svc_info, 0, sizeof(svc_info));
svc_info.i_mds_hdl = gl_vda_info.mds_adest_pwe1_hdl;
svc_info.i_svc_id = NCSMDS_SVC_ID_VDA;
svc_info.i_op = MDS_UNINSTALL;
svc_info.info.svc_uninstall.i_msg_free_cb = NULL; /* NULL for callback-model services */
/* Invoke MDS api */
if (ncsmds_api(&svc_info) != NCSCC_RC_SUCCESS)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
/* STEP : Release the use of ADEST MDS handle */
memset(&spir_req, 0, sizeof(spir_req));
spir_req.type = NCS_SPIR_REQ_REL_INST;
spir_req.i_environment_id = 1;
spir_req.i_instance_name = m_MDS_SPIR_ADEST_NAME;
spir_req.i_sp_abstract_name = m_MDS_SP_ABST_NAME;
spir_req.info.rel_inst = 0; /* dummy value */
if (ncs_spir_api(&spir_req) != NCSCC_RC_SUCCESS) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
gl_vda_info.mds_adest_pwe1_hdl = 0;
/* STEP : Deregister VDA as a service provider */
memset(&splr_req, 0, sizeof(splr_req));
splr_req.i_sp_abstract_name = m_VDA_SP_ABST_NAME;
splr_req.type = NCS_SPLR_REQ_DEREG;
splr_req.info.dereg.dummy = 0;
if (ncs_splr_api(&splr_req) != NCSCC_RC_SUCCESS) {
return NCSCC_RC_FAILURE;
}
vda_vdest_create = false;
return NCSCC_RC_SUCCESS;
}
uint32_t hm_pool_id(uint8_t unit)
{
uint32_t i = 0;
for (i = 0; i < HM_POOL_CNT; i++) {
if (gl_hpool[i].max >= unit)
return i;
}
return m_LEAP_DBG_SINK(i); /* This can't/shouldn't happen really */
}
uns32 leap_env_init()
{
if (leap_env_init_count++ != 0) {
return NCSCC_RC_SUCCESS;
}
/*
** Change buffering type for the stdout stream to line buffered.
** Otherwise printf output will be block buffered and not immidiately
** printed to file.
** TODO: to be removed in OpenSAF 4.0
*/
if (setvbuf(stdout, (char *)NULL, _IOLBF, 0) != 0) {
fprintf(stderr, "%s:%d - setvbuf failed\n", __FILE__, __LINE__);
return NCSCC_RC_FAILURE;
}
m_NCS_DBG_PRINTF("\n\n\nINITIALIZING LEAP ENVIRONMENT\n");
/* initialize OS target */
m_NCS_OS_TARGET_INIT;
ncs_os_atomic_init();
#if (NCSL_ENV_INIT_TMR == 1)
/* initialize LEAP Timer Service */
if (sysfTmrCreate() != NCSCC_RC_SUCCESS) {
printf("\nleap_env_init: FAILED to initialize Timer Service\n");
return NCSCC_RC_FAILURE;
}
#endif /* #if (NCSL_ENV_INIT_TMR == 1) */
#if (NCSL_ENV_INIT_HM == 1)
/* initialize Handle Manager */
if (ncshm_init() != NCSCC_RC_SUCCESS) {
printf("\nleap_env_init: FAILED to initialize Handle Manager\n");
#if (NCSL_ENV_INIT_TMR == 1)
(void)sysfTmrDestroy();
#endif
return NCSCC_RC_FAILURE;
}
#endif /* #if (NCSL_ENV_INIT_HM == 1) */
/* Initialize script execution control block */
if (NCSCC_RC_SUCCESS != init_exec_mod_cb()) {
/* Log error */
printf("\nleap_env_init: FAILED to initialize Execute Module CB \n");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
m_NCS_DBG_PRINTF("\nDONE INITIALIZING LEAP ENVIRONMENT\n");
return NCSCC_RC_SUCCESS;
}
/**************************************************************************\
*
* start_exec_mod_cb
*
* Description: Initialize execute module control block.
*
* Synopsis:
*
* Call Arguments:
* SUCCESS/FAILURE
*
* Returns:
* None.
*
* Notes:
*
\**************************************************************************/
uns32 start_exec_mod_cb(void)
{
NCS_PATRICIA_PARAMS pt_params;
int spair[2];
pt_params.key_size = sizeof(uns32);
if (ncs_patricia_tree_init(&module_cb.pid_list, &pt_params) != NCSCC_RC_SUCCESS) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
if (0 != socketpair(AF_UNIX, SOCK_DGRAM, 0, spair)) {
perror("init_exec_mod_cb: socketpair: ");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
module_cb.read_fd = spair[0];
module_cb.write_fd = spair[1];
/* Create a task which will handle the signal and give call back */
if (m_NCS_TASK_CREATE((NCS_OS_CB)ncs_exec_mod_hdlr,
0,
NCS_EXEC_MOD_TASKNAME,
NCS_EXEC_MOD_PRIORITY,
NCS_EXEC_MOD_STACKSIZE, &module_cb.em_task_handle) != NCSCC_RC_SUCCESS) {
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);;
}
if (m_NCS_TASK_START(module_cb.em_task_handle) != NCSCC_RC_SUCCESS) {
m_NCS_TASK_RELEASE(module_cb.em_task_handle);
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);;
}
module_cb.init = TRUE;
m_NCS_SIGNAL(SIGCHLD, ncs_exec_module_signal_hdlr);
return NCSCC_RC_SUCCESS;
}
/****************************************************************************
Name : mqa_mds_callback
Description : This callback routine will be called by MDS on event arrival
Arguments : info - pointer to the mds callback info
Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
Notes : None.
******************************************************************************/
uns32 mqa_mds_callback(struct ncsmds_callback_info *info)
{
MQA_CB *mqa_cb = NULL;
uns32 rc = NCSCC_RC_SUCCESS;
if (info == NULL)
return rc;
mqa_cb = m_MQSV_MQA_RETRIEVE_MQA_CB;
if (!mqa_cb) {
m_LOG_MQSV_A(MQA_CB_RETRIEVAL_FAILED, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__);
return m_LEAP_DBG_SINK(rc);
}
switch (info->i_op) {
case MDS_CALLBACK_COPY:
rc = mqa_mds_cpy(mqa_cb, &info->info.cpy);
break;
case MDS_CALLBACK_ENC:
rc = mqa_mds_enc(mqa_cb, &info->info.enc);
break;
case MDS_CALLBACK_DEC:
rc = mqa_mds_dec(mqa_cb, &info->info.dec);
break;
case MDS_CALLBACK_ENC_FLAT:
rc = mqa_mds_enc(mqa_cb, &info->info.enc_flat);
break;
case MDS_CALLBACK_DEC_FLAT:
rc = mqa_mds_dec(mqa_cb, &info->info.dec_flat);
break;
case MDS_CALLBACK_RECEIVE:
rc = mqa_mds_rcv(mqa_cb, &info->info.receive);
break;
case MDS_CALLBACK_SVC_EVENT:
rc = mqa_mds_svc_evt(mqa_cb, &info->info.svc_evt);
break;
default:
m_LOG_MQSV_A(MQA_MDS_CALLBK_UNKNOWN_OP, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, 0, __FILE__, __LINE__);
break;
}
if (rc != NCSCC_RC_SUCCESS) {
m_LOG_MQSV_A(MQA_MDS_CALLBK_FAILURE, NCSFL_LC_MQSV_INIT, NCSFL_SEV_ERROR, rc, __FILE__, __LINE__);
}
m_MQSV_MQA_GIVEUP_MQA_CB;
return rc;
}
static int __init_gld(void)
{
NCS_LIB_REQ_INFO lib_create;
/* Init LIB_CREATE request for Server */
memset(&lib_create, 0, sizeof(lib_create));
lib_create.i_op = NCS_LIB_REQ_CREATE;
lib_create.info.create.argc = 0;
lib_create.info.create.argv = NULL;
if (ncs_agents_startup() != NCSCC_RC_SUCCESS)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
/* Init GLD */
TRACE("GLSV:GLD:ON");
if (gld_lib_req(&lib_create) != NCSCC_RC_SUCCESS) {
fprintf(stderr, "gld_lib_req FAILED\n");
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
}
return (NCSCC_RC_SUCCESS);
}
uint32_t ncshm_init(void)
{
/* Hdl Mgr does bit-fields; here we do a few exercises up front to make */
/* sure YOUR target system can cope with bit-stuff we do............... */
HM_HDL ha;
HM_HDL hb;
HM_HDL *p_hdl;
uint32_t *p_temp;
uint32_t cnt = 0;
gl_im_created++;
if (gl_im_created > 1)
return NCSCC_RC_SUCCESS;
assert(sizeof(HM_FREE) == sizeof(HM_CELL)); /* must be same size */
assert(sizeof(uint32_t) == sizeof(HM_HDL)); /* must be same size */
ha.idx1 = 1; /* make up a fake handle with values */
ha.idx2 = 2;
ha.idx3 = 3;
ha.seq_id = 6;
/* cast to INT PTR, to HDL PTR, deref to HDL; bit-fields still stable ? */
p_temp = (uint32_t *)(&ha);
p_hdl = (HM_HDL *)p_temp;
hb = *p_hdl;
/* are all the bitfields still in tact?? .............................. */
assert(((ha.idx1 == hb.idx1) && (ha.idx2 == hb.idx2) && (ha.idx3 == hb.idx3) && (ha.seq_id == hb.seq_id)));
/* Done with basic tests; now we move on to normal initialization */
memset(&gl_hm, 0, sizeof(HM_CORE));
for (cnt = 0; cnt < HM_POOL_CNT; cnt++)
m_NCS_LOCK_INIT(&gl_hm.lock[cnt]);
if (hm_init_pools(gl_hm.pool, gl_hpool) != NCSCC_RC_SUCCESS)
return m_LEAP_DBG_SINK(NCSCC_RC_FAILURE);
return NCSCC_RC_SUCCESS;
}
USRBUF *ncs_decode_n_octets(USRBUF *u, uns8 *os, uns32 count)
{
char *s;
/** Xtract "count" # of octets from the packet...
**/
if ((s = m_MMGR_DATA_AT_START(u, count, (char *)os)) != (char *)os) {
if (s == 0) {
m_LEAP_DBG_SINK(0);
return (USRBUF *)0;
}
memcpy(os, s, (size_t)count);
}
/** Strip off "count" number of octets from the packet...
**/
m_MMGR_REMOVE_FROM_START(&u, count);
return u; /* Return the new head */
}
