static ClRcT clLogSvrDsIdMapRecreate(ClUint32T dsId, ClAddrT pBuffer, ClUint32T buffSize, ClPtrT pCookie) { ClRcT rc = CL_OK; ClLogSvrEoDataT *pSvrEoEntry = NULL; ClBufferHandleT inMsg = CL_HANDLE_INVALID_VALUE; CL_LOG_DEBUG_TRACE(("Enter")); CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER)); CL_LOG_PARAM_CHK((CL_LOG_DSID_START != dsId), CL_LOG_RC(CL_ERR_INVALID_PARAMETER)); rc = clLogSvrEoEntryGet(&pSvrEoEntry, NULL); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&inMsg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } rc = clXdrUnmarshallClUint32T(inMsg, &pSvrEoEntry->nextDsId); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]\n", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } CL_LOG_DEBUG_VERBOSE(("DsIdCnt: %d", pSvrEoEntry->nextDsId)); rc = clLogBitmapUnpack(inMsg, pSvrEoEntry->hDsIdMap); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogBitmapUnpack(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clCorAmfMoIdGet(const ClCharT *name, ClAmsEntityTypeT type, ClCorMOIdT *pMoId) { ClAmsEntityT entity = {0}; ClBufferHandleT msg = 0; ClRcT rc = CL_OK; ClVersionT version = {'B', 0x1, 0x1}; ClCharT *data = NULL; ClUint32T dataLen = 0; ClCorObjectHandleT objHandle; if(!name || !pMoId) return CL_COR_SET_RC(CL_ERR_INVALID_PARAMETER); if(!mgmtHandle) { rc = clAmsMgmtInitialize(&mgmtHandle, NULL, &version); if(rc != CL_OK) return rc; } entity.type = type; clNameSet(&entity.name, name); ++entity.name.length; rc = clAmsMgmtEntityUserDataGetKey(mgmtHandle, &entity, &entity.name, &data, &dataLen); if(rc != CL_OK) { clLogError("FLT", "REPAIR", "Entity data get for [%s] returned [%#x]", entity.name.value, rc); goto out_free; } rc = clBufferCreate(&msg); CL_ASSERT(rc == CL_OK); rc = clBufferNBytesWrite(msg, (ClUint8T*)data, dataLen); CL_ASSERT(rc == CL_OK); rc = VDECL_VER(clXdrUnmarshallClCorMOIdT, 4, 0, 0)(msg, pMoId); CL_ASSERT(rc == CL_OK); clBufferDelete(&msg); clLogNotice("COR", "AMF", "MOID for faulty entity [%s] ", entity.name.value); clCorMoIdShow(pMoId); /* * Validating moid */ rc = clCorObjectHandleGet(pMoId, &objHandle); CL_ASSERT(rc == CL_OK); out_free: if(msg) clBufferDelete(&msg); if(data) clHeapFree(data); return rc; }
ClRcT clCpmEventPayLoadExtract(ClEventHandleT eventHandle, ClSizeT eventDataSize, ClCpmEventTypeT cpmEventType, void *payLoad) { ClRcT rc = CL_OK; ClBufferHandleT payLoadMsg = 0; void *eventData = NULL; eventData = clHeapAllocate(eventDataSize); if (eventData == NULL) { clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_SEV_DEBUG, CL_CPM_CLIENT_LIB, CL_LOG_MESSAGE_0_MEMORY_ALLOCATION_FAILED); CPM_CLIENT_CHECK(CL_LOG_SEV_ERROR, ("Unable to malloc \n"), CL_CPM_RC(CL_ERR_NO_MEMORY)); } rc = clEventDataGet (eventHandle, eventData, &eventDataSize); if (rc != CL_OK) { clOsalPrintf("Event Data Get failed. rc=[0x%x]\n", rc); goto failure; } rc = clBufferCreate(&payLoadMsg); CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_BUF_CREATE_ERR, rc, rc, CL_LOG_HANDLE_APP); rc = clBufferNBytesWrite(payLoadMsg, (ClUint8T *)eventData, eventDataSize); CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_BUF_WRITE_ERR, rc, rc, CL_LOG_HANDLE_APP); switch(cpmEventType) { case CL_CPM_COMP_EVENT: rc = VDECL_VER(clXdrUnmarshallClCpmEventPayLoadT, 4, 0, 0)(payLoadMsg, payLoad); CL_CPM_CHECK_0(CL_LOG_SEV_ERROR, CL_LOG_MESSAGE_0_INVALID_BUFFER, rc, CL_LOG_HANDLE_APP); break; case CL_CPM_NODE_EVENT: rc = VDECL_VER(clXdrUnmarshallClCpmEventNodePayLoadT, 4, 0, 0)(payLoadMsg, payLoad); CL_CPM_CHECK_0(CL_LOG_SEV_ERROR, CL_LOG_MESSAGE_0_INVALID_BUFFER, rc, CL_LOG_HANDLE_APP); break; default: clOsalPrintf("Invalid event type received.\n"); goto failure; break; } failure: clBufferDelete(&payLoadMsg); clHeapFree(eventData); return rc; }
static ClRcT clLogMasterFileEntryRecover(ClLogMasterEoDataT *pMasterEoEntry, ClCkptIOVectorElementT *pIoVector, ClUint32T *pErrIndex) { ClRcT rc = CL_OK; ClBufferHandleT hFileEntryBuf = CL_HANDLE_INVALID_VALUE; ClVersionT version = {0}; CL_LOG_DEBUG_TRACE(("Enter: size %lld", pIoVector->readSize)); rc = clBufferCreate(&hFileEntryBuf); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(hFileEntryBuf, (ClUint8T*) pIoVector->dataBuffer, pIoVector->readSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK); return rc; } rc = clXdrUnmarshallClVersionT(hFileEntryBuf, &version); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClVersionT(): rc[%#x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK); return rc; } switch(CL_VERSION_CODE(version.releaseCode, version.majorVersion, version.minorVersion)) { case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION): { rc = fileEntryRecoverBaseVersion(pMasterEoEntry, hFileEntryBuf); } break; default: rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH); clLogError("FILE", "RECOVER", "Version [%d.%d.%d] unsupported", version.releaseCode, version.majorVersion, version.minorVersion); break; } CL_LOG_CLEANUP(clBufferDelete(&hFileEntryBuf), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogMasterCompData2BufferGet(ClLogCompDataT *pCompData, ClUint8T **ppBuffer, ClUint32T *pDataSize) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBufferCreate(&msg); if(CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = VDECL_VER(clXdrMarshallClLogCompDataT, 4, 0, 0)(pCompData, msg, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogMarshallClLogCompDataT(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } rc = clBufferLengthGet(msg, pDataSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferLengthGet(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } *ppBuffer = (ClUint8T*) clHeapCalloc(*pDataSize, sizeof(ClUint8T)); if( NULL == *ppBuffer ) { CL_LOG_DEBUG_ERROR(("clHeapCalloc()")); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return CL_LOG_RC(CL_ERR_NO_MEMORY); } rc = clBufferNBytesRead(msg, *ppBuffer, pDataSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc)); clHeapFree(*ppBuffer); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return CL_OK; }
ClRcT clLogSODsIdMapRecreate(ClUint32T dsId, ClAddrT pBuffer, ClUint32T size, ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; ClLogSOEoDataT *pSoEoEntry = NULL; ClLogSvrCommonEoDataT *pCommonEoData = NULL; CL_LOG_DEBUG_TRACE(("Enter")); CL_LOG_PARAM_CHK((CL_LOG_SO_DSID_START != dsId), CL_LOG_RC(CL_ERR_INVALID_PARAMETER)); CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER)); rc = clLogStreamOwnerEoEntryGet(&pSoEoEntry, &pCommonEoData); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&msg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(msg, (ClUint8T *) pBuffer, size); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesRead(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } rc = clXdrUnmarshallClUint32T(msg, &pSoEoEntry->dsIdCnt); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } CL_LOG_DEBUG_VERBOSE(("dsIdCnt : %d", pSoEoEntry->dsIdCnt)); rc = clLogBitmapUnpack(msg, pSoEoEntry->hDsIdMap); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit: rc[0x %x]", rc)); return rc; }
ClRcT clLogMasterCompTableStateRecover(ClLogMasterEoDataT *pMasterEoEntry, ClUint8T *pBuffer, ClUint32T dataSize) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; ClUint32T versionCode = 0; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBufferCreate(&msg); if(CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(msg, pBuffer, dataSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } rc = clXdrUnmarshallClUint32T(msg, &versionCode); if( CL_OK != rc) { CL_LOG_DEBUG_ERROR(("clXdrUnmarshallClUint32T(): rc[%#x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } switch(versionCode) { case CL_VERSION_CODE(CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION): { rc = compTableStateRecoverBaseVersion(msg); } break; default: clLogError("COMP", "TBL-RECOVER", "Version [%d.%d.%d] is not supported", CL_VERSION_RELEASE(versionCode), CL_VERSION_MAJOR(versionCode), CL_VERSION_MINOR(versionCode)); rc = CL_LOG_RC(CL_ERR_VERSION_MISMATCH); } clBufferDelete(&msg); return rc; }
ClRcT clNameContextCkptDeserializer(ClUint32T dsId, ClAddrT pBuffer, ClUint32T size, ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT inMsg = 0; CL_NAME_DEBUG_TRACE(("Enter")); if( CL_NAME_CONTEXT_GBL_DSID != dsId ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("dsId is not proper\n")); return CL_NS_RC(CL_ERR_INVALID_PARAMETER); } if( NULL == pBuffer ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Passed Value is NULL")); return CL_NS_RC(CL_ERR_NULL_POINTER); } rc = clBufferCreate(&inMsg); if( CL_OK != rc ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clBufferCreate() : rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(inMsg, (ClUint8T *)pBuffer, size); if( CL_OK != rc ) { clBufferDelete(&inMsg); CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clBufferNBytesWrite(): rc[0x %x]", rc)); return rc; } rc = clNameContextCkptNameUnpack(inMsg); if( CL_OK != rc ) { clBufferDelete(&inMsg); return rc; } if( CL_OK != (rc = clBufferDelete(&inMsg)) ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clBufferDelete(): rc[0x %x]", rc)); } CL_NAME_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clNodeCacheLeaderIocSend(ClIocNodeAddressT currentLeader, ClIocAddressT *dstAddr) { ClRcT rc = CL_OK; ClIocSendOptionT sendOption = {CL_IOC_HIGH_PRIORITY,0,0,CL_IOC_PERSISTENT_MSG,200 }; ClIocPhysicalAddressT compAddr = { CL_IOC_BROADCAST_ADDRESS, CL_IOC_CPM_PORT }; ClTimerTimeOutT delay = { 0, 200 }; ClUint32T i = 0; ClBufferHandleT message = 0; ClEoExecutionObjT *eoObj = NULL; ClIocNotificationT notification; memset(¬ification,0,sizeof(ClIocNotificationT)); notification.protoVersion = htonl(CL_IOC_NOTIFICATION_VERSION); notification.id = (ClIocNotificationIdT) htonl(CL_IOC_NODE_ARRIVAL_NOTIFICATION); notification.nodeAddress.iocPhyAddress.nodeAddress = htonl(clIocLocalAddressGet()); notification.nodeAddress.iocPhyAddress.portId = htonl(CL_IOC_GMS_PORT); clEoMyEoObjectGet(&eoObj); while(!eoObj && i++ <= 3) { clEoMyEoObjectGet(&eoObj); clOsalTaskDelay(delay); } if(!eoObj) { clLogWarning("CAP", "ARP", "Could not send current leader update since EO still uninitialized."); return CL_ERR_NOT_INITIALIZED; } clBufferCreate(&message); currentLeader = htonl(currentLeader); rc = clBufferNBytesWrite(message, (ClUint8T *)¬ification, sizeof(ClIocNotificationT)); rc |= clBufferNBytesWrite(message, (ClUint8T*)¤tLeader, sizeof(currentLeader)); if (rc != CL_OK) { clLogError("CAP", "ARP", "clBufferNBytesWrite failed with rc = %#x", rc); clBufferDelete(&message); return rc; } rc = clIocSend(eoObj->commObj, message, CL_IOC_PORT_NOTIFICATION_PROTO, dstAddr, &sendOption); clBufferDelete(&message); return rc; }
/** * Internal function to unpack saved state of a transaction * from checkpoint */ static ClRcT _clTxnServiceCkptTxnUnpack( CL_IN ClUint32T dataSetId, CL_IN ClAddrT pData, CL_IN ClUint32T dataLen, CL_IN ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT txnStateBuf; ClTxnDefnT *pTxnDefn; CL_FUNC_ENTER(); CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("To unpack data-set 0x%x\n", dataSetId)); rc = clBufferCreate(&txnStateBuf); if (CL_OK == rc) { rc = clBufferNBytesWrite(txnStateBuf, (ClUint8T *)pData, dataLen); if (CL_OK == rc) { rc = clTxnStreamTxnCfgInfoUnpack(txnStateBuf, &pTxnDefn); } if ( (CL_OK == rc) && ((pTxnDefn->serverTxnId.txnId + CL_TXN_CKPT_TXN_DATA_SET_ID_OFFSET) == dataSetId) ) { /* Add this definition into txnDefnDb */ rc = clTxnRecoverySessionUpdate (pTxnDefn); } else { if (CL_OK == rc) rc = CL_ERR_INVALID_PARAMETER; } rc = clBufferDelete(&txnStateBuf); } if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to extract transaction definition from data-set[0x%x], rc:0x%x", dataSetId, rc)); rc = CL_GET_ERROR_CODE(rc); } CL_FUNC_EXIT(); return (rc); }
static ClRcT clLogSvrStreamEntryRecreate(ClUint32T dsId, ClAddrT pBuffer, ClUint32T buffSize, ClPtrT cookie) { ClRcT rc = CL_OK; ClLogSvrEoDataT *pSvrEoEntry = NULL; ClBufferHandleT inMsg = CL_HANDLE_INVALID_VALUE; ClLogSvrCommonEoDataT *pSvrCommonEoEntry = NULL; CL_LOG_DEBUG_TRACE(("Enter")); CL_LOG_PARAM_CHK((NULL == pBuffer), CL_LOG_RC(CL_ERR_NULL_POINTER)); rc = clLogSvrEoEntryGet(&pSvrEoEntry, &pSvrCommonEoEntry); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&inMsg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clBufferNBytesWrite(inMsg, (ClUint8T *) pBuffer, buffSize); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } rc = clLogSvrStreamEntryUnpackNAdd(pSvrEoEntry, pSvrCommonEoEntry, inMsg, dsId); if( CL_OK != rc ) { CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); return rc; } CL_LOG_CLEANUP(clBufferDelete(&inMsg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogClntStreamListUnpack(ClUint32T numStreams, ClUint32T buffLen, ClUint8T *pBuffer, ClLogStreamInfoT **ppLogStreams) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; CL_LOG_DEBUG_TRACE(("Enter")); *ppLogStreams = clHeapCalloc(numStreams, sizeof(ClLogStreamInfoT)); if( NULL == *ppLogStreams ) { CL_LOG_DEBUG_ERROR(("clHeapCalloc()")); return CL_LOG_RC(CL_ERR_NO_MEMORY); } rc = clBufferCreate(&msg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); clHeapFree(*ppLogStreams); return rc; } rc = clBufferNBytesWrite(msg, pBuffer, buffLen); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); clHeapFree(*ppLogStreams); return rc; } rc = clLogClntStreamListGet(msg, *ppLogStreams); if( CL_OK != rc ) { CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); clHeapFree(*ppLogStreams); return rc; } CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
/* * Function - clLogStreamOwnerLocalCheckpoint() * - Do Local Checkpointing. * - If the dataset is not yet created, create the dataSet * - Write onto it. */ ClRcT clLogStreamOwnerLocalCheckpoint(ClLogSOEoDataT *pSoEoEntry, SaNameT *pStreamName, SaNameT *pStreamScopeNode, ClLogStreamOwnerDataT *pStreamOwnerData) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; ClLogSvrCommonEoDataT *pCommonEoData = NULL; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&msg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clLogStreamOwnerEntryPack(pStreamName, pStreamScopeNode, pStreamOwnerData, msg); if( CL_OK != rc ) { CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); return rc; } rc = clCkptLibraryCkptDataSetWrite(pCommonEoData->hLibCkpt, (SaNameT *) &gSOLocalCkptName, pStreamOwnerData->dsId, msg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(( "clCkptLibraryCkptDataSetWrite(): rc[0x %x]", rc)); } CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
/** * Internal Function - extracts transaction-service state from checkpoint data-set */ static ClRcT _clTxnServiceCkptAppStateUnpack( CL_IN ClUint32T dataSetId, CL_IN ClAddrT pData, CL_IN ClUint32T dataLen, CL_IN ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT txnStateMsgBuf; ClUint32T txnIdCounter; CL_FUNC_ENTER(); CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("To restore state of transaction-service\n")); rc = clBufferCreate(&txnStateMsgBuf); if (CL_OK == rc) { rc = clBufferNBytesWrite(txnStateMsgBuf, (ClUint8T *) pData, dataLen); if (CL_OK == rc) { rc = clXdrUnmarshallClUint32T(txnStateMsgBuf, &txnIdCounter); } if (CL_OK == rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Updating txnId Counter to 0x%x", txnIdCounter)); clTxnServiceCfg->txnIdCounter = txnIdCounter; } if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to restore transaction service state. Could result in inconsistent operation. rc:0x%x", rc)); rc = CL_GET_ERROR_CODE(rc); } rc = clBufferDelete(&txnStateMsgBuf); } CL_FUNC_EXIT(); return (rc); }
static ClRcT amsMgmtCCBBatchBufferInitialize(ClAmsMgmtCCBBatchT *batch) { ClRcT rc = CL_OK; if(batch->buffer) { rc |= clBufferDelete(&batch->buffer); if(rc != CL_OK) goto out; batch->buffer = 0; } rc |= clBufferCreate(&batch->buffer); if(rc != CL_OK) goto out; batch->items = 0; batch->version = CL_VERSION_CURRENT; clNodeCacheMinVersionGet(NULL, &batch->version); rc = clXdrMarshallClUint32T(&batch->version, batch->buffer, 0); if(rc != CL_OK) { goto out_free; } rc = clBufferWriteOffsetGet(batch->buffer, &batch->itemsOffset); if(rc != CL_OK) { goto out_free; } rc = clXdrMarshallClUint32T(&batch->items, batch->buffer, 0); if(rc != CL_OK) { goto out_free; } goto out; out_free: clBufferDelete(&batch->buffer); batch->buffer = 0; out: return rc; }
ClRcT clLogSOStreamEntryRecreate(ClUint32T dsId, ClAddrT pBuffer, ClUint32T size, ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT msg = CL_HANDLE_INVALID_VALUE; ClLogSvrCommonEoDataT *pCommonEoData = NULL; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData); if( CL_OK != rc ) { return rc; } rc = clBufferCreate(&msg); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate()")); return rc; } rc = clBufferNBytesWrite(msg, (ClUint8T *) pBuffer, size); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferNBytesWrite(): rc[0x %x]", rc)); clBufferDelete(&msg); return rc; } rc = clLogSOStreamEntryUnpackNAdd(pCommonEoData, msg); CL_LOG_CLEANUP(clBufferDelete(&msg), CL_OK); if(CL_GET_ERROR_CODE(rc) == CL_ERR_DUPLICATE) rc = CL_OK; CL_LOG_DEBUG_TRACE(("Exit: rc[0x %x]", rc)); return rc; }
/** * Deserializer function for transaction state */ static ClRcT _clTxnServiceCkptTxnStateUnpack( CL_IN ClUint32T dataSetId, CL_IN ClAddrT pData, CL_IN ClUint32T dataLen, CL_IN ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT msgHandle; CL_FUNC_ENTER(); /* - If, from the restored txn-log, the txn is in intermediate state, add it to pending-recovery-list else, discard */ rc = clBufferCreate (&msgHandle); if (CL_OK == rc) { rc = clBufferNBytesWrite(msgHandle, (ClUint8T *)pData, dataLen); if (CL_OK == rc) { rc = clTxnRecoveryLogUnpack(msgHandle); } } if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to extract transaction logs from ckpt. rc:0x%x", rc)); } CL_FUNC_EXIT(); return (rc); }
ClRcT corAmfObjectCreate(ClUint32T entityId, ClAmsEntityT *entity, ClCorMOIdT *pMoId) { ClRcT rc = CL_OK; ClBufferHandleT msg = 0; ClUint32T moIdBufferLen = 0; ClUint8T *moIdBuffer = NULL; ClCorMOIdT tempMoId; ClCorMOServiceIdT svcId = CL_COR_SVC_ID_PROVISIONING_MANAGEMENT; ClCorAttributeValueListT attrValueList = {0}; if(!gClAmfMibLoaded) svcId = CL_COR_SVC_ID_AMF_MANAGEMENT; /* *Faster than a clone */ memcpy(&tempMoId, pMoId, sizeof(tempMoId)); rc = clCorObjectCreate(&sessionId, &tempMoId, NULL); if(rc != CL_OK) { clLogError("COR", "AMF", "COR MO object create for entity [%s] returned [%#x]", entity->name.value, rc); goto out; } rc = clCorMoIdServiceSet(&tempMoId, svcId); CL_ASSERT(rc == CL_OK); rc = corAmfEntityAttributeListGet(&entityId, entity, NULL, &attrValueList); if(rc != CL_OK) goto out; rc = clCorObjectCreateAndSet(&sessionId, &tempMoId, &attrValueList, NULL); if(rc != CL_OK) { clLogError("COR", "AMF", "COR MSO object create for entity [%s] returned [%#x]", entity->name.value, rc); goto out; } rc = clBufferCreate(&msg); CL_ASSERT(rc == CL_OK); rc = VDECL_VER(clXdrMarshallClCorMOIdT, 4, 0, 0)((ClUint8T*)&tempMoId, msg, 0); CL_ASSERT(rc == CL_OK); rc = clBufferLengthGet(msg, &moIdBufferLen); CL_ASSERT(rc == CL_OK); rc = clBufferFlatten(msg, &moIdBuffer); CL_ASSERT(rc == CL_OK); /* * Now store this moid buffer into the entity user area for the entity key. */ rc = clAmsMgmtEntityUserDataSetKey(mgmtHandle, entity, &entity->name, (ClCharT*)moIdBuffer, moIdBufferLen); if(rc != CL_OK) { clLogError("COR", "AMF", "Entity user data set for [%s] returned [%#x]", entity->name.value, rc); goto out; } out: if(attrValueList.pAttributeValue) clHeapFree(attrValueList.pAttributeValue); if(moIdBuffer) clHeapFree(moIdBuffer); if(msg) clBufferDelete(&msg); return rc; }
ClRcT _cpmClusterConfigList(ClInt32T argc, ClCharT **retStr) { ClCpmLT *cpmL = NULL; ClRcT rc = CL_OK; ClCntNodeHandleT hNode = 0; ClUint32T cpmLCount = 0; ClCharT tempStr[256]; ClCharT *tmpStr = NULL; ClBufferHandleT message; rc = clBufferCreate(&message); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to create message \n"), rc); if (argc != ONE_ARGUMENT) { sprintf(tempStr, "Usage: clusterList"); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc); goto done; } /* * Print the local stuff first */ sprintf(tempStr, "%s\n", "nodeName | status | iocAddress | iocPort "); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); sprintf(tempStr, "%s\n", "-----------------------------------------------------------------------"); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); /* * Now even the CPM/G information is stored in the list. * So no need of printing the above information. */ #if 0 if (gpClCpm->pCpmLocalInfo->status == CL_CPM_EO_DEAD) sprintf(tempStr, "%10s | DEAD | %8d | 0x%x\n", gpClCpm->pCpmLocalInfo->nodeName, gpClCpm->pCpmLocalInfo->cpmAddress.nodeAddress, gpClCpm->pCpmLocalInfo->cpmAddress.portId); else sprintf(tempStr, "%10s | ALIVE | %8d | 0x%x\n", gpClCpm->pCpmLocalInfo->nodeName, gpClCpm->pCpmLocalInfo->cpmAddress.nodeAddress, gpClCpm->pCpmLocalInfo->cpmAddress.portId); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); #endif /*_cpmListAllSU();*/ /* * Get all the CPMs one by one and delete the stuff. */ rc = clCntFirstNodeGet(gpClCpm->cpmTable, &hNode); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get first cpmTable Node %x\n", rc), rc); rc = clCntNodeUserDataGet(gpClCpm->cpmTable, hNode, (ClCntDataHandleT *) &cpmL); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get container Node data %x\n", rc), rc); cpmLCount = gpClCpm->noOfCpm; while (cpmLCount) { if (cpmL->pCpmLocalInfo != NULL) { if (cpmL->pCpmLocalInfo->status == CL_CPM_EO_DEAD) { sprintf(tempStr, "%10s | DEAD | %8d | 0x%x\n", cpmL->nodeName, cpmL->pCpmLocalInfo->cpmAddress.nodeAddress, cpmL->pCpmLocalInfo->cpmAddress.portId); } else { sprintf(tempStr, "%10s | ALIVE | %8d | 0x%x\n", cpmL->nodeName, cpmL->pCpmLocalInfo->cpmAddress.nodeAddress, cpmL->pCpmLocalInfo->cpmAddress.portId); } rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); } else { sprintf(tempStr, "%10s \n", cpmL->nodeName); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); } #if 0 rc = clCntFirstNodeGet(cpmL->suTable, &hSU); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get first su Node in cpmL %x\n", rc), rc); if (cpmL->pCpmLocalInfo != NULL) clOsalPrintf("%10s | %8d | %8d | 0x%8x| 0x%8x \n", cpmL->pCpmLocalInfo->nodeName, cpmL->pCpmLocalInfo->status, cpmL->pCpmLocalInfo->nodeId, cpmL->pCpmLocalInfo->cpmAddress.nodeAddress, cpmL->pCpmLocalInfo->cpmAddress.portId); else clOsalPrintf("%10s \n", cpmL->nodeName); suCount = cpmL->noOfsu; while (suCount) { rc = clCntNodeUserDataGet(cpmL->suTable, hSU, (ClCntDataHandleT *) &su); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get first container su Node data %x\n", rc), rc); clOsalPrintf("\t %10s |%15s |%11s |%16s \n", su->suName, _cpmPresenceStateNameGet(su->suPresenceState), _cpmOperStateNameGet(su->suOperState), _cpmReadinessStateNameGet(su->suReadinessState)); tempCompRef = su->suCompList; while (tempCompRef != NULL) { clOsalPrintf ("-----------------------------------------------------------------------\n"); clOsalPrintf("\t\t%10s %14d |%15s |%11s |%16s \n", tempCompRef->ref->compConfig->compName, tempCompRef->ref->compRestartCount, _cpmPresenceStateNameGet(tempCompRef->ref-> compPresenceState), _cpmOperStateNameGet(tempCompRef->ref-> compOperState), _cpmReadinessStateNameGet(tempCompRef->ref-> compReadinessState)); tempCompRef = tempCompRef->pNext; } suCount--; if (suCount) { rc = clCntNextNodeGet(cpmL->suTable, hSU, &hSU); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node Data \n"), rc); } } #endif sprintf(tempStr, "%s", "-----------------------------------------------------------------------\n"); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); cpmLCount--; if (cpmLCount) { rc = clCntNextNodeGet(gpClCpm->cpmTable, hNode, &hNode); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node Data \n"), rc); rc = clCntNodeUserDataGet(gpClCpm->cpmTable, hNode, (ClCntDataHandleT *) &cpmL); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to get container Node data %d\n", rc), rc); } } /* * Bug 4986 : * Moved the code to NULL terminate the string * below the done: label, so that the usage string * written to the buffer is also NULL terminated. */ done: /* * NULL terminate the string */ sprintf(tempStr, "%s", "\0"); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, 1); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); rc = clBufferFlatten(message, (ClUint8T **) &tmpStr); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to flatten message \n"), rc); *retStr = tmpStr; clBufferDelete(&message); return rc; failure: clBufferDelete(&message); return rc; }
ClRcT _clCpmComponentListAll(ClInt32T argc, ClCharT **retStr) { ClCntNodeHandleT hNode = 0; ClCpmComponentT *comp = NULL; ClUint32T rc = CL_OK, count; ClCpmEOListNodeT *eoList = NULL; ClCharT state[10] = "\0"; ClCharT status[10] = "\0"; ClCharT tempStr[256]; ClCharT *tmpStr = NULL; ClBufferHandleT message; ClCharT cpmCompName[CL_MAX_NAME_LENGTH] = {0}; rc = clBufferCreate(&message); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to create message %x\n", rc), rc); if (argc != ONE_ARGUMENT) { rc = clBufferNBytesWrite(message, (ClUint8T *) STR_AND_SIZE("Usage: compList")); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc); rc = CL_CPM_RC(CL_ERR_INVALID_PARAMETER); goto done; } count = gpClCpm->noOfComponent; snprintf(cpmCompName, CL_MAX_NAME_LENGTH-1, "%s_%s", CL_CPM_COMPONENT_NAME, gpClCpm->pCpmLocalInfo->nodeName); rc = clCntFirstNodeGet(gpClCpm->compTable, &hNode); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get First component \n"), rc); rc = clBufferNBytesWrite(message, (ClUint8T *) STR_AND_SIZE("################### List Of Components ########################\n")); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode,(ClCntDataHandleT *) &comp); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node Data \n"), rc); rc = clBufferNBytesWrite(message, STR_AND_SIZE(" CompName | compId | eoPort | PID | RestartCount | PresenceState\n")); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); rc = clBufferNBytesWrite(message, STR_AND_SIZE("\t\t ID | Port | Name | Health |Recv Threads \n")); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); rc = clBufferNBytesWrite(message, STR_AND_SIZE("========================================================================================\n")); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); while (count) { if (strcmp(comp->compConfig->compName, cpmCompName)!=0) /* Skip if it is the CPM component */ { eoList = comp->eoHandle; int len = sprintf(tempStr, "%30s| 0x%x | 0x%x |%8d |%14d |%15s\n", comp->compConfig->compName, comp->compId, comp->eoPort, comp->processId, comp->compRestartCount, _cpmPresenceStateNameGet(comp->compPresenceState)); if (comp->compConfig->compProperty != CL_AMS_COMP_PROPERTY_SA_AWARE) { if(!eoList || !eoList->eoptr) { len += snprintf(tempStr + len, sizeof(tempStr) - len, "\t\t 0x%x | 0x%x |%10s |%10s |%04d \n", 0, 0, "-", "-", 0); } } rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr,len); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); while (eoList != NULL && eoList->eoptr != NULL) { compMgrStateStatusGet(eoList->status, eoList->eoptr->state, status, sizeof(status), state, sizeof(state)); int noOfThreads = (eoList->eoptr->appType == CL_EO_USE_THREAD_FOR_RECV) ? eoList->eoptr->noOfThreads + 1: eoList->eoptr->noOfThreads; int len = sprintf(tempStr, "\t\t 0x%llx | 0x%x |%10s |%10s |%04d \n", eoList->eoptr->eoID, eoList->eoptr->eoPort, eoList->eoptr->name, status, noOfThreads); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, len); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); eoList = eoList->pNext; } rc = clBufferNBytesWrite(message, STR_AND_SIZE("-----------------------------------------------------------------------------------------\n")); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); } count--; if (count) { rc = clCntNextNodeGet(gpClCpm->compTable, hNode, &hNode); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to Get Node Data %x\n", rc), rc); rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode, (ClCntDataHandleT *) &comp); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to Get Node user Data %x\n", rc), rc); } } /* * Bug 4986 : * Moved the code to NULL terminate the string * below the done: label, so that the usage string * written to the buffer is also NULL terminated. */ done: /* * NULL terminate the string */ rc = clBufferNBytesWrite(message, (ClUint8T *) "\0", 1); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); rc = clBufferFlatten(message, (ClUint8T **) &tmpStr); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to flatten the message \n"), rc); *retStr = tmpStr; clBufferDelete(&message); return rc; failure: clBufferDelete(&message); return rc; }
ClRcT clCpmExecutionObjectListShow(ClInt32T argc, ClIocNodeAddressT compAddr, ClUint32T flag, ClEoIdT eoId, ClCharT **retStr) { /* * ClCpmEOListNodeT* ptr = gpClCpm->eoList; */ ClCpmEOListNodeT *ptr = NULL; ClCharT name[32] = "\0"; ClCharT state[10] = "\0"; ClCharT status[10] = "\0"; ClUint32T compCount = 0; ClCntNodeHandleT hNode = 0; ClCpmComponentT *comp = NULL; ClRcT rc = CL_OK; ClCharT tempStr[256]; ClCharT *tmpStr = NULL; ClBufferHandleT message = 0; rc = clBufferCreate(&message); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to create message %x\n", rc), rc); if (argc != ONE_ARGUMENT) { sprintf(tempStr, "Usage: EOShow"); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc); goto done; } sprintf(tempStr, "\n ID | Port | Name | Health | EO State | Recv Threads "); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc); sprintf(tempStr, "\n ===================================================================== "); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to write message %x\n", rc), rc); /* * take the semaphore */ if ((rc = clOsalMutexLock(gpClCpm->eoListMutex)) != CL_OK) CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Could not get Lock successfully------\n")); rc = clCntFirstNodeGet(gpClCpm->compTable, &hNode); CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("Unable to Get First component \n"), rc); rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode, (ClCntDataHandleT *) &comp); CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("Unable to Get Node Data \n"), rc); compCount = gpClCpm->noOfComponent; while (compCount != 0) { ptr = comp->eoHandle; if (flag == 0) { while (ptr != NULL && ptr->eoptr != NULL) { strcpy(name, ptr->eoptr->name); /* * Obtain the state and status in string format */ compMgrStateStatusGet(ptr->status, ptr->eoptr->state, status, sizeof(status), state, sizeof(state)); if (ptr->eoptr->appType == CL_EO_USE_THREAD_FOR_RECV) sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d ", ptr->eoptr->eoID, ptr->eoptr->eoPort, name, status, state, (ptr->eoptr->noOfThreads + 1)); else sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d ", ptr->eoptr->eoID, ptr->eoptr->eoPort, name, status, state, ptr->eoptr->noOfThreads); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); ptr = ptr->pNext; } } else { while (ptr != NULL && ptr->eoptr != NULL) { if (ptr->eoptr->eoID == eoId) { /* * obtain the state and status in string format */ compMgrStateStatusGet(ptr->status, ptr->eoptr->state, status, sizeof(status), state, sizeof(state)); strcpy(name, ptr->eoptr->name); if (ptr->eoptr->appType == CL_EO_USE_THREAD_FOR_RECV) sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d | ", ptr->eoptr->eoID, ptr->eoptr->eoPort, name, status, state, ptr->eoptr->noOfThreads + 1); else sprintf(tempStr, "\n 0x%llx| 0x%x | %10s | %10s | %10s | %04d | ", ptr->eoptr->eoID, ptr->eoptr->eoPort, name, status, state, ptr->eoptr->noOfThreads); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, strlen(tempStr)); CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); break; } ptr = ptr->pNext; } #if 0 if (ptr == NULL) CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("EOID not found\n")); #endif } compCount--; if (compCount) { rc = clCntNextNodeGet(gpClCpm->compTable, hNode, &hNode); CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node Data \n"), rc); rc = clCntNodeUserDataGet(gpClCpm->compTable, hNode, (ClCntDataHandleT *) &comp); CL_CPM_LOCK_CHECK(CL_DEBUG_ERROR, ("\n Unable to Get Node Data \n"), rc); } } /* * Release the semaphore */ rc = clOsalMutexUnlock(gpClCpm->eoListMutex); CL_CPM_CHECK(CL_DEBUG_ERROR, ("COMP_MGR: Could not UnLock successfully------\n"), rc); /* * Bug 4986 : * Moved the code to NULL terminate the string * below the done: label, so that the usage string * written to the buffer is also NULL terminated. */ done: /* * NULL terminate the string */ sprintf(tempStr, "%s", "\0"); rc = clBufferNBytesWrite(message, (ClUint8T *) tempStr, 1); CL_CPM_CHECK(CL_DEBUG_ERROR, ("\n Unable to write message \n"), rc); /* * Construct the return buffer */ rc = clBufferFlatten(message, (ClUint8T **) &tmpStr); CL_CPM_CHECK(CL_DEBUG_ERROR, ("Unable to flatten the message \n"), rc); *retStr = tmpStr; clBufferDelete(&message); return (CL_OK); withlock: /* * Release the semaphore */ rc = clOsalMutexUnlock(gpClCpm->eoListMutex); CL_CPM_CHECK(CL_DEBUG_ERROR, ("COMP_MGR: Could not UnLock successfully------\n"), rc); failure: clBufferDelete(&message); return rc; }
ClRcT _ckptClientInfoGetClientSync_6_0_0(CL_IN ClIdlHandleT handle, CL_IN ClHandleT ckptHdl, CL_OUT ClCkptClientInfoListT_4_0_0* pClientInfoList) { ClRcT rc = CL_OK; ClVersionT funcVer = {6, 0, 0}; ClUint32T funcNo = CL_EO_GET_FULL_FN_NUM(CL_EO_NATIVE_COMPONENT_TABLE_ID, 51); ClBufferHandleT inMsgHdl = 0; ClBufferHandleT outMsgHdl = 0; ClIocAddressT address = {{0}}; ClIdlHandleObjT* pHandleObj = NULL; ClUint32T tempFlags = 0; rc = clHandleCheckout(gIdlClnt.idlDbHdl,handle,(void **)&pHandleObj); if( rc != CL_OK ) { return rc ; } if (CL_IDL_ADDRESSTYPE_IOC == pHandleObj->address.addressType) { address = pHandleObj->address.address.iocAddress; } else if (CL_IDL_ADDRESSTYPE_NAME == pHandleObj->address.addressType) { rc = clNameToObjectReferenceGet(&(pHandleObj->address.address.nameAddress.name), pHandleObj->address.address.nameAddress.attrCount, pHandleObj->address.address.nameAddress.attr, pHandleObj->address.address.nameAddress.contextCookie, (ClUint64T*)&address); if (CL_OK != rc) { return rc; } } else { return CL_IDL_RC(CL_ERR_INVALID_PARAMETER); } rc = clBufferCreate(&inMsgHdl); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClHandleT(&(ckptHdl), inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clBufferCreate(&outMsgHdl); if (CL_OK != rc) { return rc; } tempFlags |= pHandleObj->flags | (CL_RMD_CALL_NON_PERSISTENT | CL_RMD_CALL_NEED_REPLY); tempFlags &= ~CL_RMD_CALL_ASYNC; rc = clRmdWithMsgVer(address, &funcVer, funcNo, inMsgHdl, outMsgHdl, tempFlags, &(pHandleObj->options), NULL); if(CL_OK != rc) { clBufferDelete(&outMsgHdl); return rc; } rc = clXdrUnmarshallClCkptClientInfoListT_4_0_0( outMsgHdl, pClientInfoList); if (CL_OK != rc) { return rc; } clBufferDelete(&outMsgHdl); rc = clHandleCheckin(gIdlClnt.idlDbHdl,handle); return rc; }
ClRcT clCkptDeputyMasterInfoSyncupClientSync_4_0_0(CL_IN ClIdlHandleT handle, CL_INOUT ClVersionT* pVersion, CL_OUT ClUint32T* numOfCkpts, CL_OUT CkptXlationDBEntryT_4_0_0** pXlationInfo, CL_OUT CkptMasterDBInfoIDLT_4_0_0* pMasterInfo, CL_OUT ClUint32T* mastHdlCount, CL_OUT CkptMasterDBEntryIDLT_4_0_0** pMasterDBInfo, CL_OUT ClUint32T* peerCount, CL_OUT CkptPeerListInfoT_4_0_0** pPeerListInfo, CL_OUT ClUint32T* clientHdlCount, CL_OUT CkptMasterDBClientInfoT_4_0_0** pClientDBInfo) { ClRcT rc = CL_OK; ClVersionT funcVer = {4, 0, 0}; ClUint32T funcNo = CL_EO_GET_FULL_FN_NUM(CL_EO_NATIVE_COMPONENT_TABLE_ID, 18); ClBufferHandleT inMsgHdl = 0; ClBufferHandleT outMsgHdl = 0; ClIocAddressT address = {{0}}; ClIdlHandleObjT* pHandleObj = NULL; ClUint32T tempFlags = 0; rc = clHandleCheckout(gIdlClnt.idlDbHdl,handle,(void **)&pHandleObj); if( rc != CL_OK ) { return rc ; } if (CL_IDL_ADDRESSTYPE_IOC == pHandleObj->address.addressType) { address = pHandleObj->address.address.iocAddress; } else if (CL_IDL_ADDRESSTYPE_NAME == pHandleObj->address.addressType) { rc = clNameToObjectReferenceGet(&(pHandleObj->address.address.nameAddress.name), pHandleObj->address.address.nameAddress.attrCount, pHandleObj->address.address.nameAddress.attr, pHandleObj->address.address.nameAddress.contextCookie, (ClUint64T*)&address); if (CL_OK != rc) { return rc; } } else { return CL_IDL_RC(CL_ERR_INVALID_PARAMETER); } rc = clBufferCreate(&inMsgHdl); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClVersionT(pVersion, inMsgHdl, 1); if (CL_OK != rc) { return rc; } rc = clBufferCreate(&outMsgHdl); if (CL_OK != rc) { return rc; } tempFlags |= pHandleObj->flags | (CL_RMD_CALL_NON_PERSISTENT | CL_RMD_CALL_NEED_REPLY); tempFlags &= ~CL_RMD_CALL_ASYNC; rc = clRmdWithMsgVer(address, &funcVer, funcNo, inMsgHdl, outMsgHdl, tempFlags, &(pHandleObj->options), NULL); if(CL_OK != rc) { clBufferDelete(&outMsgHdl); return rc; } rc = clXdrUnmarshallClVersionT( outMsgHdl, pVersion); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallClUint32T( outMsgHdl, numOfCkpts); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallCkptMasterDBInfoIDLT_4_0_0( outMsgHdl, pMasterInfo); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallClUint32T( outMsgHdl, mastHdlCount); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallClUint32T( outMsgHdl, peerCount); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallClUint32T( outMsgHdl, clientHdlCount); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallPtrCkptXlationDBEntryT_4_0_0( outMsgHdl, (void **)pXlationInfo, *numOfCkpts); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallPtrCkptMasterDBEntryIDLT_4_0_0( outMsgHdl, (void **)pMasterDBInfo, *mastHdlCount); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallPtrCkptPeerListInfoT_4_0_0( outMsgHdl, (void **)pPeerListInfo, *peerCount); if (CL_OK != rc) { return rc; } rc = clXdrUnmarshallPtrCkptMasterDBClientInfoT_4_0_0( outMsgHdl, (void **)pClientDBInfo, *clientHdlCount); if (CL_OK != rc) { return rc; } clBufferDelete(&outMsgHdl); rc = clHandleCheckin(gIdlClnt.idlDbHdl,handle); return rc; }
/** * Serializer function for transaction state */ static ClRcT _clTxnServiceCkptTxnStatePack( CL_IN ClUint32T dataSetId, CL_OUT ClAddrT *ppData, CL_OUT ClUint32T *pDataLen, CL_IN ClPtrT cookie) { ClRcT rc = CL_OK; ClTxnTransactionIdT *pTxnId; ClBufferHandleT msgHandle; ClUint32T msgLen; CL_FUNC_ENTER(); pTxnId = (ClTxnTransactionIdT *) cookie; CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("To checkpoint recovery-log of txn 0x%x:0x%x", pTxnId->txnMgrNodeAddress, pTxnId->txnId)); rc = clBufferCreate(&msgHandle); if (CL_OK == rc) { rc = clTxnRecoveryLogPack(pTxnId, msgHandle); *ppData = NULL; *pDataLen = 0; if (CL_OK == rc) { /* Copy the state-information from message-buffer to ppData */ rc = clBufferLengthGet(msgHandle, &msgLen); } if (CL_OK == rc) { *pDataLen = msgLen; *ppData = (ClInt8T *) clHeapAllocate(msgLen); if ( *ppData == NULL ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to allocate memory")); rc = CL_ERR_NO_MEMORY; } } if (CL_OK == rc) { rc = clBufferNBytesRead(msgHandle, (ClUint8T *) *ppData, &msgLen); if (CL_OK != rc) { clHeapFree(*ppData); *pDataLen = 0x0; CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to pack/serialize txn-defn[0x%x:0x%x] for ckpt. rc:0x%x", pTxnId->txnMgrNodeAddress, pTxnId->txnId, rc)); rc = CL_GET_ERROR_CODE(rc); } } rc = clBufferDelete(&msgHandle); } CL_FUNC_EXIT(); return (rc); }
ClRcT clMsgGroupDatabaseUpdateClientSync_4_0_0(CL_IN ClIdlHandleT handle, CL_IN ClMsgSyncActionT_4_0_0 syncupType, CL_IN ClNameT* pGroupName, CL_IN SaMsgQueueGroupPolicyT_4_0_0 policy, CL_IN ClIocPhysicalAddressT_4_0_0 qGroupAddress, CL_IN ClUint16T updateCkpt) { ClRcT rc = CL_OK; ClVersionT funcVer = {4, 0, 0}; ClUint32T funcNo = CL_EO_GET_FULL_FN_NUM(CL_EO_NATIVE_COMPONENT_TABLE_ID, 13); ClBufferHandleT inMsgHdl = 0; ClBufferHandleT outMsgHdl = 0; ClIocAddressT address = {{0}}; ClIdlHandleObjT* pHandleObj = NULL; ClUint32T tempFlags = 0; rc = clHandleCheckout(gIdlClnt.idlDbHdl,handle,(void **)&pHandleObj); if( rc != CL_OK ) { return rc ; } if (CL_IDL_ADDRESSTYPE_IOC == pHandleObj->address.addressType) { address = pHandleObj->address.address.iocAddress; } else if (CL_IDL_ADDRESSTYPE_NAME == pHandleObj->address.addressType) { rc = clNameToObjectReferenceGet(&(pHandleObj->address.address.nameAddress.name), pHandleObj->address.address.nameAddress.attrCount, pHandleObj->address.address.nameAddress.attr, pHandleObj->address.address.nameAddress.contextCookie, (ClUint64T*)&address); if (CL_OK != rc) { return rc; } } else { return CL_IDL_RC(CL_ERR_INVALID_PARAMETER); } rc = clBufferCreate(&inMsgHdl); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClMsgSyncActionT_4_0_0(&(syncupType), inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClNameT(pGroupName, inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallSaMsgQueueGroupPolicyT_4_0_0(&(policy), inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClIocPhysicalAddressT_4_0_0(&(qGroupAddress), inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClUint16T(&(updateCkpt), inMsgHdl, 0); if (CL_OK != rc) { return rc; } tempFlags |= pHandleObj->flags | (CL_RMD_CALL_NON_PERSISTENT); tempFlags &= ~CL_RMD_CALL_ASYNC; rc = clRmdWithMsgVer(address, &funcVer, funcNo, inMsgHdl, outMsgHdl, tempFlags, &(pHandleObj->options), NULL); if(CL_OK != rc) { return rc; } rc = clHandleCheckin(gIdlClnt.idlDbHdl,handle); return rc; }
/** * Internal function to pack/prepare state oa given transaction */ static ClRcT _clTxnServiceCkptTxnPack( CL_IN ClUint32T dataSetId, CL_OUT ClAddrT *ppData, CL_OUT ClUint32T *pDataLen, CL_IN ClPtrT cookie) { ClRcT rc = CL_OK; ClTxnDefnT *pTxnDefn; ClBufferHandleT txnStateBuf; ClUint32T msgLen; CL_FUNC_ENTER(); pTxnDefn = (ClTxnDefnT *) cookie; if (pTxnDefn == NULL) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Null argument")); CL_FUNC_EXIT(); return (CL_ERR_NULL_POINTER); } CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Packing for data-set 0x%x for txn[0x%x:0x%x]", dataSetId, pTxnDefn->serverTxnId.txnMgrNodeAddress, pTxnDefn->serverTxnId.txnId)); /* Validate between dataSetId and txn-Id */ #if 0 if ( (dataSetId - CL_TXN_CKPT_TXN_DATA_SET_ID_OFFSET) != pTxnId->txnId) { CL_TXN_RETURN_RC(CL_ERR_INVALID_PARAMETER, ("Invalid data-set(0x%x) for transaction-id(0x%x)\n", dataSetId, pTxnId->txnId)); } #endif rc = clBufferCreate (&txnStateBuf); if (CL_OK == rc) { rc = clTxnStreamTxnCfgInfoPack (pTxnDefn, txnStateBuf); *ppData = NULL; *pDataLen = 0; if (CL_OK == rc) { /* Copy the state-information from message-buffer to ppData */ rc = clBufferLengthGet(txnStateBuf, &msgLen); } if (CL_OK == rc) { *pDataLen = msgLen; *ppData = (ClInt8T *) clHeapAllocate(msgLen); if ( *ppData == NULL ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to allocate memory")); rc = CL_ERR_NO_MEMORY; } } if (CL_OK == rc) { rc = clBufferNBytesRead(txnStateBuf, (ClUint8T *) *ppData, &msgLen); if (CL_OK != rc) { clHeapFree(*ppData); *pDataLen = 0x0; CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to pack/serialize txn-defn[0x%x:0x%x] for ckpt. rc:0x%x", pTxnDefn->serverTxnId.txnMgrNodeAddress, pTxnDefn->serverTxnId.txnId, rc)); rc = CL_GET_ERROR_CODE(rc); } } rc = clBufferDelete(&txnStateBuf); } CL_FUNC_EXIT(); return (rc); }
/** * Internal Function - used to pack/prepare data-set for checkpointing * transaction-service */ static ClRcT _clTxnServiceCkptAppStatePack( CL_IN ClUint32T dataSetId, CL_OUT ClAddrT *ppData, CL_OUT ClUint32T *pDataLen, CL_IN ClPtrT cookie) { ClRcT rc = CL_OK; ClBufferHandleT txnSrvcStateBuff; CL_FUNC_ENTER(); /* Walk through the list of transactions available in activeTxnMap. For each transaction, call clTxnStreamTxnCfgInfoPack() For the received message-buffer, append it to the master message-buffer. */ if ( (ppData == NULL) || (pDataLen == NULL) ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Null arguements")); CL_FUNC_EXIT(); return CL_ERR_NULL_POINTER; } rc = clBufferCreate (&txnSrvcStateBuff); if (CL_OK == rc) { clXdrMarshallClUint32T( &(clTxnServiceCfg->txnIdCounter), txnSrvcStateBuff, 0); /* Copy to buffer */ *pDataLen = 0; *ppData = NULL; if (CL_OK == rc) { ClUint32T ckptDataLen; rc = clBufferLengthGet(txnSrvcStateBuff, &ckptDataLen); if ( (CL_OK == rc) && ( ckptDataLen != 0) ) { *ppData = (ClAddrT) clHeapAllocate(ckptDataLen); *pDataLen = ckptDataLen; if ( *ppData != NULL ) { rc = clBufferNBytesRead(txnSrvcStateBuff, (ClUint8T *) *ppData, &ckptDataLen); if (CL_OK != rc) { *pDataLen = 0x0; clHeapFree(*ppData); CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to create txn-service checkpoint. rc:0x%x", rc)); rc = CL_GET_ERROR_CODE(rc); } } else { rc = CL_ERR_NO_MEMORY; } } else { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Error while packing or no data rc:0x%x data-len:0%x", rc, ckptDataLen)); } } rc = clBufferDelete(&txnSrvcStateBuff); } CL_FUNC_EXIT(); return (rc); }
ClRcT clCkptLeaderAddrUpdateClientAsync_4_0_0(CL_IN ClIdlHandleT handle, CL_IN ClUint32T masterAddr, CL_IN ClUint32T deputyAddr,CL_IN CkptEoClCkptLeaderAddrUpdateAsyncCallbackT_4_0_0 fpAsyncCallback, CL_IN void *cookie) { ClRcT rc = CL_OK; ClVersionT funcVer = {4, 0, 0}; ClUint32T funcNo = CL_EO_GET_FULL_FN_NUM(CL_EO_NATIVE_COMPONENT_TABLE_ID, 19); ClBufferHandleT inMsgHdl = 0; ClBufferHandleT outMsgHdl = 0; ClIocAddressT address = {{0}}; ClIdlHandleObjT* pHandleObj = NULL; ClRmdAsyncOptionsT asyncOptions; ClUint32T tempFlags = 0; ClIdlCookieT* pCookie = NULL; rc = clHandleCheckout(gIdlClnt.idlDbHdl,handle,(void **)&pHandleObj); if(rc != CL_OK) { return rc; } if (CL_IDL_ADDRESSTYPE_IOC == pHandleObj->address.addressType) { address = pHandleObj->address.address.iocAddress; } else if (CL_IDL_ADDRESSTYPE_NAME == pHandleObj->address.addressType) { rc = clNameToObjectReferenceGet(&(pHandleObj->address.address.nameAddress.name), pHandleObj->address.address.nameAddress.attrCount, pHandleObj->address.address.nameAddress.attr, pHandleObj->address.address.nameAddress.contextCookie, (ClUint64T*)&address); if (CL_OK != rc) { goto L; } } else { rc = CL_IDL_RC(CL_ERR_INVALID_PARAMETER); goto L; } rc = clBufferCreate(&inMsgHdl); if (CL_OK != rc) { goto L; } rc = clXdrMarshallClUint32T(&(masterAddr), inMsgHdl, 0); if (CL_OK != rc) { goto L; } rc = clXdrMarshallClUint32T(&(deputyAddr), inMsgHdl, 0); if (CL_OK != rc) { goto L; } if(fpAsyncCallback != NULL) { pCookie = (ClIdlCookieT*) clHeapAllocate(sizeof(ClIdlCookieT)); if (NULL == pCookie) { return CL_IDL_RC(CL_ERR_NO_MEMORY); } asyncOptions.pCookie = NULL; asyncOptions.fpCallback = NULL; rc = clBufferCreate(&outMsgHdl); if (CL_OK != rc) { goto L2; } tempFlags |= pHandleObj->flags | (CL_RMD_CALL_ASYNC | CL_RMD_CALL_NON_PERSISTENT | CL_RMD_CALL_NEED_REPLY); pCookie->pCookie = cookie; pCookie->actualCallback = (void(*)())fpAsyncCallback; pCookie->handle = handle; asyncOptions.pCookie = pCookie; asyncOptions.fpCallback = clCkptLeaderAddrUpdateAsyncCallback_4_0_0; rc = clRmdWithMsgVer(address, &funcVer, funcNo, inMsgHdl, outMsgHdl, tempFlags, &(pHandleObj->options), &asyncOptions); if (CL_OK != rc) { goto LL; } } else { tempFlags |= pHandleObj->flags | (CL_RMD_CALL_ASYNC | CL_RMD_CALL_NON_PERSISTENT); rc = clRmdWithMsgVer(address, &funcVer, funcNo, inMsgHdl, 0, tempFlags, &(pHandleObj->options),NULL); if(CL_OK != rc) { goto L; } } clHandleCheckin(gIdlClnt.idlDbHdl,handle); return rc; LL: clBufferDelete(&outMsgHdl); L2: clHeapFree(pCookie); L: clHandleCheckin(gIdlClnt.idlDbHdl,handle); return rc; }
/* This function handles msg send request from clients */ static ClRcT clMsgIocRequestHandle(ClEoExecutionObjT *pThis, ClBufferHandleT eoRecvMsg, ClUint8T priority, ClUint8T protoType, ClUint32T length, ClIocPhysicalAddressT srcAddr) { ClRcT rc = CL_OK; ClRcT ret; ClUint32T sendType; ClNameT pDestination; SaMsgMessageT pMessage; ClInt64T sendTime; ClHandleT senderHandle; ClInt64T timeout; ClInt64T msgId; ClUint8T syncType; memset(&(pDestination), 0, sizeof(ClNameT)); memset(&(pMessage), 0, sizeof(SaMsgMessageT)); memset(&(senderHandle), 0, sizeof(ClHandleT)); rc = clXdrUnmarshallClUint32T( eoRecvMsg,&(sendType)); if (CL_OK != rc) { goto out1; } rc = clXdrUnmarshallClNameT( eoRecvMsg,&(pDestination)); if (CL_OK != rc) { goto out1; } rc = clXdrUnmarshallSaMsgMessageT_4_0_0( eoRecvMsg,&(pMessage)); if (CL_OK != rc) { goto out1; } rc = clXdrUnmarshallClInt64T( eoRecvMsg,&(sendTime)); if (CL_OK != rc) { goto out1; } rc = clXdrUnmarshallClHandleT( eoRecvMsg,&(senderHandle)); if (CL_OK != rc) { goto out1; } rc = clXdrUnmarshallClInt64T( eoRecvMsg,&(timeout)); if (CL_OK != rc) { goto out1; } rc = clXdrUnmarshallClInt64T( eoRecvMsg,&(msgId)); if (CL_OK != rc) { goto out1; } rc = clXdrUnmarshallClUint8T( eoRecvMsg,&(syncType)); if (CL_OK != rc) { goto out1; } /* Call remote function */ ret = VDECL_VER(clMsgMessageReceived, 4, 0, 0)(sendType, &(pDestination), &(pMessage), sendTime, senderHandle, timeout); /* Prepare to send return value to the caller */ ClIocSendOptionT sendOption = { 0 }; ClBufferHandleT replyMsg = NULL; ClUint8T replyProto = CL_IOC_SAF_MSG_REPLY_PROTO; /* Set Ioc send option */ sendOption.msgOption = CL_IOC_PERSISTENT_MSG; sendOption.priority = CL_IOC_DEFAULT_PRIORITY; sendOption.timeout = 10000; /* Create buffer for input message */ rc = clBufferCreate(&replyMsg); if (CL_OK != rc) { clDbgResourceLimitExceeded(clDbgMemoryResource, 0, ("Out of memory")); goto out1; } /* Marshall reply data */ rc = clMsgReplyDataMarshall(replyMsg, ret, msgId, syncType); if (CL_OK != rc) { clDbgCodeError(rc, ("Cannot marshal reply data.")); goto out2; } /* Send return value to the caller */ rc = clIocSend(pThis->commObj, replyMsg, replyProto,(ClIocAddressT *) &srcAddr, &sendOption); if (CL_OK != CL_GET_ERROR_CODE(rc)) { clLogError("MSG", "REPLY", "clIocSend(): error code [0x%x].", rc); } out2: clBufferDelete(&replyMsg); out1: return rc; }
ClRcT clMsgMessageReceivedClientSync_4_0_0(CL_IN ClIdlHandleT handle, CL_IN ClUint32T sendType, CL_IN ClNameT* pDestination, CL_IN SaMsgMessageT_4_0_0* pMessage, CL_IN ClInt64T sendTime, CL_IN ClHandleT senderHandle, CL_IN ClInt64T timeout) { ClRcT rc = CL_OK; ClVersionT funcVer = {4, 0, 0}; ClUint32T funcNo = CL_EO_GET_FULL_FN_NUM(CL_MSG_CLIENT_SERVER_TABLE_ID, 4); ClBufferHandleT inMsgHdl = 0; ClBufferHandleT outMsgHdl = 0; ClIocAddressT address = {{0}}; ClIdlHandleObjT* pHandleObj = NULL; ClUint32T tempFlags = 0; rc = clHandleCheckout(gIdlClnt.idlDbHdl,handle,(void **)&pHandleObj); if( rc != CL_OK ) { return rc ; } if (CL_IDL_ADDRESSTYPE_IOC == pHandleObj->address.addressType) { address = pHandleObj->address.address.iocAddress; } else if (CL_IDL_ADDRESSTYPE_NAME == pHandleObj->address.addressType) { rc = clNameToObjectReferenceGet(&(pHandleObj->address.address.nameAddress.name), pHandleObj->address.address.nameAddress.attrCount, pHandleObj->address.address.nameAddress.attr, pHandleObj->address.address.nameAddress.contextCookie, (ClUint64T*)&address); if (CL_OK != rc) { return rc; } } else { return CL_IDL_RC(CL_ERR_INVALID_PARAMETER); } rc = clBufferCreate(&inMsgHdl); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClUint32T(&(sendType), inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClNameT(pDestination, inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallSaMsgMessageT_4_0_0(pMessage, inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClInt64T(&(sendTime), inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClHandleT(&(senderHandle), inMsgHdl, 0); if (CL_OK != rc) { return rc; } rc = clXdrMarshallClInt64T(&(timeout), inMsgHdl, 0); if (CL_OK != rc) { return rc; } tempFlags |= pHandleObj->flags | (CL_RMD_CALL_NON_PERSISTENT); tempFlags &= ~CL_RMD_CALL_ASYNC; rc = clRmdWithMsgVer(address, &funcVer, funcNo, inMsgHdl, outMsgHdl, tempFlags, &(pHandleObj->options), NULL); if(CL_OK != rc) { return rc; } rc = clHandleCheckin(gIdlClnt.idlDbHdl,handle); return rc; }