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; }
/*----------------------------------------------------------------------------- * 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 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 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 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; }
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 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); }
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 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; }
/*----------------------------------------------------------------------------- * 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; }
/* * Frees up the handle database specified by databaseHandle. If the handle * database is empty, it frees up the database immediately. Otherwise, * it will mark the database for deletion and free it when the last entry * is deleted. */ ClRcT clHandleDatabaseDestroy(ClHandleDatabaseHandleT databaseHandle) { ClHdlDatabaseT *hdbp = (ClHdlDatabaseT*)databaseHandle; ClRcT ec = CL_OK; ClHandleT handle = 0; hdlDbValidityChk(hdbp); ec = pthread_mutex_lock(&hdbp->mutex); if (ec != 0) { return CL_HANDLE_RC(CL_ERR_MUTEX_ERROR); } clDbgResourceNotify(clDbgHandleGroupResource, clDbgRelease, 0, hdbp, ("Handle database %p released", (ClPtrT) hdbp)); /* * Go thru the list of handles and delete everything, if they have not * been cleaned up properly, through warning message and destroy the * database */ if (hdbp->n_handles_used > 0) /* database is not empty */ { for( handle = 0; handle < hdbp->n_handles; handle++) { if( hdbp->handles[handle].state != HANDLE_STATE_EMPTY ) { /* explicitly making '0' for smooth removal of handles */ hdbp->handles[handle].ref_count = 1; hdbp->handles[handle].state = HANDLE_STATE_PENDINGREMOVAL; ec = pthread_mutex_unlock(&hdbp->mutex); if( ec != 0 ) { /* Who cares about the error code, during shut down */ goto free_exit; } clLogWarning(CL_HDL_AREA, CL_HDL_CTX_DBDESTROY, "Handle [%p:%#llX] has not been cleaned, destroying...", (ClPtrT) hdbp, (handle + 1)); clHandleCheckin(databaseHandle, handle + 1); ec = pthread_mutex_lock(&hdbp->mutex); if( ec != 0 ) { goto free_exit; } } } } /* Explicitly not checking the error code */ pthread_mutex_unlock(&hdbp->mutex); free_exit: if( NULL != hdbp->handles ) { free(hdbp->handles); } hdbp->pValidDb = (void *) CL_HDL_INVALID_COOKIE; clHeapFree(hdbp); return CL_OK; }
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; }
/*---------------------------------------------------------------------------- * 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; }
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; }
/* * 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 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; }
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; }
/*---------------------------------------------------------------------------- * 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 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); }
/*----------------------------------------------------------------------------- * 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; }
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 clDebugDuplicateDetectWalk(ClHandleDatabaseHandleT hHandleDB, ClHandleT handle, ClPtrT pData) { ClRcT rc = CL_OK; ClDebugFuncGroupT *pFuncGroup = NULL; ClUint32T i = 0; ClUint32T j = 0; ClDebugFuncGroupT *pPassedData = (ClDebugFuncGroupT *) 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 < pPassedData->numFunc; i++) { for(j = 0; j < pFuncGroup->numFunc; j++ ) { if (!strcasecmp(pFuncGroup->pFuncDescList[j].funcName, pPassedData->pFuncDescList[i].funcName)) { clHandleCheckin(hHandleDB, handle); CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Duplicate command found : %s", pFuncGroup->pFuncDescList[j].funcName)); return CL_DEBUG_RC(CL_ERR_DUPLICATE); } } } clHandleCheckin(hHandleDB, handle); return CL_OK; }
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 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; }