Commit d3b81c3e authored by jonas@perch.ndb.mysql.com's avatar jonas@perch.ndb.mysql.com
Browse files

ndb - bug#22696 

  Fix handling of multiple redo phases
  - set correct state
  - handle 4 phases, by moving START_FRAGCONF to end of phase instead of beginning...
parent 5af22b0d

storage/ndb/src/kernel/blocks/dblqh/Dblqh.hpp

+7 −12
Original line number Diff line number Diff line
@@ -585,7 +585,6 @@ public: 


    enum ExecSrStatus {

      IDLE = 0,

      ACTIVE_REMOVE_AFTER = 1,

      ACTIVE = 2

    };

    /**
@@ -869,11 +868,6 @@ public: 
     *       heard of.

     */

    Uint8 fragDistributionKey;

    /**

     *       The identity of the next local checkpoint this fragment

     *       should perform.

     */

    Uint8 nextLcp;

   /**

     *       How many local checkpoints does the fragment contain

     */
@@ -2097,10 +2091,6 @@ private: 
  void execEXEC_SRCONF(Signal* signal);

  void execREAD_PSEUDO_REQ(Signal* signal);



  void build_acc(Signal*, Uint32 fragPtrI);

  void execBUILDINDXREF(Signal*signal);

  void execBUILDINDXCONF(Signal*signal);

  

  void execDUMP_STATE_ORD(Signal* signal);

  void execACC_ABORTCONF(Signal* signal);

  void execNODE_FAILREP(Signal* signal);
@@ -2780,7 +2770,13 @@ private: 
/*THIS VARIABLE KEEPS TRACK OF HOW MANY FRAGMENTS THAT PARTICIPATE IN        */

/*EXECUTING THE LOG. IF ZERO WE DON'T NEED TO EXECUTE THE LOG AT ALL.        */

/* ------------------------------------------------------------------------- */

  UintR cnoFragmentsExecSr;

  Uint32 cnoFragmentsExecSr;



  /**

   * This is no of sent GSN_EXEC_FRAGREQ during this log phase

   */

  Uint32 cnoOutstandingExecFragReq;



/* ------------------------------------------------------------------------- */

/*THIS VARIABLE KEEPS TRACK OF WHICH OF THE FIRST TWO RESTART PHASES THAT    */

/*HAVE COMPLETED.                                                            */
@@ -2801,7 +2797,6 @@ private: 
  DLFifoList<Fragrecord> c_lcp_waiting_fragments;  // StartFragReq'ed

  DLFifoList<Fragrecord> c_lcp_restoring_fragments; // Restoring as we speek

  DLFifoList<Fragrecord> c_lcp_complete_fragments;  // Restored

  DLFifoList<Fragrecord> c_redo_complete_fragments; // Redo'ed

  

/* ------------------------------------------------------------------------- */

/*USED DURING SYSTEM RESTART, INDICATES THE OLDEST GCI THAT CAN BE RESTARTED */

storage/ndb/src/kernel/blocks/dblqh/DblqhInit.cpp

+0 −4
Original line number Diff line number Diff line
@@ -168,7 +168,6 @@ Dblqh::Dblqh(Block_context& ctx): 
  c_lcp_waiting_fragments(c_fragment_pool),

  c_lcp_restoring_fragments(c_fragment_pool),

  c_lcp_complete_fragments(c_fragment_pool),

  c_redo_complete_fragments(c_fragment_pool),

  m_commitAckMarkerHash(m_commitAckMarkerPool),

  c_scanTakeOverHash(c_scanRecordPool)

{
@@ -295,9 +294,6 @@ Dblqh::Dblqh(Block_context& ctx): 


  addRecSignal(GSN_READ_PSEUDO_REQ, &Dblqh::execREAD_PSEUDO_REQ);



  addRecSignal(GSN_BUILDINDXREF, &Dblqh::execBUILDINDXREF);

  addRecSignal(GSN_BUILDINDXCONF, &Dblqh::execBUILDINDXCONF);



  addRecSignal(GSN_DEFINE_BACKUP_REF, &Dblqh::execDEFINE_BACKUP_REF);

  addRecSignal(GSN_DEFINE_BACKUP_CONF, &Dblqh::execDEFINE_BACKUP_CONF);

storage/ndb/src/kernel/blocks/dblqh/DblqhMain.cpp

+47 −154
Original line number Diff line number Diff line
@@ -356,7 +356,6 @@ void Dblqh::execCONTINUEB(Signal* signal) 
    break;

  case ZSR_PHASE3_START:

    jam();

    signal->theData[0] = data0;

    srPhase3Start(signal);

    return;

    break;
@@ -428,25 +427,25 @@ void Dblqh::execCONTINUEB(Signal* signal) 
    if (fragptr.i != RNIL)

    {

      jam();

      c_redo_complete_fragments.getPtr(fragptr);

      c_lcp_complete_fragments.getPtr(fragptr);

      signal->theData[0] = fragptr.p->tabRef;

      signal->theData[1] = fragptr.p->fragId;

      sendSignal(DBACC_REF, GSN_EXPANDCHECK2, signal, 2, JBB);

      Ptr<Fragrecord> save = fragptr;









      c_redo_complete_fragments.next(fragptr);









      c_lcp_complete_fragments.next(fragptr);









      signal->theData[0] = ZENABLE_EXPAND_CHECK;









      signal->theData[1] = fragptr.i;









      sendSignal(DBLQH_REF, GSN_CONTINUEB, signal, 2, JBB);	

















      c_redo_complete_fragments.remove(save);









      c_lcp_complete_fragments.remove(save);









      return;









    }









    else









    {









      jam();









      cstartRecReq = 2;









      ndbrequire(c_redo_complete_fragments.isEmpty());









      ndbrequire(c_lcp_complete_fragments.isEmpty());









      StartRecConf * conf = (StartRecConf*)signal->getDataPtrSend();









      conf->startingNodeId = getOwnNodeId();









      sendSignal(cmasterDihBlockref, GSN_START_RECCONF, signal, 








@@ -1121,7 +1120,6 @@ void Dblqh::execLQHFRAGREQ(Signal* signal)







  Uint32 minRowsHigh = req->minRowsHigh;









  Uint32 tschemaVersion = req->schemaVersion;









  Uint32 ttupKeyLength = req->keyLength;









  Uint32 nextLcp = req->nextLCP;









  Uint32 noOfKeyAttr = req->noOfKeyAttr;









  Uint32 noOfCharsets = req->noOfCharsets;









  Uint32 checksumIndicator = req->checksumIndicator;








@@ -1214,7 +1212,6 @@ void Dblqh::execLQHFRAGREQ(Signal* signal)







    fragptr.p->lcpFlag = Fragrecord::LCP_STATE_FALSE;









  }//if









  









  fragptr.p->nextLcp = nextLcp; 









//----------------------------------------------









// For node restarts it is not necessarily zero 









//----------------------------------------------








@@ -8939,6 +8936,9 @@ void Dblqh::storedProcConfScanLab(Signal* signal)







  case Fragrecord::REMOVING:









    jam();









  default:









    jamLine(fragptr.p->fragStatus);









    ndbout_c("fragptr.p->fragStatus: %u",









             fragptr.p->fragStatus);









    ndbrequire(false);









    break;









  }//switch








@@ -14119,6 +14119,8 @@ void Dblqh::execSTART_FRAGREQ(Signal* signal)







  const StartFragReq * const startFragReq = (StartFragReq *)&signal->theData[0];









  jamEntry();

















  printSTART_FRAG_REQ(stdout, signal->getDataPtr(), signal->getLength(), number());

















  tabptr.i = startFragReq->tableId;









  Uint32 fragId = startFragReq->fragId;
















@@ -14141,15 +14143,12 @@ void Dblqh::execSTART_FRAGREQ(Signal* signal)







  if (lcpNo == (MAX_LCP_STORED - 1)) {









    jam();









    fragptr.p->lcpId[lcpNo] = lcpId;









    fragptr.p->nextLcp = 0;









  } else if (lcpNo < (MAX_LCP_STORED - 1)) {









    jam();









    fragptr.p->lcpId[lcpNo] = lcpId;









    fragptr.p->nextLcp = lcpNo + 1;









  } else {









    ndbrequire(lcpNo == ZNIL);









    jam();









    fragptr.p->nextLcp = 0;









  }//if









  fragptr.p->srNoLognodes = noOfLogNodes;









  fragptr.p->logFlag = Fragrecord::STATE_FALSE;








@@ -14181,19 +14180,9 @@ void Dblqh::execSTART_FRAGREQ(Signal* signal)







     */









    c_lcp_complete_fragments.add(fragptr);

















    if(lcpNo == ZNIL)









    {









    signal->theData[0] = tabptr.i;









    signal->theData[1] = fragId;









    sendSignal(DBACC_REF, GSN_EXPANDCHECK2, signal, 2, JBB);









    }

















    if (getNodeState().getNodeRestartInProgress())









    {









      jam();









      fragptr.p->fragStatus = Fragrecord::ACTIVE_CREATION;	









    }

















    c_tup->disk_restart_lcp_id(tabptr.i, fragId, RNIL);









    jamEntry();









    return;








@@ -14395,65 +14384,9 @@ void Dblqh::execSTART_RECCONF(Signal* signal)







    return;









  }

















  c_lcp_complete_fragments.first(fragptr);









  build_acc(signal, fragptr.i);









  return;









}//Dblqh::execSTART_RECCONF()

















void









Dblqh::build_acc(Signal* signal, Uint32 fragPtrI)









{









  fragptr.i = fragPtrI;









  while(fragptr.i != RNIL)









  {









    c_lcp_complete_fragments.getPtr(fragptr);









    tabptr.i = fragptr.p->tabRef;









    ptrCheckGuard(tabptr, ctabrecFileSize, tablerec);









    









    if(true || fragptr.i != tabptr.p->fragrec[0])









    {









      // Only need to send 1 build per table, TUP will rebuild all









      fragptr.i = fragptr.p->nextList;









      continue;









    }

















    BuildIndxReq* const req = (BuildIndxReq*)signal->getDataPtrSend();









    req->setUserRef(reference());









    req->setConnectionPtr(fragptr.i);









    req->setRequestType(BuildIndxReq::RT_SYSTEMRESTART);









    req->setBuildId(0);   // not used









    req->setBuildKey(0);  // not used









    req->setIndexType(RNIL);









    req->setIndexId(RNIL);









    req->setTableId(tabptr.i);









    req->setParallelism(0);

















    sendSignal(DBTUP_REF, GSN_BUILDINDXREQ, signal, 









	       BuildIndxReq::SignalLength, JBB);









    return;









  }

















  startExecSr(signal);









}

















void









Dblqh::execBUILDINDXREF(Signal* signal)









{









  ndbrequire(false);









}

















void









Dblqh::execBUILDINDXCONF(Signal* signal)









{









  BuildIndxConf* conf = (BuildIndxConf*)signal->getDataPtrSend();    









  Uint32 fragPtrI = conf->getConnectionPtr();

















  fragptr.i = fragPtrI;









  c_fragment_pool.getPtr(fragptr);









  infoEvent("LQH: primary key index %u rebuild done", fragptr.p->tabRef);









  build_acc(signal, fragptr.p->nextList);









}

















/* ***************> */









/*  START_RECREF  > */









/* ***************> */








@@ -14472,9 +14405,9 @@ void Dblqh::execSTART_EXEC_SR(Signal* signal)







  fragptr.i = signal->theData[0];









  Uint32 next = RNIL;









  









  if (fragptr.i == RNIL) {









  if (fragptr.i == RNIL) 









  {









    jam();









    ndbrequire(cnoOfNodes < MAX_NDB_NODES);









    /* ----------------------------------------------------------------------









     *    NO MORE FRAGMENTS TO START EXECUTING THE LOG ON.









     *    SEND EXEC_SRREQ TO ALL LQH TO INDICATE THAT THIS NODE WILL 








@@ -14490,10 +14423,15 @@ void Dblqh::execSTART_EXEC_SR(Signal* signal)







  } else {









    jam();









    c_lcp_complete_fragments.getPtr(fragptr);









    if (fragptr.p->srNoLognodes > csrPhasesCompleted) {









    next = fragptr.p->nextList;

















    if (fragptr.p->srNoLognodes > csrPhasesCompleted) 









    {









      jam();









      cnoOutstandingExecFragReq++;









      









      Uint32 index = csrPhasesCompleted;









      arrGuard(index, 4);









      arrGuard(index, MAX_LOG_EXEC);









      BlockReference ref = calcLqhBlockRef(fragptr.p->srLqhLognode[index]);









      fragptr.p->srStatus = Fragrecord::SS_STARTED;
















@@ -14512,34 +14450,7 @@ void Dblqh::execSTART_EXEC_SR(Signal* signal)







      sendSignal(ref, GSN_EXEC_FRAGREQ, signal, 









		 ExecFragReq::SignalLength, JBB);

















      next = fragptr.p->nextList;









    } else {









      jam();









      /* --------------------------------------------------------------------









       *  THIS FRAGMENT IS NOW FINISHED WITH THE SYSTEM RESTART. IT DOES 









       *  NOT NEED TO PARTICIPATE IN ANY MORE PHASES. REMOVE IT FROM THE 









       *  LIST OF COMPLETED FRAGMENTS TO EXECUTE THE LOG ON.









       *  ALSO SEND START_FRAGCONF TO DIH AND SET THE STATE TO ACTIVE ON THE









       *  FRAGMENT.









       * ------------------------------------------------------------------- */









      next = fragptr.p->nextList;









      c_lcp_complete_fragments.remove(fragptr);









      c_redo_complete_fragments.add(fragptr);









      









      if (!getNodeState().getNodeRestartInProgress())









      {









	fragptr.p->logFlag = Fragrecord::STATE_TRUE;









	fragptr.p->fragStatus = Fragrecord::FSACTIVE;









      } 









      else









      {	









	fragptr.p->fragStatus = Fragrecord::ACTIVE_CREATION;	









    }









      signal->theData[0] = fragptr.p->srUserptr;









      signal->theData[1] = cownNodeid;









      sendSignal(fragptr.p->srBlockref, GSN_START_FRAGCONF, signal, 2, JBB);









      









    } //if









    signal->theData[0] = next;









    sendSignal(cownref, GSN_START_EXEC_SR, signal, 1, JBB);









  }//if








@@ -14560,24 +14471,8 @@ void Dblqh::execEXEC_FRAGREQ(Signal* signal)







  tabptr.i = execFragReq->tableId;









  Uint32 fragId = execFragReq->fragId;









  ptrCheckGuard(tabptr, ctabrecFileSize, tablerec);









  if (!getFragmentrec(signal, fragId)) {









    jam();









    if (!insertFragrec(signal, fragId)) {









      jam();









      sendExecFragRefLab(signal);









      return;









    }//if    









    initFragrec(signal, tabptr.i, fragId, ZLOG_NODE);









    fragptr.p->execSrStatus = Fragrecord::ACTIVE_REMOVE_AFTER;









  } else {









    jam();









    if (fragptr.p->execSrStatus == Fragrecord::ACTIVE_REMOVE_AFTER) {









      jam();









      fragptr.p->execSrStatus = Fragrecord::ACTIVE_REMOVE_AFTER;









    } else {









      jam();









    }//if









  }//if









  ndbrequire(getFragmentrec(signal, fragId));

















  ndbrequire(fragptr.p->execSrNoReplicas < 4);









  fragptr.p->execSrBlockref[fragptr.p->execSrNoReplicas] = execFragReq->userRef;









  fragptr.p->execSrUserptr[fragptr.p->execSrNoReplicas] = execFragReq->userPtr;








@@ -14610,6 +14505,21 @@ void Dblqh::execEXEC_FRAGCONF(Signal* signal)







  fragptr.i = signal->theData[0];









  c_fragment_pool.getPtr(fragptr);









  fragptr.p->srStatus = Fragrecord::SS_COMPLETED;

















  ndbrequire(cnoOutstandingExecFragReq);









  cnoOutstandingExecFragReq--;









  if (fragptr.p->srNoLognodes == csrPhasesCompleted + 1)









  {









    jam();









    









    fragptr.p->logFlag = Fragrecord::STATE_TRUE;









    fragptr.p->fragStatus = Fragrecord::FSACTIVE;









    









    signal->theData[0] = fragptr.p->srUserptr;









    signal->theData[1] = cownNodeid;









    sendSignal(fragptr.p->srBlockref, GSN_START_FRAGCONF, signal, 2, JBB);









  }









  









  return;









}//Dblqh::execEXEC_FRAGCONF()
















@@ -14633,6 +14543,7 @@ void Dblqh::execEXEC_SRCONF(Signal* signal)







  Uint32 nodeId = signal->theData[0];









  arrGuard(nodeId, MAX_NDB_NODES);









  m_sr_exec_sr_conf.set(nodeId);

















  if (!m_sr_nodes.equal(m_sr_exec_sr_conf))









  {









    jam();








@@ -14653,16 +14564,8 @@ void Dblqh::execEXEC_SRCONF(Signal* signal)







   *  NOW CHECK IF ALL FRAGMENTS IN THIS PHASE HAVE COMPLETED. IF SO START THE









   *  NEXT PHASE.









   * ----------------------------------------------------------------------- */









  c_lcp_complete_fragments.first(fragptr);









  while (fragptr.i != RNIL)









  {









    jam();









    if(fragptr.p->srStatus != Fragrecord::SS_COMPLETED)









    {









      return;









    }









    c_lcp_complete_fragments.next(fragptr);









  } 









  ndbrequire(cnoOutstandingExecFragReq == 0);

















  execSrCompletedLab(signal);









  return;









}//Dblqh::execEXEC_SRCONF()








@@ -14718,6 +14621,7 @@ void Dblqh::execSrCompletedLab(Signal* signal)







     *   THERE ARE YET MORE PHASES TO RESTART.









     *   WE MUST INITIALISE DATA FOR NEXT PHASE AND SEND START SIGNAL.









     * --------------------------------------------------------------------- */









    csrPhaseStarted = ZSR_PHASE1_COMPLETED; // Set correct state first...









    startExecSr(signal);









  }//if









  return;








@@ -14791,7 +14695,8 @@ void Dblqh::srPhase3Start(Signal* signal)







  UintR tsrPhaseStarted;









  









  jamEntry();









  tsrPhaseStarted = signal->theData[0];

















  tsrPhaseStarted = signal->theData[1];









  if (csrPhaseStarted == ZSR_NO_PHASE_STARTED) {









    jam();









    csrPhaseStarted = tsrPhaseStarted;








@@ -15968,18 +15873,6 @@ void Dblqh::sendExecConf(Signal* signal)







        sendSignal(fragptr.p->execSrBlockref[i], GSN_EXEC_FRAGCONF, 









		   signal, 1, JBB);









      }//for









      if (fragptr.p->execSrStatus == Fragrecord::ACTIVE) {









        jam();









        fragptr.p->execSrStatus = Fragrecord::IDLE;









      } else {









        ndbrequire(fragptr.p->execSrStatus == Fragrecord::ACTIVE_REMOVE_AFTER);









        jam();









        Uint32 fragId = fragptr.p->fragId;









        tabptr.i = fragptr.p->tabRef;









        ptrCheckGuard(tabptr, ctabrecFileSize, tablerec);









	c_lcp_complete_fragments.remove(fragptr);









        deleteFragrec(fragId);









      }//if









      fragptr.p->execSrNoReplicas = 0;









    }//if









    loopCount++;








@@ -16259,7 +16152,7 @@ void Dblqh::srFourthComp(Signal* signal)







    if(cstartType == NodeState::ST_SYSTEM_RESTART)









    {









      jam();









      if (c_redo_complete_fragments.first(fragptr))









      if (c_lcp_complete_fragments.first(fragptr))









      {









	jam();









        signal->theData[0] = ZENABLE_EXPAND_CHECK;








@@ -17367,7 +17260,6 @@ void Dblqh::initFragrec(Signal* signal,







  fragptr.p->maxGciInLcp = 0;









  fragptr.p->copyFragState = ZIDLE;









  fragptr.p->newestGci = cnewestGci;









  fragptr.p->nextLcp = 0;









  fragptr.p->tabRef = tableId;









  fragptr.p->fragId = fragId;









  fragptr.p->srStatus = Fragrecord::SS_IDLE;








@@ -18456,6 +18348,7 @@ void Dblqh::sendLqhTransconf(Signal* signal, LqhTransConf::OperationStatus stat)







void Dblqh::startExecSr(Signal* signal) 









{









  cnoFragmentsExecSr = 0;









  cnoOutstandingExecFragReq = 0;









  c_lcp_complete_fragments.first(fragptr);









  signal->theData[0] = fragptr.i;









  sendSignal(cownref, GSN_START_EXEC_SR, signal, 1, JBB);

























storage/ndb/test/ndbapi/testSystemRestart.cpp



+39
−2






























Original line number
Diff line number
Diff line







@@ -1501,6 +1501,38 @@ int runSR_DD_2(NDBT_Context* ctx, NDBT_Step* step)







  return result;









}



















int runBug22696(NDBT_Context* ctx, NDBT_Step* step)









{









  Ndb* pNdb = GETNDB(step);









  int result = NDBT_OK;









  Uint32 loops = ctx->getNumLoops();









  Uint32 rows = ctx->getNumRecords();









  NdbRestarter restarter;









  HugoTransactions hugoTrans(*ctx->getTab());



















  Uint32 i = 0;









  while(i<=loops && result != NDBT_FAILED)









  {









    for (Uint32 j = 0; j<10 && result != NDBT_FAILED; j++)









      CHECK(hugoTrans.scanUpdateRecords(pNdb, rows) == 0);









    









    CHECK(restarter.restartAll(false, true, i > 0 ? true : false) == 0);









    CHECK(restarter.waitClusterNoStart() == 0);









    CHECK(restarter.insertErrorInAllNodes(7072) == 0);









    CHECK(restarter.startAll() == 0);









    CHECK(restarter.waitClusterStarted() == 0);



















    i++;









    if (i < loops)









    {









      NdbSleep_SecSleep(5); // Wait for a few gcp









    }









  }









  









  ctx->stopTest();  









  return result;









}



















int 









runBug27434(NDBT_Context* ctx, NDBT_Step* step)









{








@@ -1813,8 +1845,13 @@ TESTCASE("Bug28770",







  STEP(runBug28770);









  FINALIZER(runClearTable);









}





























TESTCASE("Bug22696", "")









{









  INITIALIZER(runWaitStarted);









  INITIALIZER(runLoadTable);









  INITIALIZER(runBug22696);









  FINALIZER(runClearTable);









}









NDBT_TESTSUITE_END(testSystemRestart);



















int main(int argc, const char** argv){
































storage/ndb/test/run-test/daily-basic-tests.txt



+3
−0






























Original line number
Diff line number
Diff line







@@ -1042,4 +1042,7 @@ max-time: 300







cmd: test_event









args: -n Bug31701 T1



















max-time: 300









cmd: testSystemRestart









args: -n Bug22696 T1