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 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 _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; }
static ClRcT clLogMasterEoEntryCheckpoint(ClLogMasterEoDataT *pMasterEoEntry) { ClRcT rc = CL_OK; ClBufferHandleT hEoEntryBuf = CL_HANDLE_INVALID_VALUE; ClUint8T *pBuffer = NULL; ClUint32T bufferLen = 0; ClVersionT version = { CL_RELEASE_VERSION, CL_MAJOR_VERSION, CL_MINOR_VERSION }; CL_LOG_DEBUG_TRACE(("Enter")); rc = clBufferCreate(&hEoEntryBuf); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferCreate(): rc[0x %x]", rc)); return rc; } rc = clXdrMarshallClVersionT(&version, hEoEntryBuf, 0); if( CL_OK != rc) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClVersionT(): rc[%#x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK); return rc; } rc = clXdrMarshallClUint16T(&(pMasterEoEntry->nextStreamId), hEoEntryBuf, 0); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clXdrMarshallClUint16T(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK); return rc; } rc = clBufferLengthGet(hEoEntryBuf, &bufferLen); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferLengthGet: rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK); return rc; } rc = clBufferFlatten(hEoEntryBuf, &pBuffer); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clBufferFlatten(): rc[0x %x]", rc)); CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK); return rc; } rc = clCkptSectionOverwrite(pMasterEoEntry->hCkpt, &gLogMasterDefaultSectionId, pBuffer, bufferLen); if( CL_OK != rc ) { CL_LOG_DEBUG_ERROR(("clCkptSectionOverwrite(): rc[0x %x]", rc)); } clHeapFree(pBuffer); CL_LOG_CLEANUP(clBufferDelete(&hEoEntryBuf), CL_OK); CL_LOG_DEBUG_TRACE(("Exit")); return rc; }
int clGmsSendMsg(ClGmsViewMemberT *memberNodeInfo, ClGmsGroupIdT groupId, ClGmsMessageTypeT msgType, ClGmsMemberEjectReasonT ejectReason, ClUint32T dataSize, ClPtrT dataPtr) { mar_req_header_t header = {0}; struct VDECL(req_exec_gms_nodejoin) req_exec_gms_nodejoin = {{0}}; struct iovec req_exec_gms_iovec = {0}; int result = -1; ClRcT rc = CL_OK; ClUint32T clusterVersion = 0; ClBufferHandleT bufferHandle = 0; ClUint8T *message = NULL; ClUint32T length = 0; ClPtrT temp = NULL; rc = clNodeCacheMinVersionGet(NULL, &clusterVersion); if(clusterVersion >= CL_VERSION_CODE(5, 0, 0) && clAspNativeLeaderElection()) { clLog(DBG, OPN, AIS, "Skipped sending msgtype [%d] since node cache is used to form the cluster view", msgType); return 0; } if (rc != CL_OK) { clLog(ERROR,OPN,AIS, "Error while getting version from the version cache. rc 0x%x",rc); curVer.releaseCode = CL_RELEASE_VERSION; curVer.majorVersion = CL_MAJOR_VERSION; curVer.minorVersion = CL_MINOR_VERSION; } else { curVer.releaseCode = CL_VERSION_RELEASE(clusterVersion); curVer.majorVersion = CL_VERSION_MAJOR(clusterVersion); curVer.minorVersion = CL_VERSION_MINOR(clusterVersion); } /* Get the version and send it */ req_exec_gms_nodejoin.version.releaseCode = curVer.releaseCode; req_exec_gms_nodejoin.version.majorVersion = curVer.majorVersion; req_exec_gms_nodejoin.version.minorVersion = curVer.minorVersion; /* For now we send message without caring about version. Later on * we need to change it accordingly */ switch(msgType) { case CL_GMS_CLUSTER_JOIN_MSG: case CL_GMS_CLUSTER_LEAVE_MSG: case CL_GMS_CLUSTER_EJECT_MSG: clLog(DBG,OPN,AIS, "Sending cluster %s multicast message", msgType == CL_GMS_CLUSTER_JOIN_MSG ? "join": msgType == CL_GMS_CLUSTER_LEAVE_MSG ? "leave" : "eject"); req_exec_gms_nodejoin.ejectReason = ejectReason; memcpy (&req_exec_gms_nodejoin.specificMessage.gmsClusterNode, &memberNodeInfo->clusterMember, sizeof (ClGmsClusterMemberT)); req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle; break; case CL_GMS_GROUP_CREATE_MSG: case CL_GMS_GROUP_DESTROY_MSG: case CL_GMS_GROUP_JOIN_MSG: case CL_GMS_GROUP_LEAVE_MSG: clLog(DBG,OPN,AIS, "Sending group %s multicast message", msgType == CL_GMS_GROUP_CREATE_MSG ? "create" : msgType == CL_GMS_GROUP_DESTROY_MSG ? "destroy" : msgType == CL_GMS_GROUP_JOIN_MSG ? "join" : "leave"); memcpy (&req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode, &memberNodeInfo->groupMember, sizeof (ClGmsGroupMemberT)); memcpy (&req_exec_gms_nodejoin.specificMessage.groupMessage.groupData, &memberNodeInfo->groupData, sizeof(ClGmsGroupInfoT)); req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle; break; case CL_GMS_COMP_DEATH: clLog(DBG,OPN,AIS, "Sending comp death multicast message"); memcpy (&req_exec_gms_nodejoin.specificMessage.groupMessage.gmsGroupNode, &memberNodeInfo->groupMember, sizeof (ClGmsGroupMemberT)); req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle; break; case CL_GMS_LEADER_ELECT_MSG: clLog(DBG,OPN,AIS, "Sending leader elect multicast message"); memcpy (&req_exec_gms_nodejoin.specificMessage.gmsClusterNode, &memberNodeInfo->clusterMember, sizeof (ClGmsClusterMemberT)); req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle; break; case CL_GMS_SYNC_MESSAGE: clLog(DBG,OPN,AIS, "Sending gms synch multicast message"); req_exec_gms_nodejoin.dataPtr = dataPtr; break; case CL_GMS_GROUP_MCAST_MSG: memcpy (&req_exec_gms_nodejoin.specificMessage.mcastMessage.groupInfo.gmsGroupNode, &memberNodeInfo->groupMember, sizeof (ClGmsGroupMemberT)); memcpy (&req_exec_gms_nodejoin.specificMessage.mcastMessage.groupInfo.groupData, &memberNodeInfo->groupData, sizeof(ClGmsGroupInfoT)); req_exec_gms_nodejoin.contextHandle = memberNodeInfo->contextHandle; req_exec_gms_nodejoin.specificMessage.mcastMessage.userDataSize = dataSize; req_exec_gms_nodejoin.dataPtr = dataPtr; break; default: clLog(DBG,OPN,AIS, "Requested wrong message to be multicasted. Message type %d", msgType); return CL_GMS_RC(CL_ERR_INVALID_PARAMETER); } req_exec_gms_nodejoin.gmsMessageType = msgType; req_exec_gms_nodejoin.gmsGroupId = groupId; /* Create a buffer handle and marshall the eliments */ rc = clBufferCreate(&bufferHandle); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to create buffer while sending message on totem. rc 0x%x",rc); return rc; } rc = marshallReqExecGmsNodeJoin(&req_exec_gms_nodejoin,bufferHandle); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to marshall the data while sending message on totem. rc 0x%x",rc); goto buffer_delete_return; } rc = clBufferLengthGet(bufferHandle, &length); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to get buffer length. rc 0x%x",rc); goto buffer_delete_return; } rc = clBufferFlatten(bufferHandle, &message); if (rc != CL_OK) { clLogError(OPN,AIS, "clBufferFlatten failed with rc 0x%x",rc); goto buffer_delete_return; } header.id = SERVICE_ID_MAKE (GMS_SERVICE, MESSAGE_REQ_EXEC_GMS_NODEJOIN); header.size = length + sizeof(mar_req_header_t); /* We need to prepend the total message length in the beginning of the * message so that we can find the length while unmarshalling */ temp = clHeapAllocate(header.size); if (temp == NULL) { clLogError(OPN,AIS, "Failed to allocate memory while sending the message"); goto buffer_delete_return; } memcpy(temp,&header, sizeof(mar_req_header_t)); memcpy(temp+sizeof(mar_req_header_t), message, length); req_exec_gms_iovec.iov_base = temp; req_exec_gms_iovec.iov_len = length + sizeof(mar_req_header_t); result = totempg_groups_mcast_joined (openais_group_handle, &req_exec_gms_iovec, 1, TOTEMPG_AGREED); clLog(DBG,OPN,AIS, "Done with sending multicast message of type %d",msgType); buffer_delete_return: if (message != NULL) clHeapFree(message); if (temp != NULL) clHeapFree(temp); clBufferDelete(&bufferHandle); return result; }
static int gms_nodejoin_send (void) { /* For now this function sends only latest version. It needs to be * modified in future when version changes */ /* Send the join message with given version */ mar_req_header_t header = {0}; struct VDECL(req_exec_gms_nodejoin) req_exec_gms_nodejoin; struct iovec req_exec_gms_iovec; ClGmsClusterMemberT thisGmsClusterNode; int result; ClRcT rc = CL_OK; ClUint32T clusterVersion; ClBufferHandleT bufferHandle = 0; ClUint8T *message = NULL; ClPtrT temp = NULL; ClUint32T length = 0; rc = clNodeCacheMinVersionGet(NULL, &clusterVersion); if (rc != CL_OK) { clLog(ERROR,OPN,AIS, "Error while getting version from the version cache. rc 0x%x",rc); curVer.releaseCode = CL_RELEASE_VERSION; curVer.majorVersion = CL_MAJOR_VERSION; curVer.minorVersion = CL_MINOR_VERSION; } else { curVer.releaseCode = CL_VERSION_RELEASE(clusterVersion); curVer.majorVersion = CL_VERSION_MAJOR(clusterVersion); curVer.minorVersion = CL_VERSION_MINOR(clusterVersion); } clLog(DBG,OPN,AIS, "This node is sending join message for version %d, %d, %d", curVer.releaseCode, curVer.majorVersion, curVer.minorVersion); /* Get the version and send it */ req_exec_gms_nodejoin.version.releaseCode = curVer.releaseCode; req_exec_gms_nodejoin.version.majorVersion = curVer.majorVersion; req_exec_gms_nodejoin.version.minorVersion = curVer.minorVersion; _clGmsGetThisNodeInfo(&thisGmsClusterNode); // node join is send for default cluster group - 0 req_exec_gms_nodejoin.gmsGroupId = 0; memcpy (&req_exec_gms_nodejoin.specificMessage.gmsClusterNode, &thisGmsClusterNode, sizeof (ClGmsClusterMemberT)); req_exec_gms_nodejoin.gmsMessageType = CL_GMS_CLUSTER_JOIN_MSG; /* Create a buffer handle and marshall the elements */ rc = clBufferCreate(&bufferHandle); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to create buffer while sending message on totem. rc 0x%x",rc); return rc; } rc = marshallReqExecGmsNodeJoin(&req_exec_gms_nodejoin,bufferHandle); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to marshall the data while sending message on totem. rc 0x%x",rc); goto buffer_delete_return; } rc = clBufferLengthGet(bufferHandle, &length); if (rc != CL_OK) { clLogError(OPN,AIS, "Failed to get buffer length. rc 0x%x",rc); goto buffer_delete_return; } rc = clBufferFlatten(bufferHandle, &message); if (rc != CL_OK) { clLogError(OPN,AIS, "clBufferFlatten failed with rc 0x%x",rc); goto buffer_delete_return; } /* We need to prepend the total message length in the beginning of the * message so that we can find the length while unmarshalling */ temp = clHeapAllocate(length + sizeof(mar_req_header_t)); if (temp == NULL) { clLogError(OPN,AIS, "Failed to allocate memory while sending the message"); goto buffer_delete_return; } header.id = SERVICE_ID_MAKE (GMS_SERVICE, MESSAGE_REQ_EXEC_GMS_NODEJOIN); header.size = length + sizeof(mar_req_header_t); memcpy(temp,&header,sizeof(mar_req_header_t)); memcpy(temp+sizeof(mar_req_header_t), message, length); req_exec_gms_iovec.iov_base = temp; req_exec_gms_iovec.iov_len = length + sizeof(mar_req_header_t); clLog(DBG,OPN,AIS, "Sending node join from this node in sync_process"); result = totempg_groups_mcast_joined (openais_group_handle, &req_exec_gms_iovec, 1, TOTEMPG_AGREED); buffer_delete_return: if (message != NULL) clHeapFree(message); if (temp != NULL) clHeapFree(temp); clBufferDelete(&bufferHandle); return result; }