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
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;
}
/*
shmNameCreate();
map the shared memory;
populate the Flusher data;
clLogSvrFlusherThreadCreateNStart();
populate flusher.taskId
*/
static ClRcT
clLogSvrShmOpenNFlusherCreate(ClLogSvrEoDataT *pSvrEoEntry,
SaNameT *pStreamName,
SaNameT *pStreamNodeName,
ClStringT *pFileName,
ClStringT *pFileLocation,
ClCntNodeHandleT hSvrStreamNode,
ClUint32T dsId)
{
ClRcT rc = CL_OK;
ClInt32T fd = 0;
ClLogStreamHeaderT *pStreamHeader = NULL;
ClLogSvrStreamDataT *pSvrStreamData = NULL;
ClUint32T headerSize = 0;
ClLogSvrCommonEoDataT *pSvrCommonEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogSvrEoEntryGet(NULL, &pSvrCommonEoEntry);
if( CL_OK != rc )
{
return rc;
}
rc = clCntNodeUserDataGet(pSvrEoEntry->hSvrStreamTable, hSvrStreamNode,
(ClCntDataHandleT *) &pSvrStreamData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clCntDataForNodeGet(): rc[0x %x]\n", rc));
return rc;
}
if(pFileLocation->pValue)
pSvrStreamData->fileOwnerAddr = clLogFileOwnerAddressFetch(pFileLocation);
else
pSvrStreamData->fileOwnerAddr = CL_IOC_RESERVED_ADDRESS;
memcpy(&pSvrStreamData->fileName, pFileName, sizeof(pSvrStreamData->fileName));
memcpy(&pSvrStreamData->fileLocation, pFileLocation, sizeof(pSvrStreamData->fileLocation));
rc = clLogShmNameCreate(pStreamName, pStreamNodeName,
&(pSvrStreamData->shmName));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogSvrShmNameCreate(): rc[0x %x]\n", rc));
return rc;
}
rc = clOsalShmOpen_L(pSvrStreamData->shmName.pValue, CL_LOG_SHM_CREATE_FLAGS, CL_LOG_SHM_MODE, &fd);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clOsalShmOpen(): rc[0x %x]\n", rc));
CL_LOG_CLEANUP(clLogSvrShmNameDelete(&pSvrStreamData->shmName), CL_OK);
return rc;
}
rc = clLogSvrShmMapAndGet(fd,(ClUint8T **) &pStreamHeader);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clOsalShmClose_L(fd), CL_OK);
CL_LOG_CLEANUP(clLogSvrShmNameDelete(&pSvrStreamData->shmName), CL_OK);
return rc;
}
pSvrStreamData->pStreamHeader = pStreamHeader;
rc = clOsalShmClose_L(fd);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clOsalMunmap_L((ClPtrT) pStreamHeader, pStreamHeader->shmSize),
CL_OK);
pSvrStreamData->pStreamHeader = NULL;
CL_LOG_CLEANUP(clLogSvrShmNameDelete(&pSvrStreamData->shmName), CL_OK);
return rc;
}
#if 0
/*
* FIXME- by this time, logMaster wont be availble, so postponing this call
* to some time
*/
rc = clLogSvrStreamCurrentFilterGet(hSvrStreamNode, pStreamName,
pStreamNodeName, pStreamHeader);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clOsalMunmap_L((ClPtrT) pStreamHeader, pStreamHeader->shmSize),
CL_OK);
CL_LOG_CLEANUP(clOsalShmUnlink_L(pSvrStreamData->shmName.pValue),
CL_OK);
CL_LOG_CLEANUP(clLogSvrShmNameDelete(&pSvrStreamData->shmName), CL_OK);
return rc;
}
#endif
pSvrStreamData->dsId = dsId;
/*
* streamHeader |--------------------|
* | |
* | |
* maxMsgs|--------------------|
* maxComps|--------------------|
* pStreamRecords|--------------------|
* | |
* |--------------------|
*/
headerSize =
CL_LOG_HEADER_SIZE_GET(pSvrCommonEoEntry->maxMsgs,
pSvrCommonEoEntry->maxComponents);
pSvrStreamData->pStreamRecords =
((ClUint8T *) (pSvrStreamData->pStreamHeader)) + headerSize;
rc = clOsalTaskCreateAttached(pSvrStreamData->shmName.pValue,
CL_OSAL_SCHED_OTHER, CL_OSAL_THREAD_PRI_NOT_APPLICABLE,
CL_OSAL_MIN_STACK_SIZE, clLogFlusherStart,
pSvrStreamData, &pSvrStreamData->flusherId);
if( CL_OK != rc )
{
CL_LOG_CLEANUP(clOsalMunmap_L((ClPtrT) pStreamHeader, pStreamHeader->shmSize),
CL_OK);
pSvrStreamData->pStreamHeader = NULL;
CL_LOG_CLEANUP(clLogSvrShmNameDelete(&pSvrStreamData->shmName), CL_OK);
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
