static void entityStart(ClAmsEntityConfigT& ent) { ClRcT rc; do { rc = clAmsMgmtEntityUnlock(mgmtHandle,&ent); } while(CL_GET_ERROR_CODE(rc) == CL_ERR_TRY_AGAIN); // Already running so nothing to do if (CL_GET_ERROR_CODE(rc) == CL_ERR_NO_OP) return; do { rc = clAmsMgmtEntityLockAssignment(mgmtHandle,&ent); } while(CL_GET_ERROR_CODE(rc) == CL_ERR_TRY_AGAIN); do { rc = clAmsMgmtEntityUnlock(mgmtHandle,&ent); } while(CL_GET_ERROR_CODE(rc) == CL_ERR_TRY_AGAIN); if ((rc)&&(CL_GET_ERROR_CODE(rc) != CL_ERR_NO_OP)) { checkError("Start entity", rc); } }
ClRcT clJobQueueStop(ClJobQueueT* hdl) { ClJobT* jb=0; ClRcT rc; if( !(hdl->flags & CreatedQueue) ) return CL_JOBQUEUE_RC(CL_ERR_INVALID_STATE); JQ_PFX(hdl); /* Clear out all pending jobs */ do{ ClQueueDataT temp; rc = clQueueNodeDelete(hdl->queue, &temp); if (CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_EXIST) { jb = (ClJobT*) temp; CL_ASSERT(jb); releaseJob(hdl,jb); } } while (CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_EXIST); /* GAS TODO: Let all the tasks finish up */ hdl->flags &= ~Running; rc = CL_OK; JQ_SFX(hdl); return rc; }
void clMsgQueueEmpty(ClMsgQueueInfoT *pQInfo) { ClRcT rc; ClCntNodeHandleT nodeHandle = NULL, nextNodeHandle = NULL; ClUint32T i; ClRcT retCode; for(i = 0; i < CL_MSG_QUEUE_PRIORITIES; i++) { rc = clCntFirstNodeGet(pQInfo->pPriorityContainer[i], &nodeHandle); if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) continue; do { rc = clCntNextNodeGet(pQInfo->pPriorityContainer[i], nodeHandle, &nextNodeHandle); if(CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_EXIST && rc != CL_OK) { clLogError("QUE", "EMT", "Failed to get the next node from container. error code [0x%x].", rc); break; } retCode = clCntNodeDelete(pQInfo->pPriorityContainer[i], nodeHandle); if(retCode != CL_OK) clLogError("QUE", "EMT", "Failed to delete a node from container. error code [0x%x].", retCode); nodeHandle = nextNodeHandle; }while(CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_EXIST); } }
static void checkError(const char* operation, ClRcT rc) { if (rc != 0) { Log(SevError,"%s: Error 0x%x", operation, rc); if ((CL_GET_ERROR_CODE(rc) != CL_ERR_DUPLICATE)&&(CL_GET_ERROR_CODE(rc) != CL_ERR_ALREADY_EXIST)) { throw AmfException(rc); } } }
} END_TEST_EXTERN START_TEST_EXTERN(eject_with_proper_values) { ClRcT rc = CL_OK; /* Initialize gms client without any callbacks being registered. */ rc = clGmsInitialize(&handle,NULL,&correct_version); fail_unless(rc == CL_OK, "clGmsInitialize with NULL callbacks failed with rc 0x%x",rc); rc = clGmsClusterJoin(handle, &clusterManageCallbacks, 0, 0, 100, &nodeName); fail_unless(CL_GET_ERROR_CODE(rc) == CL_OK, "ClusterJoin with 0 handle failed with rc = 0x%x",rc); callback_invoked = CL_FALSE; rc = clGmsClusterMemberEject(handle, 100, CL_GMS_MEMBER_EJECT_REASON_API_REQUEST); fail_unless(rc == CL_OK, "Cluster Leave for nodeId 100 failed with rc 0x%x",rc); /* Wait for the callback to be invoked */ sleep(5); fail_unless(callback_invoked == CL_TRUE, "Cluster Eject callback is not invoked"); /* Finalize */ rc = clGmsFinalize(handle); fail_unless(rc == CL_OK, "clGmsFinalize failed with rc = 0x%x",rc); } END_TEST_EXTERN
ClRcT clLogSOLocalStateRecover(ClHandleT hLibCkpt, ClLogSOEoDataT *pSoEoEntry) { ClRcT rc = CL_OK; CL_LOG_DEBUG_TRACE(("Enter")); /* internally calls the deserializer, clLogSODsIdMapRecreate() */ CL_LOG_DEBUG_TRACE(("clLogSODsIdMapRecreate: %s %d\n", gSOLocalCkptName.value, CL_LOG_DSID_START)); rc = clCkptLibraryCkptDataSetRead(hLibCkpt, (SaNameT *) &gSOLocalCkptName, CL_LOG_DSID_START, CL_HANDLE_INVALID_VALUE); if( CL_ERR_NOT_EXIST == CL_GET_ERROR_CODE(rc) ) { return CL_OK; } if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryCkptDataSetRead(): rc[0x %x]", rc)); return rc; } rc = clBitmapWalkUnlocked(pSoEoEntry->hDsIdMap, clLogSOLocalStreamEntryRecover, NULL); if( CL_OK != rc ) { /* What do we do, revert back or proceed */ CL_LOG_DEBUG_ERROR(("clBitmapWalkUnlocked(): rc[0x %x]", rc)); } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clCkptEntryDelete(ClCachedCkptSvcInfoT *serviceInfo, const SaNameT *sectionName) { ClRcT rc = CL_OK; SaCkptSectionIdT ckptSectionId = { /* Section id for checkpoints */ sectionName->length, (SaUint8T *) sectionName->value }; ClInt32T tries = 0; ClTimerTimeOutT delay = { 0, 500 }; /* Delete section from the ckpt */ if (clCkptEntryExist(serviceInfo, sectionName) == CL_TRUE) { retry: rc = clCkptSectionDelete(serviceInfo->ckptHandle, (ClCkptSectionIdT *)&ckptSectionId); if (CL_ERR_TRY_AGAIN == CL_GET_ERROR_CODE(rc)) { if ((++tries < 5) && (clOsalTaskDelay(delay) == CL_OK)) { goto retry; } } } return rc; }
/** * API to delete checkpoint recovery-log details of a given transaction. */ ClRcT clTxnServiceCkptRecoveryLogCheckpointDelete( CL_IN ClTxnTransactionIdT txnId) { ClRcT rc = CL_OK; if(!clTxnServiceCfg->dsblCkpt) { SaNameT txnCkptName; ClCharT elementName[200]; CL_FUNC_ENTER(); txnCkptName.length = strlen(CL_TXN_CKPT_NAME) + 1; memset(&(txnCkptName.value[0]), '\0', txnCkptName.length); strncpy(&(txnCkptName.value[0]), CL_TXN_CKPT_NAME, txnCkptName.length); elementName[0] = '\0'; sprintf(elementName, "TXN_%x_%x", txnId.txnMgrNodeAddress, txnId.txnId); rc = clCkptLibraryCkptElementDelete (clTxnServiceCfg->txnCkptHandle, &txnCkptName, CL_TXN_RECOVERY_DATA_SET, elementName, (strlen(elementName) + 1)); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to delete element of txn-recovery data for txn 0x%x:0x%x, rc:0x%x", txnId.txnMgrNodeAddress, txnId.txnId, rc)); rc = CL_GET_ERROR_CODE(rc); } } CL_FUNC_EXIT(); return (rc); }
/** * Finalize Transaction service Checkpointing */ ClRcT clTxnServiceCkptFinalize() { ClRcT rc = CL_OK; if(!clTxnServiceCfg->dsblCkpt) { SaNameT txnCkptName; CL_FUNC_ENTER(); txnCkptName.length = strlen(CL_TXN_CKPT_NAME) + 1; memset(&(txnCkptName.value[0]), '\0', txnCkptName.length); strncpy(&(txnCkptName.value[0]), CL_TXN_CKPT_NAME, txnCkptName.length); rc = clCkptLibraryCkptDataSetDelete (clTxnServiceCfg->txnCkptHandle, &txnCkptName, CL_TXN_SERVICE_DATA_SET); rc = clCkptLibraryCkptDataSetDelete (clTxnServiceCfg->txnCkptHandle, &txnCkptName, CL_TXN_RECOVERY_DATA_SET); rc = clCkptLibraryCkptDelete(clTxnServiceCfg->txnCkptHandle, &txnCkptName); rc = clCkptLibraryFinalize(clTxnServiceCfg->txnCkptHandle); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to delete cktp. rc:0x%x", rc)); rc = CL_GET_ERROR_CODE(rc); } } CL_FUNC_EXIT(); return (rc); }
/* * This API creates the container class and populates it with data from the obj deltaDb * The API iterates over the database, fetching the key and associated data. * It calls clCorDeltaDbContAdd which places MO/MSO create/set operating in the hash list. */ ClRcT clCorDeltaDbObjContCreate() { ClRcT rc = CL_OK; ClCorDeltaSaveKeyT *deltaDbKey = NULL, *deltaDbKeyNext = NULL; ClUint32T keySize = 0, keySizeNext = 0; ClDBRecordT deltaDbData, deltaDbDataNext ; ClUint32T dataSize = 0; ClVersionT dbVersion = {0}; /* Create the container for retreiving data from the Delta DB */ if ((rc = clCorDeltaContInit()) != CL_OK) return rc ; if((rc = clDbalFirstRecordGet( hDeltaObjDb, (ClDBKeyT *)&deltaDbKey, (ClUint32T *)&keySize, (ClDBRecordT *)&deltaDbData, (ClUint32T *)&dataSize )) != CL_OK) { if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) { clLog(CL_LOG_SEV_NOTICE, "DLS", "OBR", "The object Db doesn't \ contain anything. rc[0x%x]", rc); return CL_OK; } CL_DEBUG_PRINT(CL_DEBUG_ERROR,("Failed to get the first Record for the Key. rc [0x%x]",rc)); return rc; }
/* * This function initializes all the Basic ASP library */ ClRcT clEoEssentialLibInitialize(void) { ClRcT rc = CL_OK; ClUint32T i = 0; ClUint32T tableSize = CL_EO_LIB_ID_RES; // CL_SIZEOF_ARRAY(gEssentialLibInfo); /* * Initializing the Essential Libraries */ for (i = 0; i < tableSize; i++) { clLog(CL_LOG_SEV_DEBUG, CL_LOG_AREA, CL_LOG_CTXT_INI, "Initializing essential library [%s]...", gEssentialLibInfo[i].libName); if (CL_OK != (rc = gEssentialLibInfo[i].pLibInitializeFunc(gEssentialLibInfo[i].pConfig))) { if (CL_GET_ERROR_CODE(rc) != CL_ERR_INITIALIZED) /* Already Initialized is benign */ { clLog(CL_LOG_SEV_CRITICAL, CL_LOG_AREA, CL_LOG_CTXT_INI, "Failed to initialize essential library [%s], error [0x%x]", gEssentialLibInfo[i].libName, rc); return rc; } } } return CL_OK; }
/** * API to restore status of transaction-service from check-point */ ClRcT clTxnServiceCkptAppStateRestore() { ClRcT rc = CL_OK; if(!clTxnServiceCfg->dsblCkpt) { SaNameT txnCkptName; CL_FUNC_ENTER(); txnCkptName.length = strlen(CL_TXN_CKPT_NAME) + 1; memset(&(txnCkptName.value[0]), '\0', txnCkptName.length); strncpy(&(txnCkptName.value[0]), CL_TXN_CKPT_NAME, txnCkptName.length); CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Restoring transaction-service state")); clLogDebug("SER", NULL, "Ckpt exists, reading data"); rc = clCkptLibraryCkptDataSetRead(clTxnServiceCfg->txnCkptHandle, &txnCkptName, CL_TXN_SERVICE_DATA_SET, 0x0); if (CL_OK != rc) { clLogError("SER", NULL, "Failed to restore transaction-service state, rc [0x%x]", rc); rc = CL_GET_ERROR_CODE(rc); } } CL_FUNC_EXIT(); return (rc); }
static ClRcT clCorDeltaDbContAdd(ClCorDeltaSaveKeyT *deltaDbKey, ClDBRecordT deltaDbData, ClUint32T dataSize) { ClRcT rc = CL_OK; ClCorDeltaSaveKeyT *tempKey = deltaDbKey; ClCorDeltaContDataT *tempCont = clHeapCalloc(1, sizeof(ClCorDeltaContDataT)); CL_ASSERT(tempCont != NULL); tempCont->data = deltaDbData; tempCont->dataSize = dataSize; if( tempKey == NULL || tempCont->data == NULL) { clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_DEBUG, NULL, CL_LOG_MESSAGE_0_MEMORY_ALLOCATION_FAILED); CL_DEBUG_PRINT(CL_DEBUG_ERROR,(CL_COR_ERR_STR(CL_COR_ERR_NO_MEM))); return CL_COR_SET_RC(CL_COR_ERR_NO_MEM); } rc = clCntNodeAdd(gCorDeltaSaveKeyTable, (ClCntKeyHandleT) tempKey, (ClCntDataHandleT) tempCont , NULL); if(CL_OK != rc) { if (CL_GET_ERROR_CODE(rc) == CL_ERR_DUPLICATE) rc = CL_OK; else CL_COR_RETURN_ERROR(CL_DEBUG_ERROR, "Could not add node in the Delta Save Key Table", rc); clHeapFree(tempCont); } return rc; }
/** * Adds a new definition of transaction to txn-database */ ClRcT clTxnDbNewTxnDefnAdd( CL_IN ClTxnDbHandleT txnDb, CL_IN ClTxnDefnT *pNewTxn, CL_IN ClTxnTransactionIdT *pTxnId) { ClRcT rc = CL_OK; ClTxnDefnT *pTxnDef; CL_FUNC_ENTER(); rc = clCntDataForKeyGet(txnDb, (ClCntKeyHandleT) pTxnId, (ClCntDataHandleT *) &pTxnDef); if (CL_OK != rc) { rc = clCntNodeAdd(txnDb, (ClCntKeyHandleT) pTxnId, (ClCntDataHandleT) pNewTxn, 0); } else { rc = CL_ERR_DUPLICATE; } CL_FUNC_EXIT(); return (CL_GET_ERROR_CODE(rc)); }
static ClRcT nodeCacheMemberGetExtended(ClIocNodeAddressT node, ClNodeCacheMemberT *pMember,ClUint32T retries, ClUint32T msecDelay, ClBoolT compat) { ClRcT rc = CL_OK; ClUint32T i = 0; ClTimerTimeOutT delay; delay.tsSec = 0; delay.tsMilliSec = msecDelay; clOsalSemLock(gClNodeCacheSem); while(i++ <= retries) { rc = nodeCacheMemberGetFast(node, pMember, compat); if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) { clOsalSemUnlock(gClNodeCacheSem); if(i > retries) goto out; clOsalTaskDelay(delay); delay.tsMilliSec += msecDelay; /* Back off the time as retries increase */ clOsalSemLock(gClNodeCacheSem); } else break; } clOsalSemUnlock(gClNodeCacheSem); out: return rc; }
/* * Create the section if it doesn't exist. * Called on becoming active */ SaAisErrorT alarmClockCkptActivate(SaCkptCheckpointHandleT ckptHdl, ClUint32T section_num) { SaAisErrorT rc = SA_AIS_OK; SaCkptSectionIdT *id; if(section_num > NUM_SECTION_ID_MAPS) return SA_AIS_ERR_INVALID_PARAM; id = §ionIdMap[section_num-1].sectionId; rc = clCkptSectionCheck(ckptHdl, (ClCkptSectionIdT*)id); if(rc != CL_OK) { if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) { rc = alarmClockCkptSectionCreate(ckptHdl, 1); if(rc == SA_AIS_OK) { alarmClockLogWrite(CL_LOG_SEV_INFO, "alarmClockActivate: Section [%.*s] created successfully", id->idLen, (const char *)id->id); } } else rc = SA_AIS_ERR_UNAVAILABLE; /* internal error */ } else rc = SA_AIS_OK; if(rc != SA_AIS_OK) { alarmClockLogWrite(CL_LOG_SEV_INFO, "alarmClockActivate: Section operation on section [%d] " "failed with [%#x]", section_num, rc); } return rc; }
/** * API to checkpoint current state of transaction-service */ ClRcT clTxnServiceCkptAppStateCheckpoint() { ClRcT rc = CL_OK; if(!clTxnServiceCfg->dsblCkpt) { SaNameT txnCkptName; CL_FUNC_ENTER(); txnCkptName.length = strlen(CL_TXN_CKPT_NAME) + 1; memset(&(txnCkptName.value[0]), '\0', txnCkptName.length); strncpy(&(txnCkptName.value[0]), CL_TXN_CKPT_NAME, txnCkptName.length); rc = clCkptLibraryCkptDataSetWrite(clTxnServiceCfg->txnCkptHandle, &txnCkptName, CL_TXN_SERVICE_DATA_SET, 0x0); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to write data-set [0x%x], rc:0x%x", CL_TXN_SERVICE_DATA_SET, rc)); rc = CL_GET_ERROR_CODE(rc); } } CL_FUNC_EXIT(); return (rc); }
/** * API to restore recovery logs of previously active transactions * from check-point */ ClRcT clTxnServiceCkptRecoveryLogRestore() { ClRcT rc = CL_OK; if(!clTxnServiceCfg->dsblCkpt) { SaNameT txnCkptName; CL_FUNC_ENTER(); txnCkptName.length = strlen(CL_TXN_CKPT_NAME) + 1; memset(&(txnCkptName.value[0]), '\0', txnCkptName.length); strncpy(&(txnCkptName.value[0]), CL_TXN_CKPT_NAME, txnCkptName.length); CL_DEBUG_PRINT(CL_DEBUG_TRACE, ("Restoring transaction-recovery logs")); /* AD-1: To use the checkpoint exists api to check whether its recovery or * normal startup */ clLogDebug("SER", NULL, "Checkpoint exists, reading data for recovery"); rc = clCkptLibraryCkptDataSetRead(clTxnServiceCfg->txnCkptHandle, &txnCkptName, CL_TXN_RECOVERY_DATA_SET, 0x0); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Failed to restore transaction-service state. rc:0x%x", rc)); rc = CL_GET_ERROR_CODE(rc); } } CL_FUNC_EXIT(); return (rc); }
/******************************************************************************* Feature API: alarmClockCkptWrite Description : This API will not attempt to validate arguments, the thinking being that this is a volitional act by the invoker of this API to ensure that invalid parameters can be handled gracefully by the subsystem Arguments In: 1. ClCkptHdlT : ckpt handle 2. section number 3. data to write 4. size of data to write Return Value: ClInt32Teger 0 if success, non zero if failure *******************************************************************************/ ClRcT alarmClockCkptWrite ( ClCkptHdlT ckpt_hdl, ClInt32T section_num, void* data, ClInt32T data_size ) { ClRcT ret_code = CL_OK; ClInt32T pid = getpid(); ClCharT section_id_name[ CL_MAX_NAME_LENGTH ]; ClCkptSectionIdT section_id; sprintf(section_id_name, "s%05d", section_num); section_id.id = (ClUint8T*)section_id_name; section_id.idLen = strlen(section_id_name); ret_code = clCkptSectionOverwrite(ckpt_hdl, §ion_id, data, data_size); if (ret_code != CL_OK) { if(CL_GET_ERROR_CODE(ret_code) == 0xa || CL_GET_ERROR_CODE(ret_code) == CL_ERR_NOT_EXIST) { ClCkptSectionCreationAttributesT section_cr_attr; section_cr_attr.sectionId = §ion_id; section_cr_attr.expirationTime = (ClTimeT)CL_TIME_END; ret_code = clCkptSectionCreate(ckpt_hdl, §ion_cr_attr, data, data_size); } } if(ret_code != CL_OK) { alarmClockLogWrite(CL_LOG_SEV_ERROR, "alarmClockCkptWrite(pid=%d): Failed to write: 0x%x\n", pid, ret_code); } else { alarmClockLogWrite(CL_LOG_SEV_DEBUG, "alarmClockCkptWrite(pid=%d): wrote %d bytes to %s\n", pid, data_size, section_id_name); } return ret_code; }
ClRcT clLogStreamOwnerCheckpointCreate(ClLogSOEoDataT *pSoEoEntry, SaNameT *pCkptName, ClHandleT *phCkpt) { ClRcT rc = CL_OK; ClCkptCheckpointCreationAttributesT creationAtt = {0}; ClCkptOpenFlagsT openFlags = 0; ClLogSvrCommonEoDataT *pCommonEoData = NULL; ClUint32T sectionSize = 0; ClInt32T tries = 0; ClIocNodeAddressT localAddr = clIocLocalAddressGet(); static ClTimerTimeOutT delay = { 0, 500}; CL_LOG_DEBUG_TRACE(("Enter")); rc = clLogStreamOwnerEoEntryGet(NULL, &pCommonEoData); if( CL_OK != rc ) { return rc; } creationAtt.creationFlags = CL_CKPT_CHECKPOINT_COLLOCATED | CL_CKPT_ALL_OPEN_ARE_REPLICAS; creationAtt.checkpointSize = pCommonEoData->maxStreams * CL_LOG_SO_SEC_SIZE; creationAtt.retentionDuration = CL_STREAMOWNER_CKPT_RETENTION_DURATION; creationAtt.maxSections = pCommonEoData->maxStreams; sectionSize = pCommonEoData->maxComponents * sizeof(ClLogCompKeyT); creationAtt.maxSectionSize = CL_LOG_SO_SEC_SIZE + sectionSize; creationAtt.maxSectionIdSize = CL_LOG_SO_SEC_ID_SIZE; openFlags = CL_CKPT_CHECKPOINT_CREATE | CL_CKPT_CHECKPOINT_WRITE | CL_CKPT_CHECKPOINT_READ; reopen: rc = clCkptCheckpointOpen(pCommonEoData->hSvrCkpt, pCkptName, &creationAtt, openFlags, 5000L, &pSoEoEntry->hCkpt); if( rc != CL_OK ) { /* * No replica found and we are the only master. * Delete and try re-opening the checkpoint */ if(CL_GET_ERROR_CODE(rc) == CL_ERR_NO_RESOURCE && pCommonEoData->masterAddr == localAddr) { if(tries++ < 1) { clLogNotice("CKP", "GET", "No replica for log checkpoint." "Deleting ckpt [%.*s] and retrying the ckpt open", pCkptName->length, pCkptName->value); clCkptCheckpointDelete(pCommonEoData->hSvrCkpt, pCkptName); clOsalTaskDelay(delay); goto reopen; } } CL_LOG_DEBUG_ERROR(("clCkptCheckpointOpen(): rc[0x %x]", rc)); } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clCkptEntryUpdate(ClCachedCkptSvcInfoT *serviceInfo, const ClCachedCkptDataT *sectionData) { ClRcT rc; SaCkptSectionIdT ckptSectionId = { /* Section id for checkpoints */ sectionData->sectionName.length, (SaUint8T *) sectionData->sectionName.value }; ClUint8T *ckptedData, *copyData; ClSizeT ckptedDataSize = sectionData->dataSize + sizeof(ClIocAddressT); ClUint32T network_byte_order; ClInt32T tries = 0; ClTimerTimeOutT delay = { 0, 500 }; ckptedData = (ClUint8T *) clHeapAllocate(ckptedDataSize); if(ckptedData == NULL) { rc = CL_ERR_NO_MEMORY; clLogError("CCK", "UPD", "Failed to allocate memory. error code [0x%x].", rc); goto out1; } /* Marshall section data*/ copyData = ckptedData; network_byte_order = (ClUint32T) htonl((ClUint32T)sectionData->sectionAddress.iocPhyAddress.nodeAddress); memcpy(copyData, &network_byte_order, sizeof(ClUint32T)); copyData = copyData + sizeof(ClUint32T); network_byte_order = (ClUint32T) htonl((ClUint32T)sectionData->sectionAddress.iocPhyAddress.portId); memcpy(copyData, &network_byte_order, sizeof(ClUint32T)); copyData = copyData + sizeof(ClUint32T); memcpy(copyData, sectionData->data, sectionData->dataSize); /* Try to update the section */ retry: rc = clCkptSectionOverwrite(serviceInfo->ckptHandle, /* Checkpoint handle */ (ClCkptSectionIdT *)&ckptSectionId, /* Section ID */ ckptedData, /* Initial data */ ckptedDataSize); /* Size of data */ if (CL_ERR_TRY_AGAIN == CL_GET_ERROR_CODE(rc)) { if ((++tries < 5) && (clOsalTaskDelay(delay) == CL_OK)) { goto retry; } } if (rc != CL_OK) { clLogError("CCK", "UPD", "CkptSectionUpdate failed with rc [0x%x].",rc); goto out2; } out2: clHeapFree(ckptedData); out1: return rc; }
ClRcT _clTxnAgentAppendActiveJob(CL_IN ClBufferHandleT outMsg) { ClRcT rc = CL_OK; ClTxnDefnT *pTxnDefn; ClCntNodeHandleT currTxnNode; ClCharT pOutMsg[1024]; CL_FUNC_ENTER(); rc = clCntFirstNodeGet(clTxnAgntCfg->activeTxnMap, &currTxnNode); while (rc == CL_OK) { ClCntNodeHandleT nodeTxn; ClCntNodeHandleT currJobNode; ClTxnAppJobDefnT *pNewTxnJob; /* Retrieve data-node for node */ rc = clCntNodeUserDataGet(clTxnAgntCfg->activeTxnMap, currTxnNode, (ClCntDataHandleT *)&pTxnDefn); if(CL_OK != rc) { clLogError("AGT", "CLI", "User data get failed with error [0x%x]", rc); return rc; } rc = clCntFirstNodeGet(pTxnDefn->jobList, &currJobNode); while (rc == CL_OK) { ClCntNodeHandleT nodeJob; /* Retrieve data-node for node */ rc = clCntNodeUserDataGet(pTxnDefn->jobList, currJobNode, (ClCntDataHandleT *)&pNewTxnJob); pOutMsg[0] = '\0'; sprintf(pOutMsg, " 0x%x:0x%x\t| 0x%x\t| %30s \n", pTxnDefn->serverTxnId.txnMgrNodeAddress, pTxnDefn->serverTxnId.txnId, pNewTxnJob->jobId.jobId, gCliTxnStatusStr[pNewTxnJob->currentState]); clXdrMarshallArrayClUint8T(&pOutMsg, strlen((char*)pOutMsg), outMsg, 0); nodeJob = currJobNode; rc = clCntNextNodeGet(pTxnDefn->jobList, nodeJob, &currJobNode); } nodeTxn = currTxnNode; rc = clCntNextNodeGet(clTxnAgntCfg->activeTxnMap, nodeTxn, &currTxnNode); } if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) rc = CL_OK; CL_FUNC_EXIT(); return(rc); }
static ClRcT clLogDoLogWrite(ClLogDeferredHeaderT *pMsg, ClUint16T numRecs, ClUint16T *pNumNotFlushed) { ClUint16T idx = 0; ClRcT rc = CL_OK; *pNumNotFlushed = numRecs; while( idx < numRecs ) { /* * If the handle is 0, redirecting the output to SYS file, * two reasons, those are ASP components logs came before * log library initialization, or really bad handle logs, * either case just redirecting to the file */ if( pMsg[idx].handle == CL_HANDLE_INVALID_VALUE ) { if( CL_LOG_HANDLE_SYS == CL_HANDLE_INVALID_VALUE ) { /* still log library has not been initialized */ idx++; continue; } pMsg[idx].handle = CL_LOG_HANDLE_SYS; } rc = clLogWriteWithHeader(pMsg[idx].handle, pMsg[idx].severity, pMsg[idx].serviceId, pMsg[idx].msgId, pMsg[idx].msgHeader, "%s", pMsg[idx].msg); if( CL_OK != rc ) { if( CL_GET_ERROR_CODE(rc) == CL_ERR_INVALID_HANDLE ) { idx++; continue; } /* * log client is not seem to be ready, * just go back and sleep */ break; } idx++; } /* return num of not flushed records */ if( idx != 0 ) { *pNumNotFlushed -= idx; //fprintf(stderr, "Num of not flushed records [%d], written [%d] pid [%d]\n", *pNumNotFlushed, // idx, getpid()); } return CL_OK; }
ClRcT clTxnAgentListCreate(ClCntHandleT *pAgentCntHandle) { ClRcT rc = CL_OK; CL_FUNC_ENTER(); rc = clCntLlistCreate(_clTxnAgentCmpFn, _clTxnAgentDelFn, _clTxnAgentDestroy, CL_CNT_UNIQUE_KEY, pAgentCntHandle); CL_FUNC_EXIT(); return (CL_GET_ERROR_CODE(rc)); }
ClRcT clLogClntStreamEntryGet(ClLogClntEoDataT *pClntEoEntry, SaNameT *pStreamName, SaNameT *pNodeName, ClStringT *pShmName, ClUint32T shmSize, ClCntNodeHandleT *phStreamNode, ClBoolT *pAddedEntry) { ClRcT rc = CL_OK; ClLogStreamKeyT *pStreamKey = NULL; CL_LOG_DEBUG_TRACE(("Enter")); *pAddedEntry = CL_FALSE; rc = clLogClntEoEntryGet(&pClntEoEntry); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clLogClntEoEntryGet(): rc[0x %x]", rc)); return rc; } rc = clLogStreamKeyCreate(pStreamName, pNodeName, pClntEoEntry->maxStreams, &pStreamKey); if( CL_OK != rc ) { return rc; } rc = clCntNodeFind(pClntEoEntry->hClntStreamTable, (ClCntKeyHandleT) pStreamKey, phStreamNode); if( CL_ERR_NOT_EXIST == CL_GET_ERROR_CODE(rc) ) { rc = clLogClntStreamEntryAdd(pClntEoEntry->hClntStreamTable, pStreamKey, pShmName, shmSize, phStreamNode); if( CL_OK != rc ) { clLogStreamKeyDestroy(pStreamKey); } else { *pAddedEntry = CL_TRUE; } return rc; } clLogStreamKeyDestroy(pStreamKey); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT clLogSvrCkptGet(ClLogSvrEoDataT *pSvrEoEntry, ClLogSvrCommonEoDataT *pSvrCommonEoEntry, ClBoolT *pLogRestart) { ClRcT rc = CL_OK; ClBoolT ckptExists = CL_FALSE; CL_LOG_DEBUG_TRACE(("Enter")); *pLogRestart = CL_FALSE; rc = clCkptLibraryDoesCkptExist(pSvrCommonEoEntry->hLibCkpt, (SaNameT *) &gSvrLocalCkptName, &ckptExists); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptLibraryDoesCkptExist(): rc[0x %x]", rc)); return rc; } rc = clLogSvrCkptCreate(pSvrEoEntry, pSvrCommonEoEntry); if(CL_OK != rc) { return rc; } if( CL_TRUE == ckptExists )/*Log Service restart*/ { *pLogRestart = CL_TRUE; rc = clLogSvrStateRecover(pSvrEoEntry, pSvrCommonEoEntry); if( CL_OK != rc ) { /* * Just restart incase there were no streamowners checkpointed in the first place */ if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) { rc = CL_OK; *pLogRestart = CL_FALSE; } else { CL_LOG_DEBUG_ERROR(("clCkptLibraryDoesCkptExist(): rc[0x %x]", rc)); return rc; } } } CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
ClRcT _clTxnAgentAppendServices(CL_IN ClBufferHandleT outMsg) { ClRcT rc = CL_OK; ClTxnAgentCompServiceInfoT *pCompInstance; ClCntNodeHandleT currNode; ClCharT pOutMsg[1024]; CL_FUNC_ENTER(); rc = clCntFirstNodeGet(clTxnAgntCfg->compServiceMap, &currNode); while (rc == CL_OK) { ClCntNodeHandleT node; /* Retrieve data-node for node */ rc = clCntNodeUserDataGet(clTxnAgntCfg->compServiceMap, currNode, (ClCntDataHandleT *)&pCompInstance); if(CL_OK != rc) { clLogError("AGT", "CLI", "User data get failed with error [0x%x]", rc); return rc; } pOutMsg[0] = '\0'; if(pCompInstance->serviceCapability == CL_TXN_AGENT_SERVICE_2PC) { sprintf(pOutMsg, " %6d\t| 2PC Capable \n", pCompInstance->serviceType); } else if(pCompInstance->serviceCapability == CL_TXN_AGENT_SERVICE_1PC) { sprintf(pOutMsg, " %6d\t| 1PC Capable \n", pCompInstance->serviceType); } clXdrMarshallArrayClUint8T(&pOutMsg, strlen((char*)pOutMsg), outMsg, 0); node = currNode; rc = clCntNextNodeGet(clTxnAgntCfg->compServiceMap, node, &currNode); } if(CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) rc = CL_OK; CL_FUNC_EXIT(); return(rc); }
/** * Returns an OM class entry. * * This function returns a pointer to an OM class entry given * OM class Id. * * @param omClassKey - OM class type * * @returns * Pointer to class control block */ ClOmClassControlBlockT * clOmClassEntryGet(ClOmClassTypeT omClassKey) { ClRcT rc = CL_OK; #ifdef CL_DEBUG ClUint8T aFuncName[] = "clOmClassEntryGet()"; #endif ClCntNodeHandleT tempNodeHandle = 0; ClOmClassControlBlockT *pClassEntry = 0; CL_FUNC_ENTER(); if ((rc = omClassTypeValidate(omClassKey)) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Invalid input OM class (rc = 0x%x)!\r\n", aFuncName, rc)); CL_ASSERT(NULL); CL_FUNC_EXIT(); return NULL; } /* find the node for this MO ID */ if ((rc = clCntNodeFind(ghOmClassHashTbl, (ClCntKeyHandleT)(ClWordT)omClassKey, &tempNodeHandle)) != CL_OK) { if (CL_GET_ERROR_CODE(rc) == CL_ERR_NOT_EXIST) { CL_DEBUG_PRINT(CL_DEBUG_INFO, ("%s: Node does not exist for OM class " "(0x%x), with rc 0x%x!\r\n", aFuncName, omClassKey, rc)); } else { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to find node for OM class " "(0x%x), with rc 0x%x!\r\n", aFuncName, omClassKey, rc)); } return NULL; } /* now get the OM handle for this MO ID */ if ((rc = clCntNodeUserDataGet(ghOmClassHashTbl, tempNodeHandle, (ClCntDataHandleT *)&pClassEntry)) != CL_OK) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("%s: Failed to get the OM class entry from the " "node for OM class 0x%x, with rc 0x%x!\r\n", aFuncName, omClassKey, rc)); CL_ASSERT(NULL); return NULL; } return pClassEntry; }
/** * 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); }
ClRcT clMsgFinalizeBlocker(void) { ClRcT rc = CL_OK; SaTimeT timeout = (SaTimeT)(CL_MSG_FIN_BLOCK_TIME * 1000000000LL); ClTimerTimeOutT tempTime = {0}; CL_OSAL_MUTEX_LOCK(&gFinBlockMutex); if(gMsgMoveStatus == MSG_MOVE_DONE) goto out; clLogDebug("FIN", "BLOCK", "Message service finalize will be blocked for [%llu ns].", timeout); if(gMsgMoveStatus == MSG_MOVE_FIN_UNINIT) { rc = clOsalTaskCreateDetached("allClosedQueueMoverThread", CL_OSAL_SCHED_OTHER, CL_OSAL_THREAD_PRI_NOT_APPLICABLE, 0, clMsgClosedQueueMoveThread, NULL); if(rc != CL_OK) { clLogError("FIN", "BLOCK", "Failed to create a Queue mover thread. error code [0x%x].", rc); goto error_out; } clMsgTimeConvert(&tempTime, timeout); rc = clOsalCondWait(gFinBlockCond, &gFinBlockMutex, tempTime); if(CL_GET_ERROR_CODE(rc) == CL_ERR_TIMEOUT) { clLogError("FIN", "BLOCK", "Finalize blocking timed out. Timeout is [%lld ns]. error code [0x%x].", timeout, rc); } else if(rc != CL_OK) { clLogError("FIN", "BLOCK", "Failed at Conditional Wait. error code [0x%x].", rc); } else { clLogDebug("FIN", "BLOCK", "Message queues are failed over to [0x%x] node.", gQMoveDestNode); } } gMsgMoveStatus = MSG_MOVE_DONE; goto out; error_out: out: CL_OSAL_MUTEX_UNLOCK(&gFinBlockMutex); return rc; }