| List: | Commits | « Previous MessageNext Message » | |
| From: | jonas | Date: | January 11 2007 9:02pm |
| Subject: | bk commit into 5.1 tree (jonas:1.2363) | ||
| View as plain text | |||
Below is the list of changes that have just been committed into a local 5.1 repository of jonas. When jonas 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@stripped, 2007-01-11 21:02:38+01:00, jonas@stripped +4 -0 Merge perch.ndb.mysql.com:/home/jonas/src/50-work into perch.ndb.mysql.com:/home/jonas/src/51-work MERGE: 1.1810.2124.38 storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp@stripped, 2007-01-11 20:52:33+01:00, jonas@stripped +0 -0 Auto merged MERGE: 1.24.60.2 storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp@stripped, 2007-01-11 20:52:33+01:00, jonas@stripped +0 -0 Merge rename: ndb/src/kernel/blocks/dbdih/DbdihMain.cpp -> storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp@stripped, 2007-01-11 20:52:34+01:00, jonas@stripped +0 -0 Auto merged MERGE: 1.13.24.2 storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp@stripped, 2007-01-11 20:52:33+01:00, jonas@stripped +0 -0 Merge rename: ndb/src/kernel/blocks/qmgr/QmgrMain.cpp -> storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp storage/ndb/test/ndbapi/testNodeRestart.cpp@stripped, 2007-01-11 21:02:36+01:00, jonas@stripped +105 -68 merge MERGE: 1.13.14.2 storage/ndb/test/ndbapi/testNodeRestart.cpp@stripped, 2007-01-11 20:52:33+01:00, jonas@stripped +0 -0 Merge rename: ndb/test/ndbapi/testNodeRestart.cpp -> storage/ndb/test/ndbapi/testNodeRestart.cpp storage/ndb/test/run-test/daily-basic-tests.txt@stripped, 2007-01-11 21:02:37+01:00, jonas@stripped +4 -4 merge MERGE: 1.27.24.2 storage/ndb/test/run-test/daily-basic-tests.txt@stripped, 2007-01-11 20:52:33+01:00, jonas@stripped +0 -0 Merge rename: ndb/test/run-test/daily-basic-tests.txt -> storage/ndb/test/run-test/daily-basic-tests.txt # 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: jonas # Host: perch.ndb.mysql.com # Root: /home/jonas/src/51-work/RESYNC --- 1.27.24.1/ndb/test/run-test/daily-basic-tests.txt 2007-01-11 21:02:43 +01:00 +++ 1.62/storage/ndb/test/run-test/daily-basic-tests.txt 2007-01-11 21:02:43 +01:00 @@ -81,23 +81,23 @@ max-time: 500 cmd: testBasic -args: -n PkReadAndLocker T6 +args: -n PkReadAndLocker T6 D1 D2 max-time: 500 cmd: testBasic -args: -n PkReadAndLocker2 T6 +args: -n PkReadAndLocker2 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n PkReadUpdateAndLocker T6 +args: -n PkReadUpdateAndLocker T6 D1 D2 max-time: 500 cmd: testBasic -args: -n ReadWithLocksAndInserts T6 +args: -n ReadWithLocksAndInserts T6 D1 D2 max-time: 500 cmd: testBasic -args: -n PkInsertTwice T1 T6 T10 +args: -n PkInsertTwice T1 T6 T10 D1 D2 max-time: 1500 cmd: testBasic @@ -109,79 +109,79 @@ max-time: 500 cmd: testBasic -args: -n NoCommitSleep T6 +args: -n NoCommitSleep T6 D1 D2 max-time: 500 cmd: testBasic -args: -n NoCommit626 T6 +args: -n NoCommit626 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n NoCommitAndClose T6 +args: -n NoCommitAndClose T6 D1 D2 max-time: 500 cmd: testBasic -args: -n Commit626 T6 +args: -n Commit626 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n CommitTry626 T6 +args: -n CommitTry626 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n CommitAsMuch626 T6 +args: -n CommitAsMuch626 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n NoCommit626 T6 +args: -n NoCommit626 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n NoCommitRollback626 T1 T6 +args: -n NoCommitRollback626 T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n Commit630 T1 T6 +args: -n Commit630 T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n CommitTry630 T1 T6 +args: -n CommitTry630 T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n CommitAsMuch630 T1 T6 +args: -n CommitAsMuch630 T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n NoCommit630 T1 T6 +args: -n NoCommit630 T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n NoCommitRollback630 T1 T6 +args: -n NoCommitRollback630 T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n NoCommitAndClose T1 T6 +args: -n NoCommitAndClose T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n RollbackUpdate T1 T6 +args: -n RollbackUpdate T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n RollbackDeleteMultiple T1 T6 +args: -n RollbackDeleteMultiple T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n ImplicitRollbackDelete T1 T6 +args: -n ImplicitRollbackDelete T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n CommitDelete T1 T6 +args: -n CommitDelete T1 T6 D1 D2 max-time: 500 cmd: testBasic -args: -n RollbackNothing T1 T6 +args: -n RollbackNothing T1 T6 D1 D2 max-time: 500 cmd: testBasicAsynch @@ -199,13 +199,33 @@ cmd: testBasicAsynch args: -n PkDeleteAsynch +max-time: 1000 +cmd: testBasic +args: -n MassiveRollback T1 T7 D1 D2 + +max-time: 500 +cmd: testBasic +args: -n MassiveRollback2 T1 T7 D1 D2 + max-time: 500 cmd: testBasic -args: -n MassiveRollback T1 T6 T13 +args: -n MassiveRollback3 T1 T7 D1 D2 max-time: 500 cmd: testBasic -args: -n MassiveRollback2 T1 T6 T13 +args: -n MassiveRollback4 T1 T7 D1 D2 + +max-time: 500 +cmd: testBasic +args: -n TupError + +max-time: 500 +cmd: testBasic +args: -n InsertError T1 + +max-time: 500 +cmd: testBasic +args: -n InsertError2 T1 max-time: 500 cmd: testTimeout @@ -239,7 +259,7 @@ max-time: 500 cmd: testScan -args: -n ScanUpdate2 T6 +args: -n ScanUpdate2 T6 D1 D2 max-time: 500 cmd: testScan @@ -247,47 +267,51 @@ max-time: 500 cmd: testScan -args: -n ScanDelete2 T10 +args: -n ScanDelete2 T10 D1 D2 max-time: 500 cmd: testScan -args: -n ScanUpdateAndScanRead T6 +args: -n ScanUpdateAndScanRead T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadAndLocker T6 +args: -n ScanReadAndLocker T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadAndPkRead T6 +args: -n ScanReadAndPkRead T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanRead488 -l 10 T6 +args: -n ScanRead488 -l 10 T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanRead488O -l 10 T6 +args: -n ScanRead488O -l 10 T6 D1 D2 max-time: 1000 cmd: testScan -args: -n ScanRead488_Mixed -l 10 T6 +args: -n ScanRead488T -l 10 T6 D1 D2 + +max-time: 1000 +cmd: testScan +args: -n ScanRead488_Mixed -l 10 T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanRead488Timeout -l 10 T6 +args: -n ScanRead488Timeout -l 10 T6 D1 D2 max-time: 600 cmd: testScan -args: -n ScanRead40 -l 100 T2 +args: -n ScanRead40 -l 100 T2 D1 D2 max-time: 1800 cmd: testScan -args: -n ScanRead100 -l 100 T1 +args: -n ScanRead100 -l 100 T1 D1 D2 max-time: 600 cmd: testScan -args: -n ScanRead40 -l 100 T1 +args: -n ScanRead40 -l 100 T1 D1 D2 max-time: 1800 cmd: testScan @@ -299,123 +323,135 @@ max-time: 500 cmd: testScan -args: -n ScanWithLocksAndInserts T6 +args: -n ScanWithLocksAndInserts T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadAbort T6 +args: -n ScanReadAbort T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadAbort15 T6 +args: -n ScanReadAbort15 T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadAbort240 T6 +args: -n ScanReadAbort240 T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanUpdateAbort16 T6 +args: -n ScanUpdateAbort16 T6 D1 D2 max-time: 3600 cmd: testScan -args: -n ScanReadRestart T1 T6 T13 +args: -n ScanReadRestart T1 T6 T13 -max-time: 500 +max-time: 3600 cmd: testScan -args: -n ScanUpdateRestart T6 +args: -n ScanReadRestart D1 D2 -max-time: 500 +max-time: 1200 cmd: testScan -args: -n CheckGetValue T6 +args: -n ScanUpdateRestart T6 + +max-time: 1200 +cmd: testScan +args: -n ScanUpdateRestart D1 D2 max-time: 500 cmd: testScan -args: -n CloseWithoutStop T6 +args: -n CheckGetValue T6 D1 D2 max-time: 500 cmd: testScan -args: -n NextScanWhenNoMore T6 +args: -n CloseWithoutStop T6 D1 D2 max-time: 500 cmd: testScan -args: -n ExecuteScanWithoutOpenScan T6 +args: -n NextScanWhenNoMore T6 D1 D2 max-time: 500 cmd: testScan -args: -n OnlyOpenScanOnce T6 +args: -n ExecuteScanWithoutOpenScan T6 D1 D2 max-time: 500 cmd: testScan -args: -n OnlyOneOpInScanTrans T6 +args: -n OnlyOpenScanOnce T6 D1 D2 max-time: 500 cmd: testScan -args: -n OnlyOneOpBeforeOpenScan T6 +args: -n OnlyOneOpInScanTrans T6 D1 D2 max-time: 500 cmd: testScan -args: -n OnlyOneScanPerTrans T6 +args: -n OnlyOneOpBeforeOpenScan T6 D1 D2 max-time: 500 cmd: testScan -args: -n NoCloseTransaction T6 +args: -n OnlyOneScanPerTrans T6 D1 D2 max-time: 500 cmd: testScan -args: -n CheckInactivityTimeOut T6 +args: -n NoCloseTransaction T6 D1 D2 max-time: 500 cmd: testScan -args: -n CheckInactivityBeforeClose T6 +args: -n CheckInactivityTimeOut T6 D1 D2 max-time: 500 cmd: testScan -args: -n CheckAfterTerror T6 +args: -n CheckInactivityBeforeClose T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadError5021 T1 +args: -n CheckAfterTerror T6 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReaderror5022 T1 +args: -n ScanReadError5021 T1 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadError5023 T1 +args: -n ScanReaderror5022 T1 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadError5024 T1 +args: -n ScanReadError5023 T1 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadError5025 T1 +args: -n ScanReadError5024 T1 D1 D2 max-time: 500 cmd: testScan -args: -n ScanReadError5030 T1 +args: -n ScanReadError5025 T1 D1 D2 max-time: 500 cmd: testScan -args: -n InsertDelete T1 T6 +args: -n ScanReadError5030 T1 D1 D2 max-time: 500 cmd: testScan -args: -n CheckAfterTerror T1 +args: -n InsertDelete T1 T6 D1 D2 max-time: 500 cmd: testScan +args: -n CheckAfterTerror T1 D1 D2 + +max-time: 1200 +cmd: testScan args: -n ScanReadWhileNodeIsDown T1 +max-time: 1200 +cmd: testScan +args: -n ScanReadWhileNodeIsDown D1 D2 + max-time: 500 cmd: testScan -args: -n ScanRestart T1 +args: -n ScanRestart T1 D1 D2 max-time: 500 cmd: testScan -args: -l 100 -n Scan-bug8262 T7 +args: -l 100 -n Scan-bug8262 T7 D1 D2 max-time: 500 cmd: testScan @@ -426,6 +462,10 @@ args: -n Bug24447 T1 max-time: 500 +cmd: testScan +args: -n ScanVariants + +max-time: 500 cmd: testNodeRestart args: -n Bug15587 T1 @@ -462,6 +502,10 @@ args: -n Bug20185 T1 max-time: 1000 +cmd: testNodeRestart +args: -n Bug21271 T6 + +max-time: 1000 cmd: testIndex args: -n Bug21384 @@ -477,15 +521,6 @@ cmd: testNodeRestart args: -n Bug25554 T1 -# OLD FLEX -max-time: 500 -cmd: flexBench -args: -c 25 -t 10 - -max-time: 500 -cmd: flexHammer -args: -r 5 -t 32 - # # DICT TESTS max-time: 1500 @@ -502,7 +537,7 @@ max-time: 1500 cmd: testDict -args: -n CreateAndDropDuring T6 T10 +args: -n CreateAndDropDuring T6 T10 D1 D2 max-time: 1500 cmd: testDict @@ -534,7 +569,7 @@ max-time: 1500 cmd: testDict -args: -n Restart_NR2 T1 +args: -n Restart_NR2 T1 I3 # # TEST NDBAPI @@ -591,23 +626,27 @@ max-time: 500 cmd: testNdbApi -args: -n UpdateWithoutKeys T6 +args: -n UpdateWithoutKeys T6 D1 D2 max-time: 500 cmd: testNdbApi -args: -n UpdateWithoutValues T6 +args: -n UpdateWithoutValues T6 D1 D2 max-time: 500 cmd: testNdbApi -args: -n ReadWithoutGetValue +args: -n ReadWithoutGetValue D1 D2 max-time: 500 cmd: testNdbApi -args: -n Bug_11133 T1 +args: -n Bug_11133 T1 D1 D2 max-time: 500 cmd: testNdbApi -args: -n Scan_4006 T1 +args: -n Scan_4006 T1 D1 D2 + +max-time: 500 +cmd: testNdbApi +args: -n Bug_WritePartialIgnoreError T1 #max-time: 500 #cmd: testInterpreter @@ -625,13 +664,21 @@ cmd: testRestartGci args: T6 -max-time: 600 +max-time: 1500 cmd: testBlobs args: max-time: 5000 cmd: testOIBasic -args: +args: -case abcdefz + +max-time: 2000 +cmd: testOIBasic +args: -case gz + +max-time: 2000 +cmd: testOIBasic +args: -case hz max-time: 2500 cmd: testBitfield @@ -663,6 +710,14 @@ max-time: 1500 cmd: testSystemRestart +args: -n SR1 D1 + +max-time: 1500 +cmd: testSystemRestart +args: -n SR1 D2 + +max-time: 1500 +cmd: testSystemRestart args: -n SR2 T1 max-time: 1500 @@ -675,6 +730,14 @@ max-time: 1500 cmd: testSystemRestart +args: -n SR2 D1 + +max-time: 1500 +cmd: testSystemRestart +args: -n SR2 D2 + +max-time: 1500 +cmd: testSystemRestart args: -n SR_UNDO T1 max-time: 1500 @@ -688,6 +751,30 @@ max-time: 1500 cmd: testSystemRestart args: -n SR_UNDO T8 + +max-time: 1000 +cmd: testSRBank +args: -n SR -l 300 -r 15 T1 + +max-time: 1000 +cmd: testSRBank +args: -n NR -l 300 -r 15 T1 + +max-time: 1000 +cmd: testSRBank +args: -n Mix -l 300 -r 15 T1 + +max-time: 300 +cmd: testNodeRestart +args: -n Bug24543 T1 + +max-time: 1500 +cmd: testSystemRestart +args: -n Bug24664 + +max-time: 1000 +cmd: testNodeRestart +args: -n Bug25468 T1 # OLD FLEX max-time: 500 --- 1.24.60.1/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp 2007-01-11 21:02:43 +01:00 +++ 1.96/storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp 2007-01-11 21:02:43 +01:00 @@ -67,6 +67,7 @@ #include <signaldata/CreateFragmentation.hpp> #include <signaldata/LqhFrag.hpp> #include <signaldata/FsOpenReq.hpp> +#include <signaldata/DihFragCount.hpp> #include <signaldata/DictLock.hpp> #include <DebuggerNames.hpp> @@ -610,6 +611,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); @@ -666,7 +675,9 @@ if (cmasterdihref != reference()) { jam(); + Uint32 tmp= SYSFILE->m_restart_seq; memcpy(sysfileData, cdata, sizeof(sysfileData)); + SYSFILE->m_restart_seq = tmp; } c_copyGCISlave.m_copyReason = reason; @@ -1079,7 +1090,7 @@ jamEntry(); const ndb_mgm_configuration_iterator * p = - theConfiguration.getOwnConfigIterator(); + m_ctx.m_config.getOwnConfigIterator(); ndbrequireErr(p != 0, NDBD_EXIT_INVALID_CONFIG); initData(); @@ -1122,6 +1133,26 @@ return; }//Dbdih::execSTART_FRAGCONF() +void Dbdih::execSTART_FRAGREF(Signal* signal) +{ + jamEntry(); + + /** + * Kill starting node + */ + Uint32 errCode = signal->theData[1]; + Uint32 nodeId = signal->theData[2]; + + SystemError * const sysErr = (SystemError*)&signal->theData[0]; + sysErr->errorCode = SystemError::StartFragRefError; + sysErr->errorRef = reference(); + sysErr->data1 = errCode; + sysErr->data2 = 0; + sendSignal(calcNdbCntrBlockRef(nodeId), GSN_SYSTEM_ERROR, signal, + SystemError::SignalLength, JBB); + return; +}//Dbdih::execSTART_FRAGCONF() + void Dbdih::execSTART_MEREF(Signal* signal) { jamEntry(); @@ -1165,7 +1196,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); @@ -1734,12 +1765,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]; @@ -1897,11 +1931,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)) { @@ -2048,6 +2077,9 @@ signal->theData[0] = reference(); signal->theData[1] = c_nodeStartSlave.nodeId; sendSignal(BACKUP_REF, GSN_INCL_NODEREQ, signal, 2, JBB); + + // Suma will not send response to this for now, later... + sendSignal(SUMA_REF, GSN_INCL_NODEREQ, signal, 2, JBB); return; }//if if (TstartNode_or_blockref == numberToRef(BACKUP, getOwnNodeId())){ @@ -2724,13 +2756,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() @@ -2774,9 +2807,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 == ~ (Uint32) 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) { @@ -3109,6 +3286,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]; @@ -3119,6 +3304,7 @@ copyFragReq->nodeId = takeOverPtr.p->toStartingNode; copyFragReq->schemaVersion = tabPtr.p->schemaVersion; copyFragReq->distributionKey = fragPtr.p->distributionKey; + copyFragReq->gci = gci; copyFragReq->nodeCount = extractNodeInfo(fragPtr.p, copyFragReq->nodeList); sendSignal(ref, GSN_COPY_FRAGREQ, signal, @@ -3651,6 +3837,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() @@ -3859,6 +4046,11 @@ Uint32 newMasterId = nodeFail->masterNodeId; const Uint32 noOfFailedNodes = nodeFail->noOfNodes; + if (ERROR_INSERTED(7179)) + { + CLEAR_ERROR_INSERT_VALUE; + } + /*-------------------------------------------------------------------------*/ // The first step is to convert from a bit mask to an array of failed nodes. /*-------------------------------------------------------------------------*/ @@ -4169,6 +4361,8 @@ Uint32 takeOverPtrI) { jam(); + ndbout_c("checkTakeOverInMasterStartNodeFailure %x", + takeOverPtrI); if (takeOverPtrI == RNIL) { jam(); return; @@ -4182,6 +4376,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: @@ -4290,6 +4487,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 */ @@ -5361,7 +5565,7 @@ //const Uint32 lcpId = SYSFILE->latestLCP_ID; const bool lcpOngoingFlag = (tabPtr.p->tabLcpStatus== TabRecord::TLS_ACTIVE); - const bool temporary = !tabPtr.p->storedTable; + const bool unlogged = (tabPtr.p->tabStorage != TabRecord::ST_NORMAL); FragmentstorePtr fragPtr; for(Uint32 fragNo = 0; fragNo < tabPtr.p->totalfragments; fragNo++){ @@ -5382,7 +5586,7 @@ jam(); found = true; noOfRemovedReplicas++; - removeNodeFromStored(nodeId, fragPtr, replicaPtr, temporary); + removeNodeFromStored(nodeId, fragPtr, replicaPtr, unlogged); if(replicaPtr.p->lcpOngoingFlag){ jam(); /** @@ -5709,11 +5913,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 */ @@ -5724,7 +5926,6 @@ lcpState = MasterLCPConf::LCP_STATUS_IDLE; break; case LCP_STATUS_ACTIVE: - ok = true; jam(); /*--------------------------------------------------*/ /* COPY OF RESTART INFORMATION HAS BEEN */ @@ -5733,7 +5934,6 @@ lcpState = MasterLCPConf::LCP_STATUS_ACTIVE; break; case LCP_TAB_COMPLETED: - ok = true; jam(); /*--------------------------------------------------------*/ /* ALL LCP_REPORT'S HAVE BEEN COMPLETED FOR */ @@ -5743,7 +5943,6 @@ lcpState = MasterLCPConf::LCP_TAB_COMPLETED; break; case LCP_TAB_SAVED: - ok = true; jam(); /*--------------------------------------------------------*/ /* ALL LCP_REPORT'S HAVE BEEN COMPLETED FOR */ @@ -5767,15 +5966,16 @@ 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); + lcpState= MasterLCPConf::LCP_STATUS_IDLE; // remove warning }//switch - ndbrequire(ok); Uint32 failedNodeId = c_lcpState.m_MASTER_LCPREQ_FailedNodeId; MasterLCPConf * const conf = (MasterLCPConf *)&signal->theData[0]; @@ -6373,96 +6573,147 @@ 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 Sysfile::NS_NotActive_NotTakenOver: + case DictTabInfo::AllNodesMediumTable: jam(); + noOfFragments = 2 * csystemnodes; + set_default_node_groups(signal, noOfFragments); break; - case Sysfile::NS_HotSpare: + case DictTabInfo::AllNodesLargeTable: jam(); - case Sysfile::NS_NotDefined: + noOfFragments = 4 * csystemnodes; + set_default_node_groups(signal, noOfFragments); + break; + case DictTabInfo::SingleFragment: + jam(); + noOfFragments = 1; + set_default_node_groups(signal, noOfFragments); + break; + case DictTabInfo::DistrKeyHash: jam(); + 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; + + fragments[count++] = c_nextLogPart++; // Store logpart first + 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(); @@ -6476,48 +6727,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->m_log_part_id; fragments[count++] = fragPtr.p->preferredPrimary; for (replicaPtr.i = fragPtr.p->storedReplicas; replicaPtr.i != RNIL; @@ -6526,9 +6743,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) { @@ -6536,25 +6753,32 @@ 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)); + if(count != (2U + (1 + noOfReplicas) * noOfFragments)){ + char buf[255]; + BaseString::snprintf(buf, sizeof(buf), + "Illegal configuration change: NoOfReplicas." + " Can't be applied online "); + progError(__LINE__, NDBD_EXIT_INVALID_CONFIG, buf); + } 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; @@ -6566,33 +6790,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(); @@ -6617,6 +6825,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; @@ -6652,15 +6861,46 @@ /* BUT THEY DO NOT HAVE ANY INFORMATION ABOUT ANY TABLE*/ /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ tabPtr.p->tabStatus = TabRecord::TS_CREATING; - tabPtr.p->storedTable = req->storedTable; - tabPtr.p->method = TabRecord::HASH; + if(req->loggedTable) + tabPtr.p->tabStorage= TabRecord::ST_NORMAL; + else if(req->temporaryTable) + tabPtr.p->tabStorage= TabRecord::ST_TEMPORARY; + else + tabPtr.p->tabStorage= TabRecord::ST_NOLOGGING; 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; }; SegmentedSectionPtr fragDataPtr; + LINT_INIT(fragDataPtr.i); + LINT_INIT(fragDataPtr.sz); signal->getSection(fragDataPtr, DiAddTabReq::FRAGMENTATION); copy((Uint32*)fragments, fragDataPtr); releaseSections(signal); @@ -6704,7 +6944,9 @@ FragmentstorePtr fragPtr; Uint32 activeIndex = 0; getFragstore(tabPtr.p, fragId, fragPtr); + fragPtr.p->m_log_part_id = fragments[index++]; fragPtr.p->preferredPrimary = fragments[index]; + for (Uint32 i = 0; i<noReplicas; i++) { const Uint32 nodeId = fragments[index++]; ReplicaRecordPtr replicaPtr; @@ -6748,10 +6990,12 @@ TabRecordPtr tabPtr, Uint32 fragId){ jam(); const Uint32 fragCount = tabPtr.p->totalfragments; - ReplicaRecordPtr replicaPtr; replicaPtr.i = RNIL; + ReplicaRecordPtr replicaPtr; + LINT_INIT(replicaPtr.p); + replicaPtr.i = RNIL; + FragmentstorePtr fragPtr; for(; fragId<fragCount; fragId++){ jam(); - FragmentstorePtr fragPtr; getFragstore(tabPtr.p, fragId, fragPtr); replicaPtr.i = fragPtr.p->storedReplicas; @@ -6791,7 +7035,7 @@ ndbrequire(replicaPtr.p->procNode == getOwnNodeId()); Uint32 requestInfo = 0; - if(!tabPtr.p->storedTable){ + if(tabPtr.p->tabStorage != TabRecord::ST_NORMAL){ requestInfo |= LqhFragReq::TemporaryTable; } @@ -6809,6 +7053,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; @@ -7090,17 +7335,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); @@ -7267,39 +7535,70 @@ 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 + { + jam(); + ptrCheckGuard(connectPtr, cconnectFileSize, connectRecord); + 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) @@ -8073,6 +8372,15 @@ if (reason == CopyGCIReq::GLOBAL_CHECKPOINT) { jam(); cgcpParticipantState = GCP_PARTICIPANT_READY; + + SubGcpCompleteRep * const rep = (SubGcpCompleteRep*)signal->getDataPtr(); + rep->gci = coldgcp; + 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(); @@ -8161,9 +8469,9 @@ continue; } - if (tabPtr.p->storedTable == 0) { + if (tabPtr.p->tabStorage != TabRecord::ST_NORMAL) { /** - * Temporary table + * Table is not logged */ jam(); tabPtr.p->tabLcpStatus = TabRecord::TLS_COMPLETED; @@ -8476,7 +8784,7 @@ ConstPtr<ReplicaRecord> constReplicaPtr; constReplicaPtr.i = replicaPtr.i; constReplicaPtr.p = replicaPtr.p; - if (tabPtr.p->storedTable == 0 || + if (tabPtr.p->tabStorage != TabRecord::ST_NORMAL || setup_create_replica(fragPtr, &createReplica, constReplicaPtr)) { @@ -8669,12 +8977,11 @@ 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; - /* ---------------------------------- */ - /* Type of table, 2 = temporary table */ - /* ---------------------------------- */ - rf.rwfTabPtr.p->storedTable = readPageWord(&rf); + rf.rwfTabPtr.p->method = (TabRecord::Method)readPageWord(&rf); + /* ------------- */ + /* Type of table */ + /* ------------- */ + rf.rwfTabPtr.p->tabStorage = (TabRecord::Storage)(readPageWord(&rf)); Uint32 noOfFrags = rf.rwfTabPtr.p->totalfragments; ndbrequire(noOfFrags > 0); @@ -8764,8 +9071,8 @@ writePageWord(&wf, tabPtr.p->hashpointer); writePageWord(&wf, tabPtr.p->kvalue); writePageWord(&wf, tabPtr.p->mask); - writePageWord(&wf, TabRecord::HASH); - writePageWord(&wf, tabPtr.p->storedTable); + writePageWord(&wf, tabPtr.p->method); + writePageWord(&wf, tabPtr.p->tabStorage); signal->theData[0] = DihContinueB::ZPACK_FRAG_INTO_PAGES; signal->theData[1] = tabPtr.i; @@ -8865,6 +9172,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; @@ -8896,7 +9277,7 @@ continue; } - if(tabPtr.p->storedTable == 0){ + if(tabPtr.p->tabStorage != TabRecord::ST_NORMAL){ jam(); TloopCount++; tableId++; @@ -8926,6 +9307,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*/ @@ -8938,6 +9320,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; @@ -9014,8 +9400,8 @@ // otherwise we have a problem. /* --------------------------------------------------------------------- */ jam(); - ndbrequire(senderNodeId == c_nodeStartMaster.startNode); - nodeRestartStartRecConfLab(signal); + ndbout_c("startNextCopyFragment"); + startNextCopyFragment(signal, findTakeOver(senderNodeId)); return; } else { /* --------------------------------------------------------------------- */ @@ -9516,7 +9902,7 @@ }//if ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); if (tabPtr.p->tabStatus != TabRecord::TS_ACTIVE || - tabPtr.p->storedTable == 0) { + tabPtr.p->tabStorage != TabRecord::ST_NORMAL) { if (TloopCount > 100) { jam(); signal->theData[0] = DihContinueB::ZCALCULATE_KEEP_GCI; @@ -9876,12 +10262,42 @@ Uint32 fragId = lcpReport->fragId; jamEntry(); + + if (ERROR_INSERTED(7178) && nodeId != getOwnNodeId()) + { + jam(); + Uint32 owng =Sysfile::getNodeGroup(getOwnNodeId(), SYSFILE->nodeGroups); + Uint32 nodeg = Sysfile::getNodeGroup(nodeId, SYSFILE->nodeGroups); + if (owng == nodeg) + { + jam(); + ndbout_c("throwing away LCP_FRAG_REP from (and killing) %d", nodeId); + SET_ERROR_INSERT_VALUE(7179); + signal->theData[0] = 9999; + sendSignal(numberToRef(CMVMI, nodeId), + GSN_NDB_TAMPER, signal, 1, JBA); + return; + } + } + if (ERROR_INSERTED(7179) && nodeId != getOwnNodeId()) + { + jam(); + Uint32 owng =Sysfile::getNodeGroup(getOwnNodeId(), SYSFILE->nodeGroups); + Uint32 nodeg = Sysfile::getNodeGroup(nodeId, SYSFILE->nodeGroups); + if (owng == nodeg) + { + jam(); + ndbout_c("throwing away LCP_FRAG_REP from %d", nodeId); + return; + } + } + CRASH_INSERTION2(7025, isMaster()); CRASH_INSERTION2(7016, !isMaster()); - + bool fromTimeQueue = (signal->senderBlockRef() == reference()); - + TabRecordPtr tabPtr; tabPtr.i = tableId; ptrCheckGuard(tabPtr, ctabFileSize, tabRecord); @@ -10045,9 +10461,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) { @@ -10081,6 +10499,37 @@ ndbrequire(false); }//Dbdih::findReplica() + +int +Dbdih::handle_invalid_lcp_no(const LcpFragRep* rep, + ReplicaRecordPtr replicaPtr) +{ + ndbrequire(!isMaster()); + Uint32 lcpNo = rep->lcpNo; + Uint32 lcpId = rep->lcpId; + Uint32 replicaLcpNo = replicaPtr.p->nextLcp; + Uint32 prevReplicaLcpNo = prevLcpNo(replicaLcpNo); + + warningEvent("Detected previous node failure of %d during lcp", + rep->nodeId); + replicaPtr.p->nextLcp = lcpNo; + replicaPtr.p->lcpId[lcpNo] = 0; + replicaPtr.p->lcpStatus[lcpNo] = ZINVALID; + + for (Uint32 i = lcpNo; i != lcpNo; i = nextLcpNo(i)) + { + jam(); + if (replicaPtr.p->lcpStatus[i] == ZVALID && + replicaPtr.p->lcpId[i] >= lcpId) + { + ndbout_c("i: %d lcpId: %d", i, replicaPtr.p->lcpId[i]); + ndbrequire(false); + } + } + + return 0; +} + /** * Return true if table is all fragment replicas have been checkpointed * to disk (in all LQHs) @@ -10109,9 +10558,12 @@ ndbrequire(replicaPtr.p->lcpOngoingFlag == true); if(lcpNo != replicaPtr.p->nextLcp){ - ndbout_c("lcpNo = %d replicaPtr.p->nextLcp = %d", - lcpNo, replicaPtr.p->nextLcp); - ndbrequire(false); + if (handle_invalid_lcp_no(lcpReport, replicaPtr)) + { + ndbout_c("lcpNo = %d replicaPtr.p->nextLcp = %d", + lcpNo, replicaPtr.p->nextLcp); + ndbrequire(false); + } } ndbrequire(lcpNo == replicaPtr.p->nextLcp); ndbrequire(lcpNo < MAX_LCP_STORED); @@ -10444,6 +10896,14 @@ /* ------------------------------------------------------------------------- */ void Dbdih::tableUpdateLab(Signal* signal, TabRecordPtr tabPtr) { FileRecordPtr filePtr; + if(tabPtr.p->tabStorage == TabRecord::ST_TEMPORARY) { + // For temporary tables we do not write to disk. Mark both copies 0 and 1 + // as done, and go straight to the after-close code. + filePtr.i = tabPtr.p->tabFile[1]; + ptrCheckGuard(filePtr, cfileFileSize, fileRecord); + tableCloseLab(signal, filePtr); + return; + } filePtr.i = tabPtr.p->tabFile[0]; ptrCheckGuard(filePtr, cfileFileSize, fileRecord); createFileRw(signal, filePtr); @@ -11062,6 +11522,7 @@ { ConstPtr<ReplicaRecord> fblFoundReplicaPtr; ConstPtr<ReplicaRecord> fblReplicaPtr; + LINT_INIT(fblFoundReplicaPtr.p); /* --------------------------------------------------------------------- */ /* WE START WITH ZERO AS FOUND TO ENSURE THAT FIRST HIT WILL BE */ @@ -11304,6 +11765,7 @@ cnoHotSpare = 0; cnoOfActiveTables = 0; cnoOfNodeGroups = 0; + c_nextNodeGroup = 0; cnoReplicas = 0; coldgcp = 0; coldGcpId = 0; @@ -11323,6 +11785,7 @@ c_newest_restorable_gci = 0; cverifyQueueCounter = 0; cwaitLcpSr = false; + c_nextLogPart = 0; nodeResetStart(); c_nodeStartMaster.wait = ZFALSE; @@ -11330,7 +11793,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; @@ -11409,6 +11872,8 @@ SYSFILE->takeOver[i] = 0; }//for Sysfile::setInitialStartOngoing(SYSFILE->systemRestartBits); + srand(time(0)); + globalData.m_restart_seq = SYSFILE->m_restart_seq = 0; }//Dbdih::initRestartInfo() /*--------------------------------------------------------------------*/ @@ -11475,7 +11940,7 @@ tabPtr.p->kvalue = 0; tabPtr.p->hashpointer = (Uint32)-1; tabPtr.p->mask = 0; - tabPtr.p->storedTable = 1; + tabPtr.p->tabStorage = TabRecord::ST_NORMAL; tabPtr.p->tabErrorCode = 0; tabPtr.p->schemaVersion = (Uint32)-1; tabPtr.p->tabRemoveNode = RNIL; @@ -12159,6 +12624,8 @@ jam(); fragPtr.p->distributionKey = TdistKey; }//if + + fragPtr.p->m_log_part_id = readPageWord(rf); }//Dbdih::readFragment() Uint32 Dbdih::readPageWord(RWFragment* rf) @@ -13255,6 +13722,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) @@ -13321,7 +13789,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++) { @@ -13684,7 +14152,7 @@ if (signal->getLength() == 1) { const ndb_mgm_configuration_iterator * p = - theConfiguration.getOwnConfigIterator(); + m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); ndb_mgm_get_int_parameter(p, CFG_DB_GCP_INTERVAL, &cgcpDelay); } @@ -14809,13 +15277,14 @@ { Uint32 masterVersion = getNodeInfo(cmasterNodeId).m_version; - unsigned int get_major = getMajor(masterVersion); - unsigned int get_minor = getMinor(masterVersion); - unsigned int get_build = getBuild(masterVersion); - - ndbrequire(get_major == 4 || get_major == 5); + const unsigned int get_major = getMajor(masterVersion); + const unsigned int get_minor = getMinor(masterVersion); + const unsigned int get_build = getBuild(masterVersion); + ndbrequire(get_major >= 4); if (masterVersion < NDBD_DICT_LOCK_VERSION_5 || + masterVersion < NDBD_DICT_LOCK_VERSION_5_1 && + get_major == 5 && get_minor == 1 || ERROR_INSERTED(7176)) { jam(); @@ -14886,10 +15355,13 @@ { Uint32 masterVersion = getNodeInfo(cmasterNodeId).m_version; - unsigned int get_major = getMajor(masterVersion); - ndbrequire(get_major == 4 || get_major == 5); + const unsigned int get_major = getMajor(masterVersion); + const unsigned int get_minor = getMinor(masterVersion); + ndbrequire(get_major >= 4); if (masterVersion < NDBD_DICT_LOCK_VERSION_5 || + masterVersion < NDBD_DICT_LOCK_VERSION_5_1 && + get_major == 5 && get_minor == 1 || ERROR_INSERTED(7176)) { return; } --- 1.13.24.1/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp 2007-01-11 21:02:43 +01:00 +++ 1.45/storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp 2007-01-11 21:02:43 +01:00 @@ -153,13 +153,14 @@ return; } Uint64 now = NdbTick_CurrentMillisecond(); + if (now > (c_start_election_time + c_restartFailureTimeout)) { jam(); BaseString tmp; tmp.append("Shutting down node as total restart time exceeds " " StartFailureTimeout as set in config file "); - if(c_restartFailureTimeout == ~0) + if(c_restartFailureTimeout == (Uint32) ~0) tmp.append(" 0 (inifinite)"); else tmp.appfmt(" %d", c_restartFailureTimeout); @@ -228,7 +229,7 @@ Uint32 senderData = req->senderData; const ndb_mgm_configuration_iterator * p = - theConfiguration.getOwnConfigIterator(); + m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend(); @@ -259,6 +260,9 @@ case 1: initData(signal); startphase1(signal); + recompute_version_info(NodeInfo::DB); + recompute_version_info(NodeInfo::API); + recompute_version_info(NodeInfo::MGM); return; case 7: cactivateApiCheck = 1; @@ -698,7 +702,40 @@ sendCmRegrefLab(signal, Tblockref, CmRegRef::ZNOT_IN_CFG); return; } - + + if (getNodeState().getSingleUserMode()) + { + /** + * The cluster is in single user mode. + * Data node is not allowed to get added in the cluster + * while in single user mode. + */ + // handle rolling upgrade + { + unsigned int get_major = getMajor(startingVersion); + unsigned int get_minor = getMinor(startingVersion); + unsigned int get_build = getBuild(startingVersion); + + if (startingVersion < NDBD_QMGR_SINGLEUSER_VERSION_5) { + jam(); + + infoEvent("QMGR: detect upgrade: new node %u old version %u.%u.%u", + (unsigned int)addNodePtr.i, get_major, get_minor, get_build); + /** + * The new node is old version, send ZINCOMPATIBLE_VERSION instead + * of ZSINGLE_USER_MODE. + */ + sendCmRegrefLab(signal, Tblockref, CmRegRef::ZINCOMPATIBLE_VERSION); + } else { + jam(); + + sendCmRegrefLab(signal, Tblockref, CmRegRef::ZSINGLE_USER_MODE); + }//if + } + + return; + }//if + ptrCheckGuard(addNodePtr, MAX_NDB_NODES, nodeRec); Phase phase = addNodePtr.p->phase; if (phase != ZINIT) @@ -731,6 +768,7 @@ */ UintR TdynId = ++c_maxDynamicId; setNodeInfo(addNodePtr.i).m_version = startingVersion; + recompute_version_info(NodeInfo::DB, startingVersion); addNodePtr.p->ndynamicId = TdynId; /** @@ -829,7 +867,7 @@ ptrCheckGuard(myNodePtr, MAX_NDB_NODES, nodeRec); ndbrequire(c_start.m_gsn == GSN_CM_REGREQ); - ndbrequire(myNodePtr.p->phase = ZSTARTING); + ndbrequire(myNodePtr.p->phase == ZSTARTING); cpdistref = cmRegConf->presidentBlockRef; cpresident = cmRegConf->presidentNodeId; @@ -1093,6 +1131,19 @@ jam(); progError(__LINE__, NDBD_EXIT_NODE_NOT_DEAD); break; + case CmRegRef::ZSINGLE_USER_MODE: + jam(); + progError(__LINE__, NDBD_EXIT_SINGLE_USER_MODE); + break; + /** + * For generic refuse error. + * e.g. in online upgrade, we can use this error code instead + * of the incompatible error code. + */ + case CmRegRef::ZGENERIC: + jam(); + progError(__LINE__, NDBD_EXIT_GENERIC); + break; case CmRegRef::ZELECTION: jam(); if (candidate_gci > c_start.m_president_candidate_gci || @@ -1292,7 +1343,7 @@ if (now < partial_timeout) { jam(); - signal->theData[1] = c_restartPartialTimeout == ~0 ? 2 : 3; + signal->theData[1] = c_restartPartialTimeout == (Uint32) ~0 ? 2 : 3; signal->theData[2] = Uint32((partial_timeout - now + 500) / 1000); report_mask.assign(wait); retVal = 0; @@ -1309,7 +1360,7 @@ case CheckNodeGroups::Partitioning: if (now < partitioned_timeout && result != CheckNodeGroups::Win) { - signal->theData[1] = c_restartPartionedTimeout == ~0 ? 4 : 5; + signal->theData[1] = c_restartPartionedTimeout == (Uint32) ~0 ? 4 : 5; signal->theData[2] = Uint32((partitioned_timeout - now + 500) / 1000); report_mask.assign(c_definedNodes); report_mask.bitANDC(c_start.m_starting_nodes); @@ -1356,6 +1407,7 @@ " starting: %s (missing fs for: %s)", mask1, mask2); progError(__LINE__, NDBD_EXIT_SR_RESTARTCONFLICT, buf); + return 0; // Deadcode } void @@ -1455,7 +1507,8 @@ replyNodePtr.p->ndynamicId = dynamicId; replyNodePtr.p->blockRef = signal->getSendersBlockRef(); setNodeInfo(replyNodePtr.i).m_version = version; - + recompute_version_info(NodeInfo::DB, version); + if(!c_start.m_nodes.done()){ jam(); return; @@ -1554,6 +1607,7 @@ } sendCmAckAdd(signal, nodePtr.i, CmAdd::Prepare); + sendApiVersionRep(signal, nodePtr); /* President have prepared us */ CmNodeInfoConf * conf = (CmNodeInfoConf*)signal->getDataPtrSend(); @@ -1566,6 +1620,29 @@ } void +Qmgr::sendApiVersionRep(Signal* signal, NodeRecPtr nodePtr) +{ + if (getNodeInfo(nodePtr.i).m_version >= NDBD_NODE_VERSION_REP) + { + jam(); + Uint32 ref = calcQmgrBlockRef(nodePtr.i); + for(Uint32 i = 1; i<MAX_NODES; i++) + { + jam(); + Uint32 version = getNodeInfo(i).m_version; + Uint32 type = getNodeInfo(i).m_type; + if (type != NodeInfo::DB && version) + { + jam(); + signal->theData[0] = i; + signal->theData[1] = version; + sendSignal(ref, GSN_NODE_VERSION_REP, signal, 2, JBB); + } + } + } +} + +void Qmgr::sendCmAckAdd(Signal * signal, Uint32 nodeId, CmAdd::RequestType type){ CmAckAdd * cmAckAdd = (CmAckAdd*)signal->getDataPtrSend(); @@ -2007,7 +2084,7 @@ * Timeouts */ const ndb_mgm_configuration_iterator * p = - theConfiguration.getOwnConfigIterator(); + m_ctx.m_config.getOwnConfigIterator(); ndbrequire(p != 0); Uint32 hbDBDB = 1500; @@ -2025,7 +2102,7 @@ &c_restartPartionedTimeout); ndb_mgm_get_int_parameter(p, CFG_DB_START_FAILURE_TIMEOUT, &c_restartFailureTimeout); - + if(c_restartPartialTimeout == 0) { c_restartPartialTimeout = ~0; @@ -2056,7 +2133,7 @@ sd->ticket.clear(); sd->mask.clear(); ndb_mgm_configuration_iterator * iter = - theConfiguration.getClusterConfigIterator(); + m_ctx.m_config.getClusterConfigIterator(); for (ndb_mgm_first(iter); ndb_mgm_valid(iter); ndb_mgm_next(iter)) { Uint32 tmp = 0; if (ndb_mgm_get_int_parameter(iter, CFG_NODE_ARBIT_RANK, &tmp) == 0 && @@ -2340,8 +2417,11 @@ ndbrequire(failedNodePtr.p->failState == NORMAL); failedNodePtr.p->failState = WAITING_FOR_FAILCONF1; + NodeReceiverGroup rg(QMGR, c_clusterNodes); + sendSignal(rg, GSN_API_FAILREQ, signal, 2, JBA); sendSignal(DBTC_REF, GSN_API_FAILREQ, signal, 2, JBA); sendSignal(DBDICT_REF, GSN_API_FAILREQ, signal, 2, JBA); + sendSignal(SUMA_REF, GSN_API_FAILREQ, signal, 2, JBA); /**------------------------------------------------------------------------- * THE OTHER NODE WAS AN API NODE. THE COMMUNICATION LINK IS ALREADY @@ -2350,7 +2430,9 @@ * SECONDS. *-------------------------------------------------------------------------*/ setNodeInfo(failedNodePtr.i).m_heartbeat_cnt= 0; - + setNodeInfo(failedNodePtr.i).m_version = 0; + recompute_version_info(getNodeInfo(failedNodePtr.i).m_type); + CloseComReqConf * const closeCom = (CloseComReqConf *)&signal->theData[0]; closeCom->xxxBlockRef = reference(); @@ -2362,6 +2444,27 @@ CloseComReqConf::SignalLength, JBA); }//Qmgr::sendApiFailReq() +void Qmgr::execAPI_FAILREQ(Signal* signal) +{ + jamEntry(); + NodeRecPtr failedNodePtr; + failedNodePtr.i = signal->theData[0]; + // signal->theData[1] == QMGR_REF + ptrCheckGuard(failedNodePtr, MAX_NODES, nodeRec); + + ndbrequire(getNodeInfo(failedNodePtr.i).getType() != NodeInfo::DB); + + // ignore if api not active + if (failedNodePtr.p->phase != ZAPI_ACTIVE) + return; + + signal->theData[0] = NDB_LE_Disconnected; + signal->theData[1] = failedNodePtr.i; + sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB); + + node_failed(signal, failedNodePtr.i); +} + void Qmgr::execAPI_FAILCONF(Signal* signal) { NodeRecPtr failedNodePtr; @@ -2612,9 +2715,6 @@ case NodeInfo::MGM: compatability_check = ndbCompatible_ndb_mgmt(NDB_VERSION, version); break; - case NodeInfo::REP: - // compatability_check = ndbCompatible_ndb_api(NDB_VERSION, version); - // break; case NodeInfo::DB: case NodeInfo::INVALID: default: @@ -2638,14 +2738,13 @@ } setNodeInfo(apiNodePtr.i).m_version = version; - setNodeInfo(apiNodePtr.i).m_heartbeat_cnt= 0; ApiRegConf * const apiRegConf = (ApiRegConf *)&signal->theData[0]; apiRegConf->qmgrRef = reference(); apiRegConf->apiHeartbeatFrequency = (chbApiDelay / 10); apiRegConf->version = NDB_VERSION; - apiRegConf->nodeState = getNodeState(); + NodeState state= apiRegConf->nodeState = getNodeState(); { NodeRecPtr nodePtr; nodePtr.i = getOwnNodeId(); @@ -2659,13 +2758,17 @@ apiRegConf->nodeState.dynamicId = -dynamicId; } } + NodeVersionInfo info = getNodeVersionInfo(); + apiRegConf->minDbVersion = info.m_type[NodeInfo::DB].m_min_version; apiRegConf->nodeState.m_connected_nodes.assign(c_connectedNodes); - sendSignal(ref, GSN_API_REGCONF, signal, ApiRegConf::SignalLength, JBB); - if ((getNodeState().startLevel == NodeState::SL_STARTED || - getNodeState().getSingleUserMode()) - && apiNodePtr.p->phase == ZAPI_INACTIVE) { + if (apiNodePtr.p->phase == ZAPI_INACTIVE && + (state.startLevel == NodeState::SL_STARTED || + state.getSingleUserMode() || + (state.startLevel == NodeState::SL_STARTING && + state.starting.startPhase >= 100))) + { jam(); /**---------------------------------------------------------------------- * THE API NODE IS REGISTERING. WE WILL ACCEPT IT BY CHANGING STATE AND @@ -2675,6 +2778,36 @@ apiNodePtr.p->blockRef = ref; signal->theData[0] = apiNodePtr.i; sendSignal(CMVMI_REF, GSN_ENABLE_COMORD, signal, 1, JBA); + + recompute_version_info(type, version); + + if (info.m_type[NodeInfo::DB].m_min_version >= NDBD_NODE_VERSION_REP) + { + jam(); + NodeReceiverGroup rg(QMGR, c_clusterNodes); + rg.m_nodes.clear(getOwnNodeId()); + signal->theData[0] = apiNodePtr.i; + signal->theData[1] = version; + sendSignal(rg, GSN_NODE_VERSION_REP, signal, 2, JBB); + } + else + { + Uint32 i = 0; + while((i = c_clusterNodes.find(i + 1)) != NdbNodeBitmask::NotFound) + { + jam(); + if (i == getOwnNodeId()) + continue; + if (getNodeInfo(i).m_version >= NDBD_NODE_VERSION_REP) + { + jam(); + sendSignal(calcQmgrBlockRef(i), GSN_NODE_VERSION_REP, signal, 2,JBB); + } + } + } + + signal->theData[0] = apiNodePtr.i; + EXECUTE_DIRECT(NDBCNTR, GSN_API_START_REP, signal, 1); } return; }//Qmgr::execAPI_REGREQ() @@ -2708,6 +2841,76 @@ ApiVersionConf::SignalLength, JBB); } +void +Qmgr::execNODE_VERSION_REP(Signal* signal) +{ + jamEntry(); + Uint32 nodeId = signal->theData[0]; + Uint32 version = signal->theData[1]; + + if (nodeId < MAX_NODES) + { + jam(); + Uint32 type = getNodeInfo(nodeId).m_type; + setNodeInfo(nodeId).m_version = version; + recompute_version_info(type, version); + } +} + +void +Qmgr::recompute_version_info(Uint32 type, Uint32 version) +{ + NodeVersionInfo& info = setNodeVersionInfo(); + switch(type){ + case NodeInfo::DB: + case NodeInfo::API: + case NodeInfo::MGM: + break; + default: + return; + } + + if (info.m_type[type].m_min_version == 0 || + version < info.m_type[type].m_min_version) + info.m_type[type].m_min_version = version; + if (version > info.m_type[type].m_max_version) + info.m_type[type].m_max_version = version; +} + +void +Qmgr::recompute_version_info(Uint32 type) +{ + switch(type){ + case NodeInfo::DB: + case NodeInfo::API: + case NodeInfo::MGM: + break; + default: + return; + } + + Uint32 min = ~0, max = 0; + Uint32 cnt = type == NodeInfo::DB ? MAX_NDB_NODES : MAX_NODES; + for (Uint32 i = 1; i<cnt; i++) + { + if (getNodeInfo(i).m_type == type) + { + Uint32 version = getNodeInfo(i).m_version; + + if (version) + { + if (version < min) + min = version; + if (version > max) + max = version; + } + } + } + + NodeVersionInfo& info = setNodeVersionInfo(); + info.m_type[type].m_min_version = min == ~(Uint32)0 ? 0 : min; + info.m_type[type].m_max_version = max; +} #if 0 bool @@ -4784,6 +4987,178 @@ } void +Qmgr::execNODE_FAILREP(Signal * signal) +{ + jamEntry(); + // make sure any distributed signals get acknowledged + // destructive of the signal + c_counterMgr.execNODE_FAILREP(signal); +} + +void +Qmgr::execALLOC_NODEID_REQ(Signal * signal) +{ + jamEntry(); + const AllocNodeIdReq * req = (AllocNodeIdReq*)signal->getDataPtr(); + Uint32 senderRef = req->senderRef; + Uint32 nodeId = req->nodeId; + Uint32 nodeType = req->nodeType; + Uint32 error = 0; + + if (refToBlock(senderRef) != QMGR) // request from management server + { + /* master */ + + if (getOwnNodeId() != cpresident) + error = AllocNodeIdRef::NotMaster; + else if (!opAllocNodeIdReq.m_tracker.done()) + error = AllocNodeIdRef::Busy; + else if (c_connectedNodes.get(nodeId)) + error = AllocNodeIdRef::NodeConnected; + + if (error) + { + jam(); + AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->errorCode = error; + ref->masterRef = numberToRef(QMGR, cpresident); + sendSignal(senderRef, GSN_ALLOC_NODEID_REF, signal, + AllocNodeIdRef::SignalLength, JBB); + return; + } + + if (ERROR_INSERTED(934) && nodeId != getOwnNodeId()) + { + CRASH_INSERTION(934); + } + + opAllocNodeIdReq.m_req = *req; + opAllocNodeIdReq.m_error = 0; + opAllocNodeIdReq.m_connectCount = getNodeInfo(refToNode(senderRef)).m_connectCount; + + jam(); + AllocNodeIdReq * req = (AllocNodeIdReq*)signal->getDataPtrSend(); + req->senderRef = reference(); + NodeReceiverGroup rg(QMGR, c_clusterNodes); + RequestTracker & p = opAllocNodeIdReq.m_tracker; + p.init<AllocNodeIdRef>(c_counterMgr, rg, GSN_ALLOC_NODEID_REF, 0); + + sendSignal(rg, GSN_ALLOC_NODEID_REQ, signal, + AllocNodeIdReq::SignalLength, JBB); + return; + } + + /* participant */ + + if (c_connectedNodes.get(nodeId)) + error = AllocNodeIdRef::NodeConnected; + else + { + NodeRecPtr nodePtr; + nodePtr.i = nodeId; + ptrAss(nodePtr, nodeRec); + if (nodeType != getNodeInfo(nodeId).m_type) + error = AllocNodeIdRef::NodeTypeMismatch; + else if (nodePtr.p->failState != NORMAL) + error = AllocNodeIdRef::NodeFailureHandlingNotCompleted; + } + + if (error) + { + AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->errorCode = error; + sendSignal(senderRef, GSN_ALLOC_NODEID_REF, signal, + AllocNodeIdRef::SignalLength, JBB); + return; + } + + AllocNodeIdConf * conf = (AllocNodeIdConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + sendSignal(senderRef, GSN_ALLOC_NODEID_CONF, signal, + AllocNodeIdConf::SignalLength, JBB); +} + +void +Qmgr::execALLOC_NODEID_CONF(Signal * signal) +{ + /* master */ + + jamEntry(); + const AllocNodeIdConf * conf = (AllocNodeIdConf*)signal->getDataPtr(); + opAllocNodeIdReq.m_tracker.reportConf(c_counterMgr, + refToNode(conf->senderRef)); + completeAllocNodeIdReq(signal); +} + + +void +Qmgr::execALLOC_NODEID_REF(Signal * signal) +{ + /* master */ + + jamEntry(); + const AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtr(); + if (ref->errorCode == AllocNodeIdRef::NF_FakeErrorREF) + { + opAllocNodeIdReq.m_tracker.ignoreRef(c_counterMgr, + refToNode(ref->senderRef)); + } + else + { + opAllocNodeIdReq.m_tracker.reportRef(c_counterMgr, + refToNode(ref->senderRef)); + if (opAllocNodeIdReq.m_error == 0) + opAllocNodeIdReq.m_error = ref->errorCode; + } + completeAllocNodeIdReq(signal); +} + +void +Qmgr::completeAllocNodeIdReq(Signal *signal) +{ + /* master */ + + if (!opAllocNodeIdReq.m_tracker.done()) + { + jam(); + return; + } + + if (opAllocNodeIdReq.m_connectCount != + getNodeInfo(refToNode(opAllocNodeIdReq.m_req.senderRef)).m_connectCount) + { + // management server not same version as the original requester + jam(); + return; + } + + if (opAllocNodeIdReq.m_tracker.hasRef()) + { + jam(); + AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtrSend(); + ref->senderRef = reference(); + ref->senderData = opAllocNodeIdReq.m_req.senderData; + ref->nodeId = opAllocNodeIdReq.m_req.nodeId; + ref->errorCode = opAllocNodeIdReq.m_error; + ref->masterRef = numberToRef(QMGR, cpresident); + ndbassert(AllocNodeIdRef::SignalLength == 5); + sendSignal(opAllocNodeIdReq.m_req.senderRef, GSN_ALLOC_NODEID_REF, signal, + AllocNodeIdRef::SignalLength, JBB); + return; + } + jam(); + AllocNodeIdConf * conf = (AllocNodeIdConf*)signal->getDataPtrSend(); + conf->senderRef = reference(); + conf->senderData = opAllocNodeIdReq.m_req.senderData; + conf->nodeId = opAllocNodeIdReq.m_req.nodeId; + ndbassert(AllocNodeIdConf::SignalLength == 3); + sendSignal(opAllocNodeIdReq.m_req.senderRef, GSN_ALLOC_NODEID_CONF, signal, + AllocNodeIdConf::SignalLength, JBB); +} + +void Qmgr::execSTOP_REQ(Signal* signal) { jamEntry(); @@ -4791,6 +5166,7 @@ if (c_stopReq.senderRef) { + jam(); ndbrequire(NdbNodeBitmask::get(c_stopReq.nodes, getOwnNodeId())); StopConf *conf = (StopConf*)signal->getDataPtrSend(); --- 1.13.14.1/ndb/test/ndbapi/testNodeRestart.cpp 2007-01-11 21:02:43 +01:00 +++ 1.38/storage/ndb/test/ndbapi/testNodeRestart.cpp 2007-01-11 21:02:43 +01:00 @@ -698,7 +698,10 @@ do { int tmp = restarter.getRandomNodeOtherNodeGroup(node1, rand()); if (tmp == -1) - break; + { + ctx->stopTest(); + return NDBT_OK; + } node1 = tmp; } while(nodesmask.get(node1)); @@ -878,12 +881,15 @@ HugoOperations hugoOps(*ctx->getTab()); Ndb* pNdb = GETNDB(step); + const int masterNode = restarter.getMasterNodeId(); + int dump[] = { 7090, 20 } ; if (restarter.dumpStateAllNodes(dump, 2)) return NDBT_FAILED; NdbSleep_MilliSleep(3000); - + +retry: if(hugoOps.startTransaction(pNdb) != 0) return NDBT_FAILED; @@ -893,8 +899,14 @@ if (hugoOps.execute_NoCommit(pNdb) != 0) return NDBT_FAILED; - int nodeId; const int node = hugoOps.getTransaction()->getConnectedNodeId(); + if (node != masterNode) + { + hugoOps.closeTransaction(pNdb); + goto retry; + } + + int nodeId; do { nodeId = restarter.getDbNodeId(rand() % restarter.getNumDbNodes()); } while (nodeId == node); @@ -991,10 +1003,170 @@ if (restarter.waitNodesStarted(nodes, 2)) return NDBT_FAILED; } +} + +int +runBug21271(NDBT_Context* ctx, NDBT_Step* step){ + int result = NDBT_OK; + int loops = ctx->getNumLoops(); + int records = ctx->getNumRecords(); + NdbRestarter restarter; + HugoOperations hugoOps(*ctx->getTab()); + Ndb* pNdb = GETNDB(step); + + const int masterNode = restarter.getMasterNodeId(); + const int nodeId = restarter.getRandomNodeSameNodeGroup(masterNode, rand()); + + int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 1 }; + if (restarter.dumpStateOneNode(nodeId, val2, 2)) + return NDBT_FAILED; + + Uint32 tableId = ctx->getTab()->getTableId(); + int dump[] = { DumpStateOrd::LqhErrorInsert5042, 0, 5044 }; + dump[1] = tableId; + + if (restarter.dumpStateOneNode(nodeId, dump, 3)) + return NDBT_FAILED; + + restarter.waitNodesNoStart(&nodeId, 1); + ctx->stopTest(); + + restarter.startNodes(&nodeId, 1); + + if (restarter.waitClusterStarted() != 0) + return NDBT_FAILED; + + return NDBT_OK; + return NDBT_OK; +} + +int +runBug24543(NDBT_Context* ctx, NDBT_Step* step){ + NdbRestarter restarter; + + int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 1 }; + if (restarter.dumpStateAllNodes(val2, 2)) + return NDBT_FAILED; + + int nodes[2]; + nodes[0] = restarter.getMasterNodeId(); + restarter.insertErrorInNode(nodes[0], 934); + + nodes[1] = restarter.getRandomNodeOtherNodeGroup(nodes[0], rand()); + if (nodes[1] == -1) + { + nodes[1] = restarter.getRandomNodeSameNodeGroup(nodes[0], rand()); + } + + restarter.restartOneDbNode(nodes[1], false, true, true); + if (restarter.waitNodesNoStart(nodes, 2)) + return NDBT_FAILED; + + restarter.startNodes(nodes, 2); + if (restarter.waitNodesStarted(nodes, 2)) + { + return NDBT_FAILED; + } + return NDBT_OK; +} + +int runBug25364(NDBT_Context* ctx, NDBT_Step* step){ + int result = NDBT_OK; + NdbRestarter restarter; + Ndb* pNdb = GETNDB(step); + int loops = ctx->getNumLoops(); + + if (restarter.getNumDbNodes() < 4) + return NDBT_OK; + + int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 1 }; + + for (; loops; loops --) + { + int master = restarter.getMasterNodeId(); + int victim = restarter.getRandomNodeOtherNodeGroup(master, rand()); + int second = restarter.getRandomNodeSameNodeGroup(victim, rand()); + + int dump[] = { 935, victim } ; + if (restarter.dumpStateOneNode(master, dump, 2)) + return NDBT_FAILED; + + if (restarter.dumpStateOneNode(master, val2, 2)) + return NDBT_FAILED; + + if (restarter.restartOneDbNode(second, false, true, true)) + return NDBT_FAILED; + + int nodes[2] = { master, second }; + if (restarter.waitNodesNoStart(nodes, 2)) + return NDBT_FAILED; + + restarter.startNodes(nodes, 2); + + if (restarter.waitNodesStarted(nodes, 2)) + return NDBT_FAILED; + } return NDBT_OK; } +int runBug25468(NDBT_Context* ctx, NDBT_Step* step){ + + int result = NDBT_OK; + int loops = ctx->getNumLoops(); + int records = ctx->getNumRecords(); + NdbRestarter restarter; + + for (int i = 0; i<loops; i++) + { + int master = restarter.getMasterNodeId(); + int node1, node2; + switch(i % 5){ + case 0: + node1 = master; + node2 = restarter.getRandomNodeSameNodeGroup(master, rand()); + break; + case 1: + node1 = restarter.getRandomNodeSameNodeGroup(master, rand()); + node2 = master; + break; + case 2: + case 3: + case 4: + node1 = restarter.getRandomNodeOtherNodeGroup(master, rand()); + if (node1 == -1) + node1 = master; + node2 = restarter.getRandomNodeSameNodeGroup(node1, rand()); + break; + } + + ndbout_c("node1: %d node2: %d master: %d", node1, node2, master); + + int val2[] = { DumpStateOrd::CmvmiSetRestartOnErrorInsert, 1 }; + + if (restarter.dumpStateOneNode(node2, val2, 2)) + return NDBT_FAILED; + + if (restarter.insertErrorInNode(node1, 7178)) + return NDBT_FAILED; + + int val1 = 7099; + if (restarter.dumpStateOneNode(master, &val1, 1)) + return NDBT_FAILED; + + if (restarter.waitNodesNoStart(&node2, 1)) + return NDBT_FAILED; + + if (restarter.startAll()) + return NDBT_FAILED; + + if (restarter.waitClusterStarted()) + return NDBT_FAILED; + } + + return NDBT_OK; +} + int runBug25554(NDBT_Context* ctx, NDBT_Step* step){ int result = NDBT_OK; @@ -1358,11 +1530,25 @@ STEP(runBug20185); FINALIZER(runClearTable); } +TESTCASE("Bug24543", "") +{ + INITIALIZER(runBug24543); +} +TESTCASE("Bug21271", + ""){ + INITIALIZER(runLoadTable); + STEP(runBug21271); + STEP(runPkUpdateUntilStopped); + FINALIZER(runClearTable); +} TESTCASE("Bug24717", ""){ INITIALIZER(runBug24717); } TESTCASE("Bug25364", ""){ INITIALIZER(runBug25364); +} +TESTCASE("Bug25468", ""){ + INITIALIZER(runBug25468); } TESTCASE("Bug25554", ""){ INITIALIZER(runBug25554);
| Thread | ||
|---|---|---|
| • bk commit into 5.1 tree (jonas:1.2363) | jonas | 11 Jan |
© 1995-2008 MySQL AB, 2008-2009 Sun Microsystems, Inc.
Page generated in 1.152 sec. using MySQL 5.1.14-beta-log