开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
NdbcntrMain.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：76k
源码类别：

MySQL数据库

开发平台：

Visual C++

NdbcntrMain.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #define NDBCNTR_C
  18. #include "Ndbcntr.hpp"
  20. #include <ndb_limits.h>
  21. #include <ndb_version.h>
  22. #include <SimpleProperties.hpp>
  23. #include <signaldata/DictTabInfo.hpp>
  24. #include <signaldata/CreateTable.hpp>
  25. #include <signaldata/ReadNodesConf.hpp>
  26. #include <signaldata/NodeFailRep.hpp>
  27. #include <signaldata/TcKeyReq.hpp>
  28. #include <signaldata/TcKeyConf.hpp>
  29. #include <signaldata/EventReport.hpp>
  30. #include <signaldata/NodeStateSignalData.hpp>
  31. #include <signaldata/StopPerm.hpp>
  32. #include <signaldata/StopMe.hpp>
  33. #include <signaldata/WaitGCP.hpp>
  34. #include <signaldata/CheckNodeGroups.hpp>
  35. #include <signaldata/StartOrd.hpp>
  36. #include <signaldata/AbortAll.hpp>
  37. #include <signaldata/SystemError.hpp>
  38. #include <signaldata/NdbSttor.hpp>
  39. #include <signaldata/CntrStart.hpp>
  40. #include <signaldata/DumpStateOrd.hpp>
  42. #include <signaldata/FsRemoveReq.hpp>
  43. #include <signaldata/ReadConfig.hpp>
  45. #include <AttributeHeader.hpp>
  46. #include <Configuration.hpp>
  47. #include <DebuggerNames.hpp>
  49. #include <NdbOut.hpp>
  50. #include <NdbTick.h>
  52. /**
  53.  * ALL_BLOCKS Used during start phases and while changing node state
  54.  *
  55.  * NDBFS_REF Has to be before NDBCNTR_REF (due to "ndb -i" stuff)
  56.  */
  57. struct BlockInfo {
  58.   BlockReference Ref; // BlockReference
  59.   Uint32 NextSP;            // Next start phase
  60.   Uint32 ErrorInsertStart;
  61.   Uint32 ErrorInsertStop;
  62. };
  64. static BlockInfo ALL_BLOCKS[] = { 
  65.   { DBTC_REF,    1 ,  8000,  8035 },
  66.   { DBDIH_REF,   1 ,  7000,  7173 },
  67.   { DBLQH_REF,   1 ,  5000,  5030 },
  68.   { DBACC_REF,   1 ,  3000,  3999 },
  69.   { DBTUP_REF,   1 ,  4000,  4007 },
  70.   { DBDICT_REF,  1 ,  6000,  6003 },
  71.   { NDBFS_REF,   0 ,  2000,  2999 },
  72.   { NDBCNTR_REF, 0 ,  1000,  1999 },
  73.   { QMGR_REF,    1 ,     1,   999 },
  74.   { CMVMI_REF,   1 ,  9000,  9999 },
  75.   { TRIX_REF,    1 ,     0,     0 },
  76.   { BACKUP_REF,  1 , 10000, 10999 },
  77.   { DBUTIL_REF,  1 , 11000, 11999 },
  78.   { SUMA_REF,    1 , 13000, 13999 },
  79.   { DBTUX_REF,   1 , 12000, 12999 }
  80. };
  82. static const Uint32 ALL_BLOCKS_SZ = sizeof(ALL_BLOCKS)/sizeof(BlockInfo);
  84. /*******************************/
  85. /*  CONTINUEB                  */
  86. /*******************************/
  87. void Ndbcntr::execCONTINUEB(Signal* signal) 
  88. {
  89.   jamEntry();
  90.   UintR Ttemp1 = signal->theData[0];
  91.   switch (Ttemp1) {
  92.   case ZSTARTUP:{
  93.     if(getNodeState().startLevel == NodeState::SL_STARTED){
  94.       jam();
  95.       return;
  96.     }
  97.     
  98.     if(cmasterNodeId == getOwnNodeId() && c_start.m_starting.isclear()){
  99.       jam();
  100.       trySystemRestart(signal);
  101.       // Fall-through
  102.     }
  103.     
  104.     Uint64 now = NdbTick_CurrentMillisecond();
  105.     if(now > c_start.m_startFailureTimeout)
  106.     {
  107.       jam();
  108.       Uint32 to_3= 0;
  109.       const ndb_mgm_configuration_iterator * p = 
  110. theConfiguration.getOwnConfigIterator();
  111.       ndb_mgm_get_int_parameter(p, CFG_DB_START_FAILURE_TIMEOUT, &to_3);
  112.       BaseString tmp;
  113.       tmp.append("Shutting down node as total restart time exceeds "
  114.  " StartFailureTimeout as set in config file ");
  115.       if(to_3 == 0)
  116. tmp.append(" 0 (inifinite)");
  117.       else
  118. tmp.appfmt(" %d", to_3);
  119.       
  120.       progError(__LINE__, ERR_SYSTEM_ERROR, tmp.c_str());
  121.     }
  122.     
  123.     signal->theData[0] = ZSTARTUP;
  124.     sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 1);
  125.     break;
  126.   }
  127.   case ZSHUTDOWN:
  128.     jam();
  129.     c_stopRec.checkTimeout(signal);
  130.     break;
  131.   default:
  132.     jam();
  133.     systemErrorLab(signal);
  134.     return;
  135.     break;
  136.   }//switch
  137. }//Ndbcntr::execCONTINUEB()
  139. /*******************************/
  140. /*  SYSTEM_ERROR               */
  141. /*******************************/
  142. void Ndbcntr::execSYSTEM_ERROR(Signal* signal) 
  143. {
  144.   const SystemError * const sysErr = (SystemError *)signal->getDataPtr();
  145.   char buf[100];
  146.   int killingNode = refToNode(sysErr->errorRef);
  147.   Uint32 data1 = sysErr->data1;
  148.   
  149.   jamEntry();
  150.   switch (sysErr->errorCode){
  151.   case SystemError::StartInProgressError:    
  152.     BaseString::snprintf(buf, sizeof(buf), 
  153.      "Node %d killed this node because "
  154.      "master start in progress error",     
  155.      killingNode);
  156.     break;
  158.   case SystemError::GCPStopDetected:
  159.     BaseString::snprintf(buf, sizeof(buf), 
  160.      "Node %d killed this node because "
  161.      "GCP stop was detected",     
  162.      killingNode);
  163.     break;
  165.   case SystemError::ScanfragTimeout:
  166.     BaseString::snprintf(buf, sizeof(buf), 
  167.      "Node %d killed this node because "
  168.      "a fragment scan timed out and could not be stopped",     
  169.      killingNode);
  170.     break;
  172.   case SystemError::ScanfragStateError:
  173.     BaseString::snprintf(buf, sizeof(buf), 
  174.      "Node %d killed this node because "
  175.      "the state of a fragment scan was out of sync.",     
  176.      killingNode);
  177.     break;
  179.   case SystemError::CopyFragRefError:
  180.     BaseString::snprintf(buf, sizeof(buf), 
  181.      "Node %d killed this node because "
  182.      "it could not copy a fragment during node restart. "
  183.      "Copy fragment error code: %u.",
  184.      killingNode, data1);
  185.     break;
  187.   default:
  188.     BaseString::snprintf(buf, sizeof(buf), "System error %d, "
  189.      " this node was killed by node %d", 
  190.      sysErr->errorCode, killingNode);
  191.     break;
  192.   }
  194.   progError(__LINE__, 
  195.     ERR_SYSTEM_ERROR,
  196.     buf);
  197.   return;
  198. }//Ndbcntr::execSYSTEM_ERROR()
  200. void Ndbcntr::execSTTOR(Signal* signal) 
  201. {
  202.   jamEntry();
  203.   cstartPhase = signal->theData[1];
  205.   NodeState newState(NodeState::SL_STARTING, cstartPhase, 
  206.      (NodeState::StartType)ctypeOfStart);
  207.   updateNodeState(signal, newState);
  208.   
  209.   cndbBlocksCount = 0;
  210.   cinternalStartphase = cstartPhase - 1;
  212.   switch (cstartPhase) {
  213.   case 0:
  214.     if(theConfiguration.getInitialStart()){
  215.       jam();
  216.       c_fsRemoveCount = 0;
  217.       clearFilesystem(signal);
  218.       return;
  219.     }
  220.     sendSttorry(signal);
  221.     break;
  222.   case ZSTART_PHASE_1:
  223.     jam();
  224.     startPhase1Lab(signal);
  225.     break;
  226.   case ZSTART_PHASE_2:
  227.     jam();
  228.     startPhase2Lab(signal);
  229.     break;
  230.   case ZSTART_PHASE_3:
  231.     jam();
  232.     startPhase3Lab(signal);
  233.     break;
  234.   case ZSTART_PHASE_4:
  235.     jam();
  236.     startPhase4Lab(signal);
  237.     break;
  238.   case ZSTART_PHASE_5:
  239.     jam();
  240.     startPhase5Lab(signal);
  241.     break;
  242.   case 6:
  243.     jam();
  244.     getNodeGroup(signal);
  245.     // Fall through
  246.     break;
  247.   case ZSTART_PHASE_8:
  248.     jam();
  249.     startPhase8Lab(signal);
  250.     break;
  251.   case ZSTART_PHASE_9:
  252.     jam();
  253.     startPhase9Lab(signal);
  254.     break;
  255.   default:
  256.     jam();
  257.     sendSttorry(signal);
  258.     break;
  259.   }//switch
  260. }//Ndbcntr::execSTTOR()
  262. void
  263. Ndbcntr::getNodeGroup(Signal* signal){
  264.   jam();
  265.   CheckNodeGroups * sd = (CheckNodeGroups*)signal->getDataPtrSend();
  266.   sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::GetNodeGroup;
  267.   EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal, 
  268.  CheckNodeGroups::SignalLength);
  269.   jamEntry();
  270.   c_nodeGroup = sd->output;
  271.   sendSttorry(signal);
  272. }
  274. /*******************************/
  275. /*  NDB_STTORRY                */
  276. /*******************************/
  277. void Ndbcntr::execNDB_STTORRY(Signal* signal) 
  278. {
  279.   jamEntry();
  280.   switch (cstartPhase) {
  281.   case ZSTART_PHASE_2:
  282.     jam();
  283.     ph2GLab(signal);
  284.     return;
  285.     break;
  286.   case ZSTART_PHASE_3:
  287.     jam();
  288.     ph3ALab(signal);
  289.     return;
  290.     break;
  291.   case ZSTART_PHASE_4:
  292.     jam();
  293.     ph4BLab(signal);
  294.     return;
  295.     break;
  296.   case ZSTART_PHASE_5:
  297.     jam();
  298.     ph5ALab(signal);
  299.     return;
  300.     break;
  301.   case ZSTART_PHASE_6:
  302.     jam();
  303.     ph6ALab(signal);
  304.     return;
  305.     break;
  306.   case ZSTART_PHASE_7:
  307.     jam();
  308.     ph6BLab(signal);
  309.     return;
  310.     break;
  311.   case ZSTART_PHASE_8:
  312.     jam();
  313.     ph7ALab(signal);
  314.     return;
  315.     break;
  316.   case ZSTART_PHASE_9:
  317.     jam();
  318.     ph8ALab(signal);
  319.     return;
  320.     break;
  321.   default:
  322.     jam();
  323.     systemErrorLab(signal);
  324.     return;
  325.     break;
  326.   }//switch
  327. }//Ndbcntr::execNDB_STTORRY()
  329. void Ndbcntr::startPhase1Lab(Signal* signal) 
  330. {
  331.   jamEntry();
  333.   initData(signal);
  335.   cdynamicNodeId = 0;
  337.   NdbBlocksRecPtr ndbBlocksPtr;
  338.   ndbBlocksPtr.i = 0;
  339.   ptrAss(ndbBlocksPtr, ndbBlocksRec);
  340.   ndbBlocksPtr.p->blockref = DBLQH_REF;
  341.   ndbBlocksPtr.i = 1;
  342.   ptrAss(ndbBlocksPtr, ndbBlocksRec);
  343.   ndbBlocksPtr.p->blockref = DBDICT_REF;
  344.   ndbBlocksPtr.i = 2;
  345.   ptrAss(ndbBlocksPtr, ndbBlocksRec);
  346.   ndbBlocksPtr.p->blockref = DBTUP_REF;
  347.   ndbBlocksPtr.i = 3;
  348.   ptrAss(ndbBlocksPtr, ndbBlocksRec);
  349.   ndbBlocksPtr.p->blockref = DBACC_REF;
  350.   ndbBlocksPtr.i = 4;
  351.   ptrAss(ndbBlocksPtr, ndbBlocksRec);
  352.   ndbBlocksPtr.p->blockref = DBTC_REF;
  353.   ndbBlocksPtr.i = 5;
  354.   ptrAss(ndbBlocksPtr, ndbBlocksRec);
  355.   ndbBlocksPtr.p->blockref = DBDIH_REF;
  356.   sendSttorry(signal);
  357.   return;
  358. }
  360. void Ndbcntr::execREAD_NODESREF(Signal* signal) 
  361. {
  362.   jamEntry();
  363.   systemErrorLab(signal);
  364.   return;
  365. }//Ndbcntr::execREAD_NODESREF()
  368. /*******************************/
  369. /*  NDB_STARTREF               */
  370. /*******************************/
  371. void Ndbcntr::execNDB_STARTREF(Signal* signal) 
  372. {
  373.   jamEntry();
  374.   systemErrorLab(signal);
  375.   return;
  376. }//Ndbcntr::execNDB_STARTREF()
  378. /*******************************/
  379. /*  STTOR                      */
  380. /*******************************/
  381. void Ndbcntr::startPhase2Lab(Signal* signal) 
  382. {
  383.   c_start.m_lastGci = 0;
  384.   c_start.m_lastGciNodeId = getOwnNodeId();
  385.   
  386.   signal->theData[0] = reference();
  387.   sendSignal(DBDIH_REF, GSN_DIH_RESTARTREQ, signal, 1, JBB);
  388.   return;
  389. }//Ndbcntr::startPhase2Lab()
  391. /*******************************/
  392. /*  DIH_RESTARTCONF            */
  393. /*******************************/
  394. void Ndbcntr::execDIH_RESTARTCONF(Signal* signal) 
  395. {
  396.   jamEntry();
  397.   //cmasterDihId = signal->theData[0];
  398.   c_start.m_lastGci = signal->theData[1];
  399.   ctypeOfStart = NodeState::ST_SYSTEM_RESTART;
  400.   ph2ALab(signal);
  401.   return;
  402. }//Ndbcntr::execDIH_RESTARTCONF()
  404. /*******************************/
  405. /*  DIH_RESTARTREF             */
  406. /*******************************/
  407. void Ndbcntr::execDIH_RESTARTREF(Signal* signal) 
  408. {
  409.   jamEntry();
  410.   ctypeOfStart = NodeState::ST_INITIAL_START;
  411.   ph2ALab(signal);
  412.   return;
  413. }//Ndbcntr::execDIH_RESTARTREF()
  415. void Ndbcntr::ph2ALab(Signal* signal) 
  416. {
  417.   /******************************/
  418.   /* request configured nodes   */
  419.   /* from QMGR                  */
  420.   /*  READ_NODESREQ             */
  421.   /******************************/
  422.   signal->theData[0] = reference();
  423.   sendSignal(QMGR_REF, GSN_READ_NODESREQ, signal, 1, JBB);
  424.   return;
  425. }//Ndbcntr::ph2ALab()
  427. inline
  428. Uint64
  429. setTimeout(Uint64 time, Uint32 timeoutValue){
  430.   if(timeoutValue == 0)
  431.     return ~(Uint64)0;
  432.   return time + timeoutValue;
  433. }
  435. /*******************************/
  436. /*  READ_NODESCONF             */
  437. /*******************************/
  438. void Ndbcntr::execREAD_NODESCONF(Signal* signal) 
  439. {
  440.   jamEntry();
  441.   const ReadNodesConf * readNodes = (ReadNodesConf *)&signal->theData[0];
  443.   cmasterNodeId = readNodes->masterNodeId;
  444.   cdynamicNodeId = readNodes->ndynamicId;
  446.   /**
  447.    * All defined nodes...
  448.    */
  449.   c_allDefinedNodes.assign(NdbNodeBitmask::Size, readNodes->allNodes);
  450.   c_clusterNodes.assign(NdbNodeBitmask::Size, readNodes->clusterNodes);
  452.   Uint32 to_1 = 30000;
  453.   Uint32 to_2 = 0;
  454.   Uint32 to_3 = 0;
  456.   const ndb_mgm_configuration_iterator * p = 
  457.     theConfiguration.getOwnConfigIterator();
  458.   
  459.   ndbrequire(p != 0);
  460.   ndb_mgm_get_int_parameter(p, CFG_DB_START_PARTIAL_TIMEOUT, &to_1);
  461.   ndb_mgm_get_int_parameter(p, CFG_DB_START_PARTITION_TIMEOUT, &to_2);
  462.   ndb_mgm_get_int_parameter(p, CFG_DB_START_FAILURE_TIMEOUT, &to_3);
  463.   
  464.   c_start.m_startTime = NdbTick_CurrentMillisecond();
  465.   c_start.m_startPartialTimeout = setTimeout(c_start.m_startTime, to_1);
  466.   c_start.m_startPartitionedTimeout = setTimeout(c_start.m_startTime, to_2);
  467.   c_start.m_startFailureTimeout = setTimeout(c_start.m_startTime, to_3);
  468.   
  469.   UpgradeStartup::sendCmAppChg(* this, signal, 0); // ADD
  470.   
  471.   sendCntrStartReq(signal);
  473.   signal->theData[0] = ZSTARTUP;
  474.   sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 1);
  475.   
  476.   return;
  477. }
  479. void
  480. Ndbcntr::execCM_ADD_REP(Signal* signal){
  481.   jamEntry();
  482.   c_clusterNodes.set(signal->theData[0]);
  483. }
  485. void
  486. Ndbcntr::sendCntrStartReq(Signal * signal){
  487.   jamEntry();
  489.   CntrStartReq * req = (CntrStartReq*)signal->getDataPtrSend();
  490.   req->startType = ctypeOfStart;
  491.   req->lastGci = c_start.m_lastGci;
  492.   req->nodeId = getOwnNodeId();
  493.   sendSignal(calcNdbCntrBlockRef(cmasterNodeId), GSN_CNTR_START_REQ,
  494.      signal, CntrStartReq::SignalLength, JBB);
  495. }
  497. void
  498. Ndbcntr::execCNTR_START_REF(Signal * signal){
  499.   jamEntry();
  500.   const CntrStartRef * ref = (CntrStartRef*)signal->getDataPtr();
  502.   switch(ref->errorCode){
  503.   case CntrStartRef::NotMaster:
  504.     jam();
  505.     cmasterNodeId = ref->masterNodeId;
  506.     sendCntrStartReq(signal);
  507.     return;
  508.   }
  509.   ndbrequire(false);
  510. }
  512. void
  513. Ndbcntr::StartRecord::reset(){
  514.   m_starting.clear();
  515.   m_waiting.clear();
  516.   m_withLog.clear();
  517.   m_withoutLog.clear();
  518.   m_lastGci = m_lastGciNodeId = 0;
  519.   m_startPartialTimeout = ~0;
  520.   m_startPartitionedTimeout = ~0;
  521.   m_startFailureTimeout = ~0;
  522.   
  523.   m_logNodesCount = 0;
  524. }
  526. void
  527. Ndbcntr::execCNTR_START_CONF(Signal * signal){
  528.   jamEntry();
  529.   const CntrStartConf * conf = (CntrStartConf*)signal->getDataPtr();
  531.   cnoStartNodes = conf->noStartNodes;
  532.   ctypeOfStart = (NodeState::StartType)conf->startType;
  533.   c_start.m_lastGci = conf->startGci;
  534.   cmasterNodeId = conf->masterNodeId;
  535.   NdbNodeBitmask tmp; 
  536.   tmp.assign(NdbNodeBitmask::Size, conf->startedNodes);
  537.   c_startedNodes.bitOR(tmp);
  538.   c_start.m_starting.assign(NdbNodeBitmask::Size, conf->startingNodes);
  539.   ph2GLab(signal);
  541.   UpgradeStartup::sendCmAppChg(* this, signal, 2); //START
  542. }
  544. /**
  545.  * Tried with parallell nr, but it crashed in DIH
  546.  * so I turned it off, as I don't want to debug DIH now...
  547.  * Jonas 19/11-03
  548.  *
  549.  * After trying for 2 hours, I gave up.
  550.  * DIH is not designed to support it, and
  551.  * it requires quite of lot of changes to
  552.  * make it work
  553.  * Jonas 5/12-03
  554.  */
  555. #define PARALLELL_NR 0
  557. #if PARALLELL_NR
  558. const bool parallellNR = true;
  559. #else
  560. const bool parallellNR = false;
  561. #endif
  563. void
  564. Ndbcntr::execCNTR_START_REP(Signal* signal){
  565.   jamEntry();
  566.   Uint32 nodeId = signal->theData[0];
  567.   c_startedNodes.set(nodeId);
  568.   c_start.m_starting.clear(nodeId);
  569.   
  570.   if(!c_start.m_starting.isclear()){
  571.     jam();
  572.     return;
  573.   }
  574.   
  575.   if(cmasterNodeId != getOwnNodeId()){
  576.     jam();
  577.     c_start.reset();
  578.     return;
  579.   }
  581.   if(c_start.m_waiting.isclear()){
  582.     jam();
  583.     c_start.reset();
  584.     return;
  585.   }
  587.   startWaitingNodes(signal);
  588. }
  590. void
  591. Ndbcntr::execCNTR_START_REQ(Signal * signal){
  592.   jamEntry();
  593.   const CntrStartReq * req = (CntrStartReq*)signal->getDataPtr();
  594.   
  595.   const Uint32 nodeId = req->nodeId;
  596.   const Uint32 lastGci = req->lastGci;
  597.   const NodeState::StartType st = (NodeState::StartType)req->startType;
  599.   if(cmasterNodeId == 0){
  600.     jam();
  601.     // Has not completed READNODES yet
  602.     sendSignalWithDelay(reference(), GSN_CNTR_START_REQ, signal, 100, 
  603. signal->getLength());
  604.     return;
  605.   }
  606.   
  607.   if(cmasterNodeId != getOwnNodeId()){
  608.     jam();
  609.     sendCntrStartRef(signal, nodeId, CntrStartRef::NotMaster);
  610.     return;
  611.   }
  612.   
  613.   const NodeState & nodeState = getNodeState();
  614.   switch(nodeState.startLevel){
  615.   case NodeState::SL_NOTHING:
  616.   case NodeState::SL_CMVMI:
  617.     jam();
  618.     ndbrequire(false);
  619.   case NodeState::SL_STARTING:
  620.   case NodeState::SL_STARTED:
  621.     jam();
  622.     break;
  623.     
  624.   case NodeState::SL_STOPPING_1:
  625.   case NodeState::SL_STOPPING_2:
  626.   case NodeState::SL_STOPPING_3:
  627.   case NodeState::SL_STOPPING_4:
  628.     jam();
  629.     sendCntrStartRef(signal, nodeId, CntrStartRef::StopInProgress);
  630.     return;
  631.   }
  633.   /**
  634.    * Am I starting (or started)
  635.    */
  636.   const bool starting = (nodeState.startLevel != NodeState::SL_STARTED);
  637.   
  638.   c_start.m_waiting.set(nodeId);
  639.   switch(st){
  640.   case NodeState::ST_INITIAL_START:
  641.     jam();
  642.     c_start.m_withoutLog.set(nodeId);
  643.     break;
  644.   case NodeState::ST_SYSTEM_RESTART:
  645.     jam();
  646.     c_start.m_withLog.set(nodeId);
  647.     if(starting && lastGci > c_start.m_lastGci){
  648.       jam();
  649.       CntrStartRef * ref = (CntrStartRef*)signal->getDataPtrSend();
  650.       ref->errorCode = CntrStartRef::NotMaster;
  651.       ref->masterNodeId = nodeId;
  652.       NodeReceiverGroup rg (NDBCNTR, c_start.m_waiting);
  653.       sendSignal(rg, GSN_CNTR_START_REF, signal,
  654.  CntrStartRef::SignalLength, JBB);
  655.       return;
  656.     }
  657.     if(starting){
  658.       jam();
  659.       Uint32 i = c_start.m_logNodesCount++;
  660.       c_start.m_logNodes[i].m_nodeId = nodeId;
  661.       c_start.m_logNodes[i].m_lastGci = req->lastGci;
  662.     }
  663.     break;
  664.   case NodeState::ST_NODE_RESTART:
  665.   case NodeState::ST_INITIAL_NODE_RESTART:
  666.   case NodeState::ST_ILLEGAL_TYPE:
  667.     ndbrequire(false);
  668.   }
  670.   const bool startInProgress = !c_start.m_starting.isclear();
  672.   if((starting && startInProgress) || (startInProgress && !parallellNR)){
  673.     jam();
  674.     // We're already starting together with a bunch of nodes
  675.     // Let this node wait...
  676.     return;
  677.   }
  678.   
  679.   if(starting){
  680.     jam();
  681.     trySystemRestart(signal);
  682.   } else {
  683.     jam();
  684.     startWaitingNodes(signal);
  685.   }
  686.   return;
  687. }
  689. void
  690. Ndbcntr::startWaitingNodes(Signal * signal){
  692. #if ! PARALLELL_NR
  693.   const Uint32 nodeId = c_start.m_waiting.find(0);
  694.   const Uint32 Tref = calcNdbCntrBlockRef(nodeId);
  695.   ndbrequire(nodeId != c_start.m_waiting.NotFound);
  697.   NodeState::StartType nrType = NodeState::ST_NODE_RESTART;
  698.   if(c_start.m_withoutLog.get(nodeId)){
  699.     jam();
  700.     nrType = NodeState::ST_INITIAL_NODE_RESTART;
  701.   }
  702.   
  703.   /**
  704.    * Let node perform restart
  705.    */
  706.   CntrStartConf * conf = (CntrStartConf*)signal->getDataPtrSend();
  707.   conf->noStartNodes = 1;
  708.   conf->startType = nrType;
  709.   conf->startGci = ~0; // Not used
  710.   conf->masterNodeId = getOwnNodeId();
  711.   BitmaskImpl::clear(NdbNodeBitmask::Size, conf->startingNodes);
  712.   BitmaskImpl::set(NdbNodeBitmask::Size, conf->startingNodes, nodeId);
  713.   c_startedNodes.copyto(NdbNodeBitmask::Size, conf->startedNodes);
  714.   sendSignal(Tref, GSN_CNTR_START_CONF, signal, 
  715.      CntrStartConf::SignalLength, JBB);
  717.   c_start.m_waiting.clear(nodeId);
  718.   c_start.m_withLog.clear(nodeId);
  719.   c_start.m_withoutLog.clear(nodeId);
  720.   c_start.m_starting.set(nodeId);
  721. #else
  722.   // Parallell nr
  723.   
  724.   c_start.m_starting = c_start.m_waiting;
  725.   c_start.m_waiting.clear();
  726.   
  727.   CntrStartConf * conf = (CntrStartConf*)signal->getDataPtrSend();
  728.   conf->noStartNodes = 1;
  729.   conf->startGci = ~0; // Not used
  730.   conf->masterNodeId = getOwnNodeId();
  731.   c_start.m_starting.copyto(NdbNodeBitmask::Size, conf->startingNodes);
  732.   c_startedNodes.copyto(NdbNodeBitmask::Size, conf->startedNodes);
  733.   
  734.   char buf[100];
  735.   if(!c_start.m_withLog.isclear()){
  736.     jam();
  737.     ndbout_c("Starting nodes w/ log: %s", c_start.m_withLog.getText(buf));
  739.     NodeReceiverGroup rg(NDBCNTR, c_start.m_withLog);
  740.     conf->startType = NodeState::ST_NODE_RESTART;
  741.     
  742.     sendSignal(rg, GSN_CNTR_START_CONF, signal, 
  743.        CntrStartConf::SignalLength, JBB);
  744.   }
  746.   if(!c_start.m_withoutLog.isclear()){
  747.     jam();
  748.     ndbout_c("Starting nodes wo/ log: %s", c_start.m_withoutLog.getText(buf));
  749.     NodeReceiverGroup rg(NDBCNTR, c_start.m_withoutLog);
  750.     conf->startType = NodeState::ST_INITIAL_NODE_RESTART;
  751.     
  752.     sendSignal(rg, GSN_CNTR_START_CONF, signal, 
  753.        CntrStartConf::SignalLength, JBB);
  754.   }
  756.   c_start.m_waiting.clear();
  757.   c_start.m_withLog.clear();
  758.   c_start.m_withoutLog.clear();
  759. #endif
  760. }
  762. void
  763. Ndbcntr::sendCntrStartRef(Signal * signal, 
  764.   Uint32 nodeId, CntrStartRef::ErrorCode code){
  765.   CntrStartRef * ref = (CntrStartRef*)signal->getDataPtrSend();
  766.   ref->errorCode = code;
  767.   ref->masterNodeId = cmasterNodeId;
  768.   sendSignal(calcNdbCntrBlockRef(nodeId), GSN_CNTR_START_REF, signal,
  769.      CntrStartRef::SignalLength, JBB);
  770. }
  772. CheckNodeGroups::Output
  773. Ndbcntr::checkNodeGroups(Signal* signal, const NdbNodeBitmask & mask){
  774.   CheckNodeGroups* sd = (CheckNodeGroups*)&signal->theData[0];
  775.   sd->blockRef = reference();
  776.   sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::ArbitCheck;
  777.   sd->mask = mask;
  778.   EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal, 
  779.  CheckNodeGroups::SignalLength);
  780.   jamEntry();
  781.   return (CheckNodeGroups::Output)sd->output;
  782. }
  784. bool
  785. Ndbcntr::trySystemRestart(Signal* signal){
  786.   /**
  787.    * System restart something
  788.    */
  789.   const bool allNodes = c_start.m_waiting.equal(c_allDefinedNodes);
  790.   const bool allClusterNodes = c_start.m_waiting.equal(c_clusterNodes);
  791.   const Uint64 now = NdbTick_CurrentMillisecond();
  793.   if(!allClusterNodes){
  794.     jam();
  795.     return false;
  796.   }
  797.   
  798.   if(!allNodes && c_start.m_startPartialTimeout > now){
  799.     jam();
  800.     return false;
  801.   }
  803.   NodeState::StartType srType = NodeState::ST_SYSTEM_RESTART;
  804.   if(c_start.m_waiting.equal(c_start.m_withoutLog)){
  805.     if(!allNodes){
  806.       jam();
  807.       return false;
  808.     }
  809.     jam();
  810.     srType = NodeState::ST_INITIAL_START;
  811.     c_start.m_starting = c_start.m_withoutLog; // Used for starting...
  812.     c_start.m_withoutLog.clear();
  813.   } else {
  815.     CheckNodeGroups::Output wLog = checkNodeGroups(signal, c_start.m_withLog);
  817.     switch (wLog) {
  818.     case CheckNodeGroups::Win:
  819.       jam();
  820.       break;
  821.     case CheckNodeGroups::Lose:
  822.       jam();
  823.       // If we lose with all nodes, then we're in trouble
  824.       ndbrequire(!allNodes);
  825.       return false;
  826.     case CheckNodeGroups::Partitioning:
  827.       jam();
  828.       bool allowPartition = (c_start.m_startPartitionedTimeout != (Uint64)~0);
  829.       
  830.       if(allNodes){
  831. if(allowPartition){
  832.   jam();
  833.   break;
  834. }
  835. ndbrequire(false); // All nodes -> partitioning, which is not allowed
  836.       }
  837.       
  838.       if(c_start.m_startPartitionedTimeout > now){
  839. jam();
  840. return false;
  841.       }
  842.       break;
  843.     }    
  844.     
  845.     // For now only with the "logged"-ones.
  846.     // Let the others do node restart afterwards...
  847.     c_start.m_starting = c_start.m_withLog;
  848.     c_start.m_withLog.clear();
  849.   }
  850.       
  851.   /**
  852.    * Okidoki, we try to start
  853.    */
  854.   CntrStartConf * conf = (CntrStartConf*)signal->getDataPtr();
  855.   conf->noStartNodes = c_start.m_starting.count();
  856.   conf->startType = srType;
  857.   conf->startGci = c_start.m_lastGci;
  858.   conf->masterNodeId = c_start.m_lastGciNodeId;
  859.   c_start.m_starting.copyto(NdbNodeBitmask::Size, conf->startingNodes);
  860.   c_startedNodes.copyto(NdbNodeBitmask::Size, conf->startedNodes);
  861.   
  862.   ndbrequire(c_start.m_lastGciNodeId == getOwnNodeId());
  863.   
  864.   NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
  865.   sendSignal(rg, GSN_CNTR_START_CONF, signal, CntrStartConf::SignalLength,JBB);
  866.   
  867.   c_start.m_waiting.bitANDC(c_start.m_starting);
  868.   
  869.   return true;
  870. }
  872. void Ndbcntr::ph2GLab(Signal* signal) 
  873. {
  874.   if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
  875.     jam();
  876.     sendNdbSttor(signal);
  877.     return;
  878.   }//if
  879.   sendSttorry(signal);
  880.   return;
  881. }//Ndbcntr::ph2GLab()
  883. /*
  884. 4.4  START PHASE 3 */
  885. /*###########################################################################*/
  886. // SEND SIGNAL NDBSTTOR TO ALL BLOCKS, ACC, DICT, DIH, LQH, TC AND TUP
  887. // WHEN ALL BLOCKS HAVE RETURNED THEIR NDB_STTORRY ALL BLOCK HAVE FINISHED
  888. // THEIR LOCAL CONNECTIONs SUCESSFULLY
  889. // AND THEN WE CAN SEND APPL_STARTREG TO INFORM QMGR THAT WE ARE READY TO
  890. // SET UP DISTRIBUTED CONNECTIONS.
  891. /*--------------------------------------------------------------*/
  892. // THIS IS NDB START PHASE 3.
  893. /*--------------------------------------------------------------*/
  894. /*******************************/
  895. /*  STTOR                      */
  896. /*******************************/
  897. void Ndbcntr::startPhase3Lab(Signal* signal) 
  898. {
  899.   ph3ALab(signal);
  900.   return;
  901. }//Ndbcntr::startPhase3Lab()
  903. /*******************************/
  904. /*  NDB_STTORRY                */
  905. /*******************************/
  906. void Ndbcntr::ph3ALab(Signal* signal) 
  907. {
  908.   if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
  909.     jam();
  910.     sendNdbSttor(signal);
  911.     return;
  912.   }//if
  914.   sendSttorry(signal);
  915.   return;
  916. }//Ndbcntr::ph3ALab()
  918. /*
  919. 4.5  START PHASE 4      */
  920. /*###########################################################################*/
  921. // WAIT FOR ALL NODES IN CLUSTER TO CHANGE STATE INTO ZSTART ,
  922. // APPL_CHANGEREP IS ALWAYS SENT WHEN SOMEONE HAVE
  923. // CHANGED THEIR STATE. APPL_STARTCONF INDICATES THAT ALL NODES ARE IN START 
  924. // STATE SEND NDB_STARTREQ TO DIH AND THEN WAIT FOR NDB_STARTCONF
  925. /*---------------------------------------------------------------------------*/
  926. /*******************************/
  927. /*  STTOR                      */
  928. /*******************************/
  929. void Ndbcntr::startPhase4Lab(Signal* signal) 
  930. {
  931.   ph4ALab(signal);
  932. }//Ndbcntr::startPhase4Lab()
  935. void Ndbcntr::ph4ALab(Signal* signal) 
  936. {
  937.   ph4BLab(signal);
  938.   return;
  939. }//Ndbcntr::ph4ALab()
  941. /*******************************/
  942. /*  NDB_STTORRY                */
  943. /*******************************/
  944. void Ndbcntr::ph4BLab(Signal* signal) 
  945. {
  946. /*--------------------------------------*/
  947. /* CASE: CSTART_PHASE = ZSTART_PHASE_4  */
  948. /*--------------------------------------*/
  949.   if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
  950.     jam();
  951.     sendNdbSttor(signal);
  952.     return;
  953.   }//if
  954.   if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
  955.       (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
  956.     jam();
  957.     sendSttorry(signal);
  958.     return;
  959.   }//if
  960.   waitpoint41Lab(signal);
  961.   return;
  962. }//Ndbcntr::ph4BLab()
  964. void Ndbcntr::waitpoint41Lab(Signal* signal) 
  965. {
  966.   if (getOwnNodeId() == cmasterNodeId) {
  967.     jam();
  968. /*--------------------------------------*/
  969. /* MASTER WAITS UNTIL ALL SLAVES HAS    */
  970. /* SENT THE REPORTS                     */
  971. /*--------------------------------------*/
  972.     cnoWaitrep++;
  973.     if (cnoWaitrep == cnoStartNodes) {
  974.       jam();
  975.       cnoWaitrep = 0;
  976. /*---------------------------------------------------------------------------*/
  977. // NDB_STARTREQ STARTS UP ALL SET UP OF DISTRIBUTION INFORMATION IN DIH AND
  978. // DICT. AFTER SETTING UP THIS
  979. // DATA IT USES THAT DATA TO SET UP WHICH FRAGMENTS THAT ARE TO START AND
  980. // WHERE THEY ARE TO START. THEN
  981. // IT SETS UP THE FRAGMENTS AND RECOVERS THEM BY:
  982. //  1) READING A LOCAL CHECKPOINT FROM DISK.
  983. //  2) EXECUTING THE UNDO LOG ON INDEX AND DATA.
  984. //  3) EXECUTING THE FRAGMENT REDO LOG FROM ONE OR SEVERAL NODES TO
  985. //     RESTORE THE RESTART CONFIGURATION OF DATA IN NDB CLUSTER.
  986. /*---------------------------------------------------------------------------*/
  987.       signal->theData[0] = reference();
  988.       signal->theData[1] = ctypeOfStart;
  989.       sendSignal(DBDIH_REF, GSN_NDB_STARTREQ, signal, 2, JBB);
  990.     }//if
  991.   } else {
  992.     jam();
  993. /*--------------------------------------*/
  994. /* SLAVE NODES WILL PASS HERE ONCE AND  */
  995. /* SEND A WAITPOINT REPORT TO MASTER.   */
  996. /* SLAVES WONT DO ANYTHING UNTIL THEY   */
  997. /* RECEIVE A WAIT REPORT FROM THE MASTER*/
  998. /*--------------------------------------*/
  999.     signal->theData[0] = getOwnNodeId();
  1000.     signal->theData[1] = ZWAITPOINT_4_1;
  1001.     sendSignal(calcNdbCntrBlockRef(cmasterNodeId), 
  1002.        GSN_CNTR_WAITREP, signal, 2, JBB);
  1003.   }//if
  1004.   return;
  1005. }//Ndbcntr::waitpoint41Lab()
  1007. /*******************************/
  1008. /*  NDB_STARTCONF              */
  1009. /*******************************/
  1010. void Ndbcntr::execNDB_STARTCONF(Signal* signal) 
  1011. {
  1012.   jamEntry();
  1014.   NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
  1015.   signal->theData[0] = getOwnNodeId();
  1016.   signal->theData[1] = ZWAITPOINT_4_2;
  1017.   sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
  1018.   return;
  1019. }//Ndbcntr::execNDB_STARTCONF()
  1021. /*
  1022. 4.6  START PHASE 5      */
  1023. /*###########################################################################*/
  1024. // SEND APPL_RUN TO THE QMGR IN THIS BLOCK
  1025. // SEND NDB_STTOR ALL BLOCKS ACC, DICT, DIH, LQH, TC AND TUP THEN WAIT FOR
  1026. // THEIR NDB_STTORRY
  1027. /*---------------------------------------------------------------------------*/
  1028. /*******************************/
  1029. /*  STTOR                      */
  1030. /*******************************/
  1031. void Ndbcntr::startPhase5Lab(Signal* signal) 
  1032. {
  1033.   ph5ALab(signal);
  1034.   return;
  1035. }//Ndbcntr::startPhase5Lab()
  1037. /*******************************/
  1038. /*  NDB_STTORRY                */
  1039. /*******************************/
  1040. /*---------------------------------------------------------------------------*/
  1041. // THIS IS NDB START PHASE 5.
  1042. /*---------------------------------------------------------------------------*/
  1043. // IN THIS START PHASE TUP INITIALISES DISK FILES FOR DISK STORAGE IF INITIAL
  1044. // START. DIH WILL START UP
  1045. // THE GLOBAL CHECKPOINT PROTOCOL AND WILL CONCLUDE ANY UNFINISHED TAKE OVERS 
  1046. // THAT STARTED BEFORE THE SYSTEM CRASH.
  1047. /*---------------------------------------------------------------------------*/
  1048. void Ndbcntr::ph5ALab(Signal* signal) 
  1049. {
  1050.   if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
  1051.     jam();
  1052.     sendNdbSttor(signal);
  1053.     return;
  1054.   }//if
  1056.   cstartPhase = cstartPhase + 1;
  1057.   cinternalStartphase = cstartPhase - 1;
  1058.   if (getOwnNodeId() == cmasterNodeId) {
  1059.     switch(ctypeOfStart){
  1060.     case NodeState::ST_INITIAL_START:
  1061.       jam();
  1062.       /*--------------------------------------*/
  1063.       /* MASTER CNTR IS RESPONSIBLE FOR       */
  1064.       /* CREATING SYSTEM TABLES               */
  1065.       /*--------------------------------------*/
  1066.       createSystableLab(signal, 0);
  1067.       return;
  1068.     case NodeState::ST_SYSTEM_RESTART:
  1069.       jam();
  1070.       waitpoint52Lab(signal);
  1071.       return;
  1072.     case NodeState::ST_NODE_RESTART:
  1073.     case NodeState::ST_INITIAL_NODE_RESTART:
  1074.       jam();
  1075.       break;
  1076.     case NodeState::ST_ILLEGAL_TYPE:
  1077.       jam();
  1078.       break;
  1079.     }
  1080.     ndbrequire(false);
  1081.   }
  1082.   
  1083.   /**
  1084.    * Not master
  1085.    */
  1086.   NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend();
  1087.   switch(ctypeOfStart){
  1088.   case NodeState::ST_NODE_RESTART:
  1089.   case NodeState::ST_INITIAL_NODE_RESTART:
  1090.     jam();
  1091.     /*----------------------------------------------------------------------*/
  1092.     // SEND NDB START PHASE 5 IN NODE RESTARTS TO COPY DATA TO THE NEWLY
  1093.     // STARTED NODE.
  1094.     /*----------------------------------------------------------------------*/
  1095.     req->senderRef = reference();
  1096.     req->nodeId = getOwnNodeId();
  1097.     req->internalStartPhase = cinternalStartphase;
  1098.     req->typeOfStart = ctypeOfStart;
  1099.     req->masterNodeId = cmasterNodeId;
  1100.     
  1101.     //#define TRACE_STTOR
  1102. #ifdef TRACE_STTOR
  1103.     ndbout_c("sending NDB_STTOR(%d) to DIH", cinternalStartphase);
  1104. #endif
  1105.     sendSignal(DBDIH_REF, GSN_NDB_STTOR, signal, 
  1106.        NdbSttor::SignalLength, JBB);
  1107.     return;
  1108.   case NodeState::ST_INITIAL_START:
  1109.   case NodeState::ST_SYSTEM_RESTART:
  1110.     jam();
  1111.     /*--------------------------------------*/
  1112.     /* DURING SYSTEMRESTART AND INITALSTART:*/
  1113.     /* SLAVE NODES WILL PASS HERE ONCE AND  */
  1114.     /* SEND A WAITPOINT REPORT TO MASTER.   */
  1115.     /* SLAVES WONT DO ANYTHING UNTIL THEY   */
  1116.     /* RECEIVE A WAIT REPORT FROM THE MASTER*/
  1117.     /* WHEN THE MASTER HAS FINISHED HIS WORK*/
  1118.     /*--------------------------------------*/
  1119.     signal->theData[0] = getOwnNodeId();
  1120.     signal->theData[1] = ZWAITPOINT_5_2;
  1121.     sendSignal(calcNdbCntrBlockRef(cmasterNodeId), 
  1122.        GSN_CNTR_WAITREP, signal, 2, JBB);
  1123.     return;
  1124.   default:
  1125.     ndbrequire(false);
  1126.   }
  1127. }//Ndbcntr::ph5ALab()
  1129. void Ndbcntr::waitpoint52Lab(Signal* signal) 
  1130. {
  1131.   cnoWaitrep = cnoWaitrep + 1;
  1132. /*---------------------------------------------------------------------------*/
  1133. // THIS WAITING POINT IS ONLY USED BY A MASTER NODE. WE WILL EXECUTE NDB START 
  1134. // PHASE 5 FOR DIH IN THE
  1135. // MASTER. THIS WILL START UP LOCAL CHECKPOINTS AND WILL ALSO CONCLUDE ANY
  1136. // UNFINISHED LOCAL CHECKPOINTS
  1137. // BEFORE THE SYSTEM CRASH. THIS WILL ENSURE THAT WE ALWAYS RESTART FROM A
  1138. // WELL KNOWN STATE.
  1139. /*---------------------------------------------------------------------------*/
  1140. /*--------------------------------------*/
  1141. /* MASTER WAITS UNTIL HE RECEIVED WAIT  */
  1142. /* REPORTS FROM ALL SLAVE CNTR          */
  1143. /*--------------------------------------*/
  1144.   if (cnoWaitrep == cnoStartNodes) {
  1145.     jam();
  1146.     cnoWaitrep = 0;
  1148.     NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend();
  1149.     req->senderRef = reference();
  1150.     req->nodeId = getOwnNodeId();
  1151.     req->internalStartPhase = cinternalStartphase;
  1152.     req->typeOfStart = ctypeOfStart;
  1153.     req->masterNodeId = cmasterNodeId;
  1154. #ifdef TRACE_STTOR
  1155.     ndbout_c("sending NDB_STTOR(%d) to DIH", cinternalStartphase);
  1156. #endif
  1157.     sendSignal(DBDIH_REF, GSN_NDB_STTOR, signal, 
  1158.        NdbSttor::SignalLength, JBB);
  1159.   }//if
  1160.   return;
  1161. }//Ndbcntr::waitpoint52Lab()
  1163. /*******************************/
  1164. /*  NDB_STTORRY                */
  1165. /*******************************/
  1166. void Ndbcntr::ph6ALab(Signal* signal) 
  1167. {
  1168.   if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
  1169.       (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
  1170.     jam();
  1171.     waitpoint51Lab(signal);
  1172.     return;
  1173.   }//if
  1175.   NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
  1176.   rg.m_nodes.clear(getOwnNodeId());
  1177.   signal->theData[0] = getOwnNodeId();
  1178.   signal->theData[1] = ZWAITPOINT_5_1;
  1179.   sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
  1181.   waitpoint51Lab(signal);
  1182.   return;
  1183. }//Ndbcntr::ph6ALab()
  1185. void Ndbcntr::waitpoint51Lab(Signal* signal) 
  1186. {
  1187.   cstartPhase = cstartPhase + 1;
  1188. /*---------------------------------------------------------------------------*/
  1189. // A FINAL STEP IS NOW TO SEND NDB_STTOR TO TC. THIS MAKES IT POSSIBLE TO 
  1190. // CONNECT TO TC FOR APPLICATIONS.
  1191. // THIS IS NDB START PHASE 6 WHICH IS FOR ALL BLOCKS IN ALL NODES.
  1192. /*---------------------------------------------------------------------------*/
  1193.   cinternalStartphase = cstartPhase - 1;
  1194.   cndbBlocksCount = 0;
  1195.   ph6BLab(signal);
  1196.   return;
  1197. }//Ndbcntr::waitpoint51Lab()
  1199. void Ndbcntr::ph6BLab(Signal* signal) 
  1200. {
  1201.   // c_missra.currentStartPhase - cstartPhase - cinternalStartphase =
  1202.   // 5 - 7 - 6
  1203.   if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
  1204.     jam();
  1205.     sendNdbSttor(signal);
  1206.     return;
  1207.   }//if
  1208.   if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
  1209.       (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
  1210.     jam();
  1211.     sendSttorry(signal);
  1212.     return;
  1213.   }
  1214.   waitpoint61Lab(signal);
  1215. }
  1217. void Ndbcntr::waitpoint61Lab(Signal* signal)
  1218. {
  1219.   if (getOwnNodeId() == cmasterNodeId) {
  1220.     jam();
  1221.     cnoWaitrep6++;
  1222.     if (cnoWaitrep6 == cnoStartNodes) {
  1223.       jam();
  1224.       NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
  1225.       rg.m_nodes.clear(getOwnNodeId());
  1226.       signal->theData[0] = getOwnNodeId();
  1227.       signal->theData[1] = ZWAITPOINT_6_2;
  1228.       sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
  1229.       sendSttorry(signal);
  1230.     }
  1231.   } else {
  1232.     jam();
  1233.     signal->theData[0] = getOwnNodeId();
  1234.     signal->theData[1] = ZWAITPOINT_6_1;
  1235.     sendSignal(calcNdbCntrBlockRef(cmasterNodeId), GSN_CNTR_WAITREP, signal, 2, JBB);
  1236.   }
  1237. }
  1239. // Start phase 8 (internal 7)
  1240. void Ndbcntr::startPhase8Lab(Signal* signal)
  1241. {
  1242.   cinternalStartphase = cstartPhase - 1;
  1243.   cndbBlocksCount = 0;
  1244.   ph7ALab(signal);
  1245. }
  1247. void Ndbcntr::ph7ALab(Signal* signal)
  1248. {
  1249.   while (cndbBlocksCount < ZNO_NDB_BLOCKS) {
  1250.     jam();
  1251.     sendNdbSttor(signal);
  1252.     return;
  1253.   }
  1254.   if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
  1255.       (ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
  1256.     jam();
  1257.     sendSttorry(signal);
  1258.     return;
  1259.   }
  1260.   waitpoint71Lab(signal);
  1261. }
  1263. void Ndbcntr::waitpoint71Lab(Signal* signal)
  1264. {
  1265.   if (getOwnNodeId() == cmasterNodeId) {
  1266.     jam();
  1267.     cnoWaitrep7++;
  1268.     if (cnoWaitrep7 == cnoStartNodes) {
  1269.       jam();
  1270.       NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
  1271.       rg.m_nodes.clear(getOwnNodeId());
  1272.       signal->theData[0] = getOwnNodeId();
  1273.       signal->theData[1] = ZWAITPOINT_7_2;
  1274.       sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
  1275.       sendSttorry(signal);
  1276.     }
  1277.   } else {
  1278.     jam();
  1279.     signal->theData[0] = getOwnNodeId();
  1280.     signal->theData[1] = ZWAITPOINT_7_1;
  1281.     sendSignal(calcNdbCntrBlockRef(cmasterNodeId), GSN_CNTR_WAITREP, signal, 2, JBB);
  1282.   }
  1283. }
  1285. // Start phase 9 (internal 8)
  1286. void Ndbcntr::startPhase9Lab(Signal* signal)
  1287. {
  1288.   cinternalStartphase = cstartPhase - 1;
  1289.   cndbBlocksCount = 0;
  1290.   ph8ALab(signal);
  1291. }
  1293. void Ndbcntr::ph8ALab(Signal* signal)
  1294. {
  1295. /*---------------------------------------------------------------------------*/
  1296. // NODES WHICH PERFORM A NODE RESTART NEEDS TO GET THE DYNAMIC ID'S
  1297. // OF THE OTHER NODES HERE.
  1298. /*---------------------------------------------------------------------------*/
  1299.   sendSttorry(signal);
  1300.   resetStartVariables(signal);
  1301.   return;
  1302. }//Ndbcntr::ph8BLab()
  1304. /*******************************/
  1305. /*  CNTR_WAITREP               */
  1306. /*******************************/
  1307. void Ndbcntr::execCNTR_WAITREP(Signal* signal) 
  1308. {
  1309.   Uint16 twaitPoint;
  1311.   jamEntry();
  1312.   twaitPoint = signal->theData[1];
  1313.   switch (twaitPoint) {
  1314.   case ZWAITPOINT_4_1:
  1315.     jam();
  1316.     waitpoint41Lab(signal);
  1317.     break;
  1318.   case ZWAITPOINT_4_2:
  1319.     jam();
  1320.     sendSttorry(signal);
  1321.     break;
  1322.   case ZWAITPOINT_5_1:
  1323.     jam();
  1324.     waitpoint51Lab(signal);
  1325.     break;
  1326.   case ZWAITPOINT_5_2:
  1327.     jam();
  1328.     waitpoint52Lab(signal);
  1329.     break;
  1330.   case ZWAITPOINT_6_1:
  1331.     jam();
  1332.     waitpoint61Lab(signal);
  1333.     break;
  1334.   case ZWAITPOINT_6_2:
  1335.     jam();
  1336.     sendSttorry(signal);
  1337.     break;
  1338.   case ZWAITPOINT_7_1:
  1339.     jam();
  1340.     waitpoint71Lab(signal);
  1341.     break;
  1342.   case ZWAITPOINT_7_2:
  1343.     jam();
  1344.     sendSttorry(signal);
  1345.     break;
  1346.   default:
  1347.     jam();
  1348.     systemErrorLab(signal);
  1349.     break;
  1350.   }//switch
  1351. }//Ndbcntr::execCNTR_WAITREP()
  1353. /*******************************/
  1354. /*  NODE_FAILREP               */
  1355. /*******************************/
  1356. void Ndbcntr::execNODE_FAILREP(Signal* signal) 
  1357. {
  1358.   jamEntry();
  1360.   const NodeFailRep * nodeFail = (NodeFailRep *)&signal->theData[0];
  1361.   NdbNodeBitmask allFailed; 
  1362.   allFailed.assign(NdbNodeBitmask::Size, nodeFail->theNodes);
  1364.   NdbNodeBitmask failedStarted = c_startedNodes;
  1365.   NdbNodeBitmask failedStarting = c_start.m_starting;
  1366.   NdbNodeBitmask failedWaiting = c_start.m_waiting;
  1368.   failedStarted.bitAND(allFailed);
  1369.   failedStarting.bitAND(allFailed);
  1370.   failedWaiting.bitAND(allFailed);
  1371.   
  1372.   const bool tMasterFailed = allFailed.get(cmasterNodeId);
  1373.   const bool tStarted = !failedStarted.isclear();
  1374.   const bool tStarting = !failedStarting.isclear();
  1375.   const bool tWaiting = !failedWaiting.isclear();
  1377.   if(tMasterFailed){
  1378.     jam();
  1379.     /**
  1380.      * If master has failed choose qmgr president as master
  1381.      */
  1382.     cmasterNodeId = nodeFail->masterNodeId;
  1383.   }
  1384.   
  1385.   /**
  1386.    * Clear node bitmasks from failed nodes
  1387.    */
  1388.   c_start.m_starting.bitANDC(allFailed);
  1389.   c_start.m_waiting.bitANDC(allFailed);
  1390.   c_start.m_withLog.bitANDC(allFailed);
  1391.   c_start.m_withoutLog.bitANDC(allFailed);
  1392.   c_clusterNodes.bitANDC(allFailed);
  1393.   c_startedNodes.bitANDC(allFailed);
  1395.   const NodeState & st = getNodeState();
  1396.   if(st.startLevel == st.SL_STARTING){
  1397.     jam();
  1399.     const Uint32 phase = st.starting.startPhase;
  1400.     
  1401.     const bool tStartConf = (phase > 2) || (phase == 2 && cndbBlocksCount > 0);
  1403.     if(tMasterFailed){
  1404.       progError(__LINE__,
  1405. ERR_SR_OTHERNODEFAILED,
  1406. "Unhandled node failure during restart");
  1407.     }
  1408.     
  1409.     if(tStartConf && tStarting){
  1410.       // One of other starting nodes has crashed...
  1411.       progError(__LINE__,
  1412. ERR_SR_OTHERNODEFAILED,
  1413. "Unhandled node failure of starting node during restart");
  1414.     }
  1416.     if(tStartConf && tStarted){
  1417.       // One of other started nodes has crashed...      
  1418.       progError(__LINE__,
  1419. ERR_SR_OTHERNODEFAILED,
  1420. "Unhandled node failure of started node during restart");
  1421.     }
  1422.     
  1423.     Uint32 nodeId = 0;
  1424.     while(!allFailed.isclear()){
  1425.       nodeId = allFailed.find(nodeId + 1);
  1426.       allFailed.clear(nodeId);
  1427.       signal->theData[0] = nodeId;
  1428.       sendSignal(QMGR_REF, GSN_NDB_FAILCONF, signal, 1, JBB);
  1429.     }//for
  1430.     
  1431.     return;
  1432.   }
  1433.   
  1434.   ndbrequire(!allFailed.get(getOwnNodeId()));
  1436.   NodeFailRep * rep = (NodeFailRep *)&signal->theData[0];  
  1437.   rep->masterNodeId = cmasterNodeId;
  1439.   sendSignal(DBTC_REF, GSN_NODE_FAILREP, signal, 
  1440.      NodeFailRep::SignalLength, JBB);
  1441.   
  1442.   sendSignal(DBLQH_REF, GSN_NODE_FAILREP, signal, 
  1443.      NodeFailRep::SignalLength, JBB);
  1444.   
  1445.   sendSignal(DBDIH_REF, GSN_NODE_FAILREP, signal, 
  1446.      NodeFailRep::SignalLength, JBB);
  1447.   
  1448.   sendSignal(DBDICT_REF, GSN_NODE_FAILREP, signal, 
  1449.      NodeFailRep::SignalLength, JBB);
  1450.   
  1451.   sendSignal(BACKUP_REF, GSN_NODE_FAILREP, signal,
  1452.      NodeFailRep::SignalLength, JBB);
  1454.   sendSignal(SUMA_REF, GSN_NODE_FAILREP, signal,
  1455.      NodeFailRep::SignalLength, JBB);
  1457.   Uint32 nodeId = 0;
  1458.   while(!allFailed.isclear()){
  1459.     nodeId = allFailed.find(nodeId + 1);
  1460.     allFailed.clear(nodeId);
  1461.     signal->theData[0] = EventReport::NODE_FAILREP;
  1462.     signal->theData[1] = nodeId;
  1463.     signal->theData[2] = 0;
  1464.     sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
  1465.   }//for
  1467.   return;
  1468. }//Ndbcntr::execNODE_FAILREP()
  1470. /*******************************/
  1471. /*  READ_NODESREQ              */
  1472. /*******************************/
  1473. void Ndbcntr::execREAD_NODESREQ(Signal* signal) 
  1474. {
  1475.   jamEntry();
  1477.   /*----------------------------------------------------------------------*/
  1478.   // ANY BLOCK MAY SEND A REQUEST ABOUT NDB NODES AND VERSIONS IN THE
  1479.   // SYSTEM. THIS REQUEST CAN ONLY BE HANDLED IN
  1480.   // ABSOLUTE STARTPHASE 3 OR LATER
  1481.   /*----------------------------------------------------------------------*/
  1482.   BlockReference TuserBlockref = signal->theData[0];
  1483.   ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0];
  1484.   
  1485.   /**
  1486.    * Prepare inactiveNodes bitmask.
  1487.    * The concept as such is by the way pretty useless.
  1488.    * It makes parallell starts more or less impossible...
  1489.    */
  1490.   NdbNodeBitmask tmp1; 
  1491.   tmp1.bitOR(c_startedNodes);
  1492.   if(!getNodeState().getNodeRestartInProgress()){
  1493.     tmp1.bitOR(c_start.m_starting);
  1494.   } else {
  1495.     tmp1.set(getOwnNodeId());
  1496.   }
  1498.   NdbNodeBitmask tmp2;
  1499.   tmp2.bitOR(c_allDefinedNodes);
  1500.   tmp2.bitANDC(tmp1);
  1501.   /**
  1502.    * Fill in return signal
  1503.    */
  1504.   tmp2.copyto(NdbNodeBitmask::Size, readNodes->inactiveNodes);
  1505.   c_allDefinedNodes.copyto(NdbNodeBitmask::Size, readNodes->allNodes);
  1506.   c_clusterNodes.copyto(NdbNodeBitmask::Size, readNodes->clusterNodes);
  1507.   c_startedNodes.copyto(NdbNodeBitmask::Size, readNodes->startedNodes);
  1508.   c_start.m_starting.copyto(NdbNodeBitmask::Size, readNodes->startingNodes);
  1510.   readNodes->noOfNodes = c_allDefinedNodes.count();
  1511.   readNodes->masterNodeId = cmasterNodeId;
  1512.   readNodes->ndynamicId = cdynamicNodeId;
  1513.   if (cstartPhase > ZSTART_PHASE_2) {
  1514.     jam();
  1515.     sendSignal(TuserBlockref, GSN_READ_NODESCONF, signal, 
  1516.        ReadNodesConf::SignalLength, JBB);
  1517.     
  1518.   } else {
  1519.     jam();
  1520.     signal->theData[0] = ZNOT_AVAILABLE;
  1521.     sendSignal(TuserBlockref, GSN_READ_NODESREF, signal, 1, JBB);
  1522.   }//if
  1523. }//Ndbcntr::execREAD_NODESREQ()
  1525. /*----------------------------------------------------------------------*/
  1526. // SENDS APPL_ERROR TO QMGR AND THEN SET A POINTER OUT OF BOUNDS
  1527. /*----------------------------------------------------------------------*/
  1528. void Ndbcntr::systemErrorLab(Signal* signal) 
  1529. {
  1530.   progError(0, 0); /* BUG INSERTION */
  1531.   return;
  1532. }//Ndbcntr::systemErrorLab()
  1534. /*###########################################################################*/
  1535. /* CNTR MASTER CREATES AND INITIALIZES A SYSTEMTABLE AT INITIALSTART         */
  1536. /*       |-2048| # 1 00000001    |                                           */
  1537. /*       |  :  |   :             |                                           */
  1538. /*       | -1  | # 1 00000001    |                                           */
  1539. /*       |  0  |   0             |                                           */
  1540. /*       |  1  |   0             |                                           */
  1541. /*       |  :  |   :             |                                           */
  1542. /*       | 2047|   0             |                                           */
  1543. /*---------------------------------------------------------------------------*/
  1544. void Ndbcntr::createSystableLab(Signal* signal, unsigned index)
  1545. {
  1546.   if (index >= g_sysTableCount) {
  1547.     ndbassert(index == g_sysTableCount);
  1548.     startInsertTransactions(signal);
  1549.     return;
  1550.   }
  1551.   const SysTable& table = *g_sysTableList[index];
  1552.   Uint32 propPage[256];
  1553.   LinearWriter w(propPage, 256);
  1555.   // XXX remove commented-out lines later
  1557.   w.first();
  1558.   w.add(DictTabInfo::TableName, table.name);
  1559.   w.add(DictTabInfo::TableLoggedFlag, table.tableLoggedFlag);
  1560.   //w.add(DictTabInfo::TableKValue, 6);
  1561.   //w.add(DictTabInfo::MinLoadFactor, 70);
  1562.   //w.add(DictTabInfo::MaxLoadFactor, 80);
  1563.   w.add(DictTabInfo::FragmentTypeVal, (Uint32)table.fragmentType);
  1564.   //w.add(DictTabInfo::TableStorageVal, (Uint32)DictTabInfo::MainMemory);
  1565.   //w.add(DictTabInfo::NoOfKeyAttr, 1);
  1566.   w.add(DictTabInfo::NoOfAttributes, (Uint32)table.columnCount);
  1567.   //w.add(DictTabInfo::NoOfNullable, (Uint32)0);
  1568.   //w.add(DictTabInfo::NoOfVariable, (Uint32)0);
  1569.   //w.add(DictTabInfo::KeyLength, 1);
  1570.   w.add(DictTabInfo::TableTypeVal, (Uint32)table.tableType);
  1572.   for (unsigned i = 0; i < table.columnCount; i++) {
  1573.     const SysColumn& column = table.columnList[i];
  1574.     ndbassert(column.pos == i);
  1575.     w.add(DictTabInfo::AttributeName, column.name);
  1576.     w.add(DictTabInfo::AttributeId, (Uint32)column.pos);
  1577.     //w.add(DictTabInfo::AttributeType, DictTabInfo::UnSignedType);
  1578.     //w.add(DictTabInfo::AttributeSize, DictTabInfo::a32Bit);
  1579.     //w.add(DictTabInfo::AttributeArraySize, 1);
  1580.     w.add(DictTabInfo::AttributeKeyFlag, (Uint32)column.keyFlag);
  1581.     //w.add(DictTabInfo::AttributeStorage, (Uint32)DictTabInfo::MainMemory);
  1582.     w.add(DictTabInfo::AttributeNullableFlag, (Uint32)column.nullable);
  1583.     // ext type overrides
  1584.     w.add(DictTabInfo::AttributeExtType, (Uint32)column.type);
  1585.     w.add(DictTabInfo::AttributeExtLength, (Uint32)column.length);
  1586.     w.add(DictTabInfo::AttributeEnd, (Uint32)true);
  1587.   }
  1588.   w.add(DictTabInfo::TableEnd, (Uint32)true);
  1589.   
  1590.   Uint32 length = w.getWordsUsed();
  1591.   LinearSectionPtr ptr[3];
  1592.   ptr[0].p = &propPage[0];
  1593.   ptr[0].sz = length;
  1595.   CreateTableReq* const req = (CreateTableReq*)signal->getDataPtrSend();
  1596.   req->senderData = index;
  1597.   req->senderRef = reference();
  1598.   sendSignal(DBDICT_REF, GSN_CREATE_TABLE_REQ, signal,
  1599.      CreateTableReq::SignalLength, JBB, ptr, 1);
  1600.   return;
  1601. }//Ndbcntr::createSystableLab()
  1603. void Ndbcntr::execCREATE_TABLE_REF(Signal* signal) 
  1604. {
  1605.   jamEntry();
  1606.   progError(0,0);
  1607.   return;
  1608. }//Ndbcntr::execDICTTABREF()
  1610. void Ndbcntr::execCREATE_TABLE_CONF(Signal* signal) 
  1611. {
  1612.   jamEntry();
  1613.   CreateTableConf * const conf = (CreateTableConf*)signal->getDataPtrSend();
  1614.   //csystabId = conf->tableId;
  1615.   ndbrequire(conf->senderData < g_sysTableCount);
  1616.   const SysTable& table = *g_sysTableList[conf->senderData];
  1617.   table.tableId = conf->tableId;
  1618.   createSystableLab(signal, conf->senderData + 1);
  1619.   //startInsertTransactions(signal);
  1620.   return;
  1621. }//Ndbcntr::execDICTTABCONF()
  1623. /*******************************/
  1624. /*  DICTRELEASECONF            */
  1625. /*******************************/
  1626. void Ndbcntr::startInsertTransactions(Signal* signal) 
  1627. {
  1628.   jamEntry();
  1630.   ckey = 1;
  1631.   ctransidPhase = ZTRUE;
  1632.   signal->theData[0] = 0;
  1633.   signal->theData[1] = reference();
  1634.   sendSignal(DBTC_REF, GSN_TCSEIZEREQ, signal, 2, JBB);
  1635.   return;
  1636. }//Ndbcntr::startInsertTransactions()
  1638. /*******************************/
  1639. /*  TCSEIZECONF                */
  1640. /*******************************/
  1641. void Ndbcntr::execTCSEIZECONF(Signal* signal) 
  1642. {
  1643.   jamEntry();
  1644.   ctcConnectionP = signal->theData[1];
  1645.   crSystab7Lab(signal);
  1646.   return;
  1647. }//Ndbcntr::execTCSEIZECONF()
  1649. const unsigned int RowsPerCommit = 16;
  1650. void Ndbcntr::crSystab7Lab(Signal* signal) 
  1651. {
  1652.   UintR tkey;
  1653.   UintR Tmp;
  1654.   
  1655.   TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0];
  1656.   
  1657.   UintR reqInfo_Start = 0;
  1658.   tcKeyReq->setOperationType(reqInfo_Start, ZINSERT); // Insert
  1659.   tcKeyReq->setKeyLength    (reqInfo_Start, 1);
  1660.   tcKeyReq->setAIInTcKeyReq (reqInfo_Start, 5);
  1661.   tcKeyReq->setAbortOption  (reqInfo_Start, TcKeyReq::AbortOnError);
  1663. /* KEY LENGTH = 1, ATTRINFO LENGTH IN TCKEYREQ = 5 */
  1664.   cresponses = 0;
  1665.   const UintR guard0 = ckey + (RowsPerCommit - 1);
  1666.   for (Tmp = ckey; Tmp <= guard0; Tmp++) {
  1667.     UintR reqInfo = reqInfo_Start;
  1668.     if (Tmp == ckey) { // First iteration, Set start flag
  1669.       jam();
  1670.       tcKeyReq->setStartFlag(reqInfo, 1);
  1671.     } //if
  1672.     if (Tmp == guard0) { // Last iteration, Set commit flag
  1673.       jam();
  1674.       tcKeyReq->setCommitFlag(reqInfo, 1);      
  1675.       tcKeyReq->setExecuteFlag(reqInfo, 1);
  1676.     } //if
  1677.     if (ctransidPhase == ZTRUE) {
  1678.       jam();
  1679.       tkey = 0;
  1680.       tkey = tkey - Tmp;
  1681.     } else {
  1682.       jam();
  1683.       tkey = Tmp;
  1684.     }//if
  1686.     tcKeyReq->apiConnectPtr      = ctcConnectionP;
  1687.     tcKeyReq->attrLen            = 5;
  1688.     tcKeyReq->tableId            = g_sysTable_SYSTAB_0.tableId;
  1689.     tcKeyReq->requestInfo        = reqInfo;
  1690.     tcKeyReq->tableSchemaVersion = ZSYSTAB_VERSION;
  1691.     tcKeyReq->transId1           = 0;
  1692.     tcKeyReq->transId2           = ckey;
  1694. //-------------------------------------------------------------
  1695. // There is no optional part in this TCKEYREQ. There is one
  1696. // key word and five ATTRINFO words.
  1697. //-------------------------------------------------------------
  1698.     Uint32* tKeyDataPtr          = &tcKeyReq->scanInfo;
  1699.     Uint32* tAIDataPtr           = &tKeyDataPtr[1];
  1701.     tKeyDataPtr[0]               = tkey;
  1703.     AttributeHeader::init(&tAIDataPtr[0], 0, 1);
  1704.     tAIDataPtr[1]                = tkey;
  1705.     AttributeHeader::init(&tAIDataPtr[2], 1, 2);
  1706.     tAIDataPtr[3]                = (tkey << 16);
  1707.     tAIDataPtr[4]                = 1;    
  1708.     sendSignal(DBTC_REF, GSN_TCKEYREQ, signal, 
  1709.        TcKeyReq::StaticLength + 6, JBB);
  1710.   }//for
  1711.   ckey = ckey + RowsPerCommit;
  1712.   return;
  1713. }//Ndbcntr::crSystab7Lab()
  1715. /*******************************/
  1716. /*  TCKEYCONF09                */
  1717. /*******************************/
  1718. void Ndbcntr::execTCKEYCONF(Signal* signal) 
  1719. {
  1720.   const TcKeyConf * const keyConf = (TcKeyConf *)&signal->theData[0];
  1721.   
  1722.   jamEntry();
  1723.   cgciSystab = keyConf->gci;
  1724.   UintR confInfo = keyConf->confInfo;
  1725.   
  1726.   if (TcKeyConf::getMarkerFlag(confInfo)){
  1727.     Uint32 transId1 = keyConf->transId1;
  1728.     Uint32 transId2 = keyConf->transId2;
  1729.     signal->theData[0] = transId1;
  1730.     signal->theData[1] = transId2;
  1731.     sendSignal(DBTC_REF, GSN_TC_COMMIT_ACK, signal, 2, JBB);    
  1732.   }//if
  1733.   
  1734.   cresponses = cresponses + TcKeyConf::getNoOfOperations(confInfo);
  1735.   if (TcKeyConf::getCommitFlag(confInfo)){
  1736.     jam();
  1737.     ndbrequire(cresponses == RowsPerCommit);
  1739.     crSystab8Lab(signal);
  1740.     return;
  1741.   }
  1742.   return;
  1743. }//Ndbcntr::tckeyConfLab()
  1745. void Ndbcntr::crSystab8Lab(Signal* signal) 
  1746. {
  1747.   if (ckey < ZSIZE_SYSTAB) {
  1748.     jam();
  1749.     crSystab7Lab(signal);
  1750.     return;
  1751.   } else if (ctransidPhase == ZTRUE) {
  1752.     jam();
  1753.     ckey = 1;
  1754.     ctransidPhase = ZFALSE;
  1755.     crSystab7Lab(signal);
  1756.     return;
  1757.   }//if
  1758.   signal->theData[0] = ctcConnectionP;
  1759.   signal->theData[1] = reference();
  1760.   signal->theData[2] = 0;
  1761.   sendSignal(DBTC_REF, GSN_TCRELEASEREQ, signal, 2, JBB);
  1762.   return;
  1763. }//Ndbcntr::crSystab8Lab()
  1765. /*******************************/
  1766. /*  TCRELEASECONF              */
  1767. /*******************************/
  1768. void Ndbcntr::execTCRELEASECONF(Signal* signal) 
  1769. {
  1770.   jamEntry();
  1771.   waitpoint52Lab(signal);
  1772.   return;
  1773. }//Ndbcntr::execTCRELEASECONF()
  1775. void Ndbcntr::crSystab9Lab(Signal* signal) 
  1776. {
  1777.   signal->theData[1] = reference();
  1778.   sendSignalWithDelay(DBDIH_REF, GSN_GETGCIREQ, signal, 100, 2);
  1779.   return;
  1780. }//Ndbcntr::crSystab9Lab()
  1782. /*******************************/
  1783. /*  GETGCICONF                 */
  1784. /*******************************/
  1785. void Ndbcntr::execGETGCICONF(Signal* signal) 
  1786. {
  1787.   jamEntry();
  1789. #ifndef NO_GCP
  1790.   if (signal->theData[1] < cgciSystab) {
  1791.     jam();
  1792. /*--------------------------------------*/
  1793. /* MAKE SURE THAT THE SYSTABLE IS       */
  1794. /* NOW SAFE ON DISK                     */
  1795. /*--------------------------------------*/
  1796.     crSystab9Lab(signal);
  1797.     return;
  1798.   }//if
  1799. #endif
  1800.   waitpoint52Lab(signal);
  1801.   return;
  1802. }//Ndbcntr::execGETGCICONF()
  1804. void Ndbcntr::execTCKEYREF(Signal* signal) 
  1805. {
  1806.   jamEntry();
  1807.   systemErrorLab(signal);
  1808.   return;
  1809. }//Ndbcntr::execTCKEYREF()
  1811. void Ndbcntr::execTCROLLBACKREP(Signal* signal) 
  1812. {
  1813.   jamEntry();
  1814.   systemErrorLab(signal);
  1815.   return;
  1816. }//Ndbcntr::execTCROLLBACKREP()
  1818. void Ndbcntr::execTCRELEASEREF(Signal* signal) 
  1819. {
  1820.   jamEntry();
  1821.   systemErrorLab(signal);
  1822.   return;
  1823. }//Ndbcntr::execTCRELEASEREF()
  1825. void Ndbcntr::execTCSEIZEREF(Signal* signal) 
  1826. {
  1827.   jamEntry();
  1828.   systemErrorLab(signal);
  1829.   return;
  1830. }//Ndbcntr::execTCSEIZEREF()
  1833. /*---------------------------------------------------------------------------*/
  1834. /*INITIALIZE VARIABLES AND RECORDS                                           */
  1835. /*---------------------------------------------------------------------------*/
  1836. void Ndbcntr::initData(Signal* signal) 
  1837. {
  1838.   c_start.reset();
  1839.   cmasterNodeId = 0;
  1840.   cnoStartNodes = 0;
  1841.   cnoWaitrep = 0;
  1842. }//Ndbcntr::initData()
  1845. /*---------------------------------------------------------------------------*/
  1846. /*RESET VARIABLES USED DURING THE START                                      */
  1847. /*---------------------------------------------------------------------------*/
  1848. void Ndbcntr::resetStartVariables(Signal* signal) 
  1849. {
  1850.   cnoStartNodes = 0;
  1851.   cnoWaitrep6 = cnoWaitrep7 = 0;
  1852. }//Ndbcntr::resetStartVariables()
  1855. /*---------------------------------------------------------------------------*/
  1856. // SEND THE SIGNAL
  1857. // INPUT                  CNDB_BLOCKS_COUNT
  1858. /*---------------------------------------------------------------------------*/
  1859. void Ndbcntr::sendNdbSttor(Signal* signal) 
  1860. {
  1861.   NdbBlocksRecPtr ndbBlocksPtr;
  1863.   ndbBlocksPtr.i = cndbBlocksCount;
  1864.   ptrCheckGuard(ndbBlocksPtr, ZSIZE_NDB_BLOCKS_REC, ndbBlocksRec);
  1866.   NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend();
  1867.   req->senderRef = reference();
  1868.   req->nodeId = getOwnNodeId();
  1869.   req->internalStartPhase = cinternalStartphase;
  1870.   req->typeOfStart = ctypeOfStart;
  1871.   req->masterNodeId = cmasterNodeId;
  1872.   
  1873.   for (int i = 0; i < 16; i++) {
  1874.     // Garbage
  1875.     req->config[i] = 0x88776655;
  1876.     //cfgBlockPtr.p->cfgData[i];
  1877.   }
  1878.   
  1879.   //#define MAX_STARTPHASE 2
  1880. #ifdef TRACE_STTOR
  1881.   ndbout_c("sending NDB_STTOR(%d) to %s",
  1882.    cinternalStartphase, 
  1883.    getBlockName( refToBlock(ndbBlocksPtr.p->blockref)));
  1884. #endif
  1885.   sendSignal(ndbBlocksPtr.p->blockref, GSN_NDB_STTOR, signal, 22, JBB);
  1886.   cndbBlocksCount++;
  1887. }//Ndbcntr::sendNdbSttor()
  1889. /*---------------------------------------------------------------------------*/
  1890. // JUST SEND THE SIGNAL
  1891. /*---------------------------------------------------------------------------*/
  1892. void Ndbcntr::sendSttorry(Signal* signal) 
  1893. {
  1894.   signal->theData[3] = ZSTART_PHASE_1;
  1895.   signal->theData[4] = ZSTART_PHASE_2;
  1896.   signal->theData[5] = ZSTART_PHASE_3;
  1897.   signal->theData[6] = ZSTART_PHASE_4;
  1898.   signal->theData[7] = ZSTART_PHASE_5;
  1899.   signal->theData[8] = ZSTART_PHASE_6;
  1900.   // skip simulated phase 7
  1901.   signal->theData[9] = ZSTART_PHASE_8;
  1902.   signal->theData[10] = ZSTART_PHASE_9;
  1903.   signal->theData[11] = ZSTART_PHASE_END;
  1904.   sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 12, JBB);
  1905. }//Ndbcntr::sendSttorry()
  1907. void
  1908. Ndbcntr::execDUMP_STATE_ORD(Signal* signal)
  1909. {
  1910.   DumpStateOrd * const & dumpState = (DumpStateOrd *)&signal->theData[0];
  1911.   if(signal->theData[0] == 13){
  1912.     infoEvent("Cntr: cstartPhase = %d, cinternalStartphase = %d, block = %d", 
  1913.       cstartPhase, cinternalStartphase, cndbBlocksCount);
  1914.     infoEvent("Cntr: cmasterNodeId = %d", cmasterNodeId);
  1915.   }
  1917.   if (dumpState->args[0] == DumpStateOrd::NdbcntrTestStopOnError){
  1918.     if (theConfiguration.stopOnError() == true)
  1919.       ((Configuration&)theConfiguration).stopOnError(false);
  1920.     
  1921.     const BlockReference tblockref = calcNdbCntrBlockRef(getOwnNodeId());
  1922.       
  1923.     SystemError * const sysErr = (SystemError*)&signal->theData[0];
  1924.     sysErr->errorCode = SystemError::TestStopOnError;
  1925.     sysErr->errorRef = reference();
  1926.     sendSignal(tblockref, GSN_SYSTEM_ERROR, signal, 
  1927.        SystemError::SignalLength, JBA);
  1928.   }
  1931. }//Ndbcntr::execDUMP_STATE_ORD()
  1933. void Ndbcntr::execSET_VAR_REQ(Signal* signal) {
  1934. #if 0
  1935.   SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0];
  1936.   ConfigParamId var = setVarReq->variable();
  1938.   switch (var) {
  1939.   case TimeToWaitAlive:
  1940.     // Valid only during start so value not set.
  1941.     sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB);
  1942.     break;
  1944.   default:
  1945.     sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB);
  1946.   }// switch
  1947. #endif
  1948. }//Ndbcntr::execSET_VAR_REQ()
  1950. void Ndbcntr::updateNodeState(Signal* signal, const NodeState& newState) const{
  1951.   NodeStateRep * const stateRep = (NodeStateRep *)&signal->theData[0];
  1953.   stateRep->nodeState = newState;
  1954.   stateRep->nodeState.masterNodeId = cmasterNodeId;
  1955.   stateRep->nodeState.setNodeGroup(c_nodeGroup);
  1956.   
  1957.   for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
  1958.     sendSignal(ALL_BLOCKS[i].Ref, GSN_NODE_STATE_REP, signal,
  1959.        NodeStateRep::SignalLength, JBB);
  1960.   }
  1961. }
  1963. void
  1964. Ndbcntr::execRESUME_REQ(Signal* signal){
  1965.   //ResumeReq * const req = (ResumeReq *)&signal->theData[0];
  1966.   //ResumeRef * const ref = (ResumeRef *)&signal->theData[0];
  1967.   
  1968.   jamEntry();
  1970.   signal->theData[0] = EventReport::SingleUser;
  1971.   signal->theData[1] = 2;
  1972.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
  1974.   //Uint32 senderData = req->senderData;
  1975.   //BlockReference senderRef = req->senderRef;
  1976.   NodeState newState(NodeState::SL_STARTED);   
  1977.   updateNodeState(signal, newState);
  1978.   c_stopRec.stopReq.senderRef=0;
  1979. }
  1981. void
  1982. Ndbcntr::execSTOP_REQ(Signal* signal){
  1983.   StopReq * const req = (StopReq *)&signal->theData[0];
  1984.   StopRef * const ref = (StopRef *)&signal->theData[0];
  1985.   Uint32 singleuser  = req->singleuser;
  1986.   jamEntry();
  1987.   Uint32 senderData = req->senderData;
  1988.   BlockReference senderRef = req->senderRef;
  1989.   bool abort = StopReq::getStopAbort(req->requestInfo);
  1991.   if(getNodeState().startLevel < NodeState::SL_STARTED || 
  1992.      abort && !singleuser){
  1993.     /**
  1994.      * Node is not started yet
  1995.      *
  1996.      * So stop it quickly
  1997.      */
  1998.     jam();
  1999.     const Uint32 reqInfo = req->requestInfo;
  2000.     if(StopReq::getPerformRestart(reqInfo)){
  2001.       jam();
  2002.       StartOrd * startOrd = (StartOrd *)&signal->theData[0];
  2003.       startOrd->restartInfo = reqInfo;
  2004.       sendSignal(CMVMI_REF, GSN_START_ORD, signal, 1, JBA);
  2005.     } else {
  2006.       jam();
  2007.       sendSignal(CMVMI_REF, GSN_STOP_ORD, signal, 1, JBA);
  2008.     }
  2009.     return;
  2010.   }
  2012.   if(c_stopRec.stopReq.senderRef != 0){
  2013.     /**
  2014.      * Requested a system shutdown
  2015.      */
  2016.     if(!singleuser && StopReq::getSystemStop(req->requestInfo)){
  2017.       jam();
  2018.       sendSignalWithDelay(reference(), GSN_STOP_REQ, signal, 100,
  2019.   StopReq::SignalLength);
  2020.       return;
  2021.     }
  2023.     /**
  2024.      * Requested a node shutdown
  2025.      */
  2026.     if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo))
  2027.       ref->errorCode = StopRef::SystemShutdownInProgress;
  2028.     else
  2029.       ref->errorCode = StopRef::NodeShutdownInProgress;
  2030.     ref->senderData = senderData;
  2031.     sendSignal(senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
  2032.     return;
  2033.   }
  2034.   
  2035.   c_stopRec.stopReq = * req;
  2036.   c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
  2037.   
  2038.   if(!singleuser) {
  2039.     if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo)) {
  2040.       jam();
  2041.       if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo)){
  2042. ((Configuration&)theConfiguration).stopOnError(false);
  2043.       }
  2044.     }
  2045.     if(!c_stopRec.checkNodeFail(signal)){
  2046.       jam();
  2047.       return;
  2048.     }
  2049.     signal->theData[0] = EventReport::NDBStopStarted;
  2050.     signal->theData[1] = StopReq::getSystemStop(c_stopRec.stopReq.requestInfo) ? 1 : 0;
  2051.     sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
  2052.   }
  2053.   else
  2054.   {
  2055.     signal->theData[0] = EventReport::SingleUser;
  2056.     signal->theData[1] = 0;
  2057.     sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
  2058.   }
  2060.   NodeState newState(NodeState::SL_STOPPING_1, 
  2061.      StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
  2062.   
  2063.    if(singleuser) {
  2064.      newState.setSingleUser(true);
  2065.      newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi);
  2066.    }
  2067.   updateNodeState(signal, newState);
  2068.   signal->theData[0] = ZSHUTDOWN;
  2069.   sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
  2070. }
  2072. void
  2073. Ndbcntr::StopRecord::checkTimeout(Signal* signal){
  2074.   jamEntry();
  2076.   if(!cntr.getNodeState().getSingleUserMode())
  2077.     if(!checkNodeFail(signal)){
  2078.       jam();
  2079.       return;
  2080.     }
  2082.   switch(cntr.getNodeState().startLevel){
  2083.   case NodeState::SL_STOPPING_1:
  2084.     checkApiTimeout(signal);
  2085.     break;
  2086.   case NodeState::SL_STOPPING_2:
  2087.     checkTcTimeout(signal);
  2088.     break;
  2089.   case NodeState::SL_STOPPING_3:
  2090.     checkLqhTimeout_1(signal);
  2091.     break;
  2092.   case NodeState::SL_STOPPING_4:
  2093.     checkLqhTimeout_2(signal);
  2094.     break;
  2095.   case NodeState::SL_SINGLEUSER:
  2096.     break;
  2097.   default:
  2098.     ndbrequire(false);
  2099.   }
  2100. }
  2102. bool
  2103. Ndbcntr::StopRecord::checkNodeFail(Signal* signal){
  2104.   jam();
  2105.   if(StopReq::getSystemStop(stopReq.requestInfo)){
  2106.     jam();
  2107.     return true;
  2108.   }
  2110.   /**
  2111.    * Check if I can survive me stopping
  2112.    */
  2113.   NodeBitmask ndbMask; 
  2114.   ndbMask.assign(cntr.c_startedNodes);
  2115.   ndbMask.clear(cntr.getOwnNodeId());
  2116.   
  2117.   CheckNodeGroups* sd = (CheckNodeGroups*)&signal->theData[0];
  2118.   sd->blockRef = cntr.reference();
  2119.   sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::ArbitCheck;
  2120.   sd->mask = ndbMask;
  2121.   cntr.EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal, 
  2122.       CheckNodeGroups::SignalLength);
  2123.   jamEntry();
  2124.   switch (sd->output) {
  2125.   case CheckNodeGroups::Win:
  2126.   case CheckNodeGroups::Partitioning:
  2127.     return true;
  2128.     break;
  2129.   }
  2130.   
  2131.   StopRef * const ref = (StopRef *)&signal->theData[0];    
  2132.   
  2133.   ref->senderData = stopReq.senderData;
  2134.   ref->errorCode = StopRef::NodeShutdownWouldCauseSystemCrash;
  2135.   
  2136.   const BlockReference bref = stopReq.senderRef;
  2137.   cntr.sendSignal(bref, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
  2138.   
  2139.   stopReq.senderRef = 0;
  2141.   if (cntr.getNodeState().startLevel != NodeState::SL_SINGLEUSER)
  2142.   {
  2143.     NodeState newState(NodeState::SL_STARTED); 
  2144.     cntr.updateNodeState(signal, newState);
  2145.   }
  2147.   signal->theData[0] = EventReport::NDBStopAborted;
  2148.   cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB);
  2149.   
  2150.   return false;
  2151. }
  2153. void
  2154. Ndbcntr::StopRecord::checkApiTimeout(Signal* signal){
  2155.   const Int32 timeout = stopReq.apiTimeout; 
  2156.   const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
  2157.   const NDB_TICKS now = NdbTick_CurrentMillisecond();
  2158.   if((timeout >= 0 && now >= alarm)){
  2159.     // || checkWithApiInSomeMagicWay)
  2160.     jam();
  2161.     NodeState newState(NodeState::SL_STOPPING_2, 
  2162.        StopReq::getSystemStop(stopReq.requestInfo));
  2163.     if(stopReq.singleuser) {
  2164.       newState.setSingleUser(true);
  2165.       newState.setSingleUserApi(stopReq.singleUserApi);
  2166.     }
  2167.     cntr.updateNodeState(signal, newState);
  2169.     stopInitiatedTime = now;
  2170.   }
  2172.   signal->theData[0] = ZSHUTDOWN;
  2173.   cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
  2174. }
  2176. void
  2177. Ndbcntr::StopRecord::checkTcTimeout(Signal* signal){
  2178.   const Int32 timeout = stopReq.transactionTimeout;
  2179.   const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
  2180.   const NDB_TICKS now = NdbTick_CurrentMillisecond();
  2181.   if((timeout >= 0 && now >= alarm)){
  2182.     // || checkWithTcInSomeMagicWay)
  2183.     jam();
  2184.     if(stopReq.getSystemStop(stopReq.requestInfo)  || stopReq.singleuser){
  2185.       jam();
  2186.       if(stopReq.singleuser) 
  2187. {
  2188.   jam();
  2189.    AbortAllReq * req = (AbortAllReq*)&signal->theData[0];
  2190.    req->senderRef = cntr.reference();
  2191.    req->senderData = 12;
  2192.    cntr.sendSignal(DBTC_REF, GSN_ABORT_ALL_REQ, signal, 
  2193.       AbortAllReq::SignalLength, JBB);
  2194. } 
  2195.       else
  2196. {
  2197.   WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
  2198.   req->senderRef = cntr.reference();
  2199.   req->senderData = 12;
  2200.   req->requestType = WaitGCPReq::CompleteForceStart;
  2201.   cntr.sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal, 
  2202.   WaitGCPReq::SignalLength, JBB);
  2203. }
  2204.     } else {
  2205.       jam();
  2206.       StopPermReq * req = (StopPermReq*)&signal->theData[0];
  2207.       req->senderRef = cntr.reference();
  2208.       req->senderData = 12;
  2209.       cntr.sendSignal(DBDIH_REF, GSN_STOP_PERM_REQ, signal, 
  2210.       StopPermReq::SignalLength, JBB);
  2211.     }
  2212.     return;
  2213.   } 
  2214.   signal->theData[0] = ZSHUTDOWN;
  2215.   cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
  2216. }
  2218. void Ndbcntr::execSTOP_PERM_REF(Signal* signal){
  2219.   //StopPermRef* const ref = (StopPermRef*)&signal->theData[0];
  2221.   jamEntry();
  2223.   signal->theData[0] = ZSHUTDOWN;
  2224.   sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
  2225. }
  2227. void Ndbcntr::execSTOP_PERM_CONF(Signal* signal){
  2228.   jamEntry();
  2229.   
  2230.   AbortAllReq * req = (AbortAllReq*)&signal->theData[0];
  2231.   req->senderRef = reference();
  2232.   req->senderData = 12;
  2233.   sendSignal(DBTC_REF, GSN_ABORT_ALL_REQ, signal, 
  2234.      AbortAllReq::SignalLength, JBB);
  2235. }
  2237. void Ndbcntr::execABORT_ALL_CONF(Signal* signal){
  2238.   jamEntry();
  2239.   if(c_stopRec.stopReq.singleuser) {
  2240.     jam();
  2242.     NodeState newState(NodeState::SL_SINGLEUSER);    
  2243.     newState.setSingleUser(true);
  2244.     newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi);
  2245.     updateNodeState(signal, newState);    
  2246.     c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
  2248.     StopConf * const stopConf = (StopConf *)&signal->theData[0];
  2249.     stopConf->senderData = c_stopRec.stopReq.senderData;
  2250.     stopConf->nodeState  = (Uint32) NodeState::SL_SINGLEUSER;
  2251.     sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_CONF, signal, StopConf::SignalLength, JBB);
  2253.     c_stopRec.stopReq.senderRef = 0; // the command is done
  2255.     signal->theData[0] = EventReport::SingleUser;
  2256.     signal->theData[1] = 1;
  2257.     signal->theData[2] = c_stopRec.stopReq.singleUserApi;
  2258.     sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
  2259.   }
  2260.   else 
  2261.     {
  2262.       jam();
  2263.       NodeState newState(NodeState::SL_STOPPING_3, 
  2264.  StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
  2265.       updateNodeState(signal, newState);
  2266.   
  2267.       c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
  2268.       
  2269.       signal->theData[0] = ZSHUTDOWN;
  2270.       sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
  2271.     }
  2272. }
  2274. void Ndbcntr::execABORT_ALL_REF(Signal* signal){
  2275.   jamEntry();
  2276.   AbortAllRef *abortAllRef = (AbortAllRef *)&signal->theData[0];
  2277.   AbortAllRef::ErrorCode errorCode = (AbortAllRef::ErrorCode) abortAllRef->errorCode;
  2279.   StopRef * const stopRef = (StopRef *)&signal->theData[0];
  2280.   stopRef->senderData = c_stopRec.stopReq.senderData;
  2281.   stopRef->errorCode = StopRef::TransactionAbortFailed;
  2282.   sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
  2283. }
  2285. void
  2286. Ndbcntr::StopRecord::checkLqhTimeout_1(Signal* signal){
  2287.   const Int32 timeout = stopReq.readOperationTimeout;
  2288.   const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
  2289.   const NDB_TICKS now = NdbTick_CurrentMillisecond();
  2290.   
  2291.   if((timeout >= 0 && now >= alarm)){
  2292.     // || checkWithLqhInSomeMagicWay)
  2293.     jam();
  2294.     
  2295.     ChangeNodeStateReq * req = (ChangeNodeStateReq*)&signal->theData[0];
  2297.     NodeState newState(NodeState::SL_STOPPING_4, 
  2298.        StopReq::getSystemStop(stopReq.requestInfo));
  2299.     req->nodeState = newState;
  2300.     req->senderRef = cntr.reference();
  2301.     req->senderData = 12;
  2302.     cntr.sendSignal(DBLQH_REF, GSN_CHANGE_NODE_STATE_REQ, signal, 2, JBB);
  2303.     return;
  2304.   }
  2305.   signal->theData[0] = ZSHUTDOWN;
  2306.   cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
  2307. }
  2309. void Ndbcntr::execCHANGE_NODE_STATE_CONF(Signal* signal){
  2310.   jamEntry();
  2311.   signal->theData[0] = reference();
  2312.   signal->theData[1] = 12;
  2313.   sendSignal(DBDIH_REF, GSN_STOP_ME_REQ, signal, 2, JBB);
  2314. }
  2316. void Ndbcntr::execSTOP_ME_REF(Signal* signal){
  2317.   jamEntry();
  2318.   ndbrequire(false);
  2319. }
  2322. void Ndbcntr::execSTOP_ME_CONF(Signal* signal){
  2323.   jamEntry();
  2325.   NodeState newState(NodeState::SL_STOPPING_4, 
  2326.      StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
  2327.   updateNodeState(signal, newState);
  2328.   
  2329.   c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
  2330.   signal->theData[0] = ZSHUTDOWN;
  2331.   sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
  2332. }
  2334. void
  2335. Ndbcntr::StopRecord::checkLqhTimeout_2(Signal* signal){
  2336.   const Int32 timeout = stopReq.operationTimeout; 
  2337.   const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
  2338.   const NDB_TICKS now = NdbTick_CurrentMillisecond();
  2340.   if((timeout >= 0 && now >= alarm)){
  2341.     // || checkWithLqhInSomeMagicWay)
  2342.     jam();
  2343.     if(StopReq::getPerformRestart(stopReq.requestInfo)){
  2344.       jam();
  2345.       StartOrd * startOrd = (StartOrd *)&signal->theData[0];
  2346.       startOrd->restartInfo = stopReq.requestInfo;
  2347.       cntr.sendSignal(CMVMI_REF, GSN_START_ORD, signal, 2, JBA);
  2348.     } else {
  2349.       jam();
  2350.       cntr.sendSignal(CMVMI_REF, GSN_STOP_ORD, signal, 1, JBA);
  2351.     }
  2352.     return;
  2353.   }
  2354.   signal->theData[0] = ZSHUTDOWN;
  2355.   cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
  2356. }
  2358. void Ndbcntr::execWAIT_GCP_REF(Signal* signal){
  2359.   jamEntry();
  2360.   
  2361.   //WaitGCPRef* const ref = (WaitGCPRef*)&signal->theData[0];
  2363.   WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
  2364.   req->senderRef = reference();
  2365.   req->senderData = 12;
  2366.   req->requestType = WaitGCPReq::CompleteForceStart;
  2367.   sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal, 
  2368.      WaitGCPReq::SignalLength, JBB);
  2369. }
  2371. void Ndbcntr::execWAIT_GCP_CONF(Signal* signal){
  2372.   jamEntry();
  2374.   ndbrequire(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
  2375.   NodeState newState(NodeState::SL_STOPPING_3, true); 
  2377.   /**
  2378.    * Inform QMGR so that arbitrator won't kill us
  2379.    */
  2380.   NodeStateRep * rep = (NodeStateRep *)&signal->theData[0];
  2381.   rep->nodeState = newState;
  2382.   rep->nodeState.masterNodeId = cmasterNodeId;
  2383.   rep->nodeState.setNodeGroup(c_nodeGroup);
  2384.   EXECUTE_DIRECT(QMGR, GSN_NODE_STATE_REP, signal, NodeStateRep::SignalLength);
  2386.   if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo)){
  2387.     jam();
  2388.     StartOrd * startOrd = (StartOrd *)&signal->theData[0];
  2389.     startOrd->restartInfo = c_stopRec.stopReq.requestInfo;
  2390.     sendSignalWithDelay(CMVMI_REF, GSN_START_ORD, signal, 500, 
  2391. StartOrd::SignalLength);
  2392.   } else {
  2393.     jam();
  2394.     sendSignalWithDelay(CMVMI_REF, GSN_STOP_ORD, signal, 500, 1);
  2395.   }
  2396.   return;
  2397. }
  2399. void Ndbcntr::execSTTORRY(Signal* signal){
  2400.   jamEntry();
  2401.   c_missra.execSTTORRY(signal);
  2402. }
  2404. void Ndbcntr::execREAD_CONFIG_CONF(Signal* signal){
  2405.   jamEntry();
  2406.   c_missra.execREAD_CONFIG_CONF(signal);
  2407. }
  2409. void Ndbcntr::execSTART_ORD(Signal* signal){
  2410.   jamEntry();
  2411.   c_missra.execSTART_ORD(signal);
  2412. }
  2414. void
  2415. Ndbcntr::clearFilesystem(Signal* signal){
  2416.   FsRemoveReq * req  = (FsRemoveReq *)signal->getDataPtrSend();
  2417.   req->userReference = reference();
  2418.   req->userPointer   = 0;
  2419.   req->directory     = 1;
  2420.   req->ownDirectory  = 1;
  2421.   FsOpenReq::setVersion(req->fileNumber, 3);
  2422.   FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_CTL); // Can by any...
  2423.   FsOpenReq::v1_setDisk(req->fileNumber, c_fsRemoveCount);
  2424.   sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal, 
  2425.              FsRemoveReq::SignalLength, JBA);
  2426.   c_fsRemoveCount++;
  2427. }
  2429. void
  2430. Ndbcntr::execFSREMOVECONF(Signal* signal){
  2431.   jamEntry();
  2432.   if(c_fsRemoveCount == 13){
  2433.     jam();
  2434.     sendSttorry(signal);
  2435.   } else {
  2436.     jam();
  2437.     ndbrequire(c_fsRemoveCount < 13);
  2438.     clearFilesystem(signal);
  2439.   }//if
  2440. }
  2442. void Ndbcntr::Missra::execSTART_ORD(Signal* signal){
  2443.   signal->theData[0] = EventReport::NDBStartStarted;
  2444.   signal->theData[1] = NDB_VERSION;
  2445.   cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
  2447.   currentBlockIndex = 0;
  2448.   sendNextREAD_CONFIG_REQ(signal);
  2449. }
  2451. void Ndbcntr::Missra::sendNextREAD_CONFIG_REQ(Signal* signal){
  2453.   if(currentBlockIndex < ALL_BLOCKS_SZ){
  2454.     jam();
  2456.     ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtrSend();    
  2457.     req->senderData = 0;
  2458.     req->senderRef = cntr.reference();
  2459.     req->noOfParameters = 0;
  2460.     
  2461.     const BlockReference ref = ALL_BLOCKS[currentBlockIndex].Ref;
  2463. #if 0 
  2464.     ndbout_c("sending READ_CONFIG_REQ to %s(ref=%x index=%d)", 
  2465.      getBlockName( refToBlock(ref)),
  2466.      ref,
  2467.      currentBlockIndex);
  2468. #endif
  2469.     
  2470.     cntr.sendSignal(ref, GSN_READ_CONFIG_REQ, signal, 
  2471.     ReadConfigReq::SignalLength, JBB);
  2472.     return;
  2473.   }
  2474.   
  2475.   /**
  2476.    * Finished...
  2477.    */
  2478.   currentStartPhase = 0;
  2479.   for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
  2480.     if(ALL_BLOCKS[i].NextSP < currentStartPhase)
  2481.       currentStartPhase = ALL_BLOCKS[i].NextSP;
  2482.   }
  2483.   
  2484.   currentBlockIndex = 0;
  2485.   sendNextSTTOR(signal);
  2486. }
  2488. void Ndbcntr::Missra::execREAD_CONFIG_CONF(Signal* signal){
  2489.   const ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtr();
  2491.   const Uint32 ref = conf->senderRef;
  2492.   ndbrequire(refToBlock(ALL_BLOCKS[currentBlockIndex].Ref) == refToBlock(ref));
  2494.   currentBlockIndex++;
  2495.   sendNextREAD_CONFIG_REQ(signal);
  2496. }
  2498. void Ndbcntr::Missra::execSTTORRY(Signal* signal){
  2499.   const BlockReference ref = signal->senderBlockRef();
  2500.   ndbrequire(refToBlock(ref) == refToBlock(ALL_BLOCKS[currentBlockIndex].Ref));
  2501.   
  2502.   /**
  2503.    * Update next start phase
  2504.    */
  2505.   for (Uint32 i = 3; i < 25; i++){
  2506.     jam();
  2507.     if (signal->theData[i] > currentStartPhase){
  2508.       jam();
  2509.       ALL_BLOCKS[currentBlockIndex].NextSP = signal->theData[i];
  2510.       break;
  2511.     }
  2512.   }    
  2513.   
  2514.   currentBlockIndex++;
  2515.   sendNextSTTOR(signal);
  2516. }
  2518. void Ndbcntr::Missra::sendNextSTTOR(Signal* signal){
  2520.   for(; currentStartPhase < 255 ; currentStartPhase++){
  2521.     jam();
  2522.     
  2523.     const Uint32 start = currentBlockIndex;
  2524.     
  2525.     if (currentStartPhase == ZSTART_PHASE_6)
  2526.     {
  2527.       // Ndbd has passed the critical startphases.
  2528.       // Change error handler from "startup" state
  2529.       // to normal state.
  2530.       ErrorReporter::setErrorHandlerShutdownType();
  2531.     }
  2533.     for(; currentBlockIndex < ALL_BLOCKS_SZ; currentBlockIndex++){
  2534.       jam();
  2535.       if(ALL_BLOCKS[currentBlockIndex].NextSP == currentStartPhase){
  2536. jam();
  2537. signal->theData[0] = 0;
  2538. signal->theData[1] = currentStartPhase;
  2539. signal->theData[2] = 0;
  2540. signal->theData[3] = 0;
  2541. signal->theData[4] = 0;
  2542. signal->theData[5] = 0;
  2543. signal->theData[6] = 0;
  2544. signal->theData[7] = cntr.ctypeOfStart;
  2546. const BlockReference ref = ALL_BLOCKS[currentBlockIndex].Ref;
  2548. #ifdef MAX_STARTPHASE
  2549. ndbrequire(currentStartPhase <= MAX_STARTPHASE);
  2550. #endif
  2552. #ifdef TRACE_STTOR
  2553. ndbout_c("sending STTOR(%d) to %s(ref=%x index=%d)", 
  2554.  currentStartPhase,
  2555.  getBlockName( refToBlock(ref)),
  2556.  ref,
  2557.  currentBlockIndex);
  2558. #endif
  2560. cntr.sendSignal(ref, GSN_STTOR, signal, 8, JBB);
  2562. return;
  2563.       }
  2564.     }
  2565.     
  2566.     currentBlockIndex = 0;
  2568.     if(start != 0){
  2569.       /**
  2570.        * At least one wanted this start phase,  report it
  2571.        */
  2572.       jam();
  2573.       signal->theData[0] = EventReport::StartPhaseCompleted;
  2574.       signal->theData[1] = currentStartPhase;
  2575.       signal->theData[2] = cntr.ctypeOfStart;    
  2576.       cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
  2577.     }
  2578.   }
  2579.   
  2580.   signal->theData[0] = EventReport::NDBStartCompleted;
  2581.   signal->theData[1] = NDB_VERSION;
  2582.   cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
  2583.   
  2584.   NodeState newState(NodeState::SL_STARTED);
  2585.   cntr.updateNodeState(signal, newState);
  2587.   /**
  2588.    * Backward
  2589.    */
  2590.   UpgradeStartup::sendCmAppChg(cntr, signal, 3); //RUN
  2592.   NdbNodeBitmask nodes = cntr.c_clusterNodes;
  2593.   Uint32 node = 0;
  2594.   while((node = nodes.find(node+1)) != NdbNodeBitmask::NotFound){
  2595.     if(cntr.getNodeInfo(node).m_version < MAKE_VERSION(3,5,0)){
  2596.       nodes.clear(node);
  2597.     }
  2598.   }
  2599.   
  2600.   NodeReceiverGroup rg(NDBCNTR, nodes);
  2601.   signal->theData[0] = cntr.getOwnNodeId();
  2602.   cntr.sendSignal(rg, GSN_CNTR_START_REP, signal, 1, JBB);
  2603. }
  2605. /**
  2606.  * Backward compatible code
  2607.  */
  2608. void
  2609. UpgradeStartup::sendCmAppChg(Ndbcntr& cntr, Signal* signal, Uint32 startLevel){
  2610.   
  2611.   if(cntr.getNodeInfo(cntr.cmasterNodeId).m_version >= MAKE_VERSION(3,5,0)){
  2612.     jam();
  2613.     return;
  2614.   }
  2616.   /**
  2617.    * Old NDB running
  2618.    */
  2619.   
  2620.   signal->theData[0] = startLevel;
  2621.   signal->theData[1] = cntr.getOwnNodeId();
  2622.   signal->theData[2] = 3 | ('N' << 8);
  2623.   signal->theData[3] = 'D' | ('B' << 8);
  2624.   signal->theData[4] = 0;
  2625.   signal->theData[5] = 0;
  2626.   signal->theData[6] = 0;
  2627.   signal->theData[7] = 0;
  2628.   signal->theData[8] = 0;
  2629.   signal->theData[9] = 0;
  2630.   signal->theData[10] = 0;
  2631.   signal->theData[11] = 0;
  2632.   
  2633.   NdbNodeBitmask nodes = cntr.c_clusterNodes;
  2634.   nodes.clear(cntr.getOwnNodeId());
  2635.   Uint32 node = 0;
  2636.   while((node = nodes.find(node+1)) != NdbNodeBitmask::NotFound){
  2637.     if(cntr.getNodeInfo(node).m_version < MAKE_VERSION(3,5,0)){
  2638.       cntr.sendSignal(cntr.calcQmgrBlockRef(node),
  2639.       GSN_CM_APPCHG, signal, 12, JBB);
  2640.     } else {
  2641.       cntr.c_startedNodes.set(node); // Fake started
  2642.     }
  2643.   }
  2644. }
  2646. void
  2647. UpgradeStartup::execCM_APPCHG(SimulatedBlock & block, Signal* signal){
  2648.   Uint32 state = signal->theData[0];
  2649.   Uint32 nodeId = signal->theData[1];
  2650.   if(block.number() == QMGR){
  2651.     Ndbcntr& cntr = * (Ndbcntr*)globalData.getBlock(CNTR);
  2652.     switch(state){
  2653.     case 0: // ZADD
  2654.       break;
  2655.     case 2: // ZSTART
  2656.       break;
  2657.     case 3: // ZRUN{
  2658.       cntr.c_startedNodes.set(nodeId);
  2660.       Uint32 recv = cntr.c_startedNodes.count();
  2661.       Uint32 cnt = cntr.c_clusterNodes.count();
  2662.       if(recv + 1 == cnt){ //+1 == own node
  2663. /**
  2664.  * Check master
  2665.  */
  2666. sendCntrMasterReq(cntr, signal, 0);
  2667.       }
  2668.       return;
  2669.     }
  2670.   }
  2671.   block.progError(0,0);
  2672. }
  2674. void
  2675. UpgradeStartup::sendCntrMasterReq(Ndbcntr& cntr, Signal* signal, Uint32 n){
  2676.   Uint32 node = cntr.c_startedNodes.find(n);
  2677.   if(node != NdbNodeBitmask::NotFound && 
  2678.      (node == cntr.getOwnNodeId() || 
  2679.       cntr.getNodeInfo(node).m_version >= MAKE_VERSION(3,5,0))){
  2680.     node = cntr.c_startedNodes.find(node+1);
  2681.   }
  2682.   
  2683.   if(node == NdbNodeBitmask::NotFound){
  2684.     cntr.progError(0,0);
  2685.   }
  2687.   CntrMasterReq * const cntrMasterReq = (CntrMasterReq*)&signal->theData[0];
  2688.   cntr.c_clusterNodes.copyto(NdbNodeBitmask::Size, cntrMasterReq->theNodes);
  2689.   NdbNodeBitmask::clear(cntrMasterReq->theNodes, cntr.getOwnNodeId());
  2690.   cntrMasterReq->userBlockRef = 0;
  2691.   cntrMasterReq->userNodeId = cntr.getOwnNodeId();
  2692.   cntrMasterReq->typeOfStart = NodeState::ST_INITIAL_NODE_RESTART;
  2693.   cntrMasterReq->noRestartNodes = cntr.c_clusterNodes.count() - 1;
  2694.   cntr.sendSignal(cntr.calcNdbCntrBlockRef(node), GSN_CNTR_MASTERREQ,
  2695.   signal, CntrMasterReq::SignalLength, JBB);
  2696. }
  2698. void
  2699. UpgradeStartup::execCNTR_MASTER_REPLY(SimulatedBlock & block, Signal* signal){
  2700.   Uint32 gsn = signal->header.theVerId_signalNumber;
  2701.   Uint32 node = refToNode(signal->getSendersBlockRef());
  2702.   if(block.number() == CNTR){
  2703.     Ndbcntr& cntr = (Ndbcntr&)block;
  2704.     switch(gsn){
  2705.     case GSN_CNTR_MASTERREF:
  2706.       sendCntrMasterReq(cntr, signal, node + 1);
  2707.       return;
  2708.       break;
  2709.     case GSN_CNTR_MASTERCONF:{
  2710.       CntrStartConf* conf = (CntrStartConf*)signal->getDataPtrSend();
  2711.       conf->startGci = 0;
  2712.       conf->masterNodeId = node;
  2713.       conf->noStartNodes = 1;
  2714.       conf->startType = NodeState::ST_INITIAL_NODE_RESTART;
  2715.       NodeBitmask mask;
  2716.       mask.clear();
  2717.       mask.copyto(NdbNodeBitmask::Size, conf->startedNodes);
  2718.       mask.clear();
  2719.       mask.set(cntr.getOwnNodeId());
  2720.       mask.copyto(NdbNodeBitmask::Size, conf->startingNodes);
  2721.       cntr.execCNTR_START_CONF(signal);
  2722.       return;
  2723.     }
  2724.     }
  2725.   }
  2726.   block.progError(0,0);
  2727. }