static void logRecordsFlush(ClLogFlushRecordT *pFlushRecord)
{
ClRcT rc = CL_OK;
ClIdlHandleT idlHdl = CL_HANDLE_INVALID_VALUE;
ClIocNodeAddressT localAddr = clIocLocalAddressGet();
ClUint32T seqNum = 0;
ClUint32T i = 0;
seqNum = pFlushRecord->seqNum;
if(pFlushRecord->multicast)
{
rc = clLogIdlHandleInitialize(pFlushRecord->mcastAddr, &idlHdl);
if( CL_OK != rc )
{
goto out_free;
}
}
for(i = 0; i < pFlushRecord->numBufs; ++i)
{
ClUint32T numRecords = pFlushRecord->pBuffs[i].numRecords;
ClUint8T* pRecord = pFlushRecord->pBuffs[i].pRecord;
ClUint32T buffLen = pFlushRecord->recordSize * numRecords;
ClTimerHandleT hTimer = CL_HANDLE_INVALID_VALUE;
ClHandleT hFlusher = CL_HANDLE_INVALID_VALUE;
if(pFlushRecord->multicast > 0)
{
if(pFlushRecord->ackersCount > 0)
{
rc = clLogFlusherCookieHandleCreate(numRecords, &hTimer, &hFlusher);
if(rc != CL_OK)
goto out_free;
}
rc = VDECL_VER(clLogClntFileHdlrDataReceiveClientAsync, 4, 0, 0)(idlHdl,
pFlushRecord->mcastAddr.iocMulticastAddress,
seqNum,
localAddr,
hFlusher, numRecords,
buffLen, pRecord,
NULL, 0);
if(rc != CL_OK)
{
if(hFlusher)
{
CL_LOG_CLEANUP(clLogFlusherCookieHandleDestroy(hFlusher, CL_FALSE), CL_OK);
}
}
}
else
{
if(pFlushRecord->fileOwnerAddr == localAddr)
{
rc = clLogFileOwnerEntryFindNPersist(&pFlushRecord->fileName,
&pFlushRecord->fileLocation,
numRecords, pRecord);
if(rc != CL_OK)
{
/*
* do nothing
*/
}
}
}
seqNum += numRecords;
clHeapFree(pRecord);
}
out_free:
{
ClUint32T j;
for(j = i; j < pFlushRecord->numBufs; ++j)
{
if(pFlushRecord->pBuffs[j].pRecord)
clHeapFree(pFlushRecord->pBuffs[j].pRecord);
}
}
if(idlHdl)
{
CL_LOG_CLEANUP(clIdlHandleFinalize(idlHdl), CL_OK);
}
if(pFlushRecord->fileLocation.pValue)
{
clHeapFree(pFlushRecord->fileLocation.pValue);
pFlushRecord->fileLocation.pValue = NULL;
pFlushRecord->fileLocation.length = 0;
}
if(pFlushRecord->fileName.pValue)
{
clHeapFree(pFlushRecord->fileName.pValue);
pFlushRecord->fileName.pValue = NULL;
pFlushRecord->fileName.length = 0;
}
if(pFlushRecord->pBuffs)
{
clHeapFree(pFlushRecord->pBuffs);
pFlushRecord->pBuffs = NULL;
}
}
/*
* 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
clLogSvrInitialize(ClUint32T argc,ClCharT *argv[])
{
SaAmfCallbacksT callbacks = {0};
SaVersionT version;
ClRcT rc = CL_OK;
ClLogSvrEoDataT *pSvrEoEntry = NULL;
ClBoolT *pCookie = NULL;
ClIocAddressT invalidAddr = {{0}};
clLogCompName =(ClCharT*) "LOG"; /* Override generated eo name with a short name for our server */
gClLogServer = CL_FALSE; /* Mark me as the log server */
clLogInfo(CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED, "Log Server initialization started...");
clAppConfigure(&clEoConfig,clEoBasicLibs,clEoClientLibs);
version.releaseCode = 'B';
version.majorVersion = 0x01;
version.minorVersion = 0x01;
callbacks.saAmfHealthcheckCallback = NULL; /* rarely necessary because SAFplus monitors the process */
callbacks.saAmfComponentTerminateCallback = clLogSvrTerminate;
callbacks.saAmfCSISetCallback = NULL;
callbacks.saAmfCSIRemoveCallback = NULL;
callbacks.saAmfProtectionGroupTrackCallback = NULL;
callbacks.saAmfProxiedComponentInstantiateCallback = NULL;
callbacks.saAmfProxiedComponentCleanupCallback = NULL;
rc = saAmfInitialize(&amfHandle, &callbacks, &version);
if( SA_AIS_OK != rc )
{
CL_LOG_DEBUG_ERROR(("saAmfInitialize(): rc[0x %x]", rc));
return rc;
}
#if defined(CL_DEBUG) && defined(CL_DEBUG_START)
clLogDebugLevelSet();
#endif
CL_LOG_DEBUG_TRACE(("Enter"));
clLogSvrMutexModeSet();
/*
* Here dummy initialization of Idl handle to avoid mutiple database
* Initialization & finalization databases. Keeping this handle alive
* will avoid this. coz Idl library will delete the handle database if the
* handle count becomes zero. Mutiple times we are initializing & deleting
* the handles in our log service usage.
*/
rc = clLogIdlHandleInitialize(invalidAddr, &shLogDummyIdl);
if( CL_OK != rc )
{
return rc;
}
rc = clLogSvrCommonDataInit();
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrCommonDataInit(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
return rc;
}
rc = clLogStreamOwnerLocalBootup();
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogStreamOwnerLocalInit(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
return rc;
}
pCookie = (ClBoolT*) clHeapCalloc(1, sizeof(ClBoolT));
if( NULL == pCookie )
{
CL_LOG_DEBUG_ERROR(("clHeapCalloc()"));
CL_LOG_CLEANUP(clLogStreamOwnerLocalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
*pCookie = CL_FALSE;
rc = clLogSvrBootup(pCookie);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrDataInit(): rc[0x %x]", rc));
clHeapFree(pCookie);
CL_LOG_CLEANUP(clLogStreamOwnerLocalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
return rc;
}
clLogInfo(CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED,
"Log server boot type is [%s]",
(*pCookie == 1)? "Restart": "Normal");
rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clLogSvrEoDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clLogSvrEoDataFree(), CL_OK);
clHeapFree(pCookie);
CL_LOG_CLEANUP(clLogStreamOwnerLocalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
return rc;
}
pSvrEoEntry->hCpm = amfHandle;
rc = saAmfComponentNameGet(amfHandle, &logServerName);
if( SA_AIS_OK != rc )
{
CL_LOG_DEBUG_ERROR(("saAmfComponentNameGet(): rc[0x %x]", rc));
saAmfFinalize(amfHandle);
CL_LOG_CLEANUP(clLogSvrEoDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clLogSvrEoDataFree(), CL_OK);
clHeapFree(pCookie);
CL_LOG_CLEANUP(clLogStreamOwnerLocalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
return rc;
}
rc = saAmfComponentRegister(amfHandle, &logServerName, NULL);
if( SA_AIS_OK != rc )
{
CL_LOG_DEBUG_ERROR(("saAmfComponentRegister(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clLogSvrEoDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clLogSvrEoDataFree(), CL_OK);
clHeapFree(pCookie);
CL_LOG_CLEANUP(clLogStreamOwnerLocalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
saAmfFinalize(amfHandle);
return rc;
}
pSvrEoEntry->hTimer = CL_HANDLE_INVALID_VALUE;
if( CL_FALSE == *pCookie )
{
rc = clLogSvrTimerDeleteNStart(pSvrEoEntry, pCookie);
}
else
{
rc = clLogTimerCallback((void *) pCookie);
}
if( CL_OK != rc )
{
saAmfComponentUnregister(amfHandle, &logServerName, NULL);
CL_LOG_CLEANUP(clLogSvrEoDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clLogSvrEoDataFree(), CL_OK);
clHeapFree(pCookie);
CL_LOG_CLEANUP(clLogStreamOwnerLocalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
saAmfFinalize(amfHandle);
return rc;
}
rc = clLogDebugRegister();
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogDebugRegister(): rc[0x %x]", rc));
}
clLogNotice(CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED,
"Log Server partially up");
CL_LOG_DEBUG_TRACE(("Exit"));
return CL_OK;
}
