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

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

MySQL数据库

开发平台：

Visual C++

DbtupLCP.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 <signaldata/FsConf.hpp>
  24. #include <signaldata/FsRef.hpp>
  26. #define ljam() { jamLine(10000 + __LINE__); }
  27. #define ljamEntry() { jamEntryLine(10000 + __LINE__); }
  29. /* ---------------------------------------------------------------- */
  30. /* ---------------------------------------------------------------- */
  31. /* -------------------- LOCAL CHECKPOINT MODULE ------------------- */
  32. /* ---------------------------------------------------------------- */
  33. /* ---------------------------------------------------------------- */
  34. void Dbtup::execTUP_PREPLCPREQ(Signal* signal) 
  35. {
  36.   CheckpointInfoPtr ciPtr;
  37.   DiskBufferSegmentInfoPtr dbsiPtr;
  38.   FragrecordPtr regFragPtr;
  39.   LocalLogInfoPtr lliPtr;
  40.   TablerecPtr regTabPtr;
  42.   ljamEntry();
  43.   Uint32 userptr = signal->theData[0];
  44.   BlockReference userblockref = signal->theData[1];
  45.   regTabPtr.i = signal->theData[2];
  46.   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  47.   Uint32 fragId = signal->theData[3];
  48.   Uint32 checkpointNumber = signal->theData[4];
  49.   cundoFileVersion = signal->theData[5];
  51.   getFragmentrec(regFragPtr, fragId, regTabPtr.p);
  52.   ndbrequire(regTabPtr.i != RNIL);
  53.   seizeCheckpointInfoRecord(ciPtr);
  55.   lliPtr.i = (cundoFileVersion << 2) + (regTabPtr.i & 0x3);
  56.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  57.   cnoOfDataPagesToDiskWithoutSynch = 0;
  59.   ciPtr.p->lcpDataFileHandle = RNIL;
  60.   ciPtr.p->lcpCheckpointVersion = checkpointNumber;
  61.   ciPtr.p->lcpLocalLogInfoP = lliPtr.i;
  62.   ciPtr.p->lcpFragmentP = regFragPtr.i; /* SET THE FRAGMENT              */
  63.   ciPtr.p->lcpFragmentId = fragId; /* SAVE THE FRAGMENT IDENTITY    */
  64.   ciPtr.p->lcpTabPtr = regTabPtr.i; /* SET THE TABLE POINTER         */
  65.   ciPtr.p->lcpBlockref = userblockref; /* SET THE BLOCK REFERENCE       */
  66.   ciPtr.p->lcpUserptr = userptr; /* SET THE USERPOINTER           */
  68.    /***************************************************************/
  69.    /* OPEN THE UNDO FILE FOR WRITE                                */
  70.    /* UPON FSOPENCONF                                             */
  71.    /***************************************************************/
  72.   if (lliPtr.p->lliActiveLcp == 0) {                  /* IS THE UNDO LOG FILE OPEN?    */
  73.     PendingFileOpenInfoPtr undoPfoiPtr;
  74.     UndoPagePtr regUndoPagePtr;
  76.     ljam();
  77.     lliPtr.p->lliPrevRecordId = 0;
  78.     lliPtr.p->lliLogFilePage = 0;
  79.     lliPtr.p->lliUndoPagesToDiskWithoutSynch = 0;
  80.     lliPtr.p->lliUndoWord = ZUNDO_PAGE_HEADER_SIZE;
  82.     seizeUndoBufferSegment(signal, regUndoPagePtr);
  83.     seizeDiskBufferSegmentRecord(dbsiPtr);
  84.     dbsiPtr.p->pdxBuffertype = UNDO_PAGES;
  85.     for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) {
  86.       dbsiPtr.p->pdxDataPage[i] = regUndoPagePtr.i + i;
  87.     }//for
  88.     dbsiPtr.p->pdxFilePage = lliPtr.p->lliLogFilePage;
  89.     lliPtr.p->lliUndoPage = regUndoPagePtr.i;
  90.     lliPtr.p->lliUndoBufferSegmentP = dbsiPtr.i;
  91.                                                 /* F LEVEL NOT USED              */
  92.     Uint32 fileType = 1;                 /* VERSION                       */
  93.     fileType = (fileType << 8) | 2;         /* .LOCLOG                       */
  94.     fileType = (fileType << 8) | 6;         /* D6                            */
  95.     fileType = (fileType << 8) | 0xff;         /* DON'T USE P DIRECTORY LEVEL   */
  96.     Uint32 fileFlag = 0x301;                 /* CREATE, WRITE ONLY, TRUNCATE  */
  98.     seizePendingFileOpenInfoRecord(undoPfoiPtr);
  99.     undoPfoiPtr.p->pfoOpenType = LCP_UNDO_FILE_WRITE;
  100.     undoPfoiPtr.p->pfoCheckpointInfoP = ciPtr.i;
  102.     signal->theData[0] = cownref;
  103.     signal->theData[1] = undoPfoiPtr.i;
  104.     signal->theData[2] = lliPtr.i;
  105.     signal->theData[3] = 0xFFFFFFFF;
  106.     signal->theData[4] = cundoFileVersion;
  107.     signal->theData[5] = fileType;
  108.     signal->theData[6] = fileFlag;
  109.     sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA);
  110.   }//if
  111.    /***************************************************************/
  112.    /* OPEN THE DATA FILE FOR WRITE                                */
  113.    /* THE FILE HANDLE WILL BE SET IN THE CHECKPOINT_INFO_RECORD   */
  114.    /* UPON FSOPENCONF                                             */
  115.    /***************************************************************/
  116.    /* OPEN THE DATA FILE IN THE FOLLOWING FORM              */
  117.    /* D5/DBTUP/T<TABID>/F<FRAGID>/S<CHECKPOINT_NUMBER>.DATA */
  119.   PendingFileOpenInfoPtr dataPfoiPtr;
  121.   Uint32 fileType = 1;                 /* VERSION                       */
  122.   fileType = (fileType << 8) | 0; /* .DATA                         */
  123.   fileType = (fileType << 8) | 5; /* D5                            */
  124.   fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL   */
  125.   Uint32 fileFlag = 0x301;         /* CREATE, WRITE ONLY, TRUNCATE  */
  127.   seizePendingFileOpenInfoRecord(dataPfoiPtr); /* SEIZE A NEW FILE OPEN INFO    */
  128.   if (lliPtr.p->lliActiveLcp == 0) {
  129.     ljam();
  130.     dataPfoiPtr.p->pfoOpenType = LCP_DATA_FILE_WRITE_WITH_UNDO;
  131.   } else {
  132.     ljam();
  133.     dataPfoiPtr.p->pfoOpenType = LCP_DATA_FILE_WRITE;
  134.   }//if
  135.   dataPfoiPtr.p->pfoCheckpointInfoP = ciPtr.i;
  137.    /* LET'S OPEN THE DATA FILE FOR WRITE */
  138.    /* INCREASE NUMBER OF ACTIVE CHECKPOINTS */
  139.   lliPtr.p->lliActiveLcp = 1;
  140.   signal->theData[0] = cownref;
  141.   signal->theData[1] = dataPfoiPtr.i;
  142.   signal->theData[2] = ciPtr.p->lcpTabPtr;
  143.   signal->theData[3] = ciPtr.p->lcpFragmentId;
  144.   signal->theData[4] = ciPtr.p->lcpCheckpointVersion;
  145.   signal->theData[5] = fileType;
  146.   signal->theData[6] = fileFlag;
  147.   sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA);
  148.   return;
  149. }//Dbtup::execTUP_PREPLCPREQ()
  151. /* ---------------------------------------------------------------- */
  152. /* ------------------------ START CHECKPOINT  --------------------- */
  153. /* ---------------------------------------------------------------- */
  154. void Dbtup::execTUP_LCPREQ(Signal* signal) 
  155. {
  156.   CheckpointInfoPtr ciPtr;
  157.   DiskBufferSegmentInfoPtr dbsiPtr;
  158.   FragrecordPtr regFragPtr;
  159.   LocalLogInfoPtr lliPtr;
  161.   ljamEntry();
  162. //  Uint32 userptr = signal->theData[0];
  163. //  BlockReference userblockref = signal->theData[1];
  164.   ciPtr.i = signal->theData[2];
  166.   ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  167.   regFragPtr.i = ciPtr.p->lcpFragmentP;
  168.   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  170. /* ---------------------------------------------------------------- */
  171. /*       ASSIGNING A VALUE DIFFERENT FROM RNIL TO CHECKPOINT VERSION*/
  172. /*       TRIGGERS THAT UNDO LOGGING WILL START FOR THIS FRAGMENT.   */
  173. /*       WE ASSIGN IT THE POINTER TO THE CHECKPOINT RECORD FOR      */
  174. /*       OPTIMISATION OF THE WRITING OF THE UNDO LOG.               */
  175. /* ---------------------------------------------------------------- */
  176.   regFragPtr.p->checkpointVersion = ciPtr.p->lcpLocalLogInfoP; /* MARK START OF UNDO LOGGING */
  178.   regFragPtr.p->maxPageWrittenInCheckpoint = getNoOfPages(regFragPtr.p);
  179.   regFragPtr.p->minPageNotWrittenInCheckpoint = 0;
  180.   ndbrequire(getNoOfPages(regFragPtr.p) > 0);
  181.   allocDataBufferSegment(signal, dbsiPtr);
  183.   dbsiPtr.p->pdxNumDataPages =  0;
  184.   dbsiPtr.p->pdxFilePage = 1;
  185.   ciPtr.p->lcpDataBufferSegmentP = dbsiPtr.i;
  186.   dbsiPtr.p->pdxCheckpointInfoP = ciPtr.i;
  187.   ciPtr.p->lcpNoOfPages = getNoOfPages(regFragPtr.p);
  188.   ciPtr.p->lcpNoCopyPagesAlloc = regFragPtr.p->noCopyPagesAlloc;
  189.   ciPtr.p->lcpEmptyPrimPage = regFragPtr.p->emptyPrimPage;
  190.   ciPtr.p->lcpThFreeFirst = regFragPtr.p->thFreeFirst;
  191.   ciPtr.p->lcpThFreeCopyFirst = regFragPtr.p->thFreeCopyFirst;
  192.   lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
  193.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  194. /* ---------------------------------------------------------------- */
  195. /* --- PERFORM A COPY OF THE TABLE DESCRIPTOR FOR THIS FRAGMENT --- */
  196. /* ---------------------------------------------------------------- */
  197.   cprAddLogHeader(signal,
  198.                   lliPtr.p,
  199.                   ZTABLE_DESCRIPTOR,
  200.                   ciPtr.p->lcpTabPtr,
  201.                   ciPtr.p->lcpFragmentId);
  203. /* ---------------------------------------------------------------- */
  204. /*       CONTINUE WITH SAVING ACTIVE OPERATIONS AFTER A REAL-TIME   */
  205. /*       BREAK.                                                     */
  206. /* ---------------------------------------------------------------- */
  207.   ciPtr.p->lcpTmpOperPtr = regFragPtr.p->firstusedOprec;
  208.   lcpSaveCopyListLab(signal, ciPtr);
  209.   return;
  210. }//Dbtup::execTUP_LCPREQ()
  212. void Dbtup::allocDataBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr) 
  213. {
  214.   UndoPagePtr regUndoPagePtr;
  216.   seizeDiskBufferSegmentRecord(dbsiPtr);
  217.   dbsiPtr.p->pdxBuffertype = COMMON_AREA_PAGES;
  218.   ndbrequire(cfirstfreeUndoSeg != RNIL);
  219.   if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) {
  220.     EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1);
  221.     ljamEntry();
  222.   }//if
  223.   cnoFreeUndoSeg--;
  224.   ndbrequire(cnoFreeUndoSeg >= 0);
  226.   regUndoPagePtr.i = cfirstfreeUndoSeg;
  227.   ptrCheckGuard(regUndoPagePtr, cnoOfUndoPage, undoPage);
  228.   cfirstfreeUndoSeg = regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS];
  229.   regUndoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL;
  230.   for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) {
  231.     dbsiPtr.p->pdxDataPage[i] = regUndoPagePtr.i + i;
  232.   }//for
  233. }//Dbtup::allocDataBufferSegment()
  235. /* ---------------------------------------------------------------- */
  236. /* --- PERFORM A COPY OF THE ACTIVE OPERATIONS FOR THIS FRAGMENT -- */
  237. /* ---------------------------------------------------------------- */
  238. void Dbtup::lcpSaveCopyListLab(Signal* signal, CheckpointInfoPtr ciPtr) 
  239. {
  240.   FragrecordPtr regFragPtr;
  241.   LocalLogInfoPtr lliPtr;
  242.   OperationrecPtr regOpPtr;
  244.   regFragPtr.i = ciPtr.p->lcpFragmentP;
  245.   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  246.   lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
  247.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  248.   regOpPtr.i = ciPtr.p->lcpTmpOperPtr;
  250. /* -------------------------------------------------------------------------------- */
  251. /* TRAVERSE THE ENTIRE BLOCK OF OPERATIONS. CHECK IF THERE ARE EXISTING COPYS OF    */
  252. /* TUPLES IN THE CHECKPOINTED FRAGMENT. SAVE THOSE IN A LIST IN THE FOLLOWING FORM: */
  253. /*                                                                                  */
  254. /*    SOURCE PAGE                                                                   */
  255. /*    SOURCE INDEX                                                                  */
  256. /*    COPY PAGE                                                                     */
  257. /*    COPY INDEX                                                                    */
  258. /* -------------------------------------------------------------------------------- */
  259.   Uint32 loopCount = 0;
  260.   while ((regOpPtr.i != RNIL) && (loopCount < 50)) {
  261.     ljam();
  262.     ptrCheckGuard(regOpPtr, cnoOfOprec, operationrec);
  263.     if (regOpPtr.p->realPageId != RNIL) {
  264. /* ---------------------------------------------------------------- */
  265. // We ensure that we have actually allocated the tuple header and
  266. // also found it. Otherwise we will fill the undo log with garbage.
  267. /* ---------------------------------------------------------------- */
  268.       if (regOpPtr.p->optype == ZUPDATE || 
  269.   (regOpPtr.p->optype == ZINSERT && regOpPtr.p->deleteInsertFlag)) {
  270.         ljam();
  271.         if (regOpPtr.p->realPageIdC != RNIL) {
  272. /* ---------------------------------------------------------------- */
  273. // We ensure that we have actually allocated the tuple header copy.
  274. // Otherwise we will fill the undo log with garbage.
  275. /* ---------------------------------------------------------------- */
  276.           cprAddLogHeader(signal,
  277.                           lliPtr.p,
  278.                           ZLCPR_ABORT_UPDATE,
  279.                           ciPtr.p->lcpTabPtr,
  280.                           ciPtr.p->lcpFragmentId);
  281.           cprAddAbortUpdate(signal, lliPtr.p, regOpPtr.p);
  282.         }//if
  283.       } else if (regOpPtr.p->optype == ZINSERT) {
  284.         ljam();
  285.         cprAddUndoLogRecord(signal,
  286.                             ZLCPR_ABORT_INSERT,
  287.                             regOpPtr.p->fragPageId,
  288.                             regOpPtr.p->pageIndex,
  289.                             regOpPtr.p->tableRef,
  290.                             regOpPtr.p->fragId,
  291.                             regFragPtr.p->checkpointVersion);
  292.       } else {
  293.         ndbrequire(regOpPtr.p->optype == ZDELETE);
  294.         ljam();
  295.         cprAddUndoLogRecord(signal,
  296.                             ZINDICATE_NO_OP_ACTIVE,
  297.                             regOpPtr.p->fragPageId,
  298.                             regOpPtr.p->pageIndex,
  299.                             regOpPtr.p->tableRef,
  300.                             regOpPtr.p->fragId,
  301.                             regFragPtr.p->checkpointVersion);
  302.       }//if
  303.     }//if
  304.     loopCount++;;
  305.     regOpPtr.i = regOpPtr.p->nextOprecInList;
  306.   }//while
  307.   if (regOpPtr.i == RNIL) {
  308.     ljam();
  310.     signal->theData[0] = ciPtr.p->lcpUserptr;
  311.     sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_LCPSTARTED, signal, 1, JBA);
  313.     signal->theData[0] = ZCONT_SAVE_DP;
  314.     signal->theData[1] = ciPtr.i;
  315.     sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
  316.   } else {
  317.     ljam();
  318.     ciPtr.p->lcpTmpOperPtr = regOpPtr.i;
  319.     signal->theData[0] = ZCONT_START_SAVE_CL;
  320.     signal->theData[1] = ciPtr.i;
  321.     sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
  322.   }//if
  323. }//Dbtup::lcpSaveCopyListLab()
  325. /* ---------------------------------------------------------------- */
  326. /* ------- PERFORM A COPY OF ONE DATAPAGE DURING CHECKPOINT ------- */
  327. /* ---------------------------------------------------------------- */
  328. /* THE RANGE OF DATA PAGES IS INCLUDED IN THE CHECKPOINT_INFO_PTR   */
  329. /* LAST_PAGE_TO_BUFFER ELEMENT IS INCREASED UNTIL ALL PAGES ARE     */
  330. /* COPIED TO THE DISK BUFFER. WHEN A DISK BUFFER SEGMENT IS FULL    */
  331. /* IT WILL BE WRITTEN TO DISK (TYPICALLY EACH 8:TH PAGE)            */
  332. /* ---------------------------------------------------------------- */
  333. void Dbtup::lcpSaveDataPageLab(Signal* signal, Uint32 ciIndex) 
  334. {
  335.   CheckpointInfoPtr ciPtr;
  336.   DiskBufferSegmentInfoPtr dbsiPtr;
  337.   FragrecordPtr regFragPtr;
  338.   LocalLogInfoPtr lliPtr;
  339.   UndoPagePtr undoCopyPagePtr;
  340.   PagePtr pagePtr;
  342.   ciPtr.i = ciIndex;
  343.   ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  344.   if (ERROR_INSERTED(4000)){
  345.     if (ciPtr.p->lcpTabPtr == c_errorInsert4000TableId) {
  346.     // Delay writing of data pages during LCP
  347.       ndbout << "Delay writing of data pages during LCP" << endl;
  348.       signal->theData[0] = ZCONT_SAVE_DP;
  349.       signal->theData[1] = ciIndex;
  350.       sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 1000, 2);
  351.       return;
  352.     }//if
  353.   }//if
  354.   if (clblPageCounter == 0) {
  355.     ljam();
  356.     signal->theData[0] = ZCONT_SAVE_DP;
  357.     signal->theData[1] = ciPtr.i;
  358.     sendSignalWithDelay(cownref, GSN_CONTINUEB, signal, 100, 2);
  359.     return;
  360.   } else {
  361.     ljam();
  362.     clblPageCounter--;
  363.   }//if
  365.   regFragPtr.i = ciPtr.p->lcpFragmentP;
  366.   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  367.   dbsiPtr.i = ciPtr.p->lcpDataBufferSegmentP;
  368.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  370.   pagePtr.i = getRealpid(regFragPtr.p, regFragPtr.p->minPageNotWrittenInCheckpoint);
  371.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  372.   ndbrequire(dbsiPtr.p->pdxNumDataPages < 16);
  373.   undoCopyPagePtr.i = dbsiPtr.p->pdxDataPage[dbsiPtr.p->pdxNumDataPages];
  374.   ptrCheckGuard(undoCopyPagePtr, cnoOfUndoPage, undoPage);
  375.   MEMCOPY_NO_WORDS(&undoCopyPagePtr.p->undoPageWord[0],
  376.                    &pagePtr.p->pageWord[0],
  377.                    ZWORDS_ON_PAGE);
  378.   regFragPtr.p->minPageNotWrittenInCheckpoint++;
  379.   dbsiPtr.p->pdxNumDataPages++;
  380.   if (regFragPtr.p->minPageNotWrittenInCheckpoint == regFragPtr.p->maxPageWrittenInCheckpoint) {
  381.     /* ---------------------------------------------------------- */
  382.     /* ALL PAGES ARE COPIED, TIME TO FINISH THE CHECKPOINT        */
  383.     /* SAVE THE END POSITIONS OF THE LOG RECORDS SINCE ALL DATA   */
  384.     /* PAGES ARE NOW SAFE ON DISK AND NO MORE LOGGING WILL APPEAR */
  385.     /* ---------------------------------------------------------- */
  386.     ljam();
  387.     lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
  388.     ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  389.     regFragPtr.p->checkpointVersion = RNIL; /* UNDO LOGGING IS SHUT OFF */
  390.     lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, false);
  391.     dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE_LAST;
  392.   } else if (dbsiPtr.p->pdxNumDataPages == ZDB_SEGMENT_SIZE) {
  393.     ljam();
  394.     lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, false);
  395.     dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE;
  396.   } else {
  397.     ljam();
  398.     signal->theData[0] = ZCONT_SAVE_DP;
  399.     signal->theData[1] = ciPtr.i;
  400.     sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
  401.   }//if
  402. }//Dbtup::lcpSaveDataPageLab()
  404. void Dbtup::lcpWriteListDataPageSegment(Signal* signal,
  405.                                         DiskBufferSegmentInfoPtr dbsiPtr,
  406.                                         CheckpointInfoPtr ciPtr,
  407.                                         bool flushFlag) 
  408. {
  409.   Uint32 flags = 1;
  410.   cnoOfDataPagesToDiskWithoutSynch += dbsiPtr.p->pdxNumDataPages;
  411.   if ((cnoOfDataPagesToDiskWithoutSynch > MAX_PAGES_WITHOUT_SYNCH) ||
  412.       (flushFlag)) {
  413.     ljam();
  414. /* ---------------------------------------------------------------- */
  415. // To avoid synching too big chunks at a time we synch after writing
  416. // a certain number of data pages. (e.g. 2 MBytes).
  417. /* ---------------------------------------------------------------- */
  418.     cnoOfDataPagesToDiskWithoutSynch = 0;
  419.     flags |= 0x10; //Set synch flag unconditionally
  420.   }//if
  421.   signal->theData[0] = ciPtr.p->lcpDataFileHandle;
  422.   signal->theData[1] = cownref;
  423.   signal->theData[2] = dbsiPtr.i;
  424.   signal->theData[3] = flags;
  425.   signal->theData[4] = ZBASE_ADDR_UNDO_WORD;
  426.   signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  427.   signal->theData[6] = dbsiPtr.p->pdxDataPage[0];
  428.   signal->theData[7] = dbsiPtr.p->pdxFilePage;
  429.   sendSignal(NDBFS_REF, GSN_FSWRITEREQ, signal, 8, JBA);
  431.   dbsiPtr.p->pdxFilePage += dbsiPtr.p->pdxNumDataPages;
  432.   dbsiPtr.p->pdxNumDataPages = 0;
  433. }//Dbtup::lcpWriteListDataPageSegment()
  435. void Dbtup::lcpFlushLogLab(Signal* signal, CheckpointInfoPtr ciPtr) 
  436. {
  437.   DiskBufferSegmentInfoPtr oldDbsiPtr;
  438.   LocalLogInfoPtr lliPtr;
  439.   UndoPagePtr oldUndoPagePtr;
  440.   UndoPagePtr newUndoPagePtr;
  442.   lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
  443.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  444.   oldDbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP;
  445.   ptrCheckGuard(oldDbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  446.   oldDbsiPtr.p->pdxNumDataPages++;
  447.   if (clblPageCounter > 0) {
  448.     ljam();
  449.     clblPageCounter--;
  450.   }//if
  451.   oldUndoPagePtr.i = lliPtr.p->lliUndoPage;
  452.   ptrCheckGuard(oldUndoPagePtr, cnoOfUndoPage, undoPage);
  453.   lcpWriteUndoSegment(signal, lliPtr.p, true);
  454.   oldDbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_WRITE_FLUSH;
  455.   oldDbsiPtr.p->pdxCheckpointInfoP = ciPtr.i;
  457. /* ---------------------------------------------------------------- */
  458. /*       SINCE LAST PAGE SENT TO DISK WAS NOT FULL YET WE COPY IT   */
  459. /*       TO THE NEW LAST PAGE.                                      */
  460. /* ---------------------------------------------------------------- */
  461.   newUndoPagePtr.i = lliPtr.p->lliUndoPage;
  462.   ptrCheckGuard(newUndoPagePtr, cnoOfUndoPage, undoPage);
  463.   ndbrequire(lliPtr.p->lliUndoWord < ZWORDS_ON_PAGE);
  464.   MEMCOPY_NO_WORDS(&newUndoPagePtr.p->undoPageWord[0],
  465.                    &oldUndoPagePtr.p->undoPageWord[0],
  466.                    lliPtr.p->lliUndoWord);
  467. }//Dbtup::lcpFlushLogLab()
  469. void Dbtup::lcpFlushRestartInfoLab(Signal* signal, Uint32 ciIndex) 
  470. {
  471.   CheckpointInfoPtr ciPtr;
  472.   DiskBufferSegmentInfoPtr dbsiPtr;
  473.   LocalLogInfoPtr lliPtr;
  474.   UndoPagePtr undoCopyPagePtr;
  476.   ciPtr.i = ciIndex;
  477.   ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  479.   lliPtr.i = ciPtr.p->lcpLocalLogInfoP;
  480.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  481.   dbsiPtr.i = ciPtr.p->lcpDataBufferSegmentP;
  482.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  483.   undoCopyPagePtr.i = dbsiPtr.p->pdxDataPage[0]; /* UNDO INFO STORED AT PAGE 0 */
  484.   ptrCheckGuard(undoCopyPagePtr, cnoOfUndoPage, undoPage);
  485.   ndbrequire(ciPtr.p->lcpNoOfPages > 0);
  486.   undoCopyPagePtr.p->undoPageWord[ZSRI_NO_OF_FRAG_PAGES_POS] = ciPtr.p->lcpNoOfPages;
  487.   undoCopyPagePtr.p->undoPageWord[ZSRI_NO_COPY_PAGES_ALLOC] = ciPtr.p->lcpNoCopyPagesAlloc;
  488.   undoCopyPagePtr.p->undoPageWord[ZSRI_EMPTY_PRIM_PAGE] = ciPtr.p->lcpEmptyPrimPage;
  489.   undoCopyPagePtr.p->undoPageWord[ZSRI_TH_FREE_FIRST] = ciPtr.p->lcpThFreeFirst;
  490.   undoCopyPagePtr.p->undoPageWord[ZSRI_TH_FREE_COPY_FIRST] = ciPtr.p->lcpThFreeCopyFirst;
  491.   undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_LOG_END_REC_ID] = lliPtr.p->lliPrevRecordId;
  492.   undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_FILE_VER] = cundoFileVersion;
  493.   if (lliPtr.p->lliUndoWord == ZUNDO_PAGE_HEADER_SIZE) {
  494.     ljam();
  495.     undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_LOG_END_PAGE_ID] = lliPtr.p->lliLogFilePage - 1;
  496.   } else {
  497.     ljam();
  498.     undoCopyPagePtr.p->undoPageWord[ZSRI_UNDO_LOG_END_PAGE_ID] = lliPtr.p->lliLogFilePage;
  499.   }//if
  500.   dbsiPtr.p->pdxNumDataPages = 1;
  501.   dbsiPtr.p->pdxFilePage = 0;
  502.   if (clblPageCounter > 0) {
  503.     ljam();
  504.     clblPageCounter--;
  505.   }//if
  506.   lcpWriteListDataPageSegment(signal, dbsiPtr, ciPtr, true);
  507.   dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_WRITE_FLUSH;
  508.   return;
  509. }//Dbtup::lcpFlushRestartInfoLab()
  511. void Dbtup::lcpCompletedLab(Signal* signal, Uint32 ciIndex) 
  512. {
  513.   CheckpointInfoPtr ciPtr;
  514.   PendingFileOpenInfoPtr pfoiPtr;
  515. /* ---------------------------------------------------------------------- */
  516. /*       INSERT CODE TO CLOSE DATA FILE HERE. DO THIS BEFORE SEND CONF    */
  517. /* ---------------------------------------------------------------------- */
  518.   ciPtr.i = ciIndex;
  519.   ptrCheckGuard(ciPtr, cnoOfLcpRec, checkpointInfo);
  521.   seizePendingFileOpenInfoRecord(pfoiPtr);
  522.   pfoiPtr.p->pfoOpenType = LCP_DATA_FILE_CLOSE;
  523.   pfoiPtr.p->pfoCheckpointInfoP = ciPtr.i;
  525.   signal->theData[0] = ciPtr.p->lcpDataFileHandle;
  526.   signal->theData[1] = cownref;
  527.   signal->theData[2] = pfoiPtr.i;
  528.   signal->theData[3] = 0;
  529.   sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA);
  530.   return;
  531. }//Dbtup::lcpCompletedLab()
  533. void Dbtup::lcpClosedDataFileLab(Signal* signal, CheckpointInfoPtr ciPtr) 
  534. {
  535.   signal->theData[0] = ciPtr.p->lcpUserptr;
  536.   sendSignal(ciPtr.p->lcpBlockref, GSN_TUP_LCPCONF, signal, 1, JBB);
  537.   releaseCheckpointInfoRecord(ciPtr);
  538.   return;
  539. }//Dbtup::lcpClosedDataFileLab()
  541. /* ---------------------------------------------------------------------- */
  542. /* LCP END IS THE LAST STEP IN THE LCP PROCESS IT WILL CLOSE THE LOGFILES */
  543. /* AND RELEASE THE ALLOCATED CHECKPOINT_INFO_RECORDS                      */
  544. /* ---------------------------------------------------------------------- */
  545. void Dbtup::execEND_LCPREQ(Signal* signal) 
  546. {
  547.   DiskBufferSegmentInfoPtr dbsiPtr;
  548.   LocalLogInfoPtr lliPtr;
  549.   PendingFileOpenInfoPtr pfoiPtr;
  551.   ljamEntry();
  552.   clqhUserpointer = signal->theData[0];
  553.   clqhBlockref = signal->theData[1];
  554.   for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) {
  555.     ljam();
  556.     ptrAss(lliPtr, localLogInfo);
  557.     if (lliPtr.p->lliActiveLcp > 0) {
  558.       ljam();
  559.       dbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP;
  560.       ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  561.       freeDiskBufferSegmentRecord(signal, dbsiPtr);
  563.       seizePendingFileOpenInfoRecord(pfoiPtr); /* SEIZE A NEW FILE OPEN INFO    */
  564.       pfoiPtr.p->pfoOpenType = LCP_UNDO_FILE_CLOSE;
  565.       pfoiPtr.p->pfoCheckpointInfoP = lliPtr.i;
  567.       signal->theData[0] = lliPtr.p->lliUndoFileHandle;
  568.       signal->theData[1] = cownref;
  569.       signal->theData[2] = pfoiPtr.i;
  570.       signal->theData[3] = 0;
  571.       sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA);
  572.       lliPtr.p->lliActiveLcp = 0;
  573.     }//if
  574.   }//for
  575.   return;
  576. }//Dbtup::execEND_LCPREQ()
  578. void Dbtup::lcpEndconfLab(Signal* signal) 
  579. {
  580.   LocalLogInfoPtr lliPtr;
  581.   for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) {
  582.     ljam();
  583.     ptrAss(lliPtr, localLogInfo);
  584.     if (lliPtr.p->lliUndoFileHandle != RNIL) {
  585.       ljam();
  586. /* ---------------------------------------------------------------------- */
  587. /*       WAIT UNTIL ALL LOG FILES HAVE BEEN CLOSED.                       */
  588. /* ---------------------------------------------------------------------- */
  589.       return;
  590.     }//if
  591.   }//for
  592.   signal->theData[0] = clqhUserpointer;
  593.   sendSignal(clqhBlockref, GSN_END_LCPCONF, signal, 1, JBB);
  594.   return;
  595. }//Dbtup::lcpEndconfLab()