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

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

MySQL数据库

开发平台：

Visual C++

DbtupSystemRestart.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/EventReport.hpp>
  24. #include <signaldata/FsConf.hpp>
  25. #include <signaldata/FsRef.hpp>
  27. #define ljam() { jamLine(26000 + __LINE__); }
  28. #define ljamEntry() { jamEntryLine(26000 + __LINE__); }
  30. /* **************************************************************** */
  31. /* ********************* SYSTEM RESTART MANAGER ******************* */
  32. /* **************************************************************** */
  33. /***************************************************************/
  34. /* CHECK RESTART STATE AND SET NEW STATE CALLED IN OPEN,       */
  35. /* READ AND COPY STATES                                        */
  36. /***************************************************************/
  37. void Dbtup::execTUP_SRREQ(Signal* signal) 
  38. {
  39.   RestartInfoRecordPtr riPtr;
  40.   PendingFileOpenInfoPtr pfoiPtr;
  42.   ljamEntry();
  43.   Uint32 userPtr = signal->theData[0];
  44.   Uint32 userBlockref = signal->theData[1];
  45.   Uint32 tableId = signal->theData[2];
  46.   Uint32 fragId = signal->theData[3];
  47.   Uint32 checkpointNumber = signal->theData[4];
  49.   seizeRestartInfoRecord(riPtr);
  51.   riPtr.p->sriUserptr = userPtr;
  52.   riPtr.p->sriBlockref = userBlockref;
  53.   riPtr.p->sriState = OPENING_DATA_FILE;
  54.   riPtr.p->sriCheckpointVersion = checkpointNumber;
  55.   riPtr.p->sriFragid = fragId;
  56.   riPtr.p->sriTableId = tableId;
  58.    /* OPEN THE DATA FILE IN THE FOLLOWING FORM              */
  59.    /* D5/DBTUP/T<TABID>/F<FRAGID>/S<CHECKPOINT_NUMBER>.DATA */
  60.   Uint32 fileType = 1;                 /* VERSION                       */
  61.   fileType = (fileType << 8) | 0; /* .DATA                         */
  62.   fileType = (fileType << 8) | 5; /* D5                            */
  63.   fileType = (fileType << 8) | 0xff; /* DON'T USE P DIRECTORY LEVEL   */
  64.   Uint32 fileFlag = 0;                 /* READ ONLY                     */
  66.   seizePendingFileOpenInfoRecord(pfoiPtr);
  67.   pfoiPtr.p->pfoOpenType = LCP_DATA_FILE_READ;
  68.   pfoiPtr.p->pfoRestartInfoP = riPtr.i;
  70.   signal->theData[0] = cownref;
  71.   signal->theData[1] = pfoiPtr.i;
  72.   signal->theData[2] = tableId;
  73.   signal->theData[3] = fragId;
  74.   signal->theData[4] = checkpointNumber;
  75.   signal->theData[5] = fileType;
  76.   signal->theData[6] = fileFlag;
  77.   sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA);
  78.   return;
  79. }//Dbtup::execTUP_SRREQ()
  81. void Dbtup::seizeRestartInfoRecord(RestartInfoRecordPtr& riPtr) 
  82. {
  83.   riPtr.i = cfirstfreeSri;
  84.   ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord);
  85.   cfirstfreeSri = riPtr.p->sriNextRec;
  86.   riPtr.p->sriNextRec = RNIL;
  87. }//Dbtup::seizeRestartInfoRecord()
  89. void Dbtup::rfrReadRestartInfoLab(Signal* signal, RestartInfoRecordPtr riPtr) 
  90. {
  91.   DiskBufferSegmentInfoPtr dbsiPtr;
  93.   seizeDiskBufferSegmentRecord(dbsiPtr);
  94.   riPtr.p->sriDataBufferSegmentP = dbsiPtr.i;
  95.   Uint32 retPageRef = RNIL;
  96.   Uint32 noAllocPages = 1;
  97.   Uint32 noOfPagesAllocated;
  98.   {
  99.     /**
  100.      * Use low pages for 0-pages during SR
  101.      *   bitmask of free pages is kept in c_sr_free_page_0
  102.      */
  103.     Uint32 tmp = c_sr_free_page_0;
  104.     for(Uint32 i = 1; i<(1+MAX_PARALLELL_TUP_SRREQ); i++){
  105.       if(tmp & (1 << i)){
  106. retPageRef = i;
  107. c_sr_free_page_0 = tmp & (~(1 << i));
  108. break;
  109.       }
  110.     }
  111.     ndbrequire(retPageRef != RNIL);
  112.   }
  113.   
  114.   dbsiPtr.p->pdxDataPage[0] = retPageRef;
  115.   dbsiPtr.p->pdxNumDataPages = 1;
  116.   dbsiPtr.p->pdxFilePage = 0;
  117.   rfrReadNextDataSegment(signal, riPtr, dbsiPtr);
  118.   dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_READ_PAGE_ZERO;
  119. }//Dbtup::rfrReadRestartInfoLab()
  121. /***************************************************************/
  122. /* THE RESTART INFORMATION IS NOW READ INTO THE DATA BUFFER    */
  123. /* USE THE RESTART INFORMATION TO INITIATE THE RESTART RECORD  */
  124. /***************************************************************/
  125. void 
  126. Dbtup::rfrInitRestartInfoLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) 
  127. {
  128.   Uint32 TzeroDataPage[64];
  129.   Uint32 Ti;
  130.   FragrecordPtr regFragPtr;
  131.   LocalLogInfoPtr lliPtr;
  132.   PagePtr pagePtr;
  133.   RestartInfoRecordPtr riPtr;
  134.   TablerecPtr regTabPtr;
  136.   riPtr.i = dbsiPtr.p->pdxRestartInfoP;
  137.   ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord);
  138.   
  139.   regTabPtr.i = riPtr.p->sriTableId;
  140.   ptrCheckGuard(regTabPtr, cnoOfTablerec, tablerec);
  142.   Uint32 fragId = riPtr.p->sriFragid;
  143.   getFragmentrec(regFragPtr, fragId, regTabPtr.p);
  144.   riPtr.p->sriFragP = regFragPtr.i;
  145.   
  146.   /* ----- PAGE ALLOCATION --- */
  147.   /* ALLOCATE PAGES TO FRAGMENT, INSERT THEM INTO PAGE RANGE TABLE AND       */
  148.   /* ALSO CONVERT THEM INTO EMPTY PAGES AND INSERT THEM INTO THE EMPTY LIST  */
  149.   /* OF THE FRAGMENT. SET ALL LISTS OF FREE PAGES TO RNIL                    */
  151.   ndbrequire(cfirstfreerange != RNIL);
  152.   pagePtr.i = dbsiPtr.p->pdxDataPage[0];
  153.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  154.   for (Ti = 0; Ti < 63; Ti++) {
  155.     /***************************************************************/
  156.     // Save Important content from Page zero in stack variable so
  157.     // that we can immediately release page zero.
  158.     /***************************************************************/
  159.     TzeroDataPage[Ti] = pagePtr.p->pageWord[Ti];
  160.   }//for
  161.   /************************************************************************/
  162.   /* NOW WE DON'T NEED THE RESTART INFO BUFFER PAGE ANYMORE               */
  163.   /* LETS REMOVE IT AND REUSE THE SEGMENT FOR REAL DATA PAGES             */
  164.   /* REMOVE ONE PAGE ONLY, PAGEP IS ALREADY SET TO THE RESTART INFO PAGE */
  165.   /************************************************************************/
  166.   {
  167.     ndbrequire(pagePtr.i > 0 && pagePtr.i <= MAX_PARALLELL_TUP_SRREQ);
  168.     c_sr_free_page_0 |= (1 << pagePtr.i);
  169.   }
  171.   Uint32 undoFileVersion = TzeroDataPage[ZSRI_UNDO_FILE_VER];
  172.   lliPtr.i = (undoFileVersion << 2) + (regTabPtr.i & 0x3);
  173.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  174.   riPtr.p->sriLocalLogInfoP = lliPtr.i;
  176.   ndbrequire(regFragPtr.p->fragTableId == regTabPtr.i);
  177.   ndbrequire(regFragPtr.p->fragmentId == fragId);
  178.   
  179.   regFragPtr.p->fragStatus = SYSTEM_RESTART;
  181.   regFragPtr.p->noCopyPagesAlloc = TzeroDataPage[ZSRI_NO_COPY_PAGES_ALLOC];
  183.   riPtr.p->sriCurDataPageFromBuffer = 0;
  184.   riPtr.p->sriNumDataPages = TzeroDataPage[ZSRI_NO_OF_FRAG_PAGES_POS];
  186.   ndbrequire(riPtr.p->sriNumDataPages >= regFragPtr.p->noOfPages);
  187.   const Uint32 pageCount = riPtr.p->sriNumDataPages - regFragPtr.p->noOfPages;
  188.   if(pageCount > 0){
  189.     Uint32 noAllocPages = allocFragPages(regFragPtr.p, pageCount);
  190.     ndbrequire(noAllocPages == pageCount);
  191.   }//if
  192.   ndbrequire(getNoOfPages(regFragPtr.p) == riPtr.p->sriNumDataPages);
  194. /***************************************************************/
  195. // Set the variables on fragment record which might have been
  196. // affected by allocFragPages.
  197. /***************************************************************/
  199.   regFragPtr.p->emptyPrimPage = TzeroDataPage[ZSRI_EMPTY_PRIM_PAGE];
  200.   regFragPtr.p->thFreeFirst = TzeroDataPage[ZSRI_TH_FREE_FIRST];
  201.   regFragPtr.p->thFreeCopyFirst = TzeroDataPage[ZSRI_TH_FREE_COPY_FIRST];
  203. /***************************************************************/
  204. /* THE RESTART INFORMATION IS NOW READ INTO THE DATA BUFFER    */
  205. /* USE THE RESTART INFORMATION TO INITIATE THE FRAGMENT        */
  206. /***************************************************************/
  207.   /**
  208.    * IF THIS UNDO FILE IS NOT OPEN, IT WILL BE OPENED HERE AND THE EXECUTION 
  209.    * WILL CONTINUE WHEN THE FSOPENCONF IS ENTERED.
  210.    * IF IT'S ALREADY IN USE THE EXECUTION WILL CONTINUE BY A 
  211.    * CONTINUE B SIGNAL
  212.    */
  213.   if (lliPtr.p->lliActiveLcp == 0) {
  214.     PendingFileOpenInfoPtr pfoiPtr;
  215.     ljam();
  216. /***************************************************************/
  217. /* OPEN THE UNDO FILE FOR READ                                 */
  218. /* THE FILE HANDLE WILL BE SET IN THE LOCAL_LOG_INFO_REC       */
  219. /* UPON FSOPENCONF                                             */
  220. /***************************************************************/
  221.     cnoOfLocalLogInfo++;
  222.                                                 /* F_LEVEL NOT USED              */
  223.     Uint32 fileType = 1;                        /* VERSION                       */
  224.     fileType = (fileType << 8) | 2;         /* .LOCLOG                       */
  225.     fileType = (fileType << 8) | 6;         /* D6                            */
  226.     fileType = (fileType << 8) | 0xff;         /* DON'T USE P DIRECTORY LEVEL   */
  227.     Uint32 fileFlag = 0;                 /* READ ONLY                     */
  229.     seizePendingFileOpenInfoRecord(pfoiPtr);
  230.     pfoiPtr.p->pfoOpenType = LCP_UNDO_FILE_READ;
  231.     pfoiPtr.p->pfoRestartInfoP = riPtr.i;
  233.     signal->theData[0] = cownref;
  234.     signal->theData[1] = pfoiPtr.i;
  235.     signal->theData[2] = lliPtr.i;
  236.     signal->theData[3] = 0xFFFFFFFF;
  237.     signal->theData[4] = undoFileVersion;
  238.     signal->theData[5] = fileType;
  239.     signal->theData[6] = fileFlag;
  240.     sendSignal(NDBFS_REF, GSN_FSOPENREQ, signal, 7, JBA);
  242.     lliPtr.p->lliPrevRecordId = 0;
  243.     lliPtr.p->lliActiveLcp = 1;
  244.     lliPtr.p->lliNumFragments = 1;
  245.   } else {
  246.     ljam();
  247.     signal->theData[0] = ZCONT_LOAD_DP;
  248.     signal->theData[1] = riPtr.i;
  249.     sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
  250.     lliPtr.p->lliNumFragments++;
  251.   }//if
  252.    /* RETAIN THE HIGH- AND LOWSCORE ID:S OF THE LOGRECORD POSITIONS. WE HAVE TO EXECUTE THE  */
  253.    /* UNDO LOG BETWEEN THE END AND START RECORDS FOR ALL RECORDS THAT INCLUDE FRAGMENTS OF   */
  254.    /* THE RIGHT CHECKPOINT VERSION TO COMPLETE THE OPERATION WE HAVE TO RUN ALL LOGS THAT    */
  255.    /* HAS THE NUMBER OF LCP ELEMENT GREATER THAN 0, I.E. IS INCLUDED.                        */
  256.   if (TzeroDataPage[ZSRI_UNDO_LOG_END_REC_ID] > lliPtr.p->lliPrevRecordId) {
  257.     ljam();
  258.     lliPtr.p->lliPrevRecordId = TzeroDataPage[ZSRI_UNDO_LOG_END_REC_ID];
  259.     lliPtr.p->lliEndPageId = TzeroDataPage[ZSRI_UNDO_LOG_END_PAGE_ID];
  260.   }//if
  261.   return;
  262. }//Dbtup::rfrInitRestartInfoLab()
  264. /***************************************************************/
  265. /* LOAD THE NEXT DATA PAGE SEGMENT INTO MEMORY                 */
  266. /***************************************************************/
  267. void Dbtup::rfrLoadDataPagesLab(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr) 
  268. {
  269.   FragrecordPtr regFragPtr;
  271.   if (riPtr.p->sriCurDataPageFromBuffer >= riPtr.p->sriNumDataPages) {
  272.     ljam();
  273.     rfrCompletedLab(signal, riPtr);
  274.     return;
  275.   }//if
  276.   Uint32 startPage = riPtr.p->sriCurDataPageFromBuffer;
  277.   Uint32 endPage;
  278.   if ((startPage + ZDB_SEGMENT_SIZE) < riPtr.p->sriNumDataPages) {
  279.     ljam();
  280.     endPage = startPage + ZDB_SEGMENT_SIZE;
  281.   } else {
  282.     ljam();
  283.     endPage = riPtr.p->sriNumDataPages;
  284.   }//if
  285.   regFragPtr.i = riPtr.p->sriFragP;
  286.   ptrCheckGuard(regFragPtr, cnoOfFragrec, fragrecord);
  287.   ndbrequire((endPage - startPage) <= 16);
  288.   Uint32 i = 0;
  289.   for (Uint32 pageId = startPage; pageId < endPage; pageId++) {
  290.     ljam();
  291.     dbsiPtr.p->pdxDataPage[i] = getRealpid(regFragPtr.p, pageId);
  292.     i++;
  293.   }//for
  294.   dbsiPtr.p->pdxNumDataPages = endPage - startPage; /* SET THE NUMBER OF DATA PAGES */
  295.   riPtr.p->sriCurDataPageFromBuffer = endPage;
  296.   dbsiPtr.p->pdxFilePage = startPage + 1;
  297.   rfrReadNextDataSegment(signal, riPtr, dbsiPtr);
  298.   return;
  299. }//Dbtup::rfrLoadDataPagesLab()
  301. void Dbtup::rfrCompletedLab(Signal* signal, RestartInfoRecordPtr riPtr) 
  302. {
  303.   PendingFileOpenInfoPtr pfoPtr;
  304. /* ---------------------------------------------------------------------- */
  305. /*       CLOSE THE DATA FILE BEFORE SENDING TUP_SRCONF                    */
  306. /* ---------------------------------------------------------------------- */
  307.   seizePendingFileOpenInfoRecord(pfoPtr);
  308.   pfoPtr.p->pfoOpenType = LCP_DATA_FILE_READ;
  309.   pfoPtr.p->pfoCheckpointInfoP = riPtr.i;
  311.   signal->theData[0] = riPtr.p->sriDataFileHandle;
  312.   signal->theData[1] = cownref;
  313.   signal->theData[2] = pfoPtr.i;
  314.   signal->theData[3] = 0;
  315.   sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA);
  316. }//Dbtup::rfrCompletedLab()
  318. void Dbtup::rfrClosedDataFileLab(Signal* signal, Uint32 restartIndex) 
  319. {
  320.   RestartInfoRecordPtr riPtr;
  321.   DiskBufferSegmentInfoPtr dbsiPtr;
  323.   riPtr.i = restartIndex;
  324.   ptrCheckGuard(riPtr, cnoOfRestartInfoRec, restartInfoRecord);
  325.   riPtr.p->sriDataFileHandle = RNIL;
  326.   dbsiPtr.i = riPtr.p->sriDataBufferSegmentP;
  327.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  328.   releaseDiskBufferSegmentRecord(dbsiPtr);
  329.   signal->theData[0] = riPtr.p->sriUserptr;
  330.   signal->theData[1] = riPtr.p->sriFragP;
  331.   sendSignal(riPtr.p->sriBlockref, GSN_TUP_SRCONF, signal, 2, JBB);
  332.   releaseRestartInfoRecord(riPtr);
  333. }//Dbtup::rfrClosedDataFileLab()
  335. /* ---------------------------------------------------------------- */
  336. /* ---------------------- EXECUTE LOCAL LOG  ---------------------- */
  337. /* ---------------------------------------------------------------- */
  338. void Dbtup::execSTART_RECREQ(Signal* signal) 
  339. {
  340.   ljamEntry();
  341.   clqhUserpointer = signal->theData[0];
  342.   clqhBlockref = signal->theData[1];
  344.   for (int i = 0; i < ZNO_CHECKPOINT_RECORDS; i++){
  345.     cSrUndoRecords[i] = 0;
  346.   }//for
  348.   if (cnoOfLocalLogInfo == 0) {
  349.     ljam();
  350. /* ---------------------------------------------------------------- */
  351. /*       THERE WERE NO LOCAL LOGS TO EXECUTE IN THIS SYSTEM RESTART */
  352. /* ---------------------------------------------------------------- */
  353.     xlcRestartCompletedLab(signal);
  354.     return;
  355.   }//if
  356.   LocalLogInfoPtr lliPtr;
  357.   for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) {
  358.     ljam();
  359.     ptrAss(lliPtr, localLogInfo);
  360.     if (lliPtr.p->lliActiveLcp == 1) {
  361.       ljam();
  362.       signal->theData[0] = ZSTART_EXEC_UNDO_LOG;
  363.       signal->theData[1] = lliPtr.i;
  364.       sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
  365.     }//if
  366.   }//for
  367.   return;
  368. }//Dbtup::execSTART_RECREQ()
  370. void Dbtup::closeExecUndoLogLab(Signal* signal, LocalLogInfoPtr lliPtr) 
  371. {
  372.   PendingFileOpenInfoPtr pfoPtr;
  373. /* ---------------------------------------------------------------------- */
  374. /*       CLOSE THE UNDO LOG BEFORE COMPLETION OF THE SYSTEM RESTART       */
  375. /* ---------------------------------------------------------------------- */
  376.   seizePendingFileOpenInfoRecord(pfoPtr);
  377.   pfoPtr.p->pfoOpenType = LCP_UNDO_FILE_READ;
  378.   pfoPtr.p->pfoCheckpointInfoP = lliPtr.i;
  380.   signal->theData[0] = lliPtr.p->lliUndoFileHandle;
  381.   signal->theData[1] = cownref;
  382.   signal->theData[2] = pfoPtr.i;
  383.   signal->theData[3] = 0;
  384.   sendSignal(NDBFS_REF, GSN_FSCLOSEREQ, signal, 4, JBA);
  385.   return;
  386. }//Dbtup::closeExecUndoLogLab()
  388. void Dbtup::endExecUndoLogLab(Signal* signal, Uint32 lliIndex) 
  389. {
  390.   DiskBufferSegmentInfoPtr dbsiPtr;
  391.   LocalLogInfoPtr lliPtr;
  393.   lliPtr.i = lliIndex;
  394.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  395.   lliPtr.p->lliUndoFileHandle = RNIL;
  396.   lliPtr.p->lliActiveLcp = 0;
  397. /* ---------------------------------------------------------------------- */
  398. /*       WE HAVE NOW CLOSED THE LOG. WE WAIT FOR ALL LOCAL LOGS TO        */
  399. /*       COMPLETE LOG EXECUTION BEFORE SENDING THE RESPONSE TO LQH.       */
  400. /* ---------------------------------------------------------------------- */
  401.   dbsiPtr.i = lliPtr.p->lliUndoBufferSegmentP;
  402.   ptrCheckGuard(dbsiPtr, cnoOfConcurrentWriteOp, diskBufferSegmentInfo);
  403.   freeDiskBufferSegmentRecord(signal, dbsiPtr);
  404.   lliPtr.p->lliUndoBufferSegmentP = RNIL;
  405.   for (lliPtr.i = 0; lliPtr.i < 16; lliPtr.i++) {
  406.     ljam();
  407.     ptrAss(lliPtr, localLogInfo);
  408.     if (lliPtr.p->lliActiveLcp == 1) {
  409.       ljam();
  410.       return;
  411.     }//if
  412.   }//for
  413.   xlcRestartCompletedLab(signal);
  414.   return;
  415. }//Dbtup::endExecUndoLogLab()
  417. void Dbtup::xlcRestartCompletedLab(Signal* signal) 
  418. {
  419.   cnoOfLocalLogInfo = 0;
  421.   signal->theData[0] = EventReport::UNDORecordsExecuted;
  422.   signal->theData[1] = DBTUP; // From block
  423.   signal->theData[2] = 0;     // Total records executed
  424.   for (int i = 0; i < 10; i++) {
  425.     if (i < ZNO_CHECKPOINT_RECORDS){
  426.       signal->theData[i+3] = cSrUndoRecords[i];
  427.       signal->theData[2] += cSrUndoRecords[i]; 
  428.     } else {
  429.       signal->theData[i+3] = 0; // Unsused data
  430.     }//if
  431.   }//for
  432.   sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 12, JBB);
  434. /* ---------------------------------------------------------------------- */
  435. /*       ALL LOCAL LOGS HAVE COMPLETED. WE HAVE COMPLETED OUR PART OF THE */
  436. /*       SYSTEM RESTART.                                                  */
  437. /* ---------------------------------------------------------------------- */
  438.   signal->theData[0] = clqhUserpointer;
  439.   sendSignal(clqhBlockref, GSN_START_RECCONF, signal, 1, JBB);
  440.   return;
  441. }//Dbtup::xlcRestartCompletedLab()
  443. void Dbtup::startExecUndoLogLab(Signal* signal, Uint32 lliIndex) 
  444. {
  445.   DiskBufferSegmentInfoPtr dbsiPtr;
  446.   LocalLogInfoPtr lliPtr;
  448. /* ---------------------------------------------------------------------- */
  449. /*       START EXECUTING THE LOG FOR THIS PART. WE BEGIN BY READING THE   */
  450. /*       LAST 16 PAGES.                                                   */
  451. /* ---------------------------------------------------------------------- */
  452.    /* SET THE PREVIOS RECORD TO THE LAST ONE BECAUSE THAT'S WHERE TO START */
  453.   lliPtr.i = lliIndex;
  454.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  456.   allocRestartUndoBufferSegment(signal, dbsiPtr, lliPtr);
  457.   lliPtr.p->lliUndoBufferSegmentP = dbsiPtr.i;
  458.   dbsiPtr.p->pdxCheckpointInfoP = lliPtr.i;
  459.   if (lliPtr.p->lliEndPageId > ((2 * ZUB_SEGMENT_SIZE) - 1)) {
  460.     ljam();
  461.     dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE;
  462.     dbsiPtr.p->pdxFilePage = lliPtr.p->lliEndPageId - (ZUB_SEGMENT_SIZE - 1);
  463.   } else if (lliPtr.p->lliEndPageId > (ZUB_SEGMENT_SIZE - 1)) {
  464.     ljam();
  465.     dbsiPtr.p->pdxNumDataPages = lliPtr.p->lliEndPageId - (ZUB_SEGMENT_SIZE - 1);
  466.     dbsiPtr.p->pdxFilePage = ZUB_SEGMENT_SIZE;
  467.   } else {
  468.     ljam();
  469.     dbsiPtr.p->pdxNumDataPages = lliPtr.p->lliEndPageId + 1;
  470.     dbsiPtr.p->pdxFilePage = 0;
  471.     rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr);
  472.     return;
  473.   }//if
  474.   rfrReadFirstUndoSegment(signal, dbsiPtr, lliPtr);
  475.   return;
  476. }//Dbtup::startExecUndoLogLab()
  478. void Dbtup::rfrReadSecondUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr) 
  479. {
  480.   LocalLogInfoPtr lliPtr;
  481.   lliPtr.i = dbsiPtr.p->pdxCheckpointInfoP;
  482.   ptrCheckGuard(lliPtr, cnoOfParallellUndoFiles, localLogInfo);
  484.   dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE;
  485.   dbsiPtr.p->pdxFilePage -= ZUB_SEGMENT_SIZE;
  486.   rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr);
  487.   return;
  488. }//Dbtup::rfrReadSecondUndoLogLab()
  490. void Dbtup::readExecUndoLogLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
  491. {
  492. /* ---------------------------------------------------------------------- */
  493. /*       THE NEXT UNDO LOG RECORD HAS NOT BEEN READ FROM DISK YET. WE WILL*/
  494. /*       READ UPTO 8 PAGES BACKWARDS OF THE UNDO LOG FILE. WE WILL KEEP   */
  495. /*       THE LAST 8 PAGES TO ENSURE THAT WE WILL BE ABLE TO READ THE NEXT */
  496. /*       LOG RECORD EVEN IF IT SPANS UPTO 8 PAGES.                        */
  497. /* ---------------------------------------------------------------------- */
  498.   if (dbsiPtr.p->pdxFilePage >= ZUB_SEGMENT_SIZE) {
  499.     ljam();
  500.     for (Uint32 i = 0; i < ZUB_SEGMENT_SIZE; i++) {
  501.       ljam();
  502.       Uint32 savePageId = dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE];
  503.       dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE] = dbsiPtr.p->pdxDataPage[i];
  504.       dbsiPtr.p->pdxDataPage[i] = savePageId;
  505.     }//for
  506.     dbsiPtr.p->pdxNumDataPages = ZUB_SEGMENT_SIZE;
  507.     dbsiPtr.p->pdxFilePage = dbsiPtr.p->pdxFilePage - ZUB_SEGMENT_SIZE;
  508.   } else {
  509.     ljam();
  510.     Uint32 dataPages[16];
  511.     ndbrequire(dbsiPtr.p->pdxFilePage > 0);
  512.     ndbrequire(dbsiPtr.p->pdxFilePage <= ZUB_SEGMENT_SIZE);
  513.     Uint32 i;
  514.     for (i = 0; i < dbsiPtr.p->pdxFilePage; i++) {
  515.       ljam();
  516.       dataPages[i] = dbsiPtr.p->pdxDataPage[i + ZUB_SEGMENT_SIZE];
  517.     }//for
  518.     for (i = 0; i < ZUB_SEGMENT_SIZE; i++) {
  519.       ljam();
  520.       dataPages[i + dbsiPtr.p->pdxFilePage] = dbsiPtr.p->pdxDataPage[i];
  521.     }//for
  522.     Uint32 limitLoop = ZUB_SEGMENT_SIZE + dbsiPtr.p->pdxFilePage;
  523.     for (i = 0; i < limitLoop; i++) {
  524.       ljam();
  525.       dbsiPtr.p->pdxDataPage[i] = dataPages[i];
  526.     }//for
  527.     dbsiPtr.p->pdxNumDataPages = dbsiPtr.p->pdxFilePage;
  528.     dbsiPtr.p->pdxFilePage = 0;
  529.   }//if
  530.   rfrReadNextUndoSegment(signal, dbsiPtr, lliPtr);
  531.   return;
  532. }//Dbtup::readExecUndoLogLab()
  534. void Dbtup::rfrReadNextDataSegment(Signal* signal, RestartInfoRecordPtr riPtr, DiskBufferSegmentInfoPtr dbsiPtr) 
  535. {
  536.   dbsiPtr.p->pdxRestartInfoP = riPtr.i;
  537.   dbsiPtr.p->pdxOperation = CHECKPOINT_DATA_READ;
  538.   ndbrequire(dbsiPtr.p->pdxNumDataPages <= 8);
  540.   signal->theData[0] = riPtr.p->sriDataFileHandle;
  541.   signal->theData[1] = cownref;
  542.   signal->theData[2] = dbsiPtr.i;
  543.   signal->theData[3] = 2;
  544.   signal->theData[4] = ZBASE_ADDR_PAGE_WORD;
  545.   signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  546.   for (Uint32 i = 0; i < dbsiPtr.p->pdxNumDataPages; i++) {
  547.     ljam();
  548.     signal->theData[6 + i] = dbsiPtr.p->pdxDataPage[i];
  549.   }//for
  550.   signal->theData[6 + dbsiPtr.p->pdxNumDataPages] = dbsiPtr.p->pdxFilePage;
  551.   sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 15, JBA);
  552. }//Dbtup::rfrReadNextDataSegment()
  554. /* ---------------------------------------------------------------- */
  555. /* ------------------- RFR_READ_FIRST_UNDO_SEGMENT ---------------- */
  556. /* ---------------------------------------------------------------- */
  557. /* THIS ROUTINE READS IN THE FIRST UNDO SEGMENT INTO THE CURRENTLY  */
  558. /* ACTIVE UNDO BUFFER SEGMENT                                       */
  559. /* -----------------------------------------------------------------*/
  560. void Dbtup::rfrReadFirstUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
  561. {
  562.   dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_READ_FIRST;
  564.   signal->theData[0] = lliPtr.p->lliUndoFileHandle;
  565.   signal->theData[1] = cownref;
  566.   signal->theData[2] = dbsiPtr.i;
  567.   signal->theData[3] = 1;
  568.   signal->theData[4] = ZBASE_ADDR_UNDO_WORD;
  569.   signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  570.   signal->theData[6] = dbsiPtr.p->pdxDataPage[ZUB_SEGMENT_SIZE];
  571.   signal->theData[7] = dbsiPtr.p->pdxFilePage;
  572.   sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA);
  573. }//Dbtup::rfrReadFirstUndoSegment()
  575. /* ---------------------------------------------------------------- */
  576. /* ------------------- RFR_READ_NEXT_UNDO_SEGMENT ----------------- */
  577. /* ---------------------------------------------------------------- */
  578. /* THIS ROUTINE READS IN THE NEXT UNDO SEGMENT INTO THE CURRENTLY   */
  579. /* ACTIVE UNDO BUFFER SEGMENT AND SWITCH TO THE UNACTIVE, READY ONE */
  580. /* -----------------------------------------------------------------*/
  581. void Dbtup::rfrReadNextUndoSegment(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
  582. {
  583.   dbsiPtr.p->pdxOperation = CHECKPOINT_UNDO_READ;
  585.   signal->theData[0] = lliPtr.p->lliUndoFileHandle;
  586.   signal->theData[1] = cownref;
  587.   signal->theData[2] = dbsiPtr.i;
  588.   signal->theData[3] = 1;
  589.   signal->theData[4] = ZBASE_ADDR_UNDO_WORD;
  590.   signal->theData[5] = dbsiPtr.p->pdxNumDataPages;
  591.   signal->theData[6] = dbsiPtr.p->pdxDataPage[0];
  592.   signal->theData[7] = dbsiPtr.p->pdxFilePage;
  593.   sendSignal(NDBFS_REF, GSN_FSREADREQ, signal, 8, JBA);
  594. }//Dbtup::rfrReadNextUndoSegment()
  596. void Dbtup::xlcGetNextRecordLab(Signal* signal, DiskBufferSegmentInfoPtr dbsiPtr, LocalLogInfoPtr lliPtr) 
  597. {
  598.   Uint32 loopCount = 0;
  599. /* ---------------------------------------------------------------------- */
  600. /*       EXECUTE A NEW SET OF UNDO LOG RECORDS.                           */
  601. /* ---------------------------------------------------------------------- */
  602.   XlcStruct xlcStruct;
  604.   xlcStruct.LliPtr = lliPtr;
  605.   xlcStruct.DbsiPtr = dbsiPtr;
  607.   do {
  608.     ljam();
  609.     loopCount++;
  610.     if (loopCount == 20) {
  611.       ljam();
  612.       signal->theData[0] = ZCONT_EXECUTE_LC;
  613.       signal->theData[1] = xlcStruct.LliPtr.i;
  614.       sendSignal(cownref, GSN_CONTINUEB, signal, 2, JBB);
  615.       return;
  616.     }//if
  617.     if (xlcStruct.LliPtr.p->lliPrevRecordId == 0) {
  618.       ljam();
  619.       closeExecUndoLogLab(signal, xlcStruct.LliPtr);
  620.       return;
  621.     }//if
  622.     xlcStruct.PageId = xlcStruct.LliPtr.p->lliPrevRecordId >> ZUNDO_RECORD_ID_PAGE_INDEX;
  623.     xlcStruct.PageIndex = xlcStruct.LliPtr.p->lliPrevRecordId & ZUNDO_RECORD_ID_PAGE_INDEX_MASK;
  624.     if (xlcStruct.PageId < xlcStruct.DbsiPtr.p->pdxFilePage) {
  625.       ljam();
  626.       readExecUndoLogLab(signal, xlcStruct.DbsiPtr, xlcStruct.LliPtr);
  627.       return;
  628.     }//if
  629.     ndbrequire((xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage) < 16);
  630.     xlcStruct.UPPtr.i = xlcStruct.DbsiPtr.p->pdxDataPage[xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage];
  631.     ptrCheckGuard(xlcStruct.UPPtr, cnoOfUndoPage, undoPage);
  632.     xlcGetLogHeader(xlcStruct);
  633.     getFragmentrec(xlcStruct.FragPtr, xlcStruct.FragId, xlcStruct.TabPtr.p);
  634.     if (xlcStruct.FragPtr.i == RNIL) {
  635.       ljam();
  636.       continue;
  637.     }//if
  638.     if (xlcStruct.FragPtr.p->fragStatus != SYSTEM_RESTART) {
  639.       ljam();
  640.       continue;
  641.     }//if
  642.     ndbrequire(xlcStruct.LogRecordType < ZNO_CHECKPOINT_RECORDS);
  643.     cSrUndoRecords[xlcStruct.LogRecordType]++;
  644.     switch (xlcStruct.LogRecordType) {
  645.     case ZLCPR_TYPE_INSERT_TH:
  646.       ljam();
  647.       xlcInsertTh(xlcStruct);
  648.       break;
  649.     case ZLCPR_TYPE_DELETE_TH:
  650.       ljam();
  651.       xlcDeleteTh(xlcStruct);
  652.       break;
  653.     case ZLCPR_TYPE_UPDATE_TH:
  654.       ljam();
  655.       xlcUpdateTh(xlcStruct);
  656.       break;
  657.     case ZLCPR_TYPE_INSERT_TH_NO_DATA:
  658.       ljam();
  659.       xlcInsertTh(xlcStruct);
  660.       break;
  661.     case ZLCPR_ABORT_UPDATE:
  662.       ljam();
  663.       xlcAbortUpdate(signal, xlcStruct);
  664.       break;
  665.     case ZLCPR_ABORT_INSERT:
  666.       ljam();
  667.       xlcAbortInsert(signal, xlcStruct);
  668.       break;
  669.     case ZTABLE_DESCRIPTOR:
  670.       ljam();
  671.       xlcTableDescriptor(xlcStruct);
  672.       if (xlcStruct.LliPtr.p->lliNumFragments == 0) {
  673.         ljam();
  674.         closeExecUndoLogLab(signal, xlcStruct.LliPtr);
  675.         return;
  676.       }//if
  677.       break;
  678.     case ZLCPR_UNDO_LOG_PAGE_HEADER:
  679.       ljam();
  680.       xlcUndoLogPageHeader(xlcStruct);
  681.       break;
  682.     case ZINDICATE_NO_OP_ACTIVE:
  683.       ljam();
  684.       xlcIndicateNoOpActive(xlcStruct);
  685.       break;
  686.     case ZLCPR_TYPE_UPDATE_GCI:
  687.       ljam();
  688.       xlcUpdateGCI(xlcStruct);
  689.       break;
  690.     default:
  691.       ndbrequire(false);
  692.       break;
  693.     }//switch
  694.   } while (1);
  695. }//Dbtup::xlcGetNextRecordLab()
  697. /* ---------------------------------------------------------------- */
  698. /* -----------------   XLC_GET_LOG_HEADER    ---------------------- */
  699. /* ---------------------------------------------------------------- */
  700. void Dbtup::xlcGetLogHeader(XlcStruct& xlcStruct) 
  701. {
  702.   Uint32 pIndex = xlcStruct.PageIndex;
  703.   Uint32 fragId;
  704.   Uint32 tableId;
  705.   Uint32 prevId;
  706.   if ((pIndex + 4) < ZWORDS_ON_PAGE) {
  707.     UndoPage* const regUndoPagePtr = xlcStruct.UPPtr.p;
  708.     ljam();
  709.     xlcStruct.LogRecordType = regUndoPagePtr->undoPageWord[pIndex];
  710.     prevId = regUndoPagePtr->undoPageWord[pIndex + 1];
  711.     tableId = regUndoPagePtr->undoPageWord[pIndex + 2];
  712.     fragId = regUndoPagePtr->undoPageWord[pIndex + 3];
  713.     xlcStruct.PageIndex = pIndex + 4;
  714.   } else {
  715.     ljam();
  716.     xlcStruct.LogRecordType = xlcGetLogWord(xlcStruct);
  717.     prevId = xlcGetLogWord(xlcStruct);
  718.     tableId = xlcGetLogWord(xlcStruct);
  719.     fragId = xlcGetLogWord(xlcStruct);
  720.   }//if
  721.   xlcStruct.LliPtr.p->lliPrevRecordId = prevId;
  722.   xlcStruct.FragId = fragId;
  723.   xlcStruct.TabPtr.i = tableId;
  724.   ptrCheckGuard(xlcStruct.TabPtr, cnoOfTablerec, tablerec);
  725. }//Dbtup::xlcGetLogHeader()
  727. /* ------------------------------------------------------------------- */
  728. /* ---------------------- XLC_GET_LOG_WORD --------------------------- */
  729. /* ------------------------------------------------------------------- */
  730. Uint32 Dbtup::xlcGetLogWord(XlcStruct& xlcStruct) 
  731. {
  732.   Uint32 pIndex = xlcStruct.PageIndex;
  733.   ndbrequire(xlcStruct.UPPtr.p != NULL);
  734.   ndbrequire(pIndex < ZWORDS_ON_PAGE);
  735.   Uint32 logWord = xlcStruct.UPPtr.p->undoPageWord[pIndex];
  736.   pIndex++;
  737.   xlcStruct.PageIndex = pIndex;
  738.   if (pIndex == ZWORDS_ON_PAGE) {
  739.     ljam();
  740.     xlcStruct.PageIndex = ZUNDO_PAGE_HEADER_SIZE;
  741.     xlcStruct.PageId++;
  742.     if ((xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage) >= (2 * ZUB_SEGMENT_SIZE)) {
  743.       ljam();
  744.       xlcStruct.UPPtr.i = RNIL;
  745.       ptrNull(xlcStruct.UPPtr);
  746.     } else {
  747.       ljam();
  748.       Uint32 index = xlcStruct.PageId - xlcStruct.DbsiPtr.p->pdxFilePage;
  749.       ndbrequire(index < 16);
  750.       xlcStruct.UPPtr.i = xlcStruct.DbsiPtr.p->pdxDataPage[index];
  751.       ptrCheckGuard(xlcStruct.UPPtr, cnoOfUndoPage, undoPage);
  752.     }//if
  753.   }//if
  754.   return logWord;
  755. }//Dbtup::xlcGetLogWord()
  757.    /****************************************************/
  758.    /* INSERT A TUPLE HEADER THE DATA IS THE TUPLE DATA */
  759.    /****************************************************/
  760. void Dbtup::xlcInsertTh(XlcStruct& xlcStruct) 
  761. {
  762.   PagePtr pagePtr;
  763.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  764.   Tablerec* const regTabPtr = xlcStruct.TabPtr.p;
  766.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  767.   Uint32 pageIndex = xlcGetLogWord(xlcStruct);
  768.   ndbrequire((pageIndex & 1) == 0);
  769.   pagePtr.i = getRealpid(regFragPtr, fragPageId);
  770.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  771.   Uint32 pageOffset;
  772.   getThAtPageSr(pagePtr.p, pageOffset);
  773.   ndbrequire(pageOffset == (ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1))));
  774.   if (xlcStruct.LogRecordType == ZLCPR_TYPE_INSERT_TH) {
  775.     ljam();
  776.     xlcCopyData(xlcStruct, pageOffset, regTabPtr->tupheadsize, pagePtr);
  777.   } else {
  778.     ndbrequire(xlcStruct.LogRecordType == ZLCPR_TYPE_INSERT_TH_NO_DATA);
  779.     ljam();
  780.   }//if
  781. /* ----------------------------------------*/
  782. /* INDICATE THAT NO OPERATIONS ACTIVE      */
  783. /* ----------------------------------------*/
  784.   ndbrequire(pageOffset < ZWORDS_ON_PAGE);
  785.   pagePtr.p->pageWord[pageOffset] = RNIL;
  786. }//Dbtup::xlcInsertTh()
  788.    /**********************************************/
  789.    /* DELETE A TUPLE HEADER - NO ADDITIONAL DATA */
  790.    /**********************************************/
  791. void Dbtup::xlcDeleteTh(XlcStruct& xlcStruct) 
  792. {
  793.   PagePtr pagePtr;
  794.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  795.   Tablerec* const regTabPtr = xlcStruct.TabPtr.p;
  797.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  798.   Uint32 pageIndex = xlcGetLogWord(xlcStruct);
  799.   ndbrequire((pageIndex & 1) == 0);
  800.   pagePtr.i = getRealpid(regFragPtr, fragPageId);
  801.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  802.   Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1));
  803.   freeThSr(regTabPtr, pagePtr.p, pageOffset);
  804. }//Dbtup::xlcDeleteTh()
  806.    /*****************************************************/
  807.    /* UPDATE A TUPLE HEADER, THE DATA IS THE TUPLE DATA */
  808.    /*****************************************************/
  809. void Dbtup::xlcUpdateTh(XlcStruct& xlcStruct) 
  810. {
  811.   PagePtr pagePtr;
  812.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  813.   Tablerec* const regTabPtr = xlcStruct.TabPtr.p;
  815.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  816.   Uint32 pageIndex = xlcGetLogWord(xlcStruct);
  817.   ndbrequire((pageIndex & 1) == 0);
  818.   pagePtr.i = getRealpid(regFragPtr, fragPageId);
  819.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  820.   Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1));
  821.   xlcCopyData(xlcStruct, pageOffset, regTabPtr->tupheadsize, pagePtr);
  822. /* ----------------------------------------*/
  823. /* INDICATE THAT NO OPERATIONS ACTIVE      */
  824. /* ----------------------------------------*/
  825.   ndbrequire(pageOffset < ZWORDS_ON_PAGE);
  826.   pagePtr.p->pageWord[pageOffset] = RNIL;
  827. }//Dbtup::xlcUpdateTh()
  829.    /**************************************************/
  830.    /* ABORT AN INSERT OPERATION - NO ADDITIONAL DATA */
  831.    /**************************************************/
  832. void Dbtup::xlcAbortInsert(Signal* signal, XlcStruct& xlcStruct) 
  833. {
  834.   PagePtr pagePtr;
  835.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  836.   Tablerec* const regTabPtr = xlcStruct.TabPtr.p;
  838.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  839.   Uint32 pageIndex = xlcGetLogWord(xlcStruct);
  840.   ndbrequire((pageIndex & 1) == 0);
  841.   pagePtr.i = getRealpid(regFragPtr, fragPageId);
  842.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  843.   Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1));
  844.   freeTh(regFragPtr, regTabPtr, signal, pagePtr.p, pageOffset);
  845. }//Dbtup::xlcAbortInsert()
  847.    /*****************************************************/
  848.    /* COPY DATA FROM COPY TUPLE TO ORIGINAL TUPLE       */
  849.    /*****************************************************/
  850. void Dbtup::xlcAbortUpdate(Signal* signal, XlcStruct& xlcStruct) 
  851. {
  852.   PagePtr pagePtr;
  853.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  854.   Tablerec* const regTabPtr = xlcStruct.TabPtr.p;
  855.   Uint32 tuple_size = regTabPtr->tupheadsize;
  857.   Uint32 fragPageIdC = xlcGetLogWord(xlcStruct);
  858.   Uint32 pageIndexC = xlcGetLogWord(xlcStruct);
  859.   ndbrequire((pageIndexC & 1) == 0);
  860.   Uint32 TdestPageId = getRealpid(regFragPtr, fragPageIdC);
  861.   Uint32 TcmDestIndex = ZPAGE_HEADER_SIZE +
  862.                        (tuple_size * (pageIndexC >> 1));
  864.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  865.   Uint32 pageIndex = xlcGetLogWord(xlcStruct);
  866.   ndbrequire((pageIndex & 1) == 0);
  867.   Uint32 TsourcePageId = getRealpid(regFragPtr, fragPageId);
  868.   Uint32 TcmSourceIndex = ZPAGE_HEADER_SIZE +
  869.                          (tuple_size * (pageIndex >> 1));
  870.   Uint32 end_source = tuple_size + TcmSourceIndex;
  871.   Uint32 end_dest = tuple_size + TcmDestIndex;
  873.   void* Tdestination = (void*)&page[TdestPageId].pageWord[TcmDestIndex + 1]; 
  874.   const void* Tsource = 
  875.     (void*)&page[TsourcePageId].pageWord[TcmSourceIndex + 1];
  877.   ndbrequire(TsourcePageId < cnoOfPage &&
  878.              TdestPageId < cnoOfPage &&
  879.              end_source <= ZWORDS_ON_PAGE &&
  880.              end_dest <= ZWORDS_ON_PAGE);
  881.   MEMCOPY_NO_WORDS(Tdestination, Tsource, (tuple_size - 1));
  883.   pagePtr.i = TsourcePageId;
  884.   ptrAss(pagePtr, page);
  885.   freeTh(regFragPtr, regTabPtr, signal, pagePtr.p, TcmSourceIndex);
  887.   pagePtr.i = TdestPageId;
  888.   ptrAss(pagePtr, page);
  889.   pagePtr.p->pageWord[TcmDestIndex] = RNIL;
  890. }//Dbtup::xlcAbortUpdate()
  892.    /*****************************/
  893.    /* RESTORE UPDATED GCI VALUE */
  894.    /*****************************/
  895. void Dbtup::xlcUpdateGCI(XlcStruct& xlcStruct) 
  896. {
  897.   PagePtr pagePtr;
  898.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  899.   Tablerec* const regTabPtr = xlcStruct.TabPtr.p;
  901.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  902.   Uint32 pageIndex = xlcGetLogWord(xlcStruct);
  903.   Uint32 restoredGCI = xlcGetLogWord(xlcStruct);
  905.   ndbrequire((pageIndex & 1) == 0);
  906.   pagePtr.i = getRealpid(regFragPtr, fragPageId);
  907.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  908.   Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1));
  909.   Uint32 gciOffset = pageOffset + regTabPtr->tupGCPIndex;
  910.   ndbrequire((gciOffset < ZWORDS_ON_PAGE) &&
  911.              (regTabPtr->tupGCPIndex < regTabPtr->tupheadsize));
  912.   pagePtr.p->pageWord[gciOffset] = restoredGCI;
  913. }//Dbtup::xlcUpdateGCI()
  915.    /*****************************************************/
  916.    /* READ TABLE DESCRIPTOR FROM UNDO LOG               */
  917.    /*****************************************************/
  918. void Dbtup::xlcTableDescriptor(XlcStruct& xlcStruct) 
  919. {
  920.   xlcStruct.LliPtr.p->lliNumFragments--;
  921.   xlcStruct.FragPtr.p->fragStatus = ACTIVE;
  922. }//Dbtup::xlcTableDescriptor()
  924.    /********************************************************/
  925.    /* UPDATE PAGE STATE AND NEXT POINTER IN PAGE           */
  926.    /********************************************************/
  927. void Dbtup::xlcUndoLogPageHeader(XlcStruct& xlcStruct) 
  928. {
  929.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  930.   PagePtr xlcPagep;
  932.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  933.   xlcPagep.i = getRealpid(regFragPtr, fragPageId);
  934.   ptrCheckGuard(xlcPagep, cnoOfPage, page);
  935.   Uint32 logWord = xlcGetLogWord(xlcStruct);
  936.   ndbrequire(logWord != 0);
  937.   ndbrequire(logWord <= ZAC_MM_FREE_COPY);
  939.   xlcPagep.p->pageWord[ZPAGE_STATE_POS] = logWord;
  940.   xlcPagep.p->pageWord[ZPAGE_NEXT_POS] = xlcGetLogWord(xlcStruct);
  941. }//Dbtup::xlcUndoLogPageHeader()
  943.    /********************************************************/
  944.    /* INDICATE THAT NO OPERATIONS ACTIVE                   */
  945.    /********************************************************/
  946. void Dbtup::xlcIndicateNoOpActive(XlcStruct& xlcStruct) 
  947. {
  948.   PagePtr pagePtr;
  949.   Fragrecord* const regFragPtr = xlcStruct.FragPtr.p;
  950.   Tablerec* const regTabPtr = xlcStruct.TabPtr.p;
  952.   Uint32 fragPageId = xlcGetLogWord(xlcStruct);
  953.   Uint32 pageIndex = xlcGetLogWord(xlcStruct);
  954.   ndbrequire((pageIndex & 1) == 0);
  955.   pagePtr.i = getRealpid(regFragPtr, fragPageId);
  956.   ptrCheckGuard(pagePtr, cnoOfPage, page);
  957.   Uint32 pageOffset = ZPAGE_HEADER_SIZE + (regTabPtr->tupheadsize * (pageIndex >> 1));
  958. /* ----------------------------------------*/
  959. /* INDICATE THAT NO OPERATIONS ACTIVE      */
  960. /* ----------------------------------------*/
  961.   ndbrequire(pageOffset < ZWORDS_ON_PAGE);
  962.   pagePtr.p->pageWord[pageOffset] = RNIL;
  963. }//Dbtup::xlcIndicateNoOpActive()
  965.    /********************************************************/
  966.    /* THIS IS THE COMMON ROUTINE TO COPY DATA FROM THE     */
  967.    /* UNDO BUFFER TO THE DATA PAGES. IT USES THE           */
  968.    /* XLC_REQUEST_SEGMENT SUB TO GET MORE DATA WHEN NEEDED */
  969.    /********************************************************/
  970. void Dbtup::xlcCopyData(XlcStruct& xlcStruct, Uint32 pageOffset, Uint32 noOfWords, PagePtr pagePtr) 
  971. {
  972.   ndbrequire((pageOffset + noOfWords - 1) < ZWORDS_ON_PAGE);
  973.   for (Uint32 i = 1; i < noOfWords; i++) {
  974.     ljam();
  975.     pagePtr.p->pageWord[pageOffset + i] = xlcGetLogWord(xlcStruct);
  976.   }//for
  977. }//Dbtup::xlcCopyData()
  979. void Dbtup::allocRestartUndoBufferSegment(Signal* signal, DiskBufferSegmentInfoPtr& dbsiPtr, LocalLogInfoPtr lliPtr) 
  980. {
  981.   UndoPagePtr undoPagePtr;
  983.   ndbrequire(cfirstfreeUndoSeg != RNIL);
  984.   if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) {
  985.     EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1);
  986.     ljamEntry();
  987.   }//if
  988.   cnoFreeUndoSeg--;
  989.   ndbrequire(cnoFreeUndoSeg >= 0);
  990.   undoPagePtr.i = cfirstfreeUndoSeg;
  991.   ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage);
  992.   cfirstfreeUndoSeg = undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS];
  993.   undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL;
  994.   seizeDiskBufferSegmentRecord(dbsiPtr);
  995.   dbsiPtr.p->pdxBuffertype = UNDO_RESTART_PAGES;
  996.   dbsiPtr.p->pdxUndoBufferSet[0] = undoPagePtr.i;
  997.   Uint32 i;
  998.   for (i = 0; i < ZUB_SEGMENT_SIZE; i++) {
  999.     dbsiPtr.p->pdxDataPage[i] = undoPagePtr.i + i;
  1000.   }//for
  1002.   ndbrequire(cfirstfreeUndoSeg != RNIL);
  1003.   if (cnoFreeUndoSeg == ZMIN_PAGE_LIMIT_TUP_COMMITREQ) {
  1004.     EXECUTE_DIRECT(DBLQH, GSN_TUP_COM_BLOCK, signal, 1);
  1005.     ljamEntry();
  1006.   }//if
  1007.   cnoFreeUndoSeg--;
  1008.   ndbrequire(cnoFreeUndoSeg >= 0);
  1009.   undoPagePtr.i = cfirstfreeUndoSeg;
  1010.   ptrCheckGuard(undoPagePtr, cnoOfUndoPage, undoPage);
  1011.   cfirstfreeUndoSeg = undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS];
  1012.   undoPagePtr.p->undoPageWord[ZPAGE_NEXT_POS] = RNIL;
  1013.   dbsiPtr.p->pdxUndoBufferSet[1] = undoPagePtr.i;
  1014. //  lliPtr.p->lliUndoPage = undoPagePtr.i;
  1015.   for (i = ZUB_SEGMENT_SIZE; i < (2 * ZUB_SEGMENT_SIZE); i++) {
  1016.     dbsiPtr.p->pdxDataPage[i] = undoPagePtr.i + (i - ZUB_SEGMENT_SIZE);
  1017.   }//for
  1018.   return;
  1019. }//Dbtup::allocRestartUndoBufferSegment()