static ClRcT _clPluginHelperGetLinkName(const ClCharT *xportType, ClCharT *inf) { ClCharT net_addr[CL_MAX_FIELD_LENGTH] = "eth0"; ClCharT *linkName = NULL; ClCharT envlinkNameType[CL_MAX_FIELD_LENGTH] = { 0 }; if (!xportType) { return CL_ERR_INVALID_PARAMETER; } else { snprintf(envlinkNameType, CL_MAX_FIELD_LENGTH, "ASP_%s_LINK_NAME", xportType); linkName = getenv(envlinkNameType); if (linkName == NULL) { // try with default LINK_NAME linkName = getenv("LINK_NAME"); if (linkName == NULL) { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "%s and LINK_NAME environment variable is not exported. Using 'eth0:10' interface as default", envlinkNameType); } else { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "LINK_NAME env is exported. Value is %s", linkName); net_addr[0] = 0; strncat(net_addr, linkName, sizeof(net_addr)-1); ClCharT *token = NULL; strtok_r(net_addr, ":", &token); } snprintf(inf, CL_MAX_FIELD_LENGTH, "%s:%d", net_addr, gIocLocalBladeAddress + 10); } else { clLogInfo("IOC", CL_LOG_PLUGIN_HELPER_AREA, "%s env is exported. Value is %s", envlinkNameType, linkName); snprintf(inf, CL_MAX_FIELD_LENGTH, "%s", linkName); } } return CL_OK; }
static void cpmPayload2StandbySC(const ClGmsClusterNotificationBufferT *notificationBuffer, ClCpmLocalInfoT *pCpmLocalInfo) { ClUint32T rc = CL_OK; if(gpClCpm->haState == CL_AMS_HA_STATE_STANDBY) { clLogWarning(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_AMS, "Payload node already promoted to Deputy. Skipping initialization of controller functions"); return; } clLogNotice(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_AMS, "Payload node promoted to deputy. Initializing System controller functions on this node."); gpClCpm->pCpmConfig->cpmType = CL_CPM_GLOBAL; rc = cpmUpdateTL(CL_AMS_HA_STATE_STANDBY); if (rc != CL_OK) { clLogWrite(CL_LOG_HANDLE_APP, CL_LOG_SEV_DEBUG, NULL, CL_CPM_LOG_1_TL_UPDATE_FAILURE, rc); } rc = clAmsStart(&gAms, CL_AMS_INSTANTIATE_MODE_STANDBY); gpClCpm->haState = CL_AMS_HA_STATE_STANDBY; gpClCpm->activeMasterNodeId = notificationBuffer->leader; gpClCpm->deputyNodeId = notificationBuffer->deputy; if (CL_OK != rc) { clLogCritical(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_AMS, "Unable to initialize AMS, " "error = [%#x]", rc); cpmSelfShutDown(); return; } clLogInfo(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_AMS, "initialization of AMS is successful. "); if (gpClCpm->bmTable->currentBootLevel == pCpmLocalInfo->defaultBootLevel) { cpmInitializeStandby(); } clLogNotice(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_AMS, "Payload to System Controller conversion done"); return ; }
static ClRcT compConfigSet(ClCpmComponentT *comp, ClUint64T mask, ClCharT *instantiateCommand, ClAmsCompPropertyT property) { ClRcT rc = CL_OK; if ((mask == CL_AMS_CONFIG_ATTR_ALL) || (mask & COMP_CONFIG_INSTANTIATE_COMMAND)) { rc = cpmCompParseArgs(comp->compConfig, instantiateCommand, NULL); if (rc != CL_OK) goto out; } if ((mask == CL_AMS_CONFIG_ATTR_ALL) || (mask & COMP_CONFIG_PROPERTY)) { comp->compConfig->compProperty = property; } clLogNotice("COMP", "CONFIG", "Updated comp config for component [%s]", comp->compConfig->compName); out: return rc; }
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; }
static ClRcT _clPluginHelperGetLinkName(const ClCharT *xportType, ClCharT *inf) { ClCharT net_addr[CL_MAX_FIELD_LENGTH] = "eth0"; ClCharT *linkName = NULL; ClCharT envlinkNameType[CL_MAX_FIELD_LENGTH] = { 0 }; if (!xportType) { return CL_ERR_INVALID_PARAMETER; } else { snprintf(envlinkNameType, CL_MAX_FIELD_LENGTH, "ASP_%s_LINK_NAME", xportType); linkName = getenv(envlinkNameType); if (linkName == NULL) { // try with default LINK_NAME linkName = getenv("LINK_NAME"); if (linkName == NULL) { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "%s and LINK_NAME environment variable is not exported. Using 'eth0:10' interface as default", envlinkNameType); } else { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "LINK_NAME env is exported. Value is %s", linkName); net_addr[0] = 0; strncat(net_addr, linkName, sizeof(net_addr)-1); ClCharT *token = NULL; strtok_r(net_addr, ":", &token); } /* If we are not using the existing IP addr then we need to use a virtual device to make sure we don't overwrite an already-configured address */ if (!ASP_UDP_USE_EXISTING_IP) snprintf(inf, CL_MAX_FIELD_LENGTH, "%s:%d", net_addr, gIocLocalBladeAddress + 10); /* If we ARE using the existing IP, then whatever interfaces LINK_NAME is set to IS that address */ else snprintf(inf, CL_MAX_FIELD_LENGTH, "%s", net_addr); } else { clLogInfo("IOC", CL_LOG_PLUGIN_HELPER_AREA, "%s env is exported. Value is %s", envlinkNameType, linkName); snprintf(inf, CL_MAX_FIELD_LENGTH, "%s", linkName); } } return CL_OK; }
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 clAmsDBGetSISUList(ClAmsMgmtDBHandleT db, ClAmsEntityT *entity, ClAmsSISUExtendedRefBufferT *sisuRefBuffer) { ClRcT rc = CL_OK; ClAmsSISUExtendedRefBufferT buffer = {0}; if(!sisuRefBuffer) sisuRefBuffer = &buffer; rc = clAmsMgmtDBGetSISUList(db, entity, sisuRefBuffer); if(rc != CL_OK) return rc; if(sisuRefBuffer == &buffer) { clLogNotice("DBA", "READ", "Getting SI [%s] su list", entity->name.value); dumpSISURefBuffer(sisuRefBuffer); clLogNotice("DBA", "READ", "Done getting SI [%s] su list", entity->name.value); if(sisuRefBuffer->entityRef) clHeapFree(sisuRefBuffer->entityRef); } return rc; }
void clPluginHelperAddRemVirtualAddress(const ClCharT *cmd, const ClPluginHelperVirtualIpAddressT *vip) { int up = 0; if (cmd[0] == 'u') up = 1; ClPluginHelperVirtualIpAddressT* vipCopy = (ClPluginHelperVirtualIpAddressT*) malloc(sizeof(ClPluginHelperVirtualIpAddressT)); memcpy(vipCopy, vip, sizeof(ClPluginHelperVirtualIpAddressT)); /* * Ignore configure if IP and dev are already existing on node */ if (_clCheckExistingDevIf(vipCopy->ip, vipCopy->dev)) { clLogInfo("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Ignored assignment IP address: %s, for device: %s", vipCopy->ip, vipCopy->dev); goto out; } if (vipCopy->ip && vipCopy->dev && vipCopy->netmask) { char execLine[301]; snprintf(execLine, 300, "%s/virtualIp %s %s %s %s %s ", ASP_BINDIR, cmd, vipCopy->ip, vipCopy->netmask, vipCopy->dev, vipCopy->subnetPrefix); clLogInfo("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Executing %s", execLine); __attribute__((unused)) ClRcT result = system(execLine); if (up) /* If we are coming up, do a gratuitous arp */ { clLogInfo("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Sending gratuitous arps: IP address: %s, device: %s", vipCopy->ip, vipCopy->dev); _clPluginHelperSendArp(vipCopy->ip, vipCopy->dev); clOsalTaskCreateDetached("arpTask", CL_OSAL_SCHED_OTHER, 0, 0, _clPluginHelperPummelArps, vipCopy); vipCopy = NULL; /* freed by the arp thread*/ } else { /* If we are going down, delay a bit so that the machine that takes over will not do so too soon. (the assumption being that the machine taking over will not do so until this remove returns) */ clLogInfo("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Removing IP; not sending gratuitous arps"); /* sleep(1); */ } } else { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Virtual IP work assignment values incorrect: got IP address: %s, device: %s, mask: %s, net prefix: %s", vipCopy->ip, vipCopy->dev, vipCopy->netmask, vipCopy->subnetPrefix); } out: if(vipCopy) free(vipCopy); }
ClRcT clAmsDBGetSUSIList(ClAmsMgmtDBHandleT db, ClAmsEntityT *entity, ClAmsSUSIExtendedRefBufferT *susiRefBuffer) { ClRcT rc = CL_OK; ClAmsSUSIExtendedRefBufferT buffer = {0}; if(!susiRefBuffer) susiRefBuffer = &buffer; rc = clAmsMgmtDBGetSUAssignedSIsList(db, entity, susiRefBuffer); if(rc != CL_OK) return rc; if(susiRefBuffer == &buffer) { clLogNotice("DBA", "READ", "Getting SU [%s] si list", entity->name.value); dumpSUSIRefBuffer(susiRefBuffer); clLogNotice("DBA", "READ", "Done getting SU [%s] si list", entity->name.value); if(susiRefBuffer->entityRef) clHeapFree(susiRefBuffer->entityRef); } return rc; }
static ClRcT _clPluginHelperHostToIp(const ClCharT *myHost, ClUint32T *ip) { struct hostent *host = NULL; struct hostent hostdata; ClCharT buf[129]; int errnum = 0; if (gethostbyname_r(myHost, &hostdata, buf, 128, &host, &errnum) || !host) { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Cannot resolve host string %s", myHost); return CL_ERR_LIBRARY; } *ip = *((ClUint32T*) host->h_addr_list[0]); return CL_OK; }
ClRcT clAmsDBGetCompCSIList(ClAmsMgmtDBHandleT db, ClAmsEntityT *entity, ClAmsCompCSIRefBufferT *csiRefBuffer) { ClAmsCompCSIRefBufferT buffer = {0}; ClRcT rc = CL_OK; if(!csiRefBuffer) csiRefBuffer = &buffer; rc = clAmsMgmtDBGetCompCSIList(db, entity, csiRefBuffer); if(rc != CL_OK) return rc; if(csiRefBuffer == &buffer) { clLogNotice("DBA", "READ", "Getting comp csi list"); dumpCSIRefBuffer(csiRefBuffer); clLogNotice("DBA", "READ", "Done getting comp csi list"); clAmsMgmtFreeCompCSIRefBuffer(csiRefBuffer); } return rc; }
static ClRcT _clPluginHelperDevToMac(const ClCharT* dev, char mac[CL_MAC_ADDRESS_LENGTH]) { struct ifreq req; int sd = socket(AF_INET, SOCK_STREAM, 0); memset(&req, 0, sizeof(struct ifreq)); strcpy(req.ifr_name, dev); req.ifr_addr.sa_family = AF_UNSPEC; if (ioctl(sd, SIOCGIFHWADDR, &req) == -1) { int err = errno; clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "No device %s, hwaddr errno: %d", dev, err); return CL_ERR_LIBRARY; } memcpy(mac, &(req.ifr_addr.sa_data), CL_MAC_ADDRESS_LENGTH); close(sd); return CL_OK; }
static ClRcT clAmsEntityRecoveryReset(ClAmsEntityT *pEntity, ClAmsThresholdT *pThreshold) { ClRcT rc = CL_OK; ClAmsAdminStateT adminState = gClAmsEntityTriggerRecoveryResetMap[pEntity->type][pThreshold->recovery]; switch(adminState) { case CL_AMS_ADMIN_STATE_NONE: break; case CL_AMS_ADMIN_STATE_UNLOCKED: if(pEntity->type == CL_AMS_ENTITY_TYPE_CSI) return clAmsCSIRecovery(pEntity, pThreshold); if(pEntity->type == CL_AMS_ENTITY_TYPE_COMP || pEntity->type == CL_AMS_ENTITY_TYPE_SU) return clAmsCompRecovery(pEntity, pThreshold); clAmsMgmtEntityRepaired(gClAmsEntityTriggerMgmtHandle, pEntity); clLogNotice("RECOVERY", "RESET", "Unlocking [%s] -> [%.*s]", CL_AMS_STRING_ENTITY_TYPE(pEntity->type), pEntity->name.length-1, pEntity->name.value); rc = clAmsMgmtEntityUnlock(gClAmsEntityTriggerMgmtHandle, pEntity); if(rc != CL_OK) { clLogError("RECOVERY", "RESET", "Unlock returned [%#x]", rc); } break; default:; } return rc; }
/* * Returns ip address on a network interface given its name... */ ClRcT clPluginHelperDevToIpAddress(const ClCharT *dev, ClCharT *addrStr) { int sd; struct ifreq req; ClCharT ipAddress[INET_ADDRSTRLEN] = { 0 }; int rc = 1; /* Get a socket handle. */ sd = socket(PF_INET, SOCK_DGRAM, 0); if (sd < 0) { clLogError("IOC", CL_LOG_PLUGIN_HELPER_AREA, "open socket failed with error [%s]", strerror(errno)); return rc; } memset(&req, 0, sizeof(struct ifreq)); strcpy(req.ifr_name, dev); req.ifr_addr.sa_family = PF_UNSPEC; if (ioctl(sd, SIOCGIFADDR, &req) == -1) { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Operation command failed: [%s]", strerror(errno)); close(sd); return rc; } struct in_addr *in4_addr = &((struct sockaddr_in*) &((struct ifreq *) &req)->ifr_addr)->sin_addr; if (!inet_ntop(PF_INET, (const void *) in4_addr, ipAddress, sizeof(ipAddress))) { struct in6_addr *in6_addr = &((struct sockaddr_in6*) &((struct ifreq *) &req)->ifr_addr)->sin6_addr; if (!inet_ntop(PF_INET6, (const void *) in6_addr, ipAddress, sizeof(ipAddress))) { goto out; } } /* successful */ rc = 0; strncat(addrStr, ipAddress, sizeof(ipAddress) - 1); out: close(sd); return rc; }
static ClAmsEntityTriggerT *clAmsEntityTriggerCreate(ClAmsEntityT *pEntity, ClMetricT *pMetric) { ClAmsEntityTriggerT *pEntityTrigger = NULL; if(!pEntity || !pMetric) goto out; if(pMetric->id >= CL_METRIC_MAX) { clLogError("TRIGGER", "CREATE", "Invalid metric [%#x] for entity [%.*s]", pMetric->id, pEntity->name.length-1, pEntity->name.value); goto out; } clOsalMutexLock(&gClAmsEntityTriggerList.list.mutex); pEntityTrigger = clAmsEntityTriggerFind(pEntity); if(!pEntityTrigger) { clOsalMutexUnlock(&gClAmsEntityTriggerList.list.mutex); pEntityTrigger = (ClAmsEntityTriggerT*) clHeapCalloc(1, sizeof(*pEntityTrigger)); if(!pEntityTrigger) { clLogError("TRIGGER", "CREATE", "Memory allocation failure"); goto out; } memcpy(&pEntityTrigger->entity, pEntity, sizeof(pEntityTrigger->entity)); clAmsEntityTriggerLoadDefaults(pEntityTrigger, CL_METRIC_ALL); clLogNotice("TRIGGER", "CREATE", "Entity [%.*s], Metric [%#x]", pEntity->name.length-1, pEntity->name.value, pMetric->id); clOsalMutexLock(&gClAmsEntityTriggerList.list.mutex); clAmsEntityTriggerListAdd(pEntityTrigger); } clAmsEntityTriggerUpdate(pEntityTrigger, pMetric); clAmsEntityTriggerCheck(pEntityTrigger, pMetric); clOsalMutexUnlock(&gClAmsEntityTriggerList.list.mutex); out: return pEntityTrigger; }
static ClRcT _clPluginHelperDevToIfIndex(const ClCharT *dev, int *ifindex) { struct ifreq req; int sd = socket(AF_INET, SOCK_STREAM, 0); memset(&req, 0, sizeof(struct ifreq)); strcpy(req.ifr_name, dev); req.ifr_addr.sa_family = AF_UNSPEC; if (ioctl(sd, SIOCGIFINDEX, &req) == -1) { int err = errno; clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "No device %s, ifindex errno: %d", dev, err); *ifindex = 0; return CL_ERR_LIBRARY; } *ifindex = req.ifr_ifindex; close(sd); return CL_OK; }
static ClRcT clAmsEntityTriggerUpdate(ClAmsEntityTriggerT *pEntityTrigger, ClMetricT *pMetric) { ClMetricIdT start = pMetric->id; ClMetricIdT end = (ClMetricIdT) (start+1); register ClInt32T i; if(start == CL_METRIC_ALL) { start = (ClMetricIdT) (start + 1) ; end = CL_METRIC_MAX; } for(i = start; i < end; ++i) { pEntityTrigger->thresholds[i].metric.currentThreshold = pMetric->currentThreshold; clLogNotice("TRIGGER", "MODIFY", "Entity [%.*s], Threshold [%d]", pEntityTrigger->entity.name.length-1, pEntityTrigger->entity.name.value, pMetric->currentThreshold); } return CL_OK; }
static void clAmsMgmtOIExtendedCacheAdd(ClAmsMgmtOIExtendedClassTypeT type, ClCorInstanceIdT instance, ClAmsMgmtOIExtendedEntityConfigT *pConfig, ClUint32T configSize) { struct hashStruct **table = NULL; ClAmsMgmtOIExtendedCacheT *cacheEntry = NULL; if(type >= CL_AMS_MGMT_OI_EXTENDED_CLASS_MAX || !pConfig || !configSize) return; clOsalMutexLock(&gClAmsMgmtOICacheMutex); table = gClAmsMgmtOIExtendedCacheTable[type]; if( (cacheEntry = clAmsMgmtOIExtendedCacheFind(table, instance) ) ) { CL_ASSERT(cacheEntry->pConfig != NULL); if(cacheEntry->configSize != configSize) { clHeapFree(cacheEntry->pConfig); cacheEntry->pConfig = clHeapCalloc(1, configSize); CL_ASSERT(cacheEntry->pConfig != NULL); cacheEntry->configSize = configSize; } memcpy(cacheEntry->pConfig, pConfig, configSize); } else { ClAmsMgmtOIExtendedEntityConfigT *pExtendedConfig = NULL; cacheEntry = clHeapCalloc(1, sizeof(*cacheEntry)); CL_ASSERT(cacheEntry != NULL); pExtendedConfig = clHeapCalloc(1, configSize); CL_ASSERT(pExtendedConfig != NULL); cacheEntry->pConfig = pExtendedConfig; cacheEntry->instance = instance; memcpy(cacheEntry->pConfig, pConfig, configSize); hashAdd(table, entityCacheHashKey(instance), &cacheEntry->hash); clLogNotice("AMF", "MGMT", "Added entity [%s], instance [%d] to the extended class [%s]", pConfig->entity.name.value, instance, gClAmsMgmtOIExtendedCacheStrTable[type]); } clOsalMutexUnlock(&gClAmsMgmtOICacheMutex); }
static void clAmsMgmtOICacheAdd(ClCorInstanceIdT instance, ClAmsEntityT *entity) { struct hashStruct **table = NULL; ClAmsMgmtOICacheT *cacheEntry = NULL; if(!entity || entity->type > CL_AMS_ENTITY_TYPE_MAX) return; clOsalMutexLock(&gClAmsMgmtOICacheMutex); table = gClAmsMgmtOICacheTable[entity->type]; if( (cacheEntry = clAmsMgmtOICacheFind(table, instance, entity) ) ) { memcpy(&cacheEntry->entity, entity, sizeof(cacheEntry->entity)); } else { cacheEntry = clHeapCalloc(1, sizeof(*cacheEntry)); CL_ASSERT(cacheEntry != NULL); cacheEntry->instance = instance; memcpy(&cacheEntry->entity, entity, sizeof(cacheEntry->entity)); hashAdd(table, entityCacheHashKey(instance), &cacheEntry->hash); clLogNotice("AMF", "MGMT", "Added entity [%s], instance [%d] to the cache", entity->name.value, instance); } clOsalMutexUnlock(&gClAmsMgmtOICacheMutex); }
static void *clAmsMgmtMigrateListUnlock(void *arg) { ClAmsMgmtMigrateListT *unlockList = (ClAmsMgmtMigrateListT*) arg; ClUint32T i; ClRcT rc = CL_OK; if(!unlockList) return NULL; #if 0 /* * The user could modify the SI-CSI list for the newly created SI. * So we don't want to unlock this SI and have this assigned active to an SU * when running under SG reduction procedure. */ for(i = 0; i < unlockList->si.count; ++i) { ClAmsEntityT *si = unlockList->si.entity+i; clLogNotice("AMS", "MIGRATE", "Unlocking created SI [%s]", si->name.value); clAmsMgmtEntityUnlock(gHandle, si); } #endif for(i = 0; i < unlockList->node.count; ++i) { ClAmsEntityT *node = unlockList->node.entity + i; clLogNotice("AMS", "MIGRATE", "Unlocking created Node [%s]", node->name.value); rc = clAmsMgmtEntityLockAssignment(gHandle, node); if(rc == CL_OK) { rc = clAmsMgmtEntityUnlock(gHandle, node); } if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "Node [%s] unlock returned [%#x]", node->name.value, rc); } } #if 0 for(i = 0; i < unlockList->su.count; ++i) { ClAmsEntityT *su = unlockList->su.entity + i; clLogNotice("AMS", "MIGRATE", "Unlocking created SU [%s]", su->name.value); rc = clAmsMgmtEntityLockAssignment(gHandle, su); if(rc == CL_OK) { rc = clAmsMgmtEntityUnlock(gHandle, su); } if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "SU [%s] unlock returned [%#x]", su->name.value, rc); } } #endif clHeapFree(unlockList->si.entity); clHeapFree(unlockList->node.entity); clHeapFree(unlockList->su.entity); clHeapFree(unlockList); return NULL; }
ClRcT cpmNodeAdd(ClCharT *nodeName) { ClRcT rc = CL_OK; ClCpmLT *cpm = NULL; ClUint16T nodeKey = 0; ClCpmSlotInfoT slotInfo = {0}; if (!nodeName) { clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM, "NULL pointer passed."); goto failure; } clOsalMutexLock(gpClCpm->cpmTableMutex); rc = cpmNodeFindLocked((SaUint8T *)nodeName, &cpm); clOsalMutexUnlock(gpClCpm->cpmTableMutex); if (cpm) { clLogWarning(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM, "Node [%s] already exists on this node.", nodeName); rc = CL_CPM_RC(CL_ERR_ALREADY_EXIST); goto failure; } cpm = (ClCpmLT*) clHeapAllocate(sizeof(ClCpmLT)); if (!cpm) { clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM, "Unable to allocate memory"); goto failure; } memset(cpm, 0, sizeof(ClCpmLT)); strncpy(cpm->nodeName, nodeName, strlen(nodeName)); rc = clCksm16bitCompute((ClUint8T *)cpm->nodeName, strlen(cpm->nodeName), &nodeKey); if (CL_OK != rc) { clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM, "Failed to compute checksum for node, " "error [%#x]", rc); goto failure; } /* * Filling the CPML with defaults. */ saNameSet(&cpm->nodeType, nodeName); saNameSet(&cpm->nodeIdentifier, nodeName); /* * Set the class type to CLASS_C. */ strncpy(cpm->classType, "CL_AMS_NODE_CLASS_C", sizeof(cpm->classType)-1); /* * Get the MOID of the master node. Assuming that node add is * only invoked on the master. */ slotInfo.slotId = clIocLocalAddressGet(); rc = clCpmSlotInfoGet(CL_CPM_SLOT_ID, &slotInfo); if(rc == CL_OK) { rc = cpmCorMoIdToMoIdNameGet(&slotInfo.nodeMoId, &cpm->nodeMoIdStr); } if(rc != CL_OK) { if((CL_GET_ERROR_CODE(rc) != CL_IOC_ERR_COMP_UNREACHABLE) && (CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_EXIST) && (CL_GET_ERROR_CODE(rc) != CL_ERR_NOT_SUPPORTED)) { goto failure; } else { rc = CL_OK; clLogWarning(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM, "COR server not running so cannot discover the Node's MoId"); } } clOsalMutexLock(gpClCpm->cpmTableMutex); rc = clCntNodeAdd(gpClCpm->cpmTable, (ClCntKeyHandleT)(ClWordT)nodeKey, (ClCntDataHandleT) cpm, NULL); if (CL_OK != rc) { clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM, "Failed to add node to the CPM node table, " "error [%#x]", rc); clOsalMutexUnlock(gpClCpm->cpmTableMutex); goto failure; } ++gpClCpm->noOfCpm; clOsalMutexUnlock(gpClCpm->cpmTableMutex); /* * Add this to the slotinfo. */ clOsalMutexLock(&gpClCpm->cpmMutex); rc = cpmSlotClassAdd(&cpm->nodeType, &cpm->nodeIdentifier, 0); clOsalMutexUnlock(&gpClCpm->cpmMutex); if(rc != CL_OK) { clLogError(CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_MGM, "Node [%s] class add returned [%#x]", cpm->nodeType.value, rc); } clLogNotice("DYN", "NODE", "Node [%s] added to the cpm table with identity [%.*s]", cpm->nodeName, cpm->nodeIdentifier.length, cpm->nodeIdentifier.value); return CL_OK; failure: return rc; }
/* * Create objects for the static AMF entities. */ ClRcT corAmfTreeInitialize(void) { ClRcT rc = CL_OK; if(gClAmfMibLoaded) { rc = corAmfMibTreeInitialize(); } else { ClVersionT version = {'B', 0x1 , 0x1}; ClCorMOIdT moId; ClAmsEntityBufferT nodeList = {0}; ClAmsEntityBufferT suList = {0}; ClAmsEntityBufferT compList = {0}; ClAmsEntityBufferT sgList = {0}; ClAmsEntityBufferT siList = {0}; ClAmsEntityBufferT csiList = {0}; ClCorClassTypeT classIds[CL_AMS_ENTITY_TYPE_MAX+2] = {0}; ClCorMOClassPathT sgClassPath; ClInt32T i; rc = corAmfEntityInitialize(); if(rc != CL_OK) goto out; rc = clAmsMgmtInitialize(&mgmtHandle, NULL, &version); if(rc != CL_OK) { clLogError("COR", "AMF", "Mgmt initialize returned [%#x]", rc); goto out; } if( (rc = clAmsMgmtGetNodeList(mgmtHandle, &nodeList)) != CL_OK) { clLogError("COR", "AMF", "Node list returned [%#x]", rc); goto out; } /* * Create object heirarchy for nodes/sus/comps. */ for(i = 0; i < nodeList.count; ++i) { ClInt32T j; ClCorMOClassPathT nodeClassPath; rc = clCorMoIdInitialize(&moId); CL_ASSERT(rc == CL_OK); rc = clCorNodeNameToMoIdGet(nodeList.entity[i].name, &moId); if(rc != CL_OK) { clLogError("COR", "AMF", "Node name to moid get for [%s] failed with [%#x]", nodeList.entity[i].name.value, rc); goto out; } rc = clCorMoClassPathInitialize(&nodeClassPath); CL_ASSERT(rc == CL_OK); rc = clCorMoIdToMoClassPathGet(&moId, &nodeClassPath); CL_ASSERT(rc == CL_OK); /* * Now get nodes su list. */ rc = clAmsMgmtGetNodeSUList(mgmtHandle, &nodeList.entity[i], &suList); if(rc != CL_OK) { clLogError("COR", "AMF", "Node [%s] su list returned [%#x]", nodeList.entity[i].name.value, rc); goto out; } if(!classIds[CL_AMS_ENTITY_TYPE_SU]) { rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SU, classIds+CL_AMS_ENTITY_TYPE_SU); if(rc != CL_OK) { clLogError("COR", "AMF", "Class for entity SU not found"); goto out; } } if(!classIds[CL_AMS_ENTITY_TYPE_COMP]) { rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_COMP, classIds+CL_AMS_ENTITY_TYPE_COMP); if(rc != CL_OK) { clLogError("COR", "AMF", "Class for entity comp not found"); goto out; } } rc = clCorMoClassPathAppend(&nodeClassPath, classIds[CL_AMS_ENTITY_TYPE_SU]); CL_ASSERT(rc == CL_OK); rc = corAmfMoClassCreate("AMFSu", &nodeClassPath, NULL); if(rc != CL_OK) { if(CL_GET_ERROR_CODE(rc) != CL_COR_MO_TREE_ERR_FAILED_TO_ADD_NODE) goto out; } if(CL_GET_ERROR_CODE(rc) != CL_COR_MO_TREE_ERR_FAILED_TO_ADD_NODE) { rc = clCorMoClassPathAppend(&nodeClassPath, classIds[CL_AMS_ENTITY_TYPE_COMP]); CL_ASSERT(rc == CL_OK); rc = corAmfMoClassCreate("AMFComp", &nodeClassPath, NULL); if(rc != CL_OK) goto out; } else { rc = CL_OK; } for(j = 0; j < suList.count; ++j) { ClInt32T k; ClCorMOIdT suMoId; memcpy(&suMoId, &moId, sizeof(suMoId)); rc = clCorMoIdAppend(&suMoId, classIds[CL_AMS_ENTITY_TYPE_SU], j); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(0, &suList.entity[j], &suMoId); if(rc != CL_OK) goto out; rc = clAmsMgmtGetSUCompList(mgmtHandle, &suList.entity[j], &compList); if(rc != CL_OK) { goto out; } for(k = 0; k < compList.count; ++k) { ClCorMOIdT compMoId; memcpy(&compMoId, &suMoId, sizeof(compMoId)); rc = clCorMoIdAppend(&compMoId, classIds[CL_AMS_ENTITY_TYPE_COMP], k); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(0, &compList.entity[k], &compMoId); if(rc != CL_OK) goto out; } clHeapFree(compList.entity); compList.entity = NULL; } clHeapFree(suList.entity); suList.entity = NULL; } /* * Configure object heirarchy for SGs. */ rc = clAmsMgmtGetSGList(mgmtHandle, &sgList); if(rc != CL_OK) { clLogError("COR", "AMF", "SG list returned [%#x]", rc); goto out; } rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SG, &classIds[CL_AMS_ENTITY_TYPE_SG]); if(rc != CL_OK) { clLogError("COR", "AMF", "SG entity class not found"); goto out; } rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SG, &classIds[CL_AMS_ENTITY_TYPE_SI]); if(rc != CL_OK) { clLogError("COR", "AMF", "SI entity class not found"); goto out; } rc = corAmfEntityClassGet(CL_AMS_ENTITY_TYPE_SG, &classIds[CL_AMS_ENTITY_TYPE_CSI]); if(rc != CL_OK) { clLogError("COR", "AMF", "CSI entity class not found"); goto out; } rc = clCorMoClassPathInitialize(&sgClassPath); CL_ASSERT(rc == CL_OK); rc = clCorMoClassPathAppend(&sgClassPath, classIds[CL_AMS_ENTITY_TYPE_SG]); CL_ASSERT(rc == CL_OK); rc = corAmfMoClassCreate("AMFSg", &sgClassPath, NULL); if(rc != CL_OK) goto out; rc = clCorMoClassPathAppend(&sgClassPath, classIds[CL_AMS_ENTITY_TYPE_SI]); CL_ASSERT(rc == CL_OK); rc = corAmfMoClassCreate("AMFSi", &sgClassPath, NULL); if(rc != CL_OK) goto out; rc = clCorMoClassPathAppend(&sgClassPath, classIds[CL_AMS_ENTITY_TYPE_CSI]); CL_ASSERT(rc == CL_OK); rc = corAmfMoClassCreate("AMFCsi", &sgClassPath, NULL); if(rc != CL_OK) goto out; for(i = 0; i < sgList.count; ++i) { ClInt32T j; rc = clCorMoIdInitialize(&moId); CL_ASSERT(rc == CL_OK); rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SG], i); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(0, &sgList.entity[i], &moId); if(rc != CL_OK) goto out; rc = clAmsMgmtGetSGSIList(mgmtHandle, &sgList.entity[i], &siList); if(rc != CL_OK) { clLogError("COR", "AMF", "SI list get for SG [%s] returned [%#x]", sgList.entity[i].name.value, rc); goto out; } for(j = 0; j < siList.count; ++j) { ClInt32T k; ClCorMOIdT siMoId; memcpy(&siMoId, &moId, sizeof(siMoId)); rc = clCorMoIdAppend(&siMoId, classIds[CL_AMS_ENTITY_TYPE_SI], j); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(0, &siList.entity[j], &siMoId); if(rc != CL_OK) goto out; rc = clAmsMgmtGetSICSIList(mgmtHandle, &siList.entity[j], &csiList); if(rc != CL_OK) { clLogError("COR", "AMF", "CSI list for SI [%s] returned [%#x]", siList.entity[j].name.value, rc); goto out; } for(k = 0; k < csiList.count; ++k) { ClCorMOIdT csiMoId; memcpy(&csiMoId, &siMoId, sizeof(csiMoId)); rc = clCorMoIdAppend(&csiMoId, classIds[CL_AMS_ENTITY_TYPE_CSI], k); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(0, &csiList.entity[k], &csiMoId); if(rc != CL_OK) goto out; } clHeapFree(csiList.entity); csiList.entity = NULL; } clHeapFree(siList.entity); siList.entity = NULL; } /* * We are here when the objects are all created. Do a commit */ rc = corAmfObjectCommit(); if(rc != CL_OK) { clLogError("COR", "AMF", "Object commit returned [%#x]", rc); goto out; } clLogNotice("COR", "AMF", "COR AMF tree successfully initialized"); out: if(nodeList.entity) clHeapFree(nodeList.entity); if(suList.entity) clHeapFree(suList.entity); if(compList.entity) clHeapFree(compList.entity); if(sgList.entity) clHeapFree(sgList.entity); if(siList.entity) clHeapFree(siList.entity); if(csiList.entity) clHeapFree(csiList.entity); } return rc; }
ClRcT corAmfMibTreeInitialize(void) { ClRcT rc = CL_OK; ClVersionT version = {'B', 0x1 , 0x1}; ClCorMOIdT moId; ClCorMOIdT chassisMoid; ClAmsEntityBufferT nodeList = {0}; ClAmsEntityBufferT suList = {0}; ClAmsEntityBufferT compList = {0}; ClAmsEntityBufferT sgList = {0}; ClAmsEntityBufferT siList = {0}; ClAmsEntityBufferT csiList = {0}; ClCorClassTypeT classIds[CL_AMS_ENTITY_TYPE_MAX+2] = {0}; ClInt32T chassisId = 0; ClNameT entityName = {0}; ClUint32T i = 0; static ClUint32T extendedIndexTable[CL_AMS_MGMT_OI_EXTENDED_CLASS_MAX]; rc = corAmfEntityInitialize(); if(rc != CL_OK) goto out; rc = clAmsMgmtInitialize(&mgmtHandle, NULL, &version); if(rc != CL_OK) { clLogError("COR", "AMF", "Mgmt initialize returned [%#x]", rc); goto out; } snprintf(entityName.value, sizeof(entityName.value), "%s:%d", "\\Chassis", chassisId); entityName.length = strlen(entityName.value); rc = clCorMoIdNameToMoIdGet(&entityName, &chassisMoid); if(rc != CL_OK) { clLogError("COR", "AMF", "Cor moid get returned [%#x] for name [%s]", rc, entityName.value); goto out; } for(i = 0; i <= CL_AMS_ENTITY_TYPE_MAX; ++i) { rc = corAmfEntityClassGet(i, classIds + i); if(rc != CL_OK) { clLogError("COR", "AMF", "Entity class for [%s] not found", CL_AMS_STRING_ENTITY_TYPE(i)); goto out; } } if( (rc = clAmsMgmtGetNodeList(mgmtHandle, &nodeList)) != CL_OK) { clLogError("COR", "AMF", "Node list returned [%#x]", rc); goto out; } /* * Create objects for nodes/sus/comps/sgs/sis/csis */ for(i = 0; i < nodeList.count; ++i) { memcpy(&moId, &chassisMoid, sizeof(moId)); clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_NODE], i); rc = corAmfObjectCreate(i, &nodeList.entity[i], &moId); if(rc != CL_OK) goto out; } rc = clAmsMgmtGetSUList(mgmtHandle, &suList); if(rc != CL_OK) { clLogError("COR", "AMF", "SU list get returned [%#x]", rc); goto out; } for(i = 0; i < suList.count; ++i) { memcpy(&moId, &chassisMoid, sizeof(moId)); rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SU], i); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(i, &suList.entity[i], &moId); if(rc != CL_OK) goto out; } rc = clAmsMgmtGetCompList(mgmtHandle, &compList); if(rc != CL_OK) { clLogError("COR", "AMF", "Comp list get returned [%#x]", rc); goto out; } for(i = 0; i < compList.count; ++i) { memcpy(&moId, &chassisMoid, sizeof(moId)); rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_COMP], i); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(i, &compList.entity[i], &moId); if(rc != CL_OK) goto out; } rc = clAmsMgmtGetSGList(mgmtHandle, &sgList); if(rc != CL_OK) { clLogError("COR", "AMF", "SG list returned [%#x]", rc); goto out; } for(i = 0; i < sgList.count; ++i) { ClAmsEntityBufferT rankList = {0}; memcpy(&moId, &chassisMoid, sizeof(moId)); rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SG], i); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(i, &sgList.entity[i], &moId); if(rc != CL_OK) goto out; rc = clAmsMgmtGetSGSIList(mgmtHandle, &sgList.entity[i], &rankList); if(rc != CL_OK) { clLogError("COR", "AMF", "SG [%s] si list returned [%#x]", sgList.entity[i].name.value, rc); goto out; } rc = corAmfExtendedClassObjectCreate("saAmfSGSIRankTable", &sgList.entity[i], &chassisMoid, rankList.count, &extendedIndexTable[CL_AMS_MGMT_OI_SGSIRANK], &i); if(rankList.entity) { clHeapFree(rankList.entity); rankList.entity = NULL; rankList.count = 0; } rc = clAmsMgmtGetSGSUList(mgmtHandle, &sgList.entity[i], &rankList); if(rc != CL_OK) { clLogError("COR", "AMF", "SG [%s] su list returned [%#x]", sgList.entity[i].name.value, rc); goto out; } rc = corAmfExtendedClassObjectCreate("saAmfSGSURankTable", &sgList.entity[i], &chassisMoid, rankList.count, &extendedIndexTable[CL_AMS_MGMT_OI_SGSURANK], &i); if(rankList.entity) { clHeapFree(rankList.entity); rankList.count = 0; } } rc = clAmsMgmtGetSIList(mgmtHandle, &siList); if(rc != CL_OK) { clLogError("COR", "AMF", "SI list get returned [%#x]", rc); goto out; } for(i = 0; i < siList.count; ++i) { ClAmsEntityBufferT list = {0}; memcpy(&moId, &chassisMoid, sizeof(moId)); rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_SI], i); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(i, &siList.entity[i], &moId); if(rc != CL_OK) goto out; rc = clAmsMgmtGetSIDependenciesList(mgmtHandle, &siList.entity[i], &list); if(rc != CL_OK) { clLogError("COR", "AMF", "SI [%s] dependencies list returned [%#x]", siList.entity[i].name.value, rc); goto out; } if(list.count) { rc = corAmfExtendedClassObjectCreate("saAmfSISIDepTable", &siList.entity[i], &chassisMoid, list.count, &extendedIndexTable[CL_AMS_MGMT_OI_SISIDEP], &i); } if(list.entity) { clHeapFree(list.entity); list.count = 0; } rc = clAmsMgmtGetSISURankList(mgmtHandle, &siList.entity[i], &list); if(rc != CL_OK) { clLogError("COR", "AMF", "SI [%s] su rank list returned [%#x]", siList.entity[i].name.value, rc); goto out; } if(list.count) { rc = corAmfExtendedClassObjectCreate("saAmfSUsperSIRankTable", &siList.entity[i], &chassisMoid, list.count, &extendedIndexTable[CL_AMS_MGMT_OI_SUSPERSIRANK], &i); } if(list.entity) { list.count = 0; clHeapFree(list.entity); } } rc = clAmsMgmtGetCSIList(mgmtHandle, &csiList); if(rc != CL_OK) { clLogError("COR", "AMF", "CSI list get returned [%#x]", rc); goto out; } for(i = 0; i < csiList.count; ++i) { ClAmsCSINVPBufferT buffer = {0}; ClAmsEntityBufferT list = {0}; memcpy(&moId, &chassisMoid, sizeof(moId)); rc = clCorMoIdAppend(&moId, classIds[CL_AMS_ENTITY_TYPE_CSI], i); CL_ASSERT(rc == CL_OK); rc = corAmfObjectCreate(i, &csiList.entity[i], &moId); if(rc != CL_OK) goto out; rc = clAmsMgmtGetCSINVPList(mgmtHandle, &csiList.entity[i], &buffer); if(rc != CL_OK) { clLogError("COR", "AMF", "CSI [%s] nvp list returned [%#x]", csiList.entity[i].name.value, rc); goto out; } rc = corAmfExtendedClassObjectCreate("saAmfCSINameValueTable", &csiList.entity[i], &chassisMoid, buffer.count, &extendedIndexTable[CL_AMS_MGMT_OI_CSINAMEVALUE], &i); if(buffer.nvp) { clHeapFree(buffer.nvp); } rc = clAmsMgmtGetCSIDependenciesList(mgmtHandle, &csiList.entity[i], &list); if(rc != CL_OK) { clLogError("COR", "AMF", "CSI [%s] dependencies list returned [%#x]", csiList.entity[i].name.value, rc); goto out; } rc = corAmfExtendedClassObjectCreate("saAmfCSICSIDepTable", &csiList.entity[i], &chassisMoid, list.count, &extendedIndexTable[CL_AMS_MGMT_OI_CSICSIDEP], &i); if(list.entity) { clHeapFree(list.entity); } } /* * We are here when the objects are all created. Do a commit */ rc = corAmfObjectCommit(); if(rc != CL_OK) { clLogError("COR", "AMF", "Object commit returned [%#x]", rc); goto out; } clLogNotice("COR", "AMF", "COR AMF tree successfully initialized"); out: if(nodeList.entity) clHeapFree(nodeList.entity); if(suList.entity) clHeapFree(suList.entity); if(compList.entity) clHeapFree(compList.entity); if(sgList.entity) clHeapFree(sgList.entity); if(siList.entity) clHeapFree(siList.entity); if(csiList.entity) clHeapFree(csiList.entity); return rc; }
ClRcT clAmsMgmtOIInitialize(ClAmsMgmtHandleT *pHandle, ClRcT (*pClAmsMgmtOIConfigAttributesGet) (ClAmsEntityConfigT*, ClCorAttributeValueListPtrT pAttrList), ClRcT (*pClAmsMgmtOIExtendedConfigAttributesGet) (ClAmsMgmtOIExtendedClassTypeT type, ClAmsMgmtOIExtendedEntityConfigT *pConfig, ClCorClassTypeT *pClassType, ClCorAttributeValueListT *pAttrList)) { ClRcT rc = CL_OK; ClAmsMgmtHandleT handle = 0; ClAmsEntityBufferT buffer[CL_AMS_ENTITY_TYPE_MAX+2] = {{0}}; ClVersionT version = {'B', 0x1, 0x1}; ClCorTxnSessionIdT txnSession = 0; ClUint32T i; ClCorAddrT appAddress = {0}; SaNameT chassisInstance = {0}; ClUint32T chassisId = 0; if(!pClAmsMgmtOIConfigAttributesGet) return CL_AMS_RC(CL_ERR_INVALID_PARAMETER); rc = clOsalMutexInit(&gClAmsMgmtOICacheMutex); CL_ASSERT(rc == CL_OK); rc = clEoMyEoIocPortGet(&appAddress.portId); if(rc != CL_OK) return rc; appAddress.nodeAddress = clIocLocalAddressGet(); rc = clAmsMgmtInitialize(&handle, NULL, &version); if(rc != CL_OK) { return rc; } snprintf(chassisInstance.value, sizeof(chassisInstance.value), "%s:%d", "\\Chassis", chassisId); chassisInstance.length = strlen(chassisInstance.value); rc = clCorMoIdNameToMoIdGet(&chassisInstance, &gClChassisMoid); if(rc != CL_OK) { clLogError("AMF", "MGMT", "COR moid get for [%s] returned [%#x]", chassisInstance.value, rc); goto out_free; } rc = clAmsMgmtGetSGList(handle, &buffer[CL_AMS_ENTITY_TYPE_SG]); if(rc != CL_OK) { clLogError("AMF", "MGMT", "Get SG list returned [%#x]", rc); goto out_free; } rc = clAmsMgmtGetSIList(handle, &buffer[CL_AMS_ENTITY_TYPE_SI]); if(rc != CL_OK) { clLogError("AMF", "MGMT", "Get SI list returned [%#x]", rc); goto out_free; } rc = clAmsMgmtGetCSIList(handle, &buffer[CL_AMS_ENTITY_TYPE_CSI]); if(rc != CL_OK) { clLogError("AMF", "MGMT", "Get CSI list returned [%#x]", rc); goto out_free; } rc = clAmsMgmtGetNodeList(handle, &buffer[CL_AMS_ENTITY_TYPE_NODE]); if(rc != CL_OK) { clLogError("AMF", "MGMT", "Get NODE list returned [%#x]", rc); goto out_free; } rc = clAmsMgmtGetSUList(handle, &buffer[CL_AMS_ENTITY_TYPE_SU]); if(rc != CL_OK) { clLogError("AMF", "MGMT", "Get SU list returned [%#x]", rc); goto out_free; } rc = clAmsMgmtGetCompList(handle, &buffer[CL_AMS_ENTITY_TYPE_COMP]); if(rc != CL_OK) { clLogError("AMF", "MGMT", "Get COMP list returned [%#x]", rc); goto out_free; } /* * Now fetch the moid for each of the entities and build the cache. */ for(i = 0; i <= CL_AMS_ENTITY_TYPE_MAX; ++i) { ClAmsEntityBufferT *pBuffer = &buffer[i]; ClUint32T j; if(!pBuffer->count || !pBuffer->entity) continue; gClAmsMgmtOIIndexTable[i] = pBuffer->count; for(j = 0; j < pBuffer->count; ++j) { ClCorMOIdT moid = {{{0}}}; rc = clAmsMgmtOIMoIdGet(handle, pBuffer->entity+j, &moid); if(rc != CL_OK) { continue; } clAmsMgmtOICacheAdd(clCorMoIdToInstanceGet(&moid), pBuffer->entity+j); /* * Required for instances exceeding the pre-configured limit. */ rc = clCorOIRegister(&moid, &appAddress); if(rc != CL_OK) { continue; } rc = clCorPrimaryOISet(&moid, &appAddress); if(rc != CL_OK) { /* * Ignore as it could be already set by the active. */ continue; } clAmsMgmtOIConfigAttributeSet(handle, &txnSession, &moid, pBuffer->entity+j, pClAmsMgmtOIConfigAttributesGet); clAmsMgmtOIExtendedConfigAttributeSet(handle, &txnSession, pBuffer->entity+j, pClAmsMgmtOIExtendedConfigAttributesGet); } } rc = clCorTxnSessionCommit(txnSession); if(rc != CL_OK) { clLogError("AMF", "MGMT", "AMF OI config commit returned [%#x]", rc); } else { clLogNotice("AMF", "MGMT", "Entity cache successfully initialized"); gClAmsMgmtOIInitialized = CL_TRUE; } out_free: for(i = 0; i <= CL_AMS_ENTITY_TYPE_MAX; ++i) { if(buffer[i].entity) clHeapFree(buffer[i].entity); if(rc != CL_OK) clAmsMgmtOICacheDestroy(i); } if(rc != CL_OK) { for(i = 0; i < CL_AMS_MGMT_OI_EXTENDED_CLASS_MAX; ++i) clAmsMgmtOIExtendedCacheDestroy(i); } if(rc == CL_OK && pHandle) *pHandle = handle; else clAmsMgmtFinalize(handle); return rc; }
/** * The mode end function which is called after every mode is finished. * This is used currently to do bulk get. When the vbcount of the requests * is equal to the varcount. */ int clSnmpModeEndCallback( netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { ClRcT rc = CL_SNMP_ERR_NOERROR; netsnmp_request_info * request = NULL; static ClUint16T noOfOps = 0; clLogDebug("SNM","OPE", "Inside MODE-END callback [%s] ...mode [%d]", __FUNCTION__, reqinfo->mode ); switch (reqinfo->mode) { case MODE_GETBULK: clLogDebug("SNM","OPE", "Inside mode BULK-GET"); break; case MODE_GETNEXT: case MODE_GET: { for (request = requests; request != NULL; request = request->next) { noOfOps++; } clLogDebug("SNM","OPE", "Inside mode [%s] vbC[%d] noOfOps [%d]", reqinfo->mode == MODE_GET ? "GET": "GET-NEXT", reqinfo->asp->vbcount, noOfOps); if (gErrorHappened == CL_TRUE) { noOfOps = 0; clSnmpDataReset(); gErrorHappened = CL_FALSE; clLogNotice("SNM","OPE", "Error happened in the validating the request."); netsnmp_request_set_error(requests, CL_SNMP_ERR_NOSUCHNAME); return CL_SNMP_ERR_NOSUCHNAME; } if (reqinfo->asp->vbcount == noOfOps) { clLogDebug("SNP","OPE", "Sending the get request now as the vbCount and varCount are equal."); rc = clSnmpProcessRequest(requests); if (CL_OK != rc) clLogError("SNP","OPE", "Failed while processing the GET request. rc[0x%x]", rc); noOfOps = 0; } } break; case MODE_SET_RESERVE1: clLogDebug("SNM","OPE", "Inside mode RESERVE1"); break; case MODE_SET_RESERVE2: clLogDebug("SNM","OPE", "Inside mode RESERVE2"); break; case MODE_SET_ACTION: clLogDebug("SNM","OPE", "Inside mode ACTION"); break; case MODE_SET_COMMIT: clLogDebug("SNM","OPE", "Inside mode COMMIT"); break; case MODE_SET_UNDO: clLogDebug("SNM","OPE", "Inside mode UNDO"); break; case MODE_SET_FREE: clLogDebug("SNM","OPE", "Inside mode FREE"); break; default: clLogDebug("SNM","OPE", "Inside default case"); } return rc; }
static ClRcT clAmsMgmtSGMigrateMPlusN(ClAmsSGRedundancyModelT model, ClAmsEntityT *sgName, const ClCharT *prefix, ClUint32T numActiveSUs, ClUint32T numStandbySUs, ClAmsMgmtMigrateListT *migrateList) { ClUint32T i; ClRcT rc = CL_OK; ClAmsEntityBufferT siBuffer = {0}; ClAmsEntityBufferT suBuffer = {0}; ClAmsEntityBufferT nodeBuffer = {0}; ClInt32T extraSIs = 0; ClInt32T extraSUs = 0; ClInt32T extraNodes = 0; ClAmsEntityT *nodeList = NULL; ClAmsEntityT *nodes = NULL; ClAmsEntityT *sus = NULL; ClAmsEntityT *comps = NULL; ClAmsEntityT *sis = NULL; ClAmsEntityT *csis = NULL; ClInt32T numNodes = 0; ClAmsEntityConfigT *pSURefComp = NULL; ClAmsEntityConfigT *pSGRefSI = NULL; ClAmsEntityConfigT *pSIRefCSI = NULL; ClAmsEntityConfigT *pSGConfig = NULL; ClAmsSGConfigT sgConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}}; ClUint32T numSupportedCSITypes = 0; SaNameT *pNumSupportedCSITypes = NULL; ClAmsMgmtCCBHandleT ccbHandle = 0; ClAmsMgmtMigrateListT *unlockList = NULL; rc = clAmsMgmtEntityGetConfig(gHandle, sgName, &pSGConfig); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "SG [%.*s] config get returned [%#x]", sgName->name.length-1, sgName->name.value, rc); goto out; } memcpy(&sgConfig, pSGConfig, sizeof(sgConfig)); clHeapFree(pSGConfig); /* * If scaling down actives, ensure that those many service units are locked. */ if(numActiveSUs < sgConfig.numPrefActiveSUs) { ClInt32T numShrinkSUs = sgConfig.numPrefActiveSUs - numActiveSUs; ClAmsEntityBufferT suList = {0}; ClInt32T numOutOfServiceSUs = 0; rc = clAmsMgmtGetSGSUList(gHandle, sgName, &suList); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "SG [%.*s] su list returned [%#x]", sgName->name.length-1, sgName->name.value, rc); goto out; } for(i = 0; i < suList.count; ++i) { ClAmsSUConfigT *pSUConfig = NULL; rc = clAmsMgmtEntityGetConfig(gHandle, suList.entity+i, (ClAmsEntityConfigT**)&pSUConfig); if(rc != CL_OK) { clHeapFree(suList.entity); clLogError("AMS", "MIGRATE", "SU [%.*s] get config returned [%#x]", suList.entity[i].name.length-1, suList.entity[i].name.value, rc); goto out; } if(pSUConfig->adminState == CL_AMS_ADMIN_STATE_LOCKED_A || pSUConfig->adminState == CL_AMS_ADMIN_STATE_LOCKED_I) { ++numOutOfServiceSUs; } clHeapFree(pSUConfig); } clHeapFree(suList.entity); if(numOutOfServiceSUs < numShrinkSUs) { clLogError("AMS", "MIGRATE", "Expected a minimum of [%d] SUs to be out of service to satisfy SG. " "redundancy model shrink. Got [%d] out of service", numShrinkSUs, numOutOfServiceSUs); rc = CL_AMS_RC(CL_AMS_ERR_INVALID_ENTITY_STATE); goto out; } } rc = clAmsMgmtSGRedundancyModelEstimate(model, sgName, numActiveSUs, numStandbySUs, &extraSIs, &extraSUs, &extraNodes); if(rc != CL_OK) { goto out; } rc = clAmsMgmtCCBInitialize(gHandle, &ccbHandle); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS ccb initialize returned [%#x]", rc); goto out; } /* * Add the existing SI CSI list to the supported list. */ rc = clAmsMgmtGetSGSIList(gHandle, sgName, &siBuffer); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS sg si list returned [%#x]", rc); goto out; } if(siBuffer.count) { rc = clAmsMgmtEntityGetConfig(gHandle, siBuffer.entity, &pSGRefSI); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS reference si get config returned [%#x]", rc); goto out_free; } } for(i = 0; i < siBuffer.count; ++i) { ClUint32T j; ClAmsEntityBufferT csiBuffer = {CL_AMS_ENTITY_TYPE_ENTITY}; ClAmsSIConfigT siConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}}; ClUint64T mask = 0; memcpy(&siConfig.entity, siBuffer.entity+i, sizeof(siConfig.entity)); mask |= SI_CONFIG_NUM_STANDBY_ASSIGNMENTS; siConfig.numStandbyAssignments = numStandbySUs; if(numActiveSUs > 1) siConfig.numStandbyAssignments = (numStandbySUs+1)&~1; siConfig.numStandbyAssignments = CL_MAX(1, siConfig.numStandbyAssignments/ (numActiveSUs?numActiveSUs:1)); /* * Update the num standby assignments. */ rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &siConfig.entity, mask); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "SI [%.*s] num standby set returned [%#x]", siConfig.entity.name.length-1, siConfig.entity.name.value, rc); } rc = clAmsMgmtGetSICSIList(gHandle, siBuffer.entity+i, &csiBuffer); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS get si csi list returned [%#x]", rc); goto out_free; } pNumSupportedCSITypes = (SaNameT*) clHeapRealloc(pNumSupportedCSITypes, (numSupportedCSITypes+csiBuffer.count)*sizeof(SaNameT)); for(j = 0; j < csiBuffer.count ; ++j) { ClAmsEntityConfigT *entityConfig = NULL; ClAmsCSIConfigT csiConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}}; ClUint32T k; rc = clAmsMgmtEntityGetConfig(gHandle, csiBuffer.entity+j, &entityConfig); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS csi get config returned [%#x]", rc); goto out_free; } memcpy(&csiConfig, entityConfig, sizeof(csiConfig)); if(!pSIRefCSI) { pSIRefCSI = entityConfig; } else { clHeapFree(entityConfig); } /* * Search for this csi type in the list to see if its * already present */ for(k = 0; k < numSupportedCSITypes; ++k) { if(!memcmp(pNumSupportedCSITypes[k].value, csiConfig.type.value, pNumSupportedCSITypes[k].length)) break; } if(k == numSupportedCSITypes) { memcpy(pNumSupportedCSITypes+numSupportedCSITypes, &csiConfig.type, sizeof(csiConfig.type)); ++numSupportedCSITypes; } } clHeapFree(csiBuffer.entity); } if(extraSIs) { sis = (ClAmsEntityT*) clHeapCalloc(extraSIs, sizeof(ClAmsEntityT)); CL_ASSERT(sis != NULL); csis = (ClAmsEntityT*) clHeapCalloc(extraSIs, sizeof(ClAmsEntityT)); for(i = siBuffer.count; i < siBuffer.count + extraSIs; ++i) { ClAmsEntityT si ={CL_AMS_ENTITY_TYPE_ENTITY}; ClAmsEntityT csi = {CL_AMS_ENTITY_TYPE_ENTITY}; ClUint64T bitMask = 0; ClAmsSIConfigT siConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}}; ClAmsCSIConfigT csiConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}}; si.type = CL_AMS_ENTITY_TYPE_SI; snprintf((ClCharT*)si.name.value, sizeof(si.name.value)-1, "%s_%.*s_SI%d", prefix, sgName->name.length-1, (const ClCharT*)sgName->name.value, i); clLogNotice("AMS", "MIGRATE", "Creating SI [%s]", si.name.value); si.name.length = strlen((const ClCharT*)si.name.value)+1; rc = clAmsMgmtCCBEntityCreate(ccbHandle, &si); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS entity create returned [%#x]", rc); goto out_free; } memcpy(&sis[i-siBuffer.count], &si, sizeof(si)); rc = clAmsMgmtCCBSetSGSIList(ccbHandle, sgName, &si); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS set sg silist returned [%#x]", rc); goto out_free; } if(pSGRefSI) { /* * Set config to the base SI. */ bitMask = CL_AMS_CONFIG_ATTR_ALL; memcpy(&siConfig, pSGRefSI, sizeof(siConfig)); memcpy(&siConfig.entity, &si, sizeof(siConfig.entity)); siConfig.numStandbyAssignments = numStandbySUs; if(numActiveSUs > 1 ) siConfig.numStandbyAssignments = (numStandbySUs+1)&~1; siConfig.numStandbyAssignments = CL_MAX(1,siConfig.numStandbyAssignments/ (numActiveSUs?numActiveSUs:1)); siConfig.numCSIs = 1; siConfig.adminState = CL_AMS_ADMIN_STATE_LOCKED_A; rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &siConfig.entity, bitMask); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS entity set config returned [%#x]", rc); goto out_free; } } csi.type = CL_AMS_ENTITY_TYPE_CSI; snprintf((ClCharT*)csi.name.value, sizeof(csi.name.value), "%s_CSI%d", (const ClCharT*)si.name.value, i-siBuffer.count); csi.name.length = strlen((const ClCharT*)csi.name.value)+1; clLogNotice("AMS", "MIGRATE", "Creating CSI [%s]", csi.name.value); rc = clAmsMgmtCCBEntityCreate(ccbHandle, &csi); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS csi create returned [%#x]", rc); goto out_free; } memcpy(&csis[i-siBuffer.count], &csi, sizeof(csi)); rc = clAmsMgmtCCBSetSICSIList(ccbHandle, &si, &csi); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "SET si csi list returned [%#x]", rc); goto out_free; } if(pSIRefCSI) { /* * Load the config. for the base csi type. */ memcpy(&csiConfig, pSIRefCSI, sizeof(csiConfig)); memcpy(&csiConfig.entity, &csi, sizeof(csiConfig.entity)); csiConfig.isProxyCSI = CL_FALSE; memcpy(&csiConfig.type, &csiConfig.entity.name, sizeof(csiConfig.type)); bitMask = CL_AMS_CONFIG_ATTR_ALL; rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &csiConfig.entity, bitMask); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS ref csi set config returned [%#x]", rc); goto out_free; } } /* * Add this to the supported list. */ pNumSupportedCSITypes = (SaNameT*) clHeapRealloc(pNumSupportedCSITypes, (numSupportedCSITypes+1)*sizeof(SaNameT)); CL_ASSERT(pNumSupportedCSITypes != NULL); memcpy(pNumSupportedCSITypes+numSupportedCSITypes, &csi.name, sizeof(SaNameT)); ++numSupportedCSITypes; } } if(extraNodes) { nodes = (ClAmsEntityT*) clHeapCalloc(extraNodes, sizeof(ClAmsEntityT)); CL_ASSERT(nodes != NULL); rc = clAmsMgmtGetNodeList(gHandle, &nodeBuffer); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS get node list returned [%#x]", rc); goto out_free; } for(i = nodeBuffer.count ; i < nodeBuffer.count + extraNodes; ++i) { ClAmsEntityT node = {CL_AMS_ENTITY_TYPE_ENTITY}; node.type = CL_AMS_ENTITY_TYPE_NODE; snprintf((ClCharT*) node.name.value, sizeof(node.name.value), "%s_Node%d", prefix, i); node.name.length = strlen((const ClCharT*) node.name.value) + 1; clLogNotice("AMS", "MIGRATE", "Creating node [%s]", node.name.value); rc = clAmsMgmtCCBEntityCreate(ccbHandle, &node); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS ccb create returned [%#x]", rc); goto out_free; } memcpy(&nodes[i-nodeBuffer.count], &node, sizeof(node)); } } rc = clAmsMgmtGetSGSUList(gHandle, sgName, &suBuffer); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "Get SG su list returned [%#x]", rc); goto out_free; } for(i = 0 ; i < suBuffer.count; ++i) { ClUint32T j; ClAmsEntityBufferT compBuffer= { 0 } ; rc = clAmsMgmtGetSUCompList(gHandle, &suBuffer.entity[i], &compBuffer); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "Get SU comp list returned [%#x]", rc); goto out_free; } /* * Get the first component properties. */ if(!pSURefComp) { rc = clAmsMgmtEntityGetConfig(gHandle, compBuffer.entity, &pSURefComp); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS base comp get config returned [%#x]", rc); goto out_free; } } /* * Update all config. with supported csi types. * and correct comp config whereever appropriate */ for(j = 0; j < compBuffer.count; ++j) { ClAmsEntityConfigT *entityConfig =NULL; ClAmsCompConfigT compConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}}; ClUint64T bitMask = 0; ClUint32T k ; rc = clAmsMgmtEntityGetConfig(gHandle, compBuffer.entity+j, &entityConfig); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS comp get config returned [%#x]", rc); goto out_free; } memcpy(&compConfig, entityConfig, sizeof(compConfig)); clHeapFree(entityConfig); /* * update supported CSI type incase of SI additions. */ if(extraSIs) { bitMask |= COMP_CONFIG_SUPPORTED_CSI_TYPE; compConfig.pSupportedCSITypes = (SaNameT*) clHeapRealloc(compConfig.pSupportedCSITypes, (compConfig.numSupportedCSITypes + extraSIs)* sizeof(SaNameT)); CL_ASSERT(compConfig.pSupportedCSITypes); for(k = compConfig.numSupportedCSITypes; k < compConfig.numSupportedCSITypes + extraSIs; ++k) { memcpy(compConfig.pSupportedCSITypes+k, &csis[k-compConfig.numSupportedCSITypes].name, sizeof(SaNameT)); } compConfig.numSupportedCSITypes += extraSIs; } bitMask |= COMP_CONFIG_NUM_MAX_STANDBY_CSIS; /* * take active to standby ratio */ compConfig.numMaxStandbyCSIs = numActiveSUs; if(numStandbySUs > 1 ) compConfig.numMaxStandbyCSIs = (numActiveSUs+1)&~1; compConfig.numMaxStandbyCSIs = CL_MAX(1, compConfig.numMaxStandbyCSIs/ (numStandbySUs?numStandbySUs:1)); rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &compConfig.entity, bitMask); clHeapFree(compConfig.pSupportedCSITypes); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS entity set config returned [%#x]", rc); goto out_free; } } clHeapFree(compBuffer.entity); } if(extraSUs) { sus = (ClAmsEntityT*) clHeapCalloc(extraSUs, sizeof(ClAmsEntityT)); CL_ASSERT(sus != NULL); comps = (ClAmsEntityT*) clHeapCalloc(extraSUs, sizeof(ClAmsEntityT)); CL_ASSERT(comps != NULL); nodeList = (ClAmsEntityT*) clHeapCalloc(extraSUs + extraNodes, sizeof(ClAmsEntityT)); CL_ASSERT(nodeList != NULL); rc = clAmsMgmtGetSUFreeNodes(sgName, prefix, extraSUs, extraNodes, nodeList, &numNodes); for(i = suBuffer.count; i < suBuffer.count + extraSUs; ++i) { ClAmsEntityT su = {CL_AMS_ENTITY_TYPE_ENTITY}; ClAmsEntityT comp = {CL_AMS_ENTITY_TYPE_ENTITY}; ClAmsSUConfigT suConfig = { { CL_AMS_ENTITY_TYPE_ENTITY } } ; ClAmsCompConfigT compConfig = {{CL_AMS_ENTITY_TYPE_ENTITY}}; ClUint64T bitMask = 0; su.type = CL_AMS_ENTITY_TYPE_SU; snprintf((ClCharT*)su.name.value, sizeof(su.name.value), "%s_%s_SU%d", prefix, (const ClCharT*)nodeList[i-suBuffer.count].name.value, i); su.name.length = strlen((const ClCharT*)su.name.value)+1; clLogNotice("AMS", "MIGRATE", "Creating SU [%s]", su.name.value); rc = clAmsMgmtCCBEntityCreate(ccbHandle, &su); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "SU create returned [%#x]", rc); goto out_free; } memcpy(&sus[i-suBuffer.count], &su, sizeof(su)); /* * Assign this SU under the parent node and SG */ rc = clAmsMgmtCCBSetNodeSUList(ccbHandle, &nodeList[i-suBuffer.count], &su); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "Node su list set returned [%#x]", rc); goto out_free; } /* * Give the parent SG. for this SU */ rc = clAmsMgmtCCBSetSGSUList(ccbHandle, sgName, &su); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "Set SG su list returned [%#x]", rc); goto out_free; } bitMask = SU_CONFIG_NUM_COMPONENTS; memcpy(&suConfig.entity, &su, sizeof(suConfig.entity)); suConfig.numComponents = 1; rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &suConfig.entity, bitMask); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "SU set config returned [%#x]", rc); goto out_free; } comp.type = CL_AMS_ENTITY_TYPE_COMP; snprintf((ClCharT*) comp.name.value, sizeof(comp.name.value), "%s_Comp%d", su.name.value, i - suBuffer.count); comp.name.length = strlen((const ClCharT*) comp.name.value) + 1; clLogNotice("AMS", "MIGRATE", "Creating component [%s]", comp.name.value); rc = clAmsMgmtCCBEntityCreate(ccbHandle, &comp); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "Comp create returned [%#x]", rc); goto out_free; } memcpy(&comps[i-suBuffer.count], &comp, sizeof(comp)); rc = clAmsMgmtCCBSetSUCompList(ccbHandle, &su, &comp); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS set su comp list returned [%#x]", rc); goto out_free; } if(pSURefComp) { /* * At this stage, we have created the hierarchy. * Set the comp property to the base component type and * add the num supported CSI types to be part of every component * added to the SU. */ bitMask = CL_AMS_CONFIG_ATTR_ALL; memcpy(&compConfig, pSURefComp, sizeof(compConfig)); memcpy(&compConfig.entity, &comp, sizeof(compConfig.entity)); compConfig.numSupportedCSITypes = numSupportedCSITypes; compConfig.pSupportedCSITypes = pNumSupportedCSITypes; memcpy(&compConfig.parentSU.entity, &su, sizeof(compConfig.parentSU.entity)); /* * Distribute the standbys based on the active/standby ratio. */ compConfig.numMaxStandbyCSIs = numActiveSUs; if(numStandbySUs > 1 ) compConfig.numMaxStandbyCSIs = (numActiveSUs+1)&~1; compConfig.numMaxStandbyCSIs = CL_MAX(1, compConfig.numMaxStandbyCSIs/ (numStandbySUs?numStandbySUs:1)); rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &compConfig.entity, bitMask); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS set config returned [%#x]", rc); goto out_free; } } } } /* * At this stage, we are all set to commit. after updating SG config. */ { ClUint64T bitMask = 0; bitMask |= SG_CONFIG_REDUNDANCY_MODEL; sgConfig.redundancyModel = model; sgConfig.numPrefActiveSUs = numActiveSUs; bitMask |= SG_CONFIG_NUM_PREF_ACTIVE_SUS; sgConfig.numPrefStandbySUs = numStandbySUs; bitMask |= SG_CONFIG_NUM_PREF_STANDBY_SUS; if(sgConfig.numPrefInserviceSUs < numActiveSUs + numStandbySUs) { sgConfig.numPrefInserviceSUs = numActiveSUs + numStandbySUs; bitMask |= SG_CONFIG_NUM_PREF_INSERVICE_SUS; } sgConfig.numPrefAssignedSUs = numActiveSUs + numStandbySUs; bitMask |= SG_CONFIG_NUM_PREF_ASSIGNED_SUS; /* * Active standby ratio. */ sgConfig.maxStandbySIsPerSU = numActiveSUs; if(numStandbySUs > 1 ) sgConfig.maxStandbySIsPerSU = (numActiveSUs+1)&~1; sgConfig.maxStandbySIsPerSU = CL_MAX(1,sgConfig.maxStandbySIsPerSU/ (numStandbySUs?numStandbySUs:1)); bitMask |= SG_CONFIG_MAX_STANDBY_SIS_PER_SU; rc = clAmsMgmtCCBEntitySetConfig(ccbHandle, &sgConfig.entity, bitMask); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS sg set config returned [%#x]", rc); goto out_free; } } rc = clAmsMgmtCCBCommit(ccbHandle); if(rc != CL_OK) { clLogError("AMS", "MIGRATE", "AMS database commit returned [%#x]", rc); } /* * Okay, the commit is successful. Now unlock all added entities * except SU so that other attributes could be updated before unlocking * Do that in a separate thread as there could be pending invocations. */ unlockList = (ClAmsMgmtMigrateListT*) clHeapCalloc(1, sizeof(*unlockList)); CL_ASSERT(unlockList != NULL); unlockList->si.count = extraSIs; unlockList->node.count = extraNodes; unlockList->su.count = extraSUs; unlockList->si.entity = (ClAmsEntityT*) clHeapCalloc(extraSIs, sizeof(*sis)); unlockList->node.entity = (ClAmsEntityT*) clHeapCalloc(extraNodes, sizeof(*nodes)); unlockList->su.entity = (ClAmsEntityT*) clHeapCalloc(extraSUs, sizeof(*sus)); CL_ASSERT(unlockList->si.entity && unlockList->node.entity && unlockList->su.entity); memcpy(unlockList->si.entity, sis, sizeof(*sis)*extraSIs); memcpy(unlockList->node.entity, nodes, sizeof(*nodes)*extraNodes); memcpy(unlockList->su.entity, sus, sizeof(*sus) * extraSUs); clOsalTaskCreateDetached("MIGRATE-UNLOCK-THREAD", CL_OSAL_SCHED_OTHER, 0, 0, clAmsMgmtMigrateListUnlock, (void*)unlockList); /* * Return the newly created info. in the migrated list. */ if(migrateList) { if(extraSIs) { migrateList->si.count = extraSIs; migrateList->si.entity = sis; migrateList->csi.count = extraSIs; migrateList->csi.entity = csis; sis = csis = NULL; } if(extraNodes) { migrateList->node.count = extraNodes; migrateList->node.entity = nodes; nodes = NULL; } if(extraSUs) { migrateList->su.count = extraSUs; migrateList->su.entity = sus; migrateList->comp.count = extraSUs; migrateList->comp.entity = comps; sus = comps = NULL; } } out_free: clAmsMgmtCCBFinalize(ccbHandle); if(siBuffer.entity) clHeapFree(siBuffer.entity); if(nodeBuffer.entity) clHeapFree(nodeBuffer.entity); if(suBuffer.entity) clHeapFree(suBuffer.entity); if(nodeList) clHeapFree(nodeList); if(nodes) clHeapFree(nodes); if(sus) clHeapFree(sus); if(comps) clHeapFree(comps); if(sis) clHeapFree(sis); if(csis) clHeapFree(csis); if(pSGRefSI) clHeapFree(pSGRefSI); if(pSIRefCSI) clHeapFree(pSIRefCSI); if(pSURefComp) clHeapFree(pSURefComp); if(pNumSupportedCSITypes) clHeapFree(pNumSupportedCSITypes); out: return rc; }
/* * Before calling ifconfig, we want to check if interface and ip existing, * if so, just ignore the calling command */ static ClRcT _clCheckExistingDevIf(const ClCharT *ip, const ClCharT *dev) { int sd = -1; int i = 0; ClUint32T reqs = 0; struct ifconf ifc = {0}; struct ifreq *ifr = NULL; ClCharT addrStr[INET_ADDRSTRLEN] = {0}; /* Get a socket handle. */ sd = socket(PF_INET, SOCK_DGRAM, 0); if (sd < 0) { clLogError( "IOC", CL_LOG_PLUGIN_HELPER_AREA, "open socket failed with error [%s]", strerror(errno)); return (0); } memset(&ifc, 0, sizeof(ifc)); /* Query available interfaces. */ do { reqs += 5; ifc.ifc_len = reqs * sizeof(*ifr); ifc.ifc_buf = (char*) realloc(ifc.ifc_buf, sizeof(*ifr) * reqs); CL_ASSERT(ifc.ifc_buf != NULL); if (ioctl(sd, SIOCGIFCONF, &ifc) < 0) { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Operation command failed: [%s]", strerror(errno)); goto out; } } while ((unsigned int )ifc.ifc_len == reqs * sizeof(*ifr)); /* Iterate through the list of interfaces. */ ifr = ifc.ifc_req; for(i = 0; i < ifc.ifc_len; i += sizeof(*ifr)) { // clLogTrace("IOC", // CL_LOG_PLUGIN_HELPER_AREA, // "Checking interface name [%s]", // ifr->ifr_name); /* Checking if match interface name first */ if (strlen(ifr->ifr_name) == strlen(dev) && memcmp(ifr->ifr_name, dev, strlen(dev)) == 0) { /* Get the address * This may seem silly but it seems to be needed on some systems */ if (ioctl(sd, SIOCGIFADDR, ifr) < 0) { clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Operation command failed: [%s]", strerror(errno)); break; } addrStr[0] = 0; struct in_addr *in4_addr = &((struct sockaddr_in*)&ifr->ifr_addr)->sin_addr; if(!inet_ntop(PF_INET, (const void *)in4_addr, addrStr, sizeof(addrStr))) { struct in6_addr *in6_addr = &((struct sockaddr_in6*)&ifr->ifr_addr)->sin6_addr; if(!inet_ntop(PF_INET6, (const void*)in6_addr, addrStr, sizeof(addrStr))) { goto out; } } // clLogTrace("IOC", // CL_LOG_PLUGIN_HELPER_AREA, // "Checking IP address [%s]", // addrStr); if (strlen(addrStr) == strlen(ip) && memcmp(addrStr, ip, strlen(ip)) == 0) { free(ifc.ifc_buf); close(sd); return (1); } /* Ignore other interfaces */ break; } ++ifr; } out: if (ifc.ifc_buf) free(ifc.ifc_buf); close(sd); return (0); }
static ClRcT rmdSendTimerFunc(void *pData) { ClCntNodeHandleT nodeHandle; ClRmdRecordSendT *rec = NULL; ClRcT rc; ClRcT retCode = 0; ClRmdObjT *pRmdObject; ClRmdAsyncCallbackT fpTempPtr; void *cookie; ClBufferHandleT outMsgHdl; ClEoExecutionObjT *pThis = NULL; ClUint64T msgId = (ClUint32T)(ClWordT) pData; CL_FUNC_ENTER(); if (pData == NULL) { return (CL_RMD_RC(CL_ERR_INVALID_BUFFER)); } rc = clEoMyEoObjectGet(&pThis); if ( CL_OK != rc ) { return rc; } pRmdObject = (ClRmdObjT *) (pThis->rmdObj); if (pRmdObject == NULL) { return (CL_RMD_RC(CL_ERR_INVALID_BUFFER)); } rc = clOsalMutexLock(pRmdObject->semaForSendHashTable); CL_ASSERT(rc == CL_OK); clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 0"); rc = clCntNodeFind(pRmdObject->sndRecContainerHandle, (ClPtrT)(ClWordT)msgId, &nodeHandle); if (rc == CL_OK) { clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 1"); rc = clCntNodeUserDataGet(pRmdObject->sndRecContainerHandle, nodeHandle, (ClCntDataHandleT *) &rec); if (rc == CL_OK) { clLogNotice("CALLBACK", "TASKS","Enter rmdSendTimerFunc 2"); if (rec) { /* * Disabling retries for ASYNC since we dont want * to land up in duplicate send mess as anyway we have * accounted for the retries while creating the async timer. */ if (0 && rec->recType.asyncRec.noOfRetry > 0) { /* * key is part of record so no need to free just reuse */ retCode = resendMsg(rec, pRmdObject, pThis); } else { /* * key is part of record so no need to free, it will be * freed by hash delete callback */ RMD_STAT_INC(pRmdObject->rmdStats.nCallTimeouts); retCode = clTimerDeleteAsync(&rec->recType.asyncRec.timerID); if (rec->recType.asyncRec.func) { /* * unlocking it as callback func can make the rmd call */ ClBufferHandleT message; fpTempPtr = rec->recType.asyncRec.func; cookie = rec->recType.asyncRec.cookie; outMsgHdl = rec->recType.asyncRec.outMsgHdl; message = rec->recType.asyncRec.sndMsgHdl; clBufferHeaderTrim(message, rec->hdrLen); rc = clCntNodeDelete(pRmdObject->sndRecContainerHandle, nodeHandle); rc = clOsalMutexUnlock(pRmdObject-> semaForSendHashTable); fpTempPtr((CL_RMD_RC(CL_ERR_TIMEOUT)), cookie, message, outMsgHdl); clBufferDelete(&(message)); rc = clOsalMutexLock(pRmdObject->semaForSendHashTable); } } } } } rc = clOsalMutexUnlock(pRmdObject->semaForSendHashTable); CL_ASSERT(rc == CL_OK); CL_FUNC_EXIT(); return CL_OK; }
static ClRcT _clPluginHelperSendArp(const ClCharT *host, const ClCharT *dev) { int i; ClRcT rc = CL_OK; ClCharT myMac[CL_MAC_ADDRESS_LENGTH]; ClUint32T myIp = 0; ClPluginHelperEthIpv4ArpPacketT pkt; int ifindex = 0; _clPluginHelperDevToMac(dev, myMac); if ((rc = _clPluginHelperHostToIp(host, &myIp)) != CL_OK) { return rc; } _clPluginHelperDevToIfIndex(dev, &ifindex); for (i = CL_PLUGIN_HELPER_ARP_REQUEST; i <= CL_PLUGIN_HELPER_ARP_REPLY; i++) { memcpy(pkt.myMac, myMac, CL_MAC_ADDRESS_LENGTH); memset(pkt.dstMac, 0xFF, CL_MAC_ADDRESS_LENGTH); pkt.type = htons(ETHERTYPE_ARP); pkt.hrd = htons(CL_PLUGIN_HELPER_ARP_HW_TYPE_ETHERNET); pkt.pro = htons(CL_PLUGIN_HELPER_IP_PROTO_TYPE); //htons(ETHERTYPE_IP); //htons(ETH_P_IP); //ArpAddressResolutionType; pkt.hln = CL_MAC_ADDRESS_LENGTH; /* ETH_HW_ADDR_LEN; Length in bytes of ethernet address */ pkt.pln = 4; // IP_ADDR_LEN; pkt.op = htons(i); // htons(ARPOP_REQUEST); memcpy(pkt.sha, myMac, CL_MAC_ADDRESS_LENGTH); memset(pkt.tha, 0xFF, CL_MAC_ADDRESS_LENGTH); memcpy(pkt.spa, &myIp, 4); memcpy(pkt.tpa, &myIp, 4); if (1) { int sd; struct sockaddr_ll sal; bzero(&sal, sizeof(sal)); sal.sll_family = AF_PACKET; sal.sll_protocol = htons(ETH_P_ARP); sal.sll_ifindex = ifindex; sal.sll_hatype = htons(i); sal.sll_pkttype = PACKET_BROADCAST; memcpy(sal.sll_addr, myMac, CL_MAC_ADDRESS_LENGTH); sal.sll_halen = CL_MAC_ADDRESS_LENGTH; if ((sd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ARP))) < 0) { int err = errno; clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Cannot create a socket, arp not sent; error %d: %s", err, ""); } else { if (sendto(sd, &pkt, sizeof(pkt), 0, (struct sockaddr *) &sal, sizeof(sal)) < 0) { int err = errno; clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Cannot send the arp packet; error %d: %s", err, ""); rc = CL_ERR_LIBRARY; } clLogNotice("IOC", CL_LOG_PLUGIN_HELPER_AREA, "Gratuitous arp sent: IP %s device %s mac %02x:%02x:%02x:%02x:%02x:%02x", host, dev, myMac[0], myMac[1], myMac[2], myMac[3], myMac[4], myMac[5]); shutdown(sd, SHUT_RDWR); close(sd); } } } return CL_OK; }
/* * Carry out per entity recovery based on the configured recovery. */ static ClRcT clAmsEntityRecovery(ClAmsEntityT *pEntity, ClAmsThresholdT *pThreshold) { ClRcT rc = CL_OK; /* * Special case for undo on the entity that underwent recovery. */ if(pThreshold->recoveryReset == CL_TRUE) { return clAmsEntityRecoveryReset(pEntity, pThreshold); } switch(pEntity->type) { case CL_AMS_ENTITY_TYPE_SI: switch(pThreshold->recovery) { case CL_AMS_ENTITY_RECOVERY_FAILOVER: case CL_AMS_ENTITY_RECOVERY_LOCK: /* * Switch work for the SI. */ clLogNotice("TRIGGER", "RECOVERY", "Switching over SI [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); rc = clAmsMgmtEntityLockAssignment(gClAmsEntityTriggerMgmtHandle, pEntity); if(rc != CL_OK) { clLogError("TRIGGER", "RECOVERY", "Switching over SI returned [%#x]", rc); } break; default: break; } break; case CL_AMS_ENTITY_TYPE_CSI: clAmsCSIRecovery(pEntity, pThreshold); break; case CL_AMS_ENTITY_TYPE_SG: switch(pThreshold->recovery) { case CL_AMS_ENTITY_RECOVERY_FAILOVER: case CL_AMS_ENTITY_RECOVERY_LOCK: /* * Lock work for the SG */ clLogNotice("TRIGGER", "RECOVERY", "Removing work for SG [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); rc = clAmsMgmtEntityLockAssignment(gClAmsEntityTriggerMgmtHandle, pEntity); if(rc != CL_OK) { clLogError("TRIGGER", "RECOVERY", "Removing work for SG returned [%#x]", rc); } break; default: break; } break; case CL_AMS_ENTITY_TYPE_NODE: switch(pThreshold->recovery) { case CL_AMS_ENTITY_RECOVERY_LOCK: clLogNotice("TRIGGER", "RECOVERY", "Switching over work for the node SUs [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); rc = clAmsMgmtEntityLockAssignment(gClAmsEntityTriggerMgmtHandle, pEntity); if(rc != CL_OK) { clLogError("TRIGGER", "RECOVERY", "Switching over work for node returned [%#x]", rc); } break; case CL_AMS_ENTITY_RECOVERY_RESTART: clLogNotice("TRIGGER", "RECOVERY", "Restarting SUs for node [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); rc = clAmsMgmtEntityRestart(gClAmsEntityTriggerMgmtHandle, pEntity); if(rc != CL_OK) { clLogError("TRIGGER", "RECOVERY", "Restart node returned [%#x]", rc); } break; case CL_AMS_ENTITY_RECOVERY_FAILOVER: clLogNotice("TRIGGER", "RECOVERY", "Failing over node [%.*s] as part [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); clAmsTriggerFault(pEntity, CL_AMS_RECOVERY_NODE_FAILOVER); break; case CL_AMS_ENTITY_RECOVERY_FAILFAST: clLogNotice("TRIGGER", "RECOVERY", "Failing over node [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); clAmsTriggerFault(pEntity, CL_AMS_RECOVERY_NODE_FAILFAST); break; default: break; } break; case CL_AMS_ENTITY_TYPE_SU: switch(pThreshold->recovery) { case CL_AMS_ENTITY_RECOVERY_FAILOVER: clLogNotice("TRIGGER", "RECOVERY", "Failover over work for SU [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); clAmsCompRecovery(pEntity, pThreshold); break; case CL_AMS_ENTITY_RECOVERY_LOCK: clLogNotice("TRIGGER", "RECOVERY", "Switching over work for SU [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id) ); rc = clAmsMgmtEntityLockAssignment(gClAmsEntityTriggerMgmtHandle, pEntity); if(rc != CL_OK) { clLogError("TRIGGER", "RECOVERY", "Switching over work for SU returned [%#x]", rc); } break; case CL_AMS_ENTITY_RECOVERY_RESTART: clLogNotice("TRIGGER", "RECOVERY", "Restarting components in SU [%.*s] as part of [%s] threshold recovery", pEntity->name.length-1, pEntity->name.value, CL_METRIC_STR(pThreshold->metric.id)); rc = clAmsMgmtEntityRestart(gClAmsEntityTriggerMgmtHandle, pEntity); if(rc != CL_OK) { clLogError("TRIGGER", "RECOVERY", "Restarting SU returned [%#x]", rc); } break; default: break; } break; case CL_AMS_ENTITY_TYPE_COMP: clAmsCompRecovery(pEntity, pThreshold); break; default: break; } return rc; }