ClRcT clCorMoIdNodeNameMapCreate(void) { ClRcT rc; /* Create NODE NAME - MOID hash table */ rc = clCntHashtblCreate(NODE_NAME_TO_MOID_NUM_BUCKETS, clCorNodeNameTableNodeNameKeyCompare, clCorNodeNameTableNodeNameHashFn, clCorNodeNameTableNodeNameDeleteCallBack, clCorNodeNameTableNodeNameDestroyCallBack, CL_CNT_NON_UNIQUE_KEY, &nodeNameToMoIdTableHandle); if(CL_OK != rc) CL_COR_RETURN_ERROR(CL_DEBUG_ERROR, "Could not create Hash Table", rc); clCntHashtblCreate(MOID_TO_NODE_NAME_NUM_BUCKETS, clCorNodeNameTableMoIdKeyCompare, clCorNodeNameTableMoIdHashFn, clCorNodeNameTableMoIdDeleteCallBack, clCorNodeNameTableMoIdDestroyCallBack, CL_CNT_UNIQUE_KEY, &moIdToNodeNameTableHandle); if(CL_OK != rc) CL_COR_RETURN_ERROR(CL_DEBUG_ERROR, "Could not create Hash Table", rc); return CL_OK; }
static ClRcT clLogMasterFileDataRecreate(ClLogFileDataT *pFileData, ClBufferHandleT hFileEntryBuf) { ClRcT rc = CL_OK; ClUint32T cntSize = 0; ClLogSvrCommonEoDataT *pCommonEoEntry = NULL; ClUint32T count = 0; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogMasterEoEntryGet(NULL, &pCommonEoEntry); if( CL_OK != rc ) { return rc; } rc = VDECL_VER(clXdrUnmarshallClLogStreamAttrIDLT, 4, 0, 0)(hFileEntryBuf, &(pFileData->streamAttr)); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(( "clXdrUnmarshallClLogStreamAttributesT(): rc[0x %x]", rc)); return rc; } rc = clXdrUnmarshallClUint32T(hFileEntryBuf, &cntSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc)); return rc; } rc = clCntHashtblCreate(pCommonEoEntry->maxStreams, clLogStreamKeyCompare, clLogStreamHashFn, clLogMasterStreamEntryDeleteCb, clLogMasterStreamEntryDeleteCb, CL_CNT_UNIQUE_KEY, &(pFileData->hStreamTable)); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCntHashtbleCreate(): rc[0x %x]\n", rc)); return rc; } for(count = 0; count < cntSize; count++) { rc = clLogMasterStreamTableRecreate(pCommonEoEntry, hFileEntryBuf, pFileData); if( CL_OK != rc ) { /* Just keep on create as much as u can */ } } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT _clGmsNameIdDbCreate (ClCntHandleT *dbPtr) { ClRcT rc = CL_OK; if (dbPtr == NULL) { return CL_ERR_NULL_POINTER; } /* Create the container */ rc = clCntHashtblCreate( viewDbParams.htbleParams.gmsNumOfBuckets, viewDbParams.htbleParams.gmsHashKeyCompareCallback, viewDbParams.htbleParams.gmsHashCallback, viewDbParams.htbleParams.gmsHashDeleteCallback, viewDbParams.htbleParams.gmsHashDestroyCallback, CL_CNT_UNIQUE_KEY, dbPtr); 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; }
/** * Initializes the OM class table. * * This API initializes the OM class lookup table from the pre-configured<br> * tables: common and application. It also initializes other tables <br> * and prepares the OM library for usage by other components. * * @param pOmCfgData Configuration data for OM * * @returns * CL_OK - everything is ok<br> * ==>FIXME:Define(==>FIXME:Define(CL_ERR_INVLD_STATE)<==)<== - wrong initialization state<br> * Runlevel error code - please reference the Runlevel error codes * */ ClRcT clOmLibInitialize() { ClRcT rc = CL_OK; ClUint32T classIdx = 0; ClUint32T omCfgDataSz = sizeof(ClOmConfigDataT); ClOmClassControlBlockT *pOmClassEntry = NULL; /* ClUint32T cmnOmClassCnt = 0; */ /*ClUint32T omClassCnt = 0; ClUint32T skippedClassCnt = 0;*/ extern ClRcT showMgrModAdd(char *, char *, void (*fp)(char**)); extern void omShow (char ** ); CL_FUNC_ENTER(); /* * Check if the OI has its own DB and reload its db */ if(gClOIConfig.oiDBReload) return CL_OK; /* Get a count of the common classes */ /* Initialize config data struct and make a copy of the configuration data. */ memset(&gOmCfgData, 0, omCfgDataSz); /* Fill up the gOmCfgData */ gOmCfgData.maxOmClassBuckets = OM_CLASS_TABLE_MAX_BUCKETS; gOmCfgData.minAppOmClassType = OM_APP_MIN_CLASS_TYPE; gOmCfgData.maxAppOmClassType = OM_APP_MAX_CLASS_TYPE; gOmCfgData.numOfOmClasses = 0; /* Create a hash table for storing OM classes */ rc = clCntHashtblCreate(gOmCfgData.maxOmClassBuckets, omClassKeyCompare, omClassHashFn, omClassEntryDelCallBack, omClassEntryDestroyCallBack, CL_CNT_NON_UNIQUE_KEY, &ghOmClassHashTbl); if ((rc != CL_OK) || (ghOmClassHashTbl == 0)) { CL_DEBUG_PRINT(CL_DEBUG_ERROR,("%s: Failed to create a hash table " "for OM classes (rc = 0x%x)!!!\n\r", __FUNCTION__, rc)); return (rc); } /* Consolidate OM class tables into a hash table */ /* Configure the common OM class table */ /* Initialize the base class here */ if ((rc = clOmClassInitialize (&gBaseClassTable, gBaseClassTable.eMyClassType, gBaseClassTable.maxObjInst, gBaseClassTable.maxSlots)) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to initialize OM with rc = " "0x%x!\r\n", __FUNCTION__, rc)); return (rc); } /* Accumulate the number of classes registered w/ OM */ /*omClassCnt = classIdx;*/ pOmClassEntry = NULL; /* Configure the application OM class table */ classIdx = 0; if (appOmClassCnt > 0) { for (; classIdx < appOmClassCnt; classIdx++) { pOmClassEntry = &(pAppOmClassTbl[classIdx]); if (pOmClassEntry->eMyClassType == CL_OM_INVALID_CLASS) { /* skip invalid class */ /* This way invalid classes and missing, i.e. a table size if bigger than the number of classes are allowed in the table. */ /*skippedClassCnt++;*/ continue; } if ((rc = clOmClassInitialize (pOmClassEntry, pOmClassEntry->eMyClassType, pOmClassEntry->maxObjInst, pOmClassEntry->maxSlots)) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to initialize OM with rc = " "0x%x!\r\n", __FUNCTION__, rc)); return (rc); } } } else { CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("%s: Not initializing OM Application class " "table because it does not exist...ignoring.\r\n", __FUNCTION__)); } /* Get the total number of classes registered w/ OM */ /*gOmCfgData.numOfOmClasses = omClassCnt + classIdx - skippedClassCnt;*/ /* Initialize the COR/OM handle translation table */ if (rc == CL_OK) { if((rc = omCORTableInit()) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to setup the COR translation " "table with rc = 0x%x\r\n", rc)); } } #ifdef DEBUG /* Add OM into the debug agent */ if (!omClassInitState) dbgAddComponent(COMP_PREFIX, COMP_NAME, COMP_DEBUG_VAR_PTR); #endif omClassInitState = CL_TRUE; /* add the om to show manager */ /*@todo: Navdeep (show manager dependency) showMgrModAdd(COMP_PREFIX, COMP_NAME, omShow); */ CL_FUNC_EXIT(); return (rc); }
ClRcT clOmLibInitializeExtended(void) { ClRcT rc = CL_OK; ClUint32T classIdx = 0; ClUint32T omCfgDataSz = sizeof(ClOmConfigDataT); ClOmClassControlBlockT *pOmClassEntry = NULL; ClCharT oiClassFile[CL_MAX_NAME_LENGTH] = {0}; ClCharT oiRouteFile[CL_MAX_NAME_LENGTH] = {0}; ClCharT *pOIClassFile = oiClassFile; ClCharT *pOIRouteFile = oiRouteFile; extern ClRcT showMgrModAdd(char *, char *, void (*fp)(char**)); extern void omShow (char ** ); CL_FUNC_ENTER(); /* *First load the OI class configuration. into COR */ if(!gClOIConfig.pOIClassFile) { clLogError("OI", "CONFIG", "No OI class file is specified to configure the OI classes"); return CL_OM_SET_RC(CL_ERR_INVALID_PARAMETER); } if(!gClOIConfig.pOIRouteFile) { clLogError("OI", "CONFIG", "No OI route file is specified to configure the OI objects"); return CL_OM_SET_RC(CL_ERR_INVALID_PARAMETER); } if(gClOIConfig.pOIClassPath) snprintf(oiClassFile, sizeof(oiClassFile), "%s/%s", gClOIConfig.pOIClassPath, gClOIConfig.pOIClassFile); else pOIClassFile = (ClCharT*)gClOIConfig.pOIClassFile; if(gClOIConfig.pOIRoutePath) snprintf(oiRouteFile, sizeof(oiRouteFile), "%s/%s", gClOIConfig.pOIRoutePath, gClOIConfig.pOIRouteFile); else pOIRouteFile = (ClCharT*)gClOIConfig.pOIRouteFile; rc = clCorConfigLoad(pOIClassFile, pOIRouteFile); if(rc != CL_OK) { clLogError("OI", "CONFIG", "Loading OI class configuration [%s] to COR returned with error [%#x]", pOIClassFile, rc); return rc; } /* Initialize config data struct and make a copy of the configuration data. */ memset(&gOmCfgData, 0, omCfgDataSz); /* Fill up the gOmCfgData */ gOmCfgData.maxOmClassBuckets = OM_CLASS_TABLE_MAX_BUCKETS; gOmCfgData.minAppOmClassType = OM_APP_MIN_CLASS_TYPE; gOmCfgData.maxAppOmClassType = OM_APP_MAX_CLASS_TYPE; gOmCfgData.numOfOmClasses = 0; /* Create a hash table for storing OM classes */ rc = clCntHashtblCreate(gOmCfgData.maxOmClassBuckets, omClassKeyCompare, omClassHashFn, omClassEntryDelCallBack, omClassEntryDestroyCallBack, CL_CNT_NON_UNIQUE_KEY, &ghOmClassHashTbl); rc |= clCntHashtblCreate(gOmCfgData.maxOmClassBuckets, omClassNameKeyCompare, omClassNameHashFn, omClassEntryDelCallBack, omClassEntryDestroyCallBack, CL_CNT_NON_UNIQUE_KEY, &ghOmClassNameHashTbl); if ((rc != CL_OK) || (ghOmClassHashTbl == 0) || (ghOmClassNameHashTbl == 0)) { CL_DEBUG_PRINT(CL_DEBUG_ERROR,("%s: Failed to create a hash table " "for OM classes (rc = 0x%x)!!!\n\r", __FUNCTION__, rc)); return (rc); } /* Consolidate OM class tables into a hash table */ /* Configure the common OM class table */ /* Initialize the base class here */ if ((rc = clOmClassInitialize (&gBaseClassTable, gBaseClassTable.eMyClassType, gBaseClassTable.maxObjInst, gBaseClassTable.maxSlots)) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to initialize OM with rc = " "0x%x!\r\n", __FUNCTION__, rc)); return (rc); } /* Accumulate the number of classes registered w/ OM */ /*omClassCnt = classIdx;*/ pOmClassEntry = NULL; /* Configure the application OM class table */ classIdx = 0; if (appOmClassCnt > 0) { for (; classIdx < appOmClassCnt; classIdx++) { pOmClassEntry = &(pAppOmClassTbl[classIdx]); if (pOmClassEntry->eMyClassType == CL_OM_INVALID_CLASS) { /* skip invalid class */ /* This way invalid classes and missing, i.e. a table size if bigger than the number of classes are allowed in the table. */ /*skippedClassCnt++;*/ continue; } if ((rc = clOmClassNameInitialize (pOmClassEntry, pOmClassEntry->className, pOmClassEntry->maxObjInst, pOmClassEntry->maxSlots)) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to initialize OM with rc = " "0x%x!\r\n", __FUNCTION__, rc)); return (rc); } } } else { CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("%s: Not initializing OM Application class " "table because it does not exist...ignoring.\r\n", __FUNCTION__)); } /* Get the total number of classes registered w/ OM */ /*gOmCfgData.numOfOmClasses = omClassCnt + classIdx - skippedClassCnt;*/ /* Initialize the COR/OM handle translation table */ if (rc == CL_OK) { if((rc = omCORTableInit()) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to setup the COR translation " "table with rc = 0x%x\r\n", rc)); } } #ifdef DEBUG /* Add OM into the debug agent */ if (!omClassInitState) dbgAddComponent(COMP_PREFIX, COMP_NAME, COMP_DEBUG_VAR_PTR); #endif omClassInitState = CL_TRUE; /* add the om to show manager */ /*@todo: Navdeep (show manager dependency) showMgrModAdd(COMP_PREFIX, COMP_NAME, omShow); */ CL_FUNC_EXIT(); return (rc); }
/* FIXME: */ ClRcT _clGmsDbCreate( CL_IN ClGmsDbT* const gmsDb, CL_OUT ClGmsDbT** const gmsElement) { ClRcT rc = CL_OK; ClUint32T i = 0; ClUint64T cntIndex = 0; if ((gmsDb == NULL) || (gmsElement == NULL)) { return CL_GMS_RC(CL_ERR_NULL_POINTER); } for(i = 0; i < gmsGlobalInfo.config.noOfGroups; i++) { if (gmsDb[i].view.isActive == CL_FALSE) { cntIndex = i; break; } } if (i == gmsGlobalInfo.config.noOfGroups) { return CL_ERR_OUT_OF_RANGE; } /* Current view database. Holds cluster and groups info */ rc = clCntHashtblCreate( viewDbParams.htbleParams.gmsNumOfBuckets, viewDbParams.htbleParams.gmsHashKeyCompareCallback, viewDbParams.htbleParams.gmsHashCallback, viewDbParams.htbleParams.gmsHashDeleteCallback, viewDbParams.htbleParams.gmsHashDestroyCallback, CL_CNT_UNIQUE_KEY, &gmsDb[cntIndex].htbl[CL_GMS_CURRENT_VIEW]); if (rc != CL_OK) { return rc; } /* Cluster joined/left view list. Used for tracking */ rc = clCntHashtblCreate( viewDbParams.htbleParams.gmsNumOfBuckets, viewDbParams.htbleParams.gmsHashKeyCompareCallback, viewDbParams.htbleParams.gmsHashCallback, viewDbParams.htbleParams.gmsHashDeleteCallback, viewDbParams.htbleParams.gmsHashDestroyCallback, CL_CNT_UNIQUE_KEY, &gmsDb[cntIndex].htbl[CL_GMS_JOIN_LEFT_VIEW]); if (rc != CL_OK) { return rc; } /* Track hash table create */ rc = clCntHashtblCreate( viewDbParams.trackDbParams->htbleParams.gmsNumOfBuckets, viewDbParams.trackDbParams->htbleParams. gmsHashKeyCompareCallback, viewDbParams.trackDbParams->htbleParams.gmsHashCallback, viewDbParams.trackDbParams->htbleParams. gmsHashDeleteCallback, viewDbParams.trackDbParams->htbleParams. gmsHashDestroyCallback, CL_CNT_UNIQUE_KEY, &gmsDb[cntIndex].htbl[CL_GMS_TRACK]); if (rc != CL_OK) { return rc; } clGmsMutexCreate(&gmsDb[cntIndex].viewMutex); clGmsMutexCreate(&gmsDb[cntIndex].trackMutex); gmsDb[cntIndex].view.isActive = CL_TRUE; clLog(DBG,GEN,DB, "Created View and Track DB for GroupId [%lld]",cntIndex); *gmsElement = &gmsDb[cntIndex++]; return rc; }
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); }