コード例 #1
0
/****************************************************************************
  Name          : ava_lib_req
 
  Description   : This routine is exported to the external entities & is used
                  to create & destroy the AvA library.
 
  Arguments     : req_info - ptr to the request info
 
  Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
 
  Notes         : None
******************************************************************************/
uns32 ava_lib_req(NCS_LIB_REQ_INFO *req_info)
{
	uns32 rc = NCSCC_RC_SUCCESS;
	TRACE_ENTER();

	switch (req_info->i_op) {
	case NCS_LIB_REQ_CREATE:
		rc = ava_create(&req_info->info.create);
		if (NCSCC_RC_SUCCESS == rc) {
			TRACE_1("AVA creation success");
		} else {
			TRACE_4("AVA creation failed");
		}
		break;

	case NCS_LIB_REQ_DESTROY:
		ava_destroy(&req_info->info.destroy);
		if (NCSCC_RC_SUCCESS == rc) {
			TRACE_1("AVA creation success");
		} else {
			TRACE_4("AVA creation failed");
		}
		break;

	default:
		break;
	}

	TRACE_LEAVE();
	return rc;
}
コード例 #2
0
ファイル: Frontend.cpp プロジェクト: rgly/pinavm
bool Frontend::run()
{
	TRACE_1("Getting ELAB\n");

	this->elab = new SCElab(llvmMod);
	this->elab->complete();

	this->scjit = new SCJit(llvmMod, elab);
	this->sccfactory = new SCCFactory(scjit);


	TRACE_1("Analyzing code\n");

	if (this->elab->getProcesses()->empty()) {
		TRACE_1("WARNING: No process found.\n");
	}

	TRACE_4("NB of functions BEFORE inlining : " << llvmMod->size() << "\n");

	if (this->inlineFunctions) {
		this->inlineProcessFct();
	}
	
	TRACE_4("NB of functions after inlining : " << llvmMod->size() << "\n");

	this->handleConstruct_and_GV();

	TRACE_4("NB of functions after frontend : " << llvmMod->size() << "\n");

	return false;
}
コード例 #3
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
/****************************************************************************
  Name          : eda_enc_chan_unlink_msg
 
  Description   : This routine encodes a chan unlink API msg
 
  Arguments     : NCS_UBAID *msg,
                  EDSV_MSG *msg
                  
  Return Values : uint32_t
 
  Notes         : None.
******************************************************************************/
static uint32_t eda_enc_chan_unlink_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	uint32_t total_bytes = 0;
	EDSV_EDA_CHAN_UNLINK_PARAM *param = &msg->info.api_info.param.chan_unlink;

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}

   /** encode the contents **/
	p8 = ncs_enc_reserve_space(uba, 6);
	if (!p8) {
		TRACE_4("reserve space failed");
	}
	ncs_encode_32bit(&p8, param->reg_id);
	ncs_encode_16bit(&p8, param->chan_name.length);
	ncs_enc_claim_space(uba, 6);
	total_bytes += 6;

	ncs_encode_n_octets_in_uba(uba, param->chan_name.value, (uint32_t)param->chan_name.length);
	total_bytes += (uint32_t)param->chan_name.length;

	return total_bytes;
}
コード例 #4
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
/****************************************************************************
  Name          : eda_enc_retention_time_clr_msg
 
  Description   : This routine encodes a retention time clear API msg
 
  Arguments     : NCS_UBAID *msg,
                  EDSV_MSG *msg
                  
  Return Values : uint32_t
 
  Notes         : None.
******************************************************************************/
static uint32_t eda_enc_retention_time_clr_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	uint32_t total_bytes = 0;
	EDSV_EDA_RETENTION_TIME_CLR_PARAM *param = &msg->info.api_info.param.rettimeclr;

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}

   /** encode the contents **/
	p8 = ncs_enc_reserve_space(uba, 16);
	if (!p8) {
		TRACE_4("reserve space failed");
	}
	ncs_encode_32bit(&p8, param->reg_id);
	ncs_encode_32bit(&p8, param->chan_id);
	ncs_encode_32bit(&p8, param->chan_open_id);
	ncs_encode_32bit(&p8, param->event_id);
	ncs_enc_claim_space(uba, 16);
	total_bytes += 16;

	return total_bytes;
}
コード例 #5
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
/****************************************************************************
  Name          : eda_enc_unsubscribe_msg
 
  Description   : This routine encodes a unsubscribe API msg
 
  Arguments     : NCS_UBAID *msg,
                  EDSV_MSG *msg
                  
  Return Values : uint32_t
 
  Notes         : None.
******************************************************************************/
static uint32_t eda_enc_unsubscribe_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	uint32_t total_bytes = 0;
	EDSV_EDA_UNSUBSCRIBE_PARAM *param = &msg->info.api_info.param.unsubscribe;

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}

   /** encode the contents **/
	p8 = ncs_enc_reserve_space(uba, 16);
	if (!p8) {
		TRACE_4("reserve space failed");
	}
	ncs_encode_32bit(&p8, param->reg_id);
	ncs_encode_32bit(&p8, param->chan_id);
	ncs_encode_32bit(&p8, param->chan_open_id);
	ncs_encode_32bit(&p8, param->sub_id);
	ncs_enc_claim_space(uba, 16);
	total_bytes += 16;

	return total_bytes;
}
コード例 #6
0
ファイル: cpa_mds.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
  Name          : cpa_mds_enc_flat
 
  Description   : This function encodes an events sent from CPA.
 
  Arguments     : cb    : CPA control Block.
                  enc_info  : Info for encoding
  
  Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
 
  Notes         : None.
******************************************************************************/
static uint32_t cpa_mds_enc_flat(CPA_CB *cb, MDS_CALLBACK_ENC_FLAT_INFO *info)
{
	CPSV_EVT *evt = NULL;
	NCS_UBAID *uba = info->io_uba;
	uint32_t rc = NCSCC_RC_SUCCESS;

	TRACE_ENTER();
	/* Get the Msg Format version from the SERVICE_ID & RMT_SVC_PVT_SUBPART_VERSION */
	if (info->i_to_svc_id == NCSMDS_SVC_ID_CPND) {
		info->o_msg_fmt_ver = m_NCS_ENC_MSG_FMT_GET(info->i_rem_svc_pvt_ver,
							    CPA_WRT_CPND_SUBPART_VER_MIN,
							    CPA_WRT_CPND_SUBPART_VER_MAX, cpa_cpnd_msg_fmt_table);
	}
	if (info->o_msg_fmt_ver) {
		if (info->i_to_svc_id == NCSMDS_SVC_ID_CPND) {
			/* as all the event structures are flat */
			evt = (CPSV_EVT *)info->i_msg;
			rc = cpsv_evt_enc_flat(&cb->edu_hdl, evt, uba);
			if (rc != NCSCC_RC_SUCCESS)
				TRACE_4("CPA mds_enc_flat failed with return value:%d",rc);
			TRACE_LEAVE();
			return rc;
		} else {
			TRACE_4("CPA mds_enc_flat failed with return value:%d",rc);
			return NCSCC_RC_FAILURE;
		}
	} else {
		/* Drop The Message */
		TRACE_4("CPA mds_enc_flat failed with return value:%d",rc);
		return NCSCC_RC_FAILURE;
	}


}
コード例 #7
0
ファイル: eds_tmr.c プロジェクト: helioloureiro/opensaf-fork
/*****************************************************************************
  PROCEDURE NAME : eds_stop_tmr

  DESCRIPTION    : Stops the EDS timer.

  ARGUMENTS      : tmr    - ptr to the EDS timer block
               
  RETURNS        : void

  NOTES          : None
*****************************************************************************/
void eds_stop_tmr(EDS_TMR *tmr)
{
	/* If timer type is invalid just return */
	if (tmr == NULL) {
		TRACE_4("timer is NULL");
		TRACE_LEAVE();
		return;
	} else if (EDS_TMR_MAX <= tmr->type) {
		TRACE_4("unsupported timer type");
		TRACE_LEAVE();
		return;
	}

	/* Stop the timer if it is active... */
	if (tmr->is_active == true) {
		m_NCS_TMR_STOP(tmr->tmr_id);
		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;
	}

	return;
}
コード例 #8
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
/****************************************************************************
  Name          : eda_enc_subscribe_msg
 
  Description   : This routine encodes a subscribe API msg
 
  Arguments     : NCS_UBAID *msg,
                  EDSV_MSG *msg
                  
  Return Values : uint32_t
 
  Notes         : None.
******************************************************************************/
static uint32_t eda_enc_subscribe_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	uint32_t x;
	uint32_t total_bytes = 0;
	SaEvtEventFilterT *filter_ptr;
	EDSV_EDA_SUBSCRIBE_PARAM *param = &msg->info.api_info.param.subscribe;

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}

   /** encode the contents **/
	p8 = ncs_enc_reserve_space(uba, 24);
	if (!p8) {
		TRACE_4("reserve space failed");
	}
	ncs_encode_32bit(&p8, param->reg_id);
	ncs_encode_32bit(&p8, param->chan_id);
	ncs_encode_32bit(&p8, param->chan_open_id);
	ncs_encode_32bit(&p8, param->sub_id);
	ncs_encode_64bit(&p8, param->filter_array->filtersNumber);
	ncs_enc_claim_space(uba, 24);
	total_bytes += 24;

	/* Encode the filters */
	filter_ptr = param->filter_array->filters;
	for (x = 0; x < (uint32_t)param->filter_array->filtersNumber; x++) {
		/* Save room for the filterType(4 bytes), patternSize(8 bytes)
		 */
		p8 = ncs_enc_reserve_space(uba, 12);
		if (!p8) {
			TRACE_4("reserve space failed");
		}
		ncs_encode_32bit(&p8, filter_ptr->filterType);
		ncs_encode_64bit(&p8, filter_ptr->filter.patternSize);
		ncs_enc_claim_space(uba, 12);
		total_bytes = 12;

		/* For zero length filters, fake encode zero */
		if ((uint32_t)filter_ptr->filter.patternSize == 0) {
			p8 = ncs_enc_reserve_space(uba, 4);
			if (!p8) {
				TRACE_4("reserve space failed");
			}
			ncs_encode_32bit(&p8, 0);
			ncs_enc_claim_space(uba, 4);
			total_bytes += 4;
		} else {
			ncs_encode_n_octets_in_uba(uba, filter_ptr->filter.pattern,
						   (uint32_t)filter_ptr->filter.patternSize);
			total_bytes += (uint32_t)filter_ptr->filter.patternSize;
		}
		filter_ptr++;
	}

	return total_bytes;
}
コード例 #9
0
/****************************************************************************
 * PROCEDURE: mbcsv_lib_init
 *
 * Description   : This is the function which initalize the mbcsv libarary.
 *                 This function creates an global lock, creates MBCSV linked 
 *                 list, etc.
 *
 * Arguments     : req_info - Request info.
 *
 * Return Values : SA_AIS_OK/Failure code.
 *
 * Notes         : None.
 *****************************************************************************/
uint32_t mbcsv_lib_init(NCS_LIB_REQ_INFO *req_info)
{
	NCS_PATRICIA_PARAMS pt_params;
	uint32_t rc = SA_AIS_OK;
	TRACE_ENTER();

	if (mbcsv_cb.created == true) {
		TRACE_LEAVE2("Lib init request failed: MBCA already created");
		return SA_AIS_ERR_INIT;
	}

	/*
	 * Create global lock 
	 */
	m_NCS_LOCK_INIT(&mbcsv_cb.global_lock);

	/* 
	 * Create patricia tree for the MBCA registration instance 
	 */
	pt_params.key_size = sizeof(uint32_t);

	if (ncs_patricia_tree_init(&mbcsv_cb.reg_list, &pt_params) != NCSCC_RC_SUCCESS) {
		TRACE_4("pat tree init failed");
		rc = SA_AIS_ERR_FAILED_OPERATION;
		goto err1;
	}

	if (NCSCC_RC_SUCCESS != mbcsv_initialize_mbx_list()) {
		TRACE_4("pat tree init for mailbox failed");
		rc = SA_AIS_ERR_FAILED_OPERATION;
		goto err2;
	}

	/* 
	 * Create patricia tree for the peer list 
	 */
	if (mbcsv_initialize_peer_list() != NCSCC_RC_SUCCESS) {
		TRACE_4("pat tree init for peer list failed");
		rc = SA_AIS_ERR_FAILED_OPERATION;
		goto err3;
	}

	mbcsv_cb.created = true;

	return rc;

	/* Handle Different Error Situations */
 err3:
	ncs_patricia_tree_destroy(&mbcsv_cb.mbx_list);
	m_NCS_LOCK_DESTROY(&mbcsv_cb.mbx_list_lock);
 err2:
	ncs_patricia_tree_destroy(&mbcsv_cb.reg_list);
 err1:
	m_NCS_LOCK_DESTROY(&mbcsv_cb.global_lock);
	TRACE_LEAVE();
	return rc;
}
コード例 #10
0
ファイル: cpa_mds.c プロジェクト: helioloureiro/opensaf-fork
uint32_t cpa_mds_register(CPA_CB *cb)
{
	NCSMDS_INFO svc_info;
	MDS_SVC_ID subs_id[2] = { NCSMDS_SVC_ID_CPND, NCSMDS_SVC_ID_CPD };
	uint32_t rc = NCSCC_RC_SUCCESS;
	
	TRACE_ENTER();
	/* STEP1: Get the MDS Handle */
	if (cpa_mds_get_handle(cb) != NCSCC_RC_SUCCESS)
		return NCSCC_RC_FAILURE;

	/* memset the svc_info */
	memset(&svc_info, 0, sizeof(NCSMDS_INFO));

	/* STEP 2 : Install on ADEST with MDS with service ID NCSMDS_SVC_ID_CPA. */
	svc_info.i_mds_hdl = cb->cpa_mds_hdl;
	svc_info.i_svc_id = NCSMDS_SVC_ID_CPA;
	svc_info.i_op = MDS_INSTALL;

	svc_info.info.svc_install.i_yr_svc_hdl = cb->agent_handle_id;
	svc_info.info.svc_install.i_install_scope = NCSMDS_SCOPE_NONE;	/* node specific */
	svc_info.info.svc_install.i_svc_cb = cpa_mds_callback;	/* callback */
	svc_info.info.svc_install.i_mds_q_ownership = false;	/* CPA owns the mds queue */
	svc_info.info.svc_install.i_mds_svc_pvt_ver = CPA_MDS_PVT_SUBPART_VERSION;	/* Private Subpart Version of CPA for Versioning infrastructure */

	if ((rc = ncsmds_api(&svc_info)) != NCSCC_RC_SUCCESS) {
		TRACE_4("CPA MDS:INSTALL failed with return value:%d",rc);
		return rc;
	}
	cb->cpa_mds_dest = svc_info.info.svc_install.o_dest;

	/* STEP 3: Subscribe to CPND up/down events */
	svc_info.i_op = MDS_SUBSCRIBE;
	svc_info.info.svc_subscribe.i_num_svcs = 1;
	svc_info.info.svc_subscribe.i_scope = NCSMDS_SCOPE_NONE;
	svc_info.info.svc_subscribe.i_svc_ids = &subs_id[0];

	if ((rc = ncsmds_api(&svc_info)) != NCSCC_RC_SUCCESS) {
		TRACE_4("CPA MDS:SUBSCRIBE failed with return value:%d",rc);
		goto error;
	}

	return NCSCC_RC_SUCCESS;

 error:
	/* Uninstall with the mds */
	cpa_mds_unregister(cb);
	
	TRACE_LEAVE2("retval = %u", rc);
	return NCSCC_RC_FAILURE;
}
コード例 #11
0
ファイル: cpa_mds.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
  Name          : cpa_mds_msg_send
 
  Description   : This routine sends the CPA message to CPND.
 
  Arguments     : uint32_t cpa_mds_hdl Handle of CPA
                  MDS_DEST  *destination - destintion to send to
                  CPSV_EVT   *i_evt - CPSV_EVT pointer
                  
  Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
 
  Notes         : None.
******************************************************************************/
uint32_t cpa_mds_msg_send(uint32_t cpa_mds_hdl, MDS_DEST *destination, CPSV_EVT *i_evt, uint32_t to_svc)
{
	NCSMDS_INFO mds_info;
	uint32_t rc;

	TRACE_ENTER();

	if (!i_evt)
		return NCSCC_RC_FAILURE;

	memset(&mds_info, 0, sizeof(NCSMDS_INFO));
	mds_info.i_mds_hdl = cpa_mds_hdl;
	mds_info.i_svc_id = NCSMDS_SVC_ID_CPA;
	mds_info.i_op = MDS_SEND;

	/* fill the send structure */
	mds_info.info.svc_send.i_msg = (NCSCONTEXT)i_evt;
	mds_info.info.svc_send.i_priority = MDS_SEND_PRIORITY_MEDIUM;
	mds_info.info.svc_send.i_to_svc = to_svc;
	mds_info.info.svc_send.i_sendtype = MDS_SENDTYPE_SND;

	/* fill the send rsp strcuture */
	mds_info.info.svc_send.info.snd.i_to_dest = *destination;

	/* send the message */
	rc = ncsmds_api(&mds_info);

	if (NCSCC_RC_SUCCESS != rc)
		TRACE_4("Cpa MDS send failed");
	else
		TRACE_1("Cpa MDS send success");

	TRACE_LEAVE();
	return rc;
}
コード例 #12
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
/****************************************************************************
  Name          : eda_dec_chan_open_cbk_msg
 
  Description   : This routine decodes a channel open callback message
 
  Arguments     : NCS_UBAID *msg,
                  EDSV_MSG *msg
                  
  Return Values : uint32_t
 
  Notes         : None.
******************************************************************************/
static uint32_t eda_dec_chan_open_cbk_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	int32_t total_bytes = 0;
	EDSV_EDA_CHAN_OPEN_CBK_PARAM *param = &msg->info.cbk_info.param.chan_open_cbk;
	uint8_t local_data[256];

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}

	/* chan_name_len */
	p8 = ncs_dec_flatten_space(uba, local_data, 2);
	param->chan_name.length = ncs_decode_16bit(&p8);
	ncs_dec_skip_space(uba, 2);
	total_bytes += 2;

	/* chan_name */
	ncs_decode_n_octets_from_uba(uba, param->chan_name.value, (uint32_t)param->chan_name.length);
	total_bytes += (uint32_t)param->chan_name.length;

	/* chan_id, chan_open_id, chan_open_flags, eda_chan_hdl, error */
	p8 = ncs_dec_flatten_space(uba, local_data, 17);
	param->chan_id = ncs_decode_32bit(&p8);
	param->chan_open_id = ncs_decode_32bit(&p8);
	param->chan_open_flags = ncs_decode_8bit(&p8);
	param->eda_chan_hdl = ncs_decode_32bit(&p8);
	param->error = ncs_decode_32bit(&p8);
	ncs_dec_skip_space(uba, 17);
	total_bytes += 17;

	return total_bytes;
}
コード例 #13
0
ファイル: Frontend.cpp プロジェクト: rgly/pinavm
void Frontend::handleFctConstruct_and_GV(Process* proc, Function* F,
					std::vector<Function*>* fctStack)
{
	for(inst_iterator i = inst_begin(F); i != inst_end(F); ++i) {
		bool callB = false;
		Function* calledFunction = NULL;
		Instruction* currentInst = &*i;
		BasicBlock* bb = currentInst->getParent();
		if (CallInst *callInst = dyn_cast < CallInst > (currentInst)) {
			callB = true;
			calledFunction =  callInst->getCalledFunction();
		} else if(InvokeInst *invokeInst = dyn_cast < InvokeInst > (currentInst)) {
			callB = true;
			calledFunction =  invokeInst->getCalledFunction();
		}

		if (! calledFunction) {
			TRACE_6("Encountered call to function pointer. Not parsing it.\n");
		} else if (! this->sccfactory->handle(proc, F, bb, currentInst, calledFunction)) {
			TRACE_6("CallInst : " << currentInst << "\n");
			TRACE_6("CalledFct : " << calledFunction << "\n");
			PRINT_6(currentInst->dump());
			TRACE_4("Call not handled : " << calledFunction->getName().str() << "\n");
			fctStack->push_back(calledFunction);
			proc->addUsedFunction(calledFunction);

		} else if (calledFunction->getIntrinsicID() != Intrinsic::not_intrinsic) {
			TRACE_6("Encountered call to intrinsic function \"" << calledFunction->getName().str() << "\" (id = " << calledFunction->getIntrinsicID() << "). Not parsing it.\n");
		}
		if (! callB) {
			this->fillGlobalVars(currentInst);
		}
	}
}
コード例 #14
0
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);
}
コード例 #15
0
/**
 *   response to the lib on a saNtfNotificationReadNext request
 *   @param error     error code sent back to the library
 *   @param notification  The next notification read or NULL if none exist
 */
void read_next_res_lib(SaAisErrorT error,
		       ntfsv_send_not_req_t *notification, MDS_DEST mdsDest, MDS_SYNC_SND_CTXT *mdsCtxt)
{
	uns32 rc = NCSCC_RC_SUCCESS;
	ntfsv_msg_t msg;
	TRACE_ENTER();

	msg.type = NTFSV_NTFA_API_RESP_MSG;
	msg.info.api_resp_info.type = NTFSV_READ_NEXT_RSP;
	msg.info.api_resp_info.rc = error;
	msg.info.api_resp_info.param.read_next_rsp.readNotification = notification;
	if (msg.info.api_resp_info.rc == SA_AIS_OK) {
		SaNtfNotificationHeaderT *header;
		ntfsv_get_ntf_header(notification, &header);
		TRACE_4("notId: %llu, rv: %u", *header->notificationId, error);
	}

	rc = ntfs_mds_msg_send(ntfs_cb, &msg, &mdsDest, mdsCtxt, MDS_SEND_PRIORITY_HIGH);
	if (rc != NCSCC_RC_SUCCESS) {
		TRACE("ntfs_mds_msg_send FAILED");
		/* TODO: what to do exit here? */
	}
	TRACE_LEAVE();

/* TODO: async update*/
};
コード例 #16
0
ファイル: cpa_mds.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
  Name          : cpa_mds_dec

  Description   : This function decodes an events sent to CPA.

  Arguments     : cb    : CPA control Block.
                  info  : Info for decoding

  Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE

  Notes         : None.
******************************************************************************/
static uint32_t cpa_mds_dec(CPA_CB *cb, MDS_CALLBACK_DEC_INFO *dec_info)
{
	CPSV_EVT *msg_ptr = NULL;
	EDU_ERR ederror = 0;
	uint32_t rc = NCSCC_RC_SUCCESS;
	uint8_t local_data[20];
	uint8_t *pstream;
	bool is_valid_msg_fmt = false;
	
	TRACE_ENTER();

	if (dec_info->i_fr_svc_id == NCSMDS_SVC_ID_CPND) {
		is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(dec_info->i_msg_fmt_ver,
							     CPA_WRT_CPND_SUBPART_VER_MIN,
							     CPA_WRT_CPND_SUBPART_VER_MAX, cpa_cpnd_msg_fmt_table);
	} else if (dec_info->i_fr_svc_id == NCSMDS_SVC_ID_CPD) {
		is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(dec_info->i_msg_fmt_ver,
							     CPA_WRT_CPD_SUBPART_VER_MIN,
							     CPA_WRT_CPD_SUBPART_VER_MAX, cpa_cpd_msg_fmt_table);
	}

	if (is_valid_msg_fmt) {

		msg_ptr = m_MMGR_ALLOC_CPSV_EVT(NCS_SERVICE_ID_CPA);
		if (!msg_ptr)
			return NCSCC_RC_FAILURE;

		memset(msg_ptr, 0, sizeof(CPSV_EVT));
		dec_info->o_msg = (NCSCONTEXT)msg_ptr;
		pstream = ncs_dec_flatten_space(dec_info->io_uba, local_data, 8);
		msg_ptr->type = ncs_decode_32bit(&pstream);
		if (msg_ptr->type == CPSV_EVT_TYPE_CPA) {
			/* For Events  Write/Read Call EDU VER_EXEC*/
			rc = m_NCS_EDU_VER_EXEC(&cb->edu_hdl, FUNC_NAME(CPSV_EVT),
					dec_info->io_uba, EDP_OP_TYPE_DEC,
					(CPSV_EVT **)&dec_info->o_msg, &ederror, dec_info->i_msg_fmt_ver);
			goto free;

			/* if(msg_ptr->info.cpa.type == CPA_EVT_ND2A_CKPT_DATA_RSP) */
		}
		/* if( msg_ptr->type == CPSV_EVT_TYPE_CPA) */
		/* For all Other Cases Other Than CPA( Read / Write Rsp Follow EDU rules */
		rc = m_NCS_EDU_EXEC(&cb->edu_hdl, FUNC_NAME(CPSV_EVT),
				    dec_info->io_uba, EDP_OP_TYPE_DEC, (CPSV_EVT **)&dec_info->o_msg, &ederror);
 free:
		if (rc != NCSCC_RC_SUCCESS) {
			m_MMGR_FREE_CPSV_EVT(dec_info->o_msg, NCS_SERVICE_ID_CPA);
		}
		TRACE_LEAVE();
		return rc;
	} else {
		TRACE_4("CPA:Processing failed for mds_dec ");
		TRACE_LEAVE();
		return NCSCC_RC_FAILURE;
	}
}
コード例 #17
0
ファイル: cpd_red.c プロジェクト: helioloureiro/opensaf-fork
/************************************************************************************
 * 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;
}
コード例 #18
0
ファイル: cpa_mds.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
  Name          : cpa_mds_dec_flat
 
  Description   : This function decodes an events sent to CPA.
 
  Arguments     : cb    : CPA control Block.
                  dec_info  : Info for decoding
  
  Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
 
  Notes         : None.
******************************************************************************/
static uint32_t cpa_mds_dec_flat(CPA_CB *cb, MDS_CALLBACK_DEC_FLAT_INFO *info)
{
	CPSV_EVT *evt = NULL;
	NCS_UBAID *uba = info->io_uba;
	uint32_t rc = NCSCC_RC_SUCCESS;
	bool is_valid_msg_fmt = false;

	TRACE_ENTER();

	if (info->i_fr_svc_id == NCSMDS_SVC_ID_CPND) {
		is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(info->i_msg_fmt_ver,
							     CPA_WRT_CPND_SUBPART_VER_MIN,
							     CPA_WRT_CPND_SUBPART_VER_MAX, cpa_cpnd_msg_fmt_table);
	} else if (info->i_fr_svc_id == NCSMDS_SVC_ID_CPD) {
		is_valid_msg_fmt = m_NCS_MSG_FORMAT_IS_VALID(info->i_msg_fmt_ver,
							     CPA_WRT_CPD_SUBPART_VER_MIN,
							     CPA_WRT_CPD_SUBPART_VER_MAX, cpa_cpd_msg_fmt_table);
	}

	if (is_valid_msg_fmt) {

		if (info->i_fr_svc_id == NCSMDS_SVC_ID_CPND || info->i_fr_svc_id == NCSMDS_SVC_ID_CPD) {
			evt = (CPSV_EVT *)m_MMGR_ALLOC_CPSV_EVT(NCS_SERVICE_ID_CPA);
			if (evt == NULL) {
				TRACE_4("cpa mem allocation failed in mds_dec_flat");
				return NCSCC_RC_OUT_OF_MEM;
			}
			info->o_msg = evt;
			rc = cpsv_evt_dec_flat(&cb->edu_hdl, uba, evt);
			TRACE_LEAVE();
			return rc;
		} else {
			TRACE_4("cpa api processing failed in mds_dec_flat with return value:%d",rc);
			return NCSCC_RC_FAILURE;
		}
	} else {
		TRACE_4("cpa api processing failed in mds_dec_flat with return value:%d",rc);
		return NCSCC_RC_FAILURE;
	}
}
コード例 #19
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
/****************************************************************************
  Name          : eda_enc_finalize_msg
 
  Description   : This routine encodes a finalize API msg
 
  Arguments     : NCS_UBAID *msg,
                  EDSV_MSG *msg
                  
  Return Values : uint32_t
 
  Notes         : None.
******************************************************************************/
static uint32_t eda_enc_finalize_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	uint32_t total_bytes = 0;
	EDSV_EDA_FINALIZE_PARAM *param = &msg->info.api_info.param.finalize;

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}

   /** encode the contents **/
	p8 = ncs_enc_reserve_space(uba, 4);
	if (!p8) {
		TRACE_4("reserve space failed");
	}
	ncs_encode_32bit(&p8, param->reg_id);
	ncs_enc_claim_space(uba, 4);
	total_bytes += 4;

	return total_bytes;
}
コード例 #20
0
ファイル: cpnd_db.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
 * Name          : cpnd_ckpt_sec_del
 *
 * Description   : Function to remove the section from a checkpoint.
 *
 * Arguments     : CPND_CKPT_NODE *cp_node - Check point node.
 *               : SaCkptSectionIdT id - Section Identifier
 *                 
 * Return Values :  ptr to CPND_CKPT_SECTION_INFO/NULL;
 *
 * Notes         : None.
 *****************************************************************************/
CPND_CKPT_SECTION_INFO *cpnd_ckpt_sec_del(CPND_CKPT_NODE *cp_node, SaCkptSectionIdT *id)
{
	CPND_CKPT_SECTION_INFO *pSecPtr = NULL;
	uint32_t rc = NCSCC_RC_SUCCESS;

	TRACE_ENTER();
	pSecPtr = cp_node->replica_info.section_info;
	while (pSecPtr != NULL) {
		if ((pSecPtr->sec_id.idLen == id->idLen) && (memcmp(pSecPtr->sec_id.id, id->id, id->idLen) == 0)) {
			/* delete it from the list and return the pointer */
			if (cp_node->replica_info.section_info == pSecPtr)
				cp_node->replica_info.section_info = cp_node->replica_info.section_info->next;
			if (pSecPtr->prev)
				pSecPtr->prev->next = pSecPtr->next;
			if (pSecPtr->next)
				pSecPtr->next->prev = pSecPtr->prev;

			cp_node->replica_info.n_secs--;
			cp_node->replica_info.mem_used = cp_node->replica_info.mem_used - (pSecPtr->sec_size);

			/* UPDATE THE SECTION HEADER */
			rc = cpnd_sec_hdr_update(pSecPtr, cp_node);
			if (rc == NCSCC_RC_FAILURE) {
				TRACE_4("cpnd sect hdr update failed");
			}
			/* UPDATE THE CHECKPOINT HEADER */
			rc = cpnd_ckpt_hdr_update(cp_node);
			if (rc == NCSCC_RC_FAILURE) {
				TRACE_4("cpnd ckpt hdr update failed");
			}	
			TRACE_LEAVE();
			return pSecPtr;
		}
		pSecPtr = pSecPtr->next;
	}
	TRACE_LEAVE();
	return NULL;
}
コード例 #21
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
/****************************************************************************
  Name          : eda_enc_initialize_msg
 
  Description   : This routine encodes an initialize API msg
 
  Arguments     : NCS_UBAID *msg,
                  EDSV_MSG *msg
                  
  Return Values : uint32_t
 
  Notes         : None.
******************************************************************************/
static uint32_t eda_enc_initialize_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	uint32_t total_bytes = 0;
	EDSV_EDA_INIT_PARAM *param = &msg->info.api_info.param.init;

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}
   /** encode the contents **/
	p8 = ncs_enc_reserve_space(uba, 3);
	if (!p8) {
		TRACE_4("reserve space failed");
	}
	ncs_encode_8bit(&p8, param->version.releaseCode);
	ncs_encode_8bit(&p8, param->version.majorVersion);
	ncs_encode_8bit(&p8, param->version.minorVersion);
	ncs_enc_claim_space(uba, 3);
	total_bytes += 3;

	return total_bytes;
}
コード例 #22
0
ファイル: Frontend.cpp プロジェクト: rgly/pinavm
bool Frontend::inlineForProcessFct(Function* F) {
	for(inst_iterator i = inst_begin(F); i != inst_end(F); ++i) {
		Function* calledFunction = NULL;
		Instruction* currentInst = &*i;
		BasicBlock* bb = currentInst->getParent();
		bool isInvoke = false;
		if (CallInst *callInst = dyn_cast < CallInst > (currentInst)) {
			calledFunction =  callInst->getCalledFunction();
		} else if(InvokeInst *invokeInst = dyn_cast < InvokeInst > (currentInst)) {
			calledFunction =  invokeInst->getCalledFunction();
			isInvoke = true;
		} 

		if (! calledFunction) {
			TRACE_6("Encountered call to function pointer. Not parsing it.\n");
		} else if (! this->sccfactory->handlerExists(F, bb, currentInst, calledFunction)) {
			TRACE_6("CallInst : " << currentInst << "\n");
			TRACE_6("CalledFct : " << calledFunction << "\n");
			PRINT_6(currentInst->dump());
			TRACE_4("Call not handled : " << calledFunction->getName().str() << "\n");
			TRACE_4("Inlining function : " << calledFunction->getName().str() << "\n");
			bool isInlined = false;
			llvm::InlineFunctionInfo ifi;
			if (isInvoke) {
				isInlined = llvm::InlineFunction(dyn_cast<InvokeInst>(currentInst), ifi);
			} else {
				isInlined = llvm::InlineFunction(dyn_cast<CallInst>(currentInst), ifi);
			}
			// InlineFunction invalidates iterators => restart loop.
			if (isInlined) {
				return true;
			}
		}
	}

	return false;
}
コード例 #23
0
/****************************************************************************
  Name          : ava_destroy
 
  Description   : This routine destroys the AvA control block.
 
  Arguments     : destroy_info - ptr to the destroy info
 
  Return Values : None
 
  Notes         : None
******************************************************************************/
void ava_destroy(NCS_LIB_DESTROY *destroy_info)
{
	AVA_CB *cb = 0;
	uns32 rc = NCSCC_RC_SUCCESS;
	TRACE_ENTER();

	/* retrieve AvA CB */
	cb = (AVA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_AVA, gl_ava_hdl);
	if (!cb) {
		LOG_ER("Unable to take handle for control block");
		goto done;
	}

	/* delete the hdl db */
	ava_hdl_del(cb);
	TRACE_1("Deleted the handles DB");

	/* unregister with MDS */
	rc = ava_mds_unreg(cb);
	if (NCSCC_RC_SUCCESS != rc)
		TRACE_4("MDS unregistration failed");
	else
		TRACE_1("MDS unregistration success");

	/* EDU cleanup */
	m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);
	TRACE_1("EDU cleanup failed");

	/* destroy the lock */
	m_NCS_LOCK_DESTROY(&cb->lock);
	TRACE_1("Destroying lock for control block failed");

	/* return AvA CB */
	ncshm_give_hdl(gl_ava_hdl);

	/* remove the association with hdl-mngr */
	ncshm_destroy_hdl(NCS_SERVICE_ID_AVA, cb->cb_hdl);
	TRACE_1("Removing association with handle manager failed");

	/* free the control block */
	free(cb);

	/* reset the global cb handle */
	gl_ava_hdl = 0;

 done:
	TRACE_LEAVE();
	return;
}
コード例 #24
0
ファイル: cpa_mds.c プロジェクト: helioloureiro/opensaf-fork
uint32_t cpa_mds_get_handle(CPA_CB *cb)
{
	NCSADA_INFO arg;
	uint32_t rc;

	memset(&arg, 0, sizeof(NCSADA_INFO));
	arg.req = NCSADA_GET_HDLS;
	rc = ncsada_api(&arg);

	if (rc != NCSCC_RC_SUCCESS) {
		TRACE_4("CPA processing failed for ADA:GET_HDLS with return value:%d",rc);
		return rc;
	}
	cb->cpa_mds_hdl = arg.info.adest_get_hdls.o_mds_pwe1_hdl;
	return rc;
}
コード例 #25
0
ファイル: mqa_init.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
  Name          : mqa_destroy
 
  Description   : This routine destroys the MQA control block.
 
  Arguments     : destroy_info - ptr to the destroy info
 
  Return Values : NCSCC_RC_SUCCESS/NCSCC_RC_FAILURE
 
  Notes         : None
******************************************************************************/
static uint32_t mqa_destroy(NCS_LIB_DESTROY *destroy_info)
{
	MQA_CB *cb = 0;
	TRACE_ENTER();

	/* validate the CB */
	cb = (MQA_CB *)ncshm_take_hdl(NCS_SERVICE_ID_MQA, gl_mqa_hdl);
	if (!cb)
		return NCSCC_RC_FAILURE;

	/* return MQA CB */
	ncshm_give_hdl(gl_mqa_hdl);

	/* remove the association with hdl-mngr */
	ncshm_destroy_hdl(NCS_SERVICE_ID_MQA, cb->agent_handle_id);

	if (m_NCS_LOCK(&cb->cb_lock, NCS_LOCK_WRITE) != NCSCC_RC_SUCCESS)	{
		TRACE_4("FAILURE: mqa_destroy Failed to acquire lock");
		return NCSCC_RC_FAILURE;
	}

	mqa_timer_table_destroy(cb);

	/* Unregister with ASAPi */
	mqa_asapi_unregister(cb);

	/* MDS unregister. */
	mqa_mds_unregister(cb);

	m_NCS_EDU_HDL_FLUSH(&cb->edu_hdl);

	mqa_queue_tree_destroy(cb);

	/* delete all the client info */
	mqa_client_tree_destroy(cb);

	m_NCS_UNLOCK(&cb->cb_lock, NCS_LOCK_WRITE);

	/* destroy the lock */
	m_NCS_LOCK_DESTROY(&cb->cb_lock);

	/* reset the global cb handle */
	gl_mqa_hdl = 0;

	TRACE_LEAVE();
	return NCSCC_RC_SUCCESS;
}
コード例 #26
0
ファイル: callout.c プロジェクト: andreiw/polaris
/*
 * Arrange that func(arg) be called after delta clock ticks.
 */
static timeout_id_t
timeout_common(void (*func)(void *), void *arg, clock_t delta,
    callout_table_t *ct)
{
	callout_t *cp;
	callout_id_t id;
	clock_t runtime;

	mutex_enter(&ct->ct_lock);

	if ((cp = ct->ct_freelist) == NULL)
		cp = callout_alloc(ct);
	else
		ct->ct_freelist = cp->c_idnext;

	cp->c_func = func;
	cp->c_arg = arg;

	/*
	 * Make sure the callout runs at least 1 tick in the future.
	 */
	if (delta <= 0)
		delta = 1;
	cp->c_runtime = runtime = lbolt + delta;

	/*
	 * Assign an ID to this callout
	 */
	if (delta > CALLOUT_LONGTERM_TICKS)
		ct->ct_long_id = id = (ct->ct_long_id - CALLOUT_COUNTER_LOW) |
		    CALLOUT_COUNTER_HIGH;
	else
		ct->ct_short_id = id = (ct->ct_short_id - CALLOUT_COUNTER_LOW) |
		    CALLOUT_COUNTER_HIGH;

	cp->c_xid = id;

	CALLOUT_HASH_UPDATE(INSERT, ct, cp, id, runtime);

	mutex_exit(&ct->ct_lock);

	TRACE_4(TR_FAC_CALLOUT, TR_TIMEOUT,
		"timeout:%K(%p) in %ld ticks, cp %p",
		func, arg, delta, cp);

	return ((timeout_id_t)id);
}
コード例 #27
0
ファイル: cpnd_db.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
 * Name          : cpnd_ckpt_sec_add
 *
 * Description   : Function to add the section to a checkpoint.
 *
 * Arguments     : CPND_CKPT_NODE *cp_node - Check point node.
 *               : SaCkptSectionIdT id - Section Identifier
 *                 
 * Return Values :  NULL/CPND_CKPT_SECTION_INFO
 *
 * Notes         : None.
 *****************************************************************************/
CPND_CKPT_SECTION_INFO *cpnd_ckpt_sec_add(CPND_CKPT_NODE *cp_node, SaCkptSectionIdT *id,
					  SaTimeT exp_time, uint32_t gen_flag)
{
	CPND_CKPT_SECTION_INFO *pSecPtr = NULL;
	int32_t lcl_sec_id = 0;
	uint32_t rc = NCSCC_RC_SUCCESS;
	uint32_t value = 0, i = 0, j = 0;

	TRACE_ENTER();
	/* get the lcl_sec_id */

	lcl_sec_id = cpnd_ckpt_get_lck_sec_id(cp_node);
	if (lcl_sec_id == -1) {	/* -1 is invalid section Id need to define it in *.h file */
		TRACE_4("cpnd creating more than max sections");
		return NULL;
	}

	/* creat the cpnd_ckpt_section_info structure,memset */
	pSecPtr = m_MMGR_ALLOC_CPND_CKPT_SECTION_INFO;
	if (pSecPtr == NULL) {
		LOG_ER("cpnd ckpt section info memory allocation failed");
		return NULL;
	}

	memset(pSecPtr, '\0', sizeof(CPND_CKPT_SECTION_INFO));

	if (gen_flag) {

		if (cp_node->create_attrib.maxSectionIdSize > CPSV_GEN_SECTION_ID_SIZE)
			pSecPtr->sec_id.idLen = CPSV_GEN_SECTION_ID_SIZE;
		else
			pSecPtr->sec_id.idLen = cp_node->create_attrib.maxSectionIdSize;

		/* convert the lcl_sec_id to Network order */
		value = lcl_sec_id;
		pSecPtr->sec_id.id = m_MMGR_ALLOC_CPND_DEFAULT(pSecPtr->sec_id.idLen);
		if (pSecPtr->sec_id.id == NULL) {
			LOG_ER("cpnd sect memory allocation failed");
			return NULL;
		}
		memset(pSecPtr->sec_id.id, '\0', pSecPtr->sec_id.idLen);

		for (i = (CPSV_GEN_SECTION_ID_SIZE - pSecPtr->sec_id.idLen); i < CPSV_GEN_SECTION_ID_SIZE; i++) {
			pSecPtr->sec_id.id[j] = (value >> (24 - (8 * i))) & 0xff;
			j++;
		}
	} else {
コード例 #28
0
/****************************************************************************
 * PROCEDURE     : mbcsv_lib_destroy
 *
 * Description   : This is the function which destroys the MBCSV.  
 *
 * Arguments     : None.
 *
 * Return Values : SA_AIS_OK/Failure code.
 *
 * Notes         : None.
 *****************************************************************************/
uint32_t mbcsv_lib_destroy(void)
{
	MBCSV_REG *mbc_reg;
	SS_SVC_ID svc_id = 0;
	SaAisErrorT rc = SA_AIS_OK;
	TRACE_ENTER();

	if (mbcsv_cb.created == false) {
		TRACE_LEAVE2("Lib destroy request failed: Create MBCA before destroying");
		return SA_AIS_ERR_EXIST;
	}

	m_NCS_LOCK(&mbcsv_cb.global_lock, NCS_LOCK_WRITE);

	mbcsv_cb.created = false;
	/* 
	 * Walk through MBCSv reg list and destroy all the registration instances.
	 */
	while (NULL != (mbc_reg = (MBCSV_REG *)ncs_patricia_tree_getnext(&mbcsv_cb.reg_list, (const uint8_t *)&svc_id))) {
		svc_id = mbc_reg->svc_id;

		if (NCSCC_RC_SUCCESS != mbcsv_rmv_reg_inst((MBCSV_REG *)&mbcsv_cb.reg_list, mbc_reg)) {
			/* Not required to return for failure, log the err message and go 
			   ahead with cleanup */
			TRACE_4("Failed to remove this service instance:%u", mbc_reg->svc_id);
		}
	}

	ncs_patricia_tree_destroy(&mbcsv_cb.reg_list);

	/*
	 * Call function which will destroy and free all the entries of the peer list.
	 */
	mbcsv_destroy_peer_list();

	/*
	 * Call function which will destroy mail box list.
	 */
	mbcsv_destroy_mbx_list();

	m_NCS_UNLOCK(&mbcsv_cb.global_lock, NCS_LOCK_WRITE);
	m_NCS_LOCK_DESTROY(&mbcsv_cb.global_lock);

	TRACE_LEAVE();
	return rc;
}
コード例 #29
0
ファイル: mqa_init.c プロジェクト: helioloureiro/opensaf-fork
/****************************************************************************
  Name          : mqa_client_tree_find_and_add
 
  Description   : This routine adds the new client to the client tree and creates
                  the selection object for that client.
 
  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.
 
  Return Values : returns the MQA_CLIENT_INFO node.
 
  Notes         : The caller takes the cb lock before calling this function
                  
******************************************************************************/
MQA_CLIENT_INFO *mqa_client_tree_find_and_add(MQA_CB *mqa_cb, SaMsgHandleT hdl_id, bool flag)
{
	MQA_CLIENT_INFO *client_info = NULL;
	NCS_PATRICIA_PARAMS param;
	uint32_t rc = NCSCC_RC_SUCCESS;
	TRACE_ENTER();

	client_info = (MQA_CLIENT_INFO *)ncs_patricia_tree_get(&mqa_cb->mqa_client_tree, (uint8_t *)&hdl_id);

	if (flag == true) {
		/* create and allocate the memory */
		if (!client_info) {
			client_info = (MQA_CLIENT_INFO *)m_MMGR_ALLOC_MQA_CLIENT_INFO;
			if (!client_info) {
				TRACE_4("Client database creation failed");
				return NULL;
			}
			memset(client_info, 0, sizeof(MQA_CLIENT_INFO));
			/* Store the client_info pointer as msghandle. */
			client_info->msgHandle = NCS_PTR_TO_UNS64_CAST(client_info);
			client_info->patnode.key_info = (uint8_t *)&client_info->msgHandle;

			if ((rc =
			     ncs_patricia_tree_add(&mqa_cb->mqa_client_tree,
						   &client_info->patnode)) != NCSCC_RC_SUCCESS) {
				TRACE_2("Client database Registration Failed");
				m_MMGR_FREE_MQA_CLIENT_INFO(client_info);
				return NULL;
			}

			/* Create the group track tree */
			memset(&param, 0, sizeof(NCS_PATRICIA_PARAMS));
			param.key_size = SA_MAX_NAME_LENGTH;
			if (ncs_patricia_tree_init(&client_info->mqa_track_tree, &param) != NCSCC_RC_SUCCESS) {
				TRACE_2("Initialization of the client tree failed");
				m_MMGR_FREE_MQA_CLIENT_INFO(client_info);
				return NULL;
			}

		}
	}
	TRACE_LEAVE();
	return client_info;
}
コード例 #30
0
ファイル: eda_mds.c プロジェクト: indonexia2004/opensaf-indo
static uint32_t eda_dec_clm_status_cbk_msg(NCS_UBAID *uba, EDSV_MSG *msg)
{
	uint8_t *p8;
	int32_t total_bytes = 0;
	EDSV_EDA_CLM_STATUS_CBK_PARAM *param = &msg->info.cbk_info.param.clm_status_cbk;
	uint8_t local_data[256];

	if (uba == NULL) {
		TRACE_4("uba is NULL");
		return 0;
	}

	/* ClmNodeStatus */
	p8 = ncs_dec_flatten_space(uba, local_data, 2);
	param->node_status = ncs_decode_16bit(&p8);
	ncs_dec_skip_space(uba, 2);
	total_bytes += 2;
	return total_bytes;
}