QmgrMain.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:117k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #define QMGR_C
  14. #include "Qmgr.hpp"
  15. #include <pc.hpp>
  16. #include <NdbTick.h>
  17. #include <signaldata/EventReport.hpp>
  18. #include <signaldata/StartOrd.hpp>
  19. #include <signaldata/CmInit.hpp>
  20. #include <signaldata/CloseComReqConf.hpp>
  21. #include <signaldata/PrepFailReqRef.hpp>
  22. #include <signaldata/NodeFailRep.hpp>
  23. #include <signaldata/ReadNodesConf.hpp>
  24. #include <signaldata/NFCompleteRep.hpp>
  25. #include <signaldata/CheckNodeGroups.hpp>
  26. #include <signaldata/ArbitSignalData.hpp>
  27. #include <signaldata/ApiRegSignalData.hpp>
  28. #include <signaldata/ApiVersion.hpp>
  29. #include <signaldata/BlockCommitOrd.hpp>
  30. #include <signaldata/FailRep.hpp>
  31. #include <signaldata/DisconnectRep.hpp>
  32. #include <signaldata/ApiBroadcast.hpp>
  33. #include <ndb_version.h>
  34. #ifdef DEBUG_ARBIT
  35. #include <NdbOut.hpp>
  36. #endif
  37. //#define DEBUG_QMGR_START
  38. #ifdef DEBUG_QMGR_START
  39. #include <DebuggerNames.hpp>
  40. #define DEBUG(x) ndbout << "QMGR " << __LINE__ << ": " << x << endl
  41. #define DEBUG_START(gsn, node, msg) DEBUG(getSignalName(gsn) << " to: " << node << " - " << msg)
  42. #define DEBUG_START2(gsn, rg, msg) { char nodes[255]; DEBUG(getSignalName(gsn) << " to: " << rg.m_nodes.getText(nodes) << " - " << msg); }
  43. #define DEBUG_START3(signal, msg) DEBUG(getSignalName(signal->header.theVerId_signalNumber) << " from " << refToNode(signal->getSendersBlockRef()) << " - " << msg);
  44. #else
  45. #define DEBUG(x)
  46. #define DEBUG_START(gsn, node, msg)
  47. #define DEBUG_START2(gsn, rg, msg)
  48. #define DEBUG_START3(signal, msg)
  49. #endif
  50. // Signal entries and statement blocks
  51. /* 4  P R O G R A M        */
  52. /*******************************/
  53. /* CMHEART_BEAT               */
  54. /*******************************/
  55. void Qmgr::execCM_HEARTBEAT(Signal* signal) 
  56. {
  57.   NodeRecPtr hbNodePtr;
  58.   jamEntry();
  59.   hbNodePtr.i = signal->theData[0];
  60.   ptrCheckGuard(hbNodePtr, MAX_NDB_NODES, nodeRec);
  61.   hbNodePtr.p->alarmCount = 0;
  62.   return;
  63. }//Qmgr::execCM_HEARTBEAT()
  64. /*******************************/
  65. /* CM_NODEINFOREF             */
  66. /*******************************/
  67. void Qmgr::execCM_NODEINFOREF(Signal* signal) 
  68. {
  69.   jamEntry();
  70.   systemErrorLab(signal, __LINE__);
  71.   return;
  72. }//Qmgr::execCM_NODEINFOREF()
  73. /*******************************/
  74. /* CONTINUEB                  */
  75. /*******************************/
  76. void Qmgr::execCONTINUEB(Signal* signal) 
  77. {
  78.   jamEntry();
  79.   const Uint32 tcontinuebType = signal->theData[0];
  80.   const Uint32 tdata0 = signal->theData[1];
  81.   const Uint32 tdata1 = signal->theData[2];
  82.   switch (tcontinuebType) {
  83.   case ZREGREQ_TIMELIMIT:
  84.     jam();
  85.     if (c_start.m_startKey != tdata0 || c_start.m_startNode != tdata1) {
  86.       jam();
  87.       return;
  88.     }//if
  89.     regreqTimeLimitLab(signal);
  90.     break;
  91.   case ZREGREQ_MASTER_TIMELIMIT:
  92.     jam();
  93.     if (c_start.m_startKey != tdata0 || c_start.m_startNode != tdata1) {
  94.       jam();
  95.       return;
  96.     }//if
  97.     //regreqMasterTimeLimitLab(signal);
  98.     failReportLab(signal, c_start.m_startNode, FailRep::ZSTART_IN_REGREQ);
  99.     return;
  100.     break;
  101.   case ZTIMER_HANDLING:
  102.     jam();
  103.     timerHandlingLab(signal);
  104.     return;
  105.     break;
  106.   case ZARBIT_HANDLING:
  107.     jam();
  108.     runArbitThread(signal);
  109.     return;
  110.     break;
  111.   default:
  112.     jam();
  113.     // ZCOULD_NOT_OCCUR_ERROR;
  114.     systemErrorLab(signal, __LINE__);
  115.     return;
  116.     break;
  117.   }//switch
  118.   return;
  119. }//Qmgr::execCONTINUEB()
  120. void Qmgr::execDEBUG_SIG(Signal* signal) 
  121. {
  122.   NodeRecPtr debugNodePtr;
  123.   jamEntry();
  124.   debugNodePtr.i = signal->theData[0];
  125.   ptrCheckGuard(debugNodePtr, MAX_NODES, nodeRec);
  126.   return;
  127. }//Qmgr::execDEBUG_SIG()
  128. /*******************************/
  129. /* FAIL_REP                   */
  130. /*******************************/
  131. void Qmgr::execFAIL_REP(Signal* signal) 
  132. {
  133.   const FailRep * const failRep = (FailRep *)&signal->theData[0];
  134.   const NodeId failNodeId = failRep->failNodeId;
  135.   const FailRep::FailCause failCause = (FailRep::FailCause)failRep->failCause; 
  136.   
  137.   jamEntry();
  138.   failReportLab(signal, failNodeId, failCause);
  139.   return;
  140. }//Qmgr::execFAIL_REP()
  141. /*******************************/
  142. /* PRES_TOREQ                 */
  143. /*******************************/
  144. void Qmgr::execPRES_TOREQ(Signal* signal) 
  145. {
  146.   jamEntry();
  147.   BlockReference Tblockref = signal->theData[0];
  148.   signal->theData[0] = getOwnNodeId();
  149.   signal->theData[1] = ccommitFailureNr;
  150.   sendSignal(Tblockref, GSN_PRES_TOCONF, signal, 2, JBA);
  151.   return;
  152. }//Qmgr::execPRES_TOREQ()
  153. /*
  154. 4.2  ADD NODE MODULE*/
  155. /*##########################################################################*/
  156. /*
  157. 4.2.1 STTOR     */
  158. /**--------------------------------------------------------------------------
  159.  * Start phase signal, must be handled by all blocks. 
  160.  * QMGR is only interested in the first phase. 
  161.  * During phase one we clear all registered applications. 
  162.  *---------------------------------------------------------------------------*/
  163. /*******************************/
  164. /* STTOR                      */
  165. /*******************************/
  166. void Qmgr::execSTTOR(Signal* signal) 
  167. {
  168.   jamEntry();
  169.   
  170.   switch(signal->theData[1]){
  171.   case 1:
  172.     initData(signal);
  173.     startphase1(signal);
  174.     return;
  175.   case 7:
  176.     cactivateApiCheck = 1;
  177.     /**
  178.      * Start arbitration thread.  This could be done as soon as
  179.      * we have all nodes (or a winning majority).
  180.      */
  181.     if (cpresident == getOwnNodeId())
  182.       handleArbitStart(signal);
  183.     break;
  184.   }
  185.   
  186.   sendSttorryLab(signal);
  187.   return;
  188. }//Qmgr::execSTTOR()
  189. void Qmgr::sendSttorryLab(Signal* signal) 
  190. {
  191. /****************************<*/
  192. /*< STTORRY                  <*/
  193. /****************************<*/
  194.   signal->theData[3] = 7;
  195.   signal->theData[4] = 255;
  196.   sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB);
  197.   return;
  198. }//Qmgr::sendSttorryLab()
  199. void Qmgr::startphase1(Signal* signal) 
  200. {
  201.   jamEntry();
  202.   
  203.   NodeRecPtr nodePtr;
  204.   nodePtr.i = getOwnNodeId();
  205.   ptrAss(nodePtr, nodeRec);
  206.   nodePtr.p->phase = ZSTARTING;
  207.   nodePtr.p->blockRef = reference();
  208.   c_connectedNodes.set(nodePtr.i);
  209.   signal->theData[0] = 0; // no answer
  210.   signal->theData[1] = 0; // no id
  211.   signal->theData[2] = NodeInfo::DB;
  212.   sendSignal(CMVMI_REF, GSN_OPEN_COMREQ, signal, 3, JBB);
  213.   execCM_INFOCONF(signal);
  214.   return;
  215. }
  216. void Qmgr::setHbDelay(UintR aHbDelay)
  217. {
  218.   hb_send_timer.setDelay(aHbDelay < 10 ? 10 : aHbDelay);
  219.   hb_send_timer.reset();
  220.   hb_check_timer.setDelay(aHbDelay < 10 ? 10 : aHbDelay);
  221.   hb_check_timer.reset();
  222. }
  223. void Qmgr::setHbApiDelay(UintR aHbApiDelay)
  224. {
  225.   chbApiDelay = (aHbApiDelay < 100 ? 100 : aHbApiDelay);
  226.   hb_api_timer.setDelay(chbApiDelay);
  227.   hb_api_timer.reset();
  228. }
  229. void Qmgr::setArbitTimeout(UintR aArbitTimeout)
  230. {
  231.   arbitRec.timeout = (aArbitTimeout < 10 ? 10 : aArbitTimeout);
  232. }
  233. void Qmgr::execCONNECT_REP(Signal* signal)
  234. {
  235.   const Uint32 nodeId = signal->theData[0];
  236.   c_connectedNodes.set(nodeId);
  237.   NodeRecPtr nodePtr;
  238.   nodePtr.i = getOwnNodeId();
  239.   ptrCheckGuard(nodePtr, MAX_NODES, nodeRec);
  240.   switch(nodePtr.p->phase){
  241.   case ZSTARTING:
  242.     jam();
  243.     break;
  244.   case ZRUNNING:
  245.   case ZPREPARE_FAIL:
  246.   case ZFAIL_CLOSING:
  247.     jam();
  248.     return;
  249.   case ZINIT:
  250.     ndbrequire(false);
  251.   case ZAPI_ACTIVE:
  252.   case ZAPI_INACTIVE:
  253.     return;
  254.   }
  255.   if(!c_start.m_nodes.isWaitingFor(nodeId)){
  256.     jam();
  257.     return;
  258.   }
  259.   switch(c_start.m_gsn){
  260.   case GSN_CM_REGREQ:
  261.     jam();
  262.     sendCmRegReq(signal, nodeId);
  263.     return;
  264.   case GSN_CM_NODEINFOREQ:{
  265.     jam();
  266.     sendCmNodeInfoReq(signal, nodeId, nodePtr.p);
  267.     return;
  268.   }
  269.   default:
  270.     return;
  271.   }
  272.   return;
  273. }//Qmgr::execCONNECT_REP()
  274. /*******************************/
  275. /* CM_INFOCONF                */
  276. /*******************************/
  277. void Qmgr::execCM_INFOCONF(Signal* signal) 
  278. {
  279.   cpresident = ZNIL;
  280.   cpresidentCandidate = getOwnNodeId();
  281.   cpresidentAlive = ZFALSE;
  282.   c_stopElectionTime = NdbTick_CurrentMillisecond();
  283.   c_stopElectionTime += c_restartPartialTimeout;
  284.   cmInfoconf010Lab(signal);
  285.   
  286.   return;
  287. }//Qmgr::execCM_INFOCONF()
  288. void Qmgr::cmInfoconf010Lab(Signal* signal) 
  289. {
  290.   c_start.m_startKey = 0;
  291.   c_start.m_startNode = getOwnNodeId();
  292.   c_start.m_nodes.clearWaitingFor();
  293.   c_start.m_gsn = GSN_CM_REGREQ;
  294.   NodeRecPtr nodePtr;
  295.   c_regReqReqSent = c_regReqReqRecv = 0;
  296.   cnoOfNodes = 0;
  297.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  298.     jam();
  299.     ptrAss(nodePtr, nodeRec);
  300.     
  301.     if(getNodeInfo(nodePtr.i).getType() != NodeInfo::DB)
  302.       continue;
  303.     c_start.m_nodes.setWaitingFor(nodePtr.i);    
  304.     cnoOfNodes++;
  305.     if(!c_connectedNodes.get(nodePtr.i))
  306.       continue;
  307.     
  308.     sendCmRegReq(signal, nodePtr.i);
  309.   }
  310.   
  311.   //----------------------------------------
  312.   /* Wait for a while. When it returns    */
  313.   /* we will check if we got any CM_REGREF*/
  314.   /* or CM_REGREQ (lower nodeid than our  */
  315.   /* own).                                */
  316.   //----------------------------------------
  317.   signal->theData[0] = ZREGREQ_TIMELIMIT;
  318.   signal->theData[1] = c_start.m_startKey;
  319.   signal->theData[2] = c_start.m_startNode;
  320.   sendSignalWithDelay(QMGR_REF, GSN_CONTINUEB, signal, 3000, 3);
  321.   creadyDistCom = ZTRUE;
  322.   return;
  323. }//Qmgr::cmInfoconf010Lab()
  324. void
  325. Qmgr::sendCmRegReq(Signal * signal, Uint32 nodeId){
  326.   c_regReqReqSent++;
  327.   CmRegReq * const cmRegReq = (CmRegReq *)&signal->theData[0];
  328.   cmRegReq->blockRef = reference();
  329.   cmRegReq->nodeId   = getOwnNodeId();
  330.   cmRegReq->version  = NDB_VERSION;
  331.   const Uint32 ref = calcQmgrBlockRef(nodeId);
  332.   sendSignal(ref, GSN_CM_REGREQ, signal, CmRegReq::SignalLength, JBB);
  333.   DEBUG_START(GSN_CM_REGREQ, nodeId, "");
  334. }
  335. /*
  336. 4.4.11 CM_REGREQ */
  337. /**--------------------------------------------------------------------------
  338.  * If this signal is received someone tries to get registrated. 
  339.  * Only the president have the authority make decissions about new nodes, 
  340.  * so only a president or a node that claims to be the president may send a 
  341.  * reply to this signal. 
  342.  * This signal can occur any time after that STTOR was received. 
  343.  * CPRESIDENT:             Timelimit has expired and someone has 
  344.  *                         decided to enter the president role
  345.  * CPRESIDENT_CANDIDATE:
  346.  *     Assigned when we receive a CM_REGREF, if we got more than one REF 
  347.  *     then we always keep the lowest nodenumber. 
  348.  *     We accept this nodeno as president when our timelimit expires
  349.  * We should consider the following cases: 
  350.  * 1- We are the president. If we are busy by adding new nodes to cluster, 
  351.  *    then we have to refuse this node to be added. 
  352.  *    The refused node will try in ZREFUSE_ADD_TIME seconds again. 
  353.  *    If we are not busy then we confirm
  354.  *
  355.  * 2- We know the president, we dont bother us about this REQ. 
  356.  *    The president has also got this REQ and will take care of it.
  357.  *
  358.  * 3- The president are not known. We have received CM_INIT, so we compare the
  359.  *    senders node number to GETOWNNODEID().
  360.  *    If we have a lower number than the sender then we will claim 
  361.  *    that we are the president so we send him a refuse signal back. 
  362.  *    We have to wait for the CONTINUEB signal before we can enter the 
  363.  *    president role. If our GETOWNNODEID() if larger than sender node number, 
  364.  *    we are not the president and just have to wait for the 
  365.  *    reply signal (REF)  to our CM_REGREQ_2. 
  366.  * 4- We havent received the CM_INIT signal so we don't know who we are. 
  367.  *    Ignore the request.
  368.  *--------------------------------------------------------------------------*/
  369. /*******************************/
  370. /* CM_REGREQ                  */
  371. /*******************************/
  372. void Qmgr::execCM_REGREQ(Signal* signal) 
  373. {
  374.   DEBUG_START3(signal, "");
  375.   NodeRecPtr addNodePtr;
  376.   jamEntry();
  377.   CmRegReq * const cmRegReq = (CmRegReq *)&signal->theData[0];
  378.   const BlockReference Tblockref = cmRegReq->blockRef;
  379.   const Uint32 startingVersion = cmRegReq->version;
  380.   addNodePtr.i = cmRegReq->nodeId;
  381.   
  382.   if (creadyDistCom == ZFALSE) {
  383.     jam();
  384.     /* NOT READY FOR DISTRIBUTED COMMUNICATION.*/
  385.     return;                                                
  386.   }//if
  387.   
  388.   if (!ndbCompatible_ndb_ndb(NDB_VERSION, startingVersion)) {
  389.     jam();
  390.     sendCmRegrefLab(signal, Tblockref, CmRegRef::ZINCOMPATIBLE_VERSION);
  391.     return;
  392.   }
  393.   ptrCheckGuard(addNodePtr, MAX_NDB_NODES, nodeRec);
  394.   if (cpresident != getOwnNodeId()){
  395.     jam();                      
  396.     if (cpresident == ZNIL) {
  397.       /***
  398.        * We don't know the president. 
  399.        * If the node to be added has lower node id 
  400.        * than our president cancidate. Set it as 
  401.        * candidate
  402.        */
  403.       jam(); 
  404.       if (addNodePtr.i < cpresidentCandidate) {
  405. jam();
  406. cpresidentCandidate = addNodePtr.i;
  407.       }//if
  408.       sendCmRegrefLab(signal, Tblockref, CmRegRef::ZELECTION);
  409.       return;
  410.     }                                 
  411.     /**
  412.      * We are not the president.
  413.      * We know the president.
  414.      * President will answer.
  415.      */
  416.     sendCmRegrefLab(signal, Tblockref, CmRegRef::ZNOT_PRESIDENT);
  417.     return;
  418.   }//if
  419.   if (c_start.m_startNode != 0){
  420.     jam();
  421.     /**
  422.      * President busy by adding another node
  423.     */
  424.     sendCmRegrefLab(signal, Tblockref, CmRegRef::ZBUSY_PRESIDENT);
  425.     return;
  426.   }//if
  427.   
  428.   if (ctoStatus == Q_ACTIVE) {   
  429.     jam();
  430.     /**
  431.      * Active taking over as president
  432.      */
  433.     sendCmRegrefLab(signal, Tblockref, CmRegRef::ZBUSY_TO_PRES);
  434.     return;
  435.   }//if
  436.   if (getNodeInfo(addNodePtr.i).m_type != NodeInfo::DB) {
  437.     jam(); 
  438.     /** 
  439.      * The new node is not in config file
  440.      */
  441.     sendCmRegrefLab(signal, Tblockref, CmRegRef::ZNOT_IN_CFG);
  442.     return;
  443.   } 
  444.   
  445.   Phase phase = addNodePtr.p->phase;
  446.   if (phase != ZINIT){
  447.     jam();
  448.     DEBUG("phase = " << phase);
  449.     sendCmRegrefLab(signal, Tblockref, CmRegRef::ZNOT_DEAD);
  450.     return;
  451.   }//if
  452.   
  453.   jam(); 
  454.   /**
  455.    * WE ARE PRESIDENT AND WE ARE NOT BUSY ADDING ANOTHER NODE. 
  456.    * WE WILL TAKE CARE OF THE INCLUSION OF THIS NODE INTO THE CLUSTER.
  457.    * WE NEED TO START TIME SUPERVISION OF THIS. SINCE WE CANNOT STOP 
  458.    * TIMED SIGNAL IF THE INCLUSION IS INTERRUPTED WE IDENTIFY 
  459.    * EACH INCLUSION WITH A UNIQUE IDENTITY. THIS IS CHECKED WHEN 
  460.    * THE SIGNAL ARRIVES. IF IT HAS CHANGED THEN WE SIMPLY IGNORE 
  461.    * THE TIMED SIGNAL. 
  462.    */
  463.   /**
  464.    * Update start record
  465.    */
  466.   c_start.m_startKey++;
  467.   c_start.m_startNode = addNodePtr.i;
  468.   
  469.   /**
  470.    * Assign dynamic id
  471.    */
  472.   UintR TdynId = ++c_maxDynamicId;
  473.   setNodeInfo(addNodePtr.i).m_version = startingVersion;
  474.   addNodePtr.p->ndynamicId = TdynId;
  475.   
  476.   /**
  477.    * Reply with CM_REGCONF
  478.    */
  479.   CmRegConf * const cmRegConf = (CmRegConf *)&signal->theData[0];
  480.   cmRegConf->presidentBlockRef = reference();
  481.   cmRegConf->presidentNodeId   = getOwnNodeId();
  482.   cmRegConf->presidentVersion  = getNodeInfo(getOwnNodeId()).m_version;
  483.   cmRegConf->dynamicId         = TdynId;
  484.   c_clusterNodes.copyto(NdbNodeBitmask::Size, cmRegConf->allNdbNodes);
  485.   sendSignal(Tblockref, GSN_CM_REGCONF, signal, 
  486.      CmRegConf::SignalLength, JBA);
  487.   DEBUG_START(GSN_CM_REGCONF, refToNode(Tblockref), "");
  488.   /**
  489.    * Send CmAdd to all nodes (including starting)
  490.    */
  491.   c_start.m_nodes = c_clusterNodes;
  492.   c_start.m_nodes.setWaitingFor(addNodePtr.i);
  493.   c_start.m_gsn = GSN_CM_ADD;
  494.   NodeReceiverGroup rg(QMGR, c_start.m_nodes);
  495.   CmAdd * const cmAdd = (CmAdd*)signal->getDataPtrSend();
  496.   cmAdd->requestType = CmAdd::Prepare;
  497.   cmAdd->startingNodeId = addNodePtr.i; 
  498.   cmAdd->startingVersion = startingVersion;
  499.   sendSignal(rg, GSN_CM_ADD, signal, CmAdd::SignalLength, JBA);
  500.   DEBUG_START2(GSN_CM_ADD, rg, "Prepare");
  501.   
  502.   /**
  503.    * Set timer
  504.    */
  505.   return;
  506.   signal->theData[0] = ZREGREQ_MASTER_TIMELIMIT;
  507.   signal->theData[1] = c_start.m_startKey;
  508.   sendSignalWithDelay(QMGR_REF, GSN_CONTINUEB, signal, 30000, 2);
  509.   return;
  510. }//Qmgr::execCM_REGREQ()
  511. void Qmgr::sendCmRegrefLab(Signal* signal, BlockReference TBRef, 
  512.    CmRegRef::ErrorCode Terror) 
  513. {
  514.   CmRegRef* ref = (CmRegRef*)signal->getDataPtrSend();
  515.   ref->blockRef = reference();
  516.   ref->nodeId = getOwnNodeId();
  517.   ref->errorCode = Terror;
  518.   ref->presidentCandidate = (cpresident == ZNIL ? cpresidentCandidate : cpresident);
  519.   sendSignal(TBRef, GSN_CM_REGREF, signal, 
  520.      CmRegRef::SignalLength, JBB);
  521.   DEBUG_START(GSN_CM_REGREF, refToNode(TBRef), "");
  522.   return;
  523. }//Qmgr::sendCmRegrefLab()
  524. /*
  525. 4.4.11 CM_REGCONF */
  526. /**--------------------------------------------------------------------------
  527.  * President gives permission to a node which wants to join the cluster. 
  528.  * The president will prepare the cluster that a new node will be added to 
  529.  * cluster. When the new node has set up all connections to the cluster, 
  530.  * the president will send commit to all clusternodes so the phase of the 
  531.  * new node can be changed to ZRUNNING. 
  532.  *--------------------------------------------------------------------------*/
  533. /*******************************/
  534. /* CM_REGCONF                 */
  535. /*******************************/
  536. void Qmgr::execCM_REGCONF(Signal* signal) 
  537. {
  538.   DEBUG_START3(signal, "");
  539.   NodeRecPtr myNodePtr;
  540.   NodeRecPtr nodePtr;
  541.   jamEntry();
  542.   const CmRegConf * const cmRegConf = (CmRegConf *)&signal->theData[0];
  543.   if (!ndbCompatible_ndb_ndb(NDB_VERSION, cmRegConf->presidentVersion)) {
  544.     jam();
  545.     char buf[128];
  546.     BaseString::snprintf(buf,sizeof(buf),"incompatible version own=0x%x other=0x%x, shutting down", NDB_VERSION, cmRegConf->presidentVersion);
  547.     systemErrorLab(signal, __LINE__, buf);
  548.     return;
  549.   }
  550.   cpdistref    = cmRegConf->presidentBlockRef;
  551.   cpresident   = cmRegConf->presidentNodeId;
  552.   UintR TdynamicId   = cmRegConf->dynamicId;
  553.   c_maxDynamicId = TdynamicId;
  554.   c_clusterNodes.assign(NdbNodeBitmask::Size, cmRegConf->allNdbNodes);
  555. /*--------------------------------------------------------------*/
  556. // Send this as an EVENT REPORT to inform about hearing about
  557. // other NDB node proclaiming to be president.
  558. /*--------------------------------------------------------------*/
  559.   signal->theData[0] = EventReport::CM_REGCONF;
  560.   signal->theData[1] = getOwnNodeId();
  561.   signal->theData[2] = cpresident;
  562.   signal->theData[3] = TdynamicId;
  563.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB);
  564.   myNodePtr.i = getOwnNodeId();
  565.   ptrCheckGuard(myNodePtr, MAX_NDB_NODES, nodeRec);
  566.   myNodePtr.p->ndynamicId = TdynamicId;
  567.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  568.     jam();
  569.     if (c_clusterNodes.get(nodePtr.i)){
  570.       jam();
  571.       ptrAss(nodePtr, nodeRec);
  572.       ndbrequire(nodePtr.p->phase == ZINIT);
  573.       nodePtr.p->phase = ZRUNNING;
  574.       if(c_connectedNodes.get(nodePtr.i)){
  575. jam();
  576. sendCmNodeInfoReq(signal, nodePtr.i, myNodePtr.p);
  577.       }
  578.     }
  579.   }
  580.   c_start.m_gsn = GSN_CM_NODEINFOREQ;
  581.   c_start.m_nodes = c_clusterNodes;
  582.   return;
  583. }//Qmgr::execCM_REGCONF()
  584. void
  585. Qmgr::sendCmNodeInfoReq(Signal* signal, Uint32 nodeId, const NodeRec * self){
  586.   CmNodeInfoReq * const req = (CmNodeInfoReq*)signal->getDataPtrSend();
  587.   req->nodeId = getOwnNodeId();
  588.   req->dynamicId = self->ndynamicId;
  589.   req->version = getNodeInfo(getOwnNodeId()).m_version;
  590.   const Uint32 ref = calcQmgrBlockRef(nodeId);
  591.   sendSignal(ref,GSN_CM_NODEINFOREQ, signal, CmNodeInfoReq::SignalLength, JBB);
  592.   DEBUG_START(GSN_CM_NODEINFOREQ, nodeId, "");
  593. }
  594. /*
  595. 4.4.11 CM_REGREF */
  596. /**--------------------------------------------------------------------------
  597.  * Only a president or a president candidate can refuse a node to get added to
  598.  * the cluster.
  599.  * Refuse reasons: 
  600.  * ZBUSY         We know that the sender is the president and we have to 
  601.  *               make a new CM_REGREQ.
  602.  * ZNOT_IN_CFG   This node number is not specified in the configfile, 
  603.  *               SYSTEM ERROR
  604.  * ZELECTION     Sender is a president candidate, his timelimit 
  605.  *               hasn't expired so maybe someone else will show up. 
  606.  *               Update the CPRESIDENT_CANDIDATE, then wait for our 
  607.  *               timelimit to expire. 
  608.  *---------------------------------------------------------------------------*/
  609. /*******************************/
  610. /* CM_REGREF                  */
  611. /*******************************/
  612. void Qmgr::execCM_REGREF(Signal* signal) 
  613. {
  614.   jamEntry();
  615.   c_regReqReqRecv++;
  616.   // Ignore block reference in data[0]
  617.   UintR TaddNodeno = signal->theData[1];
  618.   UintR TrefuseReason = signal->theData[2];
  619.   Uint32 candidate = signal->theData[3];
  620.   DEBUG_START3(signal, TrefuseReason);
  621.   
  622.   if(candidate != cpresidentCandidate){
  623.     jam();
  624.     c_regReqReqRecv = ~0;
  625.   }
  626.   switch (TrefuseReason) {
  627.   case CmRegRef::ZINCOMPATIBLE_VERSION:
  628.     jam();
  629.     systemErrorLab(signal, __LINE__, "incompatible version, connection refused by running ndb node");
  630.     break;
  631.   case CmRegRef::ZBUSY:
  632.   case CmRegRef::ZBUSY_TO_PRES:
  633.   case CmRegRef::ZBUSY_PRESIDENT:
  634.     jam();
  635.     cpresidentAlive = ZTRUE;
  636.     signal->theData[3] = 0;
  637.     break;
  638.   case CmRegRef::ZNOT_IN_CFG:
  639.     jam();
  640.     progError(__LINE__, ERR_NODE_NOT_IN_CONFIG);
  641.     break;
  642.   case CmRegRef::ZNOT_DEAD:
  643.     jam();
  644.     progError(__LINE__, ERR_NODE_NOT_DEAD);
  645.     break;
  646.   case CmRegRef::ZELECTION:
  647.     jam();
  648.     if (cpresidentCandidate > TaddNodeno) {
  649.       jam();
  650.       //----------------------------------------
  651.       /* We may already have a candidate      */
  652.       /* choose the lowest nodeno             */
  653.       //----------------------------------------
  654.       signal->theData[3] = 2;
  655.       cpresidentCandidate = TaddNodeno;
  656.     } else {
  657.       signal->theData[3] = 4;
  658.     }//if
  659.     break;
  660.   case CmRegRef::ZNOT_PRESIDENT:
  661.     jam();
  662.     cpresidentAlive = ZTRUE;
  663.     signal->theData[3] = 3;
  664.     break;
  665.   default:
  666.     jam();
  667.     signal->theData[3] = 5;
  668.     /*empty*/;
  669.     break;
  670.   }//switch
  671. /*--------------------------------------------------------------*/
  672. // Send this as an EVENT REPORT to inform about hearing about
  673. // other NDB node proclaiming not to be president.
  674. /*--------------------------------------------------------------*/
  675.   signal->theData[0] = EventReport::CM_REGREF;
  676.   signal->theData[1] = getOwnNodeId();
  677.   signal->theData[2] = TaddNodeno;
  678. //-----------------------------------------
  679. // signal->theData[3] filled in above
  680. //-----------------------------------------
  681.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 4, JBB);
  682.   if(cpresidentAlive == ZTRUE){
  683.     jam();
  684.     DEBUG("");
  685.     return;
  686.   }
  687.   
  688.   if(c_regReqReqSent != c_regReqReqRecv){
  689.     jam();
  690.     DEBUG( c_regReqReqSent << " != " << c_regReqReqRecv);
  691.     return;
  692.   }
  693.   
  694.   if(cpresidentCandidate != getOwnNodeId()){
  695.     jam();
  696.     DEBUG("");
  697.     return;
  698.   }
  699.   /**
  700.    * All configured nodes has agreed
  701.    */
  702.   Uint64 now = NdbTick_CurrentMillisecond();
  703.   if((c_regReqReqRecv == cnoOfNodes) || now > c_stopElectionTime){
  704.     jam();
  705.     electionWon();
  706.     sendSttorryLab(signal);
  707.     
  708.     /**
  709.      * Start timer handling 
  710.      */
  711.     signal->theData[0] = ZTIMER_HANDLING;
  712.     sendSignal(QMGR_REF, GSN_CONTINUEB, signal, 10, JBB);
  713.   }
  714.   
  715.   return;
  716. }//Qmgr::execCM_REGREF()
  717. void
  718. Qmgr::electionWon(){
  719.   NodeRecPtr myNodePtr;
  720.   cpresident = getOwnNodeId(); /* This node becomes president. */
  721.   myNodePtr.i = getOwnNodeId();
  722.   ptrCheckGuard(myNodePtr, MAX_NDB_NODES, nodeRec);
  723.   
  724.   myNodePtr.p->phase = ZRUNNING;
  725.   cpdistref = reference();
  726.   cneighbourl = ZNIL;
  727.   cneighbourh = ZNIL;
  728.   myNodePtr.p->ndynamicId = 1;
  729.   c_maxDynamicId = 1;
  730.   c_clusterNodes.clear();
  731.   c_clusterNodes.set(getOwnNodeId());
  732.   
  733.   cpresidentAlive = ZTRUE;
  734.   c_stopElectionTime = ~0;
  735.   c_start.reset();
  736. }
  737. /*
  738. 4.4.11 CONTINUEB */
  739. /*--------------------------------------------------------------------------*/
  740. /*                                                                          */
  741. /*--------------------------------------------------------------------------*/
  742. /****************************>---------------------------------------------*/
  743. /* CONTINUEB                 >        SENDER: Own block, Own node          */
  744. /****************************>-------+INPUT : TCONTINUEB_TYPE              */
  745. /*--------------------------------------------------------------*/
  746. void Qmgr::regreqTimeLimitLab(Signal* signal) 
  747. {
  748.   if(cpresident == ZNIL){
  749.     cmInfoconf010Lab(signal);
  750.   }
  751. }//Qmgr::regreqTimelimitLab()
  752. /**---------------------------------------------------------------------------
  753.  * The new node will take care of giving information about own node and ask 
  754.  * all other nodes for nodeinfo. The new node will use CM_NODEINFOREQ for 
  755.  * that purpose. When the setup of connections to all running, the president 
  756.  * will send a commit to all running nodes + the new node 
  757.  * INPUT: NODE_PTR1, must be set as ZNIL if we don't enter CONNECT_NODES) 
  758.  *                   from signal CM_NODEINFOCONF. 
  759.  *---------------------------------------------------------------------------*/
  760. /*******************************/
  761. /* CM_NODEINFOCONF            */
  762. /*******************************/
  763. void Qmgr::execCM_NODEINFOCONF(Signal* signal) 
  764. {
  765.   DEBUG_START3(signal, "");
  766.   jamEntry();
  767.   CmNodeInfoConf * const conf = (CmNodeInfoConf*)signal->getDataPtr();
  768.   const Uint32 nodeId = conf->nodeId;
  769.   const Uint32 dynamicId = conf->dynamicId;
  770.   const Uint32 version = conf->version;
  771.   NodeRecPtr nodePtr;  
  772.   nodePtr.i = getOwnNodeId();
  773.   ptrAss(nodePtr, nodeRec);  
  774.   ndbrequire(nodePtr.p->phase == ZSTARTING);
  775.   ndbrequire(c_start.m_gsn == GSN_CM_NODEINFOREQ);
  776.   c_start.m_nodes.clearWaitingFor(nodeId);
  777.   /**
  778.    * Update node info
  779.    */
  780.   NodeRecPtr replyNodePtr;
  781.   replyNodePtr.i = nodeId;
  782.   ptrCheckGuard(replyNodePtr, MAX_NDB_NODES, nodeRec);
  783.   replyNodePtr.p->ndynamicId = dynamicId;
  784.   replyNodePtr.p->blockRef = signal->getSendersBlockRef();
  785.   setNodeInfo(replyNodePtr.i).m_version = version;
  786.   if(!c_start.m_nodes.done()){
  787.     jam();
  788.     return;
  789.   }
  790.   /**********************************************<*/
  791.   /* Send an ack. back to the president.          */
  792.   /* CM_ACKADD                                    */
  793.   /* The new node has been registered by all      */
  794.   /* running nodes and has stored nodeinfo about  */
  795.   /* all running nodes. The new node has to wait  */
  796.   /* for CM_ADD (commit) from president to become */
  797.   /* a running node in the cluster.               */
  798.   /**********************************************<*/
  799.   sendCmAckAdd(signal, getOwnNodeId(), CmAdd::Prepare);
  800.   return;
  801. }//Qmgr::execCM_NODEINFOCONF()
  802. /**---------------------------------------------------------------------------
  803.  * A new node sends nodeinfo about himself. The new node asks for 
  804.  * corresponding nodeinfo back in the  CM_NODEINFOCONF.  
  805.  *---------------------------------------------------------------------------*/
  806. /*******************************/
  807. /* CM_NODEINFOREQ             */
  808. /*******************************/
  809. void Qmgr::execCM_NODEINFOREQ(Signal* signal) 
  810. {
  811.   jamEntry();
  812.   const Uint32 Tblockref = signal->getSendersBlockRef();
  813.   NodeRecPtr nodePtr;  
  814.   nodePtr.i = getOwnNodeId();
  815.   ptrAss(nodePtr, nodeRec);  
  816.   if(nodePtr.p->phase != ZRUNNING){
  817.     jam();
  818.     signal->theData[0] = reference();
  819.     signal->theData[1] = getOwnNodeId();
  820.     signal->theData[2] = ZNOT_RUNNING;
  821.     sendSignal(Tblockref, GSN_CM_NODEINFOREF, signal, 3, JBB);
  822.     return;
  823.   }
  824.   NodeRecPtr addNodePtr;
  825.   CmNodeInfoReq * const req = (CmNodeInfoReq*)signal->getDataPtr();
  826.   addNodePtr.i = req->nodeId;
  827.   ptrCheckGuard(addNodePtr, MAX_NDB_NODES, nodeRec);
  828.   addNodePtr.p->ndynamicId = req->dynamicId;
  829.   addNodePtr.p->blockRef = signal->getSendersBlockRef();
  830.   setNodeInfo(addNodePtr.i).m_version = req->version;
  831.   c_maxDynamicId = req->dynamicId;
  832.   cmAddPrepare(signal, addNodePtr, nodePtr.p);
  833. }//Qmgr::execCM_NODEINFOREQ()
  834. void
  835. Qmgr::cmAddPrepare(Signal* signal, NodeRecPtr nodePtr, const NodeRec * self){
  836.   jam();
  837.   switch(nodePtr.p->phase){
  838.   case ZINIT:
  839.     jam();
  840.     nodePtr.p->phase = ZSTARTING;
  841.     return;
  842.   case ZFAIL_CLOSING:
  843.     jam();
  844. #ifdef VM_TRACE
  845.     ndbout_c("Enabling communication to CM_ADD node state=%d", 
  846.      nodePtr.p->phase);
  847. #endif
  848.     nodePtr.p->phase = ZSTARTING;
  849.     nodePtr.p->failState = NORMAL;
  850.     signal->theData[0] = 0;
  851.     signal->theData[1] = nodePtr.i;
  852.     sendSignal(CMVMI_REF, GSN_OPEN_COMREQ, signal, 2, JBA);
  853.     return;
  854.   case ZSTARTING:
  855.     break;
  856.   case ZRUNNING:
  857.   case ZPREPARE_FAIL:
  858.   case ZAPI_ACTIVE:
  859.   case ZAPI_INACTIVE:
  860.     ndbrequire(false);
  861.   }
  862.   
  863.   sendCmAckAdd(signal, nodePtr.i, CmAdd::Prepare);
  864.   /* President have prepared us */
  865.   CmNodeInfoConf * conf = (CmNodeInfoConf*)signal->getDataPtrSend();
  866.   conf->nodeId = getOwnNodeId();
  867.   conf->dynamicId = self->ndynamicId;
  868.   conf->version = getNodeInfo(getOwnNodeId()).m_version;
  869.   sendSignal(nodePtr.p->blockRef, GSN_CM_NODEINFOCONF, signal,
  870.      CmNodeInfoConf::SignalLength, JBB);
  871.   DEBUG_START(GSN_CM_NODEINFOCONF, refToNode(nodePtr.p->blockRef), "");
  872. }
  873. void
  874. Qmgr::sendCmAckAdd(Signal * signal, Uint32 nodeId, CmAdd::RequestType type){
  875.   
  876.   CmAckAdd * cmAckAdd = (CmAckAdd*)signal->getDataPtrSend();
  877.   cmAckAdd->requestType = type;
  878.   cmAckAdd->startingNodeId = nodeId;
  879.   cmAckAdd->senderNodeId = getOwnNodeId();
  880.   sendSignal(cpdistref, GSN_CM_ACKADD, signal, CmAckAdd::SignalLength, JBA);
  881.   DEBUG_START(GSN_CM_ACKADD, cpresident, "");
  882.   switch(type){
  883.   case CmAdd::Prepare:
  884.     return;
  885.   case CmAdd::AddCommit:
  886.   case CmAdd::CommitNew:
  887.     break;
  888.   }
  889.   signal->theData[0] = nodeId;
  890.   EXECUTE_DIRECT(NDBCNTR, GSN_CM_ADD_REP, signal, 1);
  891.   jamEntry();
  892. }
  893. /*
  894. 4.4.11 CM_ADD */
  895. /**--------------------------------------------------------------------------
  896.  * Prepare a running node to add a new node to the cluster. The running node 
  897.  * will change phase of the new node fron ZINIT to ZWAITING. The running node 
  898.  * will also mark that we have received a prepare. When the new node has sent 
  899.  * us nodeinfo we can send an acknowledgement back to the president. When all 
  900.  * running nodes has acknowledged the new node, the president will send a 
  901.  * commit and we can change phase of the new node to ZRUNNING. The president 
  902.  * will also send CM_ADD to himself.    
  903.  *---------------------------------------------------------------------------*/
  904. /*******************************/
  905. /* CM_ADD                     */
  906. /*******************************/
  907. void Qmgr::execCM_ADD(Signal* signal) 
  908. {
  909.   NodeRecPtr addNodePtr;
  910.   jamEntry();
  911.   NodeRecPtr nodePtr;
  912.   nodePtr.i = getOwnNodeId();
  913.   ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec);
  914.   CmAdd * const cmAdd = (CmAdd*)signal->getDataPtr();
  915.   const CmAdd::RequestType type = (CmAdd::RequestType)cmAdd->requestType;
  916.   addNodePtr.i = cmAdd->startingNodeId;
  917.   //const Uint32 startingVersion = cmAdd->startingVersion;
  918.   ptrCheckGuard(addNodePtr, MAX_NDB_NODES, nodeRec);
  919.   DEBUG_START3(signal, type);
  920.   if(nodePtr.p->phase == ZSTARTING){
  921.     jam();
  922.     /**
  923.      * We are joining...
  924.      */
  925.     ndbrequire(addNodePtr.i == nodePtr.i);
  926.     switch(type){
  927.     case CmAdd::Prepare:
  928.       ndbrequire(c_start.m_gsn == GSN_CM_NODEINFOREQ);
  929.       /**
  930.        * Wait for CM_NODEINFO_CONF
  931.        */
  932.       return;
  933.     case CmAdd::CommitNew:
  934.       /**
  935.        * Tata. we're in the cluster
  936.        */
  937.       joinedCluster(signal, addNodePtr);
  938.       return;
  939.     case CmAdd::AddCommit:
  940.       ndbrequire(false);
  941.     }
  942.   }
  943.   switch (type) {
  944.   case CmAdd::Prepare:
  945.     cmAddPrepare(signal, addNodePtr, nodePtr.p);
  946.     break;
  947.   case CmAdd::AddCommit:{
  948.     jam();
  949.     ndbrequire(addNodePtr.p->phase == ZSTARTING);
  950.     addNodePtr.p->phase = ZRUNNING;
  951.     addNodePtr.p->alarmCount = 0;
  952.     c_clusterNodes.set(addNodePtr.i);
  953.     findNeighbours(signal);
  954.     /**
  955.      * SEND A HEARTBEAT IMMEDIATELY TO DECREASE THE RISK THAT WE MISS EARLY
  956.      * HEARTBEATS. 
  957.      */
  958.     sendHeartbeat(signal);
  959.     /**
  960.      *  ENABLE COMMUNICATION WITH ALL BLOCKS WITH THE NEWLY ADDED NODE
  961.      */
  962.     signal->theData[0] = addNodePtr.i;
  963.     sendSignal(CMVMI_REF, GSN_ENABLE_COMORD, signal, 1, JBA);
  964.     sendCmAckAdd(signal, addNodePtr.i, CmAdd::AddCommit);
  965.     if(getOwnNodeId() != cpresident){
  966.       jam();
  967.       c_start.reset();
  968.     }
  969.     break;
  970.   }
  971.   case CmAdd::CommitNew:
  972.     jam();
  973.     ndbrequire(false);
  974.   }
  975. }//Qmgr::execCM_ADD()
  976. void
  977. Qmgr::joinedCluster(Signal* signal, NodeRecPtr nodePtr){
  978.   /**
  979.    * WE HAVE BEEN INCLUDED IN THE CLUSTER WE CAN START BEING PART OF THE 
  980.    * HEARTBEAT PROTOCOL AND WE WILL ALSO ENABLE COMMUNICATION WITH ALL 
  981.    * NODES IN THE CLUSTER.
  982.    */
  983.   nodePtr.p->phase = ZRUNNING;
  984.   nodePtr.p->alarmCount = 0;
  985.   findNeighbours(signal);
  986.   c_clusterNodes.set(nodePtr.i);
  987.   c_start.reset();
  988.   /**
  989.    * SEND A HEARTBEAT IMMEDIATELY TO DECREASE THE RISK 
  990.    * THAT WE MISS EARLY HEARTBEATS. 
  991.    */
  992.   sendHeartbeat(signal);
  993.   /**
  994.    * ENABLE COMMUNICATION WITH ALL BLOCKS IN THE CURRENT CLUSTER AND SET 
  995.    * THE NODES IN THE CLUSTER TO BE RUNNING. 
  996.    */
  997.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  998.     jam();
  999.     ptrAss(nodePtr, nodeRec);
  1000.     if ((nodePtr.p->phase == ZRUNNING) && (nodePtr.i != getOwnNodeId())) {
  1001.       /*-------------------------------------------------------------------*/
  1002.       // Enable full communication to all other nodes. Not really necessary 
  1003.       // to open communication to ourself.
  1004.       /*-------------------------------------------------------------------*/
  1005.       jam();
  1006.       signal->theData[0] = nodePtr.i;
  1007.       sendSignal(CMVMI_REF, GSN_ENABLE_COMORD, signal, 1, JBA);
  1008.     }//if
  1009.   }//for
  1010.   
  1011.   sendSttorryLab(signal);
  1012.   
  1013.   /**
  1014.    * Start timer handling 
  1015.    */
  1016.   signal->theData[0] = ZTIMER_HANDLING;
  1017.   sendSignal(QMGR_REF, GSN_CONTINUEB, signal, 10, JBB);
  1018.   
  1019.   sendCmAckAdd(signal, getOwnNodeId(), CmAdd::CommitNew);
  1020. }
  1021. /*  4.10.7 CM_ACKADD        - PRESIDENT IS RECEIVER -       */
  1022. /*---------------------------------------------------------------------------*/
  1023. /* Entry point for an ack add signal. 
  1024.  * The TTYPE defines if it is a prepare or a commit.                         */
  1025. /*---------------------------------------------------------------------------*/
  1026. void Qmgr::execCM_ACKADD(Signal* signal) 
  1027. {
  1028.   NodeRecPtr addNodePtr;
  1029.   NodeRecPtr senderNodePtr;
  1030.   jamEntry();
  1031.   CmAckAdd * const cmAckAdd = (CmAckAdd*)signal->getDataPtr();
  1032.   const CmAdd::RequestType type = (CmAdd::RequestType)cmAckAdd->requestType;
  1033.   addNodePtr.i = cmAckAdd->startingNodeId;
  1034.   senderNodePtr.i = cmAckAdd->senderNodeId;
  1035.   DEBUG_START3(signal, type);
  1036.   if (cpresident != getOwnNodeId()) {
  1037.     jam();
  1038.     /*-----------------------------------------------------------------------*/
  1039.     /* IF WE ARE NOT PRESIDENT THEN WE SHOULD NOT RECEIVE THIS MESSAGE.      */
  1040.     /*------------------------------------------------------------_----------*/
  1041.     warningEvent("Received CM_ACKADD from %d president=%d",
  1042.  senderNodePtr.i, cpresident);
  1043.     return;
  1044.   }//if
  1045.   if (addNodePtr.i != c_start.m_startNode) {
  1046.     jam();
  1047.     /*----------------------------------------------------------------------*/
  1048.     /* THIS IS NOT THE STARTING NODE. WE ARE ACTIVE NOW WITH ANOTHER START. */
  1049.     /*----------------------------------------------------------------------*/
  1050.     warningEvent("Received CM_ACKADD from %d with startNode=%d != own %d",
  1051.  senderNodePtr.i, addNodePtr.i, c_start.m_startNode);
  1052.     return;
  1053.   }//if
  1054.   
  1055.   ndbrequire(c_start.m_gsn == GSN_CM_ADD);
  1056.   c_start.m_nodes.clearWaitingFor(senderNodePtr.i);
  1057.   if(!c_start.m_nodes.done()){
  1058.     jam();
  1059.     return;
  1060.   }
  1061.   
  1062.   switch (type) {
  1063.   case CmAdd::Prepare:{
  1064.     jam();
  1065.     /*----------------------------------------------------------------------*/
  1066.     /* ALL RUNNING NODES HAVE PREPARED THE INCLUSION OF THIS NEW NODE.      */
  1067.     /*----------------------------------------------------------------------*/
  1068.     c_start.m_gsn = GSN_CM_ADD;
  1069.     c_start.m_nodes = c_clusterNodes;
  1070.     CmAdd * const cmAdd = (CmAdd*)signal->getDataPtrSend();
  1071.     cmAdd->requestType = CmAdd::AddCommit;
  1072.     cmAdd->startingNodeId = addNodePtr.i; 
  1073.     cmAdd->startingVersion = getNodeInfo(addNodePtr.i).m_version;
  1074.     NodeReceiverGroup rg(QMGR, c_clusterNodes);
  1075.     sendSignal(rg, GSN_CM_ADD, signal, CmAdd::SignalLength, JBA);
  1076.     DEBUG_START2(GSN_CM_ADD, rg, "AddCommit");
  1077.     return;
  1078.   }
  1079.   case CmAdd::AddCommit:{
  1080.     jam();
  1081.     /****************************************/
  1082.     /* Send commit to the new node so he    */
  1083.     /* will change PHASE into ZRUNNING      */
  1084.     /****************************************/
  1085.     c_start.m_gsn = GSN_CM_ADD;
  1086.     c_start.m_nodes.clearWaitingFor();
  1087.     c_start.m_nodes.setWaitingFor(addNodePtr.i);
  1088.     CmAdd * const cmAdd = (CmAdd*)signal->getDataPtrSend();
  1089.     cmAdd->requestType = CmAdd::CommitNew;
  1090.     cmAdd->startingNodeId = addNodePtr.i; 
  1091.     cmAdd->startingVersion = getNodeInfo(addNodePtr.i).m_version;
  1092.     
  1093.     sendSignal(calcQmgrBlockRef(addNodePtr.i), GSN_CM_ADD, signal, 
  1094.        CmAdd::SignalLength, JBA);
  1095.     DEBUG_START(GSN_CM_ADD, addNodePtr.i, "CommitNew");
  1096.     return;
  1097.   }
  1098.   case CmAdd::CommitNew:
  1099.     jam();
  1100.     /**
  1101.      * Tell arbitration about new node.
  1102.      */
  1103.     handleArbitNdbAdd(signal, addNodePtr.i);
  1104.     c_start.reset();
  1105.     return;
  1106.   }//switch
  1107.   ndbrequire(false);
  1108. }//Qmgr::execCM_ACKADD()
  1109. /**-------------------------------------------------------------------------
  1110.  * WE HAVE BEEN INCLUDED INTO THE CLUSTER. IT IS NOW TIME TO CALCULATE WHICH 
  1111.  * ARE OUR LEFT AND RIGHT NEIGHBOURS FOR THE HEARTBEAT PROTOCOL. 
  1112.  *--------------------------------------------------------------------------*/
  1113. void Qmgr::findNeighbours(Signal* signal) 
  1114. {
  1115.   UintR toldLeftNeighbour;
  1116.   UintR tfnLeftFound;
  1117.   UintR tfnMaxFound;
  1118.   UintR tfnMinFound;
  1119.   UintR tfnRightFound;
  1120.   NodeRecPtr fnNodePtr;
  1121.   NodeRecPtr fnOwnNodePtr;
  1122.   toldLeftNeighbour = cneighbourl;
  1123.   tfnLeftFound = 0;
  1124.   tfnMaxFound = 0;
  1125.   tfnMinFound = (UintR)-1;
  1126.   tfnRightFound = (UintR)-1;
  1127.   fnOwnNodePtr.i = getOwnNodeId();
  1128.   ptrCheckGuard(fnOwnNodePtr, MAX_NDB_NODES, nodeRec);
  1129.   for (fnNodePtr.i = 1; fnNodePtr.i < MAX_NDB_NODES; fnNodePtr.i++) {
  1130.     jam();
  1131.     ptrAss(fnNodePtr, nodeRec);
  1132.     if (fnNodePtr.i != fnOwnNodePtr.i) {
  1133.       if (fnNodePtr.p->phase == ZRUNNING) {
  1134.         if (tfnMinFound > fnNodePtr.p->ndynamicId) {
  1135.           jam();
  1136.           tfnMinFound = fnNodePtr.p->ndynamicId;
  1137.         }//if
  1138.         if (tfnMaxFound < fnNodePtr.p->ndynamicId) {
  1139.           jam();
  1140.           tfnMaxFound = fnNodePtr.p->ndynamicId;
  1141.         }//if
  1142.         if (fnOwnNodePtr.p->ndynamicId > fnNodePtr.p->ndynamicId) {
  1143.           jam();
  1144.           if (fnNodePtr.p->ndynamicId > tfnLeftFound) {
  1145.             jam();
  1146.             tfnLeftFound = fnNodePtr.p->ndynamicId;
  1147.           }//if
  1148.         } else {
  1149.           jam();
  1150.           if (fnNodePtr.p->ndynamicId < tfnRightFound) {
  1151.             jam();
  1152.             tfnRightFound = fnNodePtr.p->ndynamicId;
  1153.           }//if
  1154.         }//if
  1155.       }//if
  1156.     }//if
  1157.   }//for
  1158.   if (tfnLeftFound == 0) {
  1159.     if (tfnMinFound == (UintR)-1) {
  1160.       jam();
  1161.       cneighbourl = ZNIL;
  1162.     } else {
  1163.       jam();
  1164.       cneighbourl = translateDynamicIdToNodeId(signal, tfnMaxFound);
  1165.     }//if
  1166.   } else {
  1167.     jam();
  1168.     cneighbourl = translateDynamicIdToNodeId(signal, tfnLeftFound);
  1169.   }//if
  1170.   if (tfnRightFound == (UintR)-1) {
  1171.     if (tfnMaxFound == 0) {
  1172.       jam();
  1173.       cneighbourh = ZNIL;
  1174.     } else {
  1175.       jam();
  1176.       cneighbourh = translateDynamicIdToNodeId(signal, tfnMinFound);
  1177.     }//if
  1178.   } else {
  1179.     jam();
  1180.     cneighbourh = translateDynamicIdToNodeId(signal, tfnRightFound);
  1181.   }//if
  1182.   if (toldLeftNeighbour != cneighbourl) {
  1183.     jam();
  1184.     if (cneighbourl != ZNIL) {
  1185.       jam();
  1186.       /**-------------------------------------------------------------------*/
  1187.       /* WE ARE SUPERVISING A NEW LEFT NEIGHBOUR. WE START WITH ALARM COUNT 
  1188.        * EQUAL TO ZERO.
  1189.        *---------------------------------------------------------------------*/
  1190.       fnNodePtr.i = cneighbourl;
  1191.       ptrCheckGuard(fnNodePtr, MAX_NDB_NODES, nodeRec);
  1192.       fnNodePtr.p->alarmCount = 0;
  1193.     }//if
  1194.   }//if
  1195.   signal->theData[0] = EventReport::FIND_NEIGHBOURS;
  1196.   signal->theData[1] = getOwnNodeId();
  1197.   signal->theData[2] = cneighbourl;
  1198.   signal->theData[3] = cneighbourh;
  1199.   signal->theData[4] = fnOwnNodePtr.p->ndynamicId;
  1200.   UintR Tlen = 5;
  1201.   for (fnNodePtr.i = 1; fnNodePtr.i < MAX_NDB_NODES; fnNodePtr.i++) {
  1202.     jam();
  1203.     ptrAss(fnNodePtr, nodeRec);
  1204.     if (fnNodePtr.i != fnOwnNodePtr.i) {
  1205.       if (fnNodePtr.p->phase == ZRUNNING) {
  1206.         jam();
  1207.         signal->theData[Tlen] = fnNodePtr.i;
  1208.         signal->theData[Tlen + 1] = fnNodePtr.p->ndynamicId;
  1209.         if (Tlen < 25) {
  1210.   /*----------------------------------------------------------------*/
  1211.   // This code can only report 11 nodes. 
  1212.   // We need to update this when increasing the number of nodes
  1213.   // supported.
  1214.   /*-----------------------------------------------------------------*/
  1215.           Tlen += 2;
  1216.         }
  1217.       }//if
  1218.     }//if
  1219.   }//for
  1220.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, Tlen, JBB);
  1221. }//Qmgr::findNeighbours()
  1222. /*
  1223. 4.10.7 INIT_DATA        */
  1224. /*---------------------------------------------------------------------------*/
  1225. /*---------------------------------------------------------------------------*/
  1226. void Qmgr::initData(Signal* signal) 
  1227. {
  1228.   NodeRecPtr nodePtr;
  1229.   for (nodePtr.i = 1; nodePtr.i < MAX_NODES; nodePtr.i++) {
  1230.     ptrAss(nodePtr, nodeRec);
  1231.     nodePtr.p->ndynamicId = 0;
  1232.     if(getNodeInfo(nodePtr.i).m_type == NodeInfo::DB){
  1233.       nodePtr.p->phase = ZINIT;
  1234.       c_definedNodes.set(nodePtr.i);
  1235.     } else {
  1236.       nodePtr.p->phase = ZAPI_INACTIVE;
  1237.     }
  1238.     
  1239.     nodePtr.p->alarmCount = 0;
  1240.     nodePtr.p->sendPrepFailReqStatus = Q_NOT_ACTIVE;
  1241.     nodePtr.p->sendCommitFailReqStatus = Q_NOT_ACTIVE;
  1242.     nodePtr.p->sendPresToStatus = Q_NOT_ACTIVE;
  1243.     nodePtr.p->failState = NORMAL;
  1244.     nodePtr.p->rcv[0] = 0;
  1245.     nodePtr.p->rcv[1] = 0;
  1246.   }//for
  1247.   cfailureNr = 1;
  1248.   ccommitFailureNr = 1;
  1249.   cprepareFailureNr = 1;
  1250.   cnoFailedNodes = 0;
  1251.   cnoPrepFailedNodes = 0;
  1252.   creadyDistCom = ZFALSE;
  1253.   cpresident = ZNIL;
  1254.   cpresidentCandidate = ZNIL;
  1255.   cpdistref = 0;
  1256.   cneighbourh = ZNIL;
  1257.   cneighbourl = ZNIL;
  1258.   cdelayRegreq = ZDELAY_REGREQ;
  1259.   cactivateApiCheck = 0;
  1260.   ctoStatus = Q_NOT_ACTIVE;
  1261.   interface_check_timer.setDelay(1000);
  1262.   interface_check_timer.reset();
  1263.   clatestTransactionCheck = 0;
  1264.   cLqhTimeSignalCount = 0;
  1265.   // catch-all for missing initializations
  1266.   memset(&arbitRec, 0, sizeof(arbitRec));
  1267.   /**
  1268.    * Timeouts
  1269.    */
  1270.   const ndb_mgm_configuration_iterator * p = 
  1271.     theConfiguration.getOwnConfigIterator();
  1272.   ndbrequire(p != 0);
  1273.   
  1274.   Uint32 hbDBDB = 1500;
  1275.   Uint32 hbDBAPI = 1500;
  1276.   Uint32 arbitTimeout = 1000;
  1277.   c_restartPartialTimeout = 30000;
  1278.   ndb_mgm_get_int_parameter(p, CFG_DB_HEARTBEAT_INTERVAL, &hbDBDB);
  1279.   ndb_mgm_get_int_parameter(p, CFG_DB_API_HEARTBEAT_INTERVAL, &hbDBAPI);
  1280.   ndb_mgm_get_int_parameter(p, CFG_DB_ARBIT_TIMEOUT, &arbitTimeout);
  1281.   ndb_mgm_get_int_parameter(p, CFG_DB_START_PARTIAL_TIMEOUT, 
  1282.     &c_restartPartialTimeout);
  1283.   if(c_restartPartialTimeout == 0){
  1284.     c_restartPartialTimeout = ~0;
  1285.   }
  1286.   
  1287.   setHbDelay(hbDBDB);
  1288.   setHbApiDelay(hbDBAPI);
  1289.   setArbitTimeout(arbitTimeout);
  1290.   
  1291.   arbitRec.state = ARBIT_NULL;          // start state for all nodes
  1292.   arbitRec.apiMask[0].clear();          // prepare for ARBIT_CFG
  1293.   ArbitSignalData* const sd = (ArbitSignalData*)&signal->theData[0];
  1294.   for (unsigned rank = 1; rank <= 2; rank++) {
  1295.     sd->sender = getOwnNodeId();
  1296.     sd->code = rank;
  1297.     sd->node = 0;
  1298.     sd->ticket.clear();
  1299.     sd->mask.clear();
  1300.     ndb_mgm_configuration_iterator * iter =
  1301.       theConfiguration.getClusterConfigIterator();
  1302.     for (ndb_mgm_first(iter); ndb_mgm_valid(iter); ndb_mgm_next(iter)) {
  1303.       Uint32 tmp = 0;
  1304.       if (ndb_mgm_get_int_parameter(iter, CFG_NODE_ARBIT_RANK, &tmp) == 0 && 
  1305.   tmp == rank){
  1306. Uint32 nodeId = 0;
  1307. ndbrequire(!ndb_mgm_get_int_parameter(iter, CFG_NODE_ID, &nodeId));
  1308. sd->mask.set(nodeId);
  1309.       }
  1310.     }
  1311.     
  1312.     execARBIT_CFG(signal);
  1313.   }
  1314.   setNodeInfo(getOwnNodeId()).m_version = NDB_VERSION;
  1315. }//Qmgr::initData()
  1316. /**---------------------------------------------------------------------------
  1317.  * HERE WE RECEIVE THE JOB TABLE SIGNAL EVERY 10 MILLISECONDS. 
  1318.  * WE WILL USE THIS TO CHECK IF IT IS TIME TO CHECK THE NEIGHBOUR NODE. 
  1319.  * WE WILL ALSO SEND A SIGNAL TO BLOCKS THAT NEED A TIME SIGNAL AND 
  1320.  * DO NOT WANT TO USE JOB TABLE SIGNALS.
  1321.  *---------------------------------------------------------------------------*/
  1322. void Qmgr::timerHandlingLab(Signal* signal) 
  1323. {
  1324.   NDB_TICKS TcurrentTime = NdbTick_CurrentMillisecond();
  1325.   NodeRecPtr myNodePtr;
  1326.   myNodePtr.i = getOwnNodeId();
  1327.   ptrCheckGuard(myNodePtr, MAX_NDB_NODES, nodeRec);
  1328.   if (myNodePtr.p->phase == ZRUNNING) {
  1329.     jam();
  1330.     /**---------------------------------------------------------------------
  1331.      * WE ARE ONLY PART OF HEARTBEAT CLUSTER IF WE ARE UP AND RUNNING. 
  1332.      *---------------------------------------------------------------------*/
  1333.     if (hb_send_timer.check(TcurrentTime)) {
  1334.       jam();
  1335.       sendHeartbeat(signal);
  1336.       hb_send_timer.reset();
  1337.     }
  1338.     if (hb_check_timer.check(TcurrentTime)) {
  1339.       jam();
  1340.       checkHeartbeat(signal);
  1341.       hb_check_timer.reset();
  1342.     }
  1343.   }
  1344.   if (interface_check_timer.check(TcurrentTime)) {
  1345.     jam();
  1346.     interface_check_timer.reset();
  1347.     checkStartInterface(signal);
  1348.   }
  1349.   if (cactivateApiCheck != 0) {
  1350.     jam();
  1351.     if (hb_api_timer.check(TcurrentTime)) {
  1352.       jam();
  1353.       hb_api_timer.reset();
  1354.       apiHbHandlingLab(signal);
  1355.     }//if
  1356.     if (clatestTransactionCheck == 0) {
  1357.       //-------------------------------------------------------------
  1358.       // Initialise the Transaction check timer.
  1359.       //-------------------------------------------------------------
  1360.       clatestTransactionCheck = TcurrentTime;
  1361.     }//if
  1362.     int counter = 0;
  1363.     while (TcurrentTime > ((NDB_TICKS)10 + clatestTransactionCheck)) {
  1364.       jam();
  1365.       clatestTransactionCheck += (NDB_TICKS)10;
  1366.       sendSignal(DBTC_REF, GSN_TIME_SIGNAL, signal, 1, JBB);
  1367.       cLqhTimeSignalCount++;
  1368.       if (cLqhTimeSignalCount >= 100) {
  1369. cLqhTimeSignalCount = 0;
  1370. sendSignal(DBLQH_REF, GSN_TIME_SIGNAL, signal, 1, JBB);          
  1371.       }//if
  1372.       counter++;
  1373.       if (counter > 1) {
  1374. jam();
  1375. break;
  1376.       } else {
  1377. ;
  1378.       }//if
  1379.     }//while
  1380.   }//if
  1381.   
  1382.   //--------------------------------------------------
  1383.   // Resend this signal with 10 milliseconds delay.
  1384.   //--------------------------------------------------
  1385.   signal->theData[0] = ZTIMER_HANDLING;
  1386.   sendSignalWithDelay(QMGR_REF, GSN_CONTINUEB, signal, 10, 1);
  1387.   return;
  1388. }//Qmgr::timerHandlingLab()
  1389. /*---------------------------------------------------------------------------*/
  1390. /*       THIS MODULE HANDLES THE SENDING AND RECEIVING OF HEARTBEATS.        */
  1391. /*---------------------------------------------------------------------------*/
  1392. void Qmgr::sendHeartbeat(Signal* signal) 
  1393. {
  1394.   NodeRecPtr localNodePtr;
  1395.   localNodePtr.i = cneighbourh;
  1396.   if (localNodePtr.i == ZNIL) {
  1397.     jam();
  1398.     /**---------------------------------------------------------------------
  1399.      * THERE ARE NO NEIGHBOURS. THIS IS POSSIBLE IF WE ARE THE ONLY NODE IN 
  1400.      * THE CLUSTER.IN THIS CASE WE DO NOT NEED TO SEND ANY HEARTBEAT SIGNALS.
  1401.      *-----------------------------------------------------------------------*/
  1402.     return;
  1403.   }//if
  1404.   ptrCheckGuard(localNodePtr, MAX_NDB_NODES, nodeRec);
  1405.   signal->theData[0] = getOwnNodeId();
  1406.   sendSignal(localNodePtr.p->blockRef, GSN_CM_HEARTBEAT, signal, 1, JBA);
  1407. #ifdef VM_TRACE
  1408.   signal->theData[0] = EventReport::SentHeartbeat;
  1409.   signal->theData[1] = localNodePtr.i;
  1410.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);  
  1411. #endif
  1412. }//Qmgr::sendHeartbeat()
  1413. void Qmgr::checkHeartbeat(Signal* signal) 
  1414. {
  1415.   NodeRecPtr nodePtr;
  1416.   nodePtr.i = cneighbourl;
  1417.   if (nodePtr.i == ZNIL) {
  1418.     jam();
  1419.     /**---------------------------------------------------------------------
  1420.      * THERE ARE NO NEIGHBOURS. THIS IS POSSIBLE IF WE ARE THE ONLY NODE IN 
  1421.      * THE CLUSTER. IN THIS CASE WE DO NOT NEED TO CHECK ANY HEARTBEATS.
  1422.      *-----------------------------------------------------------------------*/
  1423.     return;
  1424.   }//if
  1425.   ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec);
  1426.   
  1427.   nodePtr.p->alarmCount ++;
  1428.   ndbrequire(nodePtr.p->phase == ZRUNNING);
  1429.   ndbrequire(getNodeInfo(nodePtr.i).m_type == NodeInfo::DB);
  1430.   if(nodePtr.p->alarmCount > 2){
  1431.     signal->theData[0] = EventReport::MissedHeartbeat;
  1432.     signal->theData[1] = nodePtr.i;
  1433.     signal->theData[2] = nodePtr.p->alarmCount - 1;
  1434.     sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
  1435.   }
  1436.   if (nodePtr.p->alarmCount > 4) {
  1437.     jam();
  1438.     /**----------------------------------------------------------------------
  1439.      * OUR LEFT NEIGHBOUR HAVE KEPT QUIET FOR THREE CONSECUTIVE HEARTBEAT 
  1440.      * PERIODS. THUS WE DECLARE HIM DOWN.
  1441.      *----------------------------------------------------------------------*/
  1442.     signal->theData[0] = EventReport::DeadDueToHeartbeat;
  1443.     signal->theData[1] = nodePtr.i;
  1444.     sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
  1445.     failReportLab(signal, nodePtr.i, FailRep::ZHEARTBEAT_FAILURE);
  1446.     return;
  1447.   }//if
  1448. }//Qmgr::checkHeartbeat()
  1449. void Qmgr::apiHbHandlingLab(Signal* signal) 
  1450. {
  1451.   NodeRecPtr TnodePtr;
  1452.   for (TnodePtr.i = 1; TnodePtr.i < MAX_NODES; TnodePtr.i++) {
  1453.     const Uint32 nodeId = TnodePtr.i;
  1454.     ptrAss(TnodePtr, nodeRec);
  1455.     
  1456.     const NodeInfo::NodeType type = getNodeInfo(nodeId).getType();
  1457.     if(type == NodeInfo::DB)
  1458.       continue;
  1459.     
  1460.     if(type == NodeInfo::INVALID)
  1461.       continue;
  1462.     if (TnodePtr.p->phase == ZAPI_ACTIVE){
  1463.       jam();
  1464.       TnodePtr.p->alarmCount ++;
  1465.       
  1466.       if(TnodePtr.p->alarmCount > 2){
  1467. signal->theData[0] = EventReport::MissedHeartbeat;
  1468. signal->theData[1] = nodeId;
  1469. signal->theData[2] = TnodePtr.p->alarmCount - 1;
  1470. sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
  1471.       }
  1472.       
  1473.       if (TnodePtr.p->alarmCount > 4) {
  1474.         jam();
  1475. /*------------------------------------------------------------------*/
  1476. /* THE API NODE HAS NOT SENT ANY HEARTBEAT FOR THREE SECONDS. 
  1477.  * WE WILL DISCONNECT FROM IT NOW.
  1478.  *------------------------------------------------------------------*/
  1479. /*------------------------------------------------------------------*/
  1480. /* We call node_failed to release all connections for this api node */
  1481. /*------------------------------------------------------------------*/
  1482. signal->theData[0] = EventReport::DeadDueToHeartbeat;
  1483. signal->theData[1] = nodeId;
  1484. sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
  1485.         node_failed(signal, nodeId);
  1486.       }//if
  1487.     }//if
  1488.   }//for
  1489.   return;
  1490. }//Qmgr::apiHbHandlingLab()
  1491. void Qmgr::checkStartInterface(Signal* signal) 
  1492. {
  1493.   NodeRecPtr nodePtr;
  1494.   /*------------------------------------------------------------------------*/
  1495.   // This method is called once per second. After a disconnect we wait at 
  1496.   // least three seconds before allowing new connects. We will also ensure 
  1497.   // that handling of the failure is completed before we allow new connections.
  1498.   /*------------------------------------------------------------------------*/
  1499.   for (nodePtr.i = 1; nodePtr.i < MAX_NODES; nodePtr.i++) {
  1500.     ptrAss(nodePtr, nodeRec);
  1501.     if (nodePtr.p->phase == ZFAIL_CLOSING) {
  1502.       jam();
  1503.       nodePtr.p->alarmCount = nodePtr.p->alarmCount + 1;
  1504.       if (c_connectedNodes.get(nodePtr.i)){
  1505.         jam();
  1506. /*-------------------------------------------------------------------*/
  1507. // We need to ensure that the connection is not restored until it has 
  1508. // been disconnected for at least three seconds.
  1509. /*-------------------------------------------------------------------*/
  1510.         nodePtr.p->alarmCount = 0;
  1511.       }//if
  1512.       if ((nodePtr.p->alarmCount > 3) && (nodePtr.p->failState == NORMAL)) {
  1513. /**------------------------------------------------------------------
  1514.  * WE HAVE DISCONNECTED THREE SECONDS AGO. WE ARE NOW READY TO 
  1515.  * CONNECT AGAIN AND ACCEPT NEW REGISTRATIONS FROM THIS NODE. 
  1516.  * WE WILL NOT ALLOW CONNECTIONS OF API NODES UNTIL API FAIL HANDLING 
  1517.  * IS COMPLETE.
  1518.  *-------------------------------------------------------------------*/
  1519.         nodePtr.p->failState = NORMAL;
  1520.         if (getNodeInfo(nodePtr.i).m_type != NodeInfo::DB){
  1521.           jam();
  1522.           nodePtr.p->phase = ZAPI_INACTIVE;
  1523.         } else {
  1524.           jam();
  1525.           nodePtr.p->phase = ZINIT;
  1526.         }//if
  1527.         nodePtr.p->alarmCount = 0;
  1528.         signal->theData[0] = 0;
  1529.         signal->theData[1] = nodePtr.i;
  1530.         sendSignal(CMVMI_REF, GSN_OPEN_COMREQ, signal, 2, JBA);
  1531.       } else {
  1532. if(((nodePtr.p->alarmCount + 1) % 60) == 0){
  1533.   char buf[100];
  1534.   BaseString::snprintf(buf, sizeof(buf), 
  1535.    "Failure handling of node %d has not completed in %d min."
  1536.    " - state = %d",
  1537.    nodePtr.i, 
  1538.    (nodePtr.p->alarmCount + 1)/60,
  1539.    nodePtr.p->failState);
  1540.   warningEvent(buf);
  1541. }
  1542.       }
  1543.     }//if
  1544.   }//for
  1545.   return;
  1546. }//Qmgr::checkStartInterface()
  1547. /**-------------------------------------------------------------------------
  1548.  * This method is called when a DISCONNECT_REP signal arrived which means that
  1549.  * the API node is gone and we want to release resources in TC/DICT blocks.
  1550.  *---------------------------------------------------------------------------*/
  1551. void Qmgr::sendApiFailReq(Signal* signal, Uint16 failedNodeNo) 
  1552. {
  1553.   NodeRecPtr failedNodePtr;
  1554.   jamEntry();
  1555.   failedNodePtr.i = failedNodeNo;
  1556.   signal->theData[0] = failedNodePtr.i;
  1557.   signal->theData[1] = QMGR_REF; 
  1558.   ptrCheckGuard(failedNodePtr, MAX_NODES, nodeRec);
  1559.   
  1560.   ndbrequire(failedNodePtr.p->failState == NORMAL);
  1561.   
  1562.   failedNodePtr.p->failState = WAITING_FOR_FAILCONF1;
  1563.   sendSignal(DBTC_REF, GSN_API_FAILREQ, signal, 2, JBA);
  1564.   sendSignal(DBDICT_REF, GSN_API_FAILREQ, signal, 2, JBA);
  1565.   sendSignal(SUMA_REF, GSN_API_FAILREQ, signal, 2, JBA);
  1566.   /**-------------------------------------------------------------------------
  1567.    * THE OTHER NODE WAS AN API NODE. THE COMMUNICATION LINK IS ALREADY 
  1568.    * BROKEN AND THUS NO ACTION IS NEEDED TO BREAK THE CONNECTION. 
  1569.    * WE ONLY NEED TO SET PARAMETERS TO ENABLE A NEW CONNECTION IN A FEW 
  1570.    * SECONDS. 
  1571.    *-------------------------------------------------------------------------*/
  1572.   failedNodePtr.p->alarmCount = 0;
  1573.   CloseComReqConf * const closeCom = (CloseComReqConf *)&signal->theData[0];
  1574.   closeCom->xxxBlockRef = reference();
  1575.   closeCom->failNo      = 0;
  1576.   closeCom->noOfNodes   = 1;
  1577.   NodeBitmask::clear(closeCom->theNodes);
  1578.   NodeBitmask::set(closeCom->theNodes, failedNodePtr.i);
  1579.   sendSignal(CMVMI_REF, GSN_CLOSE_COMREQ, signal, 
  1580.      CloseComReqConf::SignalLength, JBA);
  1581. }//Qmgr::sendApiFailReq()
  1582. void Qmgr::execAPI_FAILCONF(Signal* signal) 
  1583. {
  1584.   NodeRecPtr failedNodePtr;
  1585.   jamEntry();
  1586.   failedNodePtr.i = signal->theData[0];  
  1587.   ptrCheckGuard(failedNodePtr, MAX_NODES, nodeRec);
  1588.   if (failedNodePtr.p->failState == WAITING_FOR_FAILCONF1){
  1589.     jam();
  1590.     failedNodePtr.p->rcv[0] = signal->theData[1];
  1591.     failedNodePtr.p->failState = WAITING_FOR_FAILCONF2;
  1592.   } else if (failedNodePtr.p->failState == WAITING_FOR_FAILCONF2) {
  1593.     failedNodePtr.p->rcv[1] = signal->theData[1];
  1594.     failedNodePtr.p->failState = NORMAL;
  1595.     if (failedNodePtr.p->rcv[0] == failedNodePtr.p->rcv[1]) {
  1596.       jam();
  1597.       systemErrorLab(signal, __LINE__);
  1598.     } else {
  1599.       jam();
  1600.       failedNodePtr.p->rcv[0] = 0;
  1601.       failedNodePtr.p->rcv[1] = 0;
  1602.     }//if
  1603.   } else {
  1604.     jam();
  1605. #ifdef VM_TRACE
  1606.     ndbout << "failedNodePtr.p->failState = "
  1607.    << (Uint32)(failedNodePtr.p->failState) << endl;
  1608. #endif   
  1609.     systemErrorLab(signal, __LINE__);
  1610.   }//if
  1611.   return;
  1612. }//Qmgr::execAPI_FAILCONF()
  1613. void Qmgr::execNDB_FAILCONF(Signal* signal) 
  1614. {
  1615.   NodeRecPtr failedNodePtr;
  1616.   NodeRecPtr nodePtr;
  1617.   jamEntry();
  1618.   failedNodePtr.i = signal->theData[0];  
  1619.   ptrCheckGuard(failedNodePtr, MAX_NODES, nodeRec);
  1620.   if (failedNodePtr.p->failState == WAITING_FOR_NDB_FAILCONF){
  1621.     failedNodePtr.p->failState = NORMAL;
  1622.   } else {
  1623.     jam();
  1624.     systemErrorLab(signal, __LINE__);
  1625.   }//if
  1626.   if (cpresident == getOwnNodeId()) {
  1627.     jam();
  1628.     /** 
  1629.      * Prepare a NFCompleteRep and send to all connected API's
  1630.      * They can then abort all transaction waiting for response from 
  1631.      * the failed node
  1632.      */
  1633.     NFCompleteRep * const nfComp = (NFCompleteRep *)&signal->theData[0];
  1634.     nfComp->blockNo = QMGR_REF;
  1635.     nfComp->nodeId = getOwnNodeId();
  1636.     nfComp->failedNodeId = failedNodePtr.i;
  1637.     for (nodePtr.i = 1; nodePtr.i < MAX_NODES; nodePtr.i++) {
  1638.       jam();
  1639.       ptrAss(nodePtr, nodeRec);
  1640.       if (nodePtr.p->phase == ZAPI_ACTIVE){
  1641.         jam();
  1642.         sendSignal(nodePtr.p->blockRef, GSN_NF_COMPLETEREP, signal, 
  1643.                    NFCompleteRep::SignalLength, JBA);
  1644.       }//if
  1645.     }//for
  1646.   }
  1647.   return;
  1648. }//Qmgr::execNDB_FAILCONF()
  1649. /*******************************/
  1650. /* DISCONNECT_REP             */
  1651. /*******************************/
  1652. void Qmgr::execDISCONNECT_REP(Signal* signal) 
  1653. {
  1654.   jamEntry();
  1655.   const DisconnectRep * const rep = (DisconnectRep *)&signal->theData[0];
  1656.   const Uint32 nodeId = rep->nodeId;
  1657.   c_connectedNodes.clear(nodeId);
  1658.   NodeRecPtr nodePtr;
  1659.   nodePtr.i = getOwnNodeId();
  1660.   ptrCheckGuard(nodePtr, MAX_NODES, nodeRec);
  1661.   switch(nodePtr.p->phase){
  1662.   case ZRUNNING:
  1663.     jam();
  1664.     break;
  1665.   case ZINIT:
  1666.   case ZSTARTING:
  1667.   case ZPREPARE_FAIL:
  1668.   case ZFAIL_CLOSING:
  1669.   case ZAPI_ACTIVE:
  1670.   case ZAPI_INACTIVE:
  1671.     ndbrequire(false);
  1672.   }
  1673.   node_failed(signal, nodeId);
  1674. }//DISCONNECT_REP
  1675. void Qmgr::node_failed(Signal* signal, Uint16 aFailedNode) 
  1676. {
  1677.   NodeRecPtr failedNodePtr;
  1678.   /**------------------------------------------------------------------------
  1679.    *   A COMMUNICATION LINK HAS BEEN DISCONNECTED. WE MUST TAKE SOME ACTION
  1680.    *   DUE TO THIS.
  1681.    *-----------------------------------------------------------------------*/
  1682.   failedNodePtr.i = aFailedNode;
  1683.   ptrCheckGuard(failedNodePtr, MAX_NODES, nodeRec);
  1684.   if (getNodeInfo(failedNodePtr.i).getType() == NodeInfo::DB){
  1685.     jam();
  1686.     /**---------------------------------------------------------------------
  1687.      *   THE OTHER NODE IS AN NDB NODE, WE HANDLE IT AS IF A HEARTBEAT 
  1688.      *   FAILURE WAS DISCOVERED.
  1689.      *---------------------------------------------------------------------*/
  1690.     switch(failedNodePtr.p->phase){
  1691.     case ZRUNNING:
  1692.       jam();
  1693.       failReportLab(signal, aFailedNode, FailRep::ZLINK_FAILURE);
  1694.       return;
  1695.     case ZFAIL_CLOSING:
  1696.       jam();
  1697.       return;
  1698.     case ZSTARTING:
  1699.       c_start.reset();
  1700.       // Fall-through
  1701.     default:
  1702.       jam();
  1703.       /*---------------------------------------------------------------------*/
  1704.       // The other node is still not in the cluster but disconnected. 
  1705.       // We must restart communication in three seconds.
  1706.       /*---------------------------------------------------------------------*/
  1707.       failedNodePtr.p->failState = NORMAL;
  1708.       failedNodePtr.p->phase = ZFAIL_CLOSING;
  1709.       failedNodePtr.p->alarmCount = 0;
  1710.       CloseComReqConf * const closeCom = 
  1711. (CloseComReqConf *)&signal->theData[0];
  1712.       closeCom->xxxBlockRef = reference();
  1713.       closeCom->failNo      = 0;
  1714.       closeCom->noOfNodes   = 1;
  1715.       NodeBitmask::clear(closeCom->theNodes);
  1716.       NodeBitmask::set(closeCom->theNodes, failedNodePtr.i);
  1717.       sendSignal(CMVMI_REF, GSN_CLOSE_COMREQ, signal, 
  1718.  CloseComReqConf::SignalLength, JBA);
  1719.     }//if
  1720.     return;
  1721.   }
  1722.   /**
  1723.    * API code
  1724.    */
  1725.   jam();
  1726.   if (failedNodePtr.p->phase != ZFAIL_CLOSING){
  1727.     jam();
  1728.     //-------------------------------------------------------------------------
  1729.     // The API was active and has now failed. We need to initiate API failure
  1730.     // handling. If the API had already failed then we can ignore this
  1731.     // discovery.
  1732.     //-------------------------------------------------------------------------
  1733.     failedNodePtr.p->phase = ZFAIL_CLOSING;
  1734.     
  1735.     sendApiFailReq(signal, aFailedNode);
  1736.     arbitRec.code = ArbitCode::ApiFail;
  1737.     handleArbitApiFail(signal, aFailedNode);
  1738.   }//if
  1739.   return;
  1740. }//Qmgr::node_failed()
  1741. /**--------------------------------------------------------------------------
  1742.  * AN API NODE IS REGISTERING. IF FOR THE FIRST TIME WE WILL ENABLE 
  1743.  * COMMUNICATION WITH ALL NDB BLOCKS.
  1744.  *---------------------------------------------------------------------------*/
  1745. /*******************************/
  1746. /* API_REGREQ                 */
  1747. /*******************************/
  1748. void Qmgr::execAPI_REGREQ(Signal* signal) 
  1749. {
  1750.   jamEntry();
  1751.   
  1752.   ApiRegReq* req = (ApiRegReq*)signal->getDataPtr();
  1753.   const Uint32 version = req->version;
  1754.   const BlockReference ref = req->ref;
  1755.   
  1756.   NodeRecPtr apiNodePtr;
  1757.   apiNodePtr.i = refToNode(ref);
  1758.   ptrCheckGuard(apiNodePtr, MAX_NODES, nodeRec);
  1759.   
  1760. #if 0
  1761.   ndbout_c("Qmgr::execAPI_REGREQ: Recd API_REGREQ (NodeId=%d)", apiNodePtr.i);
  1762. #endif
  1763.   bool compatability_check;
  1764.   NodeInfo::NodeType type= getNodeInfo(apiNodePtr.i).getType();
  1765.   switch(type){
  1766.   case NodeInfo::API:
  1767.     compatability_check = ndbCompatible_ndb_api(NDB_VERSION, version);
  1768.     break;
  1769.   case NodeInfo::MGM:
  1770.     compatability_check = ndbCompatible_ndb_mgmt(NDB_VERSION, version);
  1771.     break;
  1772.   case NodeInfo::REP:
  1773.     //    compatability_check = ndbCompatible_ndb_api(NDB_VERSION, version);
  1774.     //    break;
  1775.   case NodeInfo::DB:
  1776.   case NodeInfo::INVALID:
  1777.   default:
  1778.     sendApiRegRef(signal, ref, ApiRegRef::WrongType);
  1779.     infoEvent("Invalid connection attempt with type %d", type);
  1780.     return;
  1781.   }
  1782.   if (!compatability_check) {
  1783.     jam();
  1784.     char buf[NDB_VERSION_STRING_BUF_SZ];
  1785.     infoEvent("Connection attempt from %s id=%d with %s "
  1786.       "incompatible with %s",
  1787.       type == NodeInfo::API ? "api or mysqld" : "management server",
  1788.       apiNodePtr.i,
  1789.       getVersionString(version,"",buf,sizeof(buf)),
  1790.       NDB_VERSION_STRING);
  1791.     apiNodePtr.p->phase = ZAPI_INACTIVE;
  1792.     sendApiRegRef(signal, ref, ApiRegRef::UnsupportedVersion);
  1793.     return;
  1794.   }
  1795.   setNodeInfo(apiNodePtr.i).m_version = version;
  1796.    
  1797.   apiNodePtr.p->alarmCount = 0;
  1798.   ApiRegConf * const apiRegConf = (ApiRegConf *)&signal->theData[0];
  1799.   apiRegConf->qmgrRef = reference();
  1800.   apiRegConf->apiHeartbeatFrequency = (chbApiDelay / 10);
  1801.   apiRegConf->version = NDB_VERSION;
  1802.   apiRegConf->nodeState = getNodeState();
  1803.   {
  1804.     NodeRecPtr nodePtr;
  1805.     nodePtr.i = getOwnNodeId();
  1806.     ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec);
  1807.     Uint32 dynamicId = nodePtr.p->ndynamicId;
  1808.     if(apiRegConf->nodeState.masterNodeId != getOwnNodeId()){
  1809.       jam();
  1810.       apiRegConf->nodeState.dynamicId = dynamicId;
  1811.     } else {
  1812.       apiRegConf->nodeState.dynamicId = -dynamicId;
  1813.     }
  1814.   }
  1815.   apiRegConf->nodeState.m_connected_nodes.assign(c_connectedNodes);
  1816.   sendSignal(ref, GSN_API_REGCONF, signal, ApiRegConf::SignalLength, JBB);
  1817.   if ((getNodeState().startLevel == NodeState::SL_STARTED ||
  1818.        getNodeState().getSingleUserMode())
  1819.       && apiNodePtr.p->phase == ZAPI_INACTIVE) {
  1820.     jam();
  1821.     /**----------------------------------------------------------------------
  1822.      * THE API NODE IS REGISTERING. WE WILL ACCEPT IT BY CHANGING STATE AND 
  1823.      * SENDING A CONFIRM. 
  1824.      *----------------------------------------------------------------------*/
  1825.     apiNodePtr.p->phase = ZAPI_ACTIVE;
  1826.     apiNodePtr.p->blockRef = ref;
  1827.     signal->theData[0] = apiNodePtr.i;
  1828.     sendSignal(CMVMI_REF, GSN_ENABLE_COMORD, signal, 1, JBA);
  1829.   }
  1830.   return;
  1831. }//Qmgr::execAPI_REGREQ()
  1832. void 
  1833. Qmgr::execAPI_VERSION_REQ(Signal * signal) {
  1834.   jamEntry();
  1835.   ApiVersionReq * const req = (ApiVersionReq *)signal->getDataPtr();
  1836.   
  1837.   Uint32 senderRef = req->senderRef;
  1838.   Uint32 nodeId = req->nodeId;
  1839.   ApiVersionConf * conf = (ApiVersionConf *)req;
  1840.   if(getNodeInfo(nodeId).m_connected)
  1841.     conf->version =  getNodeInfo(nodeId).m_version;
  1842.   else
  1843.     conf->version =  0;
  1844.   conf->nodeId = nodeId;
  1845.   struct in_addr in= globalTransporterRegistry.get_connect_address(nodeId);
  1846.   conf->inet_addr= in.s_addr;
  1847.   sendSignal(senderRef, 
  1848.      GSN_API_VERSION_CONF,
  1849.      signal,
  1850.      ApiVersionConf::SignalLength, JBB);
  1851. }
  1852. #if 0
  1853. bool
  1854. Qmgr::checkAPIVersion(NodeId nodeId, 
  1855.       Uint32 apiVersion, Uint32 ownVersion) const {
  1856.   bool ret=true;
  1857.   /**
  1858.    * First implementation...
  1859.    */
  1860.   if ((getMajor(apiVersion) < getMajor(ownVersion) ||
  1861.        getMinor(apiVersion) < getMinor(ownVersion)) &&
  1862.       apiVersion >= API_UPGRADE_VERSION) {
  1863.     jam();
  1864.     if ( getNodeInfo(nodeId).getType() !=  NodeInfo::MGM ) {
  1865.       jam();
  1866.       ret = false;
  1867.     } else {
  1868.       jam();
  1869.       /* we have a software upgrade situation, mgmtsrvr should be
  1870.        * the highest, let him decide what to do
  1871.        */
  1872.       ;
  1873.     }
  1874.   }
  1875.   return ret;
  1876. }
  1877. #endif
  1878. void
  1879. Qmgr::sendApiRegRef(Signal* signal, Uint32 Tref, ApiRegRef::ErrorCode err){
  1880.   ApiRegRef* ref = (ApiRegRef*)signal->getDataPtrSend();
  1881.   ref->ref = reference();
  1882.   ref->version = NDB_VERSION;
  1883.   ref->errorCode = err;
  1884.   sendSignal(Tref, GSN_API_REGREF, signal, ApiRegRef::SignalLength, JBB);
  1885. }
  1886. /**--------------------------------------------------------------------------
  1887.  * A NODE HAS BEEN DECLARED AS DOWN. WE WILL CLOSE THE COMMUNICATION TO THIS 
  1888.  * NODE IF NOT ALREADY DONE. IF WE ARE PRESIDENT OR BECOMES PRESIDENT BECAUSE 
  1889.  * OF A FAILED PRESIDENT THEN WE WILL TAKE FURTHER ACTION. 
  1890.  *---------------------------------------------------------------------------*/
  1891. void Qmgr::failReportLab(Signal* signal, Uint16 aFailedNode,
  1892.  FailRep::FailCause aFailCause) 
  1893. {
  1894.   NodeRecPtr nodePtr;
  1895.   NodeRecPtr failedNodePtr;
  1896.   NodeRecPtr myNodePtr;
  1897.   UintR TnoFailedNodes;
  1898.   failedNodePtr.i = aFailedNode;
  1899.   ptrCheckGuard(failedNodePtr, MAX_NODES, nodeRec);
  1900.   if (failedNodePtr.i == getOwnNodeId()) {
  1901.     jam();
  1902.     systemErrorLab(signal, __LINE__);
  1903.     return;
  1904.   }//if
  1905.   myNodePtr.i = getOwnNodeId();
  1906.   ptrCheckGuard(myNodePtr, MAX_NDB_NODES, nodeRec);
  1907.   if (myNodePtr.p->phase != ZRUNNING) {
  1908.     jam();
  1909.     systemErrorLab(signal, __LINE__);
  1910.     return;
  1911.   }//if
  1912.   TnoFailedNodes = cnoFailedNodes;
  1913.   failReport(signal, failedNodePtr.i, (UintR)ZTRUE, aFailCause);
  1914.   if (cpresident == getOwnNodeId()) {
  1915.     jam();
  1916.     if (ctoStatus == Q_NOT_ACTIVE) {
  1917.       jam();
  1918.       /**--------------------------------------------------------------------
  1919.        * AS PRESIDENT WE ARE REQUIRED TO START THE EXCLUSION PROCESS SUCH THAT
  1920.        * THE APPLICATION SEE NODE FAILURES IN A CONSISTENT ORDER.
  1921.        * IF WE HAVE BECOME PRESIDENT NOW (CTO_STATUS = ACTIVE) THEN WE HAVE 
  1922.        * TO COMPLETE THE PREVIOUS COMMIT FAILED NODE PROCESS BEFORE STARTING 
  1923.        * A NEW.
  1924.        * CTO_STATUS = ACTIVE CAN ALSO MEAN THAT WE ARE PRESIDENT AND ARE 
  1925.        * CURRENTLY COMMITTING A SET OF NODE CRASHES. IN THIS CASE IT IS NOT 
  1926.        * ALLOWED TO START PREPARING NEW NODE CRASHES.
  1927.        *---------------------------------------------------------------------*/
  1928.       if (TnoFailedNodes != cnoFailedNodes) {
  1929.         jam();
  1930.         cfailureNr = cfailureNr + 1;
  1931.         for (nodePtr.i = 1;
  1932.              nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  1933.           jam();
  1934.           ptrAss(nodePtr, nodeRec);
  1935.           if (nodePtr.p->phase == ZRUNNING) {
  1936.             jam();
  1937.             sendPrepFailReq(signal, nodePtr.i);
  1938.           }//if
  1939.         }//for
  1940.       }//if
  1941.     }//if
  1942.   }//if
  1943.   return;
  1944. }//Qmgr::failReportLab()
  1945. /**-------------------------------------------------------------------------
  1946.  * WE HAVE RECEIVED A PREPARE TO EXCLUDE A NUMBER OF NODES FROM THE CLUSTER.
  1947.  * WE WILL FIRST CHECK THAT WE HAVE NOT ANY MORE NODES THAT 
  1948.  * WE ALSO HAVE EXCLUDED
  1949.  *--------------------------------------------------------------------------*/
  1950. /*******************************/
  1951. /* PREP_FAILREQ               */
  1952. /*******************************/
  1953. void Qmgr::execPREP_FAILREQ(Signal* signal) 
  1954. {
  1955.   NodeRecPtr myNodePtr;
  1956.   jamEntry();
  1957.   PrepFailReqRef * const prepFail = (PrepFailReqRef *)&signal->theData[0];
  1958.   BlockReference Tblockref  = prepFail->xxxBlockRef;
  1959.   Uint16 TfailureNr = prepFail->failNo;
  1960.   cnoPrepFailedNodes = prepFail->noOfNodes;
  1961.   UintR arrayIndex = 0;
  1962.   Uint32 Tindex;
  1963.   for (Tindex = 0; Tindex < MAX_NDB_NODES; Tindex++) {
  1964.     if (NodeBitmask::get(prepFail->theNodes, Tindex)){
  1965.       cprepFailedNodes[arrayIndex] = Tindex;
  1966.       arrayIndex++;
  1967.     }//if
  1968.   }//for
  1969.   UintR guard0;
  1970.   /**
  1971.    * Block commit until node failures has stabilized
  1972.    *
  1973.    * @See RT352
  1974.    */
  1975.   BlockCommitOrd* const block = (BlockCommitOrd *)&signal->theData[0];
  1976.   block->failNo = TfailureNr;
  1977.   EXECUTE_DIRECT(DBDIH, GSN_BLOCK_COMMIT_ORD, signal, 
  1978.  BlockCommitOrd::SignalLength);
  1979.   myNodePtr.i = getOwnNodeId();
  1980.   ptrCheckGuard(myNodePtr, MAX_NDB_NODES, nodeRec);
  1981.   if (myNodePtr.p->phase != ZRUNNING) {
  1982.     jam();
  1983.     systemErrorLab(signal, __LINE__);
  1984.     return;
  1985.   }//if
  1986.   guard0 = cnoPrepFailedNodes - 1;
  1987.   arrGuard(guard0, MAX_NDB_NODES);
  1988.   for (Tindex = 0; Tindex <= guard0; Tindex++) {
  1989.     jam();
  1990.     failReport(signal,
  1991.                cprepFailedNodes[Tindex],
  1992.                (UintR)ZFALSE,
  1993.                FailRep::ZIN_PREP_FAIL_REQ);
  1994.   }//for
  1995.   sendCloseComReq(signal, Tblockref, TfailureNr);
  1996.   cnoCommitFailedNodes = 0;
  1997.   cprepareFailureNr = TfailureNr;
  1998.   return;
  1999. }//Qmgr::execPREP_FAILREQ()
  2000. /**---------------------------------------------------------------------------
  2001.  * THE CRASHED NODES HAS BEEN EXCLUDED FROM COMMUNICATION. 
  2002.  * WE WILL CHECK WHETHER ANY MORE NODES HAVE FAILED DURING THE PREPARE PROCESS.
  2003.  * IF SO WE WILL REFUSE THE PREPARE PHASE AND EXPECT A NEW PREPARE MESSAGE 
  2004.  * WITH ALL FAILED NODES INCLUDED.
  2005.  *---------------------------------------------------------------------------*/
  2006. /*******************************/
  2007. /* CLOSE_COMCONF              */
  2008. /*******************************/
  2009. void Qmgr::execCLOSE_COMCONF(Signal* signal) 
  2010. {
  2011.   jamEntry();
  2012.   CloseComReqConf * const closeCom = (CloseComReqConf *)&signal->theData[0];
  2013.   BlockReference Tblockref  = closeCom->xxxBlockRef;
  2014.   Uint16 TfailureNr = closeCom->failNo;
  2015.   cnoPrepFailedNodes = closeCom->noOfNodes;
  2016.   UintR arrayIndex = 0;
  2017.   UintR Tindex = 0;
  2018.   for(Tindex = 0; Tindex < MAX_NDB_NODES; Tindex++){
  2019.     if(NodeBitmask::get(closeCom->theNodes, Tindex)){
  2020.       cprepFailedNodes[arrayIndex] = Tindex;
  2021.       arrayIndex++;
  2022.     }
  2023.   }
  2024.   UintR tprepFailConf;
  2025.   UintR Tindex2;
  2026.   UintR guard0;
  2027.   UintR guard1;
  2028.   UintR Tfound;
  2029.   Uint16 TfailedNodeNo;
  2030.   tprepFailConf = ZTRUE;
  2031.   if (cnoFailedNodes > 0) {
  2032.     jam();
  2033.     guard0 = cnoFailedNodes - 1;
  2034.     arrGuard(guard0, MAX_NDB_NODES);
  2035.     for (Tindex = 0; Tindex <= guard0; Tindex++) {
  2036.       jam();
  2037.       TfailedNodeNo = cfailedNodes[Tindex];
  2038.       Tfound = ZFALSE;
  2039.       guard1 = cnoPrepFailedNodes - 1;
  2040.       arrGuard(guard1, MAX_NDB_NODES);
  2041.       for (Tindex2 = 0; Tindex2 <= guard1; Tindex2++) {
  2042.         jam();
  2043.         if (TfailedNodeNo == cprepFailedNodes[Tindex2]) {
  2044.           jam();
  2045.           Tfound = ZTRUE;
  2046.         }//if
  2047.       }//for
  2048.       if (Tfound == ZFALSE) {
  2049.         jam();
  2050.         tprepFailConf = ZFALSE;
  2051.         arrGuard(cnoPrepFailedNodes, MAX_NDB_NODES);
  2052.         cprepFailedNodes[cnoPrepFailedNodes] = TfailedNodeNo;
  2053.         cnoPrepFailedNodes = cnoPrepFailedNodes + 1;
  2054.       }//if
  2055.     }//for
  2056.   }//if
  2057.   if (tprepFailConf == ZFALSE) {
  2058.     jam();
  2059.     for (Tindex = 1; Tindex < MAX_NDB_NODES; Tindex++) {
  2060.       cfailedNodes[Tindex] = cprepFailedNodes[Tindex];
  2061.     }//for
  2062.     cnoFailedNodes = cnoPrepFailedNodes;
  2063.     sendPrepFailReqRef(signal,
  2064.        Tblockref,
  2065.        GSN_PREP_FAILREF,
  2066.        reference(),
  2067.        cfailureNr,
  2068.        cnoPrepFailedNodes,
  2069.        cprepFailedNodes);
  2070.   } else {
  2071.     jam();
  2072.     cnoCommitFailedNodes = cnoPrepFailedNodes;
  2073.     guard0 = cnoPrepFailedNodes - 1;
  2074.     arrGuard(guard0, MAX_NDB_NODES);
  2075.     for (Tindex = 0; Tindex <= guard0; Tindex++) {
  2076.       jam();
  2077.       arrGuard(Tindex, MAX_NDB_NODES);
  2078.       ccommitFailedNodes[Tindex] = cprepFailedNodes[Tindex];
  2079.     }//for
  2080.     signal->theData[0] = getOwnNodeId();
  2081.     signal->theData[1] = TfailureNr;
  2082.     sendSignal(Tblockref, GSN_PREP_FAILCONF, signal, 2, JBA);
  2083.   }//if
  2084.   return;
  2085. }//Qmgr::execCLOSE_COMCONF()
  2086. /*---------------------------------------------------------------------------*/
  2087. /* WE HAVE RECEIVED A CONFIRM OF THAT THIS NODE HAVE PREPARED THE FAILURE.   */
  2088. /*---------------------------------------------------------------------------*/
  2089. /*******************************/
  2090. /* PREP_FAILCONF              */
  2091. /*******************************/
  2092. void Qmgr::execPREP_FAILCONF(Signal* signal) 
  2093. {
  2094.   NodeRecPtr nodePtr;
  2095.   NodeRecPtr replyNodePtr;
  2096.   jamEntry();
  2097.   replyNodePtr.i = signal->theData[0];
  2098.   Uint16 TfailureNr = signal->theData[1];
  2099.   if (TfailureNr != cfailureNr) {
  2100.     jam();
  2101.     /**----------------------------------------------------------------------
  2102.      * WE HAVE ALREADY STARTING A NEW ATTEMPT TO EXCLUDE A NUMBER OF NODES. 
  2103.      *  IGNORE
  2104.      *----------------------------------------------------------------------*/
  2105.     return;
  2106.   }//if
  2107.   ptrCheckGuard(replyNodePtr, MAX_NDB_NODES, nodeRec);
  2108.   replyNodePtr.p->sendPrepFailReqStatus = Q_NOT_ACTIVE;
  2109.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2110.     jam();
  2111.     ptrAss(nodePtr, nodeRec);
  2112.     if (nodePtr.p->phase == ZRUNNING) {
  2113.       if (nodePtr.p->sendPrepFailReqStatus == Q_ACTIVE) {
  2114.         jam();
  2115.         return;
  2116.       }//if
  2117.     }//if
  2118.   }//for
  2119.   /**
  2120.    * Check node count and groups and invoke arbitrator if necessary.
  2121.    * Continues via sendCommitFailReq() if successful.
  2122.    */
  2123.   arbitRec.failureNr = cfailureNr;
  2124.   const NodeState & s = getNodeState();
  2125.   if(s.startLevel == NodeState::SL_STOPPING_3 && s.stopping.systemShutdown){
  2126.     jam();
  2127.     /**
  2128.      * We're performing a system shutdown, 
  2129.      * don't let artibtrator shut us down
  2130.      */
  2131.     return;
  2132.   }
  2133.   handleArbitCheck(signal);
  2134.   return;
  2135. }//Qmgr::execPREP_FAILCONF()
  2136. void
  2137. Qmgr::sendCommitFailReq(Signal* signal)
  2138. {
  2139.   NodeRecPtr nodePtr;
  2140.   jam();
  2141.   if (arbitRec.failureNr != cfailureNr) {
  2142.     jam();
  2143.     /**----------------------------------------------------------------------
  2144.      * WE HAVE ALREADY STARTING A NEW ATTEMPT TO EXCLUDE A NUMBER OF NODES. 
  2145.      *  IGNORE
  2146.      *----------------------------------------------------------------------*/
  2147.     return;
  2148.   }//if
  2149.   /**-----------------------------------------------------------------------
  2150.    * WE HAVE SUCCESSFULLY PREPARED A SET OF NODE FAILURES. WE WILL NOW COMMIT 
  2151.    * THESE NODE FAILURES.
  2152.    *-------------------------------------------------------------------------*/
  2153.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2154.     jam();
  2155.     ptrAss(nodePtr, nodeRec);
  2156.     if (nodePtr.p->phase == ZRUNNING) {
  2157.       jam();
  2158.       nodePtr.p->sendCommitFailReqStatus = Q_ACTIVE;
  2159.       signal->theData[0] = cpdistref;
  2160.       signal->theData[1] = cfailureNr;
  2161.       sendSignal(nodePtr.p->blockRef, GSN_COMMIT_FAILREQ, signal, 2, JBA);
  2162.     }//if
  2163.   }//for
  2164.   ctoStatus = Q_ACTIVE;
  2165.   cnoFailedNodes = 0;
  2166.   return;
  2167. }//sendCommitFailReq()
  2168. /*---------------------------------------------------------------------------*/
  2169. /* SOME NODE HAVE DISCOVERED A NODE FAILURE THAT WE HAVE NOT YET DISCOVERED. */
  2170. /* WE WILL START ANOTHER ROUND OF PREPARING A SET OF NODE FAILURES.          */
  2171. /*---------------------------------------------------------------------------*/
  2172. /*******************************/
  2173. /* PREP_FAILREF               */
  2174. /*******************************/
  2175. void Qmgr::execPREP_FAILREF(Signal* signal) 
  2176. {
  2177.   NodeRecPtr nodePtr;
  2178.   jamEntry();
  2179.   PrepFailReqRef * const prepFail = (PrepFailReqRef *)&signal->theData[0];
  2180.   Uint16 TfailureNr = prepFail->failNo;
  2181.   cnoPrepFailedNodes = prepFail->noOfNodes;
  2182.   UintR arrayIndex = 0;
  2183.   UintR Tindex = 0;
  2184.   for(Tindex = 0; Tindex < MAX_NDB_NODES; Tindex++) {
  2185.     jam();
  2186.     if(NodeBitmask::get(prepFail->theNodes, Tindex)){
  2187.       jam();
  2188.       cprepFailedNodes[arrayIndex] = Tindex;
  2189.       arrayIndex++;
  2190.     }//if
  2191.   }//for
  2192.   if (TfailureNr != cfailureNr) {
  2193.     jam();
  2194.     /**---------------------------------------------------------------------
  2195.      * WE HAVE ALREADY STARTING A NEW ATTEMPT TO EXCLUDE A NUMBER OF NODES. 
  2196.      *  IGNORE
  2197.      *----------------------------------------------------------------------*/
  2198.     return;
  2199.   }//if
  2200.   UintR guard0;
  2201.   UintR Ti;
  2202.   cnoFailedNodes = cnoPrepFailedNodes;
  2203.   guard0 = cnoPrepFailedNodes - 1;
  2204.   arrGuard(guard0, MAX_NDB_NODES);
  2205.   for (Ti = 0; Ti <= guard0; Ti++) {
  2206.     jam();
  2207.     cfailedNodes[Ti] = cprepFailedNodes[Ti];
  2208.   }//for
  2209.   cfailureNr = cfailureNr + 1;
  2210.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2211.     jam();
  2212.     ptrAss(nodePtr, nodeRec);
  2213.     if (nodePtr.p->phase == ZRUNNING) {
  2214.       jam();
  2215.       sendPrepFailReq(signal, nodePtr.i);
  2216.     }//if
  2217.   }//for
  2218.   return;
  2219. }//Qmgr::execPREP_FAILREF()
  2220. /*---------------------------------------------------------------------------*/
  2221. /*    THE PRESIDENT IS NOW COMMITTING THE PREVIOUSLY PREPARED NODE FAILURE.  */
  2222. /*---------------------------------------------------------------------------*/
  2223. /***********************/
  2224. /* COMMIT_FAILREQ     */
  2225. /***********************/
  2226. void Qmgr::execCOMMIT_FAILREQ(Signal* signal) 
  2227. {
  2228.   NodeRecPtr nodePtr;
  2229.   jamEntry();
  2230.   BlockReference Tblockref = signal->theData[0];
  2231.   UintR TfailureNr = signal->theData[1];
  2232.   if (Tblockref != cpdistref) {
  2233.     jam();
  2234.     return;
  2235.   }//if
  2236.   UintR guard0;
  2237.   UintR Tj;
  2238.   /**
  2239.    * Block commit until node failures has stabilized
  2240.    *
  2241.    * @See RT352
  2242.    */
  2243.   UnblockCommitOrd* const unblock = (UnblockCommitOrd *)&signal->theData[0];
  2244.   unblock->failNo = TfailureNr;
  2245.   EXECUTE_DIRECT(DBDIH, GSN_UNBLOCK_COMMIT_ORD, signal, 
  2246.  UnblockCommitOrd::SignalLength);
  2247.   
  2248.   if ((ccommitFailureNr != TfailureNr) &&
  2249.       (cnoCommitFailedNodes > 0)) {
  2250.     jam();
  2251.     /**-----------------------------------------------------------------------
  2252.      * WE ONLY DO THIS PART OF THE COMMIT HANDLING THE FIRST TIME WE HEAR THIS
  2253.      * SIGNAL. WE CAN HEAR IT SEVERAL TIMES IF THE PRESIDENTS KEEP FAILING.
  2254.      *-----------------------------------------------------------------------*/
  2255.     ccommitFailureNr = TfailureNr;
  2256.     NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0];
  2257.     
  2258.     nodeFail->failNo    = ccommitFailureNr;
  2259.     nodeFail->noOfNodes = cnoCommitFailedNodes;
  2260.     nodeFail->masterNodeId = cpresident;
  2261.     NodeBitmask::clear(nodeFail->theNodes);
  2262.     for(unsigned i = 0; i < cnoCommitFailedNodes; i++) {
  2263.       jam();
  2264.       NodeBitmask::set(nodeFail->theNodes, ccommitFailedNodes[i]);
  2265.     }//if
  2266.     sendSignal(NDBCNTR_REF, GSN_NODE_FAILREP, signal, 
  2267.        NodeFailRep::SignalLength, JBB);
  2268.     guard0 = cnoCommitFailedNodes - 1;
  2269.     arrGuard(guard0, MAX_NDB_NODES);
  2270.     /**--------------------------------------------------------------------
  2271.      * WE MUST PREPARE TO ACCEPT THE CRASHED NODE INTO THE CLUSTER AGAIN BY 
  2272.      * SETTING UP CONNECTIONS AGAIN AFTER THREE SECONDS OF DELAY.
  2273.      *--------------------------------------------------------------------*/
  2274.     for (Tj = 0; Tj <= guard0; Tj++) {
  2275.       jam();
  2276.       nodePtr.i = ccommitFailedNodes[Tj];
  2277.       ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec);
  2278.       nodePtr.p->phase = ZFAIL_CLOSING;
  2279.       nodePtr.p->failState = WAITING_FOR_NDB_FAILCONF;
  2280.       nodePtr.p->alarmCount = 0;
  2281.       c_clusterNodes.clear(nodePtr.i);
  2282.     }//for
  2283.     /*----------------------------------------------------------------------*/
  2284.     /*       WE INFORM THE API'S WE HAVE CONNECTED ABOUT THE FAILED NODES.  */
  2285.     /*----------------------------------------------------------------------*/
  2286.     for (nodePtr.i = 1; nodePtr.i < MAX_NODES; nodePtr.i++) {
  2287.       jam();
  2288.       ptrAss(nodePtr, nodeRec);
  2289.       if (nodePtr.p->phase == ZAPI_ACTIVE) {
  2290.         jam();
  2291. NodeFailRep * const nodeFail = (NodeFailRep *)&signal->theData[0];
  2292. nodeFail->failNo    = ccommitFailureNr;
  2293. nodeFail->noOfNodes = cnoCommitFailedNodes;
  2294. NodeBitmask::clear(nodeFail->theNodes);
  2295. for(unsigned i = 0; i < cnoCommitFailedNodes; i++) {
  2296.           jam();
  2297.   NodeBitmask::set(nodeFail->theNodes, ccommitFailedNodes[i]);
  2298.         }//for
  2299.         sendSignal(nodePtr.p->blockRef, GSN_NODE_FAILREP, signal, 
  2300.    NodeFailRep::SignalLength, JBB);
  2301.       }//if
  2302.     }//for
  2303.     if (cpresident != getOwnNodeId()) {
  2304.       jam();
  2305.       cnoFailedNodes = cnoCommitFailedNodes - cnoFailedNodes;
  2306.       if (cnoFailedNodes > 0) {
  2307.         jam();
  2308.         guard0 = cnoFailedNodes - 1;
  2309.         arrGuard(guard0 + cnoCommitFailedNodes, MAX_NDB_NODES);
  2310.         for (Tj = 0; Tj <= guard0; Tj++) {
  2311.           jam();
  2312.           cfailedNodes[Tj] = cfailedNodes[Tj + cnoCommitFailedNodes];
  2313.         }//for
  2314.       }//if
  2315.     }//if
  2316.     cnoCommitFailedNodes = 0;
  2317.   }//if
  2318.   /**-----------------------------------------------------------------------
  2319.    * WE WILL ALWAYS ACKNOWLEDGE THE COMMIT EVEN WHEN RECEIVING IT MULTIPLE 
  2320.    * TIMES SINCE IT WILL ALWAYS COME FROM A NEW PRESIDENT. 
  2321.    *------------------------------------------------------------------------*/
  2322.   signal->theData[0] = getOwnNodeId();
  2323.   sendSignal(Tblockref, GSN_COMMIT_FAILCONF, signal, 1, JBA);
  2324.   return;
  2325. }//Qmgr::execCOMMIT_FAILREQ()
  2326. /*--------------------------------------------------------------------------*/
  2327. /* WE HAVE RECEIVED A CONFIRM OF THAT THIS NODE HAVE COMMITTED THE FAILURES.*/
  2328. /*--------------------------------------------------------------------------*/
  2329. /*******************************/
  2330. /* COMMIT_FAILCONF            */
  2331. /*******************************/
  2332. void Qmgr::execCOMMIT_FAILCONF(Signal* signal) 
  2333. {
  2334.   NodeRecPtr nodePtr;
  2335.   NodeRecPtr replyNodePtr;
  2336.   jamEntry();
  2337.   replyNodePtr.i = signal->theData[0];
  2338.   ptrCheckGuard(replyNodePtr, MAX_NDB_NODES, nodeRec);
  2339.   replyNodePtr.p->sendCommitFailReqStatus = Q_NOT_ACTIVE;
  2340.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2341.     jam();
  2342.     ptrAss(nodePtr, nodeRec);
  2343.     if (nodePtr.p->phase == ZRUNNING) {
  2344.       if (nodePtr.p->sendCommitFailReqStatus == Q_ACTIVE) {
  2345.         jam();
  2346.         return;
  2347.       }//if
  2348.     }//if
  2349.   }//for
  2350.   /*-----------------------------------------------------------------------*/
  2351.   /*   WE HAVE SUCCESSFULLY COMMITTED A SET OF NODE FAILURES.              */
  2352.   /*-----------------------------------------------------------------------*/
  2353.   ctoStatus = Q_NOT_ACTIVE;
  2354.   if (cnoFailedNodes != 0) {
  2355.     jam();
  2356.     /**----------------------------------------------------------------------
  2357.      * A FAILURE OCCURRED IN THE MIDDLE OF THE COMMIT PROCESS. WE ARE NOW 
  2358.      *  READY TO START THE FAILED NODE PROCESS FOR THIS NODE.
  2359.      *----------------------------------------------------------------------*/
  2360.     cfailureNr = cfailureNr + 1;
  2361.     for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2362.       jam();
  2363.       ptrAss(nodePtr, nodeRec);
  2364.       if (nodePtr.p->phase == ZRUNNING) {
  2365.         jam();
  2366.         sendPrepFailReq(signal, nodePtr.i);
  2367.       }//if
  2368.     }//for
  2369.   }//if
  2370.   return;
  2371. }//Qmgr::execCOMMIT_FAILCONF()
  2372. /**--------------------------------------------------------------------------
  2373.  * IF THE PRESIDENT FAILS IN THE MIDDLE OF THE COMMIT OF A FAILED NODE THEN 
  2374.  * THE NEW PRESIDENT NEEDS TO QUERY THE COMMIT STATUS IN THE RUNNING NODES.
  2375.  *---------------------------------------------------------------------------*/
  2376. /*******************************/
  2377. /* PRES_TOCONF                */
  2378. /*******************************/
  2379. void Qmgr::execPRES_TOCONF(Signal* signal) 
  2380. {
  2381.   NodeRecPtr nodePtr;
  2382.   NodeRecPtr replyNodePtr;
  2383.   jamEntry();
  2384.   replyNodePtr.i = signal->theData[0];
  2385.   UintR TfailureNr = signal->theData[1];
  2386.   if (ctoFailureNr < TfailureNr) {
  2387.     jam();
  2388.     ctoFailureNr = TfailureNr;
  2389.   }//if
  2390.   ptrCheckGuard(replyNodePtr, MAX_NDB_NODES, nodeRec);
  2391.   replyNodePtr.p->sendPresToStatus = Q_NOT_ACTIVE;
  2392.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2393.     jam();
  2394.     ptrAss(nodePtr, nodeRec);
  2395.     if (nodePtr.p->sendPresToStatus == Q_ACTIVE) {
  2396.       jam();
  2397.       return;
  2398.     }//if
  2399.   }//for
  2400.   /*-------------------------------------------------------------------------*/
  2401.   /* WE ARE NOW READY TO DISCOVER WHETHER THE FAILURE WAS COMMITTED OR NOT.  */
  2402.   /*-------------------------------------------------------------------------*/
  2403.   if (ctoFailureNr > ccommitFailureNr) {
  2404.     jam();
  2405.     for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2406.       jam();
  2407.       ptrAss(nodePtr, nodeRec);
  2408.       if (nodePtr.p->phase == ZRUNNING) {
  2409.         jam();
  2410.         nodePtr.p->sendCommitFailReqStatus = Q_ACTIVE;
  2411.         signal->theData[0] = cpdistref;
  2412.         signal->theData[1] = ctoFailureNr;
  2413.         sendSignal(nodePtr.p->blockRef, GSN_COMMIT_FAILREQ, signal, 2, JBA);
  2414.       }//if
  2415.     }//for
  2416.     return;
  2417.   }//if
  2418.   /*-------------------------------------------------------------------------*/
  2419.   /*       WE ARE NOW READY TO START THE NEW NODE FAILURE PROCESS.           */
  2420.   /*-------------------------------------------------------------------------*/
  2421.   ctoStatus = Q_NOT_ACTIVE;
  2422.   cfailureNr = cfailureNr + 1;
  2423.   for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2424.     jam();
  2425.     ptrAss(nodePtr, nodeRec);
  2426.     if (nodePtr.p->phase == ZRUNNING) {
  2427.       jam();
  2428.       sendPrepFailReq(signal, nodePtr.i);
  2429.     }//if
  2430.   }//for
  2431.   return;
  2432. }//Qmgr::execPRES_TOCONF()
  2433. /*--------------------------------------------------------------------------*/
  2434. // Provide information about the configured NDB nodes in the system.
  2435. /*--------------------------------------------------------------------------*/
  2436. void Qmgr::execREAD_NODESREQ(Signal* signal)
  2437. {
  2438.   jamEntry();
  2439.   BlockReference TBref = signal->theData[0];
  2440.   ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0];
  2441.   NodeRecPtr nodePtr;
  2442.   nodePtr.i = getOwnNodeId();
  2443.   ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec);
  2444.   NdbNodeBitmask tmp = c_definedNodes;
  2445.   tmp.bitANDC(c_clusterNodes);
  2446.   readNodes->noOfNodes = c_definedNodes.count();
  2447.   readNodes->masterNodeId = cpresident;
  2448.   readNodes->ndynamicId = nodePtr.p->ndynamicId;
  2449.   c_definedNodes.copyto(NdbNodeBitmask::Size, readNodes->definedNodes);
  2450.   c_clusterNodes.copyto(NdbNodeBitmask::Size, readNodes->clusterNodes);
  2451.   tmp.copyto(NdbNodeBitmask::Size, readNodes->inactiveNodes);
  2452.   NdbNodeBitmask::clear(readNodes->startingNodes);
  2453.   NdbNodeBitmask::clear(readNodes->startedNodes);
  2454.   sendSignal(TBref, GSN_READ_NODESCONF, signal, 
  2455.      ReadNodesConf::SignalLength, JBB);
  2456. }//Qmgr::execREAD_NODESREQ()
  2457. void Qmgr::systemErrorBecauseOtherNodeFailed(Signal* signal, Uint32 line,
  2458.      NodeId failedNodeId) {
  2459.   jam();
  2460.   // Broadcast that this node is failing to other nodes
  2461.   failReport(signal, getOwnNodeId(), (UintR)ZTRUE, FailRep::ZOWN_FAILURE);
  2462.   char buf[100];
  2463.   BaseString::snprintf(buf, 100, 
  2464.    "Node was shutdown during startup because node %d failed",
  2465.    failedNodeId);
  2466.   progError(line, ERR_SR_OTHERNODEFAILED, buf);  
  2467. }
  2468. void Qmgr::systemErrorLab(Signal* signal, Uint32 line, const char * message) 
  2469. {
  2470.   jam();
  2471.   // Broadcast that this node is failing to other nodes
  2472.   failReport(signal, getOwnNodeId(), (UintR)ZTRUE, FailRep::ZOWN_FAILURE);
  2473.   // If it's known why shutdown occured
  2474.   // an error message has been passed to this function
  2475.   progError(line, 0, message);  
  2476.   return;
  2477. }//Qmgr::systemErrorLab()
  2478. /**---------------------------------------------------------------------------
  2479.  * A FAILURE HAVE BEEN DISCOVERED ON A NODE. WE NEED TO CLEAR A 
  2480.  * NUMBER OF VARIABLES.
  2481.  *---------------------------------------------------------------------------*/
  2482. void Qmgr::failReport(Signal* signal,
  2483.                       Uint16 aFailedNode,
  2484.                       UintR aSendFailRep,
  2485.                       FailRep::FailCause aFailCause) 
  2486. {
  2487.   UintR tfrMinDynamicId;
  2488.   NodeRecPtr failedNodePtr;
  2489.   NodeRecPtr nodePtr;
  2490.   NodeRecPtr presidentNodePtr;
  2491.   failedNodePtr.i = aFailedNode;
  2492.   ptrCheckGuard(failedNodePtr, MAX_NDB_NODES, nodeRec);
  2493.   if (failedNodePtr.p->phase == ZRUNNING) {
  2494.     jam();
  2495. /* WE ALSO NEED TO ADD HERE SOME CODE THAT GETS OUR NEW NEIGHBOURS. */
  2496.     if (cpresident == getOwnNodeId()) {
  2497.       jam();
  2498.       if (failedNodePtr.p->sendCommitFailReqStatus == Q_ACTIVE) {
  2499.         jam();
  2500.         signal->theData[0] = failedNodePtr.i;
  2501.         sendSignal(QMGR_REF, GSN_COMMIT_FAILCONF, signal, 1, JBA);
  2502.       }//if
  2503.       if (failedNodePtr.p->sendPresToStatus == Q_ACTIVE) {
  2504.         jam();
  2505.         signal->theData[0] = failedNodePtr.i;
  2506.         signal->theData[1] = ccommitFailureNr;
  2507.         sendSignal(QMGR_REF, GSN_PRES_TOCONF, signal, 2, JBA);
  2508.       }//if
  2509.     }//if
  2510.     failedNodePtr.p->phase = ZPREPARE_FAIL;
  2511.     failedNodePtr.p->sendPrepFailReqStatus = Q_NOT_ACTIVE;
  2512.     failedNodePtr.p->sendCommitFailReqStatus = Q_NOT_ACTIVE;
  2513.     failedNodePtr.p->sendPresToStatus = Q_NOT_ACTIVE;
  2514.     failedNodePtr.p->alarmCount = 0;
  2515.     if (aSendFailRep == ZTRUE) {
  2516.       jam();
  2517.       if (failedNodePtr.i != getOwnNodeId()) {
  2518.         jam();
  2519. FailRep * const failRep = (FailRep *)&signal->theData[0];
  2520.         failRep->failNodeId = failedNodePtr.i;
  2521.         failRep->failCause = aFailCause;
  2522.         sendSignal(failedNodePtr.p->blockRef, GSN_FAIL_REP, signal, 
  2523.    FailRep::SignalLength, JBA);
  2524.       }//if
  2525.       for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2526.         jam();
  2527.         ptrAss(nodePtr, nodeRec);
  2528.         if (nodePtr.p->phase == ZRUNNING) {
  2529.           jam();
  2530.   FailRep * const failRep = (FailRep *)&signal->theData[0];
  2531.   failRep->failNodeId = failedNodePtr.i;
  2532.   failRep->failCause = aFailCause;
  2533.           sendSignal(nodePtr.p->blockRef, GSN_FAIL_REP, signal, 
  2534.      FailRep::SignalLength, JBA);
  2535.         }//if
  2536.       }//for
  2537.     }//if
  2538.     if (failedNodePtr.i == getOwnNodeId()) {
  2539.       jam();
  2540.       return;
  2541.     }//if
  2542.     failedNodePtr.p->ndynamicId = 0;
  2543.     findNeighbours(signal);
  2544.     if (failedNodePtr.i == cpresident) {
  2545.       jam();
  2546.       /**--------------------------------------------------------------------
  2547.        * IF PRESIDENT HAVE FAILED WE MUST CALCULATE THE NEW PRESIDENT BY 
  2548.        * FINDING THE NODE WITH THE MINIMUM DYNAMIC IDENTITY.
  2549.        *---------------------------------------------------------------------*/
  2550.       tfrMinDynamicId = (UintR)-1;
  2551.       for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; nodePtr.i++) {
  2552.         jam();
  2553.         ptrAss(nodePtr, nodeRec);
  2554.         if (nodePtr.p->phase == ZRUNNING) {
  2555.           if (nodePtr.p->ndynamicId < tfrMinDynamicId) {
  2556.             jam();
  2557.             tfrMinDynamicId = nodePtr.p->ndynamicId;
  2558.             cpresident = nodePtr.i;
  2559.           }//if
  2560.         }//if
  2561.       }//for
  2562.       presidentNodePtr.i = cpresident;
  2563.       ptrCheckGuard(presidentNodePtr, MAX_NDB_NODES, nodeRec);
  2564.       cpdistref = presidentNodePtr.p->blockRef;
  2565.       if (cpresident == getOwnNodeId()) {
  2566. CRASH_INSERTION(920);
  2567.         cfailureNr = cprepareFailureNr;
  2568.         ctoFailureNr = 0;
  2569.         ctoStatus = Q_ACTIVE;
  2570.         if (cnoCommitFailedNodes > 0) {
  2571.           jam();
  2572.   /**-----------------------------------------------------------------
  2573.    * IN THIS SITUATION WE ARE UNCERTAIN OF WHETHER THE NODE FAILURE 
  2574.    * PROCESS WAS COMMITTED. WE NEED TO QUERY THE OTHER NODES ABOUT 
  2575.    * THEIR STATUS.
  2576.    *-----------------------------------------------------------------*/
  2577.           for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; 
  2578.        nodePtr.i++) {
  2579.             jam();
  2580.             ptrAss(nodePtr, nodeRec);
  2581.             if (nodePtr.p->phase == ZRUNNING) {
  2582.               jam();
  2583.               nodePtr.p->sendPresToStatus = Q_ACTIVE;
  2584.               signal->theData[0] = cpdistref;
  2585.               signal->theData[1] = cprepareFailureNr;
  2586.               sendSignal(nodePtr.p->blockRef, GSN_PRES_TOREQ, 
  2587.  signal, 1, JBA);
  2588.             }//if
  2589.           }//for
  2590.         } else {
  2591.           jam();
  2592.   /*-----------------------------------------------------------------*/
  2593.   // In this case it could be that a commit process is still ongoing. 
  2594.   // If so we must conclude it as the new master.
  2595.   /*-----------------------------------------------------------------*/
  2596.           for (nodePtr.i = 1; nodePtr.i < MAX_NDB_NODES; 
  2597.        nodePtr.i++) {
  2598.             jam();
  2599.             ptrAss(nodePtr, nodeRec);
  2600.             if (nodePtr.p->phase == ZRUNNING) {
  2601.               jam();
  2602.               nodePtr.p->sendCommitFailReqStatus = Q_ACTIVE;
  2603.               signal->theData[0] = cpdistref;
  2604.               signal->theData[1] = ccommitFailureNr;
  2605.               sendSignal(nodePtr.p->blockRef, GSN_COMMIT_FAILREQ, signal, 
  2606.  2, JBA);
  2607.             }//if
  2608.           }//for
  2609.         }//if
  2610.       }//if
  2611.     }//if
  2612.     arrGuard(cnoFailedNodes, MAX_NDB_NODES);
  2613.     cfailedNodes[cnoFailedNodes] = failedNodePtr.i;
  2614.     cnoFailedNodes = cnoFailedNodes + 1;
  2615.   }//if
  2616. }//Qmgr::failReport()
  2617. /*---------------------------------------------------------------------------*/
  2618. /*       INPUT:  TTDI_DYN_ID                                                 */
  2619. /*       OUTPUT: TTDI_NODE_ID                                                */
  2620. /*---------------------------------------------------------------------------*/
  2621. Uint16 Qmgr::translateDynamicIdToNodeId(Signal* signal, UintR TdynamicId) 
  2622. {
  2623.   NodeRecPtr tdiNodePtr;
  2624.   Uint16 TtdiNodeId = ZNIL;
  2625.   for (tdiNodePtr.i = 1; tdiNodePtr.i < MAX_NDB_NODES; tdiNodePtr.i++) {
  2626.     jam();
  2627.     ptrAss(tdiNodePtr, nodeRec);
  2628.     if (tdiNodePtr.p->ndynamicId == TdynamicId) {
  2629.       jam();
  2630.       TtdiNodeId = tdiNodePtr.i;
  2631.       break;
  2632.     }//if
  2633.   }//for
  2634.   if (TtdiNodeId == ZNIL) {
  2635.     jam();
  2636.     systemErrorLab(signal, __LINE__);
  2637.   }//if
  2638.   return TtdiNodeId;
  2639. }//Qmgr::translateDynamicIdToNodeId()
  2640. /**--------------------------------------------------------------------------
  2641.  *       WHEN RECEIVING PREPARE FAILURE REQUEST WE WILL IMMEDIATELY CLOSE
  2642.  *       COMMUNICATION WITH ALL THOSE NODES.
  2643.  *--------------------------------------------------------------------------*/
  2644. void Qmgr::sendCloseComReq(Signal* signal, BlockReference TBRef, Uint16 aFailNo)
  2645. {
  2646.   CloseComReqConf * const closeCom = (CloseComReqConf *)&signal->theData[0];
  2647.   
  2648.   closeCom->xxxBlockRef = TBRef;
  2649.   closeCom->failNo      = aFailNo;
  2650.   closeCom->noOfNodes   = cnoPrepFailedNodes;
  2651.   
  2652.   NodeBitmask::clear(closeCom->theNodes);
  2653.   for(int i = 0; i < cnoPrepFailedNodes; i++) {
  2654.     const NodeId nodeId = cprepFailedNodes[i];
  2655.     jam();
  2656.     NodeBitmask::set(closeCom->theNodes, nodeId);
  2657.   }
  2658.   sendSignal(CMVMI_REF, GSN_CLOSE_COMREQ, signal, 
  2659.      CloseComReqConf::SignalLength, JBA);
  2660. }//Qmgr::sendCloseComReq()
  2661. void 
  2662. Qmgr::sendPrepFailReqRef(Signal* signal, 
  2663.  Uint32 dstBlockRef,
  2664.  GlobalSignalNumber gsn,
  2665.  Uint32 blockRef,
  2666.  Uint32 failNo,
  2667.  Uint32 noOfNodes,
  2668.  const NodeId theNodes[]){
  2669.   PrepFailReqRef * const prepFail = (PrepFailReqRef *)&signal->theData[0];
  2670.   prepFail->xxxBlockRef = blockRef;
  2671.   prepFail->failNo = failNo;
  2672.   prepFail->noOfNodes = noOfNodes;
  2673.   NodeBitmask::clear(prepFail->theNodes);
  2674.   
  2675.   for(Uint32 i = 0; i<noOfNodes; i++){
  2676.     const NodeId nodeId = theNodes[i];
  2677.     NodeBitmask::set(prepFail->theNodes, nodeId);
  2678.   }
  2679.   sendSignal(dstBlockRef, gsn, signal, PrepFailReqRef::SignalLength, JBA);  
  2680. /**--------------------------------------------------------------------------
  2681.  *       SEND PREPARE FAIL REQUEST FROM PRESIDENT.
  2682.  *---------------------------------------------------------------------------*/
  2683. void Qmgr::sendPrepFailReq(Signal* signal, Uint16 aNode) 
  2684. {
  2685.   NodeRecPtr sendNodePtr;
  2686.   sendNodePtr.i = aNode;
  2687.   ptrCheckGuard(sendNodePtr, MAX_NDB_NODES, nodeRec);
  2688.   sendNodePtr.p->sendPrepFailReqStatus = Q_ACTIVE;
  2689.   sendPrepFailReqRef(signal,
  2690.      sendNodePtr.p->blockRef,
  2691.      GSN_PREP_FAILREQ,
  2692.      reference(),
  2693.      cfailureNr,
  2694.      cnoFailedNodes,
  2695.      cfailedNodes);
  2696. }//Qmgr::sendPrepFailReq()
  2697. /**
  2698.  * Arbitration module.  Rest of QMGR calls us only via
  2699.  * the "handle" routines.
  2700.  */
  2701. /**
  2702.  * Should < 1/2 nodes die unconditionally.  Affects only >= 3-way
  2703.  * replication.
  2704.  */
  2705. static const bool g_ndb_arbit_one_half_rule = false;
  2706. /**
  2707.  * Config signals are logically part of CM_INIT.
  2708.  */
  2709. void
  2710. Qmgr::execARBIT_CFG(Signal* signal)
  2711. {
  2712.   jamEntry();
  2713.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  2714.   unsigned rank = sd->code;
  2715.   ndbrequire(1 <= rank && rank <= 2);
  2716.   arbitRec.apiMask[0].bitOR(sd->mask);
  2717.   arbitRec.apiMask[rank] = sd->mask;
  2718. }
  2719. /**
  2720.  * ContinueB delay (0=JBA 1=JBB)
  2721.  */
  2722. Uint32 Qmgr::getArbitDelay()
  2723. {
  2724.   switch (arbitRec.state) {
  2725.   case ARBIT_NULL:
  2726.     jam();
  2727.     break;
  2728.   case ARBIT_INIT:
  2729.     jam();
  2730.   case ARBIT_FIND:
  2731.     jam();
  2732.   case ARBIT_PREP1:
  2733.     jam();
  2734.   case ARBIT_PREP2:
  2735.     jam();
  2736.   case ARBIT_START:
  2737.     jam();
  2738.     return 100;
  2739.   case ARBIT_RUN:
  2740.     jam();
  2741.     return 1000;
  2742.   case ARBIT_CHOOSE:
  2743.     jam();
  2744.     return 10;
  2745.   case ARBIT_CRASH:             // if we could wait
  2746.     jam();
  2747.     return 100;
  2748.   }
  2749.   ndbrequire(false);
  2750.   return (Uint32)-1;
  2751. }
  2752. /**
  2753.  * Time to wait for reply.  There is only 1 config parameter
  2754.  * (timeout for CHOOSE).  XXX The rest are guesses.
  2755.  */
  2756. Uint32 Qmgr::getArbitTimeout()
  2757. {
  2758.   switch (arbitRec.state) {
  2759.   case ARBIT_NULL:
  2760.     jam();
  2761.     break;
  2762.   case ARBIT_INIT:              // not used
  2763.     jam();
  2764.   case ARBIT_FIND:              // not used
  2765.     jam();
  2766.     return 1000;
  2767.   case ARBIT_PREP1:
  2768.     jam();
  2769.   case ARBIT_PREP2:
  2770.     jam();
  2771.     return 1000 + cnoOfNodes * hb_send_timer.getDelay();
  2772.   case ARBIT_START:
  2773.     jam();
  2774.     return 1000 + arbitRec.timeout;
  2775.   case ARBIT_RUN:               // not used (yet)
  2776.     jam();
  2777.     return 1000;
  2778.   case ARBIT_CHOOSE:
  2779.     jam();
  2780.     return arbitRec.timeout;
  2781.   case ARBIT_CRASH:             // if we could wait
  2782.     jam();
  2783.     return 100;
  2784.   }
  2785.   ndbrequire(false);
  2786.   return (Uint32)-1;
  2787. }
  2788. /**
  2789.  * Start arbitration thread when we are president and database
  2790.  * is opened for the first time.
  2791.  *
  2792.  * XXX  Do arbitration check just like on node failure.  Since
  2793.  * there is no arbitrator yet, must win on counts alone.
  2794.  */
  2795. void
  2796. Qmgr::handleArbitStart(Signal* signal)
  2797. {
  2798.   jam();
  2799.   ndbrequire(cpresident == getOwnNodeId());
  2800.   ndbrequire(arbitRec.state == ARBIT_NULL);
  2801.   arbitRec.state = ARBIT_INIT;
  2802.   arbitRec.newstate = true;
  2803.   startArbitThread(signal);
  2804. }
  2805. /**
  2806.  * Handle API node failure.  Called also by non-president nodes.
  2807.  * If we are president go back to INIT state, otherwise to NULL.
  2808.  * Start new thread to save time.
  2809.  */
  2810. void
  2811. Qmgr::handleArbitApiFail(Signal* signal, Uint16 nodeId)
  2812. {
  2813.   if (arbitRec.node != nodeId) {
  2814.     jam();
  2815.     return;
  2816.   }
  2817.   reportArbitEvent(signal, EventReport::ArbitState);
  2818.   arbitRec.node = 0;
  2819.   switch (arbitRec.state) {
  2820.   case ARBIT_NULL:              // should not happen
  2821.     jam();
  2822.   case ARBIT_INIT:
  2823.     jam();
  2824.   case ARBIT_FIND:
  2825.     jam();
  2826.     break;
  2827.   case ARBIT_PREP1: // start from beginning
  2828.     jam();
  2829.   case ARBIT_PREP2:
  2830.     jam();
  2831.   case ARBIT_START:
  2832.     jam();
  2833.   case ARBIT_RUN:
  2834.     if (cpresident == getOwnNodeId()) {
  2835.       jam();
  2836.       arbitRec.state = ARBIT_INIT;
  2837.       arbitRec.newstate = true;
  2838.       startArbitThread(signal);
  2839.     } else {
  2840.       jam();
  2841.       arbitRec.state = ARBIT_NULL;
  2842.     }
  2843.     break;
  2844.   case ARBIT_CHOOSE: // XXX too late
  2845.     jam();
  2846.   case ARBIT_CRASH:
  2847.     jam();
  2848.     break;
  2849.   default:
  2850.     ndbrequire(false);
  2851.     break;
  2852.   }
  2853. }
  2854. /**
  2855.  * Handle NDB node add.  Ignore if arbitration thread not yet
  2856.  * started.  If PREP is not ready, go back to INIT.  Otherwise
  2857.  * the new node gets arbitrator and ticket once we reach RUN state.
  2858.  * Start new thread to save time.
  2859.  */
  2860. void
  2861. Qmgr::handleArbitNdbAdd(Signal* signal, Uint16 nodeId)
  2862. {
  2863.   jam();
  2864.   ndbrequire(cpresident == getOwnNodeId());
  2865.   switch (arbitRec.state) {
  2866.   case ARBIT_NULL:              // before db opened
  2867.     jam();
  2868.     break;
  2869.   case ARBIT_INIT: // start from beginning
  2870.     jam();
  2871.   case ARBIT_FIND:
  2872.     jam();
  2873.   case ARBIT_PREP1:
  2874.     jam();
  2875.   case ARBIT_PREP2:
  2876.     jam();
  2877.     arbitRec.state = ARBIT_INIT;
  2878.     arbitRec.newstate = true;
  2879.     startArbitThread(signal);
  2880.     break;
  2881.   case ARBIT_START: // process in RUN state
  2882.     jam();
  2883.   case ARBIT_RUN:
  2884.     jam();
  2885.     arbitRec.newMask.set(nodeId);
  2886.     break;
  2887.   case ARBIT_CHOOSE:            // XXX too late
  2888.     jam();
  2889.   case ARBIT_CRASH:
  2890.     jam();
  2891.     break;
  2892.   default:
  2893.     ndbrequire(false);
  2894.     break;
  2895.   }
  2896. }
  2897. /**
  2898.  * Check if current nodeset can survive.  The decision is
  2899.  * based on node count, node groups, and on external arbitrator
  2900.  * (if we have one).  Always starts a new thread because
  2901.  * 1) CHOOSE cannot wait 2) if we are new president we need
  2902.  * a thread 3) if we are old president it does no harm.
  2903.  */
  2904. void
  2905. Qmgr::handleArbitCheck(Signal* signal)
  2906. {
  2907.   jam();
  2908.   ndbrequire(cpresident == getOwnNodeId());
  2909.   NodeBitmask ndbMask;
  2910.   computeArbitNdbMask(ndbMask);
  2911.   if (g_ndb_arbit_one_half_rule &&
  2912.       2 * ndbMask.count() < cnoOfNodes) {
  2913.     jam();
  2914.     arbitRec.code = ArbitCode::LoseNodes;
  2915.   } else {
  2916.     jam();
  2917.     CheckNodeGroups* sd = (CheckNodeGroups*)&signal->theData[0];
  2918.     sd->blockRef = reference();
  2919.     sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::ArbitCheck;
  2920.     sd->mask = ndbMask;
  2921.     EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal, 
  2922.    CheckNodeGroups::SignalLength);
  2923.     jamEntry();
  2924.     switch (sd->output) {
  2925.     case CheckNodeGroups::Win:
  2926.       jam();
  2927.       arbitRec.code = ArbitCode::WinGroups;
  2928.       break;
  2929.     case CheckNodeGroups::Lose:
  2930.       jam();
  2931.       arbitRec.code = ArbitCode::LoseGroups;
  2932.       break;
  2933.     case CheckNodeGroups::Partitioning:
  2934.       jam();
  2935.       arbitRec.code = ArbitCode::Partitioning;
  2936.       if (g_ndb_arbit_one_half_rule &&
  2937.           2 * ndbMask.count() > cnoOfNodes) {
  2938.         jam();
  2939.         arbitRec.code = ArbitCode::WinNodes;
  2940.       }
  2941.       break;
  2942.     default:
  2943.       ndbrequire(false);
  2944.       break;
  2945.     }
  2946.   }
  2947.   switch (arbitRec.code) {
  2948.   case ArbitCode::LoseNodes:
  2949.     jam();
  2950.   case ArbitCode::LoseGroups:
  2951.     jam();
  2952.     goto crashme;
  2953.   case ArbitCode::WinNodes:
  2954.     jam();
  2955.   case ArbitCode::WinGroups:
  2956.     jam();
  2957.     if (arbitRec.state == ARBIT_RUN) {
  2958.       jam();
  2959.       break;
  2960.     }
  2961.     arbitRec.state = ARBIT_INIT;
  2962.     arbitRec.newstate = true;
  2963.     break;
  2964.   case ArbitCode::Partitioning:
  2965.     if (arbitRec.state == ARBIT_RUN) {
  2966.       jam();
  2967.       arbitRec.state = ARBIT_CHOOSE;
  2968.       arbitRec.newstate = true;
  2969.       break;
  2970.     }
  2971.     if (arbitRec.apiMask[0].count() != 0) {
  2972.       jam();
  2973.       arbitRec.code = ArbitCode::LoseNorun;
  2974.     } else {
  2975.       jam();
  2976.       arbitRec.code = ArbitCode::LoseNocfg;
  2977.     }
  2978.     goto crashme;
  2979.   default:
  2980.   crashme:
  2981.     jam();
  2982.     arbitRec.state = ARBIT_CRASH;
  2983.     arbitRec.newstate = true;
  2984.     break;
  2985.   }
  2986.   reportArbitEvent(signal, EventReport::ArbitResult);
  2987.   switch (arbitRec.state) {
  2988.   default:
  2989.     jam();
  2990.     arbitRec.newMask.bitAND(ndbMask);   // delete failed nodes
  2991.     arbitRec.recvMask.bitAND(ndbMask);
  2992.     sendCommitFailReq(signal);          // start commit of failed nodes
  2993.     break;
  2994.   case ARBIT_CHOOSE:
  2995.     jam();
  2996.   case ARBIT_CRASH:
  2997.     jam();
  2998.     break;
  2999.   }
  3000.   startArbitThread(signal);
  3001. }
  3002. /**
  3003.  * Start a new continueB thread.  The thread id is incremented
  3004.  * so that any old thread will exit.
  3005.  */
  3006. void
  3007. Qmgr::startArbitThread(Signal* signal)
  3008. {
  3009.   jam();
  3010.   ndbrequire(cpresident == getOwnNodeId());
  3011.   arbitRec.code = ArbitCode::ThreadStart;
  3012.   reportArbitEvent(signal, EventReport::ArbitState);
  3013.   signal->theData[1] = ++arbitRec.thread;
  3014.   runArbitThread(signal);
  3015. }
  3016. /**
  3017.  * Handle arbitration thread.  The initial thread normally ends
  3018.  * up in RUN state.  New thread can be started to save time.
  3019.  */
  3020. void
  3021. Qmgr::runArbitThread(Signal* signal)
  3022. {
  3023. #ifdef DEBUG_ARBIT
  3024.   NodeBitmask ndbMask;
  3025.   computeArbitNdbMask(ndbMask);
  3026.   ndbout << "arbit thread:";
  3027.   ndbout << " state=" << arbitRec.state;
  3028.   ndbout << " newstate=" << arbitRec.newstate;
  3029.   ndbout << " thread=" << arbitRec.thread;
  3030.   ndbout << " node=" << arbitRec.node;
  3031.   ndbout << " ticket=" << arbitRec.ticket.getText();
  3032.   ndbout << " ndbmask=" << ndbMask.getText();
  3033.   ndbout << " sendcount=" << arbitRec.sendCount;
  3034.   ndbout << " recvcount=" << arbitRec.recvCount;
  3035.   ndbout << " recvmask=" << arbitRec.recvMask.getText();
  3036.   ndbout << " code=" << arbitRec.code;
  3037.   ndbout << endl;
  3038. #endif
  3039.   if (signal->theData[1] != arbitRec.thread) {
  3040.     jam();
  3041.     return;          // old thread dies
  3042.   }
  3043.   switch (arbitRec.state) {
  3044.   case ARBIT_INIT: // main thread
  3045.     jam();
  3046.     stateArbitInit(signal);
  3047.     break;
  3048.   case ARBIT_FIND:
  3049.     jam();
  3050.     stateArbitFind(signal);
  3051.     break;
  3052.   case ARBIT_PREP1:
  3053.     jam();
  3054.   case ARBIT_PREP2:
  3055.     jam();
  3056.     stateArbitPrep(signal);
  3057.     break;
  3058.   case ARBIT_START:
  3059.     jam();
  3060.     stateArbitStart(signal);
  3061.     break;
  3062.   case ARBIT_RUN:
  3063.     jam();
  3064.     stateArbitRun(signal);
  3065.     break;
  3066.   case ARBIT_CHOOSE: // partitition thread
  3067.     jam();
  3068.     stateArbitChoose(signal);
  3069.     break;
  3070.   case ARBIT_CRASH:
  3071.     jam();
  3072.     stateArbitCrash(signal);
  3073.     break;
  3074.   default:
  3075.     ndbrequire(false);
  3076.     break;
  3077.   }
  3078.   signal->theData[0] = ZARBIT_HANDLING;
  3079.   signal->theData[1] = arbitRec.thread;
  3080.   signal->theData[2] = arbitRec.state; // just for signal log
  3081.   Uint32 delay = getArbitDelay();
  3082.   if (delay == 0) {
  3083.     jam();
  3084.     sendSignal(QMGR_REF, GSN_CONTINUEB, signal, 3, JBA);
  3085.   } else if (delay == 1) {
  3086.     jam();
  3087.     sendSignal(QMGR_REF, GSN_CONTINUEB, signal, 3, JBB);
  3088.   } else {
  3089.     jam();
  3090.     sendSignalWithDelay(QMGR_REF, GSN_CONTINUEB, signal, delay, 3);
  3091.   }//if
  3092. }
  3093. /**
  3094.  * Handle INIT state.  Generate next ticket.  Switch to FIND
  3095.  * state without delay.
  3096.  */
  3097. void
  3098. Qmgr::stateArbitInit(Signal* signal)
  3099. {
  3100.   if (arbitRec.newstate) {
  3101.     jam();
  3102.     CRASH_INSERTION((Uint32)910 + arbitRec.state);
  3103.     arbitRec.node = 0;
  3104.     arbitRec.ticket.update();
  3105.     arbitRec.newMask.clear();
  3106.     arbitRec.code = 0;
  3107.     arbitRec.newstate = false;
  3108.   }
  3109.   arbitRec.state = ARBIT_FIND;
  3110.   arbitRec.newstate = true;
  3111.   stateArbitFind(signal);
  3112. }
  3113. /**
  3114.  * Handle FIND state.  Find first arbitrator which is alive
  3115.  * and invoke PREP state without delay.  If none are found,
  3116.  * loop in FIND state.  This is forever if no arbitrators
  3117.  * are configured (not the normal case).
  3118.  *
  3119.  * XXX  Add adaptive behaviour to avoid getting stuck on API
  3120.  * nodes which are alive but do not respond or die too soon.
  3121.  */
  3122. void
  3123. Qmgr::stateArbitFind(Signal* signal)
  3124. {
  3125.   if (arbitRec.newstate) {
  3126.     jam();
  3127.     CRASH_INSERTION((Uint32)910 + arbitRec.state);
  3128.     arbitRec.code = 0;
  3129.     arbitRec.newstate = false;
  3130.   }
  3131.   NodeRecPtr aPtr;
  3132.   for (unsigned rank = 1; rank <= 2; rank++) {
  3133.     jam();
  3134.     aPtr.i = 0;
  3135.     const unsigned stop = NodeBitmask::NotFound;
  3136.     while ((aPtr.i = arbitRec.apiMask[rank].find(aPtr.i + 1)) != stop) {
  3137.       jam();
  3138.       ptrAss(aPtr, nodeRec);
  3139.       if (aPtr.p->phase != ZAPI_ACTIVE)
  3140. continue;
  3141.       arbitRec.node = aPtr.i;
  3142.       arbitRec.state = ARBIT_PREP1;
  3143.       arbitRec.newstate = true;
  3144.       stateArbitPrep(signal);
  3145.       return;
  3146.     }
  3147.   }
  3148. }
  3149. /**
  3150.  * Handle PREP states.  First round nulls any existing tickets.
  3151.  * Second round sends new ticket.  When all confirms have been
  3152.  * received invoke START state immediately.
  3153.  */
  3154. void
  3155. Qmgr::stateArbitPrep(Signal* signal)
  3156. {
  3157.   if (arbitRec.newstate) {
  3158.     jam();
  3159.     CRASH_INSERTION((Uint32)910 + arbitRec.state);
  3160.     arbitRec.sendCount = 0;                     // send all at once
  3161.     computeArbitNdbMask(arbitRec.recvMask);     // to send and recv
  3162.     arbitRec.recvMask.clear(getOwnNodeId());
  3163.     arbitRec.code = 0;
  3164.     arbitRec.newstate = false;
  3165.   }
  3166.   if (! arbitRec.sendCount) {
  3167.     jam();
  3168.     NodeRecPtr aPtr;
  3169.     aPtr.i = 0;
  3170.     const unsigned stop = NodeBitmask::NotFound;
  3171.     while ((aPtr.i = arbitRec.recvMask.find(aPtr.i + 1)) != stop) {
  3172.       jam();
  3173.       ptrAss(aPtr, nodeRec);
  3174.       ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3175.       sd->sender = getOwnNodeId();
  3176.       if (arbitRec.state == ARBIT_PREP1) {
  3177.         jam();
  3178.         sd->code = ArbitCode::PrepPart1;
  3179.       } else {
  3180.         jam();
  3181.         sd->code = ArbitCode::PrepPart2;
  3182.       }
  3183.       sd->node = arbitRec.node;
  3184.       sd->ticket = arbitRec.ticket;
  3185.       sd->mask.clear();
  3186.       sendSignal(aPtr.p->blockRef, GSN_ARBIT_PREPREQ, signal,
  3187.         ArbitSignalData::SignalLength, JBB);
  3188.     }
  3189.     arbitRec.setTimestamp(); // send time
  3190.     arbitRec.sendCount = 1;
  3191.     return;
  3192.   }
  3193.   if (arbitRec.code != 0) { // error
  3194.     jam();
  3195.     arbitRec.state = ARBIT_INIT;
  3196.     arbitRec.newstate = true;
  3197.     return;
  3198.   }
  3199.   if (arbitRec.recvMask.count() == 0) { // recv all
  3200.     if (arbitRec.state == ARBIT_PREP1) {
  3201.       jam();
  3202.       arbitRec.state = ARBIT_PREP2;
  3203.       arbitRec.newstate = true;
  3204.     } else {
  3205.       jam();
  3206.       arbitRec.state = ARBIT_START;
  3207.       arbitRec.newstate = true;
  3208.       stateArbitStart(signal);
  3209.     }
  3210.     return;
  3211.   }
  3212.   if (arbitRec.getTimediff() > getArbitTimeout()) {
  3213.     jam();
  3214.     arbitRec.state = ARBIT_INIT;
  3215.     arbitRec.newstate = true;
  3216.     return;
  3217.   }
  3218. }
  3219. void
  3220. Qmgr::execARBIT_PREPREQ(Signal* signal)
  3221. {
  3222.   jamEntry();
  3223.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3224.   if (getOwnNodeId() == cpresident) {
  3225.     jam();
  3226.     return; // wrong state
  3227.   }
  3228.   if (sd->sender != cpresident) {
  3229.     jam();
  3230.     return; // wrong state
  3231.   }
  3232.   NodeRecPtr aPtr;
  3233.   aPtr.i = sd->sender;
  3234.   ptrAss(aPtr, nodeRec);
  3235.   switch (sd->code) {
  3236.   case ArbitCode::PrepPart1:    // zero them just to be sure
  3237.     jam();
  3238.     arbitRec.node = 0;
  3239.     arbitRec.ticket.clear();
  3240.     break;
  3241.   case ArbitCode::PrepPart2:    // non-president enters RUN state
  3242.     jam();
  3243.   case ArbitCode::PrepAtrun:
  3244.     jam();
  3245.     arbitRec.node = sd->node;
  3246.     arbitRec.ticket = sd->ticket;
  3247.     arbitRec.code = sd->code;
  3248.     reportArbitEvent(signal, EventReport::ArbitState);
  3249.     arbitRec.state = ARBIT_RUN;
  3250.     arbitRec.newstate = true;
  3251.     if (sd->code == ArbitCode::PrepAtrun) {
  3252.       jam();
  3253.       return;
  3254.     }
  3255.     break;
  3256.   default:
  3257.     jam();
  3258.     ndbrequire(false);
  3259.   }
  3260.   sd->sender = getOwnNodeId();
  3261.   sd->code = 0;
  3262.   sendSignal(aPtr.p->blockRef, GSN_ARBIT_PREPCONF, signal,
  3263.     ArbitSignalData::SignalLength, JBB);
  3264. }
  3265. void
  3266. Qmgr::execARBIT_PREPCONF(Signal* signal)
  3267. {
  3268.   jamEntry();
  3269.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3270.   if (! arbitRec.match(sd)) {
  3271.     jam();
  3272.     return; // stray signal
  3273.   }
  3274.   if (arbitRec.state != ARBIT_PREP1 && arbitRec.state != ARBIT_PREP2) {
  3275.     jam();
  3276.     return; // wrong state
  3277.   }
  3278.   if (! arbitRec.recvMask.get(sd->sender)) {
  3279.     jam();
  3280.     return; // wrong state
  3281.   }
  3282.   arbitRec.recvMask.clear(sd->sender);
  3283.   if (arbitRec.code == 0 && sd->code != 0) {
  3284.     jam();
  3285.     arbitRec.code = sd->code;
  3286.   }//if
  3287. }
  3288. void
  3289. Qmgr::execARBIT_PREPREF(Signal* signal)
  3290. {
  3291.   jamEntry();
  3292.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3293.   if (sd->code == 0) {
  3294.     jam();
  3295.     sd->code = ArbitCode::ErrUnknown;
  3296.   }
  3297.   execARBIT_PREPCONF(signal);
  3298. }
  3299. /**
  3300.  * Handle START state.  On first call send start request to
  3301.  * the chosen arbitrator.  Then wait for a CONF.
  3302.  */
  3303. void
  3304. Qmgr::stateArbitStart(Signal* signal)
  3305. {
  3306.   if (arbitRec.newstate) {
  3307.     jam();
  3308.     CRASH_INSERTION((Uint32)910 + arbitRec.state);
  3309.     arbitRec.sendCount = 0;
  3310.     arbitRec.recvCount = 0;
  3311.     arbitRec.code = 0;
  3312.     arbitRec.newstate = false;
  3313.   }
  3314.   if (! arbitRec.sendCount) {
  3315.     jam();
  3316.     BlockReference blockRef = calcApiClusterMgrBlockRef(arbitRec.node);
  3317.     ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3318.     sd->sender = getOwnNodeId();
  3319.     sd->code = 0;
  3320.     sd->node = arbitRec.node;
  3321.     sd->ticket = arbitRec.ticket;
  3322.     sd->mask.clear();
  3323.     sendSignal(blockRef, GSN_ARBIT_STARTREQ, signal,
  3324.       ArbitSignalData::SignalLength, JBB);
  3325.     arbitRec.sendCount = 1;
  3326.     arbitRec.setTimestamp(); // send time
  3327.     return;
  3328.   }
  3329.   if (arbitRec.recvCount) {
  3330.     jam();
  3331.     reportArbitEvent(signal, EventReport::ArbitState);
  3332.     if (arbitRec.code == ArbitCode::ApiStart) {
  3333.       jam();
  3334.       arbitRec.state = ARBIT_RUN;
  3335.       arbitRec.newstate = true;
  3336.       return;
  3337.     }
  3338.     arbitRec.state = ARBIT_INIT;
  3339.     arbitRec.newstate = true;
  3340.     return;
  3341.   }
  3342.   if (arbitRec.getTimediff() > getArbitTimeout()) {
  3343.     jam();
  3344.     arbitRec.code = ArbitCode::ErrTimeout;
  3345.     reportArbitEvent(signal, EventReport::ArbitState);
  3346.     arbitRec.state = ARBIT_INIT;
  3347.     arbitRec.newstate = true;
  3348.     return;
  3349.   }
  3350. }
  3351. void
  3352. Qmgr::execARBIT_STARTCONF(Signal* signal)
  3353. {
  3354.   jamEntry();
  3355.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3356.   if (! arbitRec.match(sd)) {
  3357.     jam();
  3358.     return; // stray signal
  3359.   }
  3360.   if (arbitRec.state != ARBIT_START) {
  3361.     jam();
  3362.     return; // wrong state
  3363.   }
  3364.   if (arbitRec.recvCount) {
  3365.     jam();
  3366.     return; // wrong state
  3367.   }
  3368.   arbitRec.code = sd->code;
  3369.   arbitRec.recvCount = 1;
  3370. }
  3371. void
  3372. Qmgr::execARBIT_STARTREF(Signal* signal)
  3373. {
  3374.   jamEntry();
  3375.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3376.   if (sd->code == 0) {
  3377.     jam();
  3378.     sd->code = ArbitCode::ErrUnknown;
  3379.   }
  3380.   execARBIT_STARTCONF(signal);
  3381. }
  3382. /**
  3383.  * Handle RUN state.  Send ticket to any new nodes which have
  3384.  * appeared after PREP state.  We don't care about a CONF.
  3385.  */
  3386. void
  3387. Qmgr::stateArbitRun(Signal* signal)
  3388. {
  3389.   if (arbitRec.newstate) {
  3390.     jam();
  3391.     CRASH_INSERTION((Uint32)910 + arbitRec.state);
  3392.     arbitRec.code = 0;
  3393.     arbitRec.newstate = false;
  3394.   }
  3395.   NodeRecPtr aPtr;
  3396.   aPtr.i = 0;
  3397.   const unsigned stop = NodeBitmask::NotFound;
  3398.   while ((aPtr.i = arbitRec.newMask.find(aPtr.i + 1)) != stop) {
  3399.     jam();
  3400.     arbitRec.newMask.clear(aPtr.i);
  3401.     ptrAss(aPtr, nodeRec);
  3402.     ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3403.     sd->sender = getOwnNodeId();
  3404.     sd->code = ArbitCode::PrepAtrun;
  3405.     sd->node = arbitRec.node;
  3406.     sd->ticket = arbitRec.ticket;
  3407.     sd->mask.clear();
  3408.     sendSignal(aPtr.p->blockRef, GSN_ARBIT_PREPREQ, signal,
  3409.       ArbitSignalData::SignalLength, JBB);
  3410.   }
  3411. }
  3412. /**
  3413.  * Handle CHOOSE state.  Entered only from RUN state when
  3414.  * there is a possible network partitioning.  Send CHOOSE to
  3415.  * the arbitrator.  On win switch to INIT state because a new
  3416.  * ticket must be created.
  3417.  */
  3418. void
  3419. Qmgr::stateArbitChoose(Signal* signal)
  3420. {
  3421.   if (arbitRec.newstate) {
  3422.     jam();
  3423.     CRASH_INSERTION((Uint32)910 + arbitRec.state);
  3424.     arbitRec.sendCount = 0;
  3425.     arbitRec.recvCount = 0;
  3426.     arbitRec.code = 0;
  3427.     arbitRec.newstate = false;
  3428.   }
  3429.   if (! arbitRec.sendCount) {
  3430.     jam();
  3431.     BlockReference blockRef = calcApiClusterMgrBlockRef(arbitRec.node);
  3432.     ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3433.     sd->sender = getOwnNodeId();
  3434.     sd->code = 0;
  3435.     sd->node = arbitRec.node;
  3436.     sd->ticket = arbitRec.ticket;
  3437.     computeArbitNdbMask(sd->mask);
  3438.     sendSignal(blockRef, GSN_ARBIT_CHOOSEREQ, signal,
  3439.       ArbitSignalData::SignalLength, JBA);
  3440.     arbitRec.sendCount = 1;
  3441.     arbitRec.setTimestamp(); // send time
  3442.     return;
  3443.   }
  3444.   if (arbitRec.recvCount) {
  3445.     jam();
  3446.     reportArbitEvent(signal, EventReport::ArbitResult);
  3447.     if (arbitRec.code == ArbitCode::WinChoose) {
  3448.       jam();
  3449.       sendCommitFailReq(signal);        // start commit of failed nodes
  3450.       arbitRec.state = ARBIT_INIT;
  3451.       arbitRec.newstate = true;
  3452.       return;
  3453.     }
  3454.     arbitRec.state = ARBIT_CRASH;
  3455.     arbitRec.newstate = true;
  3456.     stateArbitCrash(signal); // do it at once
  3457.     return;
  3458.   }
  3459.   if (arbitRec.getTimediff() > getArbitTimeout()) {
  3460.     jam();
  3461.     arbitRec.code = ArbitCode::ErrTimeout;
  3462.     reportArbitEvent(signal, EventReport::ArbitState);
  3463.     arbitRec.state = ARBIT_CRASH;
  3464.     arbitRec.newstate = true;
  3465.     stateArbitCrash(signal); // do it at once
  3466.     return;
  3467.   }
  3468. }
  3469. void
  3470. Qmgr::execARBIT_CHOOSECONF(Signal* signal)
  3471. {
  3472.   jamEntry();
  3473.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3474.   if (!arbitRec.match(sd)) {
  3475.     jam();
  3476.     return; // stray signal
  3477.   }
  3478.   if (arbitRec.state != ARBIT_CHOOSE) {
  3479.     jam();
  3480.     return; // wrong state
  3481.   }
  3482.   if (arbitRec.recvCount) {
  3483.     jam();
  3484.     return; // wrong state
  3485.   }
  3486.   arbitRec.recvCount = 1;
  3487.   arbitRec.code = sd->code;
  3488. }
  3489. void
  3490. Qmgr::execARBIT_CHOOSEREF(Signal* signal)
  3491. {
  3492.   jamEntry();
  3493.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3494.   if (sd->code == 0) {
  3495.     jam();
  3496.     sd->code = ArbitCode::ErrUnknown;
  3497.   }
  3498.   execARBIT_CHOOSECONF(signal);
  3499. }
  3500. /**
  3501.  * Handle CRASH state.  We must crash immediately.
  3502.  * XXX tell other nodes in our party to crash too.
  3503.  */
  3504. void
  3505. Qmgr::stateArbitCrash(Signal* signal)
  3506. {
  3507.   jam();
  3508.   if (arbitRec.newstate) {
  3509.     jam();
  3510.     CRASH_INSERTION((Uint32)910 + arbitRec.state);
  3511.     arbitRec.setTimestamp();
  3512.     arbitRec.code = 0;
  3513.     arbitRec.newstate = false;
  3514.   }
  3515. #ifdef ndb_arbit_crash_wait_for_event_report_to_get_out
  3516.   if (! (arbitRec.getTimediff() > getArbitTimeout()))
  3517.     return;
  3518. #endif
  3519.   progError(__LINE__, ERR_ARBIT_SHUTDOWN, "Arbitrator decided to shutdown this node");
  3520. }
  3521. /**
  3522.  * Arbitrator may inform us that it will exit.  This lets us
  3523.  * start looking sooner for a new one.  Handle it like API node
  3524.  * failure.
  3525.  */
  3526. void
  3527. Qmgr::execARBIT_STOPREP(Signal* signal)
  3528. {
  3529.   jamEntry();
  3530.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3531.   if (! arbitRec.match(sd)) {
  3532.     jam();
  3533.     return; // stray signal
  3534.   }
  3535.   arbitRec.code = ArbitCode::ApiExit;
  3536.   handleArbitApiFail(signal, arbitRec.node);
  3537. }
  3538. void
  3539. Qmgr::computeArbitNdbMask(NodeBitmask& aMask)
  3540. {
  3541.   NodeRecPtr aPtr;
  3542.   aMask.clear();
  3543.   for (aPtr.i = 1; aPtr.i < MAX_NDB_NODES; aPtr.i++) {
  3544.     jam();
  3545.     ptrAss(aPtr, nodeRec);
  3546.     if (getNodeInfo(aPtr.i).getType() == NodeInfo::DB && aPtr.p->phase == ZRUNNING){
  3547.       jam();
  3548.       aMask.set(aPtr.i);
  3549.     }
  3550.   }
  3551. }
  3552. /**
  3553.  * Report arbitration event.  We use arbitration signal format
  3554.  * where sender (word 0) is event type.
  3555.  */
  3556. void
  3557. Qmgr::reportArbitEvent(Signal* signal, EventReport::EventType type)
  3558. {
  3559.   ArbitSignalData* sd = (ArbitSignalData*)&signal->theData[0];
  3560.   sd->sender = type;
  3561.   sd->code = arbitRec.code | (arbitRec.state << 16);
  3562.   sd->node = arbitRec.node;
  3563.   sd->ticket = arbitRec.ticket;
  3564.   sd->mask.clear();
  3565.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal,
  3566.     ArbitSignalData::SignalLength, JBB);
  3567. }
  3568. // end of arbitration module
  3569. void
  3570. Qmgr::execDUMP_STATE_ORD(Signal* signal)
  3571. {
  3572.   switch (signal->theData[0]) {
  3573.   case 1:
  3574.     infoEvent("creadyDistCom = %d, cpresident = %dn",
  3575.       creadyDistCom, cpresident);
  3576.     infoEvent("cpresidentAlive = %d, cpresidentCand = %dn",
  3577.               cpresidentAlive, cpresidentCandidate);
  3578.     infoEvent("ctoStatus = %dn", ctoStatus);
  3579.     for(Uint32 i = 1; i<MAX_NDB_NODES; i++){
  3580.       if(getNodeInfo(i).getType() == NodeInfo::DB){
  3581. NodeRecPtr nodePtr;
  3582. nodePtr.i = i;
  3583. ptrCheckGuard(nodePtr, MAX_NDB_NODES, nodeRec);
  3584. char buf[100];
  3585. switch(nodePtr.p->phase){
  3586. case ZINIT:
  3587.   sprintf(buf, "Node %d: ZINIT(%d)", i, nodePtr.p->phase);
  3588.   break;
  3589. case ZSTARTING:
  3590.   sprintf(buf, "Node %d: ZSTARTING(%d)", i, nodePtr.p->phase);
  3591.   break;
  3592. case ZRUNNING:
  3593.   sprintf(buf, "Node %d: ZRUNNING(%d)", i, nodePtr.p->phase);
  3594.   break;
  3595. case ZPREPARE_FAIL:
  3596.   sprintf(buf, "Node %d: ZPREPARE_FAIL(%d)", i, nodePtr.p->phase);
  3597.   break;
  3598. case ZFAIL_CLOSING:
  3599.   sprintf(buf, "Node %d: ZFAIL_CLOSING(%d)", i, nodePtr.p->phase);
  3600.   break;
  3601. case ZAPI_INACTIVE:
  3602.   sprintf(buf, "Node %d: ZAPI_INACTIVE(%d)", i, nodePtr.p->phase);
  3603.   break;
  3604. case ZAPI_ACTIVE:
  3605.   sprintf(buf, "Node %d: ZAPI_ACTIVE(%d)", i, nodePtr.p->phase);
  3606.   break;
  3607. default:
  3608.   sprintf(buf, "Node %d: <UNKNOWN>(%d)", i, nodePtr.p->phase);
  3609.   break;
  3610. }
  3611. infoEvent(buf);
  3612.       }
  3613.     }
  3614.   default:
  3615.     ;
  3616.   }//switch
  3617. }//Qmgr::execDUMP_STATE_ORD()
  3618. void Qmgr::execSET_VAR_REQ(Signal* signal) 
  3619. {
  3620. #if 0
  3621.   SetVarReq* const setVarReq = (SetVarReq*)&signal->theData[0];
  3622.   ConfigParamId var = setVarReq->variable();
  3623.   UintR val = setVarReq->value();
  3624.   switch (var) {
  3625.   case HeartbeatIntervalDbDb:
  3626.     setHbDelay(val/10);
  3627.     sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB);
  3628.     break;
  3629.   case HeartbeatIntervalDbApi:
  3630.     setHbApiDelay(val/10);
  3631.     sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB);
  3632.     break;
  3633.   case ArbitTimeout:
  3634.     setArbitTimeout(val);
  3635.     sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB);
  3636.     break;
  3637.   default:
  3638.     sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB);
  3639.   }// switch
  3640. #endif
  3641. }//execSET_VAR_REQ()
  3642. void
  3643. Qmgr::execAPI_BROADCAST_REP(Signal* signal)
  3644. {
  3645.   jamEntry();
  3646.   ApiBroadcastRep api= *(const ApiBroadcastRep*)signal->getDataPtr();
  3647.   Uint32 len = signal->getLength() - ApiBroadcastRep::SignalLength;
  3648.   memmove(signal->theData, signal->theData+ApiBroadcastRep::SignalLength, 
  3649.   4*len);
  3650.   
  3651.   NodeBitmask mask;
  3652.   NodeRecPtr nodePtr;
  3653.   for (nodePtr.i = 1; nodePtr.i < MAX_NODES; nodePtr.i++) 
  3654.   {
  3655.     jam();
  3656.     ptrAss(nodePtr, nodeRec);
  3657.     if (nodePtr.p->phase == ZAPI_ACTIVE && 
  3658. getNodeInfo(nodePtr.i).m_version >= api.minVersion)
  3659.     {
  3660.       mask.set(nodePtr.i);
  3661.     }
  3662.   }
  3663.   
  3664.   NodeReceiverGroup rg(API_CLUSTERMGR, mask);
  3665.   sendSignal(rg, api.gsn, signal, len, JBB); // forward sections
  3666. }