void clCorMoIdToNodeNameTableFinalize(void)
{
clCorMoIdToNodeNameTablesCleanUp();
clCntDelete(nodeNameToMoIdTableHandle);
nodeNameToMoIdTableHandle=0;
clCntDelete(moIdToNodeNameTableHandle);
moIdToNodeNameTableHandle = 0;
}
/**
* Delete/free transaction-job definition
*/
ClRcT clTxnAppJobDelete(
CL_IN ClTxnAppJobDefnT *pTxnAppJob)
{
CL_FUNC_ENTER();
if (NULL == pTxnAppJob)
{
CL_FUNC_EXIT();
clDbgCodeError(CL_ERR_NULL_POINTER, ("Null pointer on the job list"));
return CL_ERR_NULL_POINTER;
}
CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Deleting txn-job %p", (ClPtrT) pTxnAppJob));
if(pTxnAppJob->compList)
{
//clCntAllNodesDelete(pTxnAppJob->compList);
clCntDelete(pTxnAppJob->compList);
}
if (pTxnAppJob->appJobDefn)
clHeapFree( (ClPtrT) pTxnAppJob->appJobDefn);
memset(pTxnAppJob, 0, sizeof(ClTxnAppJobDefnT)); /* to crash uses after delete */
clHeapFree(pTxnAppJob);
return (CL_OK);
}
/**
* Delete transaction definition
*/
ClRcT clTxnDefnDelete(
CL_IN ClTxnDefnT *pTxnDefn)
{
CL_FUNC_ENTER();
/* Clean-up all other memory allocated with this transaction */
if (NULL != pTxnDefn)
{
CL_DEBUG_PRINT(CL_DEBUG_TRACE,
("Removing transaction definition. txnId:0x%x:0x%x",
pTxnDefn->serverTxnId.txnMgrNodeAddress,
pTxnDefn->serverTxnId.txnId));
if(pTxnDefn->jobList)
{
//clCntAllNodesDelete(pTxnDefn->jobList); /* This can be removed by giving the destroy callback */
clCntDelete(pTxnDefn->jobList);
}
else
{
clDbgCodeError(0,("Where did the jobList go?"));
}
clHeapFree(pTxnDefn);
}
CL_FUNC_EXIT();
return (CL_OK);
}
static ClRcT fileEntryRecoverBaseVersion(ClLogMasterEoDataT *pMasterEoEntry,
ClBufferHandleT hFileEntryBuf)
{
ClRcT rc = CL_OK;
ClLogFileKeyT fileKey = {{0}};
ClLogFileKeyT *pFileKey = NULL;
ClLogFileDataT *pFileData = NULL;
rc = clLogMasterFileKeyUnpack(&fileKey, hFileEntryBuf);
if( CL_OK != rc )
{
return rc;
}
clLogInfo(CL_LOG_AREA_MASTER, CL_LOG_CTX_CKPT_READ,
"Recreating files fileName: %.*s fileLocation: %.*s",
fileKey.fileName.length, fileKey.fileName.pValue,
fileKey.fileLocation.length, fileKey.fileLocation.pValue);
rc = clLogFileKeyCreate(&fileKey.fileName, &fileKey.fileLocation,
pMasterEoEntry->maxFiles, &pFileKey);
if( CL_OK != rc )
{
clHeapFree(fileKey.fileName.pValue);
clHeapFree(fileKey.fileLocation.pValue);
return rc;
}
clHeapFree(fileKey.fileName.pValue);
clHeapFree(fileKey.fileLocation.pValue);
/* find out the filelocation is available */
pFileData = (ClLogFileDataT*) clHeapCalloc(1, sizeof(ClLogFileDataT));
if( NULL == pFileData )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
clLogFileKeyDestroy(pFileKey);
return rc;
}
pFileData->nActiveStreams = 0;
rc = clLogMasterFileDataRecreate(pFileData, hFileEntryBuf);
if( CL_OK != rc )
{
clLogFileKeyDestroy(pFileKey);
return rc;
}
rc = clCntNodeAdd(pMasterEoEntry->hMasterFileTable,
(ClCntKeyHandleT) pFileKey,
(ClCntDataHandleT) pFileData, NULL);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeAdd()"));
CL_LOG_CLEANUP(clCntDelete(pFileData->hStreamTable), CL_OK); //FIXME
clHeapFree(pFileData);
clLogFileKeyDestroy(pFileKey);
return rc;
}
return rc;
}
/**
* This is a finalization API for transaction agent. This API must be called
* during finalization of EO.
*/
ClRcT clTxnAgentFinalize()
{
ClRcT rc = CL_OK;
ClEoExecutionObjT *pEOObj;
CL_FUNC_ENTER();
/* - Release all allocated memeory
FIXME: Check for active transaction, and try to consolidate
*/
if (clTxnAgntCfg != NULL)
{
clTxnDbFini(clTxnAgntCfg->activeTxnMap);
clCntDelete(clTxnAgntCfg->compServiceMap);
clTxnMutexDelete(clTxnAgntCfg->actMtx);
clHeapFree(clTxnAgntCfg);
clTxnCommIfcFini();
rc = clEoMyEoObjectGet(&pEOObj);
clEoClientUninstallTables(pEOObj,
CL_EO_SERVER_SYM_MOD(gAspFuncTable, TXNAgent));
clTxnAgntCfg = NULL;
}
CL_TXN_RETURN_RC(rc, ("Failed to finalize transaction-agent rc:0x%x\n", rc));
}
ClRcT _clGmsDbDestroy(
CL_IN ClGmsDbT* const gmsDb)
{
ClRcT rc = CL_OK;
if (gmsDb == (const void*)NULL)
return CL_ERR_NULL_POINTER;
rc = clCntAllNodesDelete(gmsDb->htbl[CL_GMS_CURRENT_VIEW]);
if (rc != CL_OK)
{
return rc;
}
rc = clCntAllNodesDelete(gmsDb->htbl[CL_GMS_JOIN_LEFT_VIEW]);
if (rc != CL_OK)
{
return rc;
}
rc = clCntAllNodesDelete(gmsDb->htbl[CL_GMS_TRACK]);
if (rc != CL_OK)
{
return rc;
}
/* Delete the containers */
rc = clCntDelete((gmsDb->htbl[CL_GMS_CURRENT_VIEW]));
CL_ASSERT(rc == CL_OK);
rc = clCntDelete((gmsDb->htbl[CL_GMS_JOIN_LEFT_VIEW]));
CL_ASSERT(rc == CL_OK);
rc = clCntDelete((gmsDb->htbl[CL_GMS_TRACK]));
CL_ASSERT(rc == CL_OK);
/* Delete the mutex */
clGmsMutexDelete(gmsDb->viewMutex);
clGmsMutexDelete(gmsDb->trackMutex);
memset(gmsDb,0,sizeof(ClGmsDbT));
return rc;
}
/**
* Finalizes transaction database
*/
ClRcT clTxnDbFini(
CL_IN ClTxnDbHandleT txnDb)
{
CL_FUNC_ENTER();
/* TODO: Check for active transactions, if any */
clCntDelete(txnDb);
CL_FUNC_EXIT();
return CL_OK;
}
void clMsgQueueFree(ClMsgQueueInfoT *pQInfo)
{
ClRcT rc = CL_OK;
SaNameT qName = {strlen("--Unknow--"), "--Unknow--"};
ClUint32T i;
CL_OSAL_MUTEX_LOCK(&pQInfo->qLock);
(void)clMsgUnblockThreadsOfQueue(pQInfo);
if(pQInfo->unlinkFlag == CL_FALSE && pQInfo->pQueueEntry != NULL)
{
saNameCopy(&qName, &pQInfo->pQueueEntry->qName);
}
if(pQInfo->timerHandle != 0)
{
rc = clTimerDelete(&pQInfo->timerHandle);
if(rc != CL_OK)
clLogError("QUE", "FREE", "Failed to delete [%.*s]'s timer handle. error code [0x%x].",
qName.length, qName.value, rc);
}
clMsgQueueEmpty(pQInfo);
for(i = 0; i < CL_MSG_QUEUE_PRIORITIES ; i++)
{
rc = clCntDelete(pQInfo->pPriorityContainer[i]);
if(rc != CL_OK)
clLogError("QUE", "FREE", "Failed to delete the [%.*s]'s [%d] priority container. error code [0x%x].",
qName.length, qName.value, i, rc);
else
pQInfo->pPriorityContainer[i] = 0;
}
rc = clOsalCondDelete(pQInfo->qCondVar);
if(rc != CL_OK)
clLogError("QUE", "FREE", "Failed to delete the [%.*s]'s condtional variable. error code [0x%x].",
qName.length, qName.value, rc);
pQInfo->qCondVar = 0;
CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock);
rc = clOsalMutexDestroy(&pQInfo->qLock);
if(rc != CL_OK)
clLogError("QUE", "FREE", "Failed to delete the [%.*s]'s lock. error code [0x%x].",
qName.length, qName.value, rc);
clLogDebug("QUE", "FREE", "Freed the queue [%.*s].", qName.length, qName.value);
return;
}
/*
* This api would be called when alarm library is being finalize
*/
ClRcT clAlarmPayloadCntDeleteAll(void)
{
ClRcT rc = CL_OK;
clOsalMutexLock(gClAlarmPayloadCntMutex);
rc = clCntDelete(gPayloadCntHandle);
clOsalMutexUnlock(gClAlarmPayloadCntMutex);
clOsalMutexDelete(gClAlarmPayloadCntMutex);
if(CL_OK != rc)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("container deletion failed [%x]",rc));
return rc;
}
return rc;
}
ClRcT clEvtTestAppFinalize()
{
ClRcT rc = CL_OK;
ClEoExecutionObjT *pEoObj;
/*
* Delete the list maintaining the mapping b/n Init Name & evtHandle
*/
clCntDelete(gEvtTestInitInfo);
/*
* Delete the Mutes for the List in Init
*/
clOsalMutexDelete(gEvtTestInitMutex);
rc = clEoMyEoObjectGet(&pEoObj);
rc = clEoClientUninstall(pEoObj, CL_EO_NATIVE_COMPONENT_TABLE_ID);
return CL_OK;
}
ClRcT
clLogSvrEoDataFinalize(void)
{
ClRcT rc = CL_OK;
ClLogSvrEoDataT *pSvrEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrEoEntryGet(): rc[0x%x]", rc));
return rc;
}
rc = clOsalMutexLock_L(&pSvrEoEntry->svrStreamTableLock);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalMutexLock_L(): rc[0x %x]", rc));
return rc;
}
if( CL_HANDLE_INVALID_VALUE != pSvrEoEntry->hSvrStreamTable )
{
CL_LOG_CLEANUP(clCntDelete(pSvrEoEntry->hSvrStreamTable), CL_OK);
pSvrEoEntry->hSvrStreamTable = CL_HANDLE_INVALID_VALUE;
}
pSvrEoEntry->logInit = CL_FALSE;
CL_LOG_CLEANUP(clBitmapDestroy(pSvrEoEntry->hDsIdMap), CL_OK);
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock),
CL_OK);
CL_LOG_CLEANUP(clOsalMutexDestroy_L(&pSvrEoEntry->svrStreamTableLock),
CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT
clLogClntStreamOpen(ClLogHandleT hLog,
SaNameT *pStreamName,
SaNameT *pNodeName,
ClStringT *pShmName,
ClUint32T shmSize,
ClLogStreamHandleT *phStream,
ClUint32T recSize)
{
ClRcT rc = CL_OK;
ClLogClntEoDataT *pClntEoEntry = NULL;
ClBoolT addedTable = CL_FALSE;
ClBoolT addedEntry = CL_FALSE;
ClCntNodeHandleT hClntStreamNode = CL_HANDLE_INVALID_VALUE;
ClLogClntStreamDataT *pUserData = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == pStreamName), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pNodeName), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pShmName), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((sizeof(ClLogStreamHeaderT) > shmSize),
CL_LOG_RC(CL_ERR_INVALID_PARAMETER));
CL_LOG_PARAM_CHK((NULL == phStream), CL_LOG_RC(CL_ERR_NULL_POINTER));
rc = clLogClntEoEntryGet(&pClntEoEntry);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogClntEoEntryGet(): rc[0x %x]", rc));
return rc;
}
rc = clOsalMutexLock_L(&(pClntEoEntry->clntStreamTblLock));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalMutexLock(): rc[0x %x]", rc));
return rc;
}
if( CL_HANDLE_INVALID_VALUE == pClntEoEntry->hClntStreamTable )
{
rc = clCntHashtblCreate(pClntEoEntry->maxStreams,
clLogStreamKeyCompare,
clLogStreamHashFn,
clLogClntStreamDeleteCb,
clLogClntStreamDeleteCb,
CL_CNT_UNIQUE_KEY,
&(pClntEoEntry->hClntStreamTable));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntHashtblCreate(): rc[0x %x]", rc));
CL_LOG_CLEANUP(
clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),CL_OK);
return rc;
}
addedTable = CL_TRUE;
CL_LOG_DEBUG_VERBOSE(("Created the HashTable"));
}
rc = clLogClntStreamEntryGet(pClntEoEntry, pStreamName, pNodeName,
pShmName, shmSize, &hClntStreamNode,
&addedEntry);
if( CL_OK != rc)
{
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Got the stream entry"));
rc = clLogHandleStreamHandleCreate(hLog, hClntStreamNode, phStream);
if( CL_OK != rc)
{
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Created the streamhandle"));
rc = clCntNodeUserDataGet(pClntEoEntry->hClntStreamTable, hClntStreamNode,
(ClCntDataHandleT *) &pUserData);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB,
*phStream), CL_OK);
*phStream = CL_HANDLE_INVALID_VALUE;
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
#ifdef NO_SAF
pUserData->recSize=recSize;
#endif
CL_LOG_DEBUG_VERBOSE(("Got stream entry"));
rc = clBitmapBitSet(pUserData->hStreamBitmap, CL_HDL_IDX(*phStream));
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phStream),
CL_OK);
*phStream = CL_HANDLE_INVALID_VALUE;
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Updated stream bitmap"));
rc = clLogHandleInitHandleStreamAdd(hLog, *phStream);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clBitmapBitClear(pUserData->hStreamBitmap, CL_HDL_IDX(*phStream)),
CL_OK);
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phStream),
CL_OK);
*phStream = CL_HANDLE_INVALID_VALUE;
if( CL_TRUE == addedEntry )
{
CL_LOG_CLEANUP(clCntNodeDelete(pClntEoEntry->hClntStreamTable,
hClntStreamNode), CL_OK);
}
if( CL_TRUE == addedTable )
{
CL_LOG_CLEANUP(clCntDelete(pClntEoEntry->hClntStreamTable), CL_OK);
}
CL_LOG_CLEANUP(clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock)),
CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("Updated init handle"));
rc = clOsalMutexUnlock_L(&(pClntEoEntry->clntStreamTblLock));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalMutexUnlock(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
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;
}
ClRcT clRmdObjClose(ClRmdObjHandleT p)
{
#if 0 // Don't know why safplus_amf process hang at clOsalMutexLock(pRmdObject->semaForRecvHashTable)
ClRcT retCode = CL_OK;
ClRmdObjT *pRmdObject = NULL;
CL_FUNC_ENTER();
pRmdObject = (ClRmdObjT *) p;
if (NULL == pRmdObject)
{
RMD_DBG1((" RMD Invalid rmd handle in objclose\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
/*
* Avoid deleting the mutexes so its still valid in case any context is abusing the terminate
* and initiating or not quitting the rmd sends.
*/
retCode = clOsalMutexDelete(pRmdObject->semaForRecvHashTable);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD Recv mutex delete failed\n"));
}
retCode = clOsalMutexDelete(pRmdObject->semaForSendHashTable);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD Send mutex delete failed\n"));
}
clOsalMutexLock(pRmdObject->semaForRecvHashTable);
retCode = clCntDelete(pRmdObject->rcvRecContainerHandle);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD rcv hash table destroy failed\n"));
}
pRmdObject->rcvRecContainerHandle = 0;
clOsalMutexUnlock(pRmdObject->semaForRecvHashTable);
clOsalMutexLock(pRmdObject->semaForSendHashTable);
retCode = clCntDelete(pRmdObject->sndRecContainerHandle);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD snd hash table destroy failed\n"));
}
pRmdObject->sndRecContainerHandle = 0;
clOsalMutexUnlock(pRmdObject->semaForSendHashTable);
retCode = clHandleDatabaseDestroy(pRmdObject->responseCntxtDbHdl);
if (CL_OK != retCode)
{
RMD_DBG1((" RMD snd hash table destroy failed\n"));
}
pRmdObject->responseCntxtDbHdl = 0;
/*
* Don't release the rmd context to respect abusers or initiators of rmd send outside
* terminate callback contexts.
*/
clHeapFree(pRmdObject);
#endif
CL_FUNC_EXIT();
return (CL_OK);
}
ClRcT clRmdObjInit(ClRmdObjHandleT *p)
{
ClRcT retCode = CL_OK;
ClRmdObjT *pRmdObject = NULL;
//unsigned long timeStamp = 0;
struct timeval tm1;
#ifdef DEBUG
static ClUint8T rmdAddedTodbgComp = CL_FALSE;
if (CL_FALSE == rmdAddedTodbgComp)
{
retCode = dbgAddComponent(COMP_PREFIX, COMP_NAME, COMP_DEBUG_VAR_PTR);
rmdAddedTodbgComp = CL_TRUE;
if (CL_OK != retCode)
{
clLogError("OBG","INI","dbgAddComponent FAILED ");
CL_FUNC_EXIT();
return retCode;
}
}
#endif
CL_FUNC_ENTER();
if (NULL == p)
{
RMD_DBG1((" RMD Invalid Object handle passed\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_INVALID_PARAMETER)));
}
retCode = clOsalInitialize(NULL);
retCode = clTimerInitialize(NULL);
pRmdObject = (ClRmdObjT *) clHeapAllocate(sizeof(ClRmdObjT));
if (NULL == pRmdObject)
{
RMD_DBG1((" RMD No Memory\n"));
CL_FUNC_EXIT();
return ((CL_RMD_RC(CL_ERR_NO_MEMORY)));
}
gettimeofday(&tm1, NULL);
//timeStamp = tm1.tv_sec * 1000000 + tm1.tv_usec;
pRmdObject->msgId = 1;
retCode = clOsalMutexCreate(&pRmdObject->semaForSendHashTable);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD send Mutex creation failed\n"));
CL_FUNC_EXIT();
return (retCode);
}
retCode = clOsalMutexCreate(&pRmdObject->semaForRecvHashTable);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD recv Mutex creation failed\n"));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return (retCode);
}
retCode =
clCntHashtblCreate(NUMBER_OF_RECV_BUCKETS, recvKeyCompare,
recvHashFunction, recvHashDeleteCallBack,
recvHashDeleteCallBack, CL_CNT_UNIQUE_KEY,
&pRmdObject->rcvRecContainerHandle);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD send Hash table creation failed\n"));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForRecvHashTable));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return (retCode);
}
retCode =
clCntHashtblCreate(NUMBER_OF_SEND_BUCKETS, sendKeyCompare,
sendHashFunction, sendHashDeleteCallBack,
sendHashDestroyCallBack, CL_CNT_UNIQUE_KEY,
&pRmdObject->sndRecContainerHandle);
if (CL_OK != CL_GET_ERROR_CODE(retCode))
{
RMD_DBG1((" RMD recv Hash table creation failed\n"));
IGNORE_RETURN(clCntDelete(pRmdObject->rcvRecContainerHandle));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForRecvHashTable));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return (retCode);
}
pRmdObject->responseCntxtDbHdl = 0;
retCode = clHandleDatabaseCreate(NULL, &pRmdObject->responseCntxtDbHdl);
if (retCode != CL_OK)
{
RMD_DBG1((" RMD Sync Handle Database create failed\n"));
IGNORE_RETURN(clCntDelete(pRmdObject->sndRecContainerHandle));
IGNORE_RETURN(clCntDelete(pRmdObject->rcvRecContainerHandle));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForRecvHashTable));
IGNORE_RETURN(clOsalMutexDelete(pRmdObject->semaForSendHashTable));
CL_FUNC_EXIT();
return retCode;
}
pRmdObject->numAtmostOnceEntry = 0;
pRmdObject->lastAtmostOnceCleanupTime = clOsalStopWatchTimeGet();
pRmdObject->rmdStats.nRmdCalls = 0;
pRmdObject->rmdStats.nFailedCalls = 0;
pRmdObject->rmdStats.nResendRequests = 0;
pRmdObject->rmdStats.nRmdReplies = 0;
pRmdObject->rmdStats.nBadReplies = 0;
pRmdObject->rmdStats.nRmdRequests = 0;
pRmdObject->rmdStats.nBadRequests = 0;
pRmdObject->rmdStats.nCallTimeouts = 0;
pRmdObject->rmdStats.nDupRequests = 0;
pRmdObject->rmdStats.nAtmostOnceCalls = 0;
pRmdObject->rmdStats.nResendReplies = 0;
pRmdObject->rmdStats.nReplySend = 0;
pRmdObject->rmdStats.nRmdCallOptimized = 0;
*p = (ClRmdObjHandleT) pRmdObject;
CL_FUNC_EXIT();
return (CL_OK);
}
/*
* This function will do following steps
* 1. Create DB for ECH/G
* 2. Create DB for ECH/L
* 3. Create mutex to protect ECH/G DB
* 4. Create mutex to protect ECH/L DB
* 5. Register with CPM for component failure notification.
* 6. Intialize the global variable to indicate EM is done.
*/
ClRcT clEvtInitialize(ClInt32T argc, ClCharT *argv[])
{
ClRcT rc = CL_OK;
rc = initializeAmf();
if (rc != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_CRITICAL,
("Event: Amf Initialization failed [0x%X]\n\r", rc));
CL_FUNC_EXIT();
return rc;
}
CL_FUNC_ENTER();
rc = clEvtChannelDBInit();
rc = clEoMyEoObjectGet(&gEvtHead.evtEOId);
rc = clEoClientInstallTables(gEvtHead.evtEOId, CL_EO_SERVER_SYM_MOD(gAspFuncTable, EVT));
if (rc != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_CRITICAL,
("Event: Installing Native table failed [0x%X]\n\r",
rc));
clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_CRITICAL, NULL,
CL_LOG_MESSAGE_1_FUNC_TABLE_INSTALL_FAILED, rc);
clCntDelete(gEvtMasterECHHandle);
clEvtChannelDBClean();
CL_FUNC_EXIT();
return rc;
}
rc = clEventLibTableInit();
if(rc != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_CRITICAL,
("Event: Installing Native Server to Server table failed [0x%X]\n\r",
rc));
clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_CRITICAL, NULL,
CL_LOG_MESSAGE_1_FUNC_TABLE_INSTALL_FAILED, rc);
clCntDelete(gEvtMasterECHHandle);
clEvtChannelDBClean();
CL_FUNC_EXIT();
return rc;
}
rc = clEventDebugRegister(gEvtHead.evtEOId);
if (rc != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_CRITICAL,
("Event: Debug Register failed [0x%X]\n\r", rc));
clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_CRITICAL, NULL,
CL_LOG_MESSAGE_1_DBG_REGISTER_FAILED, rc);
CL_FUNC_EXIT();
return rc;
}
/*
** Initialize the Handle Database.
*/
rc = clEvtHandleDatabaseInit();
if (rc != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_CRITICAL,
("Event: Handle Database Init failed [0x%X]\n\r", rc));
CL_FUNC_EXIT();
return rc;
}
#ifdef CKPT_ENABLED
/*
** Initialize the Check Pointing Library.
*/
rc = clEvtCkptInit();
if (rc != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_CRITICAL,
("Event: CKPT Init failed [0x%X]\n\r", rc));
clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_CRITICAL, NULL,
CL_LOG_MESSAGE_2_LIBRARY_INIT_FAILED, "Checkpoint Library",
rc);
CL_FUNC_EXIT();
return rc;
}
#endif
gEvtInitDone = CL_EVT_TRUE;
/*
* CPM should be notified that Event Service is ready only after the
* the initialization is complete. This _MUST_ be the last step.
*/
CL_FUNC_EXIT();
return CL_OK;
}
