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;
}
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
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
clLogBitmapUnpack(ClBufferHandleT msg,
ClBitmapHandleT hBitmap)
{
ClRcT rc = CL_OK;
ClUint32T nBytes = 0;
ClUint8T *pBitMap = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clXdrUnmarshallClUint32T(msg, &nBytes);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_VERBOSE(("nBytes : %u", nBytes));
pBitMap = (ClUint8T*)clHeapCalloc(nBytes, sizeof(ClCharT));
if( NULL == pBitMap )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
rc = clXdrUnmarshallArrayClUint8T(msg, pBitMap, nBytes);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallArrayClUint8T(): rc[0x %x]", rc));
clHeapFree(pBitMap);
return rc;
}
rc = clBitmapBufferBitsCopy(nBytes, pBitMap, hBitmap);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBitmapPositionList2BitmapGet(): rc[0x %x]",
rc));
}
clHeapFree(pBitMap);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static void clLogVerifyAndFlushRecords(ClUint8T *pBuffer, ClLogStreamHeaderT *pHeader,
ClLogFlushRecordT *pFlushRecord, ClUint32T nRecords)
{
ClUint32T recordIndex = 0;
ClUint32T wipIdx = 0;
ClUint32T validRecordCount= 0;
ClUint32T size = 0;
CL_ASSERT(pBuffer != NULL);
CL_ASSERT(pHeader != NULL);
CL_ASSERT(pFlushRecord != NULL);
wipIdx = pHeader->recordSize - 1;
/*Validate records until bad record found and flush only valid records to avoid memory corrupiton */
for (validRecordCount =0, recordIndex = 0; recordIndex < nRecords; recordIndex++)
{
if ((pBuffer + (recordIndex * pHeader->recordSize))[wipIdx] == CL_LOG_RECORD_WRITE_COMPLETE)
{ /* If the Record is Valid Continue to check for next record validity */
validRecordCount++;
(pBuffer + (recordIndex * pHeader->recordSize))[wipIdx] = '\0'; //To mask this byte in the logs.
}
else
{ /* If Record is Invalid, then skip all remaining records */
clLogAlert("SVR", "FLU", "Invalid Record is Found, So Skipping remainging Records");
break;
}
}
if (validRecordCount)
{
size = (pFlushRecord->pBuffs[pFlushRecord->numBufs].numRecords) * (pHeader->recordSize);
memcpy(pFlushRecord->pBuffs[pFlushRecord->numBufs].pRecord + size, pBuffer, (validRecordCount * pHeader->recordSize));
pFlushRecord->pBuffs[pFlushRecord->numBufs].numRecords += validRecordCount;
CL_LOG_DEBUG_VERBOSE(("Copied from: %p to %u", pBuffer, validRecordCount * pHeader->recordSize));
}
}
ClRcT
clLogClntStreamWriteWithHeader(ClLogClntEoDataT *pClntEoEntry,
ClLogSeverityT severity,
ClUint16T serviceId,
ClUint16T msgId,
const ClCharT *pMsgHeader,
va_list args,
ClCntNodeHandleT hClntStreamNode)
{
ClRcT rc = CL_OK;
ClLogClntStreamDataT *pClntData = NULL;
ClLogStreamHeaderT *pStreamHeader = NULL;
ClUint8T *pStreamRecords = NULL;
ClUint32T nUnAcked = 0;
ClUint32T nDroppedRecords = 0;
ClUint8T *pBuffer = NULL;
ClUint32T recordSize = 0;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_DEBUG_VERBOSE(("Severity: %d ServiceId: %hu MsgId: %hu CompId: %u",
severity, serviceId, msgId, pClntEoEntry->compId));
rc = clCntNodeUserDataGet(pClntEoEntry->hClntStreamTable, hClntStreamNode,
(ClCntDataHandleT *) &pClntData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeUserDataGet(): rc[0x %x]", rc));
return rc;
}
pStreamHeader = pClntData->pStreamHeader;
pStreamRecords = pClntData->pStreamRecords;
#ifdef NO_SAF
ClLogStreamKeyT *pUserKey = NULL;
rc = clCntNodeUserKeyGet(pClntEoEntry->hClntStreamTable,
hClntStreamNode,
(ClCntKeyHandleT *) &pUserKey);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeUserKeyGet(): rc[0x %x]", rc));
return rc;
}
ClInt32T recSize= pClntData->recSize;
#define __UPDATE_RECORD_SIZE do { \
if(recSize < nbytes ) \
recSize = nbytes; \
recSize -= nbytes; \
if(!recSize) \
return CL_OK; \
}while(0)
ClUint16T streamId = 10;
ClUint64T sequenceNum = pUserKey->sequenceNum;
ClUint32T clientId = pClntEoEntry->clientId;
ClUint8T* pRecord=clHeapAllocate(recSize);
ClTimeT timeStamp = 0;
ClUint8T *pRecStart = pRecord;
ClUint16T tmp = 1;
ClUint8T endian = *(ClUint8T *) &tmp;
memset(pRecord, 0, recSize);
if( CL_LOG_MSGID_PRINTF_FMT == msgId )
{
ClInt32T nbytes = 0;
if(recSize < LOG_ASCII_MIN_REC_SIZE ) /* just a minimum record size taking care of the headers*/
{
printf("LOG record size has to be minimum [%d] bytes. Got [%d] bytes\n", LOG_ASCII_MIN_REC_SIZE, recSize);
return CL_LOG_RC(CL_ERR_INVALID_PARAMETER);
}
/*
* In ASCII logging, we dont need header, so just keeping only the
* required fields
*/
nbytes = snprintf((ClCharT *)pRecord, recSize, LOG_ASCII_HDR_FMT, endian, severity & 0x1f);
pRecord += nbytes;
__UPDATE_RECORD_SIZE;
{
ClCharT *pSeverity = (ClCharT *)clLogSeverityStrGet(severity);
ClCharT c = 0;
ClInt32T hdrLen = 0;
ClInt32T len = 0;
va_list argsCopy;
ClCharT *pFmtStr ;
va_copy(argsCopy, args);
pFmtStr = va_arg(argsCopy, ClCharT *);
if(pMsgHeader && pMsgHeader[0])
{
hdrLen = snprintf(&c, 1, "%s.%05lld : %6s) ",
pMsgHeader, sequenceNum, pSeverity ? pSeverity : "DEBUG");
if(hdrLen < 0) hdrLen = 0;
}
len = vsnprintf(&c, 1, pFmtStr, argsCopy);
va_end(argsCopy);
if(len < 0) len = 0;
hdrLen = CL_MIN(hdrLen, recSize - LOG_ASCII_HDR_LEN - LOG_ASCII_DATA_LEN - 1);
len = CL_MIN(len, recSize - LOG_ASCII_HDR_LEN - LOG_ASCII_DATA_LEN - hdrLen - 1);
nbytes = snprintf((ClCharT*)pRecord, recSize - 1, LOG_ASCII_HDR_LEN_FMT, hdrLen);
pRecord += nbytes;
__UPDATE_RECORD_SIZE;
nbytes = snprintf((ClCharT*)pRecord, recSize - 1, LOG_ASCII_DATA_LEN_DELIMITER_FMT, len);
pRecord += nbytes;
__UPDATE_RECORD_SIZE;
if(pMsgHeader && pMsgHeader[0])
{
nbytes = snprintf((ClCharT*)pRecord, recSize - 1, "%s.%05lld : %6s) ",
pMsgHeader, sequenceNum, pSeverity ? pSeverity : "DEBUG");
if(nbytes < 0) nbytes = 0;
pRecord += nbytes;
__UPDATE_RECORD_SIZE;
}
pFmtStr = va_arg(args, ClCharT *);
nbytes = vsnprintf((ClCharT*)pRecord, recSize - 1, pFmtStr, args);
if(nbytes < 0) nbytes = 0;
}
}
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
clLogClntStreamEntryAdd(ClCntHandleT hClntTable,
ClLogStreamKeyT *pStreamKey,
ClStringT *pShmName,
ClUint32T shmSize,
ClCntNodeHandleT *phStreamNode)
{
ClRcT rc = CL_OK;
ClLogClntStreamDataT *pStreamData = NULL;
#ifndef NO_SAF
ClInt32T fd = 0;
ClUint32T headerSize = 0;
ClInt32T tries = 0;
struct stat statbuf;
#endif
CL_LOG_DEBUG_TRACE(("Enter"));
pStreamData = (ClLogClntStreamDataT*) clHeapCalloc(1, sizeof(ClLogClntStreamDataT));
if( pStreamData == NULL )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
pStreamData->shmName.pValue = (ClCharT*) clHeapCalloc(pShmName->length, sizeof(ClCharT));
if( NULL == pStreamData->shmName.pValue )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
clHeapFree(pStreamData);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
memcpy(pStreamData->shmName.pValue, pShmName->pValue, pShmName->length);
CL_LOG_DEBUG_VERBOSE(("Opening Shared Memory Segment: %s", pStreamData->shmName.pValue));
#ifndef NO_SAF
rc = clOsalShmOpen_L(pStreamData->shmName.pValue, CL_LOG_SHM_OPEN_FLAGS, CL_LOG_SHM_MODE, &fd);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalShmOpen(): rc[0x %x]", rc));
clHeapFree(pStreamData->shmName.pValue);
clHeapFree(pStreamData);
pStreamData = NULL;
return rc;
}
/*
* Check to be safe w.r.t SIGBUS in case a parallel ftruncate from log server is in progress
*/
memset(&statbuf, 0, sizeof(statbuf));
while(tries++ < 3 && !fstat(fd, &statbuf))
{
if((ClUint32T) statbuf.st_size < shmSize)
{
sleep(1);
}
else break;
}
if(!statbuf.st_size)
{
CL_LOG_DEBUG_ERROR(("fstat on shared segment with size 0"));
CL_LOG_CLEANUP(clOsalShmClose_L(fd), CL_OK);
clHeapFree(pStreamData->shmName.pValue);
clHeapFree(pStreamData);
pStreamData = NULL;
return CL_LOG_RC(CL_ERR_LIBRARY);
}
rc = clOsalMmap_L(NULL, shmSize, CL_LOG_MMAP_PROT_FLAGS, CL_LOG_MMAP_FLAGS, fd, 0, (void **) &pStreamData->pStreamHeader);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalMmap(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clOsalShmClose_L(fd), CL_OK);
clHeapFree(pStreamData->shmName.pValue);
clHeapFree(pStreamData);
pStreamData = NULL;
return rc;
}
CL_LOG_CLEANUP(clOsalShmClose_L(fd), CL_OK);
CL_LOG_DEBUG_VERBOSE(("Mmapped Shared Memory Segment"));
pStreamData->pStreamHeader->shmSize = shmSize;
headerSize = CL_LOG_HEADER_SIZE_GET(pStreamData->pStreamHeader->maxMsgs, pStreamData->pStreamHeader->maxComps);
pStreamData->pStreamRecords = ((ClUint8T *) (pStreamData->pStreamHeader)) + headerSize;
CL_LOG_DEBUG_VERBOSE(("pStreamHeader : %p", (void *) pStreamData->pStreamHeader));
CL_LOG_DEBUG_VERBOSE(("msgMap: %p", (void *) (pStreamData->pStreamHeader + 1)));
CL_LOG_DEBUG_VERBOSE(("pStreamRecords: %p", pStreamData->pStreamRecords));
#endif
rc = clBitmapCreate(&(pStreamData->hStreamBitmap), 0);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBitmapCreate(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clOsalMunmap_L(pStreamData->pStreamHeader, shmSize),
CL_OK);
clHeapFree(pStreamData->shmName.pValue);
clHeapFree(pStreamData);
pStreamData = NULL;
return rc;
}
/*
* Create the shared lock for the sem.
*/
rc = clLogClientStreamSharedMutexInit(pStreamData, pShmName);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalProcessSharedMutexInit(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBitmapDestroy(pStreamData->hStreamBitmap), CL_OK);
CL_LOG_CLEANUP(clOsalMunmap_L(pStreamData->pStreamHeader, shmSize), CL_OK);
clHeapFree(pStreamData->shmName.pValue);
clHeapFree(pStreamData);
pStreamData = NULL;
return rc;
}
rc = clCntNodeAddAndNodeGet(hClntTable,(ClCntKeyHandleT) pStreamKey, (ClCntDataHandleT) pStreamData, NULL, phStreamNode);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntNodeAddAndNodeGet(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clBitmapDestroy(pStreamData->hStreamBitmap), CL_OK);
CL_LOG_CLEANUP(clLogClientStreamMutexDestroy(pStreamData), CL_OK);
CL_LOG_CLEANUP(clOsalMunmap_L(pStreamData->pStreamHeader, shmSize), CL_OK);
clHeapFree(pStreamData->shmName.pValue);
clHeapFree(pStreamData);
pStreamData = NULL;
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
/*
* Called with the log server flusher stream lock. held.
*/
static ClRcT
clLogFlusherRecordsMcast(ClLogSvrStreamDataT *pStreamData,
ClUint32T nRecords)
{
ClRcT rc = CL_OK;
ClLogStreamHeaderT *pHeader = pStreamData->pStreamHeader;
ClUint8T *pRecords = pStreamData->pStreamRecords;
ClUint32T startIdx = 0;
ClUint32T buffLen = 0;
ClHandleT hFlusher = CL_HANDLE_INVALID_VALUE;
ClTimerHandleT hTimer = CL_HANDLE_INVALID_VALUE;
ClIdlHandleT hIdlHdl = CL_HANDLE_INVALID_VALUE;
ClIocNodeAddressT localAddr = 0;
ClUint8T *pBuffer = NULL;
ClUint32T size = 0;
ClUint32T firstBatch = 0;
ClUint32T secondPatch = 0;
ClBoolT doMulticast =
( (0 < (pStreamData->ackersCount + pStreamData->nonAckersCount)) &&
(pHeader->streamMcastAddr.iocMulticastAddress != 0) )? CL_TRUE: CL_FALSE;
clLogDebug("SVR", "FLU", "Enter: nRecords: %u seqNum: %u fileOwnerAddr:[%d]", nRecords,
pStreamData->seqNum, pStreamData->fileOwnerAddr);
if( (pStreamData->ackersCount + pStreamData->nonAckersCount) == 1 &&
(pStreamData->fileOwnerAddr == clIocLocalAddressGet()) )
{
doMulticast = CL_FALSE;
}
/*
* If some fileowner has registered for this stream, if then multicast,
* otherwise just send it to local guy
*/
if( CL_TRUE == doMulticast )
{
rc = clLogIdlHandleInitialize(pHeader->streamMcastAddr, &hIdlHdl);
if( CL_OK != rc )
{
return rc;
}
if( pStreamData->ackersCount > 0 )
{
rc = clLogFlusherCookieHandleCreate(nRecords, &hTimer, &hFlusher);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clIdlHandleFinalize(hIdlHdl), CL_OK);
return rc;
}
CL_LOG_DEBUG_TRACE(("hFlusher: %#llX", hFlusher));
}
}
localAddr = clIocLocalAddressGet();
startIdx = pHeader->startAck % pHeader->maxRecordCount;
if(nRecords > pHeader->maxRecordCount)
nRecords = pHeader->maxRecordCount;
buffLen = nRecords * pHeader->recordSize;
/*
* Drop the server stream mutex unlock now and grab it again after file owner writes
* and before exiting out of the function
*/
clLogDebug(CL_LOG_AREA_SVR, "FLU", "startIdx: %u maxRec: %u nRecords: %u startIdx: %d recordIdx: %d", startIdx,
pHeader->maxRecordCount, nRecords, pHeader->startAck, pHeader->recordIdx);
if( (startIdx + nRecords) <= pHeader->maxRecordCount )
{
pBuffer = pRecords + (startIdx * pHeader->recordSize);
if( pStreamData->fileOwnerAddr == localAddr )
{
/* File onwer function which flushes the data into file */
rc = clLogFileOwnerEntryFindNPersist(&pStreamData->fileName,
&pStreamData->fileLocation, nRecords, pBuffer);
if( CL_OK != rc )
{
return rc;
}
}
if( doMulticast == CL_TRUE )
{
rc = VDECL_VER(clLogClntFileHdlrDataReceiveClientAsync, 4, 0, 0)(hIdlHdl,
pHeader->streamMcastAddr.iocMulticastAddress,
pStreamData->seqNum, localAddr,
hFlusher, nRecords, buffLen, pBuffer,
NULL, 0);
CL_LOG_CLEANUP(clIdlHandleFinalize(hIdlHdl), CL_OK);
}
CL_LOG_DEBUG_VERBOSE(("Copied from: %p to %u", pRecords + startIdx,
nRecords * pHeader->recordSize));
}
else
{
CL_LOG_DEBUG_TRACE(("startIdx: %u maxRec: %u nRecords: %u", startIdx,
pHeader->maxRecordCount, nRecords));
firstBatch = pHeader->maxRecordCount - startIdx;
pBuffer = pRecords + (startIdx * pHeader->recordSize);
secondPatch = nRecords - firstBatch;
if( pStreamData->fileOwnerAddr == localAddr )
{
/*
* Make two calls to fileowner function, so that no need to
* allocate memory, it just direct copy from shared memory
*/
rc = clLogFileOwnerEntryFindNPersist(&pStreamData->fileName,
&pStreamData->fileLocation, firstBatch, pBuffer);
if( CL_OK != rc )
{
return rc;
}
rc = clLogFileOwnerEntryFindNPersist(&pStreamData->fileName,
&pStreamData->fileLocation, secondPatch, pRecords);
if( CL_OK != rc )
{
return rc;
}
}
if( doMulticast == CL_TRUE )
{
pBuffer = clHeapCalloc(buffLen, sizeof(ClUint8T));
if( NULL == pBuffer )
{
clLogError("LOG", "FLS", "clHeapCalloc() : rc[0x %x]", rc);
CL_LOG_CLEANUP(clLogFlusherCookieHandleDestroy(hFlusher, CL_FALSE), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(hIdlHdl), CL_OK);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
size = firstBatch * pHeader->recordSize;
memcpy(pBuffer, pRecords + (startIdx * pHeader->recordSize), size);
memcpy(pBuffer + size, pRecords, buffLen - size);
rc = VDECL_VER(clLogClntFileHdlrDataReceiveClientAsync, 4, 0, 0)(hIdlHdl,
pHeader->streamMcastAddr.iocMulticastAddress,
pStreamData->seqNum, localAddr,
hFlusher, nRecords, buffLen, pBuffer,
NULL, 0);
clHeapFree(pBuffer);
CL_LOG_CLEANUP(clIdlHandleFinalize(hIdlHdl), CL_OK);
}
}
if( (doMulticast == CL_TRUE) && (CL_OK != rc) )
{
clLogError("LOG", "FLS", "VDECL_VER(clLogClntFileHdlrDataReceiveClientAsync, 4, 0, 0)(): "
"rc[0x %x]", rc);
CL_LOG_CLEANUP(clLogFlusherCookieHandleDestroy(hFlusher, CL_FALSE), CL_OK);
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT
clLogFileRecordsGet(ClLogFileHandleT hFileHdlr,
ClTimeT *pStartTime,
ClTimeT *pEndTime,
ClUint32T *pNumRecords,
ClPtrT *pLogRecords)
{
ClRcT rc = CL_OK;
ClIocAddressT address = {{0}};
ClIdlHandleT hLogIdl = CL_HANDLE_INVALID_VALUE;
ClLogClntFileKeyT *pFileKey = NULL;
ClBoolT isDelete = CL_FALSE;
ClUint32T version = 0;
ClUint64T startRec = 0;
ClUint32T buffLen = 0;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == pNumRecords), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == pLogRecords), CL_LOG_RC(CL_ERR_NULL_POINTER));
rc = clLogFileHdlrHandleInfoGet(hFileHdlr, &isDelete, &version,
&startRec, &pFileKey);
if( CL_OK != rc )
{
return rc;
}
rc = clLogFileHdlrAddressGet(&pFileKey->fileLocation, &address);
if( CL_OK != rc )
{
return rc;
}
rc = clLogClntIdlHandleInitialize(address, &hLogIdl);
if( CL_OK != rc )
{
return rc;
}
CL_LOG_DEBUG_ERROR(("fileName: %s fileLoc: %s", pFileKey->fileName.pValue,
pFileKey->fileLocation.pValue));
CL_LOG_DEBUG_ERROR(("Version: %d isDelete: %d startRec: %llu", version,
isDelete, startRec));
rc = VDECL_VER(clLogFileHdlrFileRecordsGetClientSync, 4, 0, 0)(hLogIdl, &pFileKey->fileName,
&pFileKey->fileLocation, isDelete,
&startRec, &version, pNumRecords, &buffLen,
(ClUint8T **) pLogRecords);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrFileHdlrFileMetaDataGet(): rc[0x %x]",
rc));
CL_LOG_CLEANUP(clIdlHandleFinalize(hLogIdl), CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("NumRecords: %d", *pNumRecords));
CL_LOG_CLEANUP(clIdlHandleFinalize(hLogIdl), CL_OK);
if( (CL_FALSE == isDelete))
{
rc = clLogClntFileHdlrHandleUpdate(hFileHdlr, version, startRec);
if( CL_OK != rc )
{
return rc;
}
updateVersion = CL_TRUE;
}
rc = clLogClntFileHdlrTimeStampGet(*pNumRecords, buffLen, *pLogRecords,
pStartTime, pEndTime);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogClntFileHdlrTimeStampGet(): rc[0x %x]",
rc));
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT
clLogStreamListGet(ClLogHandleT hLog,
ClUint32T *pNumStreams,
ClLogStreamInfoT **ppLogStreams)
{
ClRcT rc = CL_OK;
ClIocAddressT address = {{0}};
ClIdlHandleT hLogIdl = CL_HANDLE_INVALID_VALUE;
ClUint8T *pBuffer = NULL;
ClUint32T buffLen = 0;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == pNumStreams), CL_LOG_RC(CL_ERR_NULL_POINTER));
CL_LOG_PARAM_CHK((NULL == ppLogStreams), CL_LOG_RC(CL_ERR_NULL_POINTER));
rc = clLogHandleCheck(hLog, CL_LOG_INIT_HANDLE);
if( CL_OK != rc )
{
return rc;
}
rc = clLogMasterAddressGet(&address);
if( CL_OK != rc )
{
return rc;
}
rc = clLogClntIdlHandleInitialize(address, &hLogIdl);
if( CL_OK != rc )
{
return rc;
}
rc = VDECL_VER(clLogMasterStreamListGetClientSync, 4, 0, 0)(hLogIdl, pNumStreams, &buffLen, &pBuffer);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("VDECL_VER(clLogMasterStreamListGet, 4, 0, 0)(): rc[0x %x]",
rc));
CL_LOG_CLEANUP(clIdlHandleFinalize(hLogIdl), CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("NumRecords: %d", *pNumStreams));
CL_LOG_CLEANUP(clIdlHandleFinalize(hLogIdl), CL_OK);
if(!*pNumStreams)
{
if(pBuffer)
clHeapFree(pBuffer);
if(ppLogStreams)
*ppLogStreams = NULL;
return CL_OK;
}
rc = clLogClntStreamListUnpack(*pNumStreams, buffLen, pBuffer,
ppLogStreams);
if( CL_OK != rc )
{
clHeapFree(pBuffer);
return rc;
}
clHeapFree(pBuffer);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static ClRcT
clLogSvrStreamEntryUnpackNAdd(ClLogSvrEoDataT *pSvrEoEntry,
ClLogSvrCommonEoDataT *pSvrCommonEoEntry,
ClBufferHandleT msg,
ClUint32T dsId)
{
ClRcT rc = CL_OK;
SaNameT streamName = {0};
SaNameT streamScopeNode = {0};
ClUint32T compTableSize = 0;
ClCntNodeHandleT hSvrStreamNode = CL_HANDLE_INVALID_VALUE;
ClLogStreamKeyT *pStreamKey = NULL;
ClStringT shmName = {0};
ClStringT fileName = {0};
ClStringT fileLocation = {0};
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogSvrStreamTableGet(pSvrEoEntry);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrStreamTableCreate(): rc[0x %x]\n", rc));
return rc;
}
rc = clXdrUnmarshallSaNameT(msg, &streamName);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallSaNameT(): rc[0x %x]\n", rc));
return rc;
}
CL_LOG_DEBUG_VERBOSE(("streamName: %*s", streamName.length, streamName.value));
rc = clXdrUnmarshallSaNameT(msg, &streamScopeNode);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallSaNameT(): rc[0x %x]\n", rc));
return rc;
}
CL_LOG_DEBUG_VERBOSE(("streamScopeNode: %*s", streamScopeNode.length, streamScopeNode.value));
rc = clXdrUnmarshallClStringT(msg, &fileName);
if(CL_OK != rc)
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClStringT(): rc[%#x]\n", rc));
return rc;
}
rc = clXdrUnmarshallClStringT(msg, &fileLocation);
if(CL_OK != rc)
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClStringT(): rc[%#x]\n", rc));
return rc;
}
rc = clXdrUnmarshallClUint32T(msg, &compTableSize);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]\n", rc));
return rc;
}
CL_LOG_DEBUG_VERBOSE(("compSize : %u", compTableSize));
rc = clLogStreamKeyCreate(&streamName, &streamScopeNode, pSvrCommonEoEntry->maxStreams, &pStreamKey);
if( CL_OK != rc )
{
return rc;
}
rc = clLogShmNameCreate(&streamName,&streamScopeNode,&shmName);
if( CL_OK != rc )
{
return rc;
}
clLogInfo("LOG","CRT","Recreating log stream [%*s] shared memory [%*s] located at [%*s] from persistent checkpoint",streamName.length,streamName.value,shmName.length,shmName.pValue,streamScopeNode.length, streamScopeNode.value);
rc = clLogSvrStreamEntryAdd(pSvrEoEntry, pSvrCommonEoEntry, pStreamKey, &shmName, &hSvrStreamNode);
clHeapFree(shmName.pValue);
shmName.pValue=NULL;
shmName.length=0;
if (CL_ERR_DUPLICATE == CL_GET_ERROR_CODE(rc)) /* But if it is a duplicate stream should we do the items below? (if so we need to load hSvrStreamNode...) */
{
return rc;
}
if( CL_OK != rc )
{
clLogStreamKeyDestroy(pStreamKey);
return rc;
}
rc = clLogSvrCompEntryRecreate(pSvrCommonEoEntry, pSvrEoEntry,hSvrStreamNode, msg, compTableSize);
if(( CL_OK != rc )&&(CL_ERR_DUPLICATE != CL_GET_ERROR_CODE(rc)))
{
CL_LOG_CLEANUP(clCntNodeDelete(pSvrEoEntry->hSvrStreamTable, hSvrStreamNode), CL_OK);
return rc;
}
rc = clLogSvrShmOpenNFlusherCreate(pSvrEoEntry, &streamName, &streamScopeNode, &fileName, &fileLocation, hSvrStreamNode, dsId);
if (( CL_OK != rc )&&(CL_ERR_DUPLICATE != CL_GET_ERROR_CODE(rc)))
{
CL_LOG_DEBUG_ERROR(("clLogSvrShmOpenAndFlusherCreate(): rc[0x %x]\n", rc));
CL_LOG_CLEANUP(clCntNodeDelete(pSvrEoEntry->hSvrStreamTable, hSvrStreamNode), CL_OK);
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT
clLogSOStreamEntryUnpackNAdd(ClLogSvrCommonEoDataT *pCommonEoData,
ClBufferHandleT msg)
{
ClRcT rc = CL_OK;
ClUint32T size = 0;
ClUint32T count = 0;
SaNameT streamName = {0};
SaNameT streamScopeNode = {0};
ClLogStreamOwnerDataIDLT soData = {0};
ClLogStreamKeyT *pStreamKey = NULL;
ClCntHandleT hStreamTable = CL_HANDLE_INVALID_VALUE;
ClLogStreamOwnerDataT *pStreamOwnerData = NULL;
ClCntNodeHandleT hStreamOwnerNode = CL_HANDLE_INVALID_VALUE;
ClLogStreamScopeT streamScope;
ClLogSOEoDataT *pSoEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
memset(&streamScope,0,sizeof(ClLogStreamScopeT));
rc = clXdrUnmarshallSaNameT(msg, &streamName);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("streamName: %*s", streamName.length,
streamName.value));
rc = clXdrUnmarshallSaNameT(msg, &streamScopeNode);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("streamScopeNode: %*s", streamScopeNode.length,
streamScopeNode.value));
rc = clLogStreamScopeGet(&streamScopeNode, &streamScope);
if( CL_OK != rc )
{
return rc;
}
CL_LOG_DEBUG_TRACE(("streamScope: %d \n", streamScope));
rc = VDECL_VER(clXdrUnmarshallClLogStreamOwnerDataIDLT, 4, 0, 0)(msg, &soData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrMarshallSaNameT(): rc[0x %x]", rc));
return rc;
}
rc = clLogStreamOwnerStreamTableGet(&pSoEoEntry, streamScope);
if( CL_OK != rc )
{
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
return rc;
}
rc = clLogSOLock(pSoEoEntry, streamScope);
if( CL_OK != rc )
{
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
return rc;
}
rc = clLogStreamKeyCreate(&streamName, &streamScopeNode,
pCommonEoData->maxStreams, &pStreamKey);
if( CL_OK != rc )
{
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
hStreamTable = (CL_LOG_STREAM_GLOBAL == streamScope)
? pSoEoEntry->hGStreamOwnerTable
: pSoEoEntry->hLStreamOwnerTable ;
rc = clLogStreamOwnerEntryAdd(hStreamTable, streamScope, pStreamKey,
&hStreamOwnerNode);
if( CL_OK != rc )
{
clHeapFree(pStreamKey);
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
rc = clCntNodeUserDataGet(hStreamTable, hStreamOwnerNode,
(ClCntDataHandleT *) &pStreamOwnerData);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode), CL_OK);
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
pStreamOwnerData->nodeStatus = CL_LOG_NODE_STATUS_INIT;
pStreamOwnerData->streamId = soData.streamId;
pStreamOwnerData->streamMcastAddr = soData.streamMcastAddr;
pStreamOwnerData->dsId = soData.dsId;
pStreamOwnerData->isNewStream = soData.isNewStream;
pStreamOwnerData->openCnt = soData.openCnt;
pStreamOwnerData->ackerCnt = soData.ackerCnt;
pStreamOwnerData->nonAckerCnt = soData.nonAckerCnt;
clLogStreamAttributesCopy(&soData.streamAttr,
&pStreamOwnerData->streamAttr, CL_TRUE);
CL_LOG_DEBUG_TRACE(("streamId : %hu", soData.streamId));
CL_LOG_DEBUG_TRACE(("streamMcastAddr: %llu", soData.streamMcastAddr));
rc = clLogStreamOwnerFilterInfoUnpack(msg, pStreamOwnerData);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode), CL_OK);
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
clHeapFree(soData.streamAttr.fileName.pValue);
clHeapFree(soData.streamAttr.fileLocation.pValue);
rc = clXdrUnmarshallClUint32T(msg, &size);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode), CL_OK);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
CL_LOG_DEBUG_VERBOSE(("compSize : %u", size));
for(count = 0; count < size; count++)
{
rc = clLogCompEntryUnpackNAdd(msg, pStreamOwnerData);
if( CL_OK != rc )
{
if(CL_GET_ERROR_CODE(rc) == CL_ERR_DUPLICATE)
{
rc = CL_OK;
}
else
{
CL_LOG_CLEANUP(clCntNodeDelete(hStreamTable, hStreamOwnerNode),
CL_OK);
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
return rc;
}
}
}
CL_LOG_CLEANUP(clLogSOUnlock(pSoEoEntry, streamScope), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
