static ClRcT clAmsEntityTriggerRecoveryThreadCreate(void)
{
ClRcT rc = CL_OK;
clAmsListHeadInit(&gClAmsEntityTriggerRecoveryCtrl.list);
gClAmsEntityTriggerRecoveryCtrl.running = CL_TRUE;
gClAmsEntityTriggerRecoveryCtrl.task = 0;
rc = clOsalTaskCreateAttached("AMS-RECOVERY-THREAD", CL_OSAL_SCHED_OTHER, 0, 0,
clAmsEntityTriggerRecoveryThread, NULL,
&gClAmsEntityTriggerRecoveryCtrl.task);
if(rc != CL_OK)
{
gClAmsEntityTriggerRecoveryCtrl.running = CL_FALSE;
}
return rc;
}
ClRcT
clLogUtilLibInitialize(void)
{
ClRcT rc = CL_OK;
ClCharT *pEOName = NULL;
if( gUtilLibInitialized == CL_TRUE )
{
return CL_OK;
}
rc = clOsalMutexErrorCheckInit(&gLogMutex);
if( CL_OK != rc )
{
fprintf(stderr, "Mutex init failed rc[0x %x]\n", rc);
return rc;
}
rc = clOsalCondInit(&gLogCond);
if( CL_OK != rc )
{
fprintf(stderr, "Cond init failed rc[0x %x]\n", rc);
clOsalMutexDestroy(&gLogMutex);
return rc;
}
pEOName = CL_EO_NAME;
if(pEOName && !strncasecmp(pEOName, "LOG", 3))
{
gClLogServer = CL_TRUE;
}
clLogDebugFilterInitialize();
gUtilLibInitialized = CL_TRUE;
rc = clOsalTaskCreateAttached((ClCharT *)CL_LOG_UTIL_TASK_NAME, CL_OSAL_SCHED_OTHER,
CL_OSAL_THREAD_PRI_NOT_APPLICABLE, CL_OSAL_MIN_STACK_SIZE,
clLogDeferredHandler, NULL, &taskId);
if( CL_OK != rc )
{
fprintf(stderr, "Thread creation failed rc[0x %x]", rc);
clOsalCondDestroy(&gLogCond);
clOsalMutexDestroy(&gLogMutex);
return rc;
}
return CL_OK;
}
ClRcT clDispatchThreadCreate(ClEoExecutionObjT *eoObj, ClOsalTaskIdT *taskId,
ClSvcHandleT svcHandle)
{
ClRcT rc = CL_OK;
if (svcHandle.cpmHandle != NULL)
{
clCpmSelectionObjectGet(*(svcHandle.cpmHandle), &fd[numArea]);
dispatch[numArea] = clCpmDispatch;
handle[numArea] = svcHandle.cpmHandle;
numArea++;
}
rc = clOsalTaskCreateAttached("handleResponse", CL_OSAL_SCHED_OTHER, CL_OSAL_THREAD_PRI_NOT_APPLICABLE, 0,
clDispatchHandleAllCallBacks, eoObj, taskId);
return rc;
}
static ClRcT
tsActiveTimersQueueCreate (void)
{
ClRcT returnCode = CL_ERR_INVALID_HANDLE;
CL_FUNC_ENTER();
gActiveTimerQueue.pFirstTimer = NULL;
gActiveTimerQueue.pLastTimer = NULL;
returnCode = clOsalMutexCreate (&gActiveTimerQueue.timerMutex);
if (returnCode != CL_OK) {
CL_FUNC_EXIT();
return (returnCode);
}
gActiveTimerQueue.tickInMilliSec = gTimerConfig.timerResolution;
/* spawn off the timer-task */
returnCode = clOsalTaskCreateAttached("TIMER TASK",
CL_OSAL_SCHED_OTHER,
CL_OSAL_THREAD_PRI_NOT_APPLICABLE, /* gTimerConfig.timerTaskPriority: Normally it would be this, but OTHER scheduling has no priority */
TIMER_TASK_STACK_SIZE,
tsTimerTask,
NULL,
&gActiveTimerQueue.timerTaskId);
if (returnCode != CL_OK) {
if(CL_OK != clOsalMutexDelete (gActiveTimerQueue.timerMutex)) {
CL_FUNC_EXIT();
return(returnCode);
}
CL_FUNC_EXIT();
return (returnCode);
}
gActiveTimerQueue.timerServiceInitialized = 1;
CL_FUNC_EXIT();
return (CL_OK);
}
ClRcT
clLogFlushIntervalThreadCreate(ClLogSvrStreamDataT *pSvrStreamData,
ClOsalTaskIdT *pTaskId)
{
ClRcT rc = CL_OK;
/* create a mutex for this thread, no need to destroy this mutex as
* memory is not allocated for this mutex */
rc = clOsalMutexInit_L(&pSvrStreamData->flushIntervalMutex);
if( CL_OK != rc )
{
clLogError("SVR", "FLU", "Mutex creation failed rc [0x %x]", rc);
return rc;
}
rc = clOsalCondInit_L(&pSvrStreamData->flushIntervalCondvar);
if( CL_OK != rc )
{
clLogError("SVR", "FLU", "Mutex creation failed rc [0x %x]", rc);
clOsalMutexDestroy_L(&pSvrStreamData->flushIntervalMutex);
return rc;
}
pSvrStreamData->flushIntervalThreadStatus =
CL_LOG_FLUSH_INTERVAL_STATUS_ACTIVE;
rc = clOsalTaskCreateAttached(pSvrStreamData->shmName.pValue,
CL_OSAL_SCHED_OTHER, CL_OSAL_THREAD_PRI_NOT_APPLICABLE,
CL_OSAL_MIN_STACK_SIZE, clLogFlushIntervalThread,
pSvrStreamData, pTaskId);
if( CL_OK != rc )
{
clLogError("SVR", "FLU", "Creating thread for flush interval fails rc[0x %x]",
rc);
clOsalCondDestroy(&pSvrStreamData->flushIntervalCondvar);
clOsalMutexDestroy_L(&pSvrStreamData->flushIntervalMutex);
return rc;
}
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;
}
