void clMsgCommIdlFinalize(void)
{
ClRcT rc;
rc = clIdlHandleFinalize(gIdlUcastHandle);
if(rc != CL_OK)
clLogError("MSG", "IDL", "Failed to do the finalize the IDL handle. error code [0x%x].", rc);
rc = clIdlHandleFinalize(gIdlBcastHandle);
if(rc != CL_OK)
clLogError("MSG", "IDL", "Failed to do the finalize the IDL handle. error code [0x%x].", rc);
}
ClRcT clMsgQueueAllocateThroughIdl(
ClIocPhysicalAddressT destNode,
ClNameT *pQName,
SaMsgQueueOpenFlagsT openFlags,
SaMsgQueueCreationAttributesT *pCreationAttrs,
SaMsgQueueHandleT *pQHandle)
{
ClRcT rc;
ClIdlHandleObjT idlObj = {0};
ClIdlHandleT idlHandle = 0;
memcpy(&idlObj, &gIdlUcastObj, sizeof(idlObj));
idlObj.address.address.iocAddress.iocPhyAddress = destNode;
rc = clIdlHandleInitialize(&idlObj, &idlHandle);
if(rc != CL_OK)
{
clLogError("IDL", "ALOC", "Failed to initialize the IDL handle. error code [0x%x].", rc);
goto error_out;
}
clLogTrace("IDL", "ALOC", "Allocate-request for queue [%.*s] on node [%d].", pQName->length, pQName->value, destNode.nodeAddress);
rc = VDECL_VER(clMsgQueueAllocateClientSync, 4, 0, 0)(idlHandle, pQName, openFlags, pCreationAttrs, pQHandle);
if(rc != CL_OK)
{
clLogError("IDL", "ALOC", "Queue [%.*s] allocation failed on node [%d]. error code [0x%x].", pQName->length, pQName->value, destNode.nodeAddress, rc);
}
clIdlHandleFinalize(idlHandle);
error_out:
return rc;
}
ClRcT clMsgCallClientsTrackCallback(ClIocPhysicalAddressT compAddr,
ClNameT *pGroupName,
SaMsgHandleT appHandle,
SaMsgQueueGroupNotificationBufferT *pData)
{
ClRcT rc;
ClIdlHandleObjT idlObj = {0};
ClIdlHandleT idlHandle = 0;
memcpy(&idlObj, &gIdlUcastObj, sizeof(idlObj));
idlObj.address.address.iocAddress.iocPhyAddress = compAddr;
rc = clIdlHandleInitialize(&idlObj, &idlHandle);
if(rc != CL_OK)
{
clLogError("IDL", "TRCb", "Failed to initialize the IDL handle. error code [0x%x].", rc);
goto error_out;
}
clLogTrace("IDL", "TRCb", "Calling track callback for client [0x%x:0x%x].", compAddr.nodeAddress, compAddr.portId);
rc = VDECL_VER(clMsgClientsTrackCallbackClientAsync, 4, 0, 0)(idlHandle, appHandle, pGroupName, pData, NULL, NULL);
if(rc != CL_OK)
{
clLogError("IDL", "TRCb", "Failed to make an Async RMD to client. error code [0x%x].", rc);
}
clIdlHandleFinalize(idlHandle);
error_out:
return rc;
}
ClRcT clMsgMessageGet_Idl(
ClIocPhysicalAddressT destNode,
ClNameT *pQName,
SaTimeT timeout)
{
ClRcT rc;
ClIdlHandleObjT idlObj = {0};
ClIdlHandleT idlHandle = 0;
memcpy(&idlObj, &gIdlUcastObj, sizeof(idlObj));
idlObj.address.address.iocAddress.iocPhyAddress = destNode;
rc = clIdlHandleInitialize(&idlObj, &idlHandle);
if(rc != CL_OK)
{
clLogError("IDL", "GET", "Failed to initialize the IDL handle. error code [0x%x].", rc);
goto error_out;
}
clLogTrace("IDL", "GET", "Get message request for queue [%.*s] on node [%d].", pQName->length, pQName->value, destNode.nodeAddress);
rc = VDECL_VER(clMsgMessageGetClientSync, 4, 0, 0)(idlHandle, pQName, timeout);
if(rc != CL_OK)
{
clLogError("IDL", "GET", "Queue [%.*s] message get failed on node [%d]. error code [0x%x].", pQName->length, pQName->value, destNode.nodeAddress, rc);
}
clIdlHandleFinalize(idlHandle);
error_out:
return rc;
}
ClRcT
clLogClntIdlHandleFinalize(ClIdlHandleT *phClntIdl)
{
ClRcT rc = CL_OK;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == phClntIdl), CL_LOG_RC(CL_ERR_NULL_POINTER));
rc = clIdlHandleFinalize(*phClntIdl);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clIdlHandleInitialize(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("Enter"));
return rc;
}
ClRcT clMsgCommIdlInitialize(void)
{
ClRcT rc;
ClRcT retCode;
gIdlUcastObj.objId = clObjId_ClIdlHandleObjT;
gIdlUcastObj.address.addressType = CL_IDL_ADDRESSTYPE_IOC;
gIdlUcastObj.address.address.iocAddress.iocPhyAddress.nodeAddress = clIocLocalAddressGet();
gIdlUcastObj.address.address.iocAddress.iocPhyAddress.portId = CL_IOC_MSG_PORT;
gIdlUcastObj.flags = 0;
gIdlUcastObj.options.timeout = CL_RMD_TIMEOUT_FOREVER;
gIdlUcastObj.options.retries = 3;
gIdlUcastObj.options.priority = CL_IOC_DEFAULT_PRIORITY;
rc = clIdlHandleInitialize(&gIdlUcastObj, &gIdlUcastHandle);
if(rc != CL_OK)
{
clLogError("MSG", "IDL", "Failed to initialize the the IDL. error code [0x%x].", rc);
goto error_out;
}
memcpy(&gIdlBcastObj, &gIdlUcastObj, sizeof(gIdlBcastObj));
gIdlBcastObj.address.address.iocAddress.iocPhyAddress.nodeAddress = CL_IOC_BROADCAST_ADDRESS;
gIdlBcastObj.address.address.iocAddress.iocPhyAddress.portId = CL_IOC_MSG_PORT;
gIdlBcastObj.options.priority = CL_IOC_ORDERED_PRIORITY;
rc = clIdlHandleInitialize(&gIdlBcastObj, &gIdlBcastHandle);
if(rc != CL_OK)
{
clLogError("MSG", "IDL", "Failed to initialize the the IDL. error code [0x%x].", rc);
goto error_out_1;
}
goto done_out;
error_out_1:
retCode = clIdlHandleFinalize(gIdlUcastHandle);
if(retCode != CL_OK)
clLogError("MSG", "IDL", "Failed to do the finalize the IDL handle. error code [0x%x].", retCode);
error_out:
done_out:
return rc;
}
ClRcT
clLogSvrStreamCurrentFilterGet(ClCntNodeHandleT hStreamOwnerNode,
SaNameT *pStreamName,
SaNameT *pStreamNodeName,
ClPtrT pStreamHeader)
{
ClRcT rc = CL_OK;
ClIdlHandleT hStreamOwnerIdl = CL_HANDLE_INVALID_VALUE;
ClLogStreamScopeT streamScope = CL_LOG_STREAM_GLOBAL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogStreamScopeGet(pStreamNodeName, &streamScope);
if( CL_OK != rc )
{
return rc;
}
rc = clLogSvrIdlHandleInitialize(streamScope, &hStreamOwnerIdl);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrIdlHandleInitialize(): rc[0x %x]\n", rc));
return rc;
}
#if 0
FIXME - streamOwnerShould expose the function
rc = clLogStreamOwnerFilterGetClientAsync(hStreamOwnerIdl, pStreamName,
streamScope, pStreamNodeName,
&filter, clLogSvrSOFGResponse,
(void *) hStreamOwnerNode);
#endif
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogStreamOwnerFilterGetClientAsync(): rc[0x %x]\n",
rc));
}
CL_LOG_CLEANUP(clIdlHandleFinalize(hStreamOwnerIdl), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT clMsgQueueUnlinkToServer(ClNameT *pQName)
{
ClRcT rc;
/* Look up msg queue in the cached checkpoint */
ClMsgQueueCkptDataT queueData;
if(clMsgQCkptExists((ClNameT *)pQName, &queueData) == CL_FALSE)
{
rc = CL_MSG_RC(CL_ERR_DOESNT_EXIST);
clLogError("MSG", "UNL", "Failed to get the message queue information.");
goto error_out;
}
/* Get Ioc address of the given MSG queue */
ClIdlHandleObjT idlObj = {0};
ClIdlHandleT idlHandle = 0;
memcpy(&idlObj, &gIdlUcastObj, sizeof(idlObj));
if ((queueData.creationFlags == SA_MSG_QUEUE_PERSISTENT) &&
(queueData.qServerAddress.nodeAddress != 0))
{
idlObj.address.address.iocAddress.iocPhyAddress = queueData.qServerAddress;
}
rc = clIdlHandleInitialize(&idlObj, &idlHandle);
if(rc != CL_OK)
{
clLogError("MSG", "UNL", "Failed to initialize the IDL handle. error code [0x%x].", rc);
goto error_out;
}
rc = VDECL_VER(clMsgQueueUnlinkClientSync, 4, 0, 0)(idlHandle, (ClNameT *)pQName);
if(rc != CL_OK)
{
clLogError("MSG", "UNL", "Failed to close the message queue at message server. error code [0x%x].", rc);
}
clIdlHandleFinalize(idlHandle);
error_out:
return rc;
}
ClRcT
clLogSvrShutdown(void)
{
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_CLEANUP(clLogDebugDeregister(), CL_OK);
CL_LOG_CLEANUP(clLogEvtFinalize(CL_TRUE), CL_OK);
CL_LOG_CLEANUP(clLogSvrEoDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clLogFileOwnerShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerGlobalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerLocalShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogMasterShutdown(), CL_OK);
CL_LOG_CLEANUP(clLogSvrCommonDataFinalize(), CL_OK);
CL_LOG_CLEANUP(clLogFileOwnerEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clLogStreamOwnerEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clLogSvrEoDataFree(), CL_OK);
CL_LOG_CLEANUP(clIdlHandleFinalize(shLogDummyIdl), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return CL_OK;
}
ClRcT clLogSvrInitialize(ClUint32T argc,ClCharT *argv[])
{
SaAmfCallbacksT callbacks = {0};
SaVersionT version;
ClRcT rc = CL_OK;
ClBoolT *pCookie = NULL;
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;
}
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;
}
clLogNotice(CL_LOG_AREA_UNSPECIFIED, CL_LOG_CONTEXT_UNSPECIFIED, "Log Server partially up");
CL_LOG_DEBUG_TRACE(("Exit"));
return CL_OK;
}
/*
* 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;
}
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;
}
}
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
clLogFileMetaDataGet(ClLogFileHandleT hFileHdlr,
ClLogStreamAttributesT *pStreamAttr,
ClUint32T *pNumStreams,
ClLogStreamMapT **ppLogStreams)
{
ClRcT rc = CL_OK;
ClIocAddressT address = {{0}};
ClIdlHandleT hLogIdl = CL_HANDLE_INVALID_VALUE;
ClLogClntFileKeyT *pFileKey = NULL;
ClLogStreamAttrIDLT streamAttrIdl = {{0}};
ClBoolT isDelete = CL_FALSE;
ClUint32T version = 0;
ClUint64T startRec = 0;
CL_LOG_DEBUG_TRACE(("Enter"));
CL_LOG_PARAM_CHK((NULL == pStreamAttr), CL_LOG_RC(CL_ERR_NULL_POINTER));
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 = clLogFileHdlrHandleInfoGet(hFileHdlr, &isDelete, &version,
&startRec, &pFileKey);
if( CL_OK != rc )
{
return rc;
}
rc = clLogFileHdlrAddressGet(&pFileKey->fileLocation, &address);
if( CL_OK != rc )
{
return rc;
}
CL_LOG_DEBUG_ERROR(("FileOwner's Address: %d",
address.iocPhyAddress.nodeAddress));
rc = clLogClntIdlHandleInitialize(address, &hLogIdl);
if( CL_OK != rc )
{
return rc;
}
CL_LOG_DEBUG_ERROR(("fileName: %s fileLoc: %s", pFileKey->fileName.pValue,
pFileKey->fileLocation.pValue));
rc = VDECL_VER(clLogFileHdlrFileMetaDataGetClientSync, 4, 0, 0)(hLogIdl, &pFileKey->fileName,
&pFileKey->fileLocation,
&version, &streamAttrIdl,
pNumStreams, ppLogStreams);
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_ERROR(("NumStreams: %d", *pNumStreams));
CL_LOG_CLEANUP(clIdlHandleFinalize(hLogIdl), CL_OK);
{
rc = clLogClntFileHdlrHandleUpdate(hFileHdlr, version, 0);
if( CL_OK != rc )
{
clHeapFree(streamAttrIdl.fileLocation.pValue);
clHeapFree(streamAttrIdl.fileName.pValue);
clHeapFree(ppLogStreams);
return rc;
}
updateVersion = CL_TRUE;
}
rc = clLogFileHdlrStreamAttributesCopy(&streamAttrIdl, pStreamAttr);
if( CL_OK != rc )
{
clHeapFree(streamAttrIdl.fileLocation.pValue);
clHeapFree(streamAttrIdl.fileName.pValue);
clHeapFree(ppLogStreams);
return 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;
}
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;
}
ClRcT clMsgSendMessage_idl(ClMsgMessageSendTypeT sendType,
ClIocPhysicalAddressT compAddr,
ClNameT *pName,
ClMsgMessageIovecT *pMessage,
SaTimeT sendTime,
ClHandleT senderHandle,
SaTimeT timeout,
ClBoolT isSync,
SaMsgAckFlagsT ackFlag,
MsgCltSrvClMsgMessageReceivedAsyncCallbackT fpAsyncCallback,
void *cookie)
{
ClRcT rc = CL_OK;
ClIdlHandleT idlHandle = 0;
ClIdlHandleObjT idlObj = {0};
if(compAddr.nodeAddress == CL_IOC_BROADCAST_ADDRESS)
{
rc = VDECL_VER(clMsgMessageReceivedClientAsync, 4, 0, 0)(gIdlBcastHandle, sendType, pName, pMessage, sendTime, senderHandle, timeout, NULL, NULL);
if(rc != CL_OK)
clLogError("IDL", "BCAST", "Failed to broadcast a message. error code [0x%x].", rc);
return rc;
}
memcpy(&idlObj, &gIdlUcastObj, sizeof(idlObj));
idlObj.address.address.iocAddress.iocPhyAddress = compAddr;
if (pMessage->priority == SA_MSG_MESSAGE_HIGHEST_PRIORITY)
{
idlObj.options.priority = CL_IOC_HIGH_PRIORITY;
}
rc = clIdlHandleInitialize(&idlObj, &idlHandle);
if(rc != CL_OK)
{
clLogError("IDL", "SND", "Failed to initialize the IDL handle. error code [0x%x].", rc);
goto error_out;
}
clLogTrace("IDL", "SND", "Sending a message to component [0x%x,0x%x].", compAddr.nodeAddress, compAddr.portId);
if (isSync == CL_TRUE)
{
rc = VDECL_VER(clMsgMessageReceivedClientSync, 4, 0, 0)(idlHandle, sendType, pName, pMessage, sendTime, senderHandle, timeout);
if(rc != CL_OK)
clLogError("IDL", "SND", "Failed to send a message to component [0x%x,0x%x]. error code [0x%x].", compAddr.nodeAddress, compAddr.portId, rc);
}
else
{
if(ackFlag == SA_MSG_MESSAGE_DELIVERED_ACK)
{
rc = VDECL_VER(clMsgMessageReceivedClientAsync, 4, 0, 0)(idlHandle, sendType, pName, pMessage, sendTime, senderHandle, timeout, fpAsyncCallback, cookie);
if(rc != CL_OK)
clLogError("IDL", "SND", "Failed to send a message to component [0x%x,0x%x]. error code [0x%x].", compAddr.nodeAddress, compAddr.portId, rc);
}
else
{
rc = VDECL_VER(clMsgMessageReceivedClientAsync, 4, 0, 0)(idlHandle, sendType, pName, pMessage, sendTime, senderHandle, timeout, NULL, NULL);
if(rc != CL_OK)
clLogError("IDL", "SND", "Failed to send a message to component [0x%x,0x%x]. error code [0x%x].", compAddr.nodeAddress, compAddr.portId, rc);
}
}
clIdlHandleFinalize(idlHandle);
error_out:
return rc;
}
