ClRcT clMsgQueueAllocateResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_OUT ClHandleT pQueueHandle)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(msgIdlidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clXdrMarshallClHandleT(&(pQueueHandle), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L4;
}
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
goto Label1;
L4: clXdrMarshallClHandleT(&(pQueueHandle), 0, 1);
clHandleCheckin(msgIdlidlDatabaseHdl, idlHdl);
clHandleDestroy(msgIdlidlDatabaseHdl, idlHdl);
return rc;
Label1:
clHandleCheckin(msgIdlidlDatabaseHdl, idlHdl);
clHandleDestroy(msgIdlidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
ClRcT clMsgQueueStatusGetResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_OUT SaMsgQueueStatusT_4_0_0 pQueueStatus)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(msgCltSrvidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clXdrMarshallSaMsgQueueStatusT_4_0_0(&(pQueueStatus), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L2;
}
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
goto Label1;
L2: clXdrMarshallSaMsgQueueStatusT_4_0_0(&(pQueueStatus), 0, 1);
clHandleCheckin(msgCltSrvidlDatabaseHdl, idlHdl);
clHandleDestroy(msgCltSrvidlDatabaseHdl, idlHdl);
return rc;
Label1:
clHandleCheckin(msgCltSrvidlDatabaseHdl, idlHdl);
clHandleDestroy(msgCltSrvidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
ClRcT clCkptRemSvrWelcomeResponseSend_5_1_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_INOUT ClVersionT pVersion)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(ckptEoidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clXdrMarshallClVersionT(&(pVersion), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L3;
}
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
L3: clXdrMarshallClVersionT(&(pVersion), 0, 1);
clHandleCheckin(ckptEoidlDatabaseHdl, idlHdl);
clHandleDestroy(ckptEoidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
ClRcT clMsgQueueFreeByHandle(SaMsgQueueHandleT qHandle)
{
ClRcT rc;
ClMsgQueueInfoT *pQInfo;
CL_OSAL_MUTEX_LOCK(&gClLocalQsLock);
rc = clHandleCheckout(gClMsgQDatabase, qHandle, (ClPtrT *)&pQInfo);
if(rc != CL_OK)
{
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
clLogError("QUE", "FREE", "Failed at checkout the passed queue handle. error code [0x%x].", rc);
goto error_out;
}
clMsgQueueFree(pQInfo);
clLogDebug("QUE", "FREE", "Queue is freed through its handle.");
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
rc = clHandleCheckin(gClMsgQDatabase, qHandle);
if(rc != CL_OK)
clLogError("QUE", "FREE", "Failed to checkin a queue handle. error code [0x%x].", rc);
rc = clHandleDestroy(gClMsgQDatabase, qHandle);
if(rc != CL_OK)
clLogError("QUE", "FREE", "Failed to destroy a queue handle. error code [0x%x].", rc);
error_out:
return rc;
}
ClRcT clLogMasterCompIdChkNGetResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_INOUT ClUint32T pClientId)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(LogidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clXdrMarshallClUint32T(&(pClientId), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L2;
}
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
L2: clXdrMarshallClUint32T(&(pClientId), 0, 1);
clHandleCheckin(LogidlDatabaseHdl, idlHdl);
clHandleDestroy(LogidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
ClRcT clLogMasterCompListGetResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_OUT ClUint32T pNumStreams,CL_OUT ClUint32T pBuffLen,ClUint8T* pBuffer)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(LogidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clXdrMarshallClUint32T(&(pNumStreams), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L1;
}
rc = clXdrMarshallClUint32T(&(pBuffLen), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L2;
}
rc = clXdrMarshallPtrClUint8T(pBuffer, pBuffLen, outMsgHdl, 1);
if (CL_OK != rc)
{
goto L3;
}
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
goto Label1;
L1: clXdrMarshallClUint32T(&(pNumStreams), 0, 1);
L2: clXdrMarshallClUint32T(&(pBuffLen), 0, 1);
L3: clXdrMarshallPtrClUint8T(pBuffer, pBuffLen, 0, 1);
clHandleCheckin(LogidlDatabaseHdl, idlHdl);
clHandleDestroy(LogidlDatabaseHdl, idlHdl);
return rc;
Label1:
clHandleCheckin(LogidlDatabaseHdl, idlHdl);
clHandleDestroy(LogidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
/*-----------------------------------------------------------------------------
* Finalize API
*---------------------------------------------------------------------------*/
ClRcT clGmsFinalize(
CL_IN const ClGmsHandleT gmsHandle)
{
struct gms_instance *gms_instance_ptr = NULL;
ClRcT rc= CL_OK;
rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void **)&gms_instance_ptr);
if (rc != CL_OK)
{
return CL_GMS_RC(CL_ERR_INVALID_HANDLE);
}
if (gms_instance_ptr == NULL)
{
return CL_GMS_RC(CL_ERR_NULL_POINTER);
}
rc = clGmsMutexLock(gms_instance_ptr->response_mutex);
if(rc != CL_OK)
{
return rc;
}
/*
* Another thread has already started finalizing
*/
if (gms_instance_ptr->finalize) {
clGmsMutexUnlock(gms_instance_ptr->response_mutex);
if ((clHandleCheckin(gmsHandleDb, gmsHandle)) != CL_OK)
{
clLogError(GEN,DB,
"\nclHandleCheckin Error");
}
return CL_GMS_RC(CL_ERR_INVALID_HANDLE);
}
gms_instance_ptr->finalize = 1;
clGmsMutexUnlock(gms_instance_ptr->response_mutex);
clGmsMutexDelete(gms_instance_ptr->response_mutex);
if ((clHandleDestroy(gmsHandleDb, gmsHandle)) != CL_OK)
{
clLogError(GEN,NA,
"\nclHandleDestroy Error");
}
if ((clHandleCheckin(gmsHandleDb, gmsHandle)) != CL_OK)
{
clLogError(GEN,NA,
"\nclHandleCheckin Error");
}
return CL_GMS_RC(rc);
}
ClRcT clLogMasterAttrVerifyNGetResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode,CL_INOUT ClUint16T pStreamId,CL_OUT ClUint64T pStreamMcastAddr)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(LogidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clXdrMarshallClUint16T(&(pStreamId), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L5;
}
rc = clXdrMarshallClUint64T(&(pStreamMcastAddr), outMsgHdl, 1);
if (CL_OK != rc)
{
goto L6;
}
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
goto Label1;
L5: clXdrMarshallClUint16T(&(pStreamId), 0, 1);
L6: clXdrMarshallClUint64T(&(pStreamMcastAddr), 0, 1);
clHandleCheckin(LogidlDatabaseHdl, idlHdl);
clHandleDestroy(LogidlDatabaseHdl, idlHdl);
return rc;
Label1:
clHandleCheckin(LogidlDatabaseHdl, idlHdl);
clHandleDestroy(LogidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
ClRcT clDebugDeregister(ClHandleT hReg)
{
ClDebugObjT *pDebugObj = NULL;
ClRcT rc = CL_OK;
ClEoExecutionObjT *pEoObj = NULL;
ClDebugFuncGroupT *pFuncGroup = NULL;
rc = clEoMyEoObjectGet(&pEoObj);
if (CL_OK != rc)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clEoMyEoObjectGet(): rc[0x %x]",
rc));
return rc;
}
rc = clEoPrivateDataGet( pEoObj, CL_EO_DEBUG_OBJECT_COOKIE_ID,
(void**) &pDebugObj);
if (CL_OK != rc)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clEoPrivateDataGet(): rc[0x %x]",
rc));
return rc;
}
rc = clHandleCheckout(pDebugObj->hDebugFnDB, hReg, (void **) &pFuncGroup);
if( CL_OK != rc )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCheckout(): rc[0x %x]", rc));
return rc;
}
pDebugObj->numFunc -= pFuncGroup->numFunc;
clHeapFree(pFuncGroup->pFuncDescList);
if( CL_OK != (rc = clHandleCheckin(pDebugObj->hDebugFnDB, hReg)))
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCheckin(): rc[0x %x]", rc));
}
rc = clHandleDestroy(pDebugObj->hDebugFnDB, hReg);
if( CL_OK != rc )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleDestroy(): rc[0x %x]", rc));
}
return CL_OK;
}
static ClRcT
clLogFileHdlrFileHandleDelete(ClLogFileHandleT hFileHdlr,
ClLogHandleT *phLog)
{
ClRcT rc = CL_OK;
ClLogClntFileHdlrInfoT *pData = NULL;
ClLogClntEoDataT *pClntEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogClntEoEntryGet(&pClntEoEntry);
if( CL_OK != rc )
{
return rc;
}
rc = clHandleCheckout(pClntEoEntry->hClntHandleDB, hFileHdlr,
(void **) &pData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckout(): rc[0x %x]", rc));
return rc;
}
*phLog = pData->hLog;
clLogClntFileKeyDestroy(pData->pFileKey);
rc = clHandleCheckin(pClntEoEntry->hClntHandleDB, hFileHdlr);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckin(); rc[0x %x]", rc));
}
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, hFileHdlr), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT _ckptSectionCheckResponseSend_5_0_0(ClIdlHandleT idlHdl,ClRcT retCode)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(ckptEoidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
clHandleCheckin(ckptEoidlDatabaseHdl, idlHdl);
clHandleDestroy(ckptEoidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
ClRcT clMsgClientsTrackCallbackResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(msgCltidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
clHandleCheckin(msgCltidlDatabaseHdl, idlHdl);
clHandleDestroy(msgCltidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
ClRcT clLogMasterCompListNotifyResponseSend_4_0_0(ClIdlHandleT idlHdl,ClRcT retCode)
{
ClIdlSyncInfoT *pIdlSyncDeferInfo = NULL;
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = 0;
rc = clHandleCheckout(LogidlDatabaseHdl,idlHdl,(void **)&pIdlSyncDeferInfo);
if( rc != CL_OK)
{
goto Label0;
}
outMsgHdl = pIdlSyncDeferInfo->idlRmdDeferMsg;
rc = clIdlSyncResponseSend(pIdlSyncDeferInfo->idlRmdDeferHdl,outMsgHdl,
retCode);
clHandleCheckin(LogidlDatabaseHdl, idlHdl);
clHandleDestroy(LogidlDatabaseHdl, idlHdl);
Label0:
return rc;
}
/*
* clDispatchDeregister marks the handle for delete, which was created using
* clDispatchRegister. It also wakes up any sleeping thread on SelectionObject
* by writing a dummy character to the pipe
*/
ClRcT clDispatchDeregister(
CL_IN ClHandleT dispatchHandle)
{
ClRcT rc = CL_OK;
ClDispatchDbEntryT* thisDbEntry = NULL;
ClCharT ch = '\0';
CHECK_LIB_INIT;
rc = clHandleCheckout(databaseHandle, dispatchHandle, (void *)&thisDbEntry);
if (rc != CL_OK)
{
return CL_ERR_INVALID_HANDLE;
}
CL_ASSERT(thisDbEntry != NULL);
rc = clOsalMutexLock(thisDbEntry->dispatchMutex);
if (rc != CL_OK)
{
/* Handle checkin and return */
if ((clHandleCheckin(databaseHandle, dispatchHandle)) != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("clHandleCheckin failed"));
}
return rc;
}
thisDbEntry->shouldDelete = CL_TRUE;
/*
* Write a dummy character on the pipe. This is to unblock any
* waiting thread on the pipe
*/
errno = 0;
if (write(thisDbEntry->writeFd ,(void*)&ch, 1) < 0)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("write into pipe failed: %s",strerror(errno)));
rc = CL_ERR_LIBRARY;
}
if ((clOsalMutexUnlock(thisDbEntry->dispatchMutex)) != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("Mutex unlock failed"));
}
if ((clHandleCheckin(databaseHandle, dispatchHandle)) != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("clHandleCheckin failed"));
}
if ((clHandleDestroy(databaseHandle, dispatchHandle)) != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("clHandleDestroy failed"));
}
return rc;
}
ClRcT
clLogFlusherCookieHandleDestroy(ClHandleT hFlusher,
ClBoolT timerExpired)
{
ClRcT rc = CL_OK;
ClLogFlushCookieT *pFlushCookie = NULL;
ClLogSvrEoDataT *pSvrEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
/*
* FIXME:
* Unable to flush this set of records but will this be true in
* future also, DON'T know
* Also need to reset the startAck otherwise it will not enter
* the cond_wait
*/
rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL);
if( CL_OK != rc )
{
return rc;
}
rc = clHandleValidate(pSvrEoEntry->hFlusherDB, hFlusher);
if( CL_OK != rc )
{
return rc;/*Flusher handle has already been destroyed*/
}
rc = clHandleCheckout(pSvrEoEntry->hFlusherDB, hFlusher,
(void **) &pFlushCookie);
if( (CL_TRUE == timerExpired) && (CL_OK != rc) )
{
clLogTrace("LOG", "FLS", "Timer has already destroyed the handle");
return CL_OK;
}
if( CL_OK != rc )
{
clLogError("LOG", "FLS", "Flusher handle checkout failed : "
"rc[0x %x]", rc);
return rc;
}
if( CL_FALSE == timerExpired )
{
clLogWarning("LOG", "FLS", "Didn't get ack for %d records",
pFlushCookie->numRecords);
}
CL_LOG_CLEANUP(clTimerDelete(&pFlushCookie->hTimer), CL_OK);
rc = clHandleCheckin(pSvrEoEntry->hFlusherDB, hFlusher);
if( CL_OK != rc )
{
clLogError("LOG", "FLS", "clHandleCheckin(): rc[0x %x]", rc);
}
CL_LOG_CLEANUP(clHandleDestroy(pSvrEoEntry->hFlusherDB, hFlusher), CL_OK);
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
/*-----------------------------------------------------------------------------
* Initialize API
*---------------------------------------------------------------------------*/
ClRcT clGmsInitialize(
CL_OUT ClGmsHandleT* const gmsHandle,
CL_IN const ClGmsCallbacksT* const gmsCallbacks,
CL_INOUT ClVersionT* const version)
{
struct gms_instance *gms_instance_ptr = NULL;
ClRcT rc = CL_OK;
ClGmsClientInitRequestT req = {{0}};
ClGmsClientInitResponseT *res = NULL;
/* Step 0: Check readiness of library */
rc = check_lib_init();
if (rc != CL_OK)
{
return CL_GMS_RC(CL_ERR_NOT_INITIALIZED);
}
/* Step 1: Checking inputs */
CL_ASSERT(gmsHandle != NULL);
CL_ASSERT(version != NULL);
#if 0
if ((gmsHandle == NULL) || (version == NULL))
{
return CL_GMS_RC(CL_ERR_NULL_POINTER);
}
#endif
*gmsHandle = CL_HANDLE_INVALID_VALUE;
/* Step 2: Verifying version match */
rc = clVersionVerify (&version_database, version);
if (rc != CL_OK)
{
return CL_GMS_RC(CL_ERR_VERSION_MISMATCH);
}
/* Step 3: Obtain unique handle */
rc = clHandleCreate(gmsHandleDb, sizeof(struct gms_instance), gmsHandle);
CL_ASSERT(rc == CL_OK);
#if 0
if (rc != CL_OK)
{
rc = CL_GMS_RC(CL_ERR_NO_RESOURCE);
goto error_no_destroy;
}
#endif
clLogInfo("GMS","CLT","GMS client handle is [%llX]",*gmsHandle);
rc = clHandleCheckout(gmsHandleDb, *gmsHandle, (void **)&gms_instance_ptr);
CL_ASSERT(rc == CL_OK);
CL_ASSERT(gms_instance_ptr != NULL);
#if 0
if(rc != CL_OK)
{
goto error_destroy;
}
if (gms_instance_ptr == NULL)
{
clHandleCheckin(gmsHandleDb, *gmsHandle);
rc = CL_GMS_RC(CL_ERR_NULL_POINTER);
goto error_destroy;
}
#endif
rc = clGmsMutexCreate(&gms_instance_ptr->response_mutex);
CL_ASSERT(rc == CL_OK);
#if 0
if(rc != CL_OK)
{
clHandleCheckin(gmsHandleDb, *gmsHandle);
goto error_destroy;
}
#endif
/* Step 4: Negotiate version with the server */
req.clientVersion.releaseCode = version->releaseCode;
req.clientVersion.majorVersion= version->majorVersion;
req.clientVersion.minorVersion= version->minorVersion;
rc = cl_gms_clientlib_initialize_rmd(&req, 0x0 ,&res );
if(rc != CL_OK )
{
clLogError(GEN,NA,"cl_gms_clientlib_initialize_rmd failed with rc:0x%x ",rc);
clGmsMutexDelete(gms_instance_ptr->response_mutex);
gms_instance_ptr->response_mutex = 0;
clHandleCheckin(gmsHandleDb, *gmsHandle);
rc = CL_GMS_RC(rc);
goto error_destroy;
}
/* Step 5: Initialize instance entry */
if (gmsCallbacks)
{
memcpy(&gms_instance_ptr->callbacks, gmsCallbacks, sizeof(ClGmsCallbacksT));
}
else
{
memset(&gms_instance_ptr->callbacks, 0, sizeof(ClGmsCallbacksT));
}
memset(&gms_instance_ptr->cluster_notification_buffer, 0, sizeof(ClGmsClusterNotificationBufferT));
memset(&gms_instance_ptr->group_notification_buffer, 0, sizeof(ClGmsGroupNotificationBufferT));
/* Step 6: Decrement handle use count and return */
if ((clHandleCheckin(gmsHandleDb, *gmsHandle)) != CL_OK)
{
clLogError(GEN,DB, "\nclHandleCheckin failed");
}
clHeapFree(res);
return CL_OK;
error_destroy:
clHandleDestroy(gmsHandleDb, *gmsHandle);
*gmsHandle = CL_HANDLE_INVALID_VALUE;
//error_no_destroy:
return rc;
}
static ClRcT
clLogFlusherCookieHandleCreate(ClUint32T numRecords,
ClTimerHandleT *phTimer,
ClHandleT *phFlusher)
{
ClRcT rc = CL_OK;
ClLogFlushCookieT *pFlushCookie = NULL;
ClLogSvrEoDataT *pSvrEoEntry = NULL;
ClTimerTimeOutT timeout = {0, 8000L};
ClHandleT *pTimerArg = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL);
if( CL_OK != rc )
{
return rc;
}
if( CL_FALSE == pSvrEoEntry->logInit )
{
clLogError("LOG", "FLS", "Log Service has terminated...");
return CL_OK;
}
CL_LOG_DEBUG_TRACE(("hFlusherDB: %p ", (ClPtrT) pSvrEoEntry->hFlusherDB));
rc = clHandleCreate(pSvrEoEntry->hFlusherDB, sizeof(ClLogFlushCookieT),
phFlusher);
if( CL_OK != rc )
{
clLogError("LOG", "FLS", "clHandleCreate(): rc[0x %x]", rc);
return rc;
}
pTimerArg = (ClHandleT*) clHeapCalloc(1, sizeof(ClHandleT));
if( NULL == pTimerArg )
{
clLogError("LOG", "FLS", "clHeapCalloc() : rc[0x %x]", rc);
CL_LOG_CLEANUP(clHandleDestroy(pSvrEoEntry->hFlusherDB, *phFlusher),
CL_OK);
return CL_LOG_RC(CL_ERR_NO_MEMORY);
}
*pTimerArg = *phFlusher;
rc = clTimerCreateAndStart(timeout, CL_TIMER_ONE_SHOT,
CL_TIMER_SEPARATE_CONTEXT,
clLogFlusherTimerCallback,
(ClPtrT)(ClWordT) pTimerArg, phTimer);
if( CL_OK != rc )
{
clLogError("LOG", "FLS", "clTimerCreate(): rc[0x %x]", rc);
CL_LOG_CLEANUP(clHandleDestroy(pSvrEoEntry->hFlusherDB, *phFlusher),
CL_OK);
clHeapFree(pTimerArg);
return rc;
}
rc = clHandleCheckout(pSvrEoEntry->hFlusherDB, *phFlusher,
(void **) &pFlushCookie);
if( CL_OK != rc )
{
clLogError("LOG", "FLS", "clHandleCheckout(): rc[0x %x]", rc);
CL_LOG_CLEANUP(clTimerDelete(phTimer), CL_OK);
CL_LOG_CLEANUP(clHandleDestroy(pSvrEoEntry->hFlusherDB, *phFlusher),
CL_OK);
return rc;
}
pFlushCookie->numRecords = numRecords;
pFlushCookie->hTimer = *phTimer;
rc = clHandleCheckin(pSvrEoEntry->hFlusherDB, *phFlusher);
if( CL_OK != rc )
{
clLogError("LOG", "FLS", "clHandleCheckin(): rc[0x %x]", rc);
CL_LOG_CLEANUP(clTimerDelete(phTimer), CL_OK);
CL_LOG_CLEANUP(clHandleDestroy(pSvrEoEntry->hFlusherDB, *phFlusher),
CL_OK);
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
SaAisErrorT
saClmFinalize (
const SaClmHandleT clmHandle
)
{
ClRcT rc = CL_OK;
ClHandleT localHandle = CL_HANDLE_INVALID_VALUE;
SaClmInstanceT *clmInstance = NULL;
SA_GMS_CHECK_INIT_COUNT();
/* Handle checkout */
localHandle = (ClHandleT)clmHandle;
rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
if (rc != CL_OK)
{
return _aspErrToAisErr(rc);
}
CL_ASSERT(clmInstance != NULL);
/* Finalize with GMS */
rc = clGmsFinalize(localHandle);
if (rc != CL_OK)
{
clLogError("CLM","FIN",
"clGmsFinalize failed with rc 0x%x\n",rc);
}
/* Deregister with dispatch */
rc = clDispatchDeregister(clmInstance->dispatchHandle);
if (rc != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,GMS_LOG_CTX_CLM_FINALISE,
"clDispatchDeregister failed with rc 0x%x\n",rc);
}
/* Checkin the handle */
if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,GMS_LOG_CTX_CLM_FINALISE,
"clHandleCheckin failed");
}
/* Destroy the handle */
if ((clHandleDestroy(databaseHandle, localHandle)) != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,GMS_LOG_CTX_CLM_FINALISE,
"clHandleDestroy failed");
}
SA_GMS_INIT_COUNT_DEC();
if (isLastFinalize() == CL_TRUE)
{
rc = clHandleDatabaseDestroy(databaseHandle);
if (rc != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,GMS_LOG_CTX_CLM_DB,
"clHandleDatabaseDestroy failed with rc 0x%x\n",rc);
}
}
if(CL_OK != clASPFinalize())
{
clLogInfo("CLM", "FIN",
"ASP finalize failed, rc[0x%X]", rc);
return SA_AIS_ERR_LIBRARY;
}
return _aspErrToAisErr(rc);
}
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
clAmsSAFinalize(
CL_IN ClAmsClientHandleT amsHandle)
{
ClRcT rc;
clAmsClientFinalizeRequestT req;
clAmsClientFinalizeResponseT *res = NULL;
struct ams_instance *ams_instance = NULL;
/*
* Checkout the client handle
*/
if ( (rc = clHandleCheckout(
handle_database,
amsHandle,
(void *)&ams_instance))
!= CL_OK )
goto error;
if ( ( rc = clOsalMutexLock(ams_instance->response_mutex)) != CL_OK )
goto error;
/*
* Another thread has already started finalizing
*/
if (ams_instance->finalize)
{
if (( rc = clOsalMutexUnlock(ams_instance->response_mutex)) != CL_OK )
goto error;
clHandleCheckin(handle_database, amsHandle);
rc = CL_ERR_INVALID_HANDLE;
goto error;
}
ams_instance->finalize = 1;
if ( (rc = clOsalMutexUnlock(ams_instance->response_mutex)) != CL_OK )
goto error;
/*
* Send the information to the server to finalize the
* corresponding handle
*/
req.handle = ams_instance->server_handle;
if ( (rc = cl_ams_client_finalize(
&req,
&res))
!= CL_OK )
goto error;
/*
* Delete the Mutex
*/
if ( (rc = clOsalMutexDelete (ams_instance->response_mutex) ) != CL_OK )
goto error;
/*
* Destroy the handle
*/
if ( (rc = clHandleDestroy(
handle_database,
amsHandle))
!= CL_OK )
goto error;
/*
* Check-In the handle
*/
if ( (rc = clHandleCheckin(
handle_database,
amsHandle))
!= CL_OK )
goto error;
clHeapFree((void*)res);
res = NULL;
return CL_OK;
error:
clHeapFree((void*)res);
res = NULL;
return CL_AMS_RC(rc);
}
ClRcT clDebugRegister(ClDebugFuncEntryT *funcArray,
ClUint32T funcArrayLen,
ClHandleT *phDebugReg)/* - by user - needs to be exposed*/
{
ClRcT rc = CL_OK;
ClDebugObjT *pDebugObj = NULL;
ClUint32T i = 0;
ClEoExecutionObjT *pEoObj = NULL;
ClDebugFuncGroupT *pFuncGroup = NULL;
if ((0 == funcArrayLen) || (NULL == funcArray))
{
clLogWrite(CL_LOG_HANDLE_APP,CL_LOG_WARNING,CL_DEBUG_LIB_CLIENT,
CL_LOG_MESSAGE_1_INVALID_PARAMETER,"Arguments are Invalid");
return CL_DEBUG_RC(CL_ERR_INVALID_PARAMETER);
}
rc = clEoMyEoObjectGet(&pEoObj);
if (CL_OK != rc)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clEoMyEoObjectGet(): rc[0x %x]",
rc));
return rc;
}
rc = clEoPrivateDataGet( pEoObj,
CL_EO_DEBUG_OBJECT_COOKIE_ID,
(void**) &pDebugObj);
if (CL_OK != rc)
{
return rc;
}
/* Detecting dupilcate entries are there or not */
rc = clDebugDuplicateCommandDetect(pDebugObj, funcArray, funcArrayLen);
if( CL_OK != rc )
{
return rc;
}
rc = clHandleCreate(pDebugObj->hDebugFnDB, sizeof(ClDebugFuncGroupT), phDebugReg);
if( CL_OK != rc )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCreate(): rc[0x %x]", rc));
return rc;
}
rc = clHandleCheckout(pDebugObj->hDebugFnDB, *phDebugReg,
(void **) &pFuncGroup);
if( CL_OK != rc )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCheckout(): rc[0x %x]", rc));
clHandleDestroy(pDebugObj->hDebugFnDB, *phDebugReg);
return rc;
}
pFuncGroup->pFuncDescList = clHeapAllocate(sizeof(ClDebugFuncEntryT) *
funcArrayLen);
if (NULL == pFuncGroup->pFuncDescList)
{
clLogWrite(CL_LOG_HANDLE_APP,CL_LOG_CRITICAL,CL_DEBUG_LIB_CLIENT,
CL_LOG_MESSAGE_0_MEMORY_ALLOCATION_FAILED);
clHandleCheckin(pDebugObj->hDebugFnDB, *phDebugReg);
clHandleDestroy(pDebugObj->hDebugFnDB, *phDebugReg);
return CL_DEBUG_RC(CL_ERR_NO_MEMORY);
}
for (i = 0; i < funcArrayLen; i++)
{
pFuncGroup->pFuncDescList[i] = funcArray[i];
}
pFuncGroup->numFunc = funcArrayLen;
pDebugObj->numFunc += pFuncGroup->numFunc;
if( CL_OK != (rc = clHandleCheckin(pDebugObj->hDebugFnDB, *phDebugReg)))
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCheckin(): rc[0x %x]", rc));
}
return CL_OK;
}
static ClRcT
clLogFileHdlrHandleCreate(ClLogHandleT hLog,
ClBoolT isDelete,
ClUint32T operatingLvl,
ClLogClntFileKeyT *pFileKey,
ClHandleT *phFile)
{
ClRcT rc = CL_OK;
ClBoolT entryAdd = CL_FALSE;
ClLogClntFileHdlrInfoT *pData = NULL;
ClLogClntEoDataT *pClntEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogClntEoEntryGet(&pClntEoEntry);
if( CL_OK != rc )
{
return rc;
}
rc = clHandleCreate(pClntEoEntry->hClntHandleDB,
sizeof(ClLogClntFileHdlrInfoT), phFile);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCreate(); rc[0x %x]", rc));
if( CL_TRUE == entryAdd )
{
CL_LOG_CLEANUP(clHandleDatabaseDestroy(pClntEoEntry->hClntHandleDB),
CL_OK);
}
return rc;
}
rc = clHandleCheckout(pClntEoEntry->hClntHandleDB, *phFile,
(void **) &pData);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckout(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phFile),
CL_OK);
if( CL_TRUE == entryAdd )
{
CL_LOG_CLEANUP(clHandleDatabaseDestroy(pClntEoEntry->hClntHandleDB),
CL_OK);
}
return rc;
}
pData->type = CL_LOG_FILE_HANDLE;
pData->isDelete = isDelete;
pData->startRead = 0;
pData->operatingLvl = operatingLvl;
pData->hLog = hLog;
pData->pFileKey = pFileKey;
rc = clHandleCheckin(pClntEoEntry->hClntHandleDB, *phFile);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckin(); rc[0x %x]", rc));
CL_LOG_CLEANUP(clHandleDestroy(pClntEoEntry->hClntHandleDB, *phFile),
CL_OK);
if( CL_TRUE == entryAdd )
{
CL_LOG_CLEANUP(clHandleDatabaseDestroy(pClntEoEntry->hClntHandleDB),
CL_OK);
}
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
