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

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

MySQL数据库

开发平台：

Visual C++

Ndbif.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. #include <ndb_global.h>
  20. #include "NdbApiSignal.hpp"
  21. #include "NdbImpl.hpp"
  22. #include "NdbOperation.hpp"
  23. #include "NdbIndexOperation.hpp"
  24. #include "NdbScanOperation.hpp"
  25. #include "NdbConnection.hpp"
  26. #include "NdbRecAttr.hpp"
  27. #include "NdbReceiver.hpp"
  28. #include "API.hpp"
  30. #include <signaldata/TcCommit.hpp>
  31. #include <signaldata/TcKeyFailConf.hpp>
  32. #include <signaldata/TcKeyConf.hpp>
  33. #include <signaldata/TestOrd.hpp>
  34. #include <signaldata/CreateIndx.hpp>
  35. #include <signaldata/DropIndx.hpp>
  36. #include <signaldata/TcIndx.hpp>
  37. #include <signaldata/TransIdAI.hpp>
  38. #include <signaldata/ScanFrag.hpp>
  39. #include <signaldata/ScanTab.hpp>
  41. #include <ndb_limits.h>
  42. #include <NdbOut.hpp>
  43. #include <NdbTick.h>
  46. /******************************************************************************
  47.  * int init( int aNrOfCon, int aNrOfOp );
  48.  *
  49.  * Return Value:   Return 0 : init was successful.
  50.  *                Return -1: In all other case.  
  51.  * Parameters: aNrOfCon : Number of connections offered to the application.
  52.  * aNrOfOp : Number of operations offered to the application.
  53.  * Remark: Create pointers and idle list Synchronous.
  54.  ****************************************************************************/ 
  55. int
  56. Ndb::init(int aMaxNoOfTransactions)
  57. {
  58.   DBUG_ENTER("Ndb::init");
  60.   int i;
  61.   int aNrOfCon;
  62.   int aNrOfOp;
  63.   int tMaxNoOfTransactions;
  64.   NdbApiSignal* tSignal[16]; // Initiate free list of 16 signal objects
  65.   if (theInitState != NotInitialised) {
  66.     switch(theInitState){
  67.     case InitConfigError:
  68.       theError.code = 4117;
  69.       break;
  70.     default:
  71.       theError.code = 4104;
  72.       break;
  73.     }
  74.     DBUG_RETURN(-1);
  75.   }//if
  76.   theInitState = StartingInit;
  77.   TransporterFacade * theFacade =  TransporterFacade::instance();
  78.   theFacade->lock_mutex();
  79.   
  80.   const int tBlockNo = theFacade->open(this,
  81.                                        executeMessage, 
  82.                                        statusMessage);  
  83.   if ( tBlockNo == -1 ) {
  84.     theError.code = 4105;
  85.     theFacade->unlock_mutex();
  86.     DBUG_RETURN(-1); // no more free blocknumbers
  87.   }//if
  88.   
  89.   theNdbBlockNumber = tBlockNo;
  91.   theFacade->unlock_mutex();
  92.   
  93.   theDictionary->setTransporter(this, theFacade);
  94.   
  95.   aNrOfCon = theImpl->theNoOfDBnodes;
  96.   aNrOfOp = 2*theImpl->theNoOfDBnodes;
  97.   
  98.   // Create connection object in a linked list 
  99.   if((createConIdleList(aNrOfCon)) == -1){
  100.     theError.code = 4000;
  101.     goto error_handler;
  102.   }
  103.   
  104.   // Create operations in a linked list
  105.   if((createOpIdleList(aNrOfOp)) == -1){       
  106.     theError.code = 4000;
  107.     goto error_handler;
  108.   }
  109.   
  110.   tMaxNoOfTransactions = aMaxNoOfTransactions * 3;
  111.   if (tMaxNoOfTransactions > 1024) {
  112.     tMaxNoOfTransactions = 1024;
  113.   }//if
  114.   theMaxNoOfTransactions = tMaxNoOfTransactions;
  115.   
  116.   thePreparedTransactionsArray = new NdbConnection* [tMaxNoOfTransactions];
  117.   theSentTransactionsArray = new NdbConnection* [tMaxNoOfTransactions];
  118.   theCompletedTransactionsArray = new NdbConnection* [tMaxNoOfTransactions];
  119.   
  120.   if ((thePreparedTransactionsArray == NULL) ||
  121.       (theSentTransactionsArray == NULL) ||
  122.       (theCompletedTransactionsArray == NULL)) {
  123.     goto error_handler;
  124.   }//if
  125.   
  126.   for (i = 0; i < tMaxNoOfTransactions; i++) {
  127.     thePreparedTransactionsArray[i] = NULL;
  128.     theSentTransactionsArray[i] = NULL;
  129.     theCompletedTransactionsArray[i] = NULL;
  130.   }//for     
  131.   for (i = 0; i < 16; i++){
  132.     tSignal[i] = getSignal();
  133.     if(tSignal[i] == NULL) {
  134.       theError.code = 4000;
  135.       goto error_handler;
  136.     }
  137.   }
  138.   for (i = 0; i < 16; i++)
  139.     releaseSignal(tSignal[i]);
  140.   theInitState = Initialised; 
  141.   DBUG_RETURN(0);
  142.   
  143. error_handler:
  144.   ndbout << "error_handler" << endl;
  145.   releaseTransactionArrays();
  146.   delete theDictionary;
  147.   TransporterFacade::instance()->close(theNdbBlockNumber, 0);
  148.   DBUG_RETURN(-1);
  149. }
  151. void
  152. Ndb::releaseTransactionArrays()
  153. {
  154.   DBUG_ENTER("Ndb::releaseTransactionArrays");
  155.   if (thePreparedTransactionsArray != NULL) {
  156.     delete [] thePreparedTransactionsArray;
  157.   }//if
  158.   if (theSentTransactionsArray != NULL) {
  159.     delete [] theSentTransactionsArray;
  160.   }//if
  161.   if (theCompletedTransactionsArray != NULL) {
  162.     delete [] theCompletedTransactionsArray;
  163.   }//if
  164.   DBUG_VOID_RETURN;
  165. }//Ndb::releaseTransactionArrays()
  167. void
  168. Ndb::executeMessage(void* NdbObject,
  169.                     NdbApiSignal * aSignal,
  170.                     LinearSectionPtr ptr[3])
  171. {
  172.   Ndb* tNdb = (Ndb*)NdbObject;
  173.   tNdb->handleReceivedSignal(aSignal, ptr);
  174. }
  176. void Ndb::connected(Uint32 ref)
  177. {
  178.   theMyRef= ref;
  179.   Uint32 tmpTheNode= refToNode(ref);
  180.   Uint64 tBlockNo= refToBlock(ref);
  181.   if (theNdbBlockNumber >= 0){
  182.     assert(theMyRef == numberToRef(theNdbBlockNumber, tmpTheNode));
  183.   }
  184.   
  185.   TransporterFacade * theFacade =  TransporterFacade::instance();
  186.   int i, n= 0;
  187.   for (i = 1; i < MAX_NDB_NODES; i++){
  188.     if (theFacade->getIsDbNode(i)){
  189.       theImpl->theDBnodes[n] = i;
  190.       n++;
  191.     }
  192.   }
  193.   theImpl->theNoOfDBnodes= n;
  194.   theFirstTransId = ((Uint64)tBlockNo << 52)+
  195.     ((Uint64)tmpTheNode << 40);
  196.   theFirstTransId += theFacade->m_max_trans_id;
  197.   //      assert(0);
  198.   DBUG_PRINT("info",("connected with ref=%x, id=%d, no_db_nodes=%d, first_trans_id=%lx",
  199.      theMyRef,
  200.      tmpTheNode,
  201.      theImpl->theNoOfDBnodes,
  202.      theFirstTransId));
  203.   theCommitAckSignal = new NdbApiSignal(theMyRef);
  205.   theDictionary->m_receiver.m_reference= theMyRef;
  206.   theNode= tmpTheNode; // flag that Ndb object is initialized
  207. }
  209. void
  210. Ndb::statusMessage(void* NdbObject, Uint32 a_node, bool alive, bool nfComplete)
  211. {
  212.   DBUG_ENTER("Ndb::statusMessage");
  213.   Ndb* tNdb = (Ndb*)NdbObject;
  214.   if (alive) {
  215.     if (nfComplete) {
  216.       tNdb->connected(a_node);
  217.       DBUG_VOID_RETURN;
  218.     }//if
  219.   } else {
  220.     if (nfComplete) {
  221.       tNdb->report_node_failure_completed(a_node);
  222.     } else {
  223.       tNdb->report_node_failure(a_node);
  224.     }//if
  225.   }//if
  226.   NdbDictInterface::execNodeStatus(&tNdb->theDictionary->m_receiver,
  227.    a_node, alive, nfComplete);
  228.   DBUG_VOID_RETURN;
  229. }
  231. void
  232. Ndb::report_node_failure(Uint32 node_id)
  233. {
  234.   /**
  235.    * We can only set the state here since this object can execute 
  236.    * simultaneously. 
  237.    * 
  238.    * This method is only called by ClusterMgr (via lots of methods)
  239.    */
  240.   theImpl->the_release_ind[node_id] = 1;
  241.   // must come after
  242.   theImpl->the_release_ind[0] = 1;
  243.   theImpl->theWaiter.nodeFail(node_id);
  244.   return;
  245. }//Ndb::report_node_failure()
  248. void
  249. Ndb::report_node_failure_completed(Uint32 node_id)
  250. {
  251.   abortTransactionsAfterNodeFailure(node_id);
  253. }//Ndb::report_node_failure_completed()
  255. /***************************************************************************
  256. void abortTransactionsAfterNodeFailure();
  258. Remark:   Abort all transactions in theSentTransactionsArray after connection 
  259.           to one node has failed
  260. ****************************************************************************/
  261. void
  262. Ndb::abortTransactionsAfterNodeFailure(Uint16 aNodeId)
  263. {  
  264.   Uint32 tNoSentTransactions = theNoOfSentTransactions;
  265.   for (int i = tNoSentTransactions - 1; i >= 0; i--) {
  266.     NdbConnection* localCon = theSentTransactionsArray[i];
  267.     if (localCon->getConnectedNodeId() == aNodeId) {
  268.       const NdbConnection::SendStatusType sendStatus = localCon->theSendStatus;
  269.       if (sendStatus == NdbConnection::sendTC_OP || 
  270.   sendStatus == NdbConnection::sendTC_COMMIT) {
  271.         /*
  272.         A transaction was interrupted in the prepare phase by a node
  273.         failure. Since the transaction was not found in the phase
  274.         after the node failure it cannot have been committed and
  275.         we report a normal node failure abort.
  276.         */
  277. localCon->setOperationErrorCodeAbort(4010);
  278.         localCon->theCompletionStatus = NdbConnection::CompletedFailure;
  279.       } else if (sendStatus == NdbConnection::sendTC_ROLLBACK) {
  280.         /*
  281.         We aimed for abort and abort we got even if it was by a node
  282.         failure. We will thus report it as a success.
  283.         */
  284.         localCon->theCompletionStatus = NdbConnection::CompletedSuccess;
  285.       } else {
  286. #ifdef VM_TRACE
  287.         printState("abortTransactionsAfterNodeFailure %x", this);
  288.         abort();
  289. #endif
  290.       }
  291.       /*
  292.       All transactions arriving here have no connection to the kernel
  293.       intact since the node was failing and they were aborted. Thus we
  294.       set commit state to Aborted and set state to release on close.
  295.       */
  296.       localCon->theCommitStatus = NdbConnection::Aborted;
  297.       localCon->theReleaseOnClose = true;
  298.       completedTransaction(localCon);
  299.     }
  300.     else if(localCon->report_node_failure(aNodeId))
  301.     {
  302.       completedTransaction(localCon);
  303.     }
  304.   }//for
  305.   return;
  306. }//Ndb::abortTransactionsAfterNodeFailure()
  308. /****************************************************************************
  309. void handleReceivedSignal(NdbApiSignal* aSignal);
  311. Parameters:     aSignal: The signal object.
  312. Remark:         Send all operations belonging to this connection. 
  313. *****************************************************************************/
  314. void
  315. Ndb::handleReceivedSignal(NdbApiSignal* aSignal, LinearSectionPtr ptr[3])
  316. {
  317.   NdbOperation* tOp;
  318.   NdbIndexOperation* tIndexOp;
  319.   NdbConnection* tCon;
  320.   int tReturnCode = -1;
  321.   const Uint32* tDataPtr = aSignal->getDataPtr();
  322.   const Uint32 tWaitState = theImpl->theWaiter.m_state;
  323.   const Uint32 tSignalNumber = aSignal->readSignalNumber();
  324.   const Uint32 tFirstData = *tDataPtr;
  325.   const Uint32 tLen = aSignal->getLength();
  326.   void * tFirstDataPtr;
  328.   /*
  329.     In order to support 64 bit processes in the application we need to use
  330.     id's rather than a direct pointer to the object used. It is also a good
  331.     idea that one cannot corrupt the application code by sending a corrupt
  332.     memory pointer.
  333.     
  334.     All signals received by the API requires the first data word to be such
  335.     an id to the receiving object.
  336.   */
  337.   
  338.   switch (tSignalNumber){
  339.   case GSN_TCKEYCONF:
  340.     {
  341.       tFirstDataPtr = int2void(tFirstData);
  342.       if (tFirstDataPtr == 0) goto InvalidSignal;
  344.       const TcKeyConf * const keyConf = (TcKeyConf *)tDataPtr;
  345.       const BlockReference aTCRef = aSignal->theSendersBlockRef;
  347.       tCon = void2con(tFirstDataPtr);
  348.       if ((tCon->checkMagicNumber() == 0) &&
  349.           (tCon->theSendStatus == NdbConnection::sendTC_OP)) {
  350.         tReturnCode = tCon->receiveTCKEYCONF(keyConf, tLen);
  351.         if (tReturnCode != -1) {
  352.           completedTransaction(tCon);
  353.         }//if
  355. if(TcKeyConf::getMarkerFlag(keyConf->confInfo)){
  356.   NdbConnection::sendTC_COMMIT_ACK(theCommitAckSignal,
  357.    keyConf->transId1, 
  358.    keyConf->transId2,
  359.    aTCRef);
  360. }
  361.       
  362. return;
  363.       }//if
  364.       goto InvalidSignal;
  365.       
  366.       return;
  367.     }
  368.   case GSN_TRANSID_AI:{
  369.     tFirstDataPtr = int2void(tFirstData);
  370.     NdbReceiver* tRec;
  371.     if (tFirstDataPtr && (tRec = void2rec(tFirstDataPtr)) && 
  372. tRec->checkMagicNumber() && (tCon = tRec->getTransaction()) &&
  373. tCon->checkState_TransId(((const TransIdAI*)tDataPtr)->transId)){
  374.       Uint32 com;
  375.       if(aSignal->m_noOfSections > 0){
  376. com = tRec->execTRANSID_AI(ptr[0].p, ptr[0].sz);
  377.       } else {
  378. com = tRec->execTRANSID_AI(tDataPtr + TransIdAI::HeaderLength, 
  379.    tLen - TransIdAI::HeaderLength);
  380.       }
  381.       
  382.       if(com == 1){
  383. switch(tRec->getType()){
  384. case NdbReceiver::NDB_OPERATION:
  385. case NdbReceiver::NDB_INDEX_OPERATION:
  386.   if(tCon->OpCompleteSuccess() != -1){
  387.     completedTransaction(tCon);
  388.     return;
  389.   }
  390.   break;
  391. case NdbReceiver::NDB_SCANRECEIVER:
  392.   tCon->theScanningOp->receiver_delivered(tRec);
  393.   theImpl->theWaiter.m_state = (((WaitSignalType) tWaitState) == WAIT_SCAN ? 
  394.        (Uint32) NO_WAIT : tWaitState);
  395.   break;
  396. default:
  397.   goto InvalidSignal;
  398. }
  399.       }
  400.       break;
  401.     } else {
  402.       /**
  403.        * This is ok as transaction can have been aborted before TRANSID_AI
  404.        * arrives (if TUP on  other node than TC)
  405.        */
  406.       return;
  407.     }
  408.   }
  409.   case GSN_TCKEY_FAILCONF:
  410.     {
  411.       tFirstDataPtr = int2void(tFirstData);
  412.       const TcKeyFailConf * failConf = (TcKeyFailConf *)tDataPtr;
  413.       const BlockReference aTCRef = aSignal->theSendersBlockRef;
  414.       if (tFirstDataPtr != 0){
  415. tOp = void2rec_op(tFirstDataPtr);
  417. if (tOp->checkMagicNumber(false) == 0) {
  418.   tCon = tOp->theNdbCon;
  419.   if (tCon != NULL) {
  420.     if ((tCon->theSendStatus == NdbConnection::sendTC_OP) ||
  421. (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
  422.       tReturnCode = tCon->receiveTCKEY_FAILCONF(failConf);
  423.       if (tReturnCode != -1) {
  424. completedTransaction(tCon);
  425.       }//if
  426.     }//if
  427.   }
  428. }
  429.       } else {
  430. #ifdef VM_TRACE
  431. ndbout_c("Recevied TCKEY_FAILCONF wo/ operation");
  432. #endif
  433.       }
  434.       if(tFirstData & 1){
  435. NdbConnection::sendTC_COMMIT_ACK(theCommitAckSignal,
  436.  failConf->transId1, 
  437.  failConf->transId2,
  438.  aTCRef);
  439.       }
  440.       return;
  441.     }
  442.   case GSN_TCKEY_FAILREF:
  443.     {
  444.       tFirstDataPtr = int2void(tFirstData);
  445.       if(tFirstDataPtr != 0){
  446. tOp = void2rec_op(tFirstDataPtr);
  447. if (tOp->checkMagicNumber(false) == 0) {
  448.   tCon = tOp->theNdbCon;
  449.   if (tCon != NULL) {
  450.     if ((tCon->theSendStatus == NdbConnection::sendTC_OP) ||
  451. (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
  452.       tReturnCode = tCon->receiveTCKEY_FAILREF(aSignal);
  453.       if (tReturnCode != -1) {
  454. completedTransaction(tCon);
  455. return;
  456.       }//if
  457.     }//if
  458.   }//if
  459. }//if
  460.       }
  461. #ifdef VM_TRACE
  462.       ndbout_c("Recevied TCKEY_FAILREF wo/ operation");
  463. #endif
  464.       return;
  465.       break;
  466.     }
  467.   case GSN_TCKEYREF:
  468.     {
  469.       tFirstDataPtr = int2void(tFirstData);
  470.       if (tFirstDataPtr == 0) goto InvalidSignal;
  472.       tOp = void2rec_op(tFirstDataPtr);
  473.       if (tOp->checkMagicNumber() == 0) {
  474. tCon = tOp->theNdbCon;
  475. if (tCon != NULL) {
  476.   if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
  477.     tReturnCode = tOp->receiveTCKEYREF(aSignal);
  478.     if (tReturnCode != -1) {
  479.       completedTransaction(tCon);
  480.       return;
  481.     }//if
  482.     break;
  483.   }//if
  484. }//if
  485.       } //if
  486.       goto InvalidSignal;
  487.       return;
  488.     } 
  489.   case GSN_TC_COMMITCONF:
  490.     {
  491.       tFirstDataPtr = int2void(tFirstData);
  492.       if (tFirstDataPtr == 0) goto InvalidSignal;
  494.       const TcCommitConf * const commitConf = (TcCommitConf *)tDataPtr;
  495.       const BlockReference aTCRef = aSignal->theSendersBlockRef;
  496.       
  497.       tCon = void2con(tFirstDataPtr);
  498.       if ((tCon->checkMagicNumber() == 0) &&
  499.   (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
  500. tReturnCode = tCon->receiveTC_COMMITCONF(commitConf);
  501. if (tReturnCode != -1) {
  502.   completedTransaction(tCon);
  503. }//if
  505. if(tFirstData & 1){
  506.   NdbConnection::sendTC_COMMIT_ACK(theCommitAckSignal,
  507.    commitConf->transId1, 
  508.    commitConf->transId2,
  509.    aTCRef);
  510. }
  511. return;
  512.       }
  513.       goto InvalidSignal;
  514.       return;
  515.     }
  517.   case GSN_TC_COMMITREF:
  518.     {
  519.       tFirstDataPtr = int2void(tFirstData);
  520.       if (tFirstDataPtr == 0) goto InvalidSignal;
  522.       tCon = void2con(tFirstDataPtr);
  523.       if ((tCon->checkMagicNumber() == 0) &&
  524.   (tCon->theSendStatus == NdbConnection::sendTC_COMMIT)) {
  525. tReturnCode = tCon->receiveTC_COMMITREF(aSignal);
  526. if (tReturnCode != -1) {
  527.   completedTransaction(tCon);
  528. }//if
  529.       }//if
  530.       return;
  531.     }
  532.   case GSN_TCROLLBACKCONF:
  533.     {
  534.       tFirstDataPtr = int2void(tFirstData);
  535.       if (tFirstDataPtr == 0) goto InvalidSignal;
  537.       tCon = void2con(tFirstDataPtr);
  538.       if ((tCon->checkMagicNumber() == 0) &&
  539.   (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
  540. tReturnCode = tCon->receiveTCROLLBACKCONF(aSignal);
  541. if (tReturnCode != -1) {
  542.   completedTransaction(tCon);
  543. }//if
  544.       }//if
  545.       return;
  546.     }
  547.   case GSN_TCROLLBACKREF:
  548.     {
  549.       tFirstDataPtr = int2void(tFirstData);
  550.       if (tFirstDataPtr == 0) goto InvalidSignal;
  552.       tCon = void2con(tFirstDataPtr);
  553.       if ((tCon->checkMagicNumber() == 0) &&
  554.   (tCon->theSendStatus == NdbConnection::sendTC_ROLLBACK)) {
  555. tReturnCode = tCon->receiveTCROLLBACKREF(aSignal);
  556. if (tReturnCode != -1) {
  557.   completedTransaction(tCon);
  558. }//if
  559.       }//if
  560.       return;
  561.     }
  562.   case GSN_TCROLLBACKREP:
  563.     {
  564.       tFirstDataPtr = int2void(tFirstData);
  565.       if (tFirstDataPtr == 0) goto InvalidSignal;
  567.       tCon = void2con(tFirstDataPtr);
  568.       if (tCon->checkMagicNumber() == 0) {
  569. tReturnCode = tCon->receiveTCROLLBACKREP(aSignal);
  570. if (tReturnCode != -1) {
  571.   completedTransaction(tCon);
  572. }//if
  573.       }//if
  574.       return;
  575.     }
  576.   case GSN_TCSEIZECONF:
  577.     {
  578.       tFirstDataPtr = int2void(tFirstData);
  579.       if (tFirstDataPtr == 0) goto InvalidSignal;
  581.       if (tWaitState != WAIT_TC_SEIZE) {
  582. goto InvalidSignal;
  583.       }//if
  584.       tCon = void2con(tFirstDataPtr);
  585.       if (tCon->checkMagicNumber() != 0) {
  586. goto InvalidSignal;
  587.       }//if
  588.       tReturnCode = tCon->receiveTCSEIZECONF(aSignal);
  589.       if (tReturnCode != -1) {
  590. theImpl->theWaiter.m_state = NO_WAIT;
  591.       } else {
  592. goto InvalidSignal;
  593.       }//if
  594.       break;
  595.     }
  596.   case GSN_TCSEIZEREF:
  597.     {
  598.       tFirstDataPtr = int2void(tFirstData);
  599.       if (tFirstDataPtr == 0) goto InvalidSignal;
  601.       if (tWaitState != WAIT_TC_SEIZE) {
  602. return;
  603.       }//if
  604.       tCon = void2con(tFirstDataPtr);
  605.       if (tCon->checkMagicNumber() != 0) {
  606. return;
  607.       }//if
  608.       tReturnCode = tCon->receiveTCSEIZEREF(aSignal);
  609.       if (tReturnCode != -1) {
  610. theImpl->theWaiter.m_state = NO_WAIT;
  611.       } else {
  612.         return;
  613.       }//if
  614.       break;
  615.     }
  616.   case GSN_TCRELEASECONF:
  617.     {
  618.       tFirstDataPtr = int2void(tFirstData);
  619.       if (tFirstDataPtr == 0) goto InvalidSignal;
  621.       if (tWaitState != WAIT_TC_RELEASE) {
  622. goto InvalidSignal;
  623.       }//if
  624.       tCon = void2con(tFirstDataPtr);
  625.       if (tCon->checkMagicNumber() != 0) {
  626. goto InvalidSignal;
  627.       }//if
  628.       tReturnCode = tCon->receiveTCRELEASECONF(aSignal);
  629.       if (tReturnCode != -1) {
  630. theImpl->theWaiter.m_state = NO_WAIT;
  631.       }//if
  632.       break;
  633.     } 
  634.   case GSN_TCRELEASEREF:
  635.     {
  636.       tFirstDataPtr = int2void(tFirstData);
  637.       if (tFirstDataPtr == 0) goto InvalidSignal;
  639.       if (tWaitState != WAIT_TC_RELEASE) {
  640. goto InvalidSignal;
  641.       }//if
  642.       tCon = void2con(tFirstDataPtr);
  643.       if (tCon->checkMagicNumber() != 0) {
  644. goto InvalidSignal;
  645.       }//if
  646.       tReturnCode = tCon->receiveTCRELEASEREF(aSignal);
  647.       if (tReturnCode != -1) {
  648. theImpl->theWaiter.m_state = NO_WAIT;
  649.       }//if
  650.       break;
  651.     }
  652.       
  653.   case GSN_GET_TABINFOREF:
  654.   case GSN_GET_TABINFO_CONF:
  655.   case GSN_CREATE_TABLE_REF:
  656.   case GSN_CREATE_TABLE_CONF:
  657.   case GSN_DROP_TABLE_CONF:
  658.   case GSN_DROP_TABLE_REF:
  659.   case GSN_ALTER_TABLE_CONF:
  660.   case GSN_ALTER_TABLE_REF:
  661.   case GSN_CREATE_INDX_CONF:
  662.   case GSN_CREATE_INDX_REF:
  663.   case GSN_DROP_INDX_CONF:
  664.   case GSN_DROP_INDX_REF:
  665.   case GSN_CREATE_EVNT_CONF:
  666.   case GSN_CREATE_EVNT_REF:
  667.   case GSN_DROP_EVNT_CONF:
  668.   case GSN_DROP_EVNT_REF:
  669.   case GSN_LIST_TABLES_CONF:
  670.     NdbDictInterface::execSignal(&theDictionary->m_receiver,
  671.  aSignal, ptr);
  672.     break;
  673.     
  674.   case GSN_SUB_META_DATA:
  675.   case GSN_SUB_REMOVE_CONF:
  676.   case GSN_SUB_REMOVE_REF:
  677.     break; // ignore these signals
  678.   case GSN_SUB_GCP_COMPLETE_REP:
  679.   case GSN_SUB_START_CONF:
  680.   case GSN_SUB_START_REF:
  681.   case GSN_SUB_TABLE_DATA:
  682.   case GSN_SUB_STOP_CONF:
  683.   case GSN_SUB_STOP_REF:
  684.     NdbDictInterface::execSignal(&theDictionary->m_receiver,
  685.  aSignal, ptr);
  686.     break;
  688.   case GSN_DIHNDBTAMPER:
  689.     {
  690.       tFirstDataPtr = int2void(tFirstData);
  691.       if (tFirstDataPtr == 0) goto InvalidSignal;
  692.       
  693.       if (tWaitState != WAIT_NDB_TAMPER)
  694. return;
  695.       tCon = void2con(tFirstDataPtr);
  696.       if (tCon->checkMagicNumber() != 0)
  697. return;
  698.       tReturnCode = tCon->receiveDIHNDBTAMPER(aSignal);
  699.       if (tReturnCode != -1)
  700. theImpl->theWaiter.m_state = NO_WAIT;
  701.       break;
  702.     }
  703.   case GSN_SCAN_TABCONF:
  704.     {
  705.       tFirstDataPtr = int2void(tFirstData);
  706.       assert(tFirstDataPtr);
  707.       assert(void2con(tFirstDataPtr));
  708.       assert(void2con(tFirstDataPtr)->checkMagicNumber() == 0);
  709.       if(tFirstDataPtr && 
  710.  (tCon = void2con(tFirstDataPtr)) && (tCon->checkMagicNumber() == 0)){
  712. if(aSignal->m_noOfSections > 0){
  713.   tReturnCode = tCon->receiveSCAN_TABCONF(aSignal, 
  714.   ptr[0].p, ptr[0].sz);
  715. } else {
  716.   tReturnCode = 
  717.     tCon->receiveSCAN_TABCONF(aSignal, 
  718.       tDataPtr + ScanTabConf::SignalLength, 
  719.       tLen - ScanTabConf::SignalLength);
  720. }
  721. if (tReturnCode != -1 && tWaitState == WAIT_SCAN)
  722.   theImpl->theWaiter.m_state = NO_WAIT;
  723. break;
  724.       } else {
  725. goto InvalidSignal;
  726.       }
  727.     }
  728.   case GSN_SCAN_TABREF:
  729.     {
  730.       tFirstDataPtr = int2void(tFirstData);
  731.       if (tFirstDataPtr == 0) goto InvalidSignal;
  732.       
  733.       tCon = void2con(tFirstDataPtr);
  734.       
  735.       assert(tFirstDataPtr != 0 && 
  736.      void2con(tFirstDataPtr)->checkMagicNumber() == 0);
  737.       
  738.       if (tCon->checkMagicNumber() == 0){
  739. tReturnCode = tCon->receiveSCAN_TABREF(aSignal);
  740. if (tReturnCode != -1 && tWaitState == WAIT_SCAN){
  741.   theImpl->theWaiter.m_state = NO_WAIT;
  742. }
  743. break;
  744.       }
  745.       goto InvalidSignal;
  746.     }
  747.   case GSN_KEYINFO20: {
  748.     tFirstDataPtr = int2void(tFirstData);
  749.     NdbReceiver* tRec;
  750.     if (tFirstDataPtr && (tRec = void2rec(tFirstDataPtr)) &&
  751. tRec->checkMagicNumber() && (tCon = tRec->getTransaction()) &&
  752. tCon->checkState_TransId(&((const KeyInfo20*)tDataPtr)->transId1)){
  753.       
  754.       Uint32 len = ((const KeyInfo20*)tDataPtr)->keyLen;
  755.       Uint32 info = ((const KeyInfo20*)tDataPtr)->scanInfo_Node;
  756.       int com = -1;
  757.       if(aSignal->m_noOfSections > 0 && len == ptr[0].sz){
  758. com = tRec->execKEYINFO20(info, ptr[0].p, len);
  759.       } else if(len == tLen - KeyInfo20::HeaderLength){
  760. com = tRec->execKEYINFO20(info, tDataPtr+KeyInfo20::HeaderLength, len);
  761.       }
  762.       
  763.       switch(com){
  764.       case 1:
  765. tCon->theScanningOp->receiver_delivered(tRec);
  766. theImpl->theWaiter.m_state = (((WaitSignalType) tWaitState) == WAIT_SCAN ? 
  767.       (Uint32) NO_WAIT : tWaitState);
  768. break;
  769.       case 0:
  770. break;
  771.       case -1:
  772. goto InvalidSignal;
  773.       }
  774.       break;
  775.     } else {
  776.       /**
  777.        * This is ok as transaction can have been aborted before KEYINFO20
  778.        * arrives (if TUP on  other node than TC)
  779.        */
  780.       return;
  781.     }
  782.   }
  783.   case GSN_TCINDXCONF:{
  784.     tFirstDataPtr = int2void(tFirstData);
  785.     if (tFirstDataPtr == 0) goto InvalidSignal;
  787.     const TcIndxConf * const indxConf = (TcIndxConf *)tDataPtr;
  788.     const BlockReference aTCRef = aSignal->theSendersBlockRef;
  789.     tCon = void2con(tFirstDataPtr);
  790.     if ((tCon->checkMagicNumber() == 0) &&
  791. (tCon->theSendStatus == NdbConnection::sendTC_OP)) {
  792.       tReturnCode = tCon->receiveTCINDXCONF(indxConf, tLen);
  793.       if (tReturnCode != -1) { 
  794. completedTransaction(tCon);
  795.       }//if
  796.     }//if
  797.     
  798.     if(TcIndxConf::getMarkerFlag(indxConf->confInfo)){
  799.       NdbConnection::sendTC_COMMIT_ACK(theCommitAckSignal,
  800.        indxConf->transId1, 
  801.        indxConf->transId2,
  802.        aTCRef);
  803.     }
  804.     return;
  805.   }
  806.   case GSN_TCINDXREF:{
  807.     tFirstDataPtr = int2void(tFirstData);
  808.     if (tFirstDataPtr == 0) goto InvalidSignal;
  810.     tIndexOp = void2rec_iop(tFirstDataPtr);
  811.     if (tIndexOp->checkMagicNumber() == 0) {
  812.       tCon = tIndexOp->theNdbCon;
  813.       if (tCon != NULL) {
  814. if (tCon->theSendStatus == NdbConnection::sendTC_OP) {
  815.   tReturnCode = tIndexOp->receiveTCINDXREF(aSignal);
  816.   if (tReturnCode != -1) {
  817.     completedTransaction(tCon);
  818.   }//if
  819.   return;
  820. }//if
  821.       }//if
  822.     }//if
  823.     goto InvalidSignal;
  824.     return;
  825.   } 
  826.   default:
  827.     goto InvalidSignal;
  828.   }//switch
  829.   
  830.   if (theImpl->theWaiter.m_state == NO_WAIT) {
  831.     // Wake up the thread waiting for response
  832.     NdbCondition_Signal(theImpl->theWaiter.m_condition);
  833.   }//if
  834.   return;
  836.  InvalidSignal:
  837. #ifdef VM_TRACE
  838.   ndbout_c("Ndbif: Error Ndb::handleReceivedSignal "
  839.    "(GSN=%d, theImpl->theWaiter.m_state=%d)"
  840.    " sender = (Block: %d Node: %d)",
  841.    tSignalNumber,
  842.    tWaitState,
  843.    refToBlock(aSignal->theSendersBlockRef),
  844.    refToNode(aSignal->theSendersBlockRef));
  845. #endif
  846. #ifdef NDB_NO_DROPPED_SIGNAL
  847.   abort();
  848. #endif
  849.   
  850.   return;
  851. }//Ndb::handleReceivedSignal()
  854. /*****************************************************************************
  855. void completedTransaction(NdbConnection* aCon);
  857. Remark:   One transaction has been completed.
  858.           Remove it from send array and put it into the completed
  859.           transaction array. Finally check if it is time to wake
  860.           up a poller.
  861. ******************************************************************************/
  862. void
  863. Ndb::completedTransaction(NdbConnection* aCon)
  864. {
  865.   Uint32 tTransArrayIndex = aCon->theTransArrayIndex;
  866.   Uint32 tNoSentTransactions = theNoOfSentTransactions;
  867.   Uint32 tNoCompletedTransactions = theNoOfCompletedTransactions;
  868.   if ((tNoSentTransactions > 0) && (aCon->theListState == NdbConnection::InSendList) &&
  869.       (tTransArrayIndex < tNoSentTransactions)) {
  870.     NdbConnection* tMoveCon = theSentTransactionsArray[tNoSentTransactions - 1];
  872.     theCompletedTransactionsArray[tNoCompletedTransactions] = aCon;
  873.     aCon->theTransArrayIndex = tNoCompletedTransactions;
  874.     if (tMoveCon != aCon) {
  875.       tMoveCon->theTransArrayIndex = tTransArrayIndex;
  876.       theSentTransactionsArray[tTransArrayIndex] = tMoveCon;
  877.     }//if
  878.     theSentTransactionsArray[tNoSentTransactions - 1] = NULL;
  879.     theNoOfCompletedTransactions = tNoCompletedTransactions + 1;
  881.     theNoOfSentTransactions = tNoSentTransactions - 1;
  882.     aCon->theListState = NdbConnection::InCompletedList;
  883.     aCon->handleExecuteCompletion();
  884.     if ((theMinNoOfEventsToWakeUp != 0) &&
  885.         (theNoOfCompletedTransactions >= theMinNoOfEventsToWakeUp)) {
  886.       theMinNoOfEventsToWakeUp = 0;
  887.       NdbCondition_Signal(theImpl->theWaiter.m_condition);
  888.       return;
  889.     }//if
  890.   } else {
  891.     ndbout << "theNoOfSentTransactions = " << (int) theNoOfSentTransactions;
  892.     ndbout << " theListState = " << (int) aCon->theListState;
  893.     ndbout << " theTransArrayIndex = " << aCon->theTransArrayIndex;
  894.     ndbout << endl << flush;
  895. #ifdef VM_TRACE
  896.     printState("completedTransaction abort");
  897.     abort();
  898. #endif
  899.   }//if
  900. }//Ndb::completedTransaction()
  902. /*****************************************************************************
  903. void reportCallback(NdbConnection** aCopyArray, Uint32 aNoOfCompletedTrans);
  905. Remark:   Call the callback methods of the completed transactions.
  906. ******************************************************************************/
  907. void
  908. Ndb::reportCallback(NdbConnection** aCopyArray, Uint32 aNoOfCompletedTrans)
  909. {
  910.   Uint32         i;
  911.   if (aNoOfCompletedTrans > 0) {
  912.     for (i = 0; i < aNoOfCompletedTrans; i++) {
  913.       void* anyObject = aCopyArray[i]->theCallbackObject;
  914.       NdbAsynchCallback aCallback = aCopyArray[i]->theCallbackFunction;
  915.       int tResult = 0;
  916.       if (aCallback != NULL) {
  917.         if (aCopyArray[i]->theReturnStatus == NdbConnection::ReturnFailure) {
  918.           tResult = -1;
  919.         }//if
  920.         (*aCallback)(tResult, aCopyArray[i], anyObject);
  921.       }//if
  922.     }//for
  923.   }//if
  924. }//Ndb::reportCallback()
  926. /*****************************************************************************
  927. Uint32 pollCompleted(NdbConnection** aCopyArray);
  929. Remark:   Transfer the data from the completed transaction to a local array.
  930.           This support is used by a number of the poll-methods.
  931. ******************************************************************************/
  932. Uint32
  933. Ndb::pollCompleted(NdbConnection** aCopyArray)
  934. {
  935.   check_send_timeout();
  936.   Uint32         i;
  937.   Uint32 tNoCompletedTransactions = theNoOfCompletedTransactions;
  938.   if (tNoCompletedTransactions > 0) {
  939.     for (i = 0; i < tNoCompletedTransactions; i++) {
  940.       aCopyArray[i] = theCompletedTransactionsArray[i];
  941.       if (aCopyArray[i]->theListState != NdbConnection::InCompletedList) {
  942.         ndbout << "pollCompleted error ";
  943.         ndbout << (int) aCopyArray[i]->theListState << endl;
  944. abort();
  945.       }//if
  946.       theCompletedTransactionsArray[i] = NULL;
  947.       aCopyArray[i]->theListState = NdbConnection::NotInList;
  948.     }//for
  949.   }//if
  950.   theNoOfCompletedTransactions = 0;
  951.   return tNoCompletedTransactions;
  952. }//Ndb::pollCompleted()
  954. void
  955. Ndb::check_send_timeout()
  956. {
  957.   NDB_TICKS current_time = NdbTick_CurrentMillisecond();
  958.   if (current_time - the_last_check_time > 1000) {
  959.     the_last_check_time = current_time;
  960.     Uint32 no_of_sent = theNoOfSentTransactions;
  961.     for (Uint32 i = 0; i < no_of_sent; i++) {
  962.       NdbConnection* a_con = theSentTransactionsArray[i];
  963.       if ((current_time - a_con->theStartTransTime) >
  964.           WAITFOR_RESPONSE_TIMEOUT) {
  965. #ifdef VM_TRACE
  966.         a_con->printState();
  967. Uint32 t1 = a_con->theTransactionId;
  968. Uint32 t2 = a_con->theTransactionId >> 32;
  969. ndbout_c("[%.8x %.8x]", t1, t2);
  970. abort();
  971. #endif
  972.         a_con->setOperationErrorCodeAbort(4012);
  973.         a_con->theCommitStatus = NdbConnection::Aborted;
  974.         a_con->theCompletionStatus = NdbConnection::CompletedFailure;
  975.         a_con->handleExecuteCompletion();
  976.         remove_sent_list(i);
  977.         insert_completed_list(a_con);
  978.         no_of_sent--;
  979.         i--;
  980.       }//if
  981.     }//for
  982.   }//if
  983. }
  985. void
  986. Ndb::remove_sent_list(Uint32 list_index)
  987. {
  988.   Uint32 last_index = theNoOfSentTransactions - 1;
  989.   if (list_index < last_index) {
  990.     NdbConnection* t_con = theSentTransactionsArray[last_index];
  991.     theSentTransactionsArray[list_index] = t_con;
  992.   }//if
  993.   theNoOfSentTransactions = last_index;
  994.   theSentTransactionsArray[last_index] = 0;
  995. }
  997. Uint32
  998. Ndb::insert_completed_list(NdbConnection* a_con)
  999. {
  1000.   Uint32 no_of_comp = theNoOfCompletedTransactions;
  1001.   theCompletedTransactionsArray[no_of_comp] = a_con;
  1002.   theNoOfCompletedTransactions = no_of_comp + 1;
  1003.   a_con->theListState = NdbConnection::InCompletedList;
  1004.   a_con->theTransArrayIndex = no_of_comp;
  1005.   return no_of_comp;
  1006. }
  1008. Uint32
  1009. Ndb::insert_sent_list(NdbConnection* a_con)
  1010. {
  1011.   Uint32 no_of_sent = theNoOfSentTransactions;
  1012.   theSentTransactionsArray[no_of_sent] = a_con;
  1013.   theNoOfSentTransactions = no_of_sent + 1;
  1014.   a_con->theListState = NdbConnection::InSendList;
  1015.   a_con->theTransArrayIndex = no_of_sent;
  1016.   return no_of_sent;
  1017. }
  1019. /*****************************************************************************
  1020. void sendPrepTrans(int forceSend);
  1022. Remark: Send a batch of transactions prepared for sending to the NDB kernel.  
  1023. ******************************************************************************/
  1024. void
  1025. Ndb::sendPrepTrans(int forceSend)
  1026. {
  1027.   // Always called when holding mutex on TransporterFacade
  1028.   /*
  1029.      We will send a list of transactions to the NDB kernel. Before
  1030.      sending we check the following.
  1031.      1) Node connected to is still alive
  1032.         Checked by both checking node status and node sequence
  1033.      2) Send buffer can handle the size of messages we are planning to send
  1034.         So far this is just a fake check but will soon be a real check
  1035.      When the connected node has failed we abort the transaction without
  1036.      responding anymore to the node since the kernel will clean up
  1037.      automatically.
  1038.      When sendBuffer cannot handle anymore messages then we will also abort
  1039.      transaction but by communicating to the kernel since it is still alive
  1040.      and we keep a small space for messages like that.
  1041.   */
  1042.   Uint32 i;
  1043.   TransporterFacade* tp = TransporterFacade::instance();
  1044.   Uint32 no_of_prep_trans = theNoOfPreparedTransactions;
  1045.   for (i = 0; i < no_of_prep_trans; i++) {
  1046.     NdbConnection * a_con = thePreparedTransactionsArray[i];
  1047.     thePreparedTransactionsArray[i] = NULL;
  1048.     Uint32 node_id = a_con->getConnectedNodeId();
  1049.     if ((tp->getNodeSequence(node_id) == a_con->theNodeSequence) &&
  1050.          tp->get_node_alive(node_id) ||
  1051.          (tp->get_node_stopping(node_id) && 
  1052.          ((a_con->theSendStatus == NdbConnection::sendABORT) ||
  1053.           (a_con->theSendStatus == NdbConnection::sendABORTfail) ||
  1054.           (a_con->theSendStatus == NdbConnection::sendCOMMITstate) ||
  1055.           (a_con->theSendStatus == NdbConnection::sendCompleted)))) {
  1056.       /*
  1057.       We will send if
  1058.       1) Node is alive and sequences are correct OR
  1059.       2) Node is stopping and we only want to commit or abort
  1060.       In a graceful stop situation we want to ensure quick aborts
  1061.       of all transactions and commits and thus we allow aborts and
  1062.       commits to continue but not normal operations.
  1063.       */
  1064.       if (tp->check_send_size(node_id, a_con->get_send_size())) {
  1065.         if (a_con->doSend() == 0) {
  1066.           NDB_TICKS current_time = NdbTick_CurrentMillisecond();
  1067.           a_con->theStartTransTime = current_time;
  1068.           continue;
  1069.         } else {
  1070.           /*
  1071.           Although all precautions we did not manage to send the operations
  1072.           Must have been a dropped connection on the transporter side.
  1073.           We don't expect to be able to continue using this connection so
  1074.           we will treat it as a node failure.
  1075.           */
  1076.           TRACE_DEBUG("Send problem even after checking node status");
  1077.         }//if
  1078.       } else {
  1079.         /*
  1080.         The send buffer is currently full or at least close to. We will
  1081.         not allow a send to continue. We will set the connection so that
  1082.         it is indicated that we need to abort the transaction. If we were
  1083.         trying to commit or abort and got a send buffer we will not try
  1084.         again and will thus set the state to Aborted to avoid a more or
  1085.         less eternal loop of tries.
  1086.         */
  1087.         if (a_con->theSendStatus == NdbConnection::sendOperations) {
  1088.           a_con->setOperationErrorCodeAbort(4021);
  1089.           a_con->theCommitStatus = NdbConnection::NeedAbort;
  1090.           TRACE_DEBUG("Send buffer full and sendOperations");
  1091.         } else {
  1092.           a_con->setOperationErrorCodeAbort(4026);
  1093.           a_con->theCommitStatus = NdbConnection::Aborted;
  1094.           TRACE_DEBUG("Send buffer full, set state to Aborted");
  1095.         }//if
  1096.       }//if
  1097.     } else {
  1098. #ifdef VM_TRACE
  1099.       a_con->printState();
  1100. #endif
  1101.       if ((tp->getNodeSequence(node_id) == a_con->theNodeSequence) &&
  1102.           tp->get_node_stopping(node_id)) {
  1103.         /*
  1104.         The node we are connected to is currently in an early stopping phase
  1105.         of a graceful stop. We will not send the prepared transactions. We
  1106.         will simply refuse and let the application code handle the abort.
  1107.         */
  1108.         TRACE_DEBUG("Abort a transaction when stopping a node");
  1109.         a_con->setOperationErrorCodeAbort(4023);
  1110.         a_con->theCommitStatus = NdbConnection::NeedAbort;
  1111.       } else {
  1112.         /*
  1113.         The node is hard dead and we cannot continue. We will also release
  1114.         the connection to the free pool.
  1115.         */
  1116.         TRACE_DEBUG("The node was stone dead, inform about abort");
  1117.         a_con->setOperationErrorCodeAbort(4025);
  1118.         a_con->theReleaseOnClose = true;
  1119.         a_con->theTransactionIsStarted = false;
  1120.         a_con->theCommitStatus = NdbConnection::Aborted;
  1121.       }//if
  1122.     }//if
  1123.     a_con->theCompletionStatus = NdbConnection::CompletedFailure;
  1124.     a_con->handleExecuteCompletion();
  1125.     insert_completed_list(a_con);
  1126.   }//for
  1127.   theNoOfPreparedTransactions = 0;
  1128.   if (forceSend == 0) {
  1129.      tp->checkForceSend(theNdbBlockNumber);
  1130.   } else if (forceSend == 1) {
  1131.      tp->forceSend(theNdbBlockNumber);
  1132.   }//if
  1133.   return;
  1134. }//Ndb::sendPrepTrans()
  1136. /*****************************************************************************
  1137. void waitCompletedTransactions(int aMilliSecondsToWait, int noOfEventsToWaitFor);
  1139. Remark:   First send all prepared operations and then check if there are any
  1140.           transactions already completed. Do not wait for not completed
  1141.           transactions.
  1142. ******************************************************************************/
  1143. void
  1144. Ndb::waitCompletedTransactions(int aMilliSecondsToWait, 
  1145.        int noOfEventsToWaitFor)
  1146. {
  1147.   theImpl->theWaiter.m_state = NO_WAIT; 
  1148.   /**
  1149.    * theImpl->theWaiter.m_state = NO_WAIT; 
  1150.    * To ensure no messup with synchronous node fail handling
  1151.    * (see ReportFailure)
  1152.    */
  1153.   int waitTime = aMilliSecondsToWait;
  1154.   NDB_TICKS maxTime = NdbTick_CurrentMillisecond() + (NDB_TICKS)waitTime;
  1155.   theMinNoOfEventsToWakeUp = noOfEventsToWaitFor;
  1156.   do {
  1157.     if (waitTime < 1000) waitTime = 1000;
  1158.     NdbCondition_WaitTimeout(theImpl->theWaiter.m_condition,
  1159.      (NdbMutex*)theImpl->theWaiter.m_mutex,
  1160.      waitTime);
  1161.     if (theNoOfCompletedTransactions >= (Uint32)noOfEventsToWaitFor) {
  1162.       break;
  1163.     }//if
  1164.     theMinNoOfEventsToWakeUp = noOfEventsToWaitFor;
  1165.     waitTime = (int)(maxTime - NdbTick_CurrentMillisecond());
  1166.   } while (waitTime > 0);
  1167.   return;
  1168. }//Ndb::waitCompletedTransactions()
  1170. /*****************************************************************************
  1171. void sendPreparedTransactions(int forceSend = 0);
  1173. Remark:   First send all prepared operations and then check if there are any
  1174.           transactions already completed. Do not wait for not completed
  1175.           transactions.
  1176. ******************************************************************************/
  1177. void
  1178. Ndb::sendPreparedTransactions(int forceSend)
  1179. {
  1180.   TransporterFacade::instance()->lock_mutex();
  1181.   sendPrepTrans(forceSend);
  1182.   TransporterFacade::instance()->unlock_mutex();
  1183.   return;
  1184. }//Ndb::sendPreparedTransactions()
  1186. /*****************************************************************************
  1187. int sendPollNdb(int aMillisecondNumber, int minNoOfEventsToWakeup = 1, int forceSend = 0);
  1189. Remark:   First send all prepared operations and then check if there are any
  1190.           transactions already completed. Wait for not completed
  1191.           transactions until the specified number have completed or until the
  1192.           timeout has occured. Timeout zero means no waiting time.
  1193. ******************************************************************************/
  1194. int
  1195. Ndb::sendPollNdb(int aMillisecondNumber, int minNoOfEventsToWakeup, int forceSend)
  1196. {
  1197.   NdbConnection* tConArray[1024];
  1198.   Uint32         tNoCompletedTransactions;
  1200.   //theCurrentConnectCounter = 0;
  1201.   //theCurrentConnectIndex++;
  1202.   TransporterFacade::instance()->lock_mutex();
  1203.   sendPrepTrans(forceSend);
  1204.   if ((minNoOfEventsToWakeup <= 0) ||
  1205.       ((Uint32)minNoOfEventsToWakeup > theNoOfSentTransactions)) {
  1206.     minNoOfEventsToWakeup = theNoOfSentTransactions;
  1207.   }//if
  1208.   if ((theNoOfCompletedTransactions < (Uint32)minNoOfEventsToWakeup) &&
  1209.       (aMillisecondNumber > 0)) {
  1210.     waitCompletedTransactions(aMillisecondNumber, minNoOfEventsToWakeup);
  1211.     tNoCompletedTransactions = pollCompleted(tConArray);
  1212.   } else {
  1213.     tNoCompletedTransactions = pollCompleted(tConArray);
  1214.   }//if
  1215.   TransporterFacade::instance()->unlock_mutex();
  1216.   reportCallback(tConArray, tNoCompletedTransactions);
  1217.   return tNoCompletedTransactions;
  1218. }//Ndb::sendPollNdb()
  1220. /*****************************************************************************
  1221. int pollNdb(int aMillisecondNumber, int minNoOfEventsToWakeup);
  1223. Remark:   Check if there are any transactions already completed. Wait for not
  1224.           completed transactions until the specified number have completed or
  1225.           until the timeout has occured. Timeout zero means no waiting time.
  1226. ******************************************************************************/
  1227. int
  1228. Ndb::pollNdb(int aMillisecondNumber, int minNoOfEventsToWakeup)
  1229. {
  1230.   NdbConnection* tConArray[1024];
  1231.   Uint32         tNoCompletedTransactions;
  1233.   //theCurrentConnectCounter = 0;
  1234.   //theCurrentConnectIndex++;
  1235.   TransporterFacade::instance()->lock_mutex();
  1236.   if ((minNoOfEventsToWakeup == 0) ||
  1237.       ((Uint32)minNoOfEventsToWakeup > theNoOfSentTransactions)) {
  1238.     minNoOfEventsToWakeup = theNoOfSentTransactions;
  1239.   }//if
  1240.   if ((theNoOfCompletedTransactions < (Uint32)minNoOfEventsToWakeup) &&
  1241.       (aMillisecondNumber > 0)) {
  1242.     waitCompletedTransactions(aMillisecondNumber, minNoOfEventsToWakeup);
  1243.     tNoCompletedTransactions = pollCompleted(tConArray);
  1244.   } else {
  1245.     tNoCompletedTransactions = pollCompleted(tConArray);
  1246.   }//if
  1247.   TransporterFacade::instance()->unlock_mutex();
  1248.   reportCallback(tConArray, tNoCompletedTransactions);
  1249.   return tNoCompletedTransactions;
  1250. }//Ndb::sendPollNdbWithoutWait()
  1252. /*****************************************************************************
  1253. int receiveOptimisedResponse();
  1255. Return:  0 - Response received
  1256.         -1 - Timeout occured waiting for response
  1257.         -2 - Node failure interupted wait for response
  1259. ******************************************************************************/
  1260. int
  1261. Ndb::receiveResponse(int waitTime){
  1262.   int tResultCode;
  1263.   TransporterFacade::instance()->checkForceSend(theNdbBlockNumber);
  1264.   
  1265.   theImpl->theWaiter.wait(waitTime);
  1266.   
  1267.   if(theImpl->theWaiter.m_state == NO_WAIT) {
  1268.     tResultCode = 0;
  1269.   } else {
  1271. #ifdef VM_TRACE
  1272.     ndbout << "ERR: receiveResponse - theImpl->theWaiter.m_state = ";
  1273.     ndbout << theImpl->theWaiter.m_state << endl;
  1274. #endif
  1276.     if (theImpl->theWaiter.m_state == WAIT_NODE_FAILURE){
  1277.       tResultCode = -2;
  1278.     } else {
  1279.       tResultCode = -1;
  1280.     }
  1281.     theImpl->theWaiter.m_state = NO_WAIT;
  1282.   }
  1283.   return tResultCode;
  1284. }//Ndb::receiveResponse()
  1286. int
  1287. Ndb::sendRecSignal(Uint16 node_id,
  1288.    Uint32 aWaitState,
  1289.    NdbApiSignal* aSignal,
  1290.                    Uint32 conn_seq)
  1291. {
  1292.   /*
  1293.   In most situations 0 is returned.
  1294.   In error cases we have 5 different cases
  1295.   -1: Send ok, time out in waiting for reply
  1296.   -2: Node has failed
  1297.   -3: Send buffer not full, send failed yet
  1298.   -4: Send buffer full
  1299.   -5: Node is currently stopping
  1300.   */
  1302.   int return_code;
  1303.   TransporterFacade* tp = TransporterFacade::instance();
  1304.   Uint32 send_size = 1; // Always sends one signal only 
  1305.   tp->lock_mutex();
  1306.   // Protected area
  1307.   if ((tp->get_node_alive(node_id)) &&
  1308.       ((tp->getNodeSequence(node_id) == conn_seq) ||
  1309.        (conn_seq == 0))) {
  1310.     if (tp->check_send_size(node_id, send_size)) {
  1311.       return_code = tp->sendSignal(aSignal, node_id);
  1312.       if (return_code != -1) {
  1313.         theImpl->theWaiter.m_node = node_id;
  1314.         theImpl->theWaiter.m_state = aWaitState;
  1315.         return_code = receiveResponse();
  1316.       } else {
  1317. return_code = -3;
  1318.       }
  1319.     } else {
  1320.       return_code = -4;
  1321.     }//if
  1322.   } else {
  1323.     if ((tp->get_node_stopping(node_id)) &&
  1324.         ((tp->getNodeSequence(node_id) == conn_seq) ||
  1325.          (conn_seq == 0))) {
  1326.       return_code = -5;
  1327.     } else {
  1328.       return_code = -2;
  1329.     }//if
  1330.   }//if
  1331.   tp->unlock_mutex();
  1332.   // End of protected area
  1333.   return return_code;
  1334. }//Ndb::sendRecSignal()
  1336. void
  1337. NdbConnection::sendTC_COMMIT_ACK(NdbApiSignal * aSignal,
  1338.  Uint32 transId1, Uint32 transId2, 
  1339.  Uint32 aTCRef){
  1340. #ifdef MARKER_TRACE
  1341.   ndbout_c("Sending TC_COMMIT_ACK(0x%.8x, 0x%.8x) to -> %d",
  1342.    transId1,
  1343.    transId2,
  1344.    refToNode(aTCRef));
  1345. #endif  
  1346.   TransporterFacade *tp = TransporterFacade::instance();
  1347.   aSignal->theTrace                = TestOrd::TraceAPI;
  1348.   aSignal->theReceiversBlockNumber = DBTC;
  1349.   aSignal->theVerId_signalNumber   = GSN_TC_COMMIT_ACK;
  1350.   aSignal->theLength               = 2;
  1352.   Uint32 * dataPtr = aSignal->getDataPtrSend();
  1353.   dataPtr[0] = transId1;
  1354.   dataPtr[1] = transId2;
  1356.   tp->sendSignal(aSignal, refToNode(aTCRef));
  1357. }