ClRcT clMsgFinBlockStatusSet(ClMsgMoveStatusT status) { ClRcT rc; ClIocNodeAddressT node; switch(status) { case MSG_MOVE_FIN_BLOCKED : if(gMsgMoveStatus == MSG_MOVE_FIN_BLOCKED) { goto out; } rc = clMsgNextNodeGet(gLocalAddress, &node); if(rc != CL_OK) { clLogError("QUE", "FAI", "Failed to get the next node's address. error code [0x%x].", rc); goto error_out; } else if(node == gLocalAddress) { clLogDebug("QUE", "FAI", "Only one/this node is present in the cluster."); gMsgMoveStatus = MSG_MOVE_DONE; clOsalCondSignal(gFinBlockCond); goto error_out; } gQMoveDestNode = node; gMsgMoveStatus = MSG_MOVE_FIN_BLOCKED; /* Find closed queues and move */ clMsgFailoverQueuesMove(gQMoveDestNode, &gMsgNumOfOpenQs); error_out: out: if(gMsgNumOfOpenQs != 0) break; case MSG_MOVE_DONE: if(gMsgNumOfOpenQs != 0) gMsgNumOfOpenQs--; if(gMsgNumOfOpenQs == 0) { gMsgMoveStatus = MSG_MOVE_DONE; clOsalCondSignal(gFinBlockCond); } break; default: break; } return CL_OK; }
static void clMsgNotificationReceiveCallback(ClIocNotificationIdT event, ClPtrT pArg, ClIocAddressT *pAddr) { clOsalMutexLock(&gClMsgFinalizeLock); if(!gClMsgInit) { /* * Msg server already finalized. skip it. */ clOsalMutexUnlock(&gClMsgFinalizeLock); return; } ++gClMsgSvcRefCnt; clOsalMutexUnlock(&gClMsgFinalizeLock); if((event == CL_IOC_COMP_DEATH_NOTIFICATION && pAddr->iocPhyAddress.portId == CL_IOC_MSG_PORT) || event == CL_IOC_NODE_LEAVE_NOTIFICATION || event == CL_IOC_NODE_LINK_DOWN_NOTIFICATION) { clMsgNodeLeftCleanup(pAddr); } else if(event == CL_IOC_COMP_DEATH_NOTIFICATION && pAddr->iocPhyAddress.portId > CL_IOC_RESERVED_PORTS) { clMsgCompLeftCleanup(pAddr); } clOsalMutexLock(&gClMsgFinalizeLock); --gClMsgSvcRefCnt; clOsalCondSignal(&gClMsgFinalizeCond); clOsalMutexUnlock(&gClMsgFinalizeLock); return; }
void cpmClusterTrackCallBack(ClGmsHandleT handle, const ClGmsClusterNotificationBufferT *clusterNotificationBuffer, ClUint32T nMembers, ClRcT rc) { clLogMultiline(CL_LOG_SEV_DEBUG, CPM_LOG_AREA_CPM, CPM_LOG_CTX_CPM_GMS, "Received cluster track callback from GMS on node [%s] -- \n" "Leader : [%d] \n" "Deputy : [%d] (-1 -> No deputy) \n" "Leader changed ? [%s] \n" "Number of nodes in callback : [%d]", gpClCpm->pCpmLocalInfo->nodeName, clusterNotificationBuffer->leader, clusterNotificationBuffer->deputy, clusterNotificationBuffer->leadershipChanged ? "Yes" : "No", clusterNotificationBuffer->numberOfItems); clOsalMutexLock(&gpClCpm->cpmGmsMutex); gpClCpm->trackCallbackInProgress = CL_TRUE; clOsalMutexUnlock(&gpClCpm->cpmGmsMutex); cpmHandleGroupInformation(clusterNotificationBuffer); rc = clOsalMutexLock(&gpClCpm->cpmGmsMutex); gpClCpm->trackCallbackInProgress = CL_FALSE; CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_OSAL_MUTEX_LOCK_ERR, rc, rc, CL_LOG_HANDLE_APP); rc = clOsalCondSignal(&gpClCpm->cpmGmsCondVar); CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_OSAL_COND_SIGNAL_ERR, rc, rc, CL_LOG_HANDLE_APP); rc = clOsalMutexUnlock(&gpClCpm->cpmGmsMutex); CL_CPM_CHECK_1(CL_LOG_SEV_ERROR, CL_CPM_LOG_1_OSAL_MUTEX_UNLOCK_ERR, rc, rc, CL_LOG_HANDLE_APP); failure: return; }
static __inline__ ClRcT clAmsEntityTriggerRecoveryListAdd(ClAmsEntityTriggerT *pEntityTrigger) { clOsalMutexLock(&gClAmsEntityTriggerRecoveryCtrl.list.mutex); clListAddTail(&pEntityTrigger->list, &gClAmsEntityTriggerRecoveryCtrl.list.list); ++gClAmsEntityTriggerRecoveryCtrl.list.numElements; clOsalCondSignal(&gClAmsEntityTriggerRecoveryCtrl.list.cond); clOsalMutexUnlock(&gClAmsEntityTriggerRecoveryCtrl.list.mutex); return CL_OK; }
static ClRcT clAmsEntityTriggerRecoveryThreadDelete(void) { ClRcT rc = CL_OK; if(gClAmsEntityTriggerRecoveryCtrl.running && gClAmsEntityTriggerRecoveryCtrl.task) { clOsalMutexLock(&gClAmsEntityTriggerRecoveryCtrl.list.mutex); gClAmsEntityTriggerRecoveryCtrl.running = CL_FALSE; clOsalCondSignal(&gClAmsEntityTriggerRecoveryCtrl.list.cond); clOsalMutexUnlock(&gClAmsEntityTriggerRecoveryCtrl.list.mutex); clOsalTaskJoin(gClAmsEntityTriggerRecoveryCtrl.task); } return rc; }
static void sendHashDeleteCallBack(ClCntKeyHandleT userKey, ClCntDataHandleT userData) { ClRmdRecordSendT *rec = (ClRmdRecordSendT *) userData; CL_FUNC_ENTER(); if (userData) { /* * The check on the flag is a must now since sync * path also invokes this code. Added as a fix to * Bug - 3748. */ if (rec->flags & CL_RMD_CALL_ASYNC) { /* * cleanup for Async Info */ if (rec->recType.asyncRec.timerID) { clTimerDeleteAsync(&rec->recType.asyncRec.timerID); } clHeapFree(rec); } else { /* Before destroying the condition variable, make sure it is not being used in clOsalCondWait(). */ clOsalCondSignal(&rec->recType.syncRec.syncCond); /* * cleanup for Sync Info */ clOsalCondDestroy(&rec->recType.syncRec.syncCond); } } CL_FUNC_EXIT(); }
ClRcT clLogUtilLibFinalize(ClBoolT logLibInit) { ClRcT rc = CL_OK; /* Notify the thread to stop */ rc = clOsalMutexLock(&gLogMutex); if( CL_OK != rc ) { return rc; } gUtilLibInitialized = CL_FALSE; clLogDebugFilterFinalize(); /* * signalling to that guy to wake up */ clOsalCondSignal(&gLogCond); clOsalMutexUnlock(&gLogMutex); /* Wait till that thread finishes its own job */ clOsalTaskJoin(taskId); /* * This is hardcoded, have to find out the best way to solve this problem * once all the data have been flushed, log library will be finalized. */ if( CL_TRUE == logLibInit ) { clLogFinalize(1); } /* * just destroying provided, all initialed libraried will be * finalized by main EO function. */ clOsalCondDestroy(&gLogCond); clOsalMutexDestroy(&gLogMutex); return CL_OK; }
/* * This function will be called either from GMS track callback or * IOC notification, it receives the master address & deputy and * process the same */ ClRcT clCkptMasterAddressUpdate(ClIocNodeAddressT leader, ClIocNodeAddressT deputy) { ClIocTLInfoT tlInfo = {0}; SaNameT name = {0}; ClRcT rc = CL_OK; ClBoolT updateReq = CL_FALSE; /* * Check whether master or deputy address has changed. */ if(gCkptSvr->masterInfo.masterAddr != leader) { /* * Master address changed. */ updateReq = CL_TRUE; gCkptSvr->masterInfo.prevMasterAddr = gCkptSvr->masterInfo.masterAddr; gCkptSvr->masterInfo.masterAddr = leader; /* * Deregister the old TL entry. */ if(gCkptSvr->masterInfo.compId != CL_CKPT_UNINIT_VALUE) { rc = clIocTransparencyDeregister(gCkptSvr->masterInfo.compId); } else { clCpmComponentNameGet(gCkptSvr->amfHdl, &name); clCpmComponentIdGet(gCkptSvr->amfHdl, &name, &gCkptSvr->compId); gCkptSvr->masterInfo.compId = gCkptSvr->compId; } /* * Update the TL. */ if(gCkptSvr->masterInfo.masterAddr == clIocLocalAddressGet()) { ckptOwnLogicalAddressGet(&tlInfo.logicalAddr); tlInfo.compId = gCkptSvr->compId; gCkptSvr->masterInfo.compId = gCkptSvr->compId; tlInfo.contextType = CL_IOC_TL_GLOBAL_SCOPE; tlInfo.physicalAddr.nodeAddress = clIocLocalAddressGet(); tlInfo.physicalAddr.portId = CL_IOC_CKPT_PORT; tlInfo.haState = CL_IOC_TL_ACTIVE; rc = clIocTransparencyRegister(&tlInfo); } /* * update the ioc notify callbacks for the new master address * Once address update is over, then we have uninstall the registered * callback and reregistered to new master address */ clCkptIocCallbackUpdate(); } if(gCkptSvr->masterInfo.deputyAddr != deputy) { /* * Deputy address has changed. */ updateReq = CL_TRUE; gCkptSvr->masterInfo.deputyAddr = deputy ; } /* * Signal the receipt of master and deputy addresses. */ clOsalMutexLock(gCkptSvr->mutexVar); if(gCkptSvr->condVarWaiting == CL_TRUE) { gCkptSvr->condVarWaiting = CL_FALSE; clOsalCondSignal(gCkptSvr->condVar); } clOsalMutexUnlock(gCkptSvr->mutexVar); /* * Update the old master(if existing) with the new leader addresses. */ if((updateReq == CL_TRUE) && (((ClInt32T) gCkptSvr->masterInfo.prevMasterAddr != -1) && (gCkptSvr->masterInfo.prevMasterAddr != CL_CKPT_UNINIT_ADDR))) { rc = ckptIdlHandleUpdate(gCkptSvr->masterInfo.prevMasterAddr, gCkptSvr->ckptIdlHdl,0); rc = VDECL_VER(clCkptLeaderAddrUpdateClientAsync, 4, 0, 0)(gCkptSvr->ckptIdlHdl, gCkptSvr->masterInfo.masterAddr, gCkptSvr->masterInfo.deputyAddr, NULL,0); } clLogNotice("ADDR", "UPDATE", "CKPT master [%d], deputy [%d]", gCkptSvr->masterInfo.masterAddr, gCkptSvr->masterInfo.deputyAddr); return rc; }
static ClRcT logVWriteDeferred(ClHandleT handle, ClLogSeverityT severity, ClUint16T serviceId, ClUint16T msgId, ClCharT *pMsgHeader, ClBoolT deferred, ClCharT *pFmtStr, va_list vaargs) { ClRcT rc = CL_OK; ClBoolT signalFlusher = CL_FALSE; static ClBoolT deferredFlag = CL_FALSE; static ClBoolT flushPending = CL_TRUE; ClBoolT initialRecord = CL_FALSE; ClBoolT unlock = CL_TRUE; if( gUtilLibInitialized == CL_FALSE ) { /* * Since log util lib/EO itself is not initialized, * we can safely assume being single threaded at this point * and just save the log record for a later flush. */ initialRecord = CL_TRUE; goto out_store; } /* Take the mutex */ rc = clOsalMutexLock(&gLogMutex); if(CL_GET_ERROR_CODE(rc) == CL_ERR_INUSE) { /* * Same thread trying to lock as a potential log write loop. * We avoid taking the lock here. */ unlock = CL_FALSE; rc = CL_OK; } if( CL_OK != rc ) { fprintf(stderr, "failed to get the lock [0x%x]", rc); goto failure; } if(gClLogServer) deferred = CL_TRUE; /* * If log is up and there are no pending flushes, write directly * to avoid garbled logs because of per client deferred writes * We go the deferred way for log server writes whenever they are enabled/fired */ if(!deferred && CL_LOG_HANDLE_APP != CL_HANDLE_INVALID_VALUE) { if(flushPending && unlock) { clLogFlushRecords(); flushPending = CL_FALSE; } if(unlock) clOsalMutexUnlock(&gLogMutex); return clLogVWriteAsyncWithHeader(handle, severity, serviceId, msgId, pMsgHeader, vaargs); } if(!unlock) { /* * Skip the recursive deferred log here. */ return CL_OK; } /* Access the index */ out_store: gLogMsgArray[writeIdx].handle = handle; gLogMsgArray[writeIdx].severity = severity; gLogMsgArray[writeIdx].serviceId = serviceId; gLogMsgArray[writeIdx].msgId = msgId; gLogMsgArray[writeIdx].msgHeader[0] = 0; if(pMsgHeader) { memset(gLogMsgArray[writeIdx].msgHeader, 0, sizeof(gLogMsgArray[writeIdx].msgHeader)); strncpy(gLogMsgArray[writeIdx].msgHeader, pMsgHeader, sizeof(gLogMsgArray[writeIdx].msgHeader)-1); } vsnprintf(gLogMsgArray[writeIdx].msg, CL_LOG_MAX_MSG_LEN, pFmtStr, vaargs); ++writeIdx; writeIdx = writeIdx % CL_LOG_MAX_NUM_MSGS; if( overWriteFlag ) { ++readIdx; readIdx %= CL_LOG_MAX_NUM_MSGS; } if( (readIdx == writeIdx) && (overWriteFlag == 0) ) { overWriteFlag = 1; } if(initialRecord) return CL_OK; if(deferred) { if(!deferredFlag) deferredFlag = CL_TRUE; if(!flushPending) flushPending = CL_TRUE; } if(deferredFlag && (signalFlusher || overWriteFlag != 0 || (writeIdx % CL_LOG_FLUSH_FREQ == 0)) ) { clOsalCondSignal(&gLogCond); } if(unlock) { rc = clOsalMutexUnlock(&gLogMutex); if( CL_OK != rc ) { goto failure; } } return CL_OK; failure: return rc; }