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; }