/* * This api would be called as and when the object is no more and the corresponding entry * within the container needs to be deleted. */ ClRcT clAlarmPayloadCntDelete(ClCorMOIdPtrT pMoId, ClAlarmProbableCauseT probCause, ClAlarmSpecificProblemT specificProblem) { ClRcT rc = CL_OK; ClCntNodeHandleT nodeH; ClAlarmPayloadCntKeyT *pCntKey = clHeapAllocate(sizeof(ClAlarmPayloadCntKeyT)); if(NULL == pCntKey) { CL_DEBUG_PRINT (CL_DEBUG_CRITICAL,("Memory allocation failed with rc 0x%x ", rc)); return (rc); } pCntKey->probCause = probCause; pCntKey->specificProblem = specificProblem; pCntKey->moId = *pMoId; clOsalMutexLock(gClAlarmPayloadCntMutex); rc = clCntNodeFind(gPayloadCntHandle,(ClCntKeyHandleT)pCntKey,&nodeH); if(CL_OK == rc) { rc = clCntAllNodesForKeyDelete(gPayloadCntHandle,(ClCntKeyHandleT)pCntKey); if (CL_OK != rc) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("clCntAllNodesForKeyDelete failed w rc:0x%x\n", rc)); } } else { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Node does not exist with rc:0x%x\n", rc)); } clHeapFree(pCntKey); clOsalMutexUnlock(gClAlarmPayloadCntMutex); return rc; }
/** * Remove a transaction definition from txn-database. */ extern ClRcT clTxnDbTxnDefnRemove( CL_IN ClTxnDbHandleT txnDb, CL_IN ClTxnTransactionIdT txnId) { ClRcT rc = CL_OK; CL_FUNC_ENTER(); rc = clCntAllNodesForKeyDelete(txnDb, (ClCntKeyHandleT) &txnId); CL_FUNC_EXIT(); return (rc); }
/** * Remove an existing job from transaction. * FIXME: THIS IS NOT MULTITHREAD SAFE */ ClRcT clTxnAppJobRemove( CL_IN ClTxnDefnT *pTxnDefn, CL_IN ClTxnTransactionJobIdT jobId) { CL_FUNC_ENTER(); if (NULL == pTxnDefn) { CL_FUNC_EXIT(); return CL_ERR_NULL_POINTER; } clCntAllNodesForKeyDelete(pTxnDefn->jobList, (ClCntKeyHandleT) &jobId); /* Following has to be done atomically */ pTxnDefn->jobCount--; CL_FUNC_EXIT(); return (CL_OK); }
ClRcT _clGmsDbDelete( CL_IN const ClGmsDbT* const gmsDb, CL_IN const ClGmsDbTypeT type, /* Suppressing coverity warning for pass by value with below comment */ // coverity[pass_by_value] CL_IN const ClGmsDbKeyT key) { ClRcT rc = CL_OK; ClCntKeyHandleT cntKey = NULL; if (gmsDb == (const void *)NULL) return CL_ERR_NULL_POINTER; rc = _clGmsDbGetKey(type, key, &cntKey); if (rc != CL_OK) return rc; rc = clCntAllNodesForKeyDelete(gmsDb->htbl[type], cntKey); return rc; }
ClRcT _clGmsNameIdDbDelete(ClCntHandleT *dbPtr, ClNameT *name) { ClRcT rc = CL_OK; ClGmsDbKeyT key = {{0}}; ClCntKeyHandleT cntKey = NULL; if (dbPtr == NULL) { return CL_ERR_NULL_POINTER; } memcpy(&key.name, name, sizeof(ClNameT)); rc = _clGmsDbGetKey(CL_GMS_NAME_ID_DB, key, &cntKey); if (rc != CL_OK) { return rc; } rc = clCntAllNodesForKeyDelete(*dbPtr, cntKey); return rc; }
ClRcT _clCkpMastertReplicaAddressUpdate(ClHandleT mastHdl, ClIocNodeAddressT actAddr) { ClRcT rc = CL_OK; ClCntNodeHandleT nodeHdl = 0; ClCntDataHandleT dataHdl = 0; CkptMasterDBEntryT *pMasterDBEntry = NULL; ClCkptClientUpdInfoT eventInfo = {0}; ClEventIdT eventId = 0; clLogDebug(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Changing the active address of ckpt handle [%#llX]", mastHdl); /* * Retrieve the information associated with the master hdl. */ if( CL_OK != (rc = clHandleCheckout(gCkptSvr->masterInfo.masterDBHdl, mastHdl, (void **) &pMasterDBEntry))) { clLogError(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Master db entry doesn't have this handle [%#llX]", mastHdl); return rc; } /* * Delete the entry of the node that went down from the checkpoint's * replica list. */ if (pMasterDBEntry->replicaList) clCntAllNodesForKeyDelete(pMasterDBEntry->replicaList, (ClPtrT)(ClWordT)actAddr); else { clLogWarning(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN,"Replicalist for %s is empty",pMasterDBEntry->name.value); } /* * Store the node's address as prev active address. */ pMasterDBEntry->prevActiveRepAddr = actAddr; /* * Select the new active address. In case of COLLOCATED checkpoint, * the new active address to UNINIT value. */ if (CL_CKPT_IS_COLLOCATED(pMasterDBEntry->attrib.creationFlags)) { if(pMasterDBEntry->activeRepAddr == actAddr) { pMasterDBEntry->activeRepAddr = CL_CKPT_UNINIT_ADDR; } else { if(pMasterDBEntry->activeRepAddr != CL_CKPT_UNINIT_ADDR) { /* * If we have traces of the master handle in our peer list * missed by the active replica set, then remove it here. */ clLogNotice(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Active replica is [%d]." "Removing master ckpt handle [%#llX] from last active [%d]", pMasterDBEntry->activeRepAddr, mastHdl, actAddr); _ckptPeerListMasterHdlAdd(mastHdl, actAddr, CL_CKPT_UNINIT_ADDR); } goto exitOnError; } } else { rc = clCntFirstNodeGet(pMasterDBEntry->replicaList, &nodeHdl); if(CL_ERR_INVALID_HANDLE == CL_GET_ERROR_CODE(rc) || nodeHdl == 0) { rc = CL_OK; pMasterDBEntry->activeRepAddr = CL_CKPT_UNINIT_ADDR; } CKPT_ERR_CHECK(CL_CKPT_SVR,CL_LOG_SEV_ERROR, ("clCkptActiveReplicaAddrGet failed rc[0x %x]\n",rc), rc); if( nodeHdl != 0 ) { rc = clCntNodeUserDataGet(pMasterDBEntry->replicaList, nodeHdl, &dataHdl); CKPT_ERR_CHECK(CL_CKPT_SVR,CL_LOG_SEV_ERROR, ("clCkptActiveReplicaAddrGet failed rc[0x %x]\n",rc), rc); pMasterDBEntry->activeRepAddr = (ClIocNodeAddressT)(ClWordT)dataHdl; } } /* * Inform the client about the change in active replica. */ if((gCkptSvr->masterInfo.masterAddr == gCkptSvr->localAddr) || (clCpmIsSCCapable() && (pMasterDBEntry->prevActiveRepAddr == gCkptSvr->masterInfo.masterAddr))) { eventInfo.eventType = htonl(CL_CKPT_ACTIVE_REP_CHG_EVENT); eventInfo.actAddr = htonl(pMasterDBEntry->activeRepAddr); saNameCopy(&eventInfo.name, &pMasterDBEntry->name); eventInfo.name.length = htons(pMasterDBEntry->name.length); clLogNotice(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Changing the address from [%d] to [%d] for checkpoint [%.*s]", actAddr, pMasterDBEntry->activeRepAddr, pMasterDBEntry->name.length, pMasterDBEntry->name.value); rc = clEventPublish(gCkptSvr->clntUpdEvtHdl, (const void*)&eventInfo, sizeof(ClCkptClientUpdInfoT), &eventId); } /* * Delete the masterHdl from old address's peerlist and add to * new address's peerlist. */ if(!CL_CKPT_IS_COLLOCATED(pMasterDBEntry->attrib.creationFlags)) { _ckptPeerListMasterHdlAdd(mastHdl, actAddr, pMasterDBEntry->activeRepAddr); } exitOnError: { /* * Checkin the updated stuff. */ clHandleCheckin(gCkptSvr->masterInfo.masterDBHdl, mastHdl); return rc; } }
ClRcT clCkptMasterPeerUpdateNoLock(ClIocPortT portId, ClUint32T flag, ClIocNodeAddressT localAddr, ClUint8T credential) { ClRcT rc = CL_OK; CkptPeerInfoT *pPeerInfo = NULL; CkptNodeListInfoT *pPeerInfoDH = NULL; ClCntNodeHandleT nodeHdl = 0; ClCntNodeHandleT tempHdl = 0; ClHandleT *pMasterHandle = NULL; /* * Check whether node/component is coming up or going down. */ if(flag == CL_CKPT_SERVER_UP) { /* * Checkpoint server up scenario. */ clLogDebug(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_ANNOUNCE, "Received welcome message from master, updating the peerlist for [%d]", localAddr); /* Reset the replica list for peer being welcomed without knowing the peer is available or not */ if(localAddr != gCkptSvr->localAddr) { clLogNotice("PEER", "UPDATE", "Resetting the replica list for the peer [%#x] being welcomed", localAddr); clCkptMasterReplicaListUpdateNoLock(localAddr); } /* * Add an entry to the peer list if not existing. * Mark the node as "available" i.e. available for checkpoint * operations like storing replicas etc.. */ rc = clCntDataForKeyGet( gCkptSvr->masterInfo.peerList, (ClPtrT)(ClWordT)localAddr, (ClCntDataHandleT *)&pPeerInfo); if( rc == CL_OK && pPeerInfo != NULL) { CL_ASSERT(pPeerInfo->ckptList != 0); pPeerInfo->credential = credential; pPeerInfo->available = CL_CKPT_NODE_AVAIL; if(localAddr != gCkptSvr->localAddr) { pPeerInfo->replicaCount = 0; } } else { if( CL_OK !=( rc = _ckptMasterPeerListInfoCreate(localAddr, credential,0))) { return rc; } } } else { /* * Node/component down scenario. */ clLogDebug(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Updating the peerAddr [%d] for down notification", localAddr); /* * Find the corresponding entry from the peer list. */ if( CL_OK != (rc = clCntDataForKeyGet(gCkptSvr->masterInfo.peerList, (ClCntKeyHandleT)(ClWordT)localAddr, (ClCntDataHandleT *) &pPeerInfo))) { rc = CL_OK; goto exitOnError; } if( flag != CL_CKPT_COMP_DOWN) { clLogDebug(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Either ckpt server or node down, " "changing active address"); clCntFirstNodeGet(pPeerInfo->mastHdlList,&nodeHdl); tempHdl = 0; while(nodeHdl != 0) { rc = clCntNodeUserKeyGet(pPeerInfo->mastHdlList,nodeHdl, (ClCntKeyHandleT *)&pMasterHandle); if( CL_OK != rc ) { clLogError(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Not able get the data for node handle rc[0x %x]", rc); goto exitOnError; } rc = clCntNextNodeGet(pPeerInfo->mastHdlList, nodeHdl, &tempHdl); /* * Update the active address and inform the clients. */ if( CL_OK != (rc = _clCkpMastertReplicaAddressUpdate(*pMasterHandle, localAddr))) { return rc; } nodeHdl = tempHdl; tempHdl = 0; } } if (flag != CL_CKPT_SVR_DOWN) { /* * Component down/ node down case. * In case of component down close the associated client Hdl. * Incase of node down close all client Hdl. * Delete the ckpt Hdls from the client handle List. */ clLogDebug(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Closing the opened handles from this slot id [%d]...", localAddr); clCntFirstNodeGet(pPeerInfo->ckptList,&nodeHdl); while(nodeHdl != 0) { rc = clCntNodeUserDataGet(pPeerInfo->ckptList,nodeHdl, (ClCntDataHandleT *)&pPeerInfoDH); if( CL_OK != rc ) { clLogError(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Not able get the data for node handle rc[0x %x]", rc); goto exitOnError; } clCntNextNodeGet(pPeerInfo->ckptList,nodeHdl,&tempHdl); if ( (flag == CL_CKPT_COMP_DOWN && pPeerInfoDH->appPortNum == portId) || (flag == CL_CKPT_NODE_DOWN) ) { /* * Close the checkpoint hdl but dont delete the entry from * masterHdl list. */ if(gCkptSvr->masterInfo.masterAddr == gCkptSvr->localAddr) { clLogInfo(CL_CKPT_AREA_MAS_DEP, CL_CKPT_CTX_PEER_DOWN, "Closing the handle [%#llX]...", pPeerInfoDH->clientHdl); _clCkptMasterCloseNoLock(pPeerInfoDH->clientHdl, localAddr, !CL_CKPT_MASTER_HDL); } } nodeHdl = tempHdl; tempHdl = 0; } } else if (flag == CL_CKPT_SVR_DOWN) { /* * Mark the availability of checkpoint server as UNAVAILABLE. */ if(pPeerInfo->credential == CL_CKPT_CREDENTIAL_POSITIVE) gCkptSvr->masterInfo.availPeerCount--; pPeerInfo->available = CL_CKPT_NODE_UNAVAIL; } if(flag == CL_CKPT_NODE_DOWN || flag == CL_CKPT_SVR_DOWN) { /* * Node down case, delete the entry from master's peer list. */ rc = clCntAllNodesForKeyDelete(gCkptSvr->masterInfo.peerList, (ClPtrT)(ClWordT)localAddr); CKPT_ERR_CHECK(CL_CKPT_SVR,CL_LOG_SEV_ERROR, (" MasterPeerUpdate failed rc[0x %x]\n",rc), rc); } if( flag != CL_CKPT_COMP_DOWN) { /* * Find other nodes to store the replicas of checkpoints for whom * this node was storing the replicas. */ if(gCkptSvr->masterInfo.masterAddr == gCkptSvr->localAddr) { _ckptCheckpointLoadBalancing(); } } } exitOnError: { return rc; } }
/** * API to un-register a service with transaction-agent */ ClRcT clTxnAgentServiceUnRegister(CL_IN ClTxnAgentServiceHandleT tHandle) { ClRcT rc = CL_OK; ClUint8T twoPC = 0; ClTxnAgentCompServiceInfoT *pCompService = NULL; CL_FUNC_ENTER(); if (tHandle == 0x0) { CL_FUNC_EXIT(); return CL_TXN_RC(CL_ERR_INVALID_HANDLE); } /* This is a request from service hosted in the component to unregister from the transaction-management. Remove the entry from the data-structure and invalidate the handle FIXME: Before actually deleting it, check to see if this service is part of any active txn or not */ rc = clCntDataForKeyGet(clTxnAgntCfg->compServiceMap, (ClCntKeyHandleT) &(((ClTxnAgentCompServiceInfoT *)tHandle)->serviceType), (ClCntDataHandleT *)&pCompService); if (CL_OK == rc) { ClUint32T srvCount; if (pCompService->serviceCapability == CL_TXN_AGENT_SERVICE_1PC) { twoPC = 0; clTxnAgntCfg->agentCapability &= ~(CL_TXN_AGENT_SERVICE_1PC); } else if(pCompService->serviceCapability == CL_TXN_AGENT_SERVICE_2PC) { twoPC = 1; } rc = clCntAllNodesForKeyDelete(clTxnAgntCfg->compServiceMap, (ClCntKeyHandleT) &(((ClTxnAgentCompServiceInfoT *)tHandle)->serviceType)); if(CL_OK != rc) { clLogError("AGT", NULL, "Failed to delete node from compServiceMap corresponding to service[%d]", ((ClTxnAgentCompServiceInfoT *)tHandle)->serviceType); return rc; } /* Reset agent capability, if necessary */ rc = clCntSizeGet(clTxnAgntCfg->compServiceMap, &srvCount); if ( (CL_OK == rc) && (srvCount == 0x0) ) { clTxnAgntCfg->agentCapability = CL_TXN_AGENT_NO_SERVICE_REGD; } else if ( (CL_OK == rc) && (srvCount == 0x1) && ( (clTxnAgntCfg->agentCapability & CL_TXN_AGENT_SERVICE_1PC) == CL_TXN_AGENT_SERVICE_1PC) ) { clTxnAgntCfg->agentCapability = CL_TXN_AGENT_SERVICE_1PC; } else if ( CL_OK != rc ) { CL_DEBUG_PRINT(CL_DEBUG_ERROR, ("Error while reading number of service registered. rc:0x%x", rc)); } } if(CL_OK == rc) clLogNotice("AGT", "FIN", "Unregistering [%s] service successfull", twoPC ? "2PC":"READ"); CL_TXN_RETURN_RC(rc, ("Failed to unregister component-service rc:0x%x\n", rc)); }