| List: | Commits | « Previous MessageNext Message » | |
| From: | tomas | Date: | April 4 2006 11:48am |
| Subject: | bk commit into 5.1 tree (tomas:1.2283) | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.1 repository of tomas. When tomas does a push these changes will be propagated to the main repository and, within 24 hours after the push, to the public repository. For information on how to access the public repository see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html ChangeSet 1.2283 06/04/04 11:48:28 tomas@stripped +1 -0 Merge poseidon.ndb.mysql.com:/home/tomas/mysql-5.0 into poseidon.ndb.mysql.com:/home/tomas/mysql-5.1-new storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp 1.57 06/04/04 11:48:17 tomas@stripped +0 -0 Auto merged storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp 1.24.20.2 06/04/04 11:48:17 tomas@stripped +0 -0 Merge rename: ndb/src/kernel/blocks/dbdih/DbdihMain.cpp -> storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp # This is a BitKeeper patch. What follows are the unified diffs for the # set of deltas contained in the patch. The rest of the patch, the part # that BitKeeper cares about, is below these diffs. # User: tomas # Host: poseidon.ndb.mysql.com # Root: /home/tomas/mysql-5.1-new/RESYNC --- 1.24.20.1/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp 2006-04-04 11:34:25 +02:00 +++ 1.57/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp 2006-04-04 11:48:17 +02:00 @@ -67,6 +67,7 @@ #include <signaldata/CreateFragmentation.hpp> #include <signaldata/LqhFrag.hpp> #include <signaldata/FsOpenReq.hpp> +#include <signaldata/DihFragCount.hpp> #include <DebuggerNames.hpp> #include <EventLogger.hpp> @@ -609,6 +610,14 @@ checkWaitDropTabFailedLqh(signal, nodeId, tableId); return; } + case DihContinueB::ZTO_START_FRAGMENTS: + { + TakeOverRecordPtr takeOverPtr; + takeOverPtr.i = signal->theData[1]; + ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + nr_start_fragments(signal, takeOverPtr); + return; + } }//switch ndbrequire(false); @@ -639,9 +648,11 @@ c_copyGCISlave.m_expectedNextWord += CopyGCIReq::DATA_SIZE; return; }//if - + + Uint32 tmp= SYSFILE->m_restart_seq; memcpy(sysfileData, cdata, sizeof(sysfileData)); - + SYSFILE->m_restart_seq = tmp; + c_copyGCISlave.m_copyReason = reason; c_copyGCISlave.m_senderRef = signal->senderBlockRef(); c_copyGCISlave.m_senderData = copyGCI->anyData; @@ -1052,7 +1063,7 @@ jamEntry(); const ndb_mgm_configuration_iterator * p = - theConfiguration.getOwnConfigIterator(); + m_ctx.m_config.getOwnConfigIterator(); ndbrequireErr(p != 0, NDBD_EXIT_INVALID_CONFIG); initData(); @@ -1138,7 +1149,7 @@ { jamEntry(); cntrlblockref = signal->theData[0]; - if(theConfiguration.getInitialStart()){ + if(m_ctx.m_config.getInitialStart()){ sendSignal(cntrlblockref, GSN_DIH_RESTARTREF, signal, 1, JBB); } else { readGciFileLab(signal); @@ -1428,6 +1439,33 @@ return; } + NodeRecordPtr nodePtr; + Uint32 gci = SYSFILE->lastCompletedGCI[getOwnNodeId()]; + for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) + { + jam(); + ptrAss(nodePtr, nodeRecord); + if (SYSFILE->lastCompletedGCI[nodePtr.i] > gci) + { + jam(); + /** + * Since we're starting(is master) and there + * there are other nodes with higher GCI... + * there gci's must be invalidated... + * and they _must_ do an initial start + * indicate this by setting lastCompletedGCI = 0 + */ + SYSFILE->lastCompletedGCI[nodePtr.i] = 0; + ndbrequire(nodePtr.p->nodeStatus != NodeRecord::ALIVE); + warningEvent("Making filesystem for node %d unusable", + nodePtr.i); + } + } + /** + * This set which GCI we will try to restart to + */ + SYSFILE->newestRestorableGCI = gci; + ndbrequire(isMaster()); copyGciLab(signal, CopyGCIReq::RESTART); // We have already read the file! }//Dbdih::ndbStartReqLab() @@ -1563,7 +1601,7 @@ { jamEntry(); Uint32 errorCode = signal->theData[1]; - if (errorCode == ZNODE_ALREADY_STARTING_ERROR) { + if (errorCode == StartPermRef::ZNODE_ALREADY_STARTING_ERROR) { jam(); /*-----------------------------------------------------------------------*/ // The master was busy adding another node. We will wait for a second and @@ -1573,6 +1611,20 @@ sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 3000, 1); return; }//if + + if (errorCode == StartPermRef::InitialStartRequired) + { + CRASH_INSERTION(7170); + char buf[255]; + BaseString::snprintf(buf, sizeof(buf), + "Cluster requires this node to be started " + " with --initial as partial start has been performed" + " and this filesystem is unusable"); + progError(__LINE__, + NDBD_EXIT_SR_RESTARTCONFLICT, + buf); + ndbrequire(false); + } /*------------------------------------------------------------------------*/ // Some node process in another node involving our node was still active. We // will recover from this by crashing here. @@ -1615,12 +1667,15 @@ * * But dont copy lastCompletedGCI:s */ + Uint32 key = SYSFILE->m_restart_seq; Uint32 tempGCP[MAX_NDB_NODES]; for(i = 0; i < MAX_NDB_NODES; i++) tempGCP[i] = SYSFILE->lastCompletedGCI[i]; for(i = 0; i < Sysfile::SYSFILE_SIZE32; i++) sysfileData[i] = cdata[i]; + + SYSFILE->m_restart_seq = key; for(i = 0; i < MAX_NDB_NODES; i++) SYSFILE->lastCompletedGCI[i] = tempGCP[i]; @@ -1663,7 +1718,7 @@ (c_nodeStartMaster.wait != ZFALSE)) { jam(); signal->theData[0] = nodeId; - signal->theData[1] = ZNODE_ALREADY_STARTING_ERROR; + signal->theData[1] = StartPermRef::ZNODE_ALREADY_STARTING_ERROR; sendSignal(retRef, GSN_START_PERMREF, signal, 2, JBB); return; }//if @@ -1673,6 +1728,16 @@ ndbrequire(false); }//if + if (SYSFILE->lastCompletedGCI[nodeId] == 0 && + typeStart != NodeState::ST_INITIAL_NODE_RESTART) + { + jam(); + signal->theData[0] = nodeId; + signal->theData[1] = StartPermRef::InitialStartRequired; + sendSignal(retRef, GSN_START_PERMREF, signal, 2, JBB); + return; + } + /*---------------------------------------------------------------------- * WE START THE INCLUSION PROCEDURE * ---------------------------------------------------------------------*/ @@ -1768,11 +1833,6 @@ ndbrequire(c_nodeStartMaster.startNode == Tnodeid); ndbrequire(getNodeStatus(Tnodeid) == NodeRecord::STARTING); - sendSTART_RECREQ(signal, Tnodeid); -}//Dbdih::execSTART_MEREQ() - -void Dbdih::nodeRestartStartRecConfLab(Signal* signal) -{ c_nodeStartMaster.blockLcp = true; if ((c_lcpState.lcpStatus != LCP_STATUS_IDLE) && (c_lcpState.lcpStatus != LCP_TCGET)) { @@ -2583,13 +2643,14 @@ return; }//if c_startToLock = takeOverPtrI; + + takeOverPtr.p->toMasterStatus = TakeOverRecord::STARTING; StartToReq * const req = (StartToReq *)&signal->theData[0]; req->userPtr = takeOverPtr.i; req->userRef = reference(); req->startingNodeId = takeOverPtr.p->toStartingNode; req->nodeTakenOver = takeOverPtr.p->toFailedNode; req->nodeRestart = takeOverPtr.p->toNodeRestart; - takeOverPtr.p->toMasterStatus = TakeOverRecord::STARTING; sendLoopMacro(START_TOREQ, sendSTART_TOREQ); }//Dbdih::sendStartTo() @@ -2633,9 +2694,153 @@ CRASH_INSERTION(7134); c_startToLock = RNIL; + if (takeOverPtr.p->toNodeRestart) + { + jam(); + takeOverPtr.p->toMasterStatus = TakeOverRecord::STARTING_LOCAL_FRAGMENTS; + nr_start_fragments(signal, takeOverPtr); + return; + } + startNextCopyFragment(signal, takeOverPtr.i); }//Dbdih::execSTART_TOCONF() +void +Dbdih::nr_start_fragments(Signal* signal, + TakeOverRecordPtr takeOverPtr) +{ + Uint32 loopCount = 0 ; + TabRecordPtr tabPtr; + while (loopCount++ < 100) { + tabPtr.i = takeOverPtr.p->toCurrentTabref; + if (tabPtr.i >= ctabFileSize) { + jam(); + nr_run_redo(signal, takeOverPtr); + return; + }//if + ptrAss(tabPtr, tabRecord); + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE){ + jam(); + takeOverPtr.p->toCurrentFragid = 0; + takeOverPtr.p->toCurrentTabref++; + continue; + }//if + Uint32 fragId = takeOverPtr.p->toCurrentFragid; + if (fragId >= tabPtr.p->totalfragments) { + jam(); + takeOverPtr.p->toCurrentFragid = 0; + takeOverPtr.p->toCurrentTabref++; + continue; + }//if + FragmentstorePtr fragPtr; + getFragstore(tabPtr.p, fragId, fragPtr); + ReplicaRecordPtr loopReplicaPtr; + loopReplicaPtr.i = fragPtr.p->oldStoredReplicas; + while (loopReplicaPtr.i != RNIL) { + ptrCheckGuard(loopReplicaPtr, creplicaFileSize, replicaRecord); + if (loopReplicaPtr.p->procNode == takeOverPtr.p->toStartingNode) { + jam(); + nr_start_fragment(signal, takeOverPtr, loopReplicaPtr); + break; + } else { + jam(); + loopReplicaPtr.i = loopReplicaPtr.p->nextReplica; + }//if + }//while + takeOverPtr.p->toCurrentFragid++; + }//while + signal->theData[0] = DihContinueB::ZTO_START_FRAGMENTS; + signal->theData[1] = takeOverPtr.i; + sendSignal(reference(), GSN_CONTINUEB, signal, 2, JBB); +} + +void +Dbdih::nr_start_fragment(Signal* signal, + TakeOverRecordPtr takeOverPtr, + ReplicaRecordPtr replicaPtr) +{ + Uint32 i, j = 0; + Uint32 maxLcpId = 0; + Uint32 maxLcpIndex = ~0; + + Uint32 restorableGCI = 0; + + ndbout_c("tab: %d frag: %d replicaP->nextLcp: %d", + takeOverPtr.p->toCurrentTabref, + takeOverPtr.p->toCurrentFragid, + replicaPtr.p->nextLcp); + + Uint32 idx = replicaPtr.p->nextLcp; + for(i = 0; i<MAX_LCP_STORED; i++, idx = nextLcpNo(idx)) + { + ndbout_c("scanning idx: %d lcpId: %d", idx, replicaPtr.p->lcpId[idx]); + if (replicaPtr.p->lcpStatus[idx] == ZVALID) + { + ndbrequire(replicaPtr.p->lcpId[idx] > maxLcpId); + Uint32 startGci = replicaPtr.p->maxGciCompleted[idx]; + Uint32 stopGci = replicaPtr.p->maxGciStarted[idx]; + for (;j < replicaPtr.p->noCrashedReplicas; j++) + { + ndbout_c("crashed replica: %d(%d) replicaLastGci: %d", + j, + replicaPtr.p->noCrashedReplicas, + replicaPtr.p->replicaLastGci[j]); + if (replicaPtr.p->replicaLastGci[j] > stopGci) + { + maxLcpId = replicaPtr.p->lcpId[idx]; + maxLcpIndex = idx; + restorableGCI = replicaPtr.p->replicaLastGci[j]; + break; + } + } + } + } + + if (maxLcpIndex == ~0) + { + ndbout_c("Didnt find any LCP for node: %d tab: %d frag: %d", + takeOverPtr.p->toStartingNode, + takeOverPtr.p->toCurrentTabref, + takeOverPtr.p->toCurrentFragid); + replicaPtr.p->lcpIdStarted = 0; + } + else + { + ndbout_c("Found LCP: %d(%d) maxGciStarted: %d maxGciCompleted: %d restorable: %d(%d) newestRestorableGCI: %d", + maxLcpId, + maxLcpIndex, + replicaPtr.p->maxGciStarted[maxLcpIndex], + replicaPtr.p->maxGciCompleted[maxLcpIndex], + restorableGCI, + SYSFILE->lastCompletedGCI[takeOverPtr.p->toStartingNode], + SYSFILE->newestRestorableGCI); + + replicaPtr.p->lcpIdStarted = restorableGCI; + BlockReference ref = calcLqhBlockRef(takeOverPtr.p->toStartingNode); + StartFragReq *req = (StartFragReq *)signal->getDataPtrSend(); + req->userPtr = 0; + req->userRef = reference(); + req->lcpNo = maxLcpIndex; + req->lcpId = maxLcpId; + req->tableId = takeOverPtr.p->toCurrentTabref; + req->fragId = takeOverPtr.p->toCurrentFragid; + req->noOfLogNodes = 1; + req->lqhLogNode[0] = takeOverPtr.p->toStartingNode; + req->startGci[0] = replicaPtr.p->maxGciCompleted[maxLcpIndex]; + req->lastGci[0] = restorableGCI; + sendSignal(ref, GSN_START_FRAGREQ, signal, + StartFragReq::SignalLength, JBB); + } +} + +void +Dbdih::nr_run_redo(Signal* signal, TakeOverRecordPtr takeOverPtr) +{ + takeOverPtr.p->toCurrentTabref = 0; + takeOverPtr.p->toCurrentFragid = 0; + sendSTART_RECREQ(signal, takeOverPtr.p->toStartingNode); +} + void Dbdih::initStartTakeOver(const StartToReq * req, TakeOverRecordPtr takeOverPtr) { @@ -2968,6 +3173,14 @@ /*---------------------------------------------------------------------- */ FragmentstorePtr fragPtr; getFragstore(tabPtr.p, fragId, fragPtr); + Uint32 gci = 0; + if (takeOverPtr.p->toNodeRestart) + { + ReplicaRecordPtr replicaPtr; + findReplica(replicaPtr, fragPtr.p, takeOverPtr.p->toStartingNode, true); + gci = replicaPtr.p->lcpIdStarted; + replicaPtr.p->lcpIdStarted = 0; + } takeOverPtr.p->toMasterStatus = TakeOverRecord::COPY_FRAG; BlockReference ref = calcLqhBlockRef(takeOverPtr.p->toCopyNode); CopyFragReq * const copyFragReq = (CopyFragReq *)&signal->theData[0]; @@ -2978,6 +3191,7 @@ copyFragReq->nodeId = takeOverPtr.p->toStartingNode; copyFragReq->schemaVersion = tabPtr.p->schemaVersion; copyFragReq->distributionKey = fragPtr.p->distributionKey; + copyFragReq->gci = gci; sendSignal(ref, GSN_COPY_FRAGREQ, signal, CopyFragReq::SignalLength, JBB); } else { ndbrequire(takeOverPtr.p->toMasterStatus == TakeOverRecord::COMMIT_CREATE); @@ -3499,6 +3713,7 @@ /* WE ALSO COPY TO OUR OWN NODE. TO ENABLE US TO DO THIS PROPERLY WE */ /* START BY CLOSING THIS FILE. */ /* ----------------------------------------------------------------------- */ + globalData.m_restart_seq = ++SYSFILE->m_restart_seq; closeFile(signal, filePtr); filePtr.p->reqStatus = FileRecord::CLOSING_GCP; }//Dbdih::readingGcpLab() @@ -3521,24 +3736,12 @@ /* ------------------------------------------------------------------------- */ void Dbdih::selectMasterCandidateAndSend(Signal* signal) { - Uint32 gci = 0; - Uint32 masterCandidateId = 0; - NodeRecordPtr nodePtr; - for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { - jam(); - ptrAss(nodePtr, nodeRecord); - if (SYSFILE->lastCompletedGCI[nodePtr.i] > gci) { - jam(); - masterCandidateId = nodePtr.i; - gci = SYSFILE->lastCompletedGCI[nodePtr.i]; - }//if - }//for - ndbrequire(masterCandidateId != 0); setNodeGroups(); - signal->theData[0] = masterCandidateId; - signal->theData[1] = gci; + signal->theData[0] = getOwnNodeId(); + signal->theData[1] = SYSFILE->lastCompletedGCI[getOwnNodeId()]; sendSignal(cntrlblockref, GSN_DIH_RESTARTCONF, signal, 2, JBB); - + + NodeRecordPtr nodePtr; Uint32 node_groups[MAX_NDB_NODES]; memset(node_groups, 0, sizeof(node_groups)); for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) { @@ -3556,10 +3759,10 @@ if(count != 0 && count != cnoReplicas){ char buf[255]; BaseString::snprintf(buf, sizeof(buf), - "Illegal configuration change." - " Initial start needs to be performed " - " when changing no of replicas (%d != %d)", - node_groups[nodePtr.i], cnoReplicas); + "Illegal configuration change." + " Initial start needs to be performed " + " when changing no of replicas (%d != %d)", + node_groups[nodePtr.i], cnoReplicas); progError(__LINE__, NDBD_EXIT_INVALID_CONFIG, buf); } } @@ -4029,6 +4232,8 @@ Uint32 takeOverPtrI) { jam(); + ndbout_c("checkTakeOverInMasterStartNodeFailure %x", + takeOverPtrI); if (takeOverPtrI == RNIL) { jam(); return; @@ -4042,6 +4247,9 @@ takeOverPtr.i = takeOverPtrI; ptrCheckGuard(takeOverPtr, MAX_NDB_NODES, takeOverRecord); + ndbout_c("takeOverPtr.p->toMasterStatus: %x", + takeOverPtr.p->toMasterStatus); + bool ok = false; switch (takeOverPtr.p->toMasterStatus) { case TakeOverRecord::IDLE: @@ -4150,6 +4358,13 @@ //----------------------------------------------------------------------- endTakeOver(takeOverPtr.i); break; + + case TakeOverRecord::STARTING_LOCAL_FRAGMENTS: + ok = true; + jam(); + endTakeOver(takeOverPtr.i); + break; + /** * The following are states that it should not be possible to "be" in */ @@ -5220,6 +5435,7 @@ //const Uint32 lcpId = SYSFILE->latestLCP_ID; const bool lcpOngoingFlag = (tabPtr.p->tabLcpStatus== TabRecord::TLS_ACTIVE); + const bool temporary = !tabPtr.p->storedTable; FragmentstorePtr fragPtr; for(Uint32 fragNo = 0; fragNo < tabPtr.p->totalfragments; fragNo++){ @@ -5240,7 +5456,7 @@ jam(); found = true; noOfRemovedReplicas++; - removeNodeFromStored(nodeId, fragPtr, replicaPtr); + removeNodeFromStored(nodeId, fragPtr, replicaPtr, temporary); if(replicaPtr.p->lcpOngoingFlag){ jam(); /** @@ -5561,11 +5777,9 @@ #endif } - bool ok = false; MasterLCPConf::State lcpState; switch (c_lcpState.lcpStatus) { case LCP_STATUS_IDLE: - ok = true; jam(); /*------------------------------------------------*/ /* LOCAL CHECKPOINT IS CURRENTLY NOT ACTIVE */ @@ -5576,7 +5790,6 @@ lcpState = MasterLCPConf::LCP_STATUS_IDLE; break; case LCP_STATUS_ACTIVE: - ok = true; jam(); /*--------------------------------------------------*/ /* COPY OF RESTART INFORMATION HAS BEEN */ @@ -5585,7 +5798,6 @@ lcpState = MasterLCPConf::LCP_STATUS_ACTIVE; break; case LCP_TAB_COMPLETED: - ok = true; jam(); /*--------------------------------------------------------*/ /* ALL LCP_REPORT'S HAVE BEEN COMPLETED FOR */ @@ -5595,7 +5807,6 @@ lcpState = MasterLCPConf::LCP_TAB_COMPLETED; break; case LCP_TAB_SAVED: - ok = true; jam(); /*--------------------------------------------------------*/ /* ALL LCP_REPORT'S HAVE BEEN COMPLETED FOR */ @@ -5619,15 +5830,15 @@ break; case LCP_COPY_GCI: case LCP_INIT_TABLES: - ok = true; /** * These two states are handled by if statements above */ ndbrequire(false); lcpState= MasterLCPConf::LCP_STATUS_IDLE; // remove warning break; + default: + ndbrequire(false); }//switch - ndbrequire(ok); Uint32 failedNodeId = c_lcpState.m_MASTER_LCPREQ_FailedNodeId; MasterLCPConf * const conf = (MasterLCPConf *)&signal->theData[0]; @@ -5950,9 +6161,6 @@ signal->theData[0] = 7012; execDUMP_STATE_ORD(signal); - signal->theData[0] = 7015; - execDUMP_STATE_ORD(signal); - c_lcpMasterTakeOverState.set(LMTOS_IDLE, __LINE__); checkLocalNodefailComplete(signal, failedNodePtr.i, NF_LCP_TAKE_OVER); @@ -6228,96 +6436,146 @@ 3.7.1 A D D T A B L E M A I N L Y *************************************** */ -void Dbdih::execCREATE_FRAGMENTATION_REQ(Signal * signal){ + +static inline void inc_node_or_group(Uint32 &node, Uint32 max_node) +{ + Uint32 next = node + 1; + node = (next == max_node ? 0 : next); +} + +/* + Spread fragments in backwards compatible mode +*/ +static void set_default_node_groups(Signal *signal, Uint32 noFrags) +{ + Uint16 *node_group_array = (Uint16*)&signal->theData[25]; + Uint32 i; + node_group_array[0] = 0; + for (i = 1; i < noFrags; i++) + node_group_array[i] = UNDEF_NODEGROUP; +} +void Dbdih::execCREATE_FRAGMENTATION_REQ(Signal * signal) +{ + Uint16 node_group_id[MAX_NDB_PARTITIONS]; jamEntry(); CreateFragmentationReq * const req = (CreateFragmentationReq*)signal->getDataPtr(); const Uint32 senderRef = req->senderRef; const Uint32 senderData = req->senderData; - const Uint32 fragmentNode = req->fragmentNode; - const Uint32 fragmentType = req->fragmentationType; - //const Uint32 fragmentCount = req->noOfFragments; + Uint32 noOfFragments = req->noOfFragments; + const Uint32 fragType = req->fragmentationType; const Uint32 primaryTableId = req->primaryTableId; Uint32 err = 0; do { - Uint32 noOfFragments = 0; - Uint32 noOfReplicas = cnoReplicas; - switch(fragmentType){ - case DictTabInfo::AllNodesSmallTable: - jam(); - noOfFragments = csystemnodes; - break; - case DictTabInfo::AllNodesMediumTable: - jam(); - noOfFragments = 2 * csystemnodes; - break; - case DictTabInfo::AllNodesLargeTable: - jam(); - noOfFragments = 4 * csystemnodes; - break; - case DictTabInfo::SingleFragment: - jam(); - noOfFragments = 1; - break; -#if 0 - case DictTabInfo::SpecifiedFragmentCount: - noOfFragments = (fragmentCount == 0 ? 1 : (fragmentCount + 1)/ 2); - break; -#endif - default: - jam(); - err = CreateFragmentationRef::InvalidFragmentationType; - break; - } - if(err) - break; - NodeGroupRecordPtr NGPtr; TabRecordPtr primTabPtr; + Uint32 count = 2; + Uint16 noOfReplicas = cnoReplicas; + Uint16 *fragments = (Uint16*)(signal->theData+25); if (primaryTableId == RNIL) { - if(fragmentNode == 0){ - jam(); - NGPtr.i = 0; - if(noOfFragments < csystemnodes) - { - NGPtr.i = c_nextNodeGroup; - c_nextNodeGroup = (NGPtr.i + 1 == cnoOfNodeGroups ? 0 : NGPtr.i + 1); - } - } else if(! (fragmentNode < MAX_NDB_NODES)) { - jam(); - err = CreateFragmentationRef::InvalidNodeId; - } else { - jam(); - const Uint32 stat = Sysfile::getNodeStatus(fragmentNode, - SYSFILE->nodeStatus); - switch (stat) { - case Sysfile::NS_Active: - case Sysfile::NS_ActiveMissed_1: - case Sysfile::NS_ActiveMissed_2: - case Sysfile::NS_TakeOver: + jam(); + switch ((DictTabInfo::FragmentType)fragType) + { + /* + Backward compatability and for all places in code not changed. + */ + case DictTabInfo::AllNodesSmallTable: + jam(); + noOfFragments = csystemnodes; + set_default_node_groups(signal, noOfFragments); + break; + case DictTabInfo::AllNodesMediumTable: + jam(); + noOfFragments = 2 * csystemnodes; + set_default_node_groups(signal, noOfFragments); + break; + case DictTabInfo::AllNodesLargeTable: jam(); + noOfFragments = 4 * csystemnodes; + set_default_node_groups(signal, noOfFragments); break; - case Sysfile::NS_NotActive_NotTakenOver: + case DictTabInfo::SingleFragment: jam(); + noOfFragments = 1; + set_default_node_groups(signal, noOfFragments); break; - case Sysfile::NS_HotSpare: + case DictTabInfo::DistrKeyHash: jam(); - case Sysfile::NS_NotDefined: + case DictTabInfo::DistrKeyLin: jam(); + if (noOfFragments == 0) + { + jam(); + noOfFragments = csystemnodes; + set_default_node_groups(signal, noOfFragments); + } + break; default: jam(); - err = CreateFragmentationRef::InvalidNodeType; + if (noOfFragments == 0) + { + jam(); + err = CreateFragmentationRef::InvalidFragmentationType; + } break; + } + if (err) + break; + /* + When we come here the the exact partition is specified + and there is an array of node groups sent along as well. + */ + memcpy(&node_group_id[0], &signal->theData[25], 2 * noOfFragments); + Uint16 next_replica_node[MAX_NDB_NODES]; + memset(next_replica_node,0,sizeof(next_replica_node)); + Uint32 default_node_group= c_nextNodeGroup; + for(Uint32 fragNo = 0; fragNo < noOfFragments; fragNo++) + { + jam(); + NGPtr.i = node_group_id[fragNo]; + if (NGPtr.i == UNDEF_NODEGROUP) + { + jam(); + NGPtr.i = default_node_group; } - if(err) + if (NGPtr.i > cnoOfNodeGroups) + { + jam(); + err = CreateFragmentationRef::InvalidNodeGroup; break; - NGPtr.i = Sysfile::getNodeGroup(fragmentNode, - SYSFILE->nodeGroups); + } + ptrCheckGuard(NGPtr, MAX_NDB_NODES, nodeGroupRecord); + const Uint32 max = NGPtr.p->nodeCount; + + Uint32 tmp= next_replica_node[NGPtr.i]; + for(Uint32 replicaNo = 0; replicaNo < noOfReplicas; replicaNo++) + { + jam(); + const Uint16 nodeId = NGPtr.p->nodesInGroup[tmp]; + fragments[count++]= nodeId; + inc_node_or_group(tmp, max); + } + inc_node_or_group(tmp, max); + next_replica_node[NGPtr.i]= tmp; + + /** + * Next node group for next fragment + */ + inc_node_or_group(default_node_group, cnoOfNodeGroups); + } + if (err) + { + jam(); break; } + else + { + jam(); + c_nextNodeGroup = default_node_group; + } } else { if (primaryTableId >= ctabFileSize) { jam(); @@ -6331,49 +6589,14 @@ err = CreateFragmentationRef::InvalidPrimaryTable; break; } - if (noOfFragments != primTabPtr.p->totalfragments) { - jam(); - err = CreateFragmentationRef::InvalidFragmentationType; - break; - } - } - - Uint32 count = 2; - Uint16 *fragments = (Uint16*)(signal->theData+25); - if (primaryTableId == RNIL) { - jam(); - Uint8 next_replica_node[MAX_NDB_NODES]; - memset(next_replica_node,0,sizeof(next_replica_node)); - for(Uint32 fragNo = 0; fragNo<noOfFragments; fragNo++){ - jam(); - ptrCheckGuard(NGPtr, MAX_NDB_NODES, nodeGroupRecord); - const Uint32 max = NGPtr.p->nodeCount; - - Uint32 tmp= next_replica_node[NGPtr.i]; - for(Uint32 replicaNo = 0; replicaNo<noOfReplicas; replicaNo++) - { - jam(); - const Uint32 nodeId = NGPtr.p->nodesInGroup[tmp++]; - fragments[count++] = nodeId; - tmp = (tmp >= max ? 0 : tmp); - } - tmp++; - next_replica_node[NGPtr.i]= (tmp >= max ? 0 : tmp); - - /** - * Next node group for next fragment - */ - NGPtr.i++; - NGPtr.i = (NGPtr.i == cnoOfNodeGroups ? 0 : NGPtr.i); - } - } else { + noOfFragments= primTabPtr.p->totalfragments; for (Uint32 fragNo = 0; - fragNo < primTabPtr.p->totalfragments; fragNo++) { + fragNo < noOfFragments; fragNo++) { jam(); FragmentstorePtr fragPtr; ReplicaRecordPtr replicaPtr; getFragstore(primTabPtr.p, fragNo, fragPtr); - fragments[count++] = fragPtr.p->preferredPrimary; + fragments[count++]= fragPtr.p->preferredPrimary; for (replicaPtr.i = fragPtr.p->storedReplicas; replicaPtr.i != RNIL; replicaPtr.i = replicaPtr.p->nextReplica) { @@ -6381,9 +6604,9 @@ ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); if (replicaPtr.p->procNode != fragPtr.p->preferredPrimary) { jam(); - fragments[count++] = replicaPtr.p->procNode; - }//if - }//for + fragments[count++]= replicaPtr.p->procNode; + } + } for (replicaPtr.i = fragPtr.p->oldStoredReplicas; replicaPtr.i != RNIL; replicaPtr.i = replicaPtr.p->nextReplica) { @@ -6391,25 +6614,26 @@ ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); if (replicaPtr.p->procNode != fragPtr.p->preferredPrimary) { jam(); - fragments[count++] = replicaPtr.p->procNode; - }//if - }//for + fragments[count++]= replicaPtr.p->procNode; + } + } } } - ndbrequire(count == (2 + noOfReplicas * noOfFragments)); + ndbrequire(count == (2U + noOfReplicas * noOfFragments)); CreateFragmentationConf * const conf = (CreateFragmentationConf*)signal->getDataPtrSend(); conf->senderRef = reference(); conf->senderData = senderData; - conf->noOfReplicas = noOfReplicas; - conf->noOfFragments = noOfFragments; + conf->noOfReplicas = (Uint32)noOfReplicas; + conf->noOfFragments = (Uint32)noOfFragments; - fragments[0] = noOfReplicas; - fragments[1] = noOfFragments; + fragments[0]= noOfReplicas; + fragments[1]= noOfFragments; if(senderRef != 0) { + jam(); LinearSectionPtr ptr[3]; ptr[0].p = (Uint32*)&fragments[0]; ptr[0].sz = (count + 1) / 2; @@ -6421,33 +6645,17 @@ ptr, 1); } - else - { - // Execute direct - signal->theData[0] = 0; - } + // Always ACK/NACK (here ACK) + signal->theData[0] = 0; return; } while(false); - - if(senderRef != 0) - { - CreateFragmentationRef * const ref = - (CreateFragmentationRef*)signal->getDataPtrSend(); - ref->senderRef = reference(); - ref->senderData = senderData; - ref->errorCode = err; - sendSignal(senderRef, GSN_CREATE_FRAGMENTATION_REF, signal, - CreateFragmentationRef::SignalLength, JBB); - } - else - { - // Execute direct - signal->theData[0] = err; - } + // Always ACK/NACK (here NACK) + signal->theData[0] = err; } void Dbdih::execDIADDTABREQ(Signal* signal) { + Uint32 fragType; jamEntry(); DiAddTabReq * const req = (DiAddTabReq*)signal->getDataPtr(); @@ -6472,6 +6680,7 @@ ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); tabPtr.p->connectrec = connectPtr.i; tabPtr.p->tableType = req->tableType; + fragType= req->fragType; tabPtr.p->schemaVersion = req->schemaVersion; tabPtr.p->primaryTableId = req->primaryTableId; @@ -6508,9 +6717,33 @@ /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ tabPtr.p->tabStatus = TabRecord::TS_CREATING; tabPtr.p->storedTable = req->storedTable; - tabPtr.p->method = TabRecord::HASH; tabPtr.p->kvalue = req->kValue; + switch ((DictTabInfo::FragmentType)fragType) + { + case DictTabInfo::AllNodesSmallTable: + case DictTabInfo::AllNodesMediumTable: + case DictTabInfo::AllNodesLargeTable: + case DictTabInfo::SingleFragment: + jam(); + case DictTabInfo::DistrKeyLin: + jam(); + tabPtr.p->method= TabRecord::LINEAR_HASH; + break; + case DictTabInfo::DistrKeyHash: + case DictTabInfo::DistrKeyUniqueHashIndex: + case DictTabInfo::DistrKeyOrderedIndex: + jam(); + tabPtr.p->method= TabRecord::NORMAL_HASH; + break; + case DictTabInfo::UserDefined: + jam(); + tabPtr.p->method= TabRecord::USER_DEFINED; + break; + default: + ndbrequire(false); + } + union { Uint16 fragments[2 + MAX_FRAG_PER_NODE*MAX_REPLICAS*MAX_NDB_NODES]; Uint32 align; @@ -6560,6 +6793,8 @@ Uint32 activeIndex = 0; getFragstore(tabPtr.p, fragId, fragPtr); fragPtr.p->preferredPrimary = fragments[index]; + fragPtr.p->m_log_part_id = c_nextLogPart++; + for (Uint32 i = 0; i<noReplicas; i++) { const Uint32 nodeId = fragments[index++]; ReplicaRecordPtr replicaPtr; @@ -6604,9 +6839,9 @@ jam(); const Uint32 fragCount = tabPtr.p->totalfragments; ReplicaRecordPtr replicaPtr; replicaPtr.i = RNIL; + FragmentstorePtr fragPtr; for(; fragId<fragCount; fragId++){ jam(); - FragmentstorePtr fragPtr; getFragstore(tabPtr.p, fragId, fragPtr); replicaPtr.i = fragPtr.p->storedReplicas; @@ -6664,6 +6899,7 @@ req->nodeId = getOwnNodeId(); req->totalFragments = fragCount; req->startGci = SYSFILE->newestRestorableGCI; + req->logPartId = fragPtr.p->m_log_part_id; sendSignal(DBDICT_REF, GSN_ADD_FRAGREQ, signal, AddFragReq::SignalLength, JBB); return; @@ -6945,17 +7181,40 @@ tabPtr.i = req->tableId; Uint32 hashValue = req->hashValue; Uint32 ttabFileSize = ctabFileSize; + Uint32 fragId; + DiGetNodesConf * const conf = (DiGetNodesConf *)&signal->theData[0]; TabRecord* regTabDesc = tabRecord; jamEntry(); ptrCheckGuard(tabPtr, ttabFileSize, regTabDesc); - Uint32 fragId = hashValue & tabPtr.p->mask; - ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE); - if (fragId < tabPtr.p->hashpointer) { + if (tabPtr.p->method == TabRecord::LINEAR_HASH) + { jam(); - fragId = hashValue & ((tabPtr.p->mask << 1) + 1); - }//if + fragId = hashValue & tabPtr.p->mask; + ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE); + if (fragId < tabPtr.p->hashpointer) { + jam(); + fragId = hashValue & ((tabPtr.p->mask << 1) + 1); + }//if + } + else if (tabPtr.p->method == TabRecord::NORMAL_HASH) + { + jam(); + fragId= hashValue % tabPtr.p->totalfragments; + } + else + { + jam(); + ndbassert(tabPtr.p->method == TabRecord::USER_DEFINED); + fragId= hashValue; + if (fragId >= tabPtr.p->totalfragments) + { + jam(); + conf->zero= 1; //Indicate error; + signal->theData[1]= ZUNDEFINED_FRAGMENT_ERROR; + return; + } + } getFragstore(tabPtr.p, fragId, fragPtr); - DiGetNodesConf * const conf = (DiGetNodesConf *)&signal->theData[0]; Uint32 nodeCount = extractNodeInfo(fragPtr.p, conf->nodes); Uint32 sig2 = (nodeCount - 1) + (fragPtr.p->distributionKey << 16); @@ -7122,39 +7381,66 @@ void Dbdih::execDI_FCOUNTREQ(Signal* signal) { + DihFragCountReq * const req = (DihFragCountReq*)signal->getDataPtr(); ConnectRecordPtr connectPtr; TabRecordPtr tabPtr; + const BlockReference senderRef = signal->senderBlockRef(); + const Uint32 senderData = req->m_senderData; jamEntry(); - connectPtr.i = signal->theData[0]; - tabPtr.i = signal->theData[1]; + connectPtr.i = req->m_connectionData; + tabPtr.i = req->m_tableRef; ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); - ndbrequire(tabPtr.p->tabStatus == TabRecord::TS_ACTIVE); + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE) + { + DihFragCountRef* ref = (DihFragCountRef*)signal->getDataPtrSend(); + //connectPtr.i == RNIL -> question without connect record + if(connectPtr.i == RNIL) + ref->m_connectionData = RNIL; + else + ref->m_connectionData = connectPtr.p->userpointer; + ref->m_tableRef = tabPtr.i; + ref->m_senderData = senderData; + ref->m_error = DihFragCountRef::ErroneousTableState; + ref->m_tableStatus = tabPtr.p->tabStatus; + sendSignal(senderRef, GSN_DI_FCOUNTREF, signal, + DihFragCountRef::SignalLength, JBB); + return; + } if(connectPtr.i != RNIL){ ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); if (connectPtr.p->connectState == ConnectRecord::INUSE) { jam(); - signal->theData[0] = connectPtr.p->userpointer; - signal->theData[1] = tabPtr.p->totalfragments; - sendSignal(connectPtr.p->userblockref, GSN_DI_FCOUNTCONF, signal,2, JBB); - return; - }//if - signal->theData[0] = connectPtr.p->userpointer; - signal->theData[1] = ZERRONOUSSTATE; - sendSignal(connectPtr.p->userblockref, GSN_DI_FCOUNTREF, signal, 2, JBB); + DihFragCountConf* conf = (DihFragCountConf*)signal->getDataPtrSend(); + conf->m_connectionData = connectPtr.p->userpointer; + conf->m_tableRef = tabPtr.i; + conf->m_senderData = senderData; + conf->m_fragmentCount = tabPtr.p->totalfragments; + conf->m_noOfBackups = tabPtr.p->noOfBackups; + sendSignal(connectPtr.p->userblockref, GSN_DI_FCOUNTCONF, signal, + DihFragCountConf::SignalLength, JBB); + return; + }//if + DihFragCountRef* ref = (DihFragCountRef*)signal->getDataPtrSend(); + ref->m_connectionData = connectPtr.p->userpointer; + ref->m_tableRef = tabPtr.i; + ref->m_senderData = senderData; + ref->m_error = DihFragCountRef::ErroneousTableState; + ref->m_tableStatus = tabPtr.p->tabStatus; + sendSignal(connectPtr.p->userblockref, GSN_DI_FCOUNTREF, signal, + DihFragCountRef::SignalLength, JBB); return; }//if - + DihFragCountConf* conf = (DihFragCountConf*)signal->getDataPtrSend(); //connectPtr.i == RNIL -> question without connect record - const Uint32 senderData = signal->theData[2]; - const BlockReference senderRef = signal->senderBlockRef(); - signal->theData[0] = RNIL; - signal->theData[1] = tabPtr.p->totalfragments; - signal->theData[2] = tabPtr.i; - signal->theData[3] = senderData; - signal->theData[4] = tabPtr.p->noOfBackups; - sendSignal(senderRef, GSN_DI_FCOUNTCONF, signal, 5, JBB); + conf->m_connectionData = RNIL; + conf->m_tableRef = tabPtr.i; + conf->m_senderData = senderData; + conf->m_fragmentCount = tabPtr.p->totalfragments; + conf->m_noOfBackups = tabPtr.p->noOfBackups; + sendSignal(senderRef, GSN_DI_FCOUNTCONF, signal, + DihFragCountConf::SignalLength, JBB); }//Dbdih::execDI_FCOUNTREQ() void Dbdih::execDIGETPRIMREQ(Signal* signal) @@ -7913,9 +8199,12 @@ SubGcpCompleteRep * const rep = (SubGcpCompleteRep*)signal->getDataPtr(); rep->gci = coldgcp; - rep->senderData = 0; sendSignal(SUMA_REF, GSN_SUB_GCP_COMPLETE_REP, signal, SubGcpCompleteRep::SignalLength, JBB); + + EXECUTE_DIRECT(LGMAN, GSN_SUB_GCP_COMPLETE_REP, signal, + SubGcpCompleteRep::SignalLength); + jamEntry(); } jam(); @@ -8482,8 +8771,7 @@ rf.rwfTabPtr.p->hashpointer = readPageWord(&rf); rf.rwfTabPtr.p->kvalue = readPageWord(&rf); rf.rwfTabPtr.p->mask = readPageWord(&rf); - ndbrequire(readPageWord(&rf) == TabRecord::HASH); - rf.rwfTabPtr.p->method = TabRecord::HASH; + rf.rwfTabPtr.p->method = (TabRecord::Method)readPageWord(&rf); /* ---------------------------------- */ /* Type of table, 2 = temporary table */ /* ---------------------------------- */ @@ -8577,7 +8865,7 @@ writePageWord(&wf, tabPtr.p->hashpointer); writePageWord(&wf, tabPtr.p->kvalue); writePageWord(&wf, tabPtr.p->mask); - writePageWord(&wf, TabRecord::HASH); + writePageWord(&wf, tabPtr.p->method); writePageWord(&wf, tabPtr.p->storedTable); signal->theData[0] = DihContinueB::ZPACK_FRAG_INTO_PAGES; @@ -8678,6 +8966,80 @@ /*****************************************************************************/ /* ********** START FRAGMENT MODULE *************/ /*****************************************************************************/ +void +Dbdih::dump_replica_info() +{ + TabRecordPtr tabPtr; + FragmentstorePtr fragPtr; + + for(tabPtr.i = 0; tabPtr.i < ctabFileSize; tabPtr.i++) + { + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE) + continue; + + for(Uint32 fid = 0; fid<tabPtr.p->totalfragments; fid++) + { + getFragstore(tabPtr.p, fid, fragPtr); + ndbout_c("tab: %d frag: %d gci: %d\n -- storedReplicas:", + tabPtr.i, fid, SYSFILE->newestRestorableGCI); + + Uint32 i; + ReplicaRecordPtr replicaPtr; + replicaPtr.i = fragPtr.p->storedReplicas; + for(; replicaPtr.i != RNIL; replicaPtr.i = replicaPtr.p->nextReplica) + { + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + ndbout_c(" node: %d initialGci: %d nextLcp: %d noCrashedReplicas: %d", + replicaPtr.p->procNode, + replicaPtr.p->initialGci, + replicaPtr.p->nextLcp, + replicaPtr.p->noCrashedReplicas); + for(i = 0; i<MAX_LCP_STORED; i++) + { + ndbout_c(" i: %d %s : lcpId: %d maxGci Completed: %d Started: %d", + i, + (replicaPtr.p->lcpStatus[i] == ZVALID ?"VALID":"INVALID"), + replicaPtr.p->lcpId[i], + replicaPtr.p->maxGciCompleted[i], + replicaPtr.p->maxGciStarted[i]); + } + + for (i = 0; i < 8; i++) + { + ndbout_c(" crashed replica: %d replicaLastGci: %d createGci: %d", + i, + replicaPtr.p->replicaLastGci[i], + replicaPtr.p->createGci[i]); + } + } + ndbout_c(" -- oldStoredReplicas"); + replicaPtr.i = fragPtr.p->oldStoredReplicas; + for(; replicaPtr.i != RNIL; replicaPtr.i = replicaPtr.p->nextReplica) + { + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + for(i = 0; i<MAX_LCP_STORED; i++) + { + ndbout_c(" i: %d %s : lcpId: %d maxGci Completed: %d Started: %d", + i, + (replicaPtr.p->lcpStatus[i] == ZVALID ?"VALID":"INVALID"), + replicaPtr.p->lcpId[i], + replicaPtr.p->maxGciCompleted[i], + replicaPtr.p->maxGciStarted[i]); + } + + for (i = 0; i < 8; i++) + { + ndbout_c(" crashed replica: %d replicaLastGci: %d createGci: %d", + i, + replicaPtr.p->replicaLastGci[i], + replicaPtr.p->createGci[i]); + } + } + } + } +} + void Dbdih::startFragment(Signal* signal, Uint32 tableId, Uint32 fragId) { Uint32 TloopCount = 0; @@ -8739,6 +9101,7 @@ /* SEARCH FOR STORED REPLICAS THAT CAN BE USED TO RESTART THE SYSTEM. */ /* ----------------------------------------------------------------------- */ searchStoredReplicas(fragPtr); + if (cnoOfCreateReplicas == 0) { /* --------------------------------------------------------------------- */ /* THERE WERE NO STORED REPLICAS AVAILABLE THAT CAN SERVE AS REPLICA TO*/ @@ -8751,6 +9114,10 @@ char buf[64]; BaseString::snprintf(buf, sizeof(buf), "table: %d fragment: %d gci: %d", tableId, fragId, SYSFILE->newestRestorableGCI); + + ndbout_c(buf); + dump_replica_info(); + progError(__LINE__, NDBD_EXIT_NO_RESTORABLE_REPLICA, buf); ndbrequire(false); return; @@ -8827,8 +9194,8 @@ // otherwise we have a problem. /* --------------------------------------------------------------------- */ jam(); - ndbrequire(senderNodeId == c_nodeStartMaster.startNode); - nodeRestartStartRecConfLab(signal); + ndbout_c("startNextCopyFragment"); + startNextCopyFragment(signal, findTakeOver(senderNodeId)); return; } else { /* --------------------------------------------------------------------- */ @@ -9846,9 +10213,11 @@ } void Dbdih::findReplica(ReplicaRecordPtr& replicaPtr, - Fragmentstore* fragPtrP, Uint32 nodeId) + Fragmentstore* fragPtrP, + Uint32 nodeId, + bool old) { - replicaPtr.i = fragPtrP->storedReplicas; + replicaPtr.i = old ? fragPtrP->oldStoredReplicas : fragPtrP->storedReplicas; while(replicaPtr.i != RNIL){ ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); if (replicaPtr.p->procNode == nodeId) { @@ -11101,6 +11470,7 @@ cnoHotSpare = 0; cnoOfActiveTables = 0; cnoOfNodeGroups = 0; + c_nextNodeGroup = 0; cnoReplicas = 0; coldgcp = 0; coldGcpId = 0; @@ -11120,6 +11490,7 @@ c_newest_restorable_gci = 0; cverifyQueueCounter = 0; cwaitLcpSr = false; + c_nextLogPart = 0; nodeResetStart(); c_nodeStartMaster.wait = ZFALSE; @@ -11127,7 +11498,7 @@ memset(&sysfileData[0], 0, sizeof(sysfileData)); const ndb_mgm_configuration_iterator * p = - theConfiguration.getOwnConfigIterator(); + m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); c_lcpState.clcpDelay = 20; @@ -11206,6 +11577,8 @@ SYSFILE->takeOver[i] = 0; }//for Sysfile::setInitialStartOngoing(SYSFILE->systemRestartBits); + srand(time(0)); + globalData.m_restart_seq = SYSFILE->m_restart_seq = 0; }//Dbdih::initRestartInfo() /*--------------------------------------------------------------------*/ @@ -11924,6 +12297,8 @@ jam(); fragPtr.p->distributionKey = TdistKey; }//if + + fragPtr.p->m_log_part_id = readPageWord(rf); }//Dbdih::readFragment() Uint32 Dbdih::readPageWord(RWFragment* rf) @@ -12165,9 +12540,18 @@ /*---------------------------------------------------------------*/ void Dbdih::removeNodeFromStored(Uint32 nodeId, FragmentstorePtr fragPtr, - ReplicaRecordPtr replicatePtr) + ReplicaRecordPtr replicatePtr, + bool temporary) { - newCrashedReplica(nodeId, replicatePtr); + if (!temporary) + { + jam(); + newCrashedReplica(nodeId, replicatePtr); + } + else + { + jam(); + } removeStoredReplica(fragPtr, replicatePtr); linkOldStoredReplica(fragPtr, replicatePtr); ndbrequire(fragPtr.p->storedReplicas != RNIL); @@ -13014,6 +13398,7 @@ writePageWord(wf, fragPtr.p->noStoredReplicas); writePageWord(wf, fragPtr.p->noOldStoredReplicas); writePageWord(wf, fragPtr.p->distributionKey); + writePageWord(wf, fragPtr.p->m_log_part_id); }//Dbdih::writeFragment() void Dbdih::writePageWord(RWFragment* wf, Uint32 dataWord) @@ -13080,7 +13465,7 @@ signal->theData[0] = filePtr.p->fileRef; signal->theData[1] = reference(); signal->theData[2] = filePtr.i; - signal->theData[3] = ZLIST_OF_PAIRS; + signal->theData[3] = ZLIST_OF_PAIRS_SYNCH; signal->theData[4] = ZVAR_NO_WORD; signal->theData[5] = tab->noPages; for (Uint32 i = 0; i < tab->noPages; i++) { @@ -13101,7 +13486,8 @@ Dbdih::execDUMP_STATE_ORD(Signal* signal) { DumpStateOrd * const & dumpState = (DumpStateOrd *)&signal->theData[0]; - if (dumpState->args[0] == DumpStateOrd::DihDumpNodeRestartInfo) { + Uint32 arg = dumpState->args[0]; + if (arg == DumpStateOrd::DihDumpNodeRestartInfo) { infoEvent("c_nodeStartMaster.blockLcp = %d, c_nodeStartMaster.blockGcp = %d, c_nodeStartMaster.wait = %d", c_nodeStartMaster.blockLcp, c_nodeStartMaster.blockGcp, c_nodeStartMaster.wait); infoEvent("cstartGcpNow = %d, cgcpStatus = %d", @@ -13111,7 +13497,7 @@ infoEvent("cgcpOrderBlocked = %d, cgcpStartCounter = %d", cgcpOrderBlocked, cgcpStartCounter); }//if - if (dumpState->args[0] == DumpStateOrd::DihDumpNodeStatusInfo) { + if (arg == DumpStateOrd::DihDumpNodeStatusInfo) { NodeRecordPtr localNodePtr; infoEvent("Printing nodeStatus of all nodes"); for (localNodePtr.i = 1; localNodePtr.i < MAX_NDB_NODES; localNodePtr.i++) { @@ -13123,7 +13509,7 @@ }//for }//if - if (dumpState->args[0] == DumpStateOrd::DihPrintFragmentation){ + if (arg == DumpStateOrd::DihPrintFragmentation){ infoEvent("Printing fragmentation of all tables --"); for(Uint32 i = 0; i<ctabFileSize; i++){ TabRecordPtr tabPtr; @@ -13298,7 +13684,7 @@ } } - if(dumpState->args[0] == 7019 && signal->getLength() == 2) + if(arg == 7019 && signal->getLength() == 2) { char buf2[8+1]; NodeRecordPtr nodePtr; @@ -13316,7 +13702,7 @@ nodePtr.p->m_nodefailSteps.getText(buf2)); } - if(dumpState->args[0] == 7020 && signal->getLength() > 3) + if(arg == 7020 && signal->getLength() > 3) { Uint32 gsn= signal->theData[1]; Uint32 block= signal->theData[2]; @@ -13340,7 +13726,7 @@ gsn, getBlockName(block, "UNKNOWN"), length, buf); } - if(dumpState->args[0] == DumpStateOrd::DihDumpLCPState){ + if(arg == DumpStateOrd::DihDumpLCPState){ infoEvent("-- Node %d LCP STATE --", getOwnNodeId()); infoEvent("lcpStatus = %d (update place = %d) ", c_lcpState.lcpStatus, c_lcpState.lcpStatusUpdatedPlace); @@ -13356,7 +13742,7 @@ infoEvent("-- Node %d LCP STATE --", getOwnNodeId()); } - if(dumpState->args[0] == DumpStateOrd::DihDumpLCPMasterTakeOver){ + if(arg == DumpStateOrd::DihDumpLCPMasterTakeOver){ infoEvent("-- Node %d LCP MASTER TAKE OVER STATE --", getOwnNodeId()); infoEvent ("c_lcpMasterTakeOverState.state = %d updatePlace = %d failedNodeId = %d", @@ -13371,52 +13757,25 @@ infoEvent("-- Node %d LCP MASTER TAKE OVER STATE --", getOwnNodeId()); } - if (signal->theData[0] == 7015){ - for(Uint32 i = 0; i<ctabFileSize; i++){ - TabRecordPtr tabPtr; - tabPtr.i = i; - ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); - - if(tabPtr.p->tabStatus != TabRecord::TS_ACTIVE) - continue; - - infoEvent - ("Table %d: TabCopyStatus: %d TabUpdateStatus: %d TabLcpStatus: %d", - tabPtr.i, - tabPtr.p->tabCopyStatus, - tabPtr.p->tabUpdateState, - tabPtr.p->tabLcpStatus); + if (signal->theData[0] == 7015) + { + if (signal->getLength() == 1) + { + signal->theData[1] = 0; + } - FragmentstorePtr fragPtr; - for (Uint32 fid = 0; fid < tabPtr.p->totalfragments; fid++) { - jam(); - getFragstore(tabPtr.p, fid, fragPtr); - - char buf[100], buf2[100]; - BaseString::snprintf(buf, sizeof(buf), " Fragment %d: noLcpReplicas==%d ", - fid, fragPtr.p->noLcpReplicas); - - Uint32 num=0; - ReplicaRecordPtr replicaPtr; - replicaPtr.i = fragPtr.p->storedReplicas; - do { - ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); - BaseString::snprintf(buf2, sizeof(buf2), "%s %d(on %d)=%d(%s)", - buf, num, - replicaPtr.p->procNode, - replicaPtr.p->lcpIdStarted, - replicaPtr.p->lcpOngoingFlag ? "Ongoing" : "Idle"); - BaseString::snprintf(buf, sizeof(buf), "%s", buf2); - - num++; - replicaPtr.i = replicaPtr.p->nextReplica; - } while (replicaPtr.i != RNIL); - infoEvent(buf); - } + Uint32 tableId = signal->theData[1]; + if (tableId < ctabFileSize) + { + signal->theData[0] = 7021; + execDUMP_STATE_ORD(signal); + signal->theData[0] = 7015; + signal->theData[1] = tableId + 1; + sendSignal(reference(), GSN_DUMP_STATE_ORD, signal, 2, JBB); } } - if(dumpState->args[0] == DumpStateOrd::EnableUndoDelayDataWrite){ + if(arg == DumpStateOrd::EnableUndoDelayDataWrite){ ndbout << "Dbdih:: delay write of datapages for table = " << dumpState->args[1]<< endl; // Send this dump to ACC and TUP @@ -13446,7 +13805,7 @@ return; } - if(dumpState->args[0] == 7098){ + if(arg == 7098){ if(signal->length() == 3){ jam(); infoEvent("startLcpRoundLoopLab(tabel=%d, fragment=%d)", @@ -13459,9 +13818,72 @@ } } - if(dumpState->args[0] == DumpStateOrd::DihStartLcpImmediately){ + if(arg == DumpStateOrd::DihStartLcpImmediately){ c_lcpState.ctimer += (1 << c_lcpState.clcpDelay); return; + } + + if (arg == DumpStateOrd::DihSetTimeBetweenGcp) + { + if (signal->getLength() == 1) + { + const ndb_mgm_configuration_iterator * p = + m_ctx.m_config.getOwnConfigIterator(); + ndbrequire(p != 0); + ndb_mgm_get_int_parameter(p, CFG_DB_GCP_INTERVAL, &cgcpDelay); + } + else + { + cgcpDelay = signal->theData[1]; + } + ndbout_c("Setting time between gcp : %d", cgcpDelay); + } + + if (arg == 7021 && signal->getLength() == 2) + { + TabRecordPtr tabPtr; + tabPtr.i = signal->theData[1]; + if (tabPtr.i >= ctabFileSize) + return; + + ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); + + if(tabPtr.p->tabStatus != TabRecord::TS_ACTIVE) + return; + + infoEvent + ("Table %d: TabCopyStatus: %d TabUpdateStatus: %d TabLcpStatus: %d", + tabPtr.i, + tabPtr.p->tabCopyStatus, + tabPtr.p->tabUpdateState, + tabPtr.p->tabLcpStatus); + + FragmentstorePtr fragPtr; + for (Uint32 fid = 0; fid < tabPtr.p->totalfragments; fid++) { + jam(); + getFragstore(tabPtr.p, fid, fragPtr); + + char buf[100], buf2[100]; + BaseString::snprintf(buf, sizeof(buf), " Fragment %d: noLcpReplicas==%d ", + fid, fragPtr.p->noLcpReplicas); + + Uint32 num=0; + ReplicaRecordPtr replicaPtr; + replicaPtr.i = fragPtr.p->storedReplicas; + do { + ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); + BaseString::snprintf(buf2, sizeof(buf2), "%s %d(on %d)=%d(%s)", + buf, num, + replicaPtr.p->procNode, + replicaPtr.p->lcpIdStarted, + replicaPtr.p->lcpOngoingFlag ? "Ongoing" : "Idle"); + BaseString::snprintf(buf, sizeof(buf), "%s", buf2); + + num++; + replicaPtr.i = replicaPtr.p->nextReplica; + } while (replicaPtr.i != RNIL); + infoEvent(buf); + } } }//Dbdih::execDUMP_STATE_ORD()
| Thread | ||
|---|---|---|
| • bk commit into 5.1 tree (tomas:1.2283) | tomas | 4 Apr |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 0.914 sec. using MySQL 5.1.14-beta-log