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

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

MySQL数据库

开发平台：

Visual C++

DbtupGen.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. #define DBTUP_C
  19. #include "Dbtup.hpp"
  20. #include <RefConvert.hpp>
  21. #include <ndb_limits.h>
  22. #include <pc.hpp>
  23. #include <AttributeDescriptor.hpp>
  24. #include "AttributeOffset.hpp"
  25. #include <AttributeHeader.hpp>
  26. #include <Interpreter.hpp>
  27. #include <signaldata/FsConf.hpp>
  28. #include <signaldata/FsRemoveReq.hpp>
  29. #include <signaldata/TupCommit.hpp>
  30. #include <signaldata/TupKey.hpp>
  32. #include <signaldata/DropTab.hpp>
  34. #define DEBUG(x) { ndbout << "TUP::" << x << endl; }
  36. #define ljam() { jamLine(24000 + __LINE__); }
  37. #define ljamEntry() { jamEntryLine(24000 + __LINE__); }
  39. void Dbtup::initData() 
  40. {
  41.   cnoOfAttrbufrec = ZNO_OF_ATTRBUFREC;
  42.   cnoOfLcpRec = ZNO_OF_LCP_REC;
  43.   cnoOfConcurrentOpenOp = ZNO_OF_CONCURRENT_OPEN_OP;
  44.   cnoOfConcurrentWriteOp = ZNO_OF_CONCURRENT_WRITE_OP;
  45.   cnoOfFragoprec = 2 * MAX_FRAG_PER_NODE;
  46.   cnoOfPageRangeRec = ZNO_OF_PAGE_RANGE_REC;
  47.   cnoOfParallellUndoFiles = ZNO_OF_PARALLELL_UNDO_FILES;
  48.   cnoOfRestartInfoRec = ZNO_OF_RESTART_INFO_REC;
  49.   c_maxTriggersPerTable = ZDEFAULT_MAX_NO_TRIGGERS_PER_TABLE;
  50.   c_noOfBuildIndexRec = 32;
  52.   attrbufrec = 0;
  53.   checkpointInfo = 0;
  54.   diskBufferSegmentInfo = 0;
  55.   fragoperrec = 0;
  56.   fragrecord = 0;
  57.   hostBuffer = 0;
  58.   localLogInfo = 0;
  59.   operationrec = 0;
  60.   page = 0;
  61.   pageRange = 0;
  62.   pendingFileOpenInfo = 0;
  63.   restartInfoRecord = 0;
  64.   tablerec = 0;
  65.   tableDescriptor = 0;
  66.   undoPage = 0;
  67.   totNoOfPagesAllocated = 0;
  68.   cnoOfAllocatedPages = 0;
  69.   
  70.   // Records with constant sizes
  71. }//Dbtup::initData()
  73. Dbtup::Dbtup(const class Configuration & conf)
  74.   : SimulatedBlock(DBTUP, conf),
  75.   c_storedProcPool(),
  76.   c_buildIndexList(c_buildIndexPool)
  77. {
  78.   Uint32 log_page_size= 0;
  79.   BLOCK_CONSTRUCTOR(Dbtup);
  81.   const ndb_mgm_configuration_iterator * p = conf.getOwnConfigIterator();
  82.   ndbrequire(p != 0);
  84.   ndb_mgm_get_int_parameter(p, CFG_DB_UNDO_DATA_BUFFER,  
  85.     &log_page_size);
  87.   /**
  88.    * Always set page size in half MBytes
  89.    */
  90.   cnoOfUndoPage= (log_page_size / sizeof(UndoPage));
  91.   Uint32 mega_byte_part= cnoOfUndoPage & 15;
  92.   if (mega_byte_part != 0) {
  93.     jam();
  94.     cnoOfUndoPage+= (16 - mega_byte_part);
  95.   }
  97.   addRecSignal(GSN_DEBUG_SIG, &Dbtup::execDEBUG_SIG);
  98.   addRecSignal(GSN_CONTINUEB, &Dbtup::execCONTINUEB);
  100.   addRecSignal(GSN_DUMP_STATE_ORD, &Dbtup::execDUMP_STATE_ORD);
  101.   addRecSignal(GSN_SEND_PACKED, &Dbtup::execSEND_PACKED);
  102.   addRecSignal(GSN_ATTRINFO, &Dbtup::execATTRINFO);
  103.   addRecSignal(GSN_STTOR, &Dbtup::execSTTOR);
  104.   addRecSignal(GSN_TUP_LCPREQ, &Dbtup::execTUP_LCPREQ);
  105.   addRecSignal(GSN_END_LCPREQ, &Dbtup::execEND_LCPREQ);
  106.   addRecSignal(GSN_START_RECREQ, &Dbtup::execSTART_RECREQ);
  107.   addRecSignal(GSN_MEMCHECKREQ, &Dbtup::execMEMCHECKREQ);
  108.   addRecSignal(GSN_TUPKEYREQ, &Dbtup::execTUPKEYREQ);
  109.   addRecSignal(GSN_TUPSEIZEREQ, &Dbtup::execTUPSEIZEREQ);
  110.   addRecSignal(GSN_TUPRELEASEREQ, &Dbtup::execTUPRELEASEREQ);
  111.   addRecSignal(GSN_STORED_PROCREQ, &Dbtup::execSTORED_PROCREQ);
  112.   addRecSignal(GSN_TUPFRAGREQ, &Dbtup::execTUPFRAGREQ);
  113.   addRecSignal(GSN_TUP_ADD_ATTRREQ, &Dbtup::execTUP_ADD_ATTRREQ);
  114.   addRecSignal(GSN_TUP_COMMITREQ, &Dbtup::execTUP_COMMITREQ);
  115.   addRecSignal(GSN_TUP_ABORTREQ, &Dbtup::execTUP_ABORTREQ);
  116.   addRecSignal(GSN_TUP_SRREQ, &Dbtup::execTUP_SRREQ);
  117.   addRecSignal(GSN_TUP_PREPLCPREQ, &Dbtup::execTUP_PREPLCPREQ);
  118.   addRecSignal(GSN_FSOPENCONF, &Dbtup::execFSOPENCONF);
  119.   addRecSignal(GSN_FSCLOSECONF, &Dbtup::execFSCLOSECONF);
  120.   addRecSignal(GSN_FSWRITECONF, &Dbtup::execFSWRITECONF);
  121.   addRecSignal(GSN_FSREADCONF, &Dbtup::execFSREADCONF);
  122.   addRecSignal(GSN_NDB_STTOR, &Dbtup::execNDB_STTOR);
  123.   addRecSignal(GSN_READ_CONFIG_REQ, &Dbtup::execREAD_CONFIG_REQ, true);
  124.   addRecSignal(GSN_SET_VAR_REQ,  &Dbtup::execSET_VAR_REQ);
  126.   // Trigger Signals
  127.   addRecSignal(GSN_CREATE_TRIG_REQ, &Dbtup::execCREATE_TRIG_REQ);
  128.   addRecSignal(GSN_DROP_TRIG_REQ,  &Dbtup::execDROP_TRIG_REQ);
  130.   addRecSignal(GSN_DROP_TAB_REQ, &Dbtup::execDROP_TAB_REQ);
  131.   addRecSignal(GSN_FSREMOVECONF, &Dbtup::execFSREMOVECONF);
  133.   addRecSignal(GSN_TUP_ALLOCREQ, &Dbtup::execTUP_ALLOCREQ);
  134.   addRecSignal(GSN_TUP_DEALLOCREQ, &Dbtup::execTUP_DEALLOCREQ);
  135.   addRecSignal(GSN_TUP_WRITELOG_REQ, &Dbtup::execTUP_WRITELOG_REQ);
  137.   // Ordered index related
  138.   addRecSignal(GSN_BUILDINDXREQ, &Dbtup::execBUILDINDXREQ);
  140.   initData();
  141. }//Dbtup::Dbtup()
  143. Dbtup::~Dbtup() 
  144. {
  145.   // Records with dynamic sizes
  146.   deallocRecord((void **)&attrbufrec,"Attrbufrec", 
  147. sizeof(Attrbufrec), 
  148. cnoOfAttrbufrec);
  149.   
  150.   deallocRecord((void **)&checkpointInfo,"CheckpointInfo",
  151. sizeof(CheckpointInfo), 
  152. cnoOfLcpRec);
  153.   
  154.   deallocRecord((void **)&diskBufferSegmentInfo,
  155. "DiskBufferSegmentInfo",
  156. sizeof(DiskBufferSegmentInfo), 
  157. cnoOfConcurrentWriteOp);
  158.   
  159.   deallocRecord((void **)&fragoperrec,"Fragoperrec",
  160. sizeof(Fragoperrec),
  161. cnoOfFragoprec);
  162.   
  163.   deallocRecord((void **)&fragrecord,"Fragrecord",
  164. sizeof(Fragrecord), 
  165. cnoOfFragrec);
  166.   
  167.   deallocRecord((void **)&hostBuffer,"HostBuffer",
  168. sizeof(HostBuffer), 
  169. MAX_NODES);
  170.   
  171.   deallocRecord((void **)&localLogInfo,"LocalLogInfo",
  172. sizeof(LocalLogInfo), 
  173. cnoOfParallellUndoFiles);
  174.   
  175.   deallocRecord((void **)&operationrec,"Operationrec",
  176. sizeof(Operationrec),
  177. cnoOfOprec);
  179.   deallocRecord((void **)&page,"Page", 
  180. sizeof(Page), 
  181. cnoOfPage);
  182.   
  183.   deallocRecord((void **)&pageRange,"PageRange",
  184. sizeof(PageRange), 
  185. cnoOfPageRangeRec);
  187.   deallocRecord((void **)&pendingFileOpenInfo,
  188. "PendingFileOpenInfo",
  189. sizeof(PendingFileOpenInfo), 
  190. cnoOfConcurrentOpenOp);
  191.   
  192.   deallocRecord((void **)&restartInfoRecord,
  193. "RestartInfoRecord",
  194. sizeof(RestartInfoRecord),
  195. cnoOfRestartInfoRec);
  196.   
  197.   deallocRecord((void **)&tablerec,"Tablerec",
  198. sizeof(Tablerec), 
  199. cnoOfTablerec);
  200.   
  201.   deallocRecord((void **)&tableDescriptor, "TableDescriptor",
  202. sizeof(TableDescriptor),
  203. cnoOfTabDescrRec);
  204.   
  205.   deallocRecord((void **)&undoPage,"UndoPage",
  206. sizeof(UndoPage),
  207. cnoOfUndoPage);
  209. }//Dbtup::~Dbtup()
  211. BLOCK_FUNCTIONS(Dbtup)
  213. /* **************************************************************** */
  214. /* ---------------------------------------------------------------- */
  215. /* ----- GENERAL SIGNAL MULTIPLEXER (FS + CONTINUEB) -------------- */
  216. /* ---------------------------------------------------------------- */
  217. /* **************************************************************** */
  218. void Dbtup::execFSCLOSECONF(Signal* signal) 
  219. {
  220.   PendingFileOpenInfoPtr pfoPtr;
  221.   ljamEntry();
  222.   pfoPtr.i = signal->theData[0];
  223.   ptrCheckGuard(pfoPtr, cnoOfConcurrentOpenOp, pendingFileOpenInfo);
  224.   switch (pfoPtr.p->pfoOpenType) {
  225.   case LCP_DATA_FILE_CLOSE:
  226.   {
  227.     CheckpointInfoPtr ciPtr;
  228.     ljam();
  229.     ciPtr.i = pfoPtr.p->pfoCheckpointInfoP;
  230.     ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  231.     ciPtr.p->lcpDataFileHandle = RNIL;
  232.     lcpClosedDataFileLab(signal, ciPtr);
  233.     break;
  234.   }
  235.   case LCP_UNDO_FILE_CLOSE:
  236.   {
  237.     LocalLogInfoPtr lliPtr;
  238.     ljam();
  239.     lliPtr.i = pfoPtr.p->pfoCheckpointInfoP;
  240.     ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  241.     lliPtr.p->lliUndoFileHandle = RNIL;
  242.     lcpEndconfLab(signal);
  243.     break;
  244.   }
  245.   case LCP_UNDO_FILE_READ:
  246.     ljam();
  247.     endExecUndoLogLab(signal, pfoPtr.p->pfoCheckpointInfoP);
  248.     break;
  249.   case LCP_DATA_FILE_READ:
  250.     ljam();
  251.     rfrClosedDataFileLab(signal, pfoPtr.p->pfoCheckpointInfoP);
  252.     break;
  253.   default:
  254.     ndbrequire(false);
  255.     break;
  256.   }//switch
  257.   releasePendingFileOpenInfoRecord(pfoPtr);
  258. }//Dbtup::execFSCLOSECONF()
  260. void Dbtup::execFSOPENCONF(Signal* signal) 
  261. {
  262.   PendingFileOpenInfoPtr pfoPtr;
  264.   ljamEntry();
  265.   pfoPtr.i = signal->theData[0];
  266.   Uint32 fileHandle = signal->theData[1];
  267.   ptrCheckGuard(pfoPtr, cnoOfConcurrentOpenOp, pendingFileOpenInfo);
  268.   switch (pfoPtr.p->pfoOpenType) {
  269.   case LCP_DATA_FILE_READ:
  270.   {
  271.     RestartInfoRecordPtr riPtr;
  272.     ljam();
  273.     riPtr.i = pfoPtr.p->pfoRestartInfoP;
  274.     ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord);
  275.     riPtr.p->sriDataFileHandle = fileHandle;
  276.     rfrReadRestartInfoLab(signal, riPtr);
  277.     break;
  278.   }
  279.   case LCP_UNDO_FILE_READ:
  280.   {
  281.     RestartInfoRecordPtr riPtr;
  282.     LocalLogInfoPtr lliPtr;
  283.     DiskBufferSegmentInfoPtr dbsiPtr;
  285.     ljam();
  286.     riPtr.i = pfoPtr.p->pfoRestartInfoP;
  287.     ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord);
  288.     lliPtr.i = riPtr.p->sriLocalLogInfoP;
  289.     ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  290.     lliPtr.p->lliUndoFileHandle = fileHandle;
  291.     dbsiPtr.i = riPtr.p->sriDataBufferSegmentP;
  292.     ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  293.     rfrLoadDataPagesLab(signal, riPtr, dbsiPtr);
  294.     break;
  295.   }
  296.   case LCP_DATA_FILE_WRITE_WITH_UNDO:
  297.   {
  298.     CheckpointInfoPtr ciPtr;
  299.     LocalLogInfoPtr lliPtr;
  301.     ljam();
  302.     ciPtr.i = pfoPtr.p->pfoCheckpointInfoP;
  303.     ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  304.     lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
  305.     ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  306.     ciPtr.p->lcpDataFileHandle = fileHandle;
  307.     if (lliPtr.p->lliUndoFileHandle != RNIL) {
  308.       ljam();
  309.       signal->theData[0] = ciPtr.p->lcpUserptr;
  310.       signal->theData[1] = ciPtr.i;
  311.       sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_PREPLCPCONF, signal, 2, JBB);
  312.     }//if
  313.     break;
  314.   }
  315.   case LCP_DATA_FILE_WRITE:
  316.   {
  317.     CheckpointInfoPtr ciPtr;
  319.     ljam();
  320.     ciPtr.i = pfoPtr.p->pfoCheckpointInfoP;
  321.     ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  322.     ciPtr.p->lcpDataFileHandle = fileHandle;
  323.     signal->theData[0] = ciPtr.p->lcpUserptr;
  324.     signal->theData[1] = ciPtr.i;
  325.     sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_PREPLCPCONF, signal, 2, JBB);
  326.     break;
  327.   }
  328.   case LCP_UNDO_FILE_WRITE:
  329.   {
  330.     CheckpointInfoPtr ciPtr;
  331.     LocalLogInfoPtr lliPtr;
  333.     ljam();
  334.     ciPtr.i = pfoPtr.p->pfoCheckpointInfoP;
  335.     ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  336.     lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
  337.     ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  338.     lliPtr.p->lliUndoFileHandle = fileHandle;
  339.     if (ciPtr.p->lcpDataFileHandle != RNIL) {
  340.       ljam();
  341.       signal->theData[0] = ciPtr.p->lcpUserptr;
  342.       signal->theData[1] = ciPtr.i;
  343.       sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_PREPLCPCONF, signal, 2, JBB);
  344.     }//if
  345.     break;
  346.   }
  347.   default:
  348.     ndbrequire(false);
  349.     break;
  350.   }//switch
  351.   releasePendingFileOpenInfoRecord(pfoPtr);
  352. }//Dbtup::execFSOPENCONF()
  354. void Dbtup::execFSREADCONF(Signal* signal) 
  355. {
  356.   DiskBufferSegmentInfoPtr dbsiPtr;
  357.   ljamEntry();
  358.   dbsiPtr.i = signal->theData[0];
  359.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  360.   switch (dbsiPtr.p->pdxOperation) {
  361.   case CHECKPOINT_DATA_READ:
  362.   {
  363.     RestartInfoRecordPtr riPtr;
  364.     ljam();
  365.     riPtr.i = dbsiPtr.p->pdxRestartInfoP;
  366.     ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord);
  367. /************************************************************/
  368. /*       VERIFY THAT THE PAGES ARE CORRECT, HAVE A CORRECT  */
  369. /*       STATE AND A CORRECT PAGE ID.                       */
  370. /************************************************************/
  371.     ndbrequire(dbsiPtr.p->pdxNumDataPages <= 16);
  372.     for (Uint32 i = 0; i < dbsiPtr.p->pdxNumDataPages; i++) {
  373.       PagePtr pagePtr;
  374.       ljam();
  375.       pagePtr.i = dbsiPtr.p->pdxDataPage[i];
  376.       ptrCheckGuard(pagePtr, cnoOfPage, page);
  377.       ndbrequire(pagePtr.p->pageWord[ZPAGE_STATE_POS] != 0);
  378.       ndbrequire(pagePtr.p->pageWord[ZPAGE_STATE_POS] <= ZAC_MM_FREE_COPY);
  379.       ndbrequire(pagePtr.p->pageWord[ZPAGE_FRAG_PAGE_ID_POS] == ((dbsiPtr.p->pdxFilePage - 1) + i));
  380.     }//for
  381.     rfrLoadDataPagesLab(signal, riPtr, dbsiPtr);
  382.     break;
  383.   }
  384.   case CHECKPOINT_DATA_READ_PAGE_ZERO:
  385.   {
  386.     ljam();
  387.     rfrInitRestartInfoLab(signal, dbsiPtr);
  388.     break;
  389.   }
  390.   case CHECKPOINT_UNDO_READ:
  391.   {
  392.     LocalLogInfoPtr lliPtr;
  393.     ljam();
  394.     lliPtr.i = dbsiPtr.p->pdxCheckpointInfoP;
  395.     ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  396.     xlcGetNextRecordLab(signal, dbsiPtr, lliPtr);
  397.     break;
  398.   }
  399.   case CHECKPOINT_UNDO_READ_FIRST:
  400.     ljam();
  401.     rfrReadSecondUndoLogLab(signal, dbsiPtr);
  402.     break;
  403.   default:
  404.     ndbrequire(false);
  405.     break;
  406.   }//switch
  407. }//Dbtup::execFSREADCONF()
  409. void Dbtup::execFSWRITECONF(Signal* signal) 
  410. {
  411.   DiskBufferSegmentInfoPtr dbsiPtr;
  413.   ljamEntry();
  414.   dbsiPtr.i = signal->theData[0];
  415.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  416.   switch (dbsiPtr.p->pdxOperation) {
  417.   case CHECKPOINT_DATA_WRITE:
  418.     ljam();
  419.     lcpSaveDataPageLab(signal, dbsiPtr.p->pdxCheckpointInfoP);
  420.     break;
  421.   case CHECKPOINT_DATA_WRITE_LAST:
  422.   {
  423.     CheckpointInfoPtr ciPtr;
  424.     ljam();
  425.     ciPtr.i = dbsiPtr.p->pdxCheckpointInfoP;
  426.     ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  427.     lcpFlushLogLab(signal, ciPtr);
  428.     break;
  429.   }
  430.   case CHECKPOINT_DATA_WRITE_FLUSH:
  431.   {
  432.     ljam();
  433.     Uint32 ciIndex = dbsiPtr.p->pdxCheckpointInfoP;
  434.     freeDiskBufferSegmentRecord(signal, dbsiPtr);
  435.     lcpCompletedLab(signal, ciIndex);
  436.     break;
  437.   }
  438.   case CHECKPOINT_UNDO_WRITE_FLUSH:
  439.   {
  440.     ljam();
  441.     Uint32 ciIndex = dbsiPtr.p->pdxCheckpointInfoP;
  442.     freeDiskBufferSegmentRecord(signal, dbsiPtr);
  443.     lcpFlushRestartInfoLab(signal, ciIndex);
  444.     break;
  445.   }
  446.   case CHECKPOINT_UNDO_WRITE:
  447.     ljam();
  448.     freeDiskBufferSegmentRecord(signal, dbsiPtr);
  449.     break;
  450.   default:
  451.     ndbrequire(false);
  452.     break;
  453.   }//switch
  454.   return;
  455. }//Dbtup::execFSWRITECONF()
  457. void Dbtup::execCONTINUEB(Signal* signal) 
  458. {
  459.   ljamEntry();
  460.   Uint32 actionType = signal->theData[0];
  461.   Uint32 dataPtr = signal->theData[1];
  462.   switch (actionType) {
  463.   case ZSTART_EXEC_UNDO_LOG:
  464.     ljam();
  465.     startExecUndoLogLab(signal, dataPtr);
  466.     break;
  467.   case ZCONT_SAVE_DP:
  468.     ljam();
  469.     lcpSaveDataPageLab(signal, dataPtr);
  470.     break;
  471.   case ZCONT_START_SAVE_CL:
  472.   {
  473.     CheckpointInfoPtr ciPtr;
  475.     ljam();
  476.     ciPtr.i = dataPtr;
  477.     ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  478.     lcpSaveCopyListLab(signal, ciPtr);
  479.     break;
  480.   }
  481.   case ZCONT_EXECUTE_LC:
  482.   {
  483.     LocalLogInfoPtr lliPtr;
  484.     DiskBufferSegmentInfoPtr dbsiPtr;
  486.     ljam();
  487.     lliPtr.i = dataPtr;
  488.     ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  489.     dbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP;
  490.     ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  491.     xlcGetNextRecordLab(signal, dbsiPtr, lliPtr);
  492.     break;
  493.   }
  494.   case ZCONT_LOAD_DP:
  495.   {
  496.     DiskBufferSegmentInfoPtr dbsiPtr;
  497.     RestartInfoRecordPtr riPtr;
  499.     ljam();
  500.     riPtr.i = dataPtr;
  501.     ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord);
  502.     dbsiPtr.i = riPtr.p->sriDataBufferSegmentP;
  503.     ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  504.     rfrLoadDataPagesLab(signal, riPtr, dbsiPtr);
  505.     break;
  506.   }
  507.   case ZLOAD_BAL_LCP_TIMER:
  508.     ljam();
  509.     clblPageCounter = clblPagesPerTick;
  510.     signal->theData[0] = ZLOAD_BAL_LCP_TIMER;
  511.     sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 400, 1);
  512.     break;
  513.   case ZINITIALISE_RECORDS:
  514.     ljam();
  515.     initialiseRecordsLab(signal, dataPtr, 
  516.  signal->theData[2], signal->theData[3]);
  517.     break;
  518.   case ZREL_FRAG:
  519.     ljam();
  520.     releaseFragment(signal, dataPtr);
  521.     break;
  522.   case ZREPORT_MEMORY_USAGE:{
  523.     ljam();
  524.     static int c_currentMemUsed = 0;
  525.     int now = (cnoOfAllocatedPages * 100)/cnoOfPage;
  526.     const int thresholds[] = { 100, 90, 80, 0 };
  527.     
  528.     Uint32 i = 0;
  529.     const Uint32 sz = sizeof(thresholds)/sizeof(thresholds[0]);
  530.     for(i = 0; i<sz; i++){
  531.       if(now >= thresholds[i]){
  532. now = thresholds[i];
  533. break;
  534.       }
  535.     }
  537.     if(now != c_currentMemUsed){
  538.       reportMemoryUsage(signal, now > c_currentMemUsed ? 1 : -1);
  539.       c_currentMemUsed = now;
  540.     }
  541.     signal->theData[0] = ZREPORT_MEMORY_USAGE;
  542.     sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 2000, 1);    
  543.     return;
  544.   }
  545.   case ZBUILD_INDEX:
  546.     ljam();
  547.     buildIndex(signal, dataPtr);
  548.     break;
  549.   default:
  550.     ndbrequire(false);
  551.     break;
  552.   }//switch
  553. }//Dbtup::execTUP_CONTINUEB()
  555. /* **************************************************************** */
  556. /* ---------------------------------------------------------------- */
  557. /* ------------------- SYSTEM RESTART MODULE ---------------------- */
  558. /* ---------------------------------------------------------------- */
  559. /* **************************************************************** */
  560. void Dbtup::execSTTOR(Signal* signal) 
  561. {
  562.   ljamEntry();
  563.   Uint32 startPhase = signal->theData[1];
  564.   Uint32 sigKey = signal->theData[6];
  565.   switch (startPhase) {
  566.   case ZSTARTPHASE1:
  567.     ljam();
  568.     CLEAR_ERROR_INSERT_VALUE;
  569.     cownref = calcTupBlockRef(0);
  570.     break;
  571.   default:
  572.     ljam();
  573.     break;
  574.   }//switch
  575.   signal->theData[0] = sigKey;
  576.   signal->theData[1] = 3;
  577.   signal->theData[2] = 2;
  578.   signal->theData[3] = ZSTARTPHASE1;
  579.   signal->theData[4] = 255;
  580.   sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB);
  581.   return;
  582. }//Dbtup::execSTTOR()
  584. /************************************************************************************************/
  585. // SIZE_ALTREP INITIALIZE DATA STRUCTURES, FILES AND DS VARIABLES, GET READY FOR EXTERNAL 
  586. // CONNECTIONS.
  587. /************************************************************************************************/
  588. void Dbtup::execREAD_CONFIG_REQ(Signal* signal) 
  589. {
  590.   const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
  591.   Uint32 ref = req->senderRef;
  592.   Uint32 senderData = req->senderData;
  593.   ndbrequire(req->noOfParameters == 0);
  594.   
  595.   ljamEntry();
  597.   const ndb_mgm_configuration_iterator * p = 
  598.     theConfiguration.getOwnConfigIterator();
  599.   ndbrequire(p != 0);
  600.   
  601.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_FRAG, &cnoOfFragrec));
  603.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_OP_RECS, &cnoOfOprec));
  604.   
  605.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_PAGE, &cnoOfPage));
  606.   Uint32 noOfTriggers= 0;
  607.   
  608.   Uint32 tmp= 0;
  609.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_PAGE_RANGE, &tmp));
  610.   initPageRangeSize(tmp);
  611.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_TABLE, &cnoOfTablerec));
  612.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_TABLE_DESC, 
  613. &cnoOfTabDescrRec));
  614.   Uint32 noOfStoredProc;
  615.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_STORED_PROC, 
  616. &noOfStoredProc));
  617.   ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_TRIGGERS, 
  618. &noOfTriggers));
  620.   cnoOfTabDescrRec = (cnoOfTabDescrRec & 0xFFFFFFF0) + 16;
  621.   c_storedProcPool.setSize(noOfStoredProc);
  622.   c_buildIndexPool.setSize(c_noOfBuildIndexRec);
  623.   c_triggerPool.setSize(noOfTriggers);
  625.   initRecords();
  626.   czero = 0;
  627.   cminusOne = czero - 1;
  628.   clastBitMask = 1;
  629.   clastBitMask = clastBitMask << 31;
  630.   cnoOfLocalLogInfo = 0;
  631.   cnoFreeUndoSeg = 0;
  633.   initialiseRecordsLab(signal, 0, ref, senderData);
  635.   clblPagesPerTick = 50;
  636.   ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_TUP_SR, 
  637.     &clblPagesPerTick);
  639.   clblPagesPerTickAfterSr = 50;
  640.   ndb_mgm_get_int_parameter(p, CFG_DB_LCP_DISC_PAGES_TUP, 
  641.     &clblPagesPerTickAfterSr);
  643. }//Dbtup::execSIZEALT_REP()
  645. void Dbtup::initRecords() 
  646. {
  647.   // Records with dynamic sizes
  648.   attrbufrec = (Attrbufrec*)allocRecord("Attrbufrec", 
  649. sizeof(Attrbufrec), 
  650. cnoOfAttrbufrec);
  652.   checkpointInfo = (CheckpointInfo*)allocRecord("CheckpointInfo",
  653. sizeof(CheckpointInfo), 
  654. cnoOfLcpRec);
  656.   diskBufferSegmentInfo = (DiskBufferSegmentInfo*)
  657.     allocRecord("DiskBufferSegmentInfo",
  658. sizeof(DiskBufferSegmentInfo), 
  659. cnoOfConcurrentWriteOp);
  661.   fragoperrec = (Fragoperrec*)allocRecord("Fragoperrec",
  662.   sizeof(Fragoperrec),
  663.   cnoOfFragoprec);
  665.   fragrecord = (Fragrecord*)allocRecord("Fragrecord",
  666. sizeof(Fragrecord), 
  667. cnoOfFragrec);
  669.   hostBuffer = (HostBuffer*)allocRecord("HostBuffer",
  670. sizeof(HostBuffer), 
  671. MAX_NODES);
  673.   localLogInfo = (LocalLogInfo*)allocRecord("LocalLogInfo",
  674.     sizeof(LocalLogInfo), 
  675.     cnoOfParallellUndoFiles);
  677.   operationrec = (Operationrec*)allocRecord("Operationrec",
  678.     sizeof(Operationrec),
  679.     cnoOfOprec);
  681.   page = (Page*)allocRecord("Page", 
  682.     sizeof(Page), 
  683.     cnoOfPage,
  684.     false);
  685.   
  686.   pageRange = (PageRange*)allocRecord("PageRange",
  687.       sizeof(PageRange), 
  688.       cnoOfPageRangeRec);
  689.   
  690.   pendingFileOpenInfo = (PendingFileOpenInfo*)
  691.     allocRecord("PendingFileOpenInfo",
  692. sizeof(PendingFileOpenInfo), 
  693. cnoOfConcurrentOpenOp);
  694.   
  695.   restartInfoRecord = (RestartInfoRecord*)
  696.     allocRecord("RestartInfoRecord",
  697. sizeof(RestartInfoRecord),
  698. cnoOfRestartInfoRec);
  700.   
  701.   tablerec = (Tablerec*)allocRecord("Tablerec",
  702.     sizeof(Tablerec), 
  703.     cnoOfTablerec);
  704.   
  705.   for(unsigned i = 0; i<cnoOfTablerec; i++) {
  706.     void * p = &tablerec[i];
  707.     new (p) Tablerec(c_triggerPool);
  708.   }
  709.   
  710.   tableDescriptor = (TableDescriptor*)
  711.     allocRecord("TableDescriptor",
  712. sizeof(TableDescriptor),
  713. cnoOfTabDescrRec);
  714.   
  715.   undoPage = (UndoPage*)allocRecord("UndoPage",
  716.     sizeof(UndoPage),
  717.     cnoOfUndoPage);
  718.   
  719.   
  720.   // Initialize BAT for interface to file system
  721.   NewVARIABLE* bat = allocateBat(3);
  722.   bat[1].WA = &page->pageWord[0];
  723.   bat[1].nrr = cnoOfPage;
  724.   bat[1].ClusterSize = sizeof(Page);
  725.   bat[1].bits.q = 13; /* 8192 words/page */
  726.   bat[1].bits.v = 5;
  727.   bat[2].WA = &undoPage->undoPageWord[0];
  728.   bat[2].nrr = cnoOfUndoPage;
  729.   bat[2].ClusterSize = sizeof(UndoPage);
  730.   bat[2].bits.q = 13; /* 8192 words/page */
  731.   bat[2].bits.v = 5;
  732. }//Dbtup::initRecords()
  734. void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
  735.  Uint32 retRef, Uint32 retData) 
  736. {
  737.   switch (switchData) {
  738.   case 0:
  739.     ljam();
  740.     initializeHostBuffer();
  741.     break;
  742.   case 1:
  743.     ljam();
  744.     initializeOperationrec();
  745.     break;
  746.   case 2:
  747.     ljam();
  748.     initializePage();
  749.     break;
  750.   case 3:
  751.     ljam();
  752.     initializeUndoPage();
  753.     break;
  754.   case 4:
  755.     ljam();
  756.     initializeTablerec();
  757.     break;
  758.   case 5:
  759.     ljam();
  760.     initializeCheckpointInfoRec();
  761.     break;
  762.   case 6:
  763.     ljam();
  764.     initializeFragrecord();
  765.     break;
  766.   case 7:
  767.     ljam();
  768.     initializeFragoperrec();
  769.     break;
  770.   case 8:
  771.     ljam();
  772.     initializePageRange();
  773.     break;
  774.   case 9:
  775.     ljam();
  776.     initializeTabDescr();
  777.     break;
  778.   case 10:
  779.     ljam();
  780.     initializeDiskBufferSegmentRecord();
  781.     break;
  782.   case 11:
  783.     ljam();
  784.     initializeLocalLogInfo();
  785.     break;
  786.   case 12:
  787.     ljam();
  788.     initializeAttrbufrec();
  789.     break;
  790.   case 13:
  791.     ljam();
  792.     initializePendingFileOpenInfoRecord();
  793.     break;
  794.   case 14:
  795.     ljam();
  796.     initializeRestartInfoRec();
  798.     {
  799.       ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
  800.       conf->senderRef = reference();
  801.       conf->senderData = retData;
  802.       sendSignal(retRef, GSN_READ_CONFIG_CONF, signal, 
  803.  ReadConfigConf::SignalLength, JBB);
  804.     }
  805.     return;
  806.   default:
  807.     ndbrequire(false);
  808.     break;
  809.   }//switch
  810.   signal->theData[0] = ZINITIALISE_RECORDS;
  811.   signal->theData[1] = switchData + 1;
  812.   signal->theData[2] = retRef;
  813.   signal->theData[3] = retData;
  814.   sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB);
  815.   return;
  816. }//Dbtup::initialiseRecordsLab()
  818. void Dbtup::execNDB_STTOR(Signal* signal) 
  819. {
  820.   ljamEntry();
  821.   cndbcntrRef = signal->theData[0];
  822.   Uint32 ownNodeId = signal->theData[1];
  823.   Uint32 startPhase = signal->theData[2];
  824.   switch (startPhase) {
  825.   case ZSTARTPHASE1:
  826.     ljam();
  827.     cownNodeId = ownNodeId;
  828.     cownref = calcTupBlockRef(ownNodeId);
  829.     break;
  830.   case ZSTARTPHASE2:
  831.     ljam();
  832.     break;
  833.   case ZSTARTPHASE3:
  834.     ljam();
  835.     startphase3Lab(signal, ~0, ~0);
  836.     break;
  837.   case ZSTARTPHASE4:
  838.     ljam();
  839.     break;
  840.   case ZSTARTPHASE6:
  841.     ljam();
  842. /*****************************************/
  843. /*       NOW SET THE DISK WRITE SPEED TO */
  844. /*       PAGES PER TICK AFTER SYSTEM     */
  845. /*       RESTART.                        */
  846. /*****************************************/
  847.     clblPagesPerTick = clblPagesPerTickAfterSr;
  849.     signal->theData[0] = ZREPORT_MEMORY_USAGE;
  850.     sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 2000, 1);    
  851.     break;
  852.   default:
  853.     ljam();
  854.     break;
  855.   }//switch
  856.   signal->theData[0] = cownref;
  857.   sendSignal(cndbcntrRef, GSN_NDB_STTORRY, signal, 1, JBB);
  858. }//Dbtup::execNDB_STTOR()
  860. void Dbtup::startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2) 
  861. {
  862.   clblPageCounter = clblPagesPerTick;
  863.   signal->theData[0] = ZLOAD_BAL_LCP_TIMER;
  864.   sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 100, 1);
  865. }//Dbtup::startphase3Lab()
  867. void Dbtup::initializeAttrbufrec() 
  868. {
  869.   AttrbufrecPtr attrBufPtr;
  870.   for (attrBufPtr.i = 0;
  871.        attrBufPtr.i < cnoOfAttrbufrec; attrBufPtr.i++) {
  872.     refresh_watch_dog();
  873.     ptrAss(attrBufPtr, attrbufrec);
  874.     attrBufPtr.p->attrbuf[ZBUF_NEXT] = attrBufPtr.i + 1;
  875.   }//for
  876.   attrBufPtr.i = cnoOfAttrbufrec - 1;
  877.   ptrAss(attrBufPtr, attrbufrec);
  878.   attrBufPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
  879.   cfirstfreeAttrbufrec = 0;
  880.   cnoFreeAttrbufrec = cnoOfAttrbufrec;
  881. }//Dbtup::initializeAttrbufrec()
  883. void Dbtup::initializeCheckpointInfoRec() 
  884. {
  885.   CheckpointInfoPtr checkpointInfoPtr;
  886.   for (checkpointInfoPtr.i = 0;
  887.        checkpointInfoPtr.i < cnoOfLcpRec; checkpointInfoPtr.i++) {
  888.     ptrAss(checkpointInfoPtr, checkpointInfo);
  889.     checkpointInfoPtr.p->lcpNextRec = checkpointInfoPtr.i + 1;
  890.   }//for
  891.   checkpointInfoPtr.i = cnoOfLcpRec - 1;
  892.   ptrAss(checkpointInfoPtr, checkpointInfo);
  893.   checkpointInfoPtr.p->lcpNextRec = RNIL;
  894.   cfirstfreeLcp = 0;
  895. }//Dbtup::initializeCheckpointInfoRec()
  897. void Dbtup::initializeDiskBufferSegmentRecord() 
  898. {
  899.   DiskBufferSegmentInfoPtr diskBufferSegmentPtr;
  900.   for (diskBufferSegmentPtr.i = 0;
  901.        diskBufferSegmentPtr.i < cnoOfConcurrentWriteOp; diskBufferSegmentPtr.i++) {
  902.     ptrAss(diskBufferSegmentPtr, diskBufferSegmentInfo);
  903.     diskBufferSegmentPtr.p->pdxNextRec = diskBufferSegmentPtr.i + 1;
  904.     diskBufferSegmentPtr.p->pdxBuffertype = NOT_INITIALIZED;
  905.   }//for
  906.   diskBufferSegmentPtr.i = cnoOfConcurrentWriteOp - 1;
  907.   ptrAss(diskBufferSegmentPtr, diskBufferSegmentInfo);
  908.   diskBufferSegmentPtr.p->pdxNextRec = RNIL;
  909.   cfirstfreePdx = 0;
  910. }//Dbtup::initializeDiskBufferSegmentRecord()
  912. void Dbtup::initializeFragoperrec() 
  913. {
  914.   FragoperrecPtr fragoperPtr;
  915.   for (fragoperPtr.i = 0; fragoperPtr.i < cnoOfFragoprec; fragoperPtr.i++) {
  916.     ptrAss(fragoperPtr, fragoperrec);
  917.     fragoperPtr.p->nextFragoprec = fragoperPtr.i + 1;
  918.   }//for
  919.   fragoperPtr.i = cnoOfFragoprec - 1;
  920.   ptrAss(fragoperPtr, fragoperrec);
  921.   fragoperPtr.p->nextFragoprec = RNIL;
  922.   cfirstfreeFragopr = 0;
  923. }//Dbtup::initializeFragoperrec()
  925. void Dbtup::initializeFragrecord() 
  926. {
  927.   FragrecordPtr regFragPtr;
  928.   for (regFragPtr.i = 0; regFragPtr.i < cnoOfFragrec; regFragPtr.i++) {
  929.     refresh_watch_dog();
  930.     ptrAss(regFragPtr, fragrecord);
  931.     regFragPtr.p->nextfreefrag = regFragPtr.i + 1;
  932.     regFragPtr.p->checkpointVersion = RNIL;
  933.     regFragPtr.p->firstusedOprec = RNIL;
  934.     regFragPtr.p->lastusedOprec = RNIL;
  935.     regFragPtr.p->fragStatus = IDLE;
  936.   }//for
  937.   regFragPtr.i = cnoOfFragrec - 1;
  938.   ptrAss(regFragPtr, fragrecord);
  939.   regFragPtr.p->nextfreefrag = RNIL;
  940.   cfirstfreefrag = 0;
  941. }//Dbtup::initializeFragrecord()
  943. void Dbtup::initializeHostBuffer() 
  944. {
  945.   Uint32 hostId;
  946.   cpackedListIndex = 0;
  947.   for (hostId = 0; hostId < MAX_NODES; hostId++) {
  948.     hostBuffer[hostId].inPackedList = false;
  949.     hostBuffer[hostId].noOfPacketsTA = 0;
  950.     hostBuffer[hostId].packetLenTA = 0;
  951.   }//for
  952. }//Dbtup::initializeHostBuffer()
  954. void Dbtup::initializeLocalLogInfo() 
  955. {
  956.   LocalLogInfoPtr localLogInfoPtr;
  957.   for (localLogInfoPtr.i = 0;
  958.        localLogInfoPtr.i < cnoOfParallellUndoFiles; localLogInfoPtr.i++) {
  959.     ptrAss(localLogInfoPtr, localLogInfo);
  960.     localLogInfoPtr.p->lliActiveLcp = 0;
  961.     localLogInfoPtr.p->lliUndoFileHandle = RNIL;
  962.   }//for
  963. }//Dbtup::initializeLocalLogInfo()
  965. void Dbtup::initializeOperationrec() 
  966. {
  967.   OperationrecPtr regOpPtr;
  968.   for (regOpPtr.i = 0; regOpPtr.i < cnoOfOprec; regOpPtr.i++) {
  969.     refresh_watch_dog();
  970.     ptrAss(regOpPtr, operationrec);
  971.     regOpPtr.p->firstAttrinbufrec = RNIL;
  972.     regOpPtr.p->lastAttrinbufrec = RNIL;
  973.     regOpPtr.p->prevOprecInList = RNIL;
  974.     regOpPtr.p->nextOprecInList = regOpPtr.i + 1;
  975.     regOpPtr.p->optype = ZREAD;
  976.     regOpPtr.p->inFragList = ZFALSE;
  977.     regOpPtr.p->inActiveOpList = ZFALSE;
  978. /* FOR ABORT HANDLING BEFORE ANY SUCCESSFUL OPERATION */
  979.     regOpPtr.p->transstate = DISCONNECTED;
  980.     regOpPtr.p->storedProcedureId = ZNIL;
  981.     regOpPtr.p->prevActiveOp = RNIL;
  982.     regOpPtr.p->nextActiveOp = RNIL;
  983.     regOpPtr.p->tupVersion = ZNIL;
  984.     regOpPtr.p->deleteInsertFlag = 0;
  985.   }//for
  986.   regOpPtr.i = cnoOfOprec - 1;
  987.   ptrAss(regOpPtr, operationrec);
  988.   regOpPtr.p->nextOprecInList = RNIL;
  989.   cfirstfreeOprec = 0;
  990. }//Dbtup::initializeOperationrec()
  992. void Dbtup::initializePendingFileOpenInfoRecord() 
  993. {
  994.   PendingFileOpenInfoPtr pendingFileOpenInfoPtr;
  995.   for (pendingFileOpenInfoPtr.i = 0;
  996.        pendingFileOpenInfoPtr.i < cnoOfConcurrentOpenOp; pendingFileOpenInfoPtr.i++) {
  997.     ptrAss(pendingFileOpenInfoPtr, pendingFileOpenInfo);
  998.     pendingFileOpenInfoPtr.p->pfoNextRec = pendingFileOpenInfoPtr.i + 1;
  999.   }//for
  1000.   pendingFileOpenInfoPtr.i = cnoOfConcurrentOpenOp - 1;
  1001.   ptrAss(pendingFileOpenInfoPtr, pendingFileOpenInfo);
  1002.   pendingFileOpenInfoPtr.p->pfoNextRec = RNIL;
  1003.   cfirstfreePfo = 0;
  1004. }//Dbtup::initializePendingFileOpenInfoRecord()
  1006. void Dbtup::initializeRestartInfoRec() 
  1007. {
  1008.   RestartInfoRecordPtr restartInfoPtr;
  1009.   for (restartInfoPtr.i = 0; restartInfoPtr.i < cnoOfRestartInfoRec; restartInfoPtr.i++) {
  1010.     ptrAss(restartInfoPtr, restartInfoRecord);
  1011.     restartInfoPtr.p->sriNextRec = restartInfoPtr.i + 1;
  1012.   }//for
  1013.   restartInfoPtr.i = cnoOfRestartInfoRec - 1;
  1014.   ptrAss(restartInfoPtr, restartInfoRecord);
  1015.   restartInfoPtr.p->sriNextRec = RNIL;
  1016.   cfirstfreeSri = 0;
  1017. }//Dbtup::initializeRestartInfoRec()
  1019. void Dbtup::initializeTablerec() 
  1020. {
  1021.   TablerecPtr regTabPtr;
  1022.   for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) {
  1023.     ljam();
  1024.     refresh_watch_dog();
  1025.     ptrAss(regTabPtr, tablerec);
  1026.     initTab(regTabPtr.p);
  1027.   }//for
  1028. }//Dbtup::initializeTablerec()
  1030. void
  1031. Dbtup::initTab(Tablerec* const regTabPtr)
  1032. {
  1033.   for (Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE); i++) {
  1034.     regTabPtr->fragid[i] = RNIL;
  1035.     regTabPtr->fragrec[i] = RNIL;
  1036.   }//for
  1037.   regTabPtr->readFunctionArray = NULL;
  1038.   regTabPtr->updateFunctionArray = NULL;
  1039.   regTabPtr->charsetArray = NULL;
  1041.   regTabPtr->tabDescriptor = RNIL;
  1042.   regTabPtr->attributeGroupDescriptor = RNIL;
  1043.   regTabPtr->readKeyArray = RNIL;
  1045.   regTabPtr->checksumIndicator = false;
  1046.   regTabPtr->GCPIndicator = false;
  1048.   regTabPtr->noOfAttr = 0;
  1049.   regTabPtr->noOfKeyAttr = 0;
  1050.   regTabPtr->noOfNewAttr = 0;
  1051.   regTabPtr->noOfAttributeGroups = 0;
  1053.   regTabPtr->tupheadsize = 0;
  1054.   regTabPtr->tupNullIndex = 0;
  1055.   regTabPtr->tupNullWords = 0;
  1056.   regTabPtr->tupChecksumIndex = 0;
  1057.   regTabPtr->tupGCPIndex = 0;
  1059.   regTabPtr->m_dropTable.tabUserPtr = RNIL;
  1060.   regTabPtr->m_dropTable.tabUserRef = 0;
  1061.   regTabPtr->tableStatus = NOT_DEFINED;
  1063.   // Clear trigger data
  1064.   if (!regTabPtr->afterInsertTriggers.isEmpty())
  1065.     regTabPtr->afterInsertTriggers.release();
  1066.   if (!regTabPtr->afterDeleteTriggers.isEmpty())
  1067.     regTabPtr->afterDeleteTriggers.release();
  1068.   if (!regTabPtr->afterUpdateTriggers.isEmpty())
  1069.     regTabPtr->afterUpdateTriggers.release();
  1070.   if (!regTabPtr->subscriptionInsertTriggers.isEmpty())
  1071.     regTabPtr->subscriptionInsertTriggers.release();
  1072.   if (!regTabPtr->subscriptionDeleteTriggers.isEmpty())
  1073.     regTabPtr->subscriptionDeleteTriggers.release();
  1074.   if (!regTabPtr->subscriptionUpdateTriggers.isEmpty())
  1075.     regTabPtr->subscriptionUpdateTriggers.release();
  1076.   if (!regTabPtr->constraintUpdateTriggers.isEmpty())
  1077.     regTabPtr->constraintUpdateTriggers.release();
  1078.   if (!regTabPtr->tuxCustomTriggers.isEmpty())
  1079.     regTabPtr->tuxCustomTriggers.release();
  1080. }//Dbtup::initTab()
  1082. void Dbtup::initializeTabDescr() 
  1083. {
  1084.   TableDescriptorPtr regTabDesPtr;
  1085.   for (Uint32 i = 0; i < 16; i++) {
  1086.     cfreeTdList[i] = RNIL;
  1087.   }//for
  1088.   for (regTabDesPtr.i = 0; regTabDesPtr.i < cnoOfTabDescrRec; regTabDesPtr.i++) {
  1089.     refresh_watch_dog();
  1090.     ptrAss(regTabDesPtr, tableDescriptor);
  1091.     regTabDesPtr.p->tabDescr = RNIL;
  1092.   }//for
  1093.   freeTabDescr(0, cnoOfTabDescrRec);
  1094. }//Dbtup::initializeTabDescr()
  1096. void Dbtup::initializeUndoPage() 
  1097. {
  1098.   UndoPagePtr undoPagep;
  1099.   for (undoPagep.i = 0;
  1100.        undoPagep.i < cnoOfUndoPage;
  1101.        undoPagep.i = undoPagep.i + ZUB_SEGMENT_SIZE) {
  1102.     refresh_watch_dog();
  1103.     ptrAss(undoPagep, undoPage);
  1104.     undoPagep.p->undoPageWord[ZPAGE_NEXT_POS] = undoPagep.i + 
  1105.                                                  ZUB_SEGMENT_SIZE;
  1106.     cnoFreeUndoSeg++;
  1107.   }//for
  1108.   undoPagep.i = cnoOfUndoPage - ZUB_SEGMENT_SIZE;
  1109.   ptrAss(undoPagep, undoPage);
  1110.   undoPagep.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL;
  1111.   cfirstfreeUndoSeg = 0;
  1112. }//Dbtup::initializeUndoPage()
  1114. /* ---------------------------------------------------------------- */
  1115. /* ---------------------------------------------------------------- */
  1116. /* --------------- CONNECT/DISCONNECT MODULE ---------------------- */
  1117. /* ---------------------------------------------------------------- */
  1118. /* ---------------------------------------------------------------- */
  1119. void Dbtup::execTUPSEIZEREQ(Signal* signal)
  1120. {
  1121.   OperationrecPtr regOperPtr;
  1122.   ljamEntry();
  1123.   Uint32 userPtr = signal->theData[0];
  1124.   BlockReference userRef = signal->theData[1];
  1125.   if (cfirstfreeOprec != RNIL) {
  1126.     ljam();
  1127.     seizeOpRec(regOperPtr);
  1128.   } else {
  1129.     ljam();
  1130.     signal->theData[0] = userPtr;
  1131.     signal->theData[1] = ZGET_OPREC_ERROR;
  1132.     sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB);
  1133.     return;
  1134.   }//if
  1135.   regOperPtr.p->optype = ZREAD;
  1136.   initOpConnection(regOperPtr.p, 0);
  1137.   regOperPtr.p->userpointer = userPtr;
  1138.   regOperPtr.p->userblockref = userRef;
  1139.   signal->theData[0] = regOperPtr.p->userpointer;
  1140.   signal->theData[1] = regOperPtr.i;
  1141.   sendSignal(userRef, GSN_TUPSEIZECONF, signal, 2, JBB);
  1142.   return;
  1143. }//Dbtup::execTUPSEIZEREQ()
  1145. #define printFragment(t){ for(Uint32 i = 0; i < (2 * MAX_FRAG_PER_NODE);i++){
  1146.   ndbout_c("table = %d fragid[%d] = %d fragrec[%d] = %d", 
  1147.            t.i, t.p->fragid[i], i, t.p->fragrec[i]); }}
  1149. void Dbtup::execTUPRELEASEREQ(Signal* signal) 
  1150. {
  1151.   OperationrecPtr regOperPtr;
  1152.   ljamEntry();
  1153.   regOperPtr.i = signal->theData[0];
  1154.   ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec);
  1155.   regOperPtr.p->transstate = DISCONNECTED;
  1156.   regOperPtr.p->nextOprecInList = cfirstfreeOprec;
  1157.   cfirstfreeOprec = regOperPtr.i;
  1158.   signal->theData[0] = regOperPtr.p->userpointer;
  1159.   sendSignal(regOperPtr.p->userblockref, GSN_TUPRELEASECONF, signal, 1, JBB);
  1160.   return;
  1161. }//Dbtup::execTUPRELEASEREQ()
  1163. /* ---------------------------------------------------------------- */
  1164. /* ---------------- FREE_DISK_BUFFER_SEGMENT_RECORD --------------- */
  1165. /* ---------------------------------------------------------------- */
  1166. /*                                                                  */
  1167. /* THIS ROUTINE DEALLOCATES A DISK SEGMENT AND ITS DATA PAGES       */
  1168. /*                                                                  */
  1169. /* INPUT:  DISK_BUFFER_SEGMENT_PTR    THE DISK SEGMENT              */
  1170. /*                                                                  */
  1171. /* -----------------------------------------------------------------*/
  1172. void Dbtup::freeDiskBufferSegmentRecord(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) 
  1173. {
  1174.   switch (dbsiPtr.p->pdxBuffertype) {
  1175.   case UNDO_PAGES:
  1176.   case COMMON_AREA_PAGES:
  1177.     ljam();
  1178.     freeUndoBufferPages(signal, dbsiPtr);
  1179.     break;
  1180.   case UNDO_RESTART_PAGES:
  1181.     ljam();
  1182.     dbsiPtr.p->pdxDataPage[0] = dbsiPtr.p->pdxUndoBufferSet[0];
  1183.     freeUndoBufferPages(signal, dbsiPtr);
  1184.     dbsiPtr.p->pdxDataPage[0] = dbsiPtr.p->pdxUndoBufferSet[1];
  1185.     freeUndoBufferPages(signal, dbsiPtr);
  1186.     break;
  1187.   default:
  1188.     ndbrequire(false);
  1189.     break;
  1190.   }//switch
  1191.   releaseDiskBufferSegmentRecord(dbsiPtr);
  1192. }//Dbtup::freeDiskBufferSegmentRecord()
  1194. /* ---------------------------------------------------------------- */
  1195. /* -------------------- FREE_UNDO_BUFFER_PAGES -------------------- */
  1196. /* ---------------------------------------------------------------- */
  1197. /*                                                                  */
  1198. /* THIS ROUTINE DEALLOCATES A SEGMENT OF UNDO PAGES                 */
  1199. /*                                                                  */
  1200. /* INPUT:  UNDO_PAGEP    POINTER TO FIRST PAGE IN SEGMENT          */
  1201. /*                                                                  */
  1202. /* -----------------------------------------------------------------*/
  1203. void Dbtup::freeUndoBufferPages(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) 
  1204. {
  1205.   UndoPagePtr undoPagePtr;
  1207.   undoPagePtr.i = dbsiPtr.p->pdxDataPage[0];
  1208.   ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage);
  1209.   undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = cfirstfreeUndoSeg;
  1210.   cfirstfreeUndoSeg = undoPagePtr.i;
  1211.   cnoFreeUndoSeg++;
  1212.   if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) {
  1213.     EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_UNBLOCK, signal, 1);
  1214.     ljamEntry();
  1215.   }//if
  1216. }//Dbtup::freeUndoBufferPages()
  1218. void Dbtup::releaseCheckpointInfoRecord(CheckpointInfoPtr ciPtr) 
  1219. {
  1220.   ciPtr.p->lcpNextRec = cfirstfreeLcp;
  1221.   cfirstfreeLcp = ciPtr.i;
  1222. }//Dbtup::releaseCheckpointInfoRecord()
  1224. void Dbtup::releaseDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr dbsiPtr) 
  1225. {
  1226.   dbsiPtr.p->pdxNextRec = cfirstfreePdx;
  1227.   cfirstfreePdx = dbsiPtr.i;
  1228. }//Dbtup::releaseDiskBufferSegmentRecord()
  1230. void Dbtup::releaseFragrec(FragrecordPtr regFragPtr) 
  1231. {
  1232.   regFragPtr.p->nextfreefrag = cfirstfreefrag;
  1233.   cfirstfreefrag = regFragPtr.i;
  1234. }//Dbtup::releaseFragrec()
  1236. void Dbtup::releasePendingFileOpenInfoRecord(PendingFileOpenInfoPtr pfoPtr) 
  1237. {
  1238.   pfoPtr.p->pfoNextRec = cfirstfreePfo;
  1239.   cfirstfreePfo = pfoPtr.i;
  1240. }//Dbtup::releasePendingFileOpenInfoRecord()
  1242. void Dbtup::releaseRestartInfoRecord(RestartInfoRecordPtr riPtr) 
  1243. {
  1244.   riPtr.p->sriNextRec = cfirstfreeSri;
  1245.   cfirstfreeSri = riPtr.i;
  1246. }//Dbtup::releaseRestartInfoRecord()
  1248. void Dbtup::seizeCheckpointInfoRecord(CheckpointInfoPtr& ciPtr) 
  1249. {
  1250.   ciPtr.i = cfirstfreeLcp;
  1251.   ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  1252.   cfirstfreeLcp = ciPtr.p->lcpNextRec;
  1253.   ciPtr.p->lcpNextRec = RNIL;
  1254. }//Dbtup::seizeCheckpointInfoRecord()
  1256. void Dbtup::seizeDiskBufferSegmentRecord(DiskBufferSegmentInfoPtr& dbsiPtr) 
  1257. {
  1258.   dbsiPtr.i = cfirstfreePdx;
  1259.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  1260.   cfirstfreePdx = dbsiPtr.p->pdxNextRec;
  1261.   dbsiPtr.p->pdxNextRec = RNIL;
  1262.   for (Uint32 i = 0; i < 16; i++) {
  1263.     dbsiPtr.p->pdxDataPage[i] = RNIL;
  1264.   }//for
  1265.   dbsiPtr.p->pdxCheckpointInfoP = RNIL;
  1266.   dbsiPtr.p->pdxRestartInfoP = RNIL;
  1267.   dbsiPtr.p->pdxLocalLogInfoP = RNIL;
  1268.   dbsiPtr.p->pdxFilePage = 0;
  1269.   dbsiPtr.p->pdxNumDataPages = 0;
  1270. }//Dbtup::seizeDiskBufferSegmentRecord()
  1272. void Dbtup::seizeOpRec(OperationrecPtr& regOperPtr) 
  1273. {
  1274.   regOperPtr.i = cfirstfreeOprec;
  1275.   ptrCheckGuard(regOperPtr, cnoOfOprec, operationrec);
  1276.   cfirstfreeOprec = regOperPtr.p->nextOprecInList;
  1277. }//Dbtup::seizeOpRec()
  1279. void Dbtup::seizePendingFileOpenInfoRecord(PendingFileOpenInfoPtr& pfoiPtr) 
  1280. {
  1281.   pfoiPtr.i = cfirstfreePfo;
  1282.   ptrCheckGuard(pfoiPtr, cnoOfConcurrentOpenOp, pendingFileOpenInfo);
  1283.   cfirstfreePfo = pfoiPtr.p->pfoNextRec;
  1284.   pfoiPtr.p->pfoNextRec = RNIL;
  1285. }//Dbtup::seizePendingFileOpenInfoRecord()
  1287. void Dbtup::execSET_VAR_REQ(Signal* signal) 
  1288. {
  1289. #if 0
  1290.   SetVarReq* const setVarReq = (SetVarReq*)signal->getDataPtrSend();
  1291.   ConfigParamId var = setVarReq->variable();
  1292.   int val = setVarReq->value();
  1294.   switch (var) {
  1296.   case NoOfDiskPagesToDiskAfterRestartTUP:
  1297.     clblPagesPerTick = val;
  1298.     sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB);
  1299.     break;
  1301.   case NoOfDiskPagesToDiskDuringRestartTUP:
  1302.     // Valid only during start so value not set.
  1303.     sendSignal(CMVMI_REF, GSN_SET_VAR_CONF, signal, 1, JBB);
  1304.     break;
  1306.   default:
  1307.     sendSignal(CMVMI_REF, GSN_SET_VAR_REF, signal, 1, JBB);
  1308.   } // switch
  1309. #endif
  1311. }//execSET_VAR_REQ()