ClRcT clLogCompEntryUnpackNAdd(ClBufferHandleT msg, ClLogStreamOwnerDataT *pStreamOwnerData) { ClRcT rc = CL_OK; ClLogCompKeyT compKey = {0}; ClLogCompKeyT *pCompKey = NULL; ClLogSOCompDataT compData = {0}; ClLogSOCompDataT *pData = NULL; CL_LOG_DEBUG_TRACE(("Enter")); rc = VDECL_VER(clXdrUnmarshallClLogCompKeyT, 4, 0, 0)(msg, &compKey); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("VDECL_VER(clXdrUnmarshallClLogCompKeyT, 4, 0, 0)(): rc[0x %x]", rc)); return rc; } rc = VDECL_VER(clXdrUnmarshallClLogSOCompDataT, 4, 0, 0)(msg, &compData); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("VDECL_VER(clXdrUnmarshallClLogSOCompDataT, 4, 0, 0)(): rc[0x %x]", rc)); return rc; } pCompKey = (ClLogCompKeyT*)clHeapCalloc(1, sizeof(ClLogCompKeyT)); if( NULL == pCompKey ) { CL_LOG_DEBUG_ERROR(( "clHeapCalloc()")); return CL_LOG_RC(CL_ERR_NO_MEMORY); } *pCompKey = compKey; CL_LOG_DEBUG_VERBOSE(("compKey.nodeAddress: %u", compKey.nodeAddr)); CL_LOG_DEBUG_VERBOSE(("compKey.compId : %u", compKey.compId)); pData = (ClLogSOCompDataT*)clHeapCalloc(1, sizeof(ClLogSOCompDataT)); if( NULL == pData ) { CL_LOG_DEBUG_ERROR(( "clHeapCalloc()")); clHeapFree(pCompKey); return CL_LOG_RC(CL_ERR_NO_MEMORY); } *pData = compData; CL_LOG_DEBUG_VERBOSE(("compData.refCount : %u", pData->refCount)); CL_LOG_DEBUG_VERBOSE(("compData.ackerCnt : %u", pData->ackerCnt)); CL_LOG_DEBUG_VERBOSE(("compData.nonAckerCnt : %u", pData->nonAckerCnt)); rc = clCntNodeAdd(pStreamOwnerData->hCompTable, (ClCntKeyHandleT) pCompKey, (ClCntDataHandleT) pData, NULL); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(( "clCntNodeAdd(): rc[0x %x]", rc)); clHeapFree(pData); clHeapFree(pCompKey); } CL_LOG_DEBUG_TRACE(("Exit")); return CL_OK; }
ClRcT clLogSOLocalStateRecover(ClHandleT hLibCkpt, ClLogSOEoDataT *pSoEoEntry) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); /* internally calls the deserializer, clLogSODsIdMapRecreate() */ CL_LOG_DEBUG_TRACE(("clLogSODsIdMapRecreate: %s %d\n", gSOLocalCkptName.value, CL_LOG_DSID_START)); rc = clCkptLibraryCkptDataSetRead(hLibCkpt, (SaNameT *) &gSOLocalCkptName, CL_LOG_DSID_START, CL_HANDLE_INVALID_VALUE); if( CL_ERR_NOT_EXIST == CL_GET_ERROR_CODE(rc) ) { return CL_OK; } if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetRead(): rc[0x %x]", rc)); return rc; } rc = clBitmapWalkUnlocked(pSoEoEntry->hDsIdMap, clLogSOLocalStreamEntryRecover, NULL); if( CL_OK != rc ) { /* What do we do, revert back or proceed */ CL_LOG_DEBUG_ERROR(("clBitmapWalkUnlocked(): rc[0x %x]", rc)); } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogStreamOwnerEntrySerialiser(ClUint32T dsId, ClAddrT *pBuffer, ClUint32T *pSize, ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT msg = (ClBufferHandleT) cookie; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBufferLengthGet(msg, pSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc)); return rc; } *pBuffer = (ClAddrT)clHeapCalloc(*pSize, sizeof(ClUint8T)); if( NULL == *pBuffer ) { CL_LOG_DEBUG_ERROR(("clHeapCalloc()")); return rc; } rc = clBufferNBytesRead(msg, (ClUint8T *) *pBuffer, pSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc)); clHeapFree(*pBuffer); return rc; } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogBitmapPack(ClBitmapHandleT hBitmap, ClBufferHandleT msg) { ClRcT rc = CL_OK; ClUint32T nBytes = 0; ClUint8T *pBitMap = NULL; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBitmap2BufferGet(hBitmap, &nBytes, &pBitMap); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBitmap2PositionListGet(): rc[0x %x]", rc)); return rc; } rc = clXdrMarshallClUint32T(&nBytes, msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc)); clHeapFree(pBitMap); return rc; } rc = clXdrMarshallArrayClUint8T(pBitMap, nBytes, msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallArrayClUint8T(): rc[0x %x]", rc)); } clHeapFree(pBitMap); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogClntStreamDataCleanup(ClLogClntStreamDataT *pData) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBitmapDestroy(pData->hStreamBitmap); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBitmapDestroy(): rc[0x %x]", rc)); } #ifdef VXWORKS_BUILD clLogClientStreamMutexDestroy(pData); clLogClientStreamFlusherMutexDestroy(pData); #endif rc = clOsalMunmap_L(pData->pStreamHeader, pData->pStreamHeader->shmSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clOsalMunmap(): rc[0x %x]", rc)); } clHeapFree(pData->shmName.pValue); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogStreamOwnerLocalCkptCreate(ClCkptSvcHdlT hLibInit) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); rc = clCkptLibraryCkptCreate(hLibInit, (SaNameT *) &gSOLocalCkptName); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCreate(): rc[0x %x]", rc)); return rc; } rc = clCkptLibraryCkptDataSetCreate(hLibInit, (SaNameT *) &gSOLocalCkptName, CL_LOG_DSID_START, 0, 0, clLogSODsIdMapPack, clLogSODsIdMapRecreate); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetCreate(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clCkptLibraryCkptDelete(hLibInit, (SaNameT *) &gSOLocalCkptName), CL_OK); } CL_LOG_DEBUG_TRACE(("Checkpoint is created: %s %d \n", gSOLocalCkptName.value, CL_LOG_DSID_START)); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
static ClRcT clLogSvrCkptCreate(ClLogSvrEoDataT *pSvrEoEntry, ClLogSvrCommonEoDataT *pSvrCommonEoEntry) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); rc = clCkptLibraryCkptCreate(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptCreate(): rc[0x %x]", rc)); return rc; } rc = clCkptLibraryCkptDataSetCreate(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName, CL_LOG_DSID_START, 0, 0, clLogSvrDsIdMapPack, clLogSvrDsIdMapRecreate); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDelete(): rc[0x %x]", rc)); clCkptLibraryCkptDelete(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName); } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
void clLogStreamOwnerDataDump(ClCharT **retval) { ClRcT rc = CL_OK; ClDebugPrintHandleT msg = 0; ClLogSOEoDataT *pSoEoEntry = NULL; ClLogSvrCommonEoDataT *pCommonEoEntry = NULL; CL_LOG_DEBUG_TRACE(("Enter")); clDebugPrintInitialize(&msg); rc = clLogStreamOwnerEoEntryGet(&pSoEoEntry, &pCommonEoEntry); if( CL_OK != rc ) { return ; } rc = clLogSOLock(pSoEoEntry, CL_LOG_STREAM_GLOBAL); if( CL_OK != rc ) { return ; } clLogStreamOwnerEoDataPrint(pSoEoEntry, &msg); if( CL_HANDLE_INVALID_VALUE != pSoEoEntry->hGStreamOwnerTable ) { rc = clCntWalk(pSoEoEntry->hGStreamOwnerTable, clLogSOTableWalkForPrint, &msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCntWalk(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_GLOBAL), CL_OK); return ; } } CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_GLOBAL), CL_OK); rc = clLogSOLock(pSoEoEntry, CL_LOG_STREAM_LOCAL); if( CL_OK != rc ) { return ; } if( CL_HANDLE_INVALID_VALUE != pSoEoEntry->hLStreamOwnerTable ) { rc = clCntWalk(pSoEoEntry->hLStreamOwnerTable, clLogSOTableWalkForPrint, &msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCntWalk(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_LOCAL), CL_OK); return ; } } CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, CL_LOG_STREAM_LOCAL), CL_OK); clDebugPrintFinalize(&msg, retval); CL_LOG_DEBUG_TRACE(("Exit")); return ; }
ClRcT clLogCompTablePack(ClCntKeyHandleT key, ClCntDataHandleT data, ClCntArgHandleT arg, ClUint32T size) { ClRcT rc = CL_OK; ClLogCompKeyT *pCompKey = (ClLogCompKeyT *) key; ClLogSOCompDataT *pData = (ClLogSOCompDataT *) data; ClBufferHandleT msg = (ClBufferHandleT) arg; CL_LOG_DEBUG_TRACE(("Enter")); rc = VDECL_VER(clXdrMarshallClLogCompKeyT, 4, 0, 0)(pCompKey, msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc)); return rc; } rc = VDECL_VER(clXdrMarshallClLogSOCompDataT, 4, 0, 0)(pData, msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc)); return rc; } CL_LOG_DEBUG_TRACE(("Exit")); return CL_OK; }
static ClRcT clLogMasterFileKeyPack(ClLogFileKeyT *pFileKey, ClBufferHandleT hFileEntryBuf) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); rc = clXdrMarshallClStringT(&pFileKey->fileLocation, hFileEntryBuf, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClStringT(): rc[0x %x]", rc)); return rc; } rc = clXdrMarshallClStringT(&pFileKey->fileName, hFileEntryBuf, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClStringT(): rc[0x %x]", rc)); return rc; } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
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; }
static ClRcT clLogSvrCompTablePack(ClCntKeyHandleT key, ClCntDataHandleT data, ClCntArgHandleT arg, ClUint32T size) { ClRcT rc = CL_OK; ClLogSvrCompKeyT *pCompKey = (ClLogSvrCompKeyT *)key; ClLogSvrCompDataT *pCompData = (ClLogSvrCompDataT *)data; ClBufferHandleT msg = *(ClBufferHandleT *)arg; CL_LOG_DEBUG_TRACE(("Enter")); rc = clXdrMarshallClUint32T(&(pCompKey->componentId), msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc)); return rc; } rc = clXdrMarshallClUint32T(&(pCompData->refCount), msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc)); return rc; } rc = clXdrMarshallClUint32T(&(pCompData->portId), msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint32T(): rc[0x %x]", rc)); return rc; } CL_LOG_DEBUG_TRACE(("Exit")); return CL_OK; }
static ClRcT clLogSvrSOFGResponseProcess(ClLogFilterT *pStreamFilter, ClPtrT pCookie) { ClRcT rc = CL_OK; ClLogSvrEoDataT *pSvrEoEntry = NULL; ClCntNodeHandleT hStreamOwnerNode = (ClCntNodeHandleT) pCookie; ClLogSvrStreamDataT *pStreamData = NULL; ClLogSvrCommonEoDataT *pSvrCommonEoEntry = NULL; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry); if( CL_OK != rc ) { return rc; } rc = clOsalMutexLock_L(&pSvrEoEntry->svrStreamTableLock); if( CL_OK != rc ) { return rc; } rc = clCntNodeUserDataGet(pSvrEoEntry->hSvrStreamTable, hStreamOwnerNode, (ClCntDataHandleT *) &pStreamData); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK); return rc; } rc = clLogServerStreamMutexLock(pStreamData); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clOsalMutexLock(): rc[0x %x]\n", rc)); CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK); return rc; } CL_LOG_CLEANUP(clOsalMutexUnlock_L(&pSvrEoEntry->svrStreamTableLock), CL_OK); /* * Log Server will not intimate the client about this filter update, * as it is recreating the state for itself and filter may or may * not have been updated during that transient period. */ rc = clLogFilterAssign(pStreamData->pStreamHeader, pStreamFilter); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogFilterAssign(): rc[0x %x]\n", rc)); } CL_LOG_CLEANUP(clLogServerStreamMutexUnlock(pStreamData),CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
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; }
static ClRcT clLogSvrDsIdMapRecreate(ClUint32T dsId, ClAddrT pBuffer, ClUint32T buffSize, ClPtrT pCookie) { ClRcT rc = CL_OK; ClLogSvrEoDataT *pSvrEoEntry = NULL; ClBufferHandleT inMsg = CL_HANDLE_INVALID_VALUE; CL_LOG_DEBUG_TRACE(("Enter")); CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER)); CL_LOG_PARAM_CHK((CL_LOG_DSID_START != dsId), CL_LOG_RC(CL_ERR_INVALID_PARAMETER)); rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&inMsg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } rc = clXdrUnmarshallClUint32T(inMsg, &pSvrEoEntry->nextDsId); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]\n", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } CL_LOG_DEBUG_VERBOSE(("DsIdCnt: %d", pSvrEoEntry->nextDsId)); rc = clLogBitmapUnpack(inMsg, pSvrEoEntry->hDsIdMap); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogBitmapUnpack(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogSvrEoDataInit(ClLogSvrEoDataT *pSvrEoEntry, ClLogSvrCommonEoDataT *pSvrCommonEoEntry) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); pSvrEoEntry->hSvrStreamTable = CL_HANDLE_INVALID_VALUE; pSvrEoEntry->nextDsId = CL_LOG_DSID_START; rc = clOsalMutexInit_L(&pSvrEoEntry->svrStreamTableLock); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clOsalMutexCreate(): rc[0x %x]", rc)); return rc; } rc = clBitmapCreate(&pSvrEoEntry->hDsIdMap, pSvrCommonEoEntry->maxStreams); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBitmapCreate(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clOsalMutexDestroy_L(&pSvrEoEntry->svrStreamTableLock), CL_OK); return rc; } rc = clHandleDatabaseCreate(NULL, &pSvrEoEntry->hFlusherDB); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clHandleDatabaseCreate(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBitmapDestroy(pSvrEoEntry->hDsIdMap), CL_OK); CL_LOG_CLEANUP(clOsalMutexDestroy_L(&pSvrEoEntry->svrStreamTableLock), CL_OK); return rc; } rc = clLogConfigDataGet(NULL, NULL, NULL, &pSvrEoEntry->maxFlushLimit); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogConfigDataGet(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clHandleDatabaseDestroy(pSvrEoEntry->hFlusherDB), CL_OK); CL_LOG_CLEANUP(clBitmapDestroy(pSvrEoEntry->hDsIdMap), CL_OK); CL_LOG_CLEANUP(clOsalMutexDestroy_L(&pSvrEoEntry->svrStreamTableLock), CL_OK); return rc; } pSvrEoEntry->hCpm = CL_HANDLE_INVALID_VALUE; pSvrEoEntry->logCompId = 0; pSvrEoEntry->gmsInit = CL_FALSE; pSvrEoEntry->evtInit = CL_FALSE; pSvrEoEntry->ckptInit = CL_FALSE; pSvrEoEntry->logInit = CL_FALSE; pSvrEoEntry->hTimer = CL_FALSE; CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
static ClRcT clLogSvrStreamEntryRecover(ClBitmapHandleT hBitmap, ClUint32T dsId, void *pCookie) { ClRcT rc = CL_OK; ClLogSvrEoDataT *pSvrEoEntry = NULL; ClLogSvrCommonEoDataT *pSvrCommonEoEntry = NULL; ClBoolT dataSetExists = CL_TRUE; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogSvrEoEntryGet(): rc[0x %x]", rc)); return rc; } rc = clCkptLibraryDoesDatasetExist(pSvrCommonEoEntry->hLibCkpt, (SaNameT *)&gSvrLocalCkptName, dsId, &dataSetExists); if(rc != CL_OK || !dataSetExists) { CL_LOG_DEBUG_ERROR(("Dataset [%u] doesnt exist. Continuing", dsId)); return CL_OK; } rc = clCkptLibraryCkptDataSetCreate(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName, dsId, 0, 0, clLogSvrStreamEntryPack, clLogSvrStreamEntryRecreate); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetCreate(): rc[0x %x]", rc)); return rc; } /* this will internaly call deserializer, clLogSvrStreamEntryRecreate() */ rc = clCkptLibraryCkptDataSetRead(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName, dsId, CL_HANDLE_INVALID_VALUE); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetRead(): rc[0x %x]", rc)); CL_LOG_DEBUG_ERROR(("Unable to recover data from this dsId: %u. " "Continuing", dsId)); return CL_OK; } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogMasterCompData2BufferGet(ClLogCompDataT *pCompData, ClUint8T **ppBuffer, ClUint32T *pDataSize) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBufferCreate(&msg); if(CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = VDECL_VER(clXdrMarshallClLogCompDataT, 4, 0, 0)(pCompData, msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogMarshallClLogCompDataT(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } rc = clBufferLengthGet(msg, pDataSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } *ppBuffer = (ClUint8T*) clHeapCalloc(*pDataSize, sizeof(ClUint8T)); if( NULL == *ppBuffer ) { CL_LOG_DEBUG_ERROR(("clHeapCalloc()")); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return CL_LOG_RC(CL_ERR_NO_MEMORY); } rc = clBufferNBytesRead(msg, *ppBuffer, pDataSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc)); clHeapFree(*ppBuffer); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return CL_OK; }
static ClRcT clLogMasterFileEntryRecover(ClLogMasterEoDataT *pMasterEoEntry, ClCkptIOVectorElementT *pIoVector, ClUint32T *pErrIndex) { ClRcT rc = CL_OK; ClBufferHandleT hFileEntryBuf = CL_HANDLE_INVALID_VALUE; ClVersionT version = {0}; CL_LOG_DEBUG_TRACE(("Enter: size %lld", pIoVector->readSize)); rc = clBufferCreate(&hFileEntryBuf); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(hFileEntryBuf, (ClUint8T*) pIoVector->dataBuffer, pIoVector->readSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK); return rc; } rc = clXdrUnmarshallClVersionT(hFileEntryBuf, &version); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClVersionT(): rc[%#x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK); return rc; } switch(CL_VERSION_CODE(version.releaseCode, version.majorVersion, version.minorVersion)) { case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION): { rc = fileEntryRecoverBaseVersion(pMasterEoEntry, hFileEntryBuf); } break; default: rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH); clLogError("FILE", "RECOVER", "Version [%d.%d.%d] unsupported", version.releaseCode, version.majorVersion, version.minorVersion); break; } CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogSODsIdMapRecreate(ClUint32T dsId, ClAddrT pBuffer, ClUint32T size, ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; ClLogSOEoDataT *pSoEoEntry = NULL; ClLogSvrCommonEoDataT *pCommonEoData = NULL; CL_LOG_DEBUG_TRACE(("Enter")); CL_LOG_PARAM_CHK((CL_LOG_SO_DSID_START != dsId), CL_LOG_RC(CL_ERR_INVALID_PARAMETER)); CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER)); rc = clLogStreamOwnerEoEntryGet(&pSoEoEntry, &pCommonEoData); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&msg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(msg, (ClUint8T *) pBuffer, size); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } rc = clXdrUnmarshallClUint32T(msg, &pSoEoEntry->dsIdCnt); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } CL_LOG_DEBUG_VERBOSE(("dsIdCnt : %d", pSoEoEntry->dsIdCnt)); rc = clLogBitmapUnpack(msg, pSoEoEntry->hDsIdMap); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit: rc[0x %x]", rc)); return rc; }
ClRcT clLogMasterCompTableStateRecover(ClLogMasterEoDataT *pMasterEoEntry, ClUint8T *pBuffer, ClUint32T dataSize) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; ClUint32T versionCode = 0; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBufferCreate(&msg); if(CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(msg, pBuffer, dataSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } rc = clXdrUnmarshallClUint32T(msg, &versionCode); if( CL_OK != rc) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[%#x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } switch(versionCode) { case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION): { rc = compTableStateRecoverBaseVersion(msg); } break; default: clLogError("COMP", "TBL-RECOVER", "Version [%d.%d.%d] is not supported", CL_VERSION_RELEASE(versionCode), CL_VERSION_MAJOR(versionCode), CL_VERSION_MINOR(versionCode)); rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH); } clBufferDelete(&msg); return rc; }
ClRcT clLogSvrCkptGet(ClLogSvrEoDataT *pSvrEoEntry, ClLogSvrCommonEoDataT *pSvrCommonEoEntry, ClBoolT *pLogRestart) { ClRcT rc = CL_OK; ClBoolT ckptExists = CL_FALSE; CL_LOG_DEBUG_TRACE(("Enter")); *pLogRestart = CL_FALSE; rc = clCkptLibraryDoesCkptExist(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName, &ckptExists); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryDoesCkptExist(): rc[0x %x]", rc)); return rc; } rc = clLogSvrCkptCreate(pSvrEoEntry, pSvrCommonEoEntry); if(CL_OK != rc) { return rc; } if( CL_TRUE == ckptExists )/*Log Service restart*/ { *pLogRestart = CL_TRUE; rc = clLogSvrStateRecover(pSvrEoEntry, pSvrCommonEoEntry); if( CL_OK != rc ) { /* * Just restart incase there were no streamowners checkpointed in the first place */ if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) { rc = CL_OK; *pLogRestart = CL_FALSE; } else { CL_LOG_DEBUG_ERROR(("clCkptLibraryDoesCkptExist(): rc[0x %x]", rc)); return rc; } } } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogSvrCkptDataSetDelete(ClUint32T dsId) { ClRcT rc = CL_OK; ClLogSvrCommonEoDataT *pSvrCommonEoEntry = NULL; ClLogSvrEoDataT *pSvrEoEntry = NULL; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogSvrEoEntryGet(): rc[0x %x]", rc)); return rc; } if( CL_LOG_DSID_START >= dsId ) { CL_LOG_DEBUG_ERROR(("Invalid DataSet ID\n ")); return CL_LOG_RC(CL_ERR_INVALID_STATE);/*FIXME*/ } rc = clBitmapBitClear(pSvrEoEntry->hDsIdMap, dsId); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetDelete(): rc[0x %x]", rc)); return rc; } rc = clCkptLibraryCkptDataSetDelete(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName, dsId); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetDelete(): rc[0x %x]", rc)); return rc; } rc = clCkptLibraryCkptDataSetWrite(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName, CL_LOG_DSID_START, pSvrEoEntry); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetWrite(): rc[0x %x]", rc)); } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
static ClRcT clLogSvrStreamEntryRecreate(ClUint32T dsId, ClAddrT pBuffer, ClUint32T buffSize, ClPtrT cookie) { ClRcT rc = CL_OK; ClLogSvrEoDataT *pSvrEoEntry = NULL; ClBufferHandleT inMsg = CL_HANDLE_INVALID_VALUE; ClLogSvrCommonEoDataT *pSvrCommonEoEntry = NULL; CL_LOG_DEBUG_TRACE(("Enter")); CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER)); rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&inMsg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } rc = clLogSvrStreamEntryUnpackNAdd(pSvrEoEntry, pSvrCommonEoEntry, inMsg, dsId); if( CL_OK != rc ) { CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
/* - clLogClntIdlHandleInitialize * - Initializes the IDL handle for use in calls to the server */ ClRcT clLogClntIdlHandleInitialize(ClIocAddressT destAddr, ClIdlHandleT *phLogIdl) { ClRcT rc = CL_OK; ClIdlHandleObjT idlObj = CL_IDL_HANDLE_INVALID_VALUE; ClIdlAddressT address = {0}; CL_LOG_DEBUG_TRACE(("Enter")); address.addressType = CL_IDL_ADDRESSTYPE_IOC; address.address.iocAddress = destAddr; idlObj.address = address; idlObj.flags = CL_RMD_CALL_DO_NOT_OPTIMIZE; idlObj.options.timeout = CL_LOG_CLIENT_DEFULT_TIMEOUT; idlObj.options.priority = CL_RMD_DEFAULT_PRIORITY; idlObj.options.retries = CL_LOG_CLIENT_DEFAULT_RETRIES; rc = clIdlHandleInitialize(&idlObj, phLogIdl); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clIdlHandleInitialize(): rc[0x %x]", rc)); return rc; } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogStreamOwnerFilterInfoUnpack(ClBufferHandleT msg, ClLogStreamOwnerDataT *pStreamOwnerData) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); rc = clXdrUnmarshallClUint16T(msg, &pStreamOwnerData->streamFilter.severityFilter); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint16T(): rc[0x %x]", rc)); return rc; } rc = clLogBitmapUnpack(msg, pStreamOwnerData->streamFilter.hMsgIdMap); if( CL_OK != rc ) { return rc; } rc = clLogBitmapUnpack(msg, pStreamOwnerData->streamFilter.hCompIdMap); if( CL_OK != rc ) { return rc; } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogStreamOwnerCkptDsIdDelete(ClLogSOEoDataT *pSoEoEntry, ClUint32T dsId) { ClRcT rc = CL_OK; ClLogSvrCommonEoDataT *pCommonEoData = NULL; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData); if( CL_OK != rc ) { return rc; } rc = clBitmapBitClear(pSoEoEntry->hDsIdMap, dsId); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBitmapBitClear(): rc[0x %x]", rc)); return rc; } CL_LOG_CLEANUP(clCkptLibraryCkptDataSetDelete(pCommonEoData->hLibCkpt, (SaNameT *) &gSOLocalCkptName, dsId), CL_OK); CL_LOG_CLEANUP(clCkptLibraryCkptDataSetWrite(pCommonEoData->hLibCkpt, (SaNameT *) &gSOLocalCkptName, CL_LOG_SO_DSID_START, pSoEoEntry), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
void clLogSvrSOFGResponse(ClIdlHandleT hLogIdl, SaNameT *pStreamName, SaNameT *pStreamScopeNode, ClLogFilterT *pStreamFilter, ClRcT retCode, ClPtrT pCookie) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); CL_ASSERT( NULL != pCookie ); if( CL_OK != retCode ) { CL_LOG_DEBUG_ERROR(("clLogSvrSOFGResponse(): rc[0x %x]", retCode)); return ; } rc = clLogSvrSOFGResponseProcess(pStreamFilter, pCookie); clHeapFree(pStreamFilter->pMsgIdSet); clHeapFree(pStreamFilter->pCompIdSet); CL_LOG_DEBUG_TRACE(("Exit")); (void)rc; return ; }
static ClRcT clLogMasterFileEntrySecIdGet(ClLogFileKeyT *pFileKey, ClCkptSectionIdT *pSecId) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter: namelen: %u locationlen: %u", pFileKey->fileName.length, pFileKey->fileLocation.length)); CL_LOG_PARAM_CHK((NULL == pFileKey->fileName.pValue), CL_LOG_RC(CL_ERR_NULL_POINTER)); CL_LOG_PARAM_CHK((NULL == pFileKey->fileLocation.pValue), CL_LOG_RC(CL_ERR_NULL_POINTER)); CL_LOG_PARAM_CHK((NULL == pSecId), CL_LOG_RC(CL_ERR_NULL_POINTER)); /* * ClString: Assuming length includes NULL terminator also. * So we idLen will include 2 more than the characters. * One we will use for / so we need to decrement it by 1 */ pSecId->idLen = pFileKey->fileName.length + pFileKey->fileLocation.length + 1; pSecId->id = (ClUint8T*) clHeapCalloc(pSecId->idLen, sizeof(ClCharT)); if( NULL == pSecId->id ) { CL_LOG_DEBUG_ERROR(("clHeapCalloc()")); return CL_LOG_RC(CL_ERR_NO_MEMORY); } snprintf((ClCharT *) pSecId->id, pSecId->idLen, "%s/%s", pFileKey->fileLocation.pValue, pFileKey->fileName.pValue); CL_LOG_DEBUG_TRACE(("Exit [%*s]", pSecId->idLen, pSecId->id)); return rc; }
ClRcT clLogClntStreamListUnpack(ClUint32T numStreams, ClUint32T buffLen, ClUint8T *pBuffer, ClLogStreamInfoT **ppLogStreams) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; CL_LOG_DEBUG_TRACE(("Enter")); *ppLogStreams = clHeapCalloc(numStreams, sizeof(ClLogStreamInfoT)); if( NULL == *ppLogStreams ) { CL_LOG_DEBUG_ERROR(("clHeapCalloc()")); return CL_LOG_RC(CL_ERR_NO_MEMORY); } rc = clBufferCreate(&msg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); clHeapFree(*ppLogStreams); return rc; } rc = clBufferNBytesWrite(msg, pBuffer, buffLen); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); clHeapFree(*ppLogStreams); return rc; } rc = clLogClntStreamListGet(msg, *ppLogStreams); if( CL_OK != rc ) { CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); clHeapFree(*ppLogStreams); return rc; } CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }