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