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;
}
SaAisErrorT
saClmClusterNodeGetAsync (
const SaClmHandleT clmHandle,
const SaInvocationT invocation,
const SaClmNodeIdT nodeId)
{
ClRcT rc;
ClHandleT localHandle = CL_HANDLE_INVALID_VALUE;
SaClmInstanceT *clmInstance = NULL;
SA_GMS_CHECK_INIT_COUNT();
/* Check the validity of the handle */
localHandle = (ClHandleT)clmHandle;
rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
if (rc != CL_OK)
{
return _aspErrToAisErr(rc);
}
CL_ASSERT(clmInstance != NULL);
rc = clGmsClusterMemberGetAsync(localHandle,
invocation,
(ClGmsMemberIdT)nodeId);
if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,CL_LOG_CONTEXT_UNSPECIFIED,
"clHandleCheckin failed");
}
return _aspErrToAisErr(rc);
}
ClRcT clMsgMessageCancel(SaMsgQueueHandleT qHandle)
{
ClRcT rc;
ClRcT retCode;
ClMsgQueueInfoT *pQInfo;
CL_OSAL_MUTEX_LOCK(&gClLocalQsLock);
rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void**)&pQInfo);
if(rc != CL_OK)
{
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
clLogError("MSG", "CANL", "Failed to checkout the passed handle. error code [0x%x].", rc);
goto error_out;
}
CL_OSAL_MUTEX_LOCK(&pQInfo->qLock);
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
rc = clMsgUnblockThreadsOfQueue(pQInfo);
CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock);
retCode = clHandleCheckin(gClMsgQDatabase, qHandle);
if(retCode != CL_OK)
clLogError("QUE", "CANL", "Failed to checkin queue handle. error code [0x%x].", retCode);
error_out:
return rc;
}
SaAisErrorT
saClmSelectionObjectGet (
const SaClmHandleT clmHandle,
SaSelectionObjectT*const selectionObject
)
{
ClRcT rc;
ClHandleT localHandle = CL_HANDLE_INVALID_VALUE;
SaClmInstanceT *clmInstance = NULL;
SA_GMS_CHECK_INIT_COUNT();
/* Check the validity of the handle */
localHandle = (ClHandleT)clmHandle;
rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
if (rc != CL_OK)
{
return _aspErrToAisErr(rc);
}
CL_ASSERT(clmInstance != NULL);
rc = clDispatchSelectionObjectGet(
clmInstance->dispatchHandle,
selectionObject);
if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,CL_LOG_CONTEXT_UNSPECIFIED,
"clHandleCheckin failed");
}
return _aspErrToAisErr(rc);
}
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 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;
}
/*-----------------------------------------------------------------------------
* Cluster Leader Elect API
*---------------------------------------------------------------------------*/
ClRcT clGmsClusterLeaderElect(
CL_IN const ClGmsHandleT gmsHandle,
CL_IN const ClGmsNodeIdT preferredLeader,
CL_INOUT ClGmsNodeIdT *leader,
CL_INOUT ClGmsNodeIdT *deputy,
CL_INOUT ClBoolT *leadershipChanged)
{
ClRcT rc = CL_OK;
struct gms_instance *gms_instance_ptr = NULL;
ClGmsClusterLeaderElectRequestT req = {0};
ClGmsClusterLeaderElectResponseT *res = NULL;
if ((leader == NULL) || (deputy == NULL) || (leadershipChanged == NULL))
{
return CL_GMS_RC(CL_ERR_NULL_POINTER);
}
CL_GMS_SET_CLIENT_VERSION( req );
rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
if (rc != CL_OK)
{
return rc;
}
if (gms_instance_ptr == NULL)
{
return CL_GMS_RC(CL_ERR_NULL_POINTER);
}
clGmsMutexLock( gms_instance_ptr->response_mutex);
req.gmsHandle = gmsHandle;
req.preferredLeaderNode = preferredLeader;
rc = cl_gms_cluster_leader_elect_rmd(&req, 0 /* use def. timeout */, &res);
if ((rc != CL_OK) || (res == NULL)) /* If there was an error, res isn't allocated */
{
goto error_unlock_checkin;
}
rc = res->rc;
*leader = res->leader;
*deputy = res->deputy;
*leadershipChanged = res->leadershipChanged;
clHeapFree((void*)res);
error_unlock_checkin:
clGmsMutexUnlock(gms_instance_ptr->response_mutex);
if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
{
clLogError(LEA,NA,
"\nclHandleCheckin failed");
}
return rc;
}
/*-----------------------------------------------------------------------------
* Cluster Member Get Async API
*---------------------------------------------------------------------------*/
ClRcT clGmsClusterMemberGetAsync(
CL_IN const ClGmsHandleT gmsHandle,
CL_IN const ClInvocationT invocation,
CL_IN const ClGmsNodeIdT nodeId)
{
ClRcT rc = CL_OK;
struct gms_instance *gms_instance_ptr = NULL;
ClGmsClusterMemberGetAsyncRequestT req = {0};
ClGmsClusterMemberGetAsyncResponseT *res = NULL;
CL_GMS_SET_CLIENT_VERSION( req );
rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
if (rc != CL_OK)
{
return rc;
}
if (gms_instance_ptr == NULL)
{
return CL_GMS_RC(CL_ERR_NULL_POINTER);
}
if (gms_instance_ptr->callbacks.clGmsClusterMemberGetCallback == NULL)
{
rc = CL_GMS_RC(CL_ERR_NO_CALLBACK);
goto error_checkin;
}
req.gmsHandle = gmsHandle;
req.nodeId = nodeId;
req.invocation = invocation;
req.address.iocPhyAddress.nodeAddress = clIocLocalAddressGet();
rc = clEoMyEoIocPortGet(&(req.address.iocPhyAddress.portId));
if (rc != CL_OK)
{
goto error_checkin;
}
clGmsMutexLock(gms_instance_ptr->response_mutex);
rc = cl_gms_cluster_member_get_async_rmd(&req, 0 /* use def. timeout */,
&res);
if (rc != CL_OK) /* If there was an error, res isn't allocated */
{
goto error_unlock_checkin;
}
error_unlock_checkin:
clGmsMutexUnlock(gms_instance_ptr->response_mutex);
error_checkin:
if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
{
clLogError(CLM,NA,
"\nclHandleCheckin failed");
}
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);
}
/*----------------------------------------------------------------------------
* Cluster Track Callback Handler
*---------------------------------------------------------------------------*/
ClRcT clGmsClusterTrackCallbackHandler(
CL_IN ClGmsClusterTrackCallbackDataT* const res)
{
ClRcT rc = CL_OK;
struct gms_instance *gms_instance_ptr = NULL;
ClGmsHandleT gmsHandle = CL_GMS_INVALID_HANDLE;
CL_ASSERT(res != NULL);
clLog(INFO,NA,NA,"received cluster track callback");
gmsHandle = res->gmsHandle;
rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
if (rc != CL_OK)
{
goto error_free_res;
}
if (gms_instance_ptr == NULL)
{
rc = CL_GMS_RC(CL_ERR_NULL_POINTER);
goto error_free_res;
}
if (gms_instance_ptr->callbacks.clGmsClusterTrackCallback == NULL)
{
rc = CL_GMS_RC(CL_ERR_NO_CALLBACK);
goto error_checkin_free_res;
}
/*
* Calling the user's callback function with the data. The user cannot
* free the data we provide. If it needs to reatin it, it has to copy
* it out from what we provide here.
*/
(*gms_instance_ptr->callbacks.clGmsClusterTrackCallback)
(gmsHandle, &res->buffer, res->numberOfMembers, res->rc);
error_checkin_free_res:
if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
{
clLogError(CLM,NA,
"\nclHandleCheckin failed");
}
error_free_res:
/* Need to free data (res) if are not able to call the actual callback */
if (res->buffer.notification != NULL)
{
clHeapFree((void*)res->buffer.notification);
}
clHeapFree((void*)res);
return rc;
}
/*-----------------------------------------------------------------------------
* Cluster Leave Async API
*---------------------------------------------------------------------------*/
ClRcT clGmsClusterLeaveAsync(
CL_IN const ClGmsHandleT gmsHandle,
CL_IN const ClGmsNodeIdT nodeId)
{
ClRcT rc = CL_OK;
struct gms_instance *gms_instance_ptr = NULL;
ClGmsClusterLeaveRequestT req = {0};
ClGmsClusterLeaveResponseT *res = NULL;
CL_GMS_SET_CLIENT_VERSION( req );
rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
if (rc != CL_OK)
{
return rc;
}
if (gms_instance_ptr == NULL)
{
return CL_GMS_RC(CL_ERR_NULL_POINTER);
}
memset(&(gms_instance_ptr->cluster_manage_callbacks), 0,
sizeof(ClGmsClusterManageCallbacksT));
req.gmsHandle = gmsHandle;
req.nodeId = nodeId;
req.sync = CL_FALSE;
clGmsMutexLock(gms_instance_ptr->response_mutex);
rc = cl_gms_cluster_leave_rmd(&req, 0 /* use def. timeout */, &res);
if ((rc != CL_OK) || (res == NULL)) /* If there was an error, res isn't allocated */
{
goto error_unlock_checkin;
}
rc = res->rc;
clHeapFree((void*)res);
error_unlock_checkin:
clGmsMutexUnlock(gms_instance_ptr->response_mutex);
if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
{
clLogError(CLM,NA,
"\nclHandleCheckin failed");
}
return rc;
}
/*
* clDispatchSelectionObject returns the selection object [readFd] associated
* with this particular initialization of the dispatch library
*/
ClRcT clDispatchSelectionObjectGet(
CL_IN ClHandleT dispatchHandle,
CL_OUT ClSelectionObjectT* pSelectionObject)
{
ClRcT rc = CL_OK;
ClDispatchDbEntryT* thisDbEntry = NULL;
if (pSelectionObject == NULL)
{
return CL_ERR_NULL_POINTER;
}
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)
{
goto error_return;
}
if (thisDbEntry->shouldDelete == CL_TRUE)
{
rc = CL_ERR_INVALID_HANDLE;
goto error_unlock_return;
}
*pSelectionObject = (ClSelectionObjectT)thisDbEntry->readFd;
error_unlock_return:
rc = clOsalMutexUnlock(thisDbEntry->dispatchMutex);
if (rc != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("Mutex Unlock failed with rc = 0x%x\n",rc));
}
error_return:
if ((clHandleCheckin(databaseHandle, dispatchHandle)) != CL_OK)
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR,
("clHandleCheckin failed"));
}
return rc;
}
/*----------------------------------------------------------------------------
* Cluster Member Eject Callback Handler
*---------------------------------------------------------------------------*/
ClRcT clGmsClusterMemberEjectCallbackHandler(
CL_IN ClGmsClusterMemberEjectCallbackDataT* const res)
{
ClRcT rc = CL_OK;
struct gms_instance *gms_instance_ptr = NULL;
ClGmsHandleT gmsHandle = CL_GMS_INVALID_HANDLE;
CL_ASSERT(res != NULL);
gmsHandle = res->gmsHandle;
rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
if (rc != CL_OK)
{
goto error_free_res;
}
if (gms_instance_ptr == NULL)
{
rc = CL_GMS_RC(CL_ERR_NULL_POINTER);
goto error_free_res;
}
if (gms_instance_ptr->
cluster_manage_callbacks.clGmsMemberEjectCallback == NULL)
{
rc = CL_GMS_RC(CL_ERR_NO_CALLBACK);
goto error_checkin_free_res;
}
/*
* Calling the user's callback function with the data. The user cannot
* free the data we provide. If it needs to reatin it, it has to copy
* it out from what we provide here.
*/
(*gms_instance_ptr->cluster_manage_callbacks.clGmsMemberEjectCallback)
(res->reason);
error_checkin_free_res:
if (clHandleCheckin(gmsHandleDb, gmsHandle))
{
clLogError(CLM,NA,
"\nclHandleCheckin failed");
}
error_free_res:
clHeapFree((void*)res);
return rc;
}
/*-----------------------------------------------------------------------------
* Cluster Member Eject API
*---------------------------------------------------------------------------*/
ClRcT clGmsClusterMemberEject(
CL_IN const ClGmsHandleT gmsHandle,
CL_IN const ClGmsNodeIdT nodeId,
CL_IN const ClGmsMemberEjectReasonT reason)
{
ClRcT rc = CL_OK;
struct gms_instance *gms_instance_ptr = NULL;
ClGmsClusterMemberEjectRequestT req = {0};
ClGmsClusterMemberEjectResponseT *res = NULL;
CL_GMS_SET_CLIENT_VERSION( req );
rc = clHandleCheckout(gmsHandleDb, gmsHandle, (void**)&gms_instance_ptr);
if (rc != CL_OK)
{
return rc;
}
if (gms_instance_ptr == NULL)
{
return CL_GMS_RC(CL_ERR_NULL_POINTER);
}
clGmsMutexLock( gms_instance_ptr->response_mutex);
req.gmsHandle = gmsHandle;
req.nodeId = nodeId;
req.reason = reason;
rc = cl_gms_cluster_member_eject_rmd(&req, 0 /* use def. timeout */, &res);
if ((rc != CL_OK) || (res == NULL)) /* If there was an error, res isn't allocated */
{
goto error_unlock_checkin;
}
rc = res->rc;
clHeapFree((void*)res);
error_unlock_checkin:
clGmsMutexUnlock(gms_instance_ptr->response_mutex);
if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
{
clLogError(CLM,NA,
"\nclHandleCheckin failed");
}
return rc;
}
/*-----------------------------------------------------------------------------
* Cluster Track Stop API
*---------------------------------------------------------------------------*/
ClRcT clGmsClusterTrackStop(
CL_IN const ClGmsHandleT gmsHandle)
{
ClRcT rc = CL_OK;
struct gms_instance *gms_instance_ptr = NULL;
ClGmsClusterTrackStopRequestT req = {0};
ClGmsClusterTrackStopResponseT *res = NULL;
CL_GMS_SET_CLIENT_VERSION( req );
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);
}
req.gmsHandle = gmsHandle;
req.address.iocPhyAddress.nodeAddress = clIocLocalAddressGet();
rc = clEoMyEoIocPortGet(&(req.address.iocPhyAddress.portId));
CL_ASSERT(rc == CL_OK); /* Should really never happen */
clGmsMutexLock(gms_instance_ptr->response_mutex);
rc = cl_gms_cluster_track_stop_rmd(&req, 0 /* use def. timeout */, &res);
if ((rc != CL_OK) || (res == NULL)) /* If there was an error, res isn't allocated */
{
goto error_exit;
}
rc = res->rc;
clHeapFree((void*)res);
error_exit:
clGmsMutexUnlock(gms_instance_ptr->response_mutex);
if (clHandleCheckin(gmsHandleDb, gmsHandle) != CL_OK)
{
clLogError(CLM,NA,
"\nclHandleCheckin failed");
}
return CL_GMS_RC(rc);
}
ClRcT
clAmsSACSIHAStateGet(
CL_IN ClAmsClientHandleT amsHandle,
CL_IN const ClNameT *compName,
CL_IN const ClNameT *csiName,
CL_OUT ClAmsHAStateT *haState)
{
ClRcT rc;
struct ams_instance *ams_instance = NULL;
if ( !compName || !csiName || !haState)
return CL_ERR_NULL_POINTER;
/*
* Checkout the client handle
*/
if ( (rc = clHandleCheckout(
handle_database,
amsHandle,
(void *)&ams_instance))
!= CL_OK )
goto error;
/*
* Send the information to the server to
*/
if ( ( rc = _clAmsSACSIHAStateGet(
(ClNameT *)compName,
(ClNameT *)csiName,
haState ))
!= CL_OK )
goto error;
if ( (rc = clHandleCheckin(
handle_database,
amsHandle))
!= CL_OK )
goto error;
return CL_OK;
error:
return CL_AMS_RC(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;
}
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;
}
ClRcT clMsgQueueRetentionTimeSet(SaMsgQueueHandleT qHandle, SaTimeT *pRetenTime)
{
ClRcT rc;
ClRcT retCode;
ClMsgQueueInfoT *pQInfo;
CL_OSAL_MUTEX_LOCK(&gClLocalQsLock);
rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void **)&pQInfo);
if(rc != CL_OK)
{
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
clLogError("QUE", "RET", "Failed to checkout the queue handle. error code [0x%x].", rc);
goto error_out;
}
CL_OSAL_MUTEX_LOCK(&pQInfo->qLock);
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
if(pQInfo->state == CL_MSG_QUEUE_CLOSED)
{
rc = CL_MSG_RC(CL_ERR_INVALID_HANDLE);
clLogError("QUE", "RET", "Queue [%.*s] is in closed state. Cannot change retention time. error code [0x%x].",
pQInfo->pQueueEntry->qName.length, pQInfo->pQueueEntry->qName.value, rc);
goto error_out_1;
}
if(pQInfo->creationFlags != 0)
{
rc = CL_MSG_RC(CL_ERR_BAD_OPERATION);
clLogError("QUE", "RET", "Retention time can be set for only for non-persistent queues. error code [0x%x].", rc);
goto error_out_1;
}
pQInfo->retentionTime = *pRetenTime;
error_out_1:
CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock);
retCode = clHandleCheckin(gClMsgQDatabase, qHandle);
if(retCode != CL_OK)
clLogError("QUE", "RET", "Failed to checkin queue handle. error code [0x%x].", retCode);
error_out:
return rc;
}
ClRcT
clLogInitHandleBitmapFileRemove(ClLogHandleT hLog,
ClLogFileHandleT hFileHdlr)
{
ClRcT rc = CL_OK;
ClLogInitHandleDataT *pData = NULL;
ClLogClntEoDataT *pClntEoEntry = NULL;
CL_LOG_DEBUG_TRACE(("Enter"));
rc = clLogClntEoEntryGet(&pClntEoEntry);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clLogClntEoEntryGet(): rc[0x %x]", rc));
return rc;
}
rc = clHandleCheckout(pClntEoEntry->hClntHandleDB, hLog,
(void **) (&pData));
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckout(): rc[0x %x]\n", rc));
return rc;
}
rc = clBitmapBitClear(pData->hStreamBitmap, hFileHdlr);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clBitmapBitSet(): rc[0x %x]", rc));
CL_LOG_CLEANUP(clHandleCheckin(pClntEoEntry->hClntHandleDB, hLog),
CL_OK);
return rc;
}
rc = clHandleCheckin(pClntEoEntry->hClntHandleDB, hLog);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckin(): rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
ClRcT
clDebugContexDetailsPack(ClHandleDatabaseHandleT hHandleDB,
ClHandleT handle,
ClPtrT pData)
{
ClRcT rc = CL_OK;
ClBufferHandleT outMsgHdl = (ClBufferHandleT) pData;
ClDebugFuncGroupT *pFuncGroup = NULL;
ClUint32T i = 0;
rc = clHandleCheckout(hHandleDB, handle, (void *) &pFuncGroup);
if( CL_OK != rc )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCheckout(): rc[0x %x]", rc));
return rc;
}
for (i = 0; i < pFuncGroup->numFunc; i++)
{
rc = clXdrMarshallArrayClCharT(pFuncGroup->pFuncDescList[i].funcName,
CL_DEBUG_FUNC_NAME_LEN,
outMsgHdl,0);
if (CL_OK != rc)
{
clHandleCheckin(hHandleDB, handle);
return rc;
}
rc = clXdrMarshallArrayClCharT(pFuncGroup->pFuncDescList[i].funcHelp,
CL_DEBUG_FUNC_HELP_LEN,
outMsgHdl,0);
if (CL_OK != rc)
{
clHandleCheckin(hHandleDB, handle);
return rc;
}
}
clHandleCheckin(hHandleDB, handle);
return rc;
}
ClRcT
clLogFileHdlrHandleInfoGet(ClLogFileHandleT hFileHdlr,
ClBoolT *pIsDelete,
ClUint32T *pVersion,
ClUint64T *pStartRec,
ClLogClntFileKeyT **ppFileKey)
{
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;
}
*ppFileKey = pData->pFileKey;
*pIsDelete = pData->isDelete;
*pStartRec = pData->startRead;
*pVersion = pData->operatingLvl;
rc = clHandleCheckin(pClntEoEntry->hClntHandleDB, hFileHdlr);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckin(); rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
static void dispatchWrapperCallback (ClHandleT localHandle,
ClUint32T callbackType,
void* callbackData)
{
SaClmInstanceT *clmInstance = NULL;
ClRcT rc = CL_OK;
/* Handle checkout */
rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
if (rc != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,CL_LOG_CONTEXT_UNSPECIFIED,
"localHandle checkout failed with rc 0x%x\n",rc);
return;
}
switch (callbackType)
{
case CL_GMS_CLIENT_CLUSTER_TRACK_CALLBACK:
/* Invoke the callback */
clmInstance->callbacks.saClmClusterTrackCallback (
((SaClmClusterTrackDataT*)callbackData)->notificationBuffer,
((SaClmClusterTrackDataT*)callbackData)->numberOfMembers,
((SaClmClusterTrackDataT*)callbackData)->rc);
break;
case CL_GMS_CLIENT_CLUSTER_MEMBER_GET_CALLBACK:
/* Invoke the callback */
clmInstance->callbacks.saClmClusterNodeGetCallback (
((SaClmClusterNodeGetDataT*)callbackData)->invocation,
((SaClmClusterNodeGetDataT*)callbackData)->clusterNode,
((SaClmClusterNodeGetDataT*)callbackData)->rc);
break;
}
if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,CL_LOG_CONTEXT_UNSPECIFIED,
"clHandleCheckin failed");
}
return;
}
ClRcT clMsgQueueStatusGet(SaMsgQueueHandleT qHandle,
SaMsgQueueStatusT *pQueueStatus)
{
ClRcT rc, retCode;
ClMsgQueueInfoT *pQInfo;
ClUint32T i = 0;
CL_OSAL_MUTEX_LOCK(&gClLocalQsLock);
rc = clHandleCheckout(gClMsgQDatabase, qHandle, (void **)&pQInfo);
if(rc != CL_OK)
{
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
clLogError("QUE", "STAT", "Failed to checkout the queue handle. error code [0x%x].", rc);
goto error_out;
}
CL_OSAL_MUTEX_LOCK(&pQInfo->qLock);
CL_OSAL_MUTEX_UNLOCK(&gClLocalQsLock);
pQueueStatus->creationFlags = pQInfo->creationFlags;
pQueueStatus->retentionTime = pQInfo->retentionTime;
pQueueStatus->closeTime = pQInfo->closeTime * 1000 ;
for(i = 0; i < CL_MSG_QUEUE_PRIORITIES; ++i)
{
pQueueStatus->saMsgQueueUsage[i].queueSize = pQInfo->size[i];
pQueueStatus->saMsgQueueUsage[i].queueUsed = pQInfo->usedSize[i];
pQueueStatus->saMsgQueueUsage[i].numberOfMessages = pQInfo->numberOfMessages[i];
}
CL_OSAL_MUTEX_UNLOCK(&pQInfo->qLock);
retCode = clHandleCheckin(gClMsgQDatabase, qHandle);
if(retCode != CL_OK)
clLogError("QUE", "STAT", "Failed to check-in the queue handle. error code [0x%x].", retCode);
error_out:
return 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
clDebugFuncInvokeCallback(ClHandleDatabaseHandleT hHandleDB,
ClHandleT handle,
ClPtrT pData)
{
ClRcT rc = CL_OK;
ClDebugFuncGroupT *pFuncGroup = NULL;
ClUint32T i = 0;
ClDebugInvokeCookieT *pCookie = (ClDebugInvokeCookieT *) pData;
rc = clHandleCheckout(hHandleDB, handle, (void *) &pFuncGroup);
if( CL_OK != rc )
{
CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clHandleCheckout(): rc[0x %x]", rc));
return rc;
}
for (i = 0; i < pFuncGroup->numFunc; i++)
{
if (!strcasecmp(pFuncGroup->pFuncDescList[i].funcName,
pCookie->pCommandName))
{
pCookie->pFuncEntry = &(pFuncGroup->pFuncDescList[i]);
clHandleCheckin(hHandleDB, handle);
/*
* Specifically returning NON CL_OK, to quit the container walk as
* already found proper function name
*/
return CL_DBG_INFO_CMD_FOUND;
}
}
clHandleCheckin(hHandleDB, handle);
/*
* If you are returning non CL_OK, container walk will not proceed.
* this will break for mutiple registrations of debug commands.
*/
return rc;
}
ClRcT
clLogClntFileHdlrHandleUpdate(ClLogFileHandleT hFileHdlr,
ClUint32T version,
ClUint64T startRec)
{
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;
}
pData->operatingLvl = version;
pData->startRead = startRec;
rc = clHandleCheckin(pClntEoEntry->hClntHandleDB, hFileHdlr);
if( CL_OK != rc )
{
CL_LOG_DEBUG_ERROR(("clHandleCheckin(); rc[0x %x]", rc));
return rc;
}
CL_LOG_DEBUG_TRACE(("Exit"));
return rc;
}
SaAisErrorT
saClmDispatch (
const SaClmHandleT clmHandle,
const SaDispatchFlagsT dispatchFlags
)
{
ClRcT rc;
ClHandleT localHandle = CL_HANDLE_INVALID_VALUE;
SaClmInstanceT *clmInstance = NULL;
SA_GMS_CHECK_INIT_COUNT();
/* Check the validity of the handle */
localHandle = (ClHandleT)clmHandle;
rc = clHandleCheckout(databaseHandle, localHandle, (void**)&clmInstance);
if (rc != CL_OK)
{
return _aspErrToAisErr(rc);
}
CL_ASSERT(clmInstance != NULL);
/*
* Since dispatch can be blocking and it would return only after
* finalize, we will do the checkin before getting into dispatch
*/
if ((clHandleCheckin(databaseHandle, localHandle)) != CL_OK)
{
clLogError(GMS_LOG_AREA_CLM,CL_LOG_CONTEXT_UNSPECIFIED,
"clHandleCheckin failed");
}
rc = clDispatchCbDispatch(
clmInstance->dispatchHandle,
(ClDispatchFlagsT)dispatchFlags);
return _aspErrToAisErr(rc);
}
