bool Dbinfo::find_next(Ndbinfo::ScanCursor* cursor) const { Uint32 node = refToNode(cursor->currRef); Uint32 block = refToBlock(cursor->currRef); const Uint32 instance = refToInstance(cursor->currRef); ndbrequire(instance == 0); if (node == 0) { jam(); // First 'find_next' ndbrequire(block == 0); cursor->currRef = switchRef(dbinfo_blocks[0], getOwnNodeId()); return true; } if (block) { jam(); // Find next block ndbrequire(node == getOwnNodeId()); block = find_next_block(block); if (block) { jam(); cursor->currRef = switchRef(block, node); return true; } } // Nothing more to scan cursor->currRef = 0; return false; }
void DblqhProxy::sendGCP_SAVECONF(Signal* signal, Uint32 ssId) { Ss_GCP_SAVEREQ& ss = ssFind<Ss_GCP_SAVEREQ>(ssId); if (!lastReply(ss)) return; if (ss.m_error == 0) { GCPSaveConf* conf = (GCPSaveConf*)signal->getDataPtrSend(); conf->dihPtr = ss.m_req.dihPtr; conf->nodeId = getOwnNodeId(); conf->gci = ss.m_req.gci; sendSignal(ss.m_req.dihBlockRef, GSN_GCP_SAVECONF, signal, GCPSaveConf::SignalLength, JBB); } else { jam(); GCPSaveRef* ref = (GCPSaveRef*)signal->getDataPtrSend(); ref->dihPtr = ss.m_req.dihPtr; ref->nodeId = getOwnNodeId(); ref->gci = ss.m_req.gci; ref->errorCode = ss.m_error; sendSignal(ss.m_req.dihBlockRef, GSN_GCP_SAVEREF, signal, GCPSaveRef::SignalLength, JBB); } ssRelease<Ss_GCP_SAVEREQ>(ssId); }
void DbgdmProxy::sendTAB_COMMITCONF(Signal* signal, Uint32 ssId) { Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId); BlockReference dictRef = ss.m_req.senderRef; if (!lastReply(ss)) return; if (ss.m_error == 0) { jam(); TabCommitConf* conf = (TabCommitConf*)signal->getDataPtrSend(); conf->senderData = ss.m_req.senderData; conf->nodeId = getOwnNodeId(); conf->tableId = ss.m_req.tableId; sendSignal(dictRef, GSN_TAB_COMMITCONF, signal, TabCommitConf::SignalLength, JBB); } else { jam(); TabCommitRef* ref = (TabCommitRef*)signal->getDataPtrSend(); ref->senderData = ss.m_req.senderData; ref->nodeId = getOwnNodeId(); ref->tableId = ss.m_req.tableId; sendSignal(dictRef, GSN_TAB_COMMITREF, signal, TabCommitRef::SignalLength, JBB); return; } ssRelease<Ss_TAB_COMMITREQ>(ssId); }
void ClusterMgr::reportConnected(NodeId nodeId) { DBUG_ENTER("ClusterMgr::reportConnected"); DBUG_PRINT("info", ("nodeId: %u", nodeId)); /** * Ensure that we are sending heartbeat every 100 ms * until we have got the first reply from NDB providing * us with the real time-out period to use. */ assert(nodeId > 0 && nodeId < MAX_NODES); if (nodeId == getOwnNodeId()) { noOfConnectedNodes--; // Don't count self... } noOfConnectedNodes++; Node & cm_node = theNodes[nodeId]; trp_node & theNode = cm_node; cm_node.hbMissed = 0; cm_node.hbCounter = 0; cm_node.hbFrequency = 0; assert(theNode.is_connected() == false); /** * make sure the node itself is marked connected even * if first API_REGCONF has not arrived */ theNode.set_connected(true); theNode.m_state.m_connected_nodes.set(nodeId); theNode.m_info.m_version = 0; theNode.compatible = true; theNode.nfCompleteRep = true; theNode.m_node_fail_rep = false; theNode.m_state.startLevel = NodeState::SL_NOTHING; theNode.minDbVersion = 0; /** * We know that we have clusterMgrThreadMutex and trp_client::mutex * but we don't know if we are polling...and for_each can * only be used by a poller... * * Send signal to self, so that we can do this when receiving a signal */ NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId())); signal.theVerId_signalNumber = GSN_CONNECT_REP; signal.theReceiversBlockNumber = API_CLUSTERMGR; signal.theTrace = 0; signal.theLength = 1; signal.getDataPtrSend()[0] = nodeId; raw_sendSignal(&signal, getOwnNodeId()); DBUG_VOID_RETURN; }
void DblqhProxy::execEXEC_SR_2(Signal* signal, GlobalSignalNumber gsn) { ndbrequire(signal->getLength() == Ss_EXEC_SR_2::Sig::SignalLength); const Ss_EXEC_SR_2::Sig* sig = (const Ss_EXEC_SR_2::Sig*)signal->getDataPtr(); Uint32 ssId = getSsId(sig); bool found = false; Ss_EXEC_SR_2& ss = ssFindSeize<Ss_EXEC_SR_2>(ssId, &found); if (!found) { jam(); setMask(ss); } ndbrequire(sig->nodeId == getOwnNodeId()); if (ss.m_sigcount == 0) { jam(); ss.m_gsn = gsn; ss.m_sig = *sig; } else { jam(); ndbrequire(ss.m_gsn == gsn); ndbrequire(memcmp(&ss.m_sig, sig, sizeof(*sig)) == 0); } ss.m_sigcount++; // reversed roles recvCONF(signal, ss); }
void DblqhProxy::sendLQH_TRANSCONF(Signal* signal, Uint32 ssId) { Ss_LQH_TRANSREQ& ss = ssFind<Ss_LQH_TRANSREQ>(ssId); if (ss.m_conf.operationStatus != LqhTransConf::LastTransConf) { jam(); LqhTransConf* conf = (LqhTransConf*)signal->getDataPtrSend(); *conf = ss.m_conf; conf->tcRef = ss.m_req.senderData; sendSignal(ss.m_req.senderRef, GSN_LQH_TRANSCONF, signal, LqhTransConf::SignalLength, JBB); // more replies from this worker skipConf(ss); } if (!lastReply(ss)) return; if (ss.m_error == 0) { jam(); LqhTransConf* conf = (LqhTransConf*)signal->getDataPtrSend(); conf->tcRef = ss.m_req.senderData; conf->lqhNodeId = getOwnNodeId(); conf->operationStatus = LqhTransConf::LastTransConf; sendSignal(ss.m_req.senderRef, GSN_LQH_TRANSCONF, signal, LqhTransConf::SignalLength, JBB); } else { ndbrequire(false); } ssRelease<Ss_LQH_TRANSREQ>(ssId); }
void ClusterMgr::startup() { assert(theStop == -1); Uint32 nodeId = getOwnNodeId(); Node & cm_node = theNodes[nodeId]; trp_node & theNode = cm_node; assert(theNode.defined); lock(); theFacade.doConnect(nodeId); flush_send_buffers(); unlock(); for (Uint32 i = 0; i<3000; i++) { theFacade.request_connection_check(); start_poll(); do_poll(0); complete_poll(); if (theNode.is_connected()) break; NdbSleep_MilliSleep(20); } assert(theNode.is_connected()); Guard g(clusterMgrThreadMutex); /* Signalling to creating thread that we are done with thread startup */ theStop = 0; NdbCondition_Broadcast(waitForHBCond); }
void Ndbfs::execREAD_CONFIG_REQ(Signal* signal) { const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr(); Uint32 ref = req->senderRef; Uint32 senderData = req->senderData; const ndb_mgm_configuration_iterator * p = m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); theFileSystemPath.assfmt("%sndb_%u_fs%s", m_ctx.m_config.fileSystemPath(), getOwnNodeId(), DIR_SEPARATOR); theBackupFilePath.assign(m_ctx.m_config.backupFilePath()); theRequestPool = new Pool<Request>; m_maxFiles = 0; ndb_mgm_get_int_parameter(p, CFG_DB_MAX_OPEN_FILES, &m_maxFiles); Uint32 noIdleFiles = 27; ndb_mgm_get_int_parameter(p, CFG_DB_INITIAL_OPEN_FILES, &noIdleFiles); if (noIdleFiles > m_maxFiles && m_maxFiles != 0) m_maxFiles = noIdleFiles; // Create idle AsyncFiles for (Uint32 i = 0; i < noIdleFiles; i++){ theIdleFiles.push_back(createAsyncFile()); } ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend(); conf->senderRef = reference(); conf->senderData = senderData; sendSignal(ref, GSN_READ_CONFIG_CONF, signal, ReadConfigConf::SignalLength, JBB); }
void ClusterMgr::startup() { assert(theStop == -1); Uint32 nodeId = getOwnNodeId(); Node & cm_node = theNodes[nodeId]; trp_node & theNode = cm_node; assert(theNode.defined); lock(); theFacade.doConnect(nodeId); flush_send_buffers(); unlock(); for (Uint32 i = 0; i<3000; i++) { lock(); theFacade.theTransporterRegistry->update_connections(); flush_send_buffers(); unlock(); if (theNode.is_connected()) break; NdbSleep_MilliSleep(20); } assert(theNode.is_connected()); Guard g(clusterMgrThreadMutex); theStop = 0; NdbCondition_Broadcast(waitForHBCond); }
void DblqhProxy::execLQHFRAGREQ(Signal* signal) { LqhFragReq* req = (LqhFragReq*)signal->getDataPtrSend(); Uint32 instance = getInstanceKey(req->tableId, req->fragId); // wl4391_todo impl. method that fakes senders block-ref sendSignal(numberToRef(DBLQH, instance, getOwnNodeId()), GSN_LQHFRAGREQ, signal, signal->getLength(), JBB); }
void ClusterMgr::execDISCONNECT_REP(const NdbApiSignal* sig, const LinearSectionPtr ptr[]) { const DisconnectRep * rep = CAST_CONSTPTR(DisconnectRep, sig->getDataPtr()); Uint32 nodeId = rep->nodeId; assert(nodeId > 0 && nodeId < MAX_NODES); Node & cm_node = theNodes[nodeId]; trp_node & theNode = cm_node; bool node_failrep = theNode.m_node_fail_rep; set_node_dead(theNode); theNode.set_connected(false); noOfConnectedNodes--; if (noOfConnectedNodes == 0) { if (!global_flag_skip_invalidate_cache && theFacade.m_globalDictCache) { theFacade.m_globalDictCache->lock(); theFacade.m_globalDictCache->invalidate_all(); theFacade.m_globalDictCache->unlock(); m_connect_count ++; m_cluster_state = CS_waiting_for_clean_cache; } if (m_auto_reconnect == 0) { theStop = 2; } } if (node_failrep == false) { /** * Inform API */ NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId())); signal.theVerId_signalNumber = GSN_NODE_FAILREP; signal.theReceiversBlockNumber = API_CLUSTERMGR; signal.theTrace = 0; signal.theLength = NodeFailRep::SignalLengthLong; NodeFailRep * rep = CAST_PTR(NodeFailRep, signal.getDataPtrSend()); rep->failNo = 0; rep->masterNodeId = 0; rep->noOfNodes = 1; NodeBitmask::clear(rep->theAllNodes); NodeBitmask::set(rep->theAllNodes, nodeId); execNODE_FAILREP(&signal, 0); } }
void Qmgr::initData() { creadyDistCom = ZFALSE; // Records with constant sizes nodeRec = new NodeRec[MAX_NODES]; cnoCommitFailedNodes = 0; c_maxDynamicId = 0; c_clusterNodes.clear(); c_stopReq.senderRef = 0; /** * Check sanity for NodeVersion */ ndbrequire((Uint32)NodeInfo::DB == 0); ndbrequire((Uint32)NodeInfo::API == 1); ndbrequire((Uint32)NodeInfo::MGM == 2); NodeRecPtr nodePtr; nodePtr.i = getOwnNodeId(); ptrAss(nodePtr, nodeRec); nodePtr.p->blockRef = reference(); c_connectedNodes.set(getOwnNodeId()); setNodeInfo(getOwnNodeId()).m_version = NDB_VERSION; /** * Timeouts */ const ndb_mgm_configuration_iterator * p = m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); Uint32 hbDBAPI = 1500; ndb_mgm_get_int_parameter(p, CFG_DB_API_HEARTBEAT_INTERVAL, &hbDBAPI); setHbApiDelay(hbDBAPI); }//Qmgr::initData()
void DblqhProxy::execLQHFRAGREQ(Signal* signal) { LqhFragReq* req = (LqhFragReq*)signal->getDataPtrSend(); Uint32 instance = getInstanceKey(req->tableId, req->fragId); /* Ensure instance hasn't quietly mapped back to proxy! */ ndbrequire(signal->getSendersBlockRef() != reference()); // wl4391_todo impl. method that fakes senders block-ref sendSignal(numberToRef(DBLQH, instance, getOwnNodeId()), GSN_LQHFRAGREQ, signal, signal->getLength(), JBB); }
void DblqhProxy::checkSendEMPTY_LCP_CONF_impl(Signal* signal) { ndbrequire(!c_lcpRecord.m_empty_lcp_req.isclear()); EmptyLcpRep * rep = (EmptyLcpRep*)signal->getDataPtrSend(); EmptyLcpConf * conf = (EmptyLcpConf*)rep->conf; switch(c_lcpRecord.m_state){ case LcpRecord::L_IDLE: jam(); conf->idle = true; break; case LcpRecord::L_STARTING: jam(); return; case LcpRecord::L_RUNNING:{ jam(); if (getNoOfOutstanding(c_lcpRecord) == 0) { jam(); /** * Given that we wait for all ongoing... * we can simply return last LCP_FRAG_ORD sent to us */ conf->tableId = c_lcpRecord.m_last_lcp_frag_ord.tableId; conf->fragmentId = c_lcpRecord.m_last_lcp_frag_ord.fragmentId; conf->lcpId = c_lcpRecord.m_last_lcp_frag_ord.lcpId; conf->lcpNo = c_lcpRecord.m_last_lcp_frag_ord.lcpNo; break; } return; } case LcpRecord::L_COMPLETING_1: jam(); case LcpRecord::L_COMPLETING_2: jam(); case LcpRecord::L_COMPLETING_3: jam(); return; } conf->senderNodeId = getOwnNodeId(); c_lcpRecord.m_empty_lcp_req.copyto(NdbNodeBitmask::Size, rep->receiverGroup); sendSignal(DBDIH_REF, GSN_EMPTY_LCP_REP, signal, EmptyLcpRep::SignalLength + EmptyLcpConf::SignalLength, JBB); c_lcpRecord.m_empty_lcp_req.clear(); }
void ClusterMgr::reportDisconnected(NodeId nodeId) { assert(nodeId > 0 && nodeId < MAX_NODES); assert(noOfConnectedNodes > 0); /** * We know that we have trp_client lock * but we don't know if we are polling...and for_each can * only be used by a poller... * * Send signal to self, so that we can do this when receiving a signal */ NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId())); signal.theVerId_signalNumber = GSN_DISCONNECT_REP; signal.theReceiversBlockNumber = API_CLUSTERMGR; signal.theTrace = 0; signal.theLength = DisconnectRep::SignalLength; DisconnectRep * rep = CAST_PTR(DisconnectRep, signal.getDataPtrSend()); rep->nodeId = nodeId; rep->err = 0; raw_sendSignal(&signal, getOwnNodeId()); }
void DbtcProxy::execTAKE_OVERTCCONF(Signal* signal) { jamEntry(); if (!checkNodeFailSequence(signal)) { jam(); return; } for (Uint32 i = 0; i < c_workers; i++) { jam(); Uint32 ref = numberToRef(number(), workerInstance(i), getOwnNodeId()); sendSignal(ref, GSN_TAKE_OVERTCCONF, signal, signal->getLength(), JBB); } }
void DblqhProxy::completeLCP_1(Signal* signal) { ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING); c_lcpRecord.m_state = LcpRecord::L_COMPLETING_1; ndbrequire(c_lcpRecord.m_complete_outstanding == 0); /** * send LCP_FRAG_ORD (lastFragmentFlag = true) * to all LQH instances... * they will reply with LCP_COMPLETE_REP */ LcpFragOrd* ord = (LcpFragOrd*)signal->getDataPtrSend(); ord->lcpId = c_lcpRecord.m_lcpId; ord->lastFragmentFlag = true; for (Uint32 i = 0; i<c_workers; i++) { jam(); c_lcpRecord.m_complete_outstanding++; sendSignal(workerRef(i), GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB); } /** * send END_LCP_REQ to all pgman instances (except "extra" pgman) * they will reply with END_LCP_CONF */ EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend(); req->senderData= 0; req->senderRef= reference(); req->backupPtr= 0; req->backupId= c_lcpRecord.m_lcpId; for (Uint32 i = 0; i<c_workers; i++) { jam(); c_lcpRecord.m_complete_outstanding++; sendSignal(numberToRef(PGMAN, workerInstance(i), getOwnNodeId()), GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB); } }
// GSN_EXEC_FRAGCONF void DblqhProxy::execEXEC_FRAGCONF(Signal* signal) { Uint32 ref = signal->theData[1]; if (refToNode(ref) == getOwnNodeId()) { jam(); sendSignal(ref, GSN_EXEC_FRAGCONF, signal, 1, JBB); } else if (ndb_route_exec_frag(getNodeInfo(refToNode(ref)).m_version)) { jam(); sendSignal(numberToRef(DBLQH, refToNode(ref)), GSN_EXEC_FRAGCONF, signal, 2, JBB); } else { jam(); sendSignal(ref, GSN_EXEC_FRAGCONF, signal, 2, JBB); } }
void DblqhProxy::sendSTART_RECREQ_2(Signal* signal, Uint32 ssId) { Ss_START_RECREQ_2& ss = ssFind<Ss_START_RECREQ_2>(ssId); const Ss_START_RECREQ_2::Req* req = (const Ss_START_RECREQ_2::Req*)signal->getDataPtr(); if (firstReply(ss)) { ss.m_req = *req; } else { jam(); /* * Fragments can be started from different lcpId's. LGMAN must run * UNDO until lowest lcpId. Each DBLQH instance computes the lowest * lcpId in START_FRAGREQ. In MT case the proxy further computes * the lowest of the lcpId's from worker instances. */ if (req->lcpId < ss.m_req.lcpId) { jam(); ss.m_req.lcpId = req->lcpId; } ndbrequire(ss.m_req.proxyBlockNo == req->proxyBlockNo); } if (!lastReply(ss)) return; { Ss_START_RECREQ_2::Req* req = (Ss_START_RECREQ_2::Req*)signal->getDataPtrSend(); *req = ss.m_req; BlockReference ref = numberToRef(req->proxyBlockNo, getOwnNodeId()); sendSignal(ref, GSN_START_RECREQ, signal, Ss_START_RECREQ_2::Req::SignalLength, JBB); } }
// GSN_EXEC_FRAGREQ void DblqhProxy::execEXEC_FRAGREQ(Signal* signal) { Uint32 ref = ((ExecFragReq*)signal->getDataPtr())->dst; if (refToNode(ref) == getOwnNodeId()) { jam(); sendSignal(ref, GSN_EXEC_FRAGREQ, signal, signal->getLength(), JBB); } else if (ndb_route_exec_frag(getNodeInfo(refToNode(ref)).m_version)) { jam(); sendSignal(numberToRef(DBLQH, refToNode(ref)), GSN_EXEC_FRAGREQ, signal, signal->getLength(), JBB); } else { jam(); sendSignal(ref, GSN_EXEC_FRAGREQ, signal, signal->getLength(), JBB); } }
void DblqhProxy::completeLCP_2(Signal* signal) { jamEntry(); ndbrequire(c_lcpRecord.m_state == LcpRecord::L_COMPLETING_1); c_lcpRecord.m_state = LcpRecord::L_COMPLETING_2; EndLcpReq* req = (EndLcpReq*)signal->getDataPtrSend(); req->senderData= 0; req->senderRef= reference(); req->backupPtr= 0; req->backupId= c_lcpRecord.m_lcpId; c_lcpRecord.m_complete_outstanding++; /** * send to "extra" instance * that will checkpoint extent-pages */ // NOTE: ugly to use MaxLqhWorkers directly Uint32 instance = c_workers + 1; sendSignal(numberToRef(PGMAN, instance, getOwnNodeId()), GSN_END_LCP_REQ, signal, EndLcpReq::SignalLength, JBB); }
void DblqhProxy::sendSTART_RECCONF(Signal* signal, Uint32 ssId) { Ss_START_RECREQ& ss = ssFind<Ss_START_RECREQ>(ssId); if (!lastReply(ss)) return; if (ss.m_error == 0) { jam(); /** * There should be no disk-ops in flight here...check it */ signal->theData[0] = 12003; sendSignal(LGMAN_REF, GSN_DUMP_STATE_ORD, signal, 1, JBB); StartRecConf* conf = (StartRecConf*)signal->getDataPtrSend(); conf->startingNodeId = getOwnNodeId(); conf->senderData = ss.m_req.senderData; sendSignal(ss.m_req.senderRef, GSN_START_RECCONF, signal, StartRecConf::SignalLength, JBB); } else { ndbrequire(false); } { Uint32 i; for (i = 0; i < ss.m_req2cnt; i++) { jam(); Uint32 ssId2 = ss.m_req2[i].m_ssId; ssRelease<Ss_START_RECREQ_2>(ssId2); } } ssRelease<Ss_START_RECREQ>(ssId); }
Cmvmi::Cmvmi(Block_context& ctx) : SimulatedBlock(CMVMI, ctx) ,subscribers(subscriberPool) { BLOCK_CONSTRUCTOR(Cmvmi); Uint32 long_sig_buffer_size; const ndb_mgm_configuration_iterator * p = m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); ndb_mgm_get_int_parameter(p, CFG_DB_LONG_SIGNAL_BUFFER, &long_sig_buffer_size); long_sig_buffer_size= long_sig_buffer_size / 256; g_sectionSegmentPool.setSize(long_sig_buffer_size, false,true,true,CFG_DB_LONG_SIGNAL_BUFFER); // Add received signals addRecSignal(GSN_CONNECT_REP, &Cmvmi::execCONNECT_REP); addRecSignal(GSN_DISCONNECT_REP, &Cmvmi::execDISCONNECT_REP); addRecSignal(GSN_NDB_TAMPER, &Cmvmi::execNDB_TAMPER, true); addRecSignal(GSN_SET_LOGLEVELORD, &Cmvmi::execSET_LOGLEVELORD); addRecSignal(GSN_EVENT_REP, &Cmvmi::execEVENT_REP); addRecSignal(GSN_STTOR, &Cmvmi::execSTTOR); addRecSignal(GSN_READ_CONFIG_REQ, &Cmvmi::execREAD_CONFIG_REQ); addRecSignal(GSN_CLOSE_COMREQ, &Cmvmi::execCLOSE_COMREQ); addRecSignal(GSN_ENABLE_COMORD, &Cmvmi::execENABLE_COMORD); addRecSignal(GSN_OPEN_COMREQ, &Cmvmi::execOPEN_COMREQ); addRecSignal(GSN_TEST_ORD, &Cmvmi::execTEST_ORD); addRecSignal(GSN_TAMPER_ORD, &Cmvmi::execTAMPER_ORD); addRecSignal(GSN_STOP_ORD, &Cmvmi::execSTOP_ORD); addRecSignal(GSN_START_ORD, &Cmvmi::execSTART_ORD); addRecSignal(GSN_EVENT_SUBSCRIBE_REQ, &Cmvmi::execEVENT_SUBSCRIBE_REQ); addRecSignal(GSN_DUMP_STATE_ORD, &Cmvmi::execDUMP_STATE_ORD); addRecSignal(GSN_TESTSIG, &Cmvmi::execTESTSIG); addRecSignal(GSN_NODE_START_REP, &Cmvmi::execNODE_START_REP, true); subscriberPool.setSize(5); const ndb_mgm_configuration_iterator * db = m_ctx.m_config.getOwnConfigIterator(); for(unsigned j = 0; j<LogLevel::LOGLEVEL_CATEGORIES; j++){ Uint32 logLevel; if(!ndb_mgm_get_int_parameter(db, CFG_MIN_LOGLEVEL+j, &logLevel)){ clogLevel.setLogLevel((LogLevel::EventCategory)j, logLevel); } } ndb_mgm_configuration_iterator * iter = m_ctx.m_config.getClusterConfigIterator(); for(ndb_mgm_first(iter); ndb_mgm_valid(iter); ndb_mgm_next(iter)){ jam(); Uint32 nodeId; Uint32 nodeType; ndbrequire(!ndb_mgm_get_int_parameter(iter,CFG_NODE_ID, &nodeId)); ndbrequire(!ndb_mgm_get_int_parameter(iter,CFG_TYPE_OF_SECTION,&nodeType)); switch(nodeType){ case NodeInfo::DB: c_dbNodes.set(nodeId); break; case NodeInfo::API: case NodeInfo::MGM: break; default: ndbrequire(false); } setNodeInfo(nodeId).m_type = nodeType; } setNodeInfo(getOwnNodeId()).m_connected = true; setNodeInfo(getOwnNodeId()).m_version = ndbGetOwnVersion(); }
Backup::Backup(Block_context& ctx, Uint32 instanceNumber) : SimulatedBlock(BACKUP, ctx, instanceNumber), c_nodes(c_nodePool), c_backups(c_backupPool) { BLOCK_CONSTRUCTOR(Backup); c_masterNodeId = getOwnNodeId(); // Add received signals addRecSignal(GSN_READ_CONFIG_REQ, &Backup::execREAD_CONFIG_REQ); addRecSignal(GSN_STTOR, &Backup::execSTTOR); addRecSignal(GSN_DUMP_STATE_ORD, &Backup::execDUMP_STATE_ORD); addRecSignal(GSN_READ_NODESCONF, &Backup::execREAD_NODESCONF); addRecSignal(GSN_NODE_FAILREP, &Backup::execNODE_FAILREP); addRecSignal(GSN_INCL_NODEREQ, &Backup::execINCL_NODEREQ); addRecSignal(GSN_CONTINUEB, &Backup::execCONTINUEB); addRecSignal(GSN_READ_CONFIG_REQ, &Backup::execREAD_CONFIG_REQ, true); addRecSignal(GSN_SCAN_HBREP, &Backup::execSCAN_HBREP); addRecSignal(GSN_TRANSID_AI, &Backup::execTRANSID_AI); addRecSignal(GSN_SCAN_FRAGREF, &Backup::execSCAN_FRAGREF); addRecSignal(GSN_SCAN_FRAGCONF, &Backup::execSCAN_FRAGCONF); addRecSignal(GSN_BACKUP_TRIG_REQ, &Backup::execBACKUP_TRIG_REQ); addRecSignal(GSN_TRIG_ATTRINFO, &Backup::execTRIG_ATTRINFO); addRecSignal(GSN_FIRE_TRIG_ORD, &Backup::execFIRE_TRIG_ORD); addRecSignal(GSN_LIST_TABLES_CONF, &Backup::execLIST_TABLES_CONF); addRecSignal(GSN_GET_TABINFOREF, &Backup::execGET_TABINFOREF); addRecSignal(GSN_GET_TABINFO_CONF, &Backup::execGET_TABINFO_CONF); addRecSignal(GSN_CREATE_TRIG_IMPL_REF, &Backup::execCREATE_TRIG_IMPL_REF); addRecSignal(GSN_CREATE_TRIG_IMPL_CONF, &Backup::execCREATE_TRIG_IMPL_CONF); addRecSignal(GSN_DROP_TRIG_IMPL_REF, &Backup::execDROP_TRIG_IMPL_REF); addRecSignal(GSN_DROP_TRIG_IMPL_CONF, &Backup::execDROP_TRIG_IMPL_CONF); addRecSignal(GSN_DIH_SCAN_TAB_CONF, &Backup::execDIH_SCAN_TAB_CONF); addRecSignal(GSN_DIH_SCAN_GET_NODES_CONF, &Backup::execDIH_SCAN_GET_NODES_CONF); addRecSignal(GSN_FSOPENREF, &Backup::execFSOPENREF, true); addRecSignal(GSN_FSOPENCONF, &Backup::execFSOPENCONF); addRecSignal(GSN_FSCLOSEREF, &Backup::execFSCLOSEREF, true); addRecSignal(GSN_FSCLOSECONF, &Backup::execFSCLOSECONF); addRecSignal(GSN_FSAPPENDREF, &Backup::execFSAPPENDREF, true); addRecSignal(GSN_FSAPPENDCONF, &Backup::execFSAPPENDCONF); addRecSignal(GSN_FSREMOVEREF, &Backup::execFSREMOVEREF, true); addRecSignal(GSN_FSREMOVECONF, &Backup::execFSREMOVECONF); /*****/ addRecSignal(GSN_BACKUP_REQ, &Backup::execBACKUP_REQ); addRecSignal(GSN_ABORT_BACKUP_ORD, &Backup::execABORT_BACKUP_ORD); addRecSignal(GSN_DEFINE_BACKUP_REQ, &Backup::execDEFINE_BACKUP_REQ); addRecSignal(GSN_DEFINE_BACKUP_REF, &Backup::execDEFINE_BACKUP_REF); addRecSignal(GSN_DEFINE_BACKUP_CONF, &Backup::execDEFINE_BACKUP_CONF); addRecSignal(GSN_START_BACKUP_REQ, &Backup::execSTART_BACKUP_REQ); addRecSignal(GSN_START_BACKUP_REF, &Backup::execSTART_BACKUP_REF); addRecSignal(GSN_START_BACKUP_CONF, &Backup::execSTART_BACKUP_CONF); addRecSignal(GSN_BACKUP_FRAGMENT_REQ, &Backup::execBACKUP_FRAGMENT_REQ); addRecSignal(GSN_BACKUP_FRAGMENT_REF, &Backup::execBACKUP_FRAGMENT_REF); addRecSignal(GSN_BACKUP_FRAGMENT_CONF, &Backup::execBACKUP_FRAGMENT_CONF); addRecSignal(GSN_BACKUP_FRAGMENT_COMPLETE_REP, &Backup::execBACKUP_FRAGMENT_COMPLETE_REP); addRecSignal(GSN_STOP_BACKUP_REQ, &Backup::execSTOP_BACKUP_REQ); addRecSignal(GSN_STOP_BACKUP_REF, &Backup::execSTOP_BACKUP_REF); addRecSignal(GSN_STOP_BACKUP_CONF, &Backup::execSTOP_BACKUP_CONF); //addRecSignal(GSN_BACKUP_STATUS_REQ, &Backup::execBACKUP_STATUS_REQ); //addRecSignal(GSN_BACKUP_STATUS_CONF, &Backup::execBACKUP_STATUS_CONF); addRecSignal(GSN_UTIL_SEQUENCE_REF, &Backup::execUTIL_SEQUENCE_REF); addRecSignal(GSN_UTIL_SEQUENCE_CONF, &Backup::execUTIL_SEQUENCE_CONF); addRecSignal(GSN_WAIT_GCP_REF, &Backup::execWAIT_GCP_REF); addRecSignal(GSN_WAIT_GCP_CONF, &Backup::execWAIT_GCP_CONF); addRecSignal(GSN_BACKUP_LOCK_TAB_CONF, &Backup::execBACKUP_LOCK_TAB_CONF); addRecSignal(GSN_BACKUP_LOCK_TAB_REF, &Backup::execBACKUP_LOCK_TAB_REF); addRecSignal(GSN_LCP_STATUS_REQ, &Backup::execLCP_STATUS_REQ); /** * Testing */ addRecSignal(GSN_BACKUP_REF, &Backup::execBACKUP_REF); addRecSignal(GSN_BACKUP_CONF, &Backup::execBACKUP_CONF); addRecSignal(GSN_BACKUP_ABORT_REP, &Backup::execBACKUP_ABORT_REP); addRecSignal(GSN_BACKUP_COMPLETE_REP, &Backup::execBACKUP_COMPLETE_REP); addRecSignal(GSN_LCP_PREPARE_REQ, &Backup::execLCP_PREPARE_REQ); addRecSignal(GSN_END_LCPREQ, &Backup::execEND_LCPREQ); addRecSignal(GSN_DBINFO_SCANREQ, &Backup::execDBINFO_SCANREQ); }
void ClusterMgr::threadMain() { startup(); NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId())); signal.theVerId_signalNumber = GSN_API_REGREQ; signal.theTrace = 0; signal.theLength = ApiRegReq::SignalLength; ApiRegReq * req = CAST_PTR(ApiRegReq, signal.getDataPtrSend()); req->ref = numberToRef(API_CLUSTERMGR, theFacade.ownId()); req->version = NDB_VERSION; req->mysql_version = NDB_MYSQL_VERSION_D; NdbApiSignal nodeFail_signal(numberToRef(API_CLUSTERMGR, getOwnNodeId())); nodeFail_signal.theVerId_signalNumber = GSN_NODE_FAILREP; nodeFail_signal.theReceiversBlockNumber = API_CLUSTERMGR; nodeFail_signal.theTrace = 0; nodeFail_signal.theLength = NodeFailRep::SignalLengthLong; NDB_TICKS timeSlept = 100; NDB_TICKS now = NdbTick_CurrentMillisecond(); while(!theStop) { /* Sleep at 100ms between each heartbeat check */ NDB_TICKS before = now; for (Uint32 i = 0; i<5; i++) { NdbSleep_MilliSleep(20); { Guard g(clusterMgrThreadMutex); /** * Protect from ArbitMgr sending signals while we poll */ start_poll(); do_poll(0); complete_poll(); } } now = NdbTick_CurrentMillisecond(); timeSlept = (now - before); if (m_cluster_state == CS_waiting_for_clean_cache && theFacade.m_globalDictCache) { if (!global_flag_skip_waiting_for_clean_cache) { theFacade.m_globalDictCache->lock(); unsigned sz= theFacade.m_globalDictCache->get_size(); theFacade.m_globalDictCache->unlock(); if (sz) continue; } m_cluster_state = CS_waiting_for_first_connect; } NodeFailRep * nodeFailRep = CAST_PTR(NodeFailRep, nodeFail_signal.getDataPtrSend()); nodeFailRep->noOfNodes = 0; NodeBitmask::clear(nodeFailRep->theAllNodes); lock(); for (int i = 1; i < MAX_NODES; i++){ /** * Send register request (heartbeat) to all available nodes * at specified timing intervals */ const NodeId nodeId = i; // Check array bounds + don't allow node 0 to be touched assert(nodeId > 0 && nodeId < MAX_NODES); Node & cm_node = theNodes[nodeId]; trp_node & theNode = cm_node; if (!theNode.defined) continue; if (theNode.is_connected() == false){ theFacade.doConnect(nodeId); continue; } if (!theNode.compatible){ continue; } if (nodeId == getOwnNodeId() && theNode.is_confirmed()) { /** * Don't send HB to self more than once * (once needed to avoid weird special cases in e.g ConfigManager) */ continue; } cm_node.hbCounter += (Uint32)timeSlept; if (cm_node.hbCounter >= m_max_api_reg_req_interval || cm_node.hbCounter >= cm_node.hbFrequency) { /** * It is now time to send a new Heartbeat */ if (cm_node.hbCounter >= cm_node.hbFrequency) { cm_node.hbMissed++; cm_node.hbCounter = 0; } if (theNode.m_info.m_type != NodeInfo::DB) signal.theReceiversBlockNumber = API_CLUSTERMGR; else signal.theReceiversBlockNumber = QMGR; #ifdef DEBUG_REG ndbout_c("ClusterMgr: Sending API_REGREQ to node %d", (int)nodeId); #endif raw_sendSignal(&signal, nodeId); }//if if (cm_node.hbMissed == 4 && cm_node.hbFrequency > 0) { nodeFailRep->noOfNodes++; NodeBitmask::set(nodeFailRep->theAllNodes, nodeId); } } flush_send_buffers(); unlock(); if (nodeFailRep->noOfNodes) { lock(); raw_sendSignal(&nodeFail_signal, getOwnNodeId()); flush_send_buffers(); unlock(); } } }
void DblqhProxy::execLCP_FRAG_ORD(Signal* signal) { ndbrequire(signal->getLength() == LcpFragOrd::SignalLength); const LcpFragOrd* req = (const LcpFragOrd*)signal->getDataPtr(); const LcpFragOrd req_copy = *req; bool lcp_complete_ord = req->lastFragmentFlag; if (c_lcpRecord.m_state == LcpRecord::L_IDLE) { jam(); D("LCP: start" << V(req->lcpId)); c_lcpRecord.m_state = LcpRecord::L_STARTING; c_lcpRecord.m_lcpId = req->lcpId; c_lcpRecord.m_lcp_frag_rep_cnt = 0; c_lcpRecord.m_lcp_frag_ord_cnt = 0; c_lcpRecord.m_complete_outstanding = 0; c_lcpRecord.m_lastFragmentFlag = false; c_lcpRecord.m_empty_lcp_req.clear(); // handle start of LCP in PGMAN and TSMAN LcpFragOrd* req = (LcpFragOrd*)signal->getDataPtrSend(); *req = req_copy; EXECUTE_DIRECT(PGMAN, GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength); *req = req_copy; EXECUTE_DIRECT(TSMAN, GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength); c_lcpRecord.m_state = LcpRecord::L_RUNNING; } jam(); D("LCP: continue" << V(req->lcpId) << V(c_lcpRecord.m_lcp_frag_ord_cnt)); ndbrequire(c_lcpRecord.m_state == LcpRecord::L_RUNNING); ndbrequire(c_lcpRecord.m_lcpId == req->lcpId); if (lcp_complete_ord) { jam(); c_lcpRecord.m_lastFragmentFlag = true; if (getNoOfOutstanding(c_lcpRecord) == 0) { jam(); completeLCP_1(signal); return; } /** * Wait for all LCP_FRAG_ORD/REP to complete */ return; } else { jam(); c_lcpRecord.m_last_lcp_frag_ord = req_copy; } c_lcpRecord.m_lcp_frag_ord_cnt++; // Forward ndbrequire(req->tableId < c_tableRecSize); if (c_tableRec[req->tableId] == 0) { jam(); /** * Send to lqh-0...that will handle it... */ sendSignal(workerRef(0), GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB); } else { jam(); Uint32 instance = getInstanceKey(req->tableId, req->fragmentId); sendSignal(numberToRef(DBLQH, instance, getOwnNodeId()), GSN_LCP_FRAG_ORD, signal, LcpFragOrd::SignalLength, JBB); } }
void ClusterMgr::execAPI_REGREQ(const Uint32 * theData) { const ApiRegReq * const apiRegReq = (ApiRegReq *)&theData[0]; const NodeId nodeId = refToNode(apiRegReq->ref); #ifdef DEBUG_REG ndbout_c("ClusterMgr: Recd API_REGREQ from node %d", nodeId); #endif assert(nodeId > 0 && nodeId < MAX_NODES); Node & cm_node = theNodes[nodeId]; trp_node & node = cm_node; assert(node.defined == true); assert(node.is_connected() == true); /* API nodes send API_REGREQ once to themselves. Other than that, there are no API-API heart beats. */ assert(cm_node.m_info.m_type != NodeInfo::API || (nodeId == getOwnNodeId() && !cm_node.is_confirmed())); if(node.m_info.m_version != apiRegReq->version) { node.m_info.m_version = apiRegReq->version; node.m_info.m_mysql_version = apiRegReq->mysql_version; if (node.m_info.m_version < NDBD_SPLIT_VERSION) node.m_info.m_mysql_version = 0; if (getMajor(node.m_info.m_version) < getMajor(NDB_VERSION) || getMinor(node.m_info.m_version) < getMinor(NDB_VERSION)) { node.compatible = false; } else { node.compatible = true; } } NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId())); signal.theVerId_signalNumber = GSN_API_REGCONF; signal.theReceiversBlockNumber = API_CLUSTERMGR; signal.theTrace = 0; signal.theLength = ApiRegConf::SignalLength; ApiRegConf * const conf = CAST_PTR(ApiRegConf, signal.getDataPtrSend()); conf->qmgrRef = numberToRef(API_CLUSTERMGR, theFacade.ownId()); conf->version = NDB_VERSION; conf->mysql_version = NDB_MYSQL_VERSION_D; /* This is the frequency (in centiseonds) at which we want the other node to send API_REGREQ messages. */ conf->apiHeartbeatFrequency = m_hbFrequency/10; conf->minDbVersion= 0; conf->nodeState= node.m_state; node.set_confirmed(true); if (safe_sendSignal(&signal, nodeId) != 0) node.set_confirmed(false); }
void ClusterMgr::threadMain() { startup(); NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId())); signal.theVerId_signalNumber = GSN_API_REGREQ; signal.theTrace = 0; signal.theLength = ApiRegReq::SignalLength; ApiRegReq * req = CAST_PTR(ApiRegReq, signal.getDataPtrSend()); req->ref = numberToRef(API_CLUSTERMGR, theFacade.ownId()); req->version = NDB_VERSION; req->mysql_version = NDB_MYSQL_VERSION_D; NdbApiSignal nodeFail_signal(numberToRef(API_CLUSTERMGR, getOwnNodeId())); nodeFail_signal.theVerId_signalNumber = GSN_NODE_FAILREP; nodeFail_signal.theReceiversBlockNumber = API_CLUSTERMGR; nodeFail_signal.theTrace = 0; nodeFail_signal.theLength = NodeFailRep::SignalLengthLong; NDB_TICKS now = NdbTick_getCurrentTicks(); while(!theStop) { /* Sleep 1/5 of minHeartBeatInterval between each check */ const NDB_TICKS before = now; for (Uint32 i = 0; i<5; i++) { NdbSleep_MilliSleep(minHeartBeatInterval/5); { /** * start_poll does lock the trp_client and complete_poll * releases this lock. This means that this protects * against concurrent calls to send signals in ArbitMgr. * We do however need to protect also against concurrent * close in doStop, so to avoid this problem we need to * also lock clusterMgrThreadMutex before we start the * poll. */ Guard g(clusterMgrThreadMutex); start_poll(); do_poll(0); complete_poll(); } } now = NdbTick_getCurrentTicks(); const Uint32 timeSlept = (Uint32)NdbTick_Elapsed(before, now).milliSec(); lock(); if (m_cluster_state == CS_waiting_for_clean_cache && theFacade.m_globalDictCache) { if (!global_flag_skip_waiting_for_clean_cache) { theFacade.m_globalDictCache->lock(); unsigned sz= theFacade.m_globalDictCache->get_size(); theFacade.m_globalDictCache->unlock(); if (sz) { unlock(); continue; } } m_cluster_state = CS_waiting_for_first_connect; } NodeFailRep * nodeFailRep = CAST_PTR(NodeFailRep, nodeFail_signal.getDataPtrSend()); nodeFailRep->noOfNodes = 0; NodeBitmask::clear(nodeFailRep->theAllNodes); for (int i = 1; i < MAX_NODES; i++) { /** * Send register request (heartbeat) to all available nodes * at specified timing intervals */ const NodeId nodeId = i; // Check array bounds + don't allow node 0 to be touched assert(nodeId > 0 && nodeId < MAX_NODES); Node & cm_node = theNodes[nodeId]; trp_node & theNode = cm_node; if (!theNode.defined) continue; if (theNode.is_connected() == false) { theFacade.doConnect(nodeId); continue; } if (!theNode.compatible) { continue; } if (nodeId == getOwnNodeId()) { /** * Don't send HB to self more than once * (once needed to avoid weird special cases in e.g ConfigManager) */ if (m_sent_API_REGREQ_to_myself) { continue; } } cm_node.hbCounter += timeSlept; if (cm_node.hbCounter >= m_max_api_reg_req_interval || cm_node.hbCounter >= cm_node.hbFrequency) { /** * It is now time to send a new Heartbeat */ if (cm_node.hbCounter >= cm_node.hbFrequency) { cm_node.hbMissed++; cm_node.hbCounter = 0; } if (theNode.m_info.m_type != NodeInfo::DB) signal.theReceiversBlockNumber = API_CLUSTERMGR; else signal.theReceiversBlockNumber = QMGR; #ifdef DEBUG_REG ndbout_c("ClusterMgr: Sending API_REGREQ to node %d", (int)nodeId); #endif if (nodeId == getOwnNodeId()) { /* Set flag to ensure we only send once to ourself */ m_sent_API_REGREQ_to_myself = true; } raw_sendSignal(&signal, nodeId); }//if if (cm_node.hbMissed == 4 && cm_node.hbFrequency > 0) { nodeFailRep->noOfNodes++; NodeBitmask::set(nodeFailRep->theAllNodes, nodeId); } } flush_send_buffers(); unlock(); if (nodeFailRep->noOfNodes) { lock(); raw_sendSignal(&nodeFail_signal, getOwnNodeId()); flush_send_buffers(); unlock(); } } }
void ClusterMgr::execNODE_FAILREP(const NdbApiSignal* sig, const LinearSectionPtr ptr[]) { const NodeFailRep * rep = CAST_CONSTPTR(NodeFailRep, sig->getDataPtr()); NodeBitmask mask; if (sig->getLength() == NodeFailRep::SignalLengthLong) { mask.assign(NodeBitmask::Size, rep->theAllNodes); } else { mask.assign(NdbNodeBitmask::Size, rep->theNodes); } NdbApiSignal signal(sig->theSendersBlockRef); signal.theVerId_signalNumber = GSN_NODE_FAILREP; signal.theReceiversBlockNumber = API_CLUSTERMGR; signal.theTrace = 0; signal.theLength = NodeFailRep::SignalLengthLong; NodeFailRep * copy = CAST_PTR(NodeFailRep, signal.getDataPtrSend()); copy->failNo = 0; copy->masterNodeId = 0; copy->noOfNodes = 0; NodeBitmask::clear(copy->theAllNodes); for (Uint32 i = mask.find_first(); i != NodeBitmask::NotFound; i = mask.find_next(i + 1)) { Node & cm_node = theNodes[i]; trp_node & theNode = cm_node; bool node_failrep = theNode.m_node_fail_rep; bool connected = theNode.is_connected(); set_node_dead(theNode); if (node_failrep == false) { theNode.m_node_fail_rep = true; NodeBitmask::set(copy->theAllNodes, i); copy->noOfNodes++; } if (connected) { theFacade.doDisconnect(i); } } recalcMinDbVersion(); if (copy->noOfNodes) { theFacade.for_each(this, &signal, 0); // report GSN_NODE_FAILREP } if (noOfAliveNodes == 0) { NdbApiSignal signal(numberToRef(API_CLUSTERMGR, getOwnNodeId())); signal.theVerId_signalNumber = GSN_NF_COMPLETEREP; signal.theReceiversBlockNumber = 0; signal.theTrace = 0; signal.theLength = NFCompleteRep::SignalLength; NFCompleteRep * rep = CAST_PTR(NFCompleteRep, signal.getDataPtrSend()); rep->blockNo =0; rep->nodeId = getOwnNodeId(); rep->unused = 0; rep->from = __LINE__; for (Uint32 i = 1; i < MAX_NODES; i++) { trp_node& theNode = theNodes[i]; if (theNode.defined && theNode.nfCompleteRep == false) { rep->failedNodeId = i; execNF_COMPLETEREP(&signal, 0); } } } }
void Cmvmi::execOPEN_COMREQ(Signal* signal) { // Connect to the specifed NDB node, only QMGR allowed communication // so far with the node const BlockReference userRef = signal->theData[0]; Uint32 tStartingNode = signal->theData[1]; Uint32 tData2 = signal->theData[2]; jamEntry(); const Uint32 len = signal->getLength(); if(len == 2) { #ifdef ERROR_INSERT if (! ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002)) && c_error_9000_nodes_mask.get(tStartingNode))) #endif { if (globalData.theStartLevel != NodeState::SL_STARTED && (getNodeInfo(tStartingNode).m_type != NodeInfo::DB && getNodeInfo(tStartingNode).m_type != NodeInfo::MGM)) { jam(); goto done; } globalTransporterRegistry.do_connect(tStartingNode); globalTransporterRegistry.setIOState(tStartingNode, HaltIO); //----------------------------------------------------- // Report that the connection to the node is opened //----------------------------------------------------- signal->theData[0] = NDB_LE_CommunicationOpened; signal->theData[1] = tStartingNode; sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); //----------------------------------------------------- } } else { for(unsigned int i = 1; i < MAX_NODES; i++ ) { jam(); if (i != getOwnNodeId() && getNodeInfo(i).m_type == tData2) { jam(); #ifdef ERROR_INSERT if ((ERROR_INSERTED(9000) || ERROR_INSERTED(9002)) && c_error_9000_nodes_mask.get(i)) continue; #endif globalTransporterRegistry.do_connect(i); globalTransporterRegistry.setIOState(i, HaltIO); signal->theData[0] = NDB_LE_CommunicationOpened; signal->theData[1] = i; sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); } } } done: if (userRef != 0) { jam(); signal->theData[0] = tStartingNode; signal->theData[1] = tData2; sendSignal(userRef, GSN_OPEN_COMCONF, signal, len - 1,JBA); } }