void clEvtContTestDbInit()
{
ClRcT rc = CL_OK;
ClUint32T noOfApp;
rc = clCntLlistCreate(clEvtContSubKeyCompare, clEvtContSubDataDelete,
clEvtContSubDataDelete, CL_CNT_NON_UNIQUE_KEY,
&gEvtContSubInfo);
if (CL_OK != rc)
{
clOsalPrintf("Creating linked list failed for sub \r\n");
exit(-1);
}
rc = clCntLlistCreate(clEvtContPubKeyCompare, clEvtContPubDataDelete,
clEvtContPubDataDelete, CL_CNT_UNIQUE_KEY,
&gEvtContPubInfo);
if (CL_OK != rc)
{
clOsalPrintf("Creating linked list failed for pub \r\n");
exit(-1);
}
clEvtContGetApp(&noOfApp);
clHeapAllocate(noOfApp * sizeof(ClEvtContSubInfoStorageT));
return;
}
ClRcT clEvtTestAppInitialize(ClUint32T argc, ClCharT *argv[])
{
ClRcT rc = CL_OK;
ClEoExecutionObjT *pEoObj;
#if 0
ClSvcHandleT svcHandle = { 0 };
ClOsalTaskIdT taskId = 0;
#endif
/*
* Create the list to hold the mapping b/n Init Name & evtHandle
*/
rc = clCntLlistCreate(clEvtContInitKeyCompare, clEvtContInitDataDelete,
clEvtContInitDataDelete, CL_CNT_UNIQUE_KEY,
&gEvtTestInitInfo);
if (CL_OK != rc)
{
clOsalPrintf("Creating linked list for Init Failed, rc[0x%X]\r\n", rc);
return rc;
}
rc = clCntLlistCreate(clChanContainerKeyCompare, clChanContainerDataDelete,
clChanContainerDataDelete, CL_CNT_UNIQUE_KEY,
&gChanHandleInitInfo);
if(rc!=CL_OK)
{
clOsalPrintf("Creating Linked List for Channel handles failed\n\r");
return rc;
}
/*
* Create a Mutex to lock the containers before accessing them
*/
rc = clOsalMutexCreate(&gEvtTestInitMutex);
if (CL_OK != rc)
{
clOsalPrintf("Creating Mutex for Init Failed, rc[0x%X]\r\n", rc);
return rc;
}
rc = clEoMyEoObjectGet(&pEoObj);
rc = clEoClientInstall(pEoObj, CL_EO_NATIVE_COMPONENT_TABLE_ID,
gClEvtTestAppFuncList, (ClEoDataT) NULL,
(int) sizeof(gClEvtTestAppFuncList) /
(int) sizeof(ClEoPayloadWithReplyCallbackT));
rc = clEvtCpmInit();
#if 0
svcHandle.cpmHandle = &gEvtTestAppCpmHandle;
rc = clDispatchThreadCreate(pEoObj, &taskId, svcHandle);
#endif
return CL_OK;
}
ClRcT clTxnAgentListCreate(ClCntHandleT *pAgentCntHandle)
{
ClRcT rc = CL_OK;
CL_FUNC_ENTER();
rc = clCntLlistCreate(_clTxnAgentCmpFn, _clTxnAgentDelFn,
_clTxnAgentDestroy,
CL_CNT_UNIQUE_KEY,
pAgentCntHandle);
CL_FUNC_EXIT();
return (CL_GET_ERROR_CODE(rc));
}
/*
* The container creation api
*/
ClRcT clAlarmPayloadCntListCreate()
{
ClRcT rc = CL_OK;
clOsalMutexCreate (&gClAlarmPayloadCntMutex);
rc = clCntLlistCreate(clAlarmPayloadCntCompare,
clAlarmPayloadCntEntryDeleteCallback,
clAlarmPayloadCntEntryDestroyCallback,
CL_CNT_UNIQUE_KEY,
&gPayloadCntHandle );
return rc;
}
/**
* Create newly transaction-job definition
*/
ClRcT clTxnNewAppJobCreate(
CL_OUT ClTxnAppJobDefnPtrT *pNewTxnJob)
{
ClRcT rc = CL_OK;
ClTxnAppJobDefnT *pTxnJob;
CL_FUNC_ENTER();
if (NULL == pNewTxnJob)
{
CL_FUNC_EXIT();
return CL_ERR_NULL_POINTER;
}
*pNewTxnJob = NULL;
pTxnJob = (ClTxnAppJobDefnT *)clHeapAllocate( sizeof(ClTxnAppJobDefnT));
if (NULL == pTxnJob)
{
CL_FUNC_EXIT();
return CL_ERR_NO_MEMORY;
}
memset(pTxnJob, 0, sizeof(ClTxnAppJobDefnT));
rc = clCntLlistCreate(_clTxnCmpKeyCompare,
_clTxnCompEntryDelete, _clTxnCompEntryDestroy,
CL_CNT_UNIQUE_KEY,
(ClCntHandleT *) &(pTxnJob->compList) );
if (CL_OK != rc)
{
clHeapFree(pTxnJob);
}
else
{
CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Creating new txn-job %p, compList:%p",
(ClPtrT) pTxnJob, (ClPtrT) pTxnJob->compList));
*pNewTxnJob = pTxnJob;
}
CL_FUNC_EXIT();
return (CL_GET_ERROR_CODE(rc));
}
/**
* Creates new transaction definition instance
*/
ClRcT clTxnNewTxnDfnCreate(
CL_OUT ClTxnDefnPtrT *pNewTxnDef)
{
ClRcT rc = CL_OK;
CL_FUNC_ENTER();
if (NULL == pNewTxnDef)
{
CL_FUNC_EXIT();
return (CL_ERR_NULL_POINTER);
}
*pNewTxnDef = (ClTxnDefnT *) clHeapCalloc(1,sizeof(ClTxnDefnT));
if (NULL == *pNewTxnDef)
{
CL_FUNC_EXIT();
return (CL_ERR_NO_MEMORY);
}
memset(*pNewTxnDef, 0, sizeof(ClTxnDefnT));
/* Initialize data-structure for storing job and component details */
rc = clCntLlistCreate(_clTxnJobKeyCompare,
_clTxnJobDelete, _clTxnJobDestroy,
CL_CNT_UNIQUE_KEY,
(ClCntHandleT *) &( (*pNewTxnDef)->jobList));
if (CL_OK != rc)
{
clHeapFree(*pNewTxnDef);
*pNewTxnDef = NULL;
}
CL_FUNC_EXIT();
return (rc);
}
ClRcT halObjCreate(ClUint32T omId,
ClCorMOIdPtrT moId,
ClHalObjectHandleT *const phalObjHandle)
{
HalObjectT * phalObject = NULL;
ClRcT ret=CL_OK;
#ifdef CL_DEBUG
char aFunction[]="halObjCreate";
#endif
CL_FUNC_ENTER();
if (NULL == phalObjHandle)
{
CL_DEBUG_PRINT(CL_DEBUG_TRACE,("\n %s Error NULL Pointer \n ",aFunction));
CL_FUNC_EXIT();
return (CL_HAL_SET_RC(CL_ERR_NULL_POINTER));
}
phalObject =(HalObjectT*) clHeapAllocate((ClUint32T)sizeof(HalObjectT));
if (NULL == phalObject)
{
CL_DEBUG_PRINT(CL_DEBUG_TRACE,("\n %s Error Malloc Failed\n ",aFunction));
CL_FUNC_EXIT();
return (CL_HAL_SET_RC( CL_ERR_NO_MEMORY)) ;
}
memset(phalObject,0,sizeof(HalObjectT));
phalObject->omId=omId;
if(NULL != moId)
{
phalObject->moId = (ClCorMOIdPtrT) clHeapAllocate ((ClUint32T)sizeof(ClCorMOIdT));
if (NULL == phalObject->moId)
{
clHeapFree (phalObject);
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("\n %s Error Malloc Failed\n ",aFunction));
CL_FUNC_EXIT();
return (CL_HAL_SET_RC( CL_ERR_NO_MEMORY)) ;
}
memset (phalObject->moId,0,sizeof(ClCorMOIdT));
memcpy (phalObject->moId, moId, sizeof(ClCorMOIdT));
}
else
{
/* Error Condition */
/* This needs to be uncommented after fixing the call to clOmObjectCreate &
clOmCorAndOmObjectsCreate by passing hMOId ,sizeof(ClCorMOIdT) as the last 2parameters.
As of now NULL is being passed */
CL_DEBUG_PRINT(CL_DEBUG_ERROR,("\n %s Error Invalid Parameter \n ",aFunction));
CL_FUNC_EXIT();
return (CL_HAL_SET_RC(CL_ERR_INVALID_PARAMETER));
}
ret = clCntLlistCreate(halKeyCompare,NULL,halObjContainerDestroy,CL_CNT_UNIQUE_KEY,
&(phalObject->hTableRefDevObject));
if (CL_OK !=ret)
{
clHeapFree (phalObject);
phalObject =NULL;
CL_DEBUG_PRINT(CL_DEBUG_TRACE,("\n %s Error returned by \
clCntLlistCreate \n ", aFunction));
CL_FUNC_EXIT();
return ret;
}
ClRcT
_ckptMasterPeerListInfoCreate(ClIocNodeAddressT nodeAddr,
ClUint32T credential,
ClUint32T replicaCount)
{
CkptPeerInfoT *pPeerInfo = NULL;
ClRcT rc = CL_OK;
/*
* Allocate memory for storing peer info.
*/
if (NULL == (pPeerInfo = (CkptPeerInfoT*) clHeapCalloc(1,
sizeof(CkptPeerInfoT))))
{
rc = CL_CKPT_ERR_NO_MEMORY;
CKPT_DEBUG_E(("PeerInfo No Memory\n"));
return rc;
}
/*
* Copy the passed info.
*/
pPeerInfo->addr = nodeAddr;
pPeerInfo->credential = credential;
pPeerInfo->available = CL_CKPT_NODE_AVAIL;
pPeerInfo->replicaCount = replicaCount;
/*
* Create the list to store the client hdls that
* will be opened on that node.
*/
rc = clCntLlistCreate(ckptCkptListKeyComp, ckptCkptListDeleteCallback,ckptCkptListDeleteCallback, CL_CNT_UNIQUE_KEY, &pPeerInfo->ckptList);
CKPT_ERR_CHECK(CL_CKPT_SVR,CL_LOG_SEV_ERROR, ("CkptList create failed rc[0x %x]\n",rc), rc);
/*
* Create the list to store the master hdls for checkpoints that
* will be created on that node.
*/
rc = clCntLlistCreate(ckptMastHdlListtKeyComp, ckptMastHdlListDeleteCallback, ckptMastHdlListDeleteCallback, CL_CNT_UNIQUE_KEY, &pPeerInfo->mastHdlList);
CKPT_ERR_CHECK(CL_CKPT_SVR,CL_LOG_SEV_ERROR, ("MastHdlList create failed rc[0x %x]\n",rc), rc);
if(credential == CL_CKPT_CREDENTIAL_POSITIVE)
gCkptSvr->masterInfo.availPeerCount++;
/*
* Add the node to the master's peer list.
*/
rc = clCntNodeAdd(gCkptSvr->masterInfo.peerList, (ClPtrT)(ClWordT)nodeAddr, (ClCntDataHandleT)pPeerInfo, NULL);
CKPT_ERR_CHECK(CL_CKPT_SVR,CL_LOG_SEV_ERROR, ("PeerInfo Add is failed rc[0x %x]\n",rc), rc);
return rc;
exitOnError:
/*
* Do the necessary cleanup.
*/
if (pPeerInfo->ckptList != 0)
clCntDelete(pPeerInfo->ckptList);
if (pPeerInfo->mastHdlList != 0)
clCntDelete(pPeerInfo->mastHdlList);
clHeapFree(pPeerInfo);
return rc;
}
