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

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef DBLQH_H
  14. #define DBLQH_H
  15. #include <pc.hpp>
  16. #include <ndb_limits.h>
  17. #include <SimulatedBlock.hpp>
  18. #include <DLList.hpp>
  19. #include <DLFifoList.hpp>
  20. #include <DLHashTable.hpp>
  21. #include <NodeBitmask.hpp>
  22. #include <signaldata/LCP.hpp>
  23. #include <signaldata/LqhTransConf.hpp>
  24. #include <signaldata/LqhFrag.hpp>
  25. #ifdef DBLQH_C
  26. // Constants
  27. /* ------------------------------------------------------------------------- */
  28. /*       CONSTANTS USED WHEN MASTER REQUESTS STATE OF COPY FRAGMENTS.        */
  29. /* ------------------------------------------------------------------------- */
  30. #define ZCOPY_CLOSING 0
  31. #define ZCOPY_ONGOING 1
  32. #define ZCOPY_ACTIVATION 2
  33. /* ------------------------------------------------------------------------- */
  34. /*       STATES FOR THE VARIABLE GCP_LOG_PART_STATE                          */
  35. /* ------------------------------------------------------------------------- */
  36. #define ZIDLE 0
  37. #define ZWAIT_DISK 1
  38. #define ZON_DISK 2
  39. #define ZACTIVE 1
  40. /* ------------------------------------------------------------------------- */
  41. /*       STATES FOR THE VARIABLE CSR_PHASES_STARTED                          */
  42. /* ------------------------------------------------------------------------- */
  43. #define ZSR_NO_PHASE_STARTED 0
  44. #define ZSR_PHASE1_COMPLETED 1
  45. #define ZSR_PHASE2_COMPLETED 2
  46. #define ZSR_BOTH_PHASES_STARTED 3
  47. /* ------------------------------------------------------------------------- */
  48. /*       THE NUMBER OF PAGES IN A MBYTE, THE TWO LOGARITHM OF THIS.          */
  49. /*       THE NUMBER OF MBYTES IN A LOG FILE.                                 */
  50. /*       THE MAX NUMBER OF PAGES READ/WRITTEN FROM/TO DISK DURING            */
  51. /*       A WRITE OR READ.                                                    */
  52. /* ------------------------------------------------------------------------- */
  53. #define ZNOT_DIRTY 0
  54. #define ZDIRTY 1
  55. #define ZREAD_AHEAD_SIZE 8
  56. /* ------------------------------------------------------------------------- */
  57. /*       CONSTANTS OF THE LOG PAGES                                          */
  58. /* ------------------------------------------------------------------------- */
  59. #define ZPAGE_HEADER_SIZE 32
  60. #define ZNO_MBYTES_IN_FILE 16
  61. #define ZPAGE_SIZE 8192
  62. #define ZPAGES_IN_MBYTE 32
  63. #define ZTWOLOG_NO_PAGES_IN_MBYTE 5
  64. #define ZTWOLOG_PAGE_SIZE 13
  65. #define ZMAX_MM_BUFFER_SIZE 32     // Main memory window during log execution
  66. #define ZMAX_PAGES_WRITTEN 8    // Max pages before writing to disk (=> config)
  67. #define ZMIN_READ_BUFFER_SIZE 2       // Minimum number of pages to execute log
  68. #define ZMIN_LOG_PAGES_OPERATION 10   // Minimum no of pages before stopping
  69. #define ZPOS_CHECKSUM 0
  70. #define ZPOS_LOG_LAP 1
  71. #define ZPOS_MAX_GCI_COMPLETED 2
  72. #define ZPOS_MAX_GCI_STARTED 3
  73. #define ZNEXT_PAGE 4
  74. #define ZPREV_PAGE 5
  75. #define ZPOS_VERSION 6
  76. #define ZPOS_NO_LOG_FILES 7
  77. #define ZCURR_PAGE_INDEX 8
  78. #define ZLAST_LOG_PREP_REF 10
  79. #define ZPOS_DIRTY 11
  80. /* A number of debug items written in the page header of all log files */
  81. #define ZPOS_LOG_TIMER 12
  82. #define ZPOS_PAGE_I 13
  83. #define ZPOS_PLACE_WRITTEN_FROM 14
  84. #define ZPOS_PAGE_NO 15
  85. #define ZPOS_PAGE_FILE_NO 16
  86. #define ZPOS_WORD_WRITTEN 17
  87. #define ZPOS_IN_WRITING 18
  88. #define ZPOS_PREV_PAGE_NO 19
  89. #define ZPOS_IN_FREE_LIST 20
  90. /* ------------------------------------------------------------------------- */
  91. /*       CONSTANTS FOR THE VARIOUS REPLICA AND NODE TYPES.                   */
  92. /* ------------------------------------------------------------------------- */
  93. #define ZPRIMARY_NODE 0
  94. #define ZBACKUP_NODE 1
  95. #define ZSTANDBY_NODE 2
  96. #define ZTC_NODE 3
  97. #define ZLOG_NODE 3
  98. /* ------------------------------------------------------------------------- */
  99. /*       VARIOUS CONSTANTS USED AS FLAGS TO THE FILE MANAGER.                */
  100. /* ------------------------------------------------------------------------- */
  101. #define ZOPEN_READ 0
  102. #define ZOPEN_WRITE 1
  103. #define ZOPEN_READ_WRITE 2
  104. #define ZVAR_NO_LOG_PAGE_WORD 1
  105. #define ZLIST_OF_PAIRS 0
  106. #define ZLIST_OF_PAIRS_SYNCH 16
  107. #define ZARRAY_OF_PAGES 1
  108. #define ZLIST_OF_MEM_PAGES 2
  109. #define ZLIST_OF_MEM_PAGES_SYNCH 18
  110. #define ZCLOSE_NO_DELETE 0
  111. #define ZCLOSE_DELETE 1
  112. #define ZPAGE_ZERO 0
  113. /* ------------------------------------------------------------------------- */
  114. /*       THE FOLLOWING CONSTANTS ARE USED TO DESCRIBE THE TYPES OF           */
  115. /*       LOG RECORDS, THE SIZE OF THE VARIOUS LOG RECORD TYPES AND           */
  116. /*       THE POSITIONS WITHIN THOSE LOG RECORDS.                             */
  117. /* ------------------------------------------------------------------------- */
  118. /* ------------------------------------------------------------------------- */
  119. /*       THESE CONSTANTS DESCRIBE THE SIZES OF VARIOUS TYPES OF LOG REORDS.  */
  120. /*       NEXT_LOG_SIZE IS ACTUALLY ONE. THE REASON WE SET IT TO 2 IS TO      */
  121. /*       SIMPLIFY THE CODE SINCE OTHERWISE HAVE TO USE A SPECIAL VERSION     */
  122. /*       OF READ_LOGWORD WHEN READING LOG RECORD TYPE                        */
  123. /*       SINCE NEXT MBYTE TYPE COULD BE THE VERY LAST WORD IN THE MBYTE.     */
  124. /*       BY SETTING IT TO 2 WE ENSURE IT IS NEVER THE VERY LAST WORD         */
  125. /*       IN THE MBYTE.                                                       */
  126. /* ------------------------------------------------------------------------- */
  127. #define ZFD_HEADER_SIZE 3
  128. #define ZFD_PART_SIZE 48
  129. #define ZLOG_HEAD_SIZE 6
  130. #define ZNEXT_LOG_SIZE 2
  131. #define ZABORT_LOG_SIZE 3
  132. #define ZCOMMIT_LOG_SIZE 9
  133. #define ZCOMPLETED_GCI_LOG_SIZE 2
  134. /* ------------------------------------------------------------------------- */
  135. /*       THESE CONSTANTS DESCRIBE THE TYPE OF A LOG RECORD.                  */
  136. /*       THIS IS THE FIRST WORD OF A LOG RECORD.                             */
  137. /* ------------------------------------------------------------------------- */
  138. #define ZNEW_PREP_OP_TYPE 0
  139. #define ZPREP_OP_TYPE 1
  140. #define ZCOMMIT_TYPE 2
  141. #define ZABORT_TYPE 3
  142. #define ZFD_TYPE 4
  143. #define ZFRAG_SPLIT_TYPE 5
  144. #define ZNEXT_LOG_RECORD_TYPE 6
  145. #define ZNEXT_MBYTE_TYPE 7
  146. #define ZCOMPLETED_GCI_TYPE 8
  147. #define ZINVALID_COMMIT_TYPE 9
  148. /* ------------------------------------------------------------------------- */
  149. /*       THE POSITIONS OF LOGGED DATA IN A FILE DESCRIPTOR LOG RECORD HEADER.*/
  150. /*       ALSO THE MAXIMUM NUMBER OF FILE DESCRIPTORS IN A LOG RECORD.        */
  151. /* ------------------------------------------------------------------------- */
  152. #define ZPOS_LOG_TYPE 0
  153. #define ZPOS_NO_FD 1
  154. #define ZPOS_FILE_NO 2
  155. #define ZMAX_LOG_FILES_IN_PAGE_ZERO 40
  156. /* ------------------------------------------------------------------------- */
  157. /*       THE POSITIONS WITHIN A PREPARE LOG RECORD AND A NEW PREPARE         */
  158. /*       LOG RECORD.                                                         */
  159. /* ------------------------------------------------------------------------- */
  160. #define ZPOS_HASH_VALUE 2
  161. #define ZPOS_SCHEMA_VERSION 3
  162. #define ZPOS_TRANS_TICKET 4
  163. #define ZPOS_OP_TYPE 5
  164. #define ZPOS_NO_ATTRINFO 6
  165. #define ZPOS_NO_KEYINFO 7
  166. /* ------------------------------------------------------------------------- */
  167. /*       THE POSITIONS WITHIN A COMMIT LOG RECORD.                           */
  168. /* ------------------------------------------------------------------------- */
  169. #define ZPOS_COMMIT_TRANSID1 1
  170. #define ZPOS_COMMIT_TRANSID2 2
  171. #define ZPOS_COMMIT_GCI 3
  172. #define ZPOS_COMMIT_TABLE_REF 4
  173. #define ZPOS_COMMIT_FRAGID 5
  174. #define ZPOS_COMMIT_FILE_NO 6
  175. #define ZPOS_COMMIT_START_PAGE_NO 7
  176. #define ZPOS_COMMIT_START_PAGE_INDEX 8
  177. #define ZPOS_COMMIT_STOP_PAGE_NO 9
  178. /* ------------------------------------------------------------------------- */
  179. /*       THE POSITIONS WITHIN A ABORT LOG RECORD.                            */
  180. /* ------------------------------------------------------------------------- */
  181. #define ZPOS_ABORT_TRANSID1 1
  182. #define ZPOS_ABORT_TRANSID2 2
  183. /* ------------------------------------------------------------------------- */
  184. /*       THE POSITION WITHIN A COMPLETED GCI LOG RECORD.                     */
  185. /* ------------------------------------------------------------------------- */
  186. #define ZPOS_COMPLETED_GCI 1
  187. /* ------------------------------------------------------------------------- */
  188. /*       THE POSITIONS WITHIN A NEW PREPARE LOG RECORD.                      */
  189. /* ------------------------------------------------------------------------- */
  190. #define ZPOS_NEW_PREP_FILE_NO 8
  191. #define ZPOS_NEW_PREP_PAGE_REF 9
  192. #define ZLAST_WRITE_IN_FILE 1
  193. #define ZENFORCE_WRITE 2
  194. /* ------------------------------------------------------------------------- */
  195. /*       CONSTANTS USED AS INPUT TO SUBROUTINE WRITE_LOG_PAGES AMONG OTHERS. */
  196. /* ------------------------------------------------------------------------- */
  197. #define ZNORMAL 0
  198. #define ZINIT 1
  199. /* ------------------------------------------------------------------------- */
  200. /*       CONSTANTS USED BY CONTINUEB TO DEDUCE WHICH CONTINUE SIGNAL IS TO   */
  201. /*       BE EXECUTED AS A RESULT OF THIS CONTINUEB SIGNAL.                   */
  202. /* ------------------------------------------------------------------------- */
  203. #define ZLOG_LQHKEYREQ 0
  204. #define ZPACK_LQHKEYREQ 1
  205. #define ZSEND_ATTRINFO 2
  206. #define ZSR_GCI_LIMITS 3
  207. #define ZSR_LOG_LIMITS 4
  208. #define ZSEND_EXEC_CONF 5
  209. #define ZEXEC_SR 6
  210. #define ZSR_FOURTH_COMP 7
  211. #define ZINIT_FOURTH 8
  212. #define ZTIME_SUPERVISION 9
  213. #define ZSR_PHASE3_START 10
  214. #define ZLQH_TRANS_NEXT 11
  215. #define ZLQH_RELEASE_AT_NODE_FAILURE 12
  216. #define ZSCAN_TC_CONNECT 13
  217. #define ZINITIALISE_RECORDS 14
  218. #define ZINIT_GCP_REC 15
  219. #define ZRESTART_OPERATIONS_AFTER_STOP 16
  220. #define ZCHECK_LCP_STOP_BLOCKED 17
  221. #define ZSCAN_MARKERS 18
  222. #define ZOPERATION_EVENT_REP 19
  223. #define ZPREP_DROP_TABLE 20
  224. /* ------------------------------------------------------------------------- */
  225. /*        NODE STATE DURING SYSTEM RESTART, VARIABLES CNODES_SR_STATE        */
  226. /*        AND CNODES_EXEC_SR_STATE.                                          */
  227. /* ------------------------------------------------------------------------- */
  228. #define ZSTART_SR 1
  229. #define ZEXEC_SR_COMPLETED 2
  230. /* ------------------------------------------------------------------------- */
  231. /*       CONSTANTS USED BY NODE STATUS TO DEDUCE THE STATUS OF A NODE.       */
  232. /* ------------------------------------------------------------------------- */
  233. #define ZNODE_UP 0
  234. #define ZNODE_DOWN 1
  235. /* ------------------------------------------------------------------------- */
  236. /*       START PHASES                                                        */
  237. /* ------------------------------------------------------------------------- */
  238. #define ZLAST_START_PHASE 255
  239. #define ZSTART_PHASE1 1
  240. #define ZSTART_PHASE2 2
  241. #define ZSTART_PHASE3 3
  242. #define ZSTART_PHASE4 4
  243. #define ZSTART_PHASE6 6
  244. /* ------------------------------------------------------------------------- */
  245. /*       CONSTANTS USED BY SCAN AND COPY FRAGMENT PROCEDURES                 */
  246. /* ------------------------------------------------------------------------- */
  247. #define ZSTORED_PROC_SCAN 0
  248. #define ZSTORED_PROC_COPY 2
  249. #define ZDELETE_STORED_PROC_ID 3
  250. //#define ZSCAN_NEXT 1
  251. //#define ZSCAN_NEXT_COMMIT 2
  252. //#define ZSCAN_NEXT_ABORT 12
  253. #define ZCOPY_COMMIT 3
  254. #define ZCOPY_REPEAT 4
  255. #define ZCOPY_ABORT 5
  256. #define ZCOPY_CLOSE 6
  257. //#define ZSCAN_CLOSE 6
  258. //#define ZEMPTY_FRAGMENT 0
  259. #define ZWRITE_LOCK 1
  260. #define ZSCAN_FRAG_CLOSED 2
  261. /* ------------------------------------------------------------------------- */
  262. /*       ERROR CODES ADDED IN VERSION 0.1 AND 0.2                            */
  263. /* ------------------------------------------------------------------------- */
  264. #define ZNOT_FOUND 1             // Not an error code, a return value
  265. #define ZNO_FREE_LQH_CONNECTION 414
  266. #define ZGET_DATAREC_ERROR 418
  267. #define ZGET_ATTRINBUF_ERROR 419
  268. #define ZNO_FREE_FRAGMENTREC 460 // Insert new fragment error code
  269. #define ZTAB_FILE_SIZE 464       // Insert new fragment error code + Start kernel
  270. #define ZNO_ADD_FRAGREC 465      // Insert new fragment error code
  271. /* ------------------------------------------------------------------------- */
  272. /*       ERROR CODES ADDED IN VERSION 0.3                                    */
  273. /* ------------------------------------------------------------------------- */
  274. #define ZTAIL_PROBLEM_IN_LOG_ERROR 410
  275. #define ZGCI_TOO_LOW_ERROR 429        // GCP_SAVEREF error code
  276. #define ZTAB_STATE_ERROR 474          // Insert new fragment error code
  277. #define ZTOO_NEW_GCI_ERROR 479        // LCP Start error
  278. /* ------------------------------------------------------------------------- */
  279. /*       ERROR CODES ADDED IN VERSION 0.4                                    */
  280. /* ------------------------------------------------------------------------- */
  281. #define ZNO_FREE_FRAG_SCAN_REC_ERROR 490 // SCAN_FRAGREF error code
  282. #define ZCOPY_NO_FRAGMENT_ERROR 491      // COPY_FRAGREF error code
  283. #define ZTAKE_OVER_ERROR 499
  284. #define ZCOPY_NODE_ERROR 1204
  285. #define ZTOO_MANY_COPY_ACTIVE_ERROR 1208 // COPY_FRAG and COPY_ACTIVEREF code
  286. #define ZCOPY_ACTIVE_ERROR 1210          // COPY_ACTIVEREF error code
  287. #define ZNO_TC_CONNECT_ERROR 1217        // Simple Read + SCAN
  288. /* ------------------------------------------------------------------------- */
  289. /*       ERROR CODES ADDED IN VERSION 1.X                                    */
  290. /* ------------------------------------------------------------------------- */
  291. //#define ZSCAN_BOOK_ACC_OP_ERROR 1219   // SCAN_FRAGREF error code
  292. #define ZFILE_CHANGE_PROBLEM_IN_LOG_ERROR 1220
  293. #define ZTEMPORARY_REDO_LOG_FAILURE 1221
  294. #define ZNO_FREE_MARKER_RECORDS_ERROR 1222
  295. #define ZNODE_SHUTDOWN_IN_PROGESS 1223
  296. #define ZTOO_MANY_FRAGMENTS 1224
  297. #define ZTABLE_NOT_DEFINED 1225
  298. #define ZDROP_TABLE_IN_PROGRESS 1226
  299. #define ZINVALID_SCHEMA_VERSION 1227
  300. /* ------------------------------------------------------------------------- */
  301. /*       ERROR CODES ADDED IN VERSION 2.X                                    */
  302. /* ------------------------------------------------------------------------- */
  303. #define ZNODE_FAILURE_ERROR 400
  304. /* ------------------------------------------------------------------------- */
  305. /*       ERROR CODES FROM ACC                                                */
  306. /* ------------------------------------------------------------------------- */
  307. #define ZNO_TUPLE_FOUND 626
  308. #define ZTUPLE_ALREADY_EXIST 630
  309. /* ------------------------------------------------------------------------- */
  310. /*       ERROR CODES FROM TUP                                                */
  311. /* ------------------------------------------------------------------------- */
  312. #define ZSEARCH_CONDITION_FALSE 899
  313. #define ZUSER_ERROR_CODE_LIMIT 6000
  314. #endif
  315. /** 
  316.  * @class dblqh
  317.  *
  318.  * @section secIntro Introduction
  319.  *
  320.  * Dblqh is the coordinator of the LDM.  Dblqh is responsible for 
  321.  * performing operations on tuples.  It does this job with help of 
  322.  * Dbacc block (that manages the index structures) and Dbtup
  323.  * (that manages the tuples).
  324.  *
  325.  * Dblqh also keeps track of the participants and acts as a coordinator of
  326.  * 2-phase commits.  Logical redo logging is also handled by the Dblqh
  327.  * block.
  328.  *
  329.  * @section secModules Modules
  330.  *
  331.  * The code is partitioned into the following modules:
  332.  * - START / RESTART 
  333.  *   - Start phase 1: Load our block reference and our processor id
  334.  *   - Start phase 2: Initiate all records within the block
  335.  *                    Connect LQH with ACC and TUP.
  336.  *   - Start phase 4: Connect LQH with LQH.  Connect every LQH with 
  337.  *                    every LQH in the database system.           
  338.  *               If initial start, then create the fragment log files.
  339.  *               If system restart or node restart, 
  340.  *                    then open the fragment log files and   
  341.  *               find the end of the log files.
  342.  * - ADD / DELETE FRAGMENT<br>
  343.  *     Used by dictionary to create new fragments and delete old fragments.
  344.  *  - EXECUTION<br>
  345.  *    handles the reception of lqhkeyreq and all processing        
  346.  *    of operations on behalf of this request. 
  347.  *    This does also involve reception of various types of attrinfo 
  348.  *    and keyinfo. 
  349.  *    It also involves communication with ACC and TUP.
  350.  *  - LOG<br>
  351.  *    The log module handles the reading and writing of the log.
  352.  *    It is also responsible for handling system restart. 
  353.  *    It controls the system restart in TUP and ACC as well.
  354.  *  - TRANSACTION<br>
  355.  *    This module handles the commit and the complete phases.
  356.  *  - MODULE TO HANDLE TC FAILURE<br>
  357.  *  - SCAN<br>
  358.  *    This module contains the code that handles a scan of a particular 
  359.  *    fragment.
  360.  *    It operates under the control of TC and orders ACC to 
  361.  *    perform a scan of all tuples in the fragment.
  362.  *    TUP performs the necessary search conditions
  363.  *    to ensure that only valid tuples are returned to the application.
  364.  *  - NODE RECOVERY<br>
  365.  *    Used when a node has failed. 
  366.  *    It performs a copy of a fragment to a new replica of the fragment. 
  367.  *    It does also shut down all connections to the failed node.
  368.  *  - LOCAL CHECKPOINT<br>
  369.  *    Handles execution and control of LCPs
  370.  *    It controls the LCPs in TUP and ACC. 
  371.  *    It also interacts with DIH to control which GCPs are recoverable.
  372.  *  - GLOBAL CHECKPOINT<br>
  373.  *    Helps DIH in discovering when GCPs are recoverable. 
  374.  *    It handles the request gcp_savereq that requests LQH to 
  375.  *    save a particular GCP to disk and respond when completed.  
  376.  *  - FILE HANDLING<br>
  377.  *    With submodules: 
  378.  *    - SIGNAL RECEPTION
  379.  *    - NORMAL OPERATION
  380.  *    - FILE CHANGE
  381.  *    - INITIAL START
  382.  *    - SYSTEM RESTART PHASE ONE
  383.  *    - SYSTEM RESTART PHASE TWO,
  384.  *    - SYSTEM RESTART PHASE THREE
  385.  *    - SYSTEM RESTART PHASE FOUR
  386.  *  - ERROR 
  387.  *  - TEST 
  388.  *  - LOG 
  389.  */
  390. class Dblqh: public SimulatedBlock {
  391. public:
  392.   enum LcpCloseState {
  393.     LCP_IDLE = 0,
  394.     LCP_RUNNING = 1,       // LCP is running
  395.     LCP_CLOSE_STARTED = 2, // Completion(closing of files) has started
  396.     ACC_LCP_CLOSE_COMPLETED = 3,
  397.     TUP_LCP_CLOSE_COMPLETED = 4
  398.   };
  399.   enum ExecUndoLogState {
  400.     EULS_IDLE = 0,
  401.     EULS_STARTED = 1,
  402.     EULS_COMPLETED = 2,
  403.     EULS_ACC_COMPLETED = 3,
  404.     EULS_TUP_COMPLETED = 4
  405.   };
  406.   struct AddFragRecord {
  407.     enum AddFragStatus {
  408.       FREE = 0,
  409.       ACC_ADDFRAG = 1,
  410.       WAIT_TWO_TUP = 2,
  411.       WAIT_ONE_TUP = 3,
  412.       WAIT_TWO_TUX = 4,
  413.       WAIT_ONE_TUX = 5,
  414.       WAIT_ADD_ATTR = 6,
  415.       TUP_ATTR_WAIT1 = 7,
  416.       TUP_ATTR_WAIT2 = 8,
  417.       TUX_ATTR_WAIT1 = 9,
  418.       TUX_ATTR_WAIT2 = 10
  419.     };
  420.     LqhAddAttrReq::Entry attributes[LqhAddAttrReq::MAX_ATTRIBUTES];
  421.     UintR accConnectptr;
  422.     AddFragStatus addfragStatus;
  423.     UintR dictConnectptr;
  424.     UintR fragmentPtr;
  425.     UintR nextAddfragrec;
  426.     UintR noOfAllocPages;
  427.     UintR schemaVer;
  428.     UintR tup1Connectptr;
  429.     UintR tup2Connectptr;
  430.     UintR tux1Connectptr;
  431.     UintR tux2Connectptr;
  432.     UintR checksumIndicator;
  433.     UintR GCPIndicator;
  434.     BlockReference dictBlockref;
  435.     Uint32 m_senderAttrPtr;
  436.     Uint16 addfragErrorCode;
  437.     Uint16 attrSentToTup;
  438.     Uint16 attrReceived;
  439.     Uint16 addFragid;
  440.     Uint16 fragid1;
  441.     Uint16 fragid2;
  442.     Uint16 noOfAttr;
  443.     Uint16 noOfNull;
  444.     Uint16 tabId;
  445.     Uint16 totalAttrReceived;
  446.     Uint16 fragCopyCreation;
  447.     Uint16 noOfKeyAttr;
  448.     Uint32 noOfNewAttr; // noOfCharsets in upper half
  449.     Uint16 noOfAttributeGroups;
  450.     Uint16 lh3DistrBits;
  451.     Uint16 tableType;
  452.     Uint16 primaryTableId;
  453.   };// Size 108 bytes
  454.   typedef Ptr<AddFragRecord> AddFragRecordPtr;
  455.   
  456.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  457.   /* $$$$$$$               ATTRIBUTE INFORMATION RECORD              $$$$$$$ */
  458.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  459.   /**
  460.    *       Can contain one (1) attrinfo signal. 
  461.    *       One signal contains 24 attr. info words. 
  462.    *       But 32 elements are used to make plex happy.  
  463.    *       Some of the elements are used to the following things:
  464.    *       - Data length in this record is stored in the
  465.    *         element indexed by ZINBUF_DATA_LEN.  
  466.    *       - Next attrinbuf is pointed out by the element 
  467.    *         indexed by ZINBUF_NEXT.
  468.    */
  469.   struct Attrbuf {
  470.     UintR attrbuf[32];
  471.   }; // Size 128 bytes
  472.   typedef Ptr<Attrbuf> AttrbufPtr;
  473.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  474.   /* $$$$$$$                         DATA BUFFER                     $$$$$$$ */
  475.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  476.   /**
  477.    *       This buffer is used as a general data storage.                     
  478.    */
  479.   struct Databuf {
  480.     UintR data[4];
  481.     UintR nextDatabuf;
  482.   }; // size 20 bytes
  483.   typedef Ptr<Databuf> DatabufPtr;
  484.   struct ScanRecord {
  485.     enum ScanState {
  486.       SCAN_FREE = 0,
  487.       WAIT_STORED_PROC_COPY = 1,
  488.       WAIT_STORED_PROC_SCAN = 2,
  489.       WAIT_NEXT_SCAN_COPY = 3,
  490.       WAIT_NEXT_SCAN = 4,
  491.       WAIT_DELETE_STORED_PROC_ID_SCAN = 5,
  492.       WAIT_DELETE_STORED_PROC_ID_COPY = 6,
  493.       WAIT_ACC_COPY = 7,
  494.       WAIT_ACC_SCAN = 8,
  495.       WAIT_SCAN_KEYINFO = 9,
  496.       WAIT_SCAN_NEXTREQ = 10,
  497.       WAIT_COPY_KEYINFO = 11,
  498.       WAIT_CLOSE_SCAN = 12,
  499.       WAIT_CLOSE_COPY = 13,
  500.       WAIT_RELEASE_LOCK = 14,
  501.       WAIT_TUPKEY_COPY = 15,
  502.       WAIT_LQHKEY_COPY = 16,
  503.       IN_QUEUE = 17
  504.     };
  505.     enum ScanType {
  506.       ST_IDLE = 0,
  507.       SCAN = 1,
  508.       COPY = 2
  509.     };
  510.     UintR scan_acc_op_ptr[32];
  511.     Uint32 scan_acc_index;
  512.     Uint32 scan_acc_attr_recs;
  513.     UintR scanApiOpPtr;
  514.     UintR scanLocalref[2];
  515.     
  516.     Uint32 m_max_batch_size_rows;
  517.     Uint32 m_max_batch_size_bytes;
  518.     Uint32 m_curr_batch_size_rows;
  519.     Uint32 m_curr_batch_size_bytes;
  520.     bool check_scan_batch_completed() const;
  521.     
  522.     UintR copyPtr;
  523.     union {
  524.       Uint32 nextPool;
  525.       Uint32 nextList;
  526.     };
  527.     Uint32 prevList;
  528.     Uint32 nextHash;
  529.     Uint32 prevHash;
  530.     bool equal(const ScanRecord & key) const {
  531.       return scanNumber == key.scanNumber && fragPtrI == key.fragPtrI;
  532.     }
  533.     Uint32 hashValue() const {
  534.       return fragPtrI ^ scanNumber;
  535.     }
  536.     
  537.     UintR scanAccPtr;
  538.     UintR scanAiLength;
  539.     UintR scanErrorCounter;
  540.     UintR scanLocalFragid;
  541.     UintR scanSchemaVersion;
  542.     /**
  543.      * This is _always_ main table, even in range scan
  544.      *   in which case scanTcrec->fragmentptr is different
  545.      */
  546.     Uint32 fragPtrI;
  547.     UintR scanStoredProcId;
  548.     ScanState scanState;
  549.     UintR scanTcrec;
  550.     ScanType scanType;
  551.     BlockReference scanApiBlockref;
  552.     NodeId scanNodeId;
  553.     Uint16 scanReleaseCounter;
  554.     Uint16 scanNumber;
  555.  
  556.     Uint8 scanCompletedStatus;
  557.     Uint8 scanFlag;
  558.     Uint8 scanLockHold;
  559.     Uint8 scanLockMode;
  560.     Uint8 readCommitted;
  561.     Uint8 rangeScan;
  562.     Uint8 scanTcWaiting;
  563.     Uint8 scanKeyinfoFlag;
  564.     Uint8 m_last_row;
  565.   }; // Size 272 bytes
  566.   typedef Ptr<ScanRecord> ScanRecordPtr;
  567.   struct Fragrecord {
  568.     enum ExecSrStatus {
  569.       IDLE = 0,
  570.       ACTIVE_REMOVE_AFTER = 1,
  571.       ACTIVE = 2
  572.     };
  573.     /**
  574.      * Possible state transitions are:
  575.      * - FREE -> DEFINED                 Fragment record is allocated
  576.      * - DEFINED -> ACTIVE               Add fragment is completed and 
  577.      *                                   fragment is ready to      
  578.      *                                   receive operations.
  579.      * - DEFINED -> ACTIVE_CREATION      Add fragment is completed and 
  580.      *                                   fragment is ready to      
  581.      *                                   receive operations in parallel 
  582.      *                                   with a copy fragment     
  583.      *                                   which is performed from the 
  584.      *                                   primary replica             
  585.      * - DEFINED -> CRASH_RECOVERING     A fragment is ready to be 
  586.      *                                   recovered from a local        
  587.      *                                   checkpoint on disk
  588.      * - ACTIVE -> BLOCKED               A local checkpoint is to be 
  589.      *                                   started.  No more operations 
  590.      *                                   are allowed to be started until 
  591.      *                                   the local checkpoint    
  592.      *                                   has been started.
  593.      * - ACTIVE -> REMOVING              A fragment is removed from the node
  594.      * - BLOCKED -> ACTIVE               Operations are allowed again in 
  595.      *                                   the fragment.           
  596.      * - CRASH_RECOVERING -> ACTIVE      A fragment has been recovered and 
  597.      *                                   are now ready for     
  598.      *                                   operations again.
  599.      * - CRASH_RECOVERING -> REMOVING    Fragment recovery failed or 
  600.      *                                   was cancelled.              
  601.      * - ACTIVE_CREATION -> ACTIVE       A fragment is now copied and now 
  602.      *                                   is a normal fragment   
  603.      * - ACTIVE_CREATION -> REMOVING     Copying of the fragment failed
  604.      * - REMOVING -> FREE                Removing of the fragment is 
  605.      *                                   completed and the fragment  
  606.      *                                   is now free again.
  607.      */
  608.     enum FragStatus {
  609.       FREE = 0,               ///< Fragment record is currently not in use
  610.       FSACTIVE = 1,           ///< Fragment is defined and usable for operations
  611.       DEFINED = 2,            ///< Fragment is defined but not yet usable by 
  612.                               ///< operations
  613.       BLOCKED = 3,            ///< LQH is waiting for all active operations to 
  614.                               ///< complete the current phase so that the 
  615.                               ///< local checkpoint can be started.
  616.       ACTIVE_CREATION = 4,    ///< Fragment is defined and active but is under 
  617.                               ///< creation by the primary LQH.
  618.       CRASH_RECOVERING = 5,   ///< Fragment is recovering after a crash by 
  619.                               ///< executing the fragment log and so forth. 
  620.                               ///< Will need further breakdown.
  621.       REMOVING = 6            ///< The fragment is currently removed. 
  622.                               ///< Operations are not allowed. 
  623.     };
  624.     enum LogFlag {
  625.       STATE_TRUE = 0,
  626.       STATE_FALSE = 1
  627.     };
  628.     enum SrStatus {
  629.       SS_IDLE = 0,
  630.       SS_STARTED = 1,
  631.       SS_COMPLETED = 2
  632.     };
  633.     enum LcpFlag {
  634.       LCP_STATE_TRUE = 0,
  635.       LCP_STATE_FALSE = 1
  636.     };
  637.     /**
  638.      *        Last GCI for executing the fragment log in this phase.
  639.      */
  640.     UintR execSrLastGci[4];
  641.     /**
  642.      *       Start GCI for executing the fragment log in this phase.
  643.      */
  644.     UintR execSrStartGci[4];
  645.     /**
  646.      *       Requesting user pointer for executing the fragment log in
  647.      *       this phase
  648.      */
  649.     UintR execSrUserptr[4];
  650.     /**
  651.      *       The LCP identifier of the LCP's. 
  652.      *       =0 means that the LCP number has not been stored.
  653.      *       The LCP identifier is supplied by DIH when starting the LCP.   
  654.      */
  655.     UintR lcpId[MAX_LCP_STORED];
  656.     UintR maxGciInLcp;
  657.     /**
  658.      *       This variable contains the maximum global checkpoint 
  659.      *       identifier that exists in a certain local checkpoint. 
  660.      *       Maximum 4 local checkpoints is possible in this release.
  661.      */
  662.     UintR maxGciCompletedInLcp;
  663.     UintR srLastGci[4];
  664.     UintR srStartGci[4];
  665.     /**
  666.      *       The fragment pointers in ACC
  667.      */
  668.     UintR accFragptr[2];
  669.     /**
  670.      *       The EXEC_SR variables are used to keep track of which fragments  
  671.      *       that are interested in being executed as part of executing the    
  672.      *       fragment loop. 
  673.      *       It is initialised for every phase of executing the 
  674.      *       fragment log (the fragment log can be executed upto four times).  
  675.      *                                                                         
  676.      *       Each execution is capable of executing the log records on four    
  677.      *       fragment replicas.                                                
  678.      */
  679.     /**
  680.      *       Requesting block reference for executing the fragment log
  681.      *       in this phase.
  682.      */
  683.     BlockReference execSrBlockref[4];
  684.     /**
  685.      *       This variable contains references to active scan and copy     
  686.      *       fragment operations on the fragment. 
  687.      *       A maximum of four concurrently active is allowed.
  688.      */
  689.     typedef Bitmask<4> ScanNumberMask;
  690.     ScanNumberMask m_scanNumberMask;
  691.     DLList<ScanRecord>::Head m_activeScans;
  692.     DLFifoList<ScanRecord>::Head m_queuedScans;
  693.     Uint16 srLqhLognode[4];
  694.     /**
  695.      *       The fragment pointers in TUP and TUX
  696.      */
  697.     UintR tupFragptr[2];
  698.     UintR tuxFragptr[2];
  699.     /**
  700.      *       This queue is where operations are put when blocked in ACC
  701.      *       during start of a local chkp.
  702.      */
  703.     UintR accBlockedList;
  704.     /**
  705.      *       This is the queue where all operations that are active on the     
  706.      *       fragment is put. 
  707.      *       This is used to deduct when the fragment do 
  708.      *       no longer contain any active operations. 
  709.      *       This is needed when starting a local checkpoint.
  710.      */
  711.     UintR activeList;
  712.     /**
  713.      *       This variable keeps track of how many operations that are 
  714.      *       active that have skipped writing the log but not yet committed 
  715.      *       or aborted.  This is used during start of fragment.
  716.      */
  717.     UintR activeTcCounter;
  718.     /**
  719.      *       This status specifies whether this fragment is actively 
  720.      *       engaged in executing the fragment log.
  721.      */
  722.     ExecSrStatus execSrStatus;
  723.     /**
  724.      *       The fragment id of this fragment.
  725.      */
  726.     UintR fragId;
  727.     /**
  728.      *       Status of fragment
  729.      */
  730.     FragStatus fragStatus;
  731.     /**
  732.      *       Indicates a local checkpoint is active and thus can generate
  733.      *       UNDO log records.
  734.      */
  735.     UintR fragActiveStatus;
  736.     /**
  737.      *       Reference to current LCP record. 
  738.      *       If no LCP is ongoing on the fragment then the value is RNIL.
  739.      *       If LCP_REF /= RNIL then a local checkpoint is ongoing in the 
  740.      *       fragment.
  741.      *       LCP_STATE in LCP_RECORD specifies the state of the 
  742.      *       local checkpoint.
  743.      */
  744.     UintR lcpRef;
  745.     /**
  746.      *       This flag indicates whether logging is currently activated at 
  747.      *       the fragment.  
  748.      *       During a system restart it is temporarily shut off. 
  749.      *       Some fragments have it permanently shut off. 
  750.      */
  751.     LogFlag logFlag;
  752.     UintR masterPtr;
  753.     /**
  754.      *       This variable contains the maximum global checkpoint identifier 
  755.      *       which was completed when the local checkpoint was started.
  756.      */
  757.     /**
  758.      *       Reference to the next fragment record in a free list of fragment 
  759.      *       records.              
  760.      */
  761.     UintR nextFrag;
  762.     /**
  763.      *       The newest GCI that has been committed on fragment             
  764.      */
  765.     UintR newestGci;
  766.     SrStatus srStatus;
  767.     UintR srUserptr;
  768.     /**
  769.      *       The starting global checkpoint of this fragment.
  770.      */
  771.     UintR startGci;
  772.     /**
  773.      *       A reference to the table owning this fragment.
  774.      */
  775.     UintR tabRef;
  776.     /**
  777.      *       This is the queue to put operations that have been blocked 
  778.      *       during start of a local chkp.
  779.      */
  780.     UintR firstWaitQueue;
  781.     UintR lastWaitQueue;
  782.     /**
  783.      *       The block reference to ACC on the fragment makes it
  784.      *       possible to have different ACC blocks for different
  785.      *       fragments in the future.
  786.      */
  787.     BlockReference accBlockref;
  788.     /**
  789.      *       Ordered index block.
  790.      */
  791.     BlockReference tuxBlockref;
  792.     /**
  793.      *       The master block reference as sent in COPY_ACTIVEREQ.
  794.      */
  795.     BlockReference masterBlockref;
  796.     /**
  797.      *       These variables are used during system restart to recall
  798.      *       from which node to execute the fragment log and which GCI's
  799.      *       this node should start and stop from. Also to remember who
  800.      *       to send the response to when system restart is completed.
  801.      */
  802.     BlockReference srBlockref;
  803.     /**
  804.      *       The block reference to TUP on the fragment makes it
  805.      *       possible to have different TUP blocks for different
  806.      *       fragments in the future.
  807.      */
  808.     BlockReference tupBlockref;
  809.     /**
  810.      *      This state indicates if the fragment will participate in a
  811.      *      checkpoint.  
  812.      *      Temporary tables with Fragrecord::logFlag permanently off
  813.      *      will also have Fragrecord::lcpFlag off.
  814.      */
  815.     LcpFlag lcpFlag;
  816.     /**
  817.      *       Used to ensure that updates started with old
  818.      *       configuration do not arrive here after the copy fragment
  819.      *       has started. 
  820.      *       If they are allowed to arrive after they
  821.      *       could update a record that has already been replicated to
  822.      *       the new node.  This type of arrival should be extremely
  823.      *       rare but we must anyway ensure that no harm is done.
  824.      */
  825.     Uint16 copyNode;
  826.     /**
  827.      *       This variable ensures that only one copy fragment is
  828.      *       active at a time on the fragment.
  829.      */
  830.     Uint8 copyFragState;
  831.     /**
  832.      *       The number of fragment replicas that will execute the log
  833.      *       records in this round of executing the fragment
  834.      *       log.  Maximum four is possible.
  835.      */
  836.     Uint8 execSrNoReplicas;
  837.     /**
  838.      *       This variable contains what type of replica this fragment
  839.      *       is.  Two types are possible:  
  840.      *       - Primary/Backup replica = 0
  841.      *       - Stand-by replica = 1 
  842.      *
  843.      *       It is not possible to distinguish between primary and
  844.      *       backup on a fragment.  
  845.      *       This can only be done per transaction. 
  846.      *       DIH can change from primary to backup without informing
  847.      *       the various replicas about this change.
  848.      */
  849.     Uint8 fragCopy;
  850.     /**
  851.      *       This is the last fragment distribution key that we have
  852.      *       heard of.
  853.      */
  854.     Uint8 fragDistributionKey;
  855.     /**
  856.      *       Used to calculate which local fragment to use.                  
  857.      */
  858.     Uint8 hashCheckBit;
  859.     /**
  860.      *       The identity of the next local checkpoint this fragment
  861.      *       should perform.
  862.      */
  863.     Uint8 nextLcp;
  864.    /**
  865.      *       How many local checkpoints does the fragment contain
  866.      */
  867.     Uint8 srChkpnr;
  868.     Uint8 srNoLognodes;
  869.     /**
  870.      *       Table type.
  871.      */
  872.     Uint8 tableType;
  873.     /**
  874.      *       For ordered index fragment, i-value of corresponding
  875.      *       fragment in primary table.
  876.      */
  877.     UintR tableFragptr;
  878.   };
  879.   typedef Ptr<Fragrecord> FragrecordPtr;
  880.   
  881.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  882.   /* $$$$$$$                GLOBAL CHECKPOINT RECORD                  $$$$$$ */
  883.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  884.   /**
  885.    *       This record describes a global checkpoint that is
  886.    *       completed.  It waits for all log records belonging to this
  887.    *       global checkpoint to be saved on disk.
  888.    */
  889.   struct GcpRecord {
  890.     /**
  891.      *       The file number within each log part where the log was
  892.      *       located when gcp_savereq was received. The last record 
  893.      *       belonging to this global checkpoint is certainly before 
  894.      *       this place in the log. We could come even closer but it 
  895.      *       would cost performance and doesn't seem like a good 
  896.      *       idea. This is simple and it works.
  897.      */
  898.     Uint16 gcpFilePtr[4];
  899.     /** 
  900.      *       The page number within the file for each log part.
  901.      */
  902.     Uint16 gcpPageNo[4];
  903.     /**
  904.      *       The word number within the last page that was written for
  905.      *       each log part.
  906.      */
  907.     Uint16 gcpWordNo[4];
  908.     /**
  909.      *       The identity of this global checkpoint.
  910.      */
  911.     UintR gcpId;
  912.     /**
  913.      *       The state of this global checkpoint, one for each log part.
  914.      */
  915.     Uint8 gcpLogPartState[4];
  916.     /**
  917.      *       The sync state of this global checkpoint, one for each
  918.      *       log part.
  919.      */
  920.     Uint8 gcpSyncReady[4];
  921.     /**
  922.      *       User pointer of the sender of gcp_savereq (= master DIH).
  923.      */
  924.     UintR gcpUserptr;
  925.     /**
  926.      *       Block reference of the sender of gcp_savereq 
  927.      *       (= master DIH).
  928.      */
  929.     BlockReference gcpBlockref;
  930.   }; // Size 44 bytes
  931.   typedef Ptr<GcpRecord> GcpRecordPtr;
  932.   struct HostRecord {
  933.     bool inPackedList;
  934.     UintR noOfPackedWordsLqh;
  935.     UintR packedWordsLqh[30];
  936.     UintR noOfPackedWordsTc;
  937.     UintR packedWordsTc[29];
  938.     BlockReference hostLqhBlockRef;
  939.     BlockReference hostTcBlockRef;
  940.   };// Size 128 bytes
  941.   typedef Ptr<HostRecord> HostRecordPtr;
  942.   
  943.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  944.   /* $$$$$$$              LOCAL CHECKPOINT RECORD                    $$$$$$$ */
  945.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  946.   /** 
  947.    *       This record contains the information about a local
  948.    *       checkpoint that is ongoing. This record is also used as a
  949.    *       system restart record.
  950.    */
  951.   struct LcpRecord {
  952.     LcpRecord() { m_EMPTY_LCP_REQ.clear(); }
  953.     
  954.     enum LcpState {
  955.       LCP_IDLE = 0,
  956.       LCP_COMPLETED = 2,
  957.       LCP_WAIT_FRAGID = 3,
  958.       LCP_WAIT_TUP_PREPLCP = 4,
  959.       LCP_WAIT_HOLDOPS = 5,
  960.       LCP_WAIT_ACTIVE_FINISH = 6,
  961.       LCP_START_CHKP = 7,
  962.       LCP_BLOCKED_COMP = 8,
  963.       LCP_SR_WAIT_FRAGID = 9,
  964.       LCP_SR_STARTED = 10,
  965.       LCP_SR_COMPLETED = 11
  966.     };
  967.     Uint32 firstLcpLocAcc;
  968.     Uint32 firstLcpLocTup;
  969.     Uint32 lcpAccptr;
  970.  
  971.     LcpState lcpState;
  972.     bool lastFragmentFlag;
  973.     struct FragOrd {
  974.       Uint32 fragPtrI;
  975.       LcpFragOrd lcpFragOrd;
  976.     };
  977.     FragOrd currentFragment;
  978.     
  979.     bool   lcpQueued;
  980.     FragOrd queuedFragment;
  981.     
  982.     bool   reportEmpty;
  983.     NdbNodeBitmask m_EMPTY_LCP_REQ;
  984.   }; // Size 76 bytes
  985.   typedef Ptr<LcpRecord> LcpRecordPtr;
  986.   
  987.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  988.   /* $$$$$$               LOCAL CHECKPOINT SUPPORT RECORD            $$$$$$$ */
  989.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  990.   /**
  991.    *      This record contains the information about an outstanding
  992.    *      request to TUP or ACC. Used for both local checkpoints and
  993.    *      system restart.
  994.    */
  995.   struct LcpLocRecord {
  996.     enum LcpLocstate {
  997.       IDLE = 0,
  998.       WAIT_TUP_PREPLCP = 1,
  999.       WAIT_LCPHOLDOP = 2,
  1000.       HOLDOP_READY = 3,
  1001.       ACC_WAIT_STARTED = 4,
  1002.       ACC_STARTED = 5,
  1003.       ACC_COMPLETED = 6,
  1004.       TUP_WAIT_STARTED = 7,
  1005.       TUP_STARTED = 8,
  1006.       TUP_COMPLETED = 9,
  1007.       SR_ACC_STARTED = 10,
  1008.       SR_TUP_STARTED = 11,
  1009.       SR_ACC_COMPLETED = 12,
  1010.       SR_TUP_COMPLETED = 13
  1011.     };
  1012.     enum WaitingBlock {
  1013.       ACC = 0,
  1014.       TUP = 1,
  1015.       NONE = 2
  1016.     };
  1017.     
  1018.     LcpLocstate lcpLocstate;
  1019.     UintR locFragid;
  1020.     UintR masterLcpRec;
  1021.     UintR nextLcpLoc;
  1022.     UintR tupRef;
  1023.     WaitingBlock waitingBlock;
  1024.     Uint32 accContCounter;
  1025.   }; // 28 bytes
  1026.   typedef Ptr<LcpLocRecord> LcpLocRecordPtr;
  1027.   
  1028.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1029.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1030.   /*                                                                          */
  1031.   /*       THE RECORDS THAT START BY LOG_ ARE A PART OF THE LOG MANAGER.      */
  1032.   /*       THESE RECORDS ARE USED TO HANDLE THE FRAGMENT LOG.                 */
  1033.   /*                                                                          */
  1034.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1035.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1036.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1037.   /* $$$$$$$                       LOG RECORD                         $$$$$$$ */
  1038.   /*                                                                          */
  1039.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1040.   /*       THIS RECORD IS ALIGNED TO BE 256 BYTES.                            */
  1041.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1042.   /**       
  1043.    *       This record describes the current state of a log. 
  1044.    *       A log consists of a number of log files. 
  1045.    *       These log files are described by the log file record.
  1046.    *
  1047.    *       There will be 4 sets of log files. 
  1048.    *       Different tables will use different log files dependent 
  1049.    *       on the table id. 
  1050.    *       This  ensures that more than one outstanding request can 
  1051.    *       be sent to the file system.
  1052.    *       The log file to use is found by performing a very simple hash
  1053.    *       function.
  1054.    */
  1055.   struct LogPartRecord {
  1056.     enum LogPartState {
  1057.       IDLE = 0,                       ///< Nothing happens at the moment
  1058.       ACTIVE = 1,                     ///< An operation is active logging 
  1059.       SR_FIRST_PHASE = 2,             ///< Finding the end of the log and 
  1060.                                       ///< the information about global 
  1061.                                       ///< checkpoints in the log is ongoing.
  1062.       SR_FIRST_PHASE_COMPLETED = 3,   ///< First phase completed
  1063.       SR_THIRD_PHASE_STARTED = 4,     ///< Executing fragment log is in 3rd ph
  1064.       SR_THIRD_PHASE_COMPLETED = 5,
  1065.       SR_FOURTH_PHASE_STARTED = 6,    ///< Finding the log tail and head 
  1066.                                       ///< is the fourth phase.
  1067.       SR_FOURTH_PHASE_COMPLETED = 7,
  1068.       FILE_CHANGE_PROBLEM = 8,        ///< For some reason the write to 
  1069.                                       ///< page zero in file zero have not   
  1070.                                       ///< finished after 15 mbyte of 
  1071.                                       ///< log data have been written
  1072.       TAIL_PROBLEM = 9                ///< Only 1 mbyte of log left. 
  1073.                                       ///< No operations allowed to enter the 
  1074.                                       ///< log. Only special log records 
  1075.                                       ///< are allowed
  1076.     };
  1077.     enum WaitWriteGciLog {
  1078.       WWGL_TRUE = 0,
  1079.       WWGL_FALSE = 1
  1080.     };
  1081.     enum LogExecState {
  1082.       LES_IDLE = 0,
  1083.       LES_SEARCH_STOP = 1,
  1084.       LES_SEARCH_START = 2,
  1085.       LES_EXEC_LOG = 3,
  1086.       LES_EXEC_LOG_NEW_MBYTE = 4,
  1087.       LES_EXEC_LOG_NEW_FILE = 5,
  1088.       LES_EXEC_LOGREC_FROM_FILE = 6,
  1089.       LES_EXEC_LOG_COMPLETED = 7,
  1090.       LES_WAIT_READ_EXEC_SR_NEW_MBYTE = 8,
  1091.       LES_WAIT_READ_EXEC_SR = 9,
  1092.       LES_EXEC_LOG_INVALIDATE = 10
  1093.     };
  1094.     /**
  1095.      *       Is a CONTINUEB(ZLOG_LQHKEYREQ) signal sent and
  1096.      *       outstanding. We do not want several instances of this
  1097.      *       signal out in the air since that would create multiple
  1098.      *       writers of the list.
  1099.      */
  1100.     UintR LogLqhKeyReqSent;
  1101.     /**
  1102.      *       Contains the current log file where log records are
  1103.      *       written.  During system restart it is used to indicate the
  1104.      *       last log file.
  1105.      */
  1106.     UintR currentLogfile;
  1107.     /**
  1108.      *       The log file used to execute log records from far behind.
  1109.      */
  1110.     UintR execSrExecLogFile;
  1111.     /**
  1112.      *       The currently executing prepare record starts in this log
  1113.      *       page. This variable is used to enable that a log record is
  1114.      *       executed multiple times in execution of the log.
  1115.      */
  1116.     UintR execSrLogPage;
  1117.     /**
  1118.      *       This variable keeps track of the lfo record where the
  1119.      *       pages that were read from disk when an operations log
  1120.      *       record were not found in the main memory buffer for log
  1121.      *       pages.
  1122.      */
  1123.     UintR execSrLfoRec;
  1124.     /**
  1125.      *       The starting page number when reading log from far behind.
  1126.      */
  1127.     UintR execSrStartPageNo;
  1128.     /**
  1129.      *       The last page number when reading log from far behind.
  1130.      */
  1131.     UintR execSrStopPageNo;
  1132.     /**
  1133.      *       Contains a reference to the first log file, file number 0.
  1134.      */
  1135.     UintR firstLogfile;
  1136.     /**
  1137.      *       The head of the operations queued for logging.
  1138.      */
  1139.     UintR firstLogQueue;
  1140.     /** 
  1141.      *       This variable contains the oldest operation in this log
  1142.      *       part which have not been committed yet.
  1143.      */
  1144.     UintR firstLogTcrec;
  1145.     /**
  1146.      *       The first reference to a set of 8 pages. These are used
  1147.      *       during execution of the log to keep track of which pages
  1148.      *       are in memory and which are not.
  1149.      */
  1150.     UintR firstPageRef;
  1151.     /**
  1152.      *       This variable contains the global checkpoint record
  1153.      *       waiting for disk writes to complete.
  1154.      */
  1155.     UintR gcprec;
  1156.     /**
  1157.      *       The last reference to a set of 8 pages.  These are used
  1158.      *       during execution of the log to keep track of which pages
  1159.      *       are in memory and which are not.
  1160.      */
  1161.     UintR lastPageRef;
  1162.     /**
  1163.      *       The tail of the operations queued for logging.                   
  1164.      */
  1165.     UintR lastLogQueue;
  1166.     /**
  1167.      *       This variable contains the newest operation in this log
  1168.      *       part which have not been committed yet.
  1169.      */
  1170.     UintR lastLogTcrec;
  1171.     /**
  1172.      *       This variable indicates which was the last mbyte that was
  1173.      *       written before the system crashed.  Discovered during
  1174.      *       system restart.
  1175.      */
  1176.     UintR lastLogfile;
  1177.     /**
  1178.      *       This variable is used to keep track of the state during
  1179.      *       the third phase of the system restart, i.e. when
  1180.      *       LogPartRecord::logPartState == 
  1181.      *       LogPartRecord::SR_THIRD_PHASE_STARTED.
  1182.      */
  1183.     LogExecState logExecState;
  1184.     /**
  1185.      *       This variable contains the lap number of this log part.
  1186.      */
  1187.     UintR logLap;
  1188.     /**
  1189.      *       This variable contains the place to stop executing the log
  1190.      *       in this phase.
  1191.      */
  1192.     UintR logLastGci;
  1193.     /**
  1194.      *       This variable contains the place to start executing the
  1195.      *       log in this phase.
  1196.      */
  1197.     UintR logStartGci;
  1198.     /**
  1199.      *       The latest GCI completed in this log part.
  1200.      */
  1201.     UintR logPartNewestCompletedGCI;
  1202.     /**
  1203.      *       The current state of this log part.                               
  1204.      */
  1205.     LogPartState logPartState;
  1206.     /**
  1207.      *       A timer that is set every time a log page is sent to disk.
  1208.      *       Ensures that log pages are not kept in main memory for
  1209.      *       more than a certain time.
  1210.      */
  1211.     UintR logPartTimer;
  1212.     /**
  1213.      *       The current timer which is set by the periodic signal
  1214.      *       received by LQH
  1215.      */
  1216.     UintR logTimer;
  1217.     /** 
  1218.      *       Contains the number of the log tail file and the mbyte
  1219.      *       reference within that file.  This information ensures that
  1220.      *       the tail is not overwritten when writing new log records.
  1221.      */
  1222.     UintR logTailFileNo;
  1223.     /**
  1224.      *       The TcConnectionrec used during execution of this log part.
  1225.      */
  1226.     UintR logTcConrec;
  1227.     /**
  1228.      *       The number of pages that currently resides in the main
  1229.      *       memory buffer.  It does not refer pages that are currently
  1230.      *       read from the log files.  Only to pages already read
  1231.      *       from the log file.
  1232.      */
  1233.     UintR mmBufferSize;
  1234.     /**
  1235.      *       Contains the current number of log files in this log part. 
  1236.      */
  1237.     UintR noLogFiles;
  1238.     /**
  1239.      *       This variable is used only during execution of a log
  1240.      *       record.  It keeps track of in which page record a log
  1241.      *       record was started.  It is used then to deduce which
  1242.      *       pages that are dirty after that the log records on the
  1243.      *       page have been executed.
  1244.      *
  1245.      *       It is also used to find out where to write the invalidate
  1246.      *       command when that is needed.
  1247.      */
  1248.     UintR prevLogpage;
  1249.     /**
  1250.      *       The number of files remaining to gather GCI information
  1251.      *       for during system restart.  Only used if number of files
  1252.      *       is larger than 60.
  1253.      */
  1254.     UintR srRemainingFiles;
  1255.     /**
  1256.      *       The log file where to start executing the log during
  1257.      *       system restart.
  1258.      */
  1259.     UintR startLogfile;
  1260.     /**
  1261.      *       The last log file in which to execute the log during system 
  1262.      *       restart.                    
  1263.      */
  1264.     UintR stopLogfile;
  1265.     /**
  1266.      *       This variable keeps track of when we want to write a complete 
  1267.      *       gci log record but have been blocked by an ongoing log operation.
  1268.      */
  1269.     WaitWriteGciLog waitWriteGciLog;
  1270.     /**
  1271.      *       The currently executing prepare record starts in this index 
  1272.      *       in the log page.            
  1273.      */
  1274.     Uint16 execSrLogPageIndex;
  1275.     /**
  1276.      *       Which of the four exec_sr's in the fragment is currently executing
  1277.      */
  1278.     Uint16 execSrExecuteIndex;
  1279.     /**
  1280.      *       The number of pages executed in the current mbyte. 
  1281.      */
  1282.     Uint16 execSrPagesExecuted;
  1283.     /**
  1284.      *       The number of pages read from disk that have arrived and are 
  1285.      *       currently awaiting execution of the log.
  1286.      */
  1287.     Uint16 execSrPagesRead;
  1288.     /**
  1289.      *       The number of pages read from disk and currently not arrived 
  1290.      *       to the block.             
  1291.      */
  1292.     Uint16 execSrPagesReading;
  1293.     /**
  1294.      *       This variable refers to the new header file where we will 
  1295.      *       start writing the log after a system restart have been completed.
  1296.      */
  1297.     Uint16 headFileNo;
  1298.     /**
  1299.      *       This variable refers to the page number within the header file.
  1300.      */
  1301.     Uint16 headPageNo;
  1302.     /**
  1303.      *       This variable refers to the index within the new header
  1304.      *       page.
  1305.      */
  1306.     Uint16 headPageIndex;
  1307.     /**
  1308.      *       This variables indicates which was the last mbyte in the last 
  1309.      *       logfile before a system crash. Discovered during system restart.
  1310.      */
  1311.     Uint16 lastMbyte;
  1312.     /**
  1313.      *       This variable is used only during execution of a log
  1314.      *       record. It keeps track of in which file page a log
  1315.      *       record was started.  It is used if it is needed to write a
  1316.      *       dirty page to disk during log execution (this happens when
  1317.      *       commit records are invalidated).
  1318.      */
  1319.     Uint16 prevFilepage;
  1320.     /**
  1321.      *       This is used to save where we were in the execution of log
  1322.      *       records when we find a commit record that needs to be
  1323.      *       executed.
  1324.      *
  1325.      *       This variable is also used to remember the index where the
  1326.      *       log type was in the log record. It is only used in this
  1327.      *       role when finding a commit record that needs to be
  1328.      *       invalidated.
  1329.      */
  1330.     Uint16 savePageIndex;
  1331.     Uint8 logTailMbyte;
  1332.     /**
  1333.      *       The mbyte within the starting log file where to start 
  1334.      *       executing the log.                
  1335.      */
  1336.     Uint8 startMbyte;
  1337.     /**
  1338.      *       The last mbyte in which to execute the log during system
  1339.      *       restart.
  1340.      */
  1341.     Uint8 stopMbyte;
  1342.    /**
  1343.      *       This variable refers to the file where invalidation is
  1344.      *       occuring during system/node restart.
  1345.      */
  1346.     Uint16 invalidateFileNo;
  1347.     /**
  1348.      *       This variable refers to the page where invalidation is
  1349.      *       occuring during system/node restart.
  1350.      */
  1351.     Uint16 invalidatePageNo;
  1352.   }; // Size 164 Bytes
  1353.   typedef Ptr<LogPartRecord> LogPartRecordPtr;
  1354.   
  1355.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1356.   /* $$$$$$$                      LOG FILE RECORD                     $$$$$$$ */
  1357.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1358.   /*       THIS RECORD IS ALIGNED TO BE 288 (256 + 32) BYTES.                 */
  1359.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1360.   /**
  1361.    *              This record contains information about a log file.          
  1362.    *              A log file contains log records from several tables and     
  1363.    *              fragments of a table. LQH can contain more than             
  1364.    *              one log file to ensure faster log processing.               
  1365.    *                                                                          
  1366.    *              The number of pages to write to disk at a time is           
  1367.    *              configurable.                                               
  1368.    */
  1369.   struct LogFileRecord {
  1370.     enum FileChangeState {
  1371.       NOT_ONGOING = 0,
  1372.       BOTH_WRITES_ONGOING = 1,
  1373.       LAST_WRITE_ONGOING = 2,
  1374.       FIRST_WRITE_ONGOING = 3,
  1375.       WRITE_PAGE_ZERO_ONGOING = 4
  1376.     };  
  1377.     enum LogFileStatus {
  1378.       LFS_IDLE = 0,                     ///< Log file record not in use
  1379.       CLOSED = 1,                       ///< Log file closed
  1380.       OPENING_INIT = 2,
  1381.       OPEN_SR_FRONTPAGE = 3,            ///< Log file opened as part of system
  1382.                                         ///< restart.  Open file 0 to find  
  1383.                                         ///< the front page of the log part.
  1384.       OPEN_SR_LAST_FILE = 4,            ///< Open last log file that was written
  1385.                                         ///< before the system restart.  
  1386.       OPEN_SR_NEXT_FILE = 5,            ///< Open a log file which is 16 files 
  1387.                                         ///< backwards to find the next    
  1388.                                         ///< information about GCPs.
  1389.       OPEN_EXEC_SR_START = 6,           ///< Log file opened as part of 
  1390.                                         ///< executing 
  1391.                                         ///< log during system restart. 
  1392.       OPEN_EXEC_SR_NEW_MBYTE = 7,
  1393.       OPEN_SR_FOURTH_PHASE = 8,
  1394.       OPEN_SR_FOURTH_NEXT = 9,
  1395.       OPEN_SR_FOURTH_ZERO = 10,
  1396.       OPENING_WRITE_LOG = 11,           ///< Log file opened as part of writing 
  1397.                                         ///< log during normal operation. 
  1398.       OPEN_EXEC_LOG = 12,
  1399.       CLOSING_INIT = 13,
  1400.       CLOSING_SR = 14,                  ///< Log file closed as part of system 
  1401.                                         ///< restart.  Currently trying to  
  1402.                                         ///< find where to start executing the 
  1403.                                         ///< log
  1404.       CLOSING_EXEC_SR = 15,             ///< Log file closed as part of 
  1405.                                         ///< executing log during system restart
  1406.       CLOSING_EXEC_SR_COMPLETED = 16,
  1407.       CLOSING_WRITE_LOG = 17,           ///< Log file closed as part of writing 
  1408.                                         ///< log during normal operation. 
  1409.       CLOSING_EXEC_LOG = 18,
  1410.       OPEN_INIT = 19,
  1411.       OPEN = 20,                         ///< Log file open
  1412.       OPEN_SR_INVALIDATE_PAGES = 21,
  1413.       CLOSE_SR_INVALIDATE_PAGES = 22
  1414.     };
  1415.     
  1416.     /**
  1417.      *       When a new mbyte is started in the log we have to find out
  1418.      *       how far back in the log we still have prepared operations
  1419.      *       which have been neither committed or aborted.  This variable
  1420.      *       keeps track of this value for each of the mbytes in this
  1421.      *       log file.  This is used in writing down these values in the
  1422.      *       header of each log file.  That information is used during
  1423.      *       system restart to find the tail of the log.  
  1424.      */
  1425.     UintR logLastPrepRef[16];
  1426.     /**
  1427.      *       The max global checkpoint completed before the mbyte in the
  1428.      *       log file was started.  One variable per mbyte.  
  1429.      */
  1430.     UintR logMaxGciCompleted[16];
  1431.     /**
  1432.      *       The max global checkpoint started before the mbyte in the log
  1433.      *       file was started.  One variable per mbyte.
  1434.      */
  1435.     UintR logMaxGciStarted[16];
  1436.     /**
  1437.      *       This variable contains the file name as needed by the file 
  1438.      *       system when opening the file.
  1439.      */
  1440.     UintR fileName[4];
  1441.     /**
  1442.      *       This variable has a reference to the log page which is 
  1443.      *       currently in use by the log.     
  1444.      */
  1445.     UintR currentLogpage;
  1446.     /**
  1447.      *       The number of the current mbyte in the log file.
  1448.      */
  1449.     UintR currentMbyte;
  1450.     /**
  1451.      *       This variable is used when changing files.  It is to find
  1452.      *       out when both the last write in the previous file and the
  1453.      *       first write in this file has been completed.  After these
  1454.      *       writes have completed the variable keeps track of when the
  1455.      *       write to page zero in file zero is completed.  
  1456.      */
  1457.     FileChangeState fileChangeState;
  1458.     /**
  1459.      *       The number of the file within this log part.
  1460.      */
  1461.     UintR fileNo;
  1462.     /**
  1463.      *       This variable shows where to read/write the next pages into
  1464.      *       the log.  Used when writing the log during normal operation
  1465.      *       and when reading the log during system restart.  It
  1466.      *       specifies the page position where each page is 8 kbyte.
  1467.      */
  1468.     UintR filePosition;
  1469.     /**
  1470.      *       This contains the file pointer needed by the file system
  1471.      *       when reading/writing/closing and synching.  
  1472.      */
  1473.     UintR fileRef;
  1474.     /**
  1475.      *       The head of the pages waiting for shipment to disk. 
  1476.      *       They are filled with log info. 
  1477.      */
  1478.     UintR firstFilledPage;
  1479.     /**
  1480.      *       A list of active read/write operations on the log file.
  1481.      *       Operations are always put in last and the first should
  1482.      *       always complete first.  
  1483.      */
  1484.     UintR firstLfo;
  1485.     UintR lastLfo;
  1486.     /**
  1487.      *       The tail of the pages waiting for shipment to disk. 
  1488.      *       They are filled with log info.
  1489.      */
  1490.     UintR lastFilledPage;
  1491.     /**
  1492.      *       This variable keeps track of the last written page in the
  1493.      *       file while writing page zero in file zero when changing log
  1494.      *       file.  
  1495.      */
  1496.     UintR lastPageWritten;
  1497.     /**
  1498.      *       This variable keeps track of the last written word in the
  1499.      *       last page written in the file while writing page zero in
  1500.      *       file zero when changing log file.  
  1501.      */
  1502.     UintR lastWordWritten;
  1503.     /**
  1504.      *       This variable contains the last word written in the last page.
  1505.      */
  1506.     UintR logFilePagesToDiskWithoutSynch;
  1507.     /**
  1508.      *       This variable keeps track of the number of pages written since
  1509.      *       last synch on this log file.
  1510.      */
  1511.     LogFileStatus logFileStatus;
  1512.     /**
  1513.      *       A reference to page zero in this file. 
  1514.      *       This page is written before the file is closed.  
  1515.      */
  1516.     UintR logPageZero;
  1517.     /**
  1518.      *       This variable contains a reference to the record describing 
  1519.      *       this log part.   One of four records (0,1,2 or 3).
  1520.      */
  1521.     UintR logPartRec;
  1522.     /**
  1523.      *       Next free log file record or next log file in this log.
  1524.      */
  1525.     UintR nextLogFile;
  1526.     /**
  1527.      *       The previous log file.
  1528.      */
  1529.     UintR prevLogFile;
  1530.     /**
  1531.      *       The number of remaining words in this mbyte of the log file.
  1532.      */
  1533.     UintR remainingWordsInMbyte;
  1534.     /**
  1535.      *       The current file page within the current log file. This is
  1536.      *       a reference within the file and not a reference to a log
  1537.      *       page record.  It is used to deduce where log records are
  1538.      *       written.  Particularly completed gcp records and prepare log
  1539.      *       records.  
  1540.      */
  1541.     Uint16 currentFilepage;
  1542.     /**
  1543.      *       The number of pages in the list referenced by 
  1544.      *       LOG_PAGE_BUFFER.
  1545.      */
  1546.     Uint16 noLogpagesInBuffer;
  1547.   }; // Size 288 bytes
  1548.   typedef Ptr<LogFileRecord> LogFileRecordPtr;
  1549.   
  1550.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1551.   /* $$$$$$$                      LOG OPERATION RECORD                $$$$$$$ */
  1552.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1553.   /**
  1554.    * This record contains a currently active file operation
  1555.    * that has started by the log module.
  1556.    */
  1557.   struct LogFileOperationRecord {
  1558.     enum LfoState {
  1559.       IDLE = 0,                         ///< Operation is not used at the moment
  1560.       INIT_WRITE_AT_END = 1,            ///< Write in file so that it grows to 
  1561.                                         ///< 16 Mbyte
  1562.       INIT_FIRST_PAGE = 2,              ///< Initialise the first page in a file
  1563.       WRITE_GCI_ZERO = 3,
  1564.       WRITE_INIT_MBYTE = 4,
  1565.       WRITE_DIRTY = 5,
  1566.       READ_SR_FRONTPAGE = 6,            ///< Read page zero in file zero during 
  1567.                                         ///< system restart               
  1568.       READ_SR_LAST_FILE = 7,            ///< Read page zero in last file open 
  1569.                                         ///< before system crash            
  1570.       READ_SR_NEXT_FILE = 8,            ///< Read 60 files backwards to find 
  1571.                                         ///< further information GCPs in page
  1572.                                         ///< zero
  1573.       READ_SR_LAST_MBYTE = 9,
  1574.       READ_EXEC_SR = 10,
  1575.       READ_EXEC_LOG = 11,
  1576.       READ_SR_FOURTH_PHASE = 12,
  1577.       READ_SR_FOURTH_ZERO = 13,
  1578.       FIRST_PAGE_WRITE_IN_LOGFILE = 14,
  1579.       LAST_WRITE_IN_FILE = 15,
  1580.       WRITE_PAGE_ZERO = 16,
  1581.       ACTIVE_WRITE_LOG = 17,             ///< A write operation during 
  1582.                                         ///< writing of log
  1583.       READ_SR_INVALIDATE_PAGES = 18,
  1584.       WRITE_SR_INVALIDATE_PAGES = 19
  1585.     };
  1586.     /**
  1587.      * We have to remember the log pages read. 
  1588.      * Otherwise we cannot build the linked list after the pages have 
  1589.      * arrived to main memory.  
  1590.      */
  1591.     UintR logPageArray[16];
  1592.     /**
  1593.      * A list of the pages that are part of this active operation.
  1594.      */
  1595.     UintR firstLfoPage;
  1596.     /**
  1597.      * A timer to ensure that records are not lost.
  1598.      */
  1599.     UintR lfoTimer;
  1600.     /**
  1601.      * The word number of the last written word in the last during
  1602.      * a file write.  
  1603.      */
  1604.     UintR lfoWordWritten;
  1605.     /**
  1606.      * This variable contains the state of the log file operation.     
  1607.      */
  1608.     LfoState lfoState;
  1609.     /**
  1610.      * The log file that the file operation affects.
  1611.      */
  1612.     UintR logFileRec;
  1613.     /**
  1614.      * The log file operations on a file are kept in a linked list.
  1615.      */
  1616.     UintR nextLfo;
  1617.     /**
  1618.      * The page number of the first read/written page during a file 
  1619.      * read/write.                
  1620.      */
  1621.     Uint16 lfoPageNo;
  1622.     /**
  1623.      * The number of pages written or read during an operation to
  1624.      * the log file.                
  1625.      */
  1626.     Uint16 noPagesRw;
  1627.   }; // 92 bytes
  1628.   typedef Ptr<LogFileOperationRecord> LogFileOperationRecordPtr;
  1629.   
  1630.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1631.   /* $$$$$$$                      LOG PAGE RECORD                     $$$$$$$ */
  1632.   /* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ */
  1633.   /**
  1634.    *    These are the 8 k pages used to store log records before storing
  1635.    *    them in the file system. 
  1636.    *    Since 64 kbyte is sent to disk at a time it is necessary to have   
  1637.    *    at least 4*64 kbytes of log pages. 
  1638.    *    To handle multiple outstanding requests we need some additional pages. 
  1639.    *    Thus we allocate 1 mbyte to ensure that we do not get problems with 
  1640.    *    insufficient number of pages.
  1641.    */
  1642.   struct LogPageRecord {
  1643.     /**
  1644.      * This variable contains the pages that are sent to disk. 
  1645.      *
  1646.      * All pages contain a header of 12 words:
  1647.      * - WORD 0:  CHECKSUM             Calculated before storing on disk and 
  1648.      *                                 checked when read from disk.
  1649.      * - WORD 1:  LAP                  How many wraparounds have the log 
  1650.      *                                 experienced since initial start of the
  1651.      *                                 system.
  1652.      * - WORD 2:  MAX_GCI_COMPLETED    Which is the maximum gci which have 
  1653.      *                                 completed before this page. This 
  1654.      *                                 gci will not be found in this    
  1655.      *                                 page and hereafter in the log.
  1656.      * - WORD 3:  MAX_GCI_STARTED      The maximum gci which have started 
  1657.      *                                 before this page.    
  1658.      * - WORD 4:  NEXT_PAGE            Pointer to the next page. 
  1659.      *                                 Only used in main memory      
  1660.      * - WORD 5:  PREVIOUS_PAGE        Pointer to the previous page. 
  1661.      *                                 Currently not used.       
  1662.      * - WORD 6:  VERSION              NDB version that wrote the page.
  1663.      * - WORD 7:  NO_LOG_FILES         Number of log files in this log part.
  1664.      * - WORD 8:  CURRENT PAGE INDEX   This keeps track of where we are in the 
  1665.      *                                 page.   
  1666.      *                                 This is only used when pages is in 
  1667.      *                                 memory.
  1668.      * - WORD 9:  OLD PREPARE FILE NO  This keeps track of the oldest prepare 
  1669.      *                                 operation still alive (not committed 
  1670.      *                                 or aborted) when this mbyte started.
  1671.      * - WORD 10: OLD PREPARE PAGE REF File page reference within this file 
  1672.      *                                 number.    
  1673.      *                                 Page no + Page index.
  1674.      *                                 If no prepare was alive then these 
  1675.      *                                 values points this mbyte.
  1676.      * - WORD 11: DIRTY FLAG            = 0 means not dirty and 
  1677.      *                                  = 1 means the page is dirty.    
  1678.      *                                 Is used when executing log when 
  1679.      *                                 a need to write invalid commit 
  1680.      *                                 records arise.
  1681.      *
  1682.      * The remaining 2036 words are used for log information, i.e.
  1683.      * log records.
  1684.      *
  1685.      * A log record on this page has the following layout:
  1686.      * - WORD 0: LOG RECORD TYPE                           
  1687.      *     The following types are supported:
  1688.      *     - PREPARE OPERATION       An operation not yet committed.
  1689.      *     - NEW PREPARE OPERATION   A prepared operation already 
  1690.      *                               logged is inserted 
  1691.      *                               into the log again so that the
  1692.      *                               log tail can be advanced. 
  1693.      *                               This can happen when a transaction is 
  1694.      *                               committed for a long time.     
  1695.      *     - ABORT TRANSACTION       A previously prepared transaction 
  1696.      *                               was aborted.  
  1697.      *     - COMMIT TRANSACTION      A previously prepared transaction 
  1698.      *                               was committed.
  1699.      *     - INVALID COMMIT          A previous commit record was 
  1700.      *                               invalidated by a   
  1701.      *                               subsequent system restart.
  1702.      *                               A log record must be invalidated
  1703.      *                               in a system restart if it belongs
  1704.      *                               to a global checkpoint id which
  1705.      *                               is not included in the system
  1706.      *                               restart.
  1707.      *                               Otherwise it will be included in
  1708.      *                               a subsequent system restart since
  1709.      *                               it will then most likely belong
  1710.      *                               to a global checkpoint id which
  1711.      *                               is part of that system
  1712.      *                               restart.  
  1713.      *                               This is not a correct behaviour
  1714.      *                               since this operation is lost in a
  1715.      *                               system restart and should not
  1716.      *                               reappear at a later system
  1717.      *                               restart.
  1718.      *     - COMPLETED GCI           A GCI has now been completed.
  1719.      *     - FRAGMENT SPLIT          A fragment has been split 
  1720.      *                               (not implemented yet)
  1721.      *     - FILE DESCRIPTOR         This is always the first log record 
  1722.      *                               in a file.
  1723.      *                               It is always placed on page 0 after 
  1724.      *                               the header.
  1725.      *                               It is written when the file is 
  1726.      *                               opened and when the file is closed.
  1727.      *     - NEXT LOG RECORD         This log record only records where 
  1728.      *                               the next log record starts.
  1729.      *     - NEXT MBYTE RECORD       This log record specifies that there 
  1730.      *                               are no more log records in this mbyte.
  1731.      *
  1732.      *
  1733.      * A FILE DESCRIPTOR log record continues as follows:
  1734.      * - WORD 1: NO_LOG_DESCRIPTORS  This defines the number of 
  1735.      *                               descriptors of log files that
  1736.      *                               will follow hereafter (max 32).
  1737.      *                               the log descriptor will describe
  1738.      *                               information about
  1739.      *                               max_gci_completed,
  1740.      *                               max_gci_started and log_lap at
  1741.      *                               every 1 mbyte of the log file
  1742.      *                               since a log file is 16 mbyte
  1743.      *                               always, i need 16 entries in the
  1744.      *                               array with max_gci_completed,
  1745.      *                               max_gci_started and log_lap. thus
  1746.      *                               32 entries per log file
  1747.      *                               descriptor (max 32*48 = 1536,
  1748.      *                               always fits in page 0).
  1749.      * - WORD 2: LAST LOG FILE       The number of the log file currently 
  1750.      *                               open.  This is only valid in file 0.
  1751.      * - WORD 3 - WORD 18:           MAX_GCI_COMPLETED for every 1 mbyte 
  1752.      *                               in this log file.
  1753.      * - WORD 19 - WORD 34:          MAX_GCI_STARTED for every 1 mbyte 
  1754.      *                               in this log file.
  1755.      *
  1756.      * Then it continues for NO_LOG_DESCRIPTORS until all subsequent 
  1757.      * log files (max 32) have been properly described.
  1758.      *
  1759.      *
  1760.      * A PREPARE OPERATION log record continues as follows:
  1761.      * - WORD 1: LOG RECORD SIZE
  1762.      * - WORD 2: HASH VALUE                   
  1763.      * - WORD 3: SCHEMA VERSION 
  1764.      * - WORD 4: OPERATION TYPE
  1765.      *            = 0 READ,
  1766.      *            = 1 UPDATE,
  1767.      *            = 2 INSERT,
  1768.      *            = 3 DELETE
  1769.      * - WORD 5: NUMBER OF WORDS IN ATTRINFO PART
  1770.      * - WORD 6: KEY LENGTH IN WORDS
  1771.      * - WORD 7 - (WORD 7 + KEY_LENGTH - 1)                 The tuple key
  1772.      * - (WORD 7 + KEY_LENGTH) - 
  1773.      *   (WORD 7 + KEY_LENGTH + ATTRINFO_LENGTH - 1)        The attrinfo
  1774.      *                                                                  
  1775.      * A log record can be spread in several pages in some cases.
  1776.      * The next log record always starts immediately after this log record.
  1777.      * A log record does however never traverse a 1 mbyte boundary. 
  1778.      * This is used to ensure that we can always come back if something 
  1779.      * strange occurs in the log file.
  1780.      * To ensure this we also have log records which only records 
  1781.      * the next log record.
  1782.      *
  1783.      *
  1784.      * A COMMIT TRANSACTION log record continues as follows:
  1785.      * - WORD 1: TRANSACTION ID PART 1
  1786.      * - WORD 2: TRANSACTION ID PART 2
  1787.      * - WORD 3: FRAGMENT ID OF THE OPERATION
  1788.      * - WORD 4: TABLE ID OF THE OPERATION
  1789.      * - WORD 5: THE FILE NUMBER OF THE PREPARE RECORD
  1790.      * - WORD 6: THE STARTING PAGE NUMBER OF THE PREPARE RECORD
  1791.      * - WORD 7: THE STARTING PAGE INDEX OF THE PREPARE RECORD
  1792.      * - WORD 8: THE STOP PAGE NUMBER OF THE PREPARE RECORD
  1793.      * - WORD 9: GLOBAL CHECKPOINT OF THE TRANSACTION
  1794.      *
  1795.      *
  1796.      * An ABORT TRANSACTION log record continues as follows:
  1797.      * - WORD 1: TRANSACTION ID PART 1
  1798.      * - WORD 2: TRANSACTION ID PART 2 
  1799.      *
  1800.      * 
  1801.      * A COMPLETED CGI log record continues as follows:
  1802.      * - WORD 1: THE COMPLETED GCI                                 
  1803.      *
  1804.      *
  1805.      * A NEXT LOG RECORD log record continues as follows:
  1806.      * - There is no more information needed. 
  1807.      *   The next log record will always refer to the start of the next page.
  1808.      *
  1809.      * A NEXT MBYTE RECORD log record continues as follows:
  1810.      * - There is no more information needed. 
  1811.      *   The next mbyte will always refer to the start of the next mbyte.
  1812.      */
  1813.     UintR logPageWord[8192]; // Size 32 kbytes
  1814.   };  
  1815.   typedef Ptr<LogPageRecord> LogPageRecordPtr;
  1816.   struct PageRefRecord {
  1817.     UintR pageRef[8];
  1818.     UintR prNext;
  1819.     UintR prPrev;
  1820.     Uint16 prFileNo;
  1821.     Uint16 prPageNo;
  1822.   }; // size 44 bytes
  1823.   typedef Ptr<PageRefRecord> PageRefRecordPtr;
  1824.   struct Tablerec {
  1825.     enum TableStatus {
  1826.       TABLE_DEFINED = 0,
  1827.       NOT_DEFINED = 1,
  1828.       ADD_TABLE_ONGOING = 2,
  1829.       PREP_DROP_TABLE_ONGOING = 3,
  1830.       PREP_DROP_TABLE_DONE = 4
  1831.     };
  1832.     
  1833.     UintR fragrec[MAX_FRAG_PER_NODE];
  1834.     Uint16 fragid[MAX_FRAG_PER_NODE];
  1835.     /**
  1836.      * Status of the table 
  1837.      */
  1838.     TableStatus tableStatus;
  1839.     /**
  1840.      * Table type and target table of index.
  1841.      */
  1842.     Uint16 tableType;
  1843.     Uint16 primaryTableId;
  1844.     Uint32 schemaVersion;
  1845.     Uint32 usageCount;
  1846.     NdbNodeBitmask waitingTC;
  1847.     NdbNodeBitmask waitingDIH;
  1848.   }; // Size 100 bytes
  1849.   typedef Ptr<Tablerec> TablerecPtr;
  1850.   struct TcConnectionrec {
  1851.     enum ListState {
  1852.       NOT_IN_LIST = 0,
  1853.       IN_ACTIVE_LIST = 1,
  1854.       ACC_BLOCK_LIST = 2,
  1855.       WAIT_QUEUE_LIST = 3
  1856.     };
  1857.     enum LogWriteState {
  1858.       NOT_STARTED = 0,
  1859.       NOT_WRITTEN = 1,
  1860.       NOT_WRITTEN_WAIT = 2,
  1861.       WRITTEN = 3
  1862.     };
  1863.     enum AbortState {
  1864.       ABORT_IDLE = 0,
  1865.       ABORT_ACTIVE = 1,
  1866.       NEW_FROM_TC = 2,
  1867.       REQ_FROM_TC = 3,
  1868.       ABORT_FROM_TC = 4,
  1869.       ABORT_FROM_LQH = 5
  1870.     };
  1871.     enum TransactionState {
  1872.       IDLE = 0,
  1873.       /* -------------------------------------------------------------------- */
  1874.       // Transaction in progress states
  1875.       /* -------------------------------------------------------------------- */
  1876.       WAIT_ACC = 1,
  1877.       WAIT_TUPKEYINFO = 2,
  1878.       WAIT_ATTR = 3,
  1879.       WAIT_TUP = 4,
  1880.       STOPPED = 5,
  1881.       LOG_QUEUED = 6,
  1882.       PREPARED = 7,
  1883.       LOG_COMMIT_WRITTEN_WAIT_SIGNAL = 8,
  1884.       LOG_COMMIT_QUEUED_WAIT_SIGNAL = 9,
  1885.       
  1886.       /* -------------------------------------------------------------------- */
  1887.       // Commit in progress states
  1888.       /* -------------------------------------------------------------------- */
  1889.       COMMIT_STOPPED = 10,
  1890.       LOG_COMMIT_QUEUED = 11,
  1891.       COMMIT_QUEUED = 12,
  1892.       COMMITTED = 13,
  1893.       
  1894.       /* -------------------------------------------------------------------- */
  1895.       // Abort in progress states
  1896.       /* -------------------------------------------------------------------- */
  1897.       WAIT_ACC_ABORT = 14,
  1898.       ABORT_QUEUED = 15,
  1899.       ABORT_STOPPED = 16,
  1900.       WAIT_AI_AFTER_ABORT = 17,
  1901.       LOG_ABORT_QUEUED = 18,
  1902.       WAIT_TUP_TO_ABORT = 19,
  1903.       
  1904.       /* -------------------------------------------------------------------- */
  1905.       // Scan in progress states
  1906.       /* -------------------------------------------------------------------- */
  1907.       WAIT_SCAN_AI = 20,
  1908.       SCAN_STATE_USED = 21,
  1909.       SCAN_FIRST_STOPPED = 22,
  1910.       SCAN_CHECK_STOPPED = 23,
  1911.       SCAN_STOPPED = 24,
  1912.       SCAN_RELEASE_STOPPED = 25,
  1913.       SCAN_CLOSE_STOPPED = 26,
  1914.       COPY_CLOSE_STOPPED = 27,
  1915.       COPY_FIRST_STOPPED = 28,
  1916.       COPY_STOPPED = 29,
  1917.       SCAN_TUPKEY = 30,
  1918.       COPY_TUPKEY = 31,
  1919.       TC_NOT_CONNECTED = 32,
  1920.       PREPARED_RECEIVED_COMMIT = 33, // Temporary state in write commit log
  1921.       LOG_COMMIT_WRITTEN = 34        // Temporary state in write commit log
  1922.     };
  1923.     enum ConnectState {
  1924.       DISCONNECTED = 0,
  1925.       CONNECTED = 1,
  1926.       COPY_CONNECTED = 2,
  1927.       LOG_CONNECTED = 3
  1928.     };
  1929.     ConnectState connectState;
  1930.     UintR copyCountWords;    
  1931.     UintR firstAttrinfo[5];
  1932.     UintR tupkeyData[4];
  1933.     UintR transid[2];
  1934.     AbortState abortState;
  1935.     UintR accConnectrec;
  1936.     UintR applOprec;
  1937.     UintR clientConnectrec;
  1938.     UintR tcTimer;
  1939.     UintR currReclenAi;
  1940.     UintR currTupAiLen;
  1941.     UintR firstAttrinbuf;
  1942.     UintR firstTupkeybuf;
  1943.     UintR fragmentid;
  1944.     UintR fragmentptr;
  1945.     UintR gci;
  1946.     UintR hashValue;
  1947.     UintR lastTupkeybuf;
  1948.     UintR lastAttrinbuf;
  1949.     /**
  1950.      * Each operation (TcConnectrec) can be stored in max one out of many 
  1951.      * lists.
  1952.      * This variable keeps track of which list it is in.
  1953.      */
  1954.     ListState listState;
  1955.     
  1956.     UintR logStartFileNo;
  1957.     LogWriteState logWriteState;
  1958.     UintR nextHashRec;
  1959.     UintR nextLogTcrec;
  1960.     UintR nextTcLogQueue;
  1961.     UintR nextTc;
  1962.     UintR nextTcConnectrec;
  1963.     UintR prevHashRec;
  1964.     UintR prevLogTcrec;
  1965.     UintR prevTc;
  1966.     UintR readlenAi;
  1967.     UintR reqRef;
  1968.     UintR reqinfo;
  1969.     UintR schemaVersion;
  1970.     UintR storedProcId;
  1971.     UintR simpleTcConnect;
  1972.     UintR tableref;
  1973.     UintR tcOprec;
  1974.     UintR tcScanInfo;
  1975.     UintR tcScanRec;
  1976.     UintR totReclenAi;
  1977.     UintR totSendlenAi;
  1978.     UintR tupConnectrec;
  1979.     UintR savePointId;
  1980.     TransactionState transactionState;
  1981.     BlockReference applRef;
  1982.     BlockReference clientBlockref;
  1983.     BlockReference reqBlockref;
  1984.     BlockReference tcBlockref;
  1985.     BlockReference tcAccBlockref;
  1986.     BlockReference tcTuxBlockref;
  1987.     BlockReference tcTupBlockref;
  1988.     Uint32 commitAckMarker;
  1989.     UintR noFiredTriggers;
  1990.     Uint16 errorCode;
  1991.     Uint16 logStartPageIndex;
  1992.     Uint16 logStartPageNo;
  1993.     Uint16 logStopPageNo;
  1994.     Uint16 nextReplica;
  1995.     Uint16 primKeyLen;
  1996.     Uint16 save1;
  1997.     Uint16 nodeAfterNext[3];
  1998.     Uint8 activeCreat;
  1999.     Uint8 apiVersionNo;
  2000.     Uint8 dirtyOp;
  2001.     Uint8 indTakeOver;
  2002.     Uint8 lastReplicaNo;
  2003.     Uint8 localFragptr;
  2004.     Uint8 lockType;
  2005.     Uint8 nextSeqNoReplica;
  2006.     Uint8 opSimple;
  2007.     Uint8 opExec;
  2008.     Uint8 operation;
  2009.     Uint8 reclenAiLqhkey;
  2010.     Uint8 replicaType;
  2011.     Uint8 simpleRead;
  2012.     Uint8 seqNoReplica;
  2013.     Uint8 tcNodeFailrec;
  2014.   }; /* p2c: size = 280 bytes */
  2015.   
  2016.   typedef Ptr<TcConnectionrec> TcConnectionrecPtr;
  2017.   struct TcNodeFailRecord {
  2018.     enum TcFailStatus {
  2019.       TC_STATE_TRUE = 0,
  2020.       TC_STATE_FALSE = 1,
  2021.       TC_STATE_BREAK = 2
  2022.     };
  2023.     UintR lastNewTcRef;
  2024.     UintR newTcRef;
  2025.     TcFailStatus tcFailStatus;
  2026.     UintR tcRecNow;
  2027.     BlockReference lastNewTcBlockref;
  2028.     BlockReference newTcBlockref;
  2029.     Uint16 oldNodeId;
  2030.   }; // Size 28 bytes
  2031.   typedef Ptr<TcNodeFailRecord> TcNodeFailRecordPtr;
  2032.   struct CommitLogRecord {
  2033.     Uint32 startPageNo;
  2034.     Uint32 startPageIndex;
  2035.     Uint32 stopPageNo;
  2036.     Uint32 fileNo;
  2037.   };
  2038.   
  2039. public:
  2040.   Dblqh(const class Configuration &);
  2041.   virtual ~Dblqh();
  2042.   
  2043. private:
  2044.   BLOCK_DEFINES(Dblqh);
  2045.   void execPACKED_SIGNAL(Signal* signal);
  2046.   void execDEBUG_SIG(Signal* signal);
  2047.   void execATTRINFO(Signal* signal);
  2048.   void execKEYINFO(Signal* signal);
  2049.   void execLQHKEYREQ(Signal* signal);
  2050.   void execLQHKEYREF(Signal* signal);
  2051.   void execCOMMIT(Signal* signal);
  2052.   void execCOMPLETE(Signal* signal);
  2053.   void execLQHKEYCONF(Signal* signal);
  2054.   void execTESTSIG(Signal* signal);
  2055.   void execLQH_RESTART_OP(Signal* signal);
  2056.   void execCONTINUEB(Signal* signal);
  2057.   void execSTART_RECREQ(Signal* signal);
  2058.   void execSTART_RECCONF(Signal* signal);
  2059.   void execEXEC_FRAGREQ(Signal* signal);
  2060.   void execEXEC_FRAGCONF(Signal* signal);
  2061.   void execEXEC_FRAGREF(Signal* signal);
  2062.   void execSTART_EXEC_SR(Signal* signal);
  2063.   void execEXEC_SRREQ(Signal* signal);
  2064.   void execEXEC_SRCONF(Signal* signal);
  2065.   void execREAD_PSUEDO_REQ(Signal* signal);
  2066.   
  2067.   void execDUMP_STATE_ORD(Signal* signal);
  2068.   void execACC_COM_BLOCK(Signal* signal);
  2069.   void execACC_COM_UNBLOCK(Signal* signal);
  2070.   void execTUP_COM_BLOCK(Signal* signal);
  2071.   void execTUP_COM_UNBLOCK(Signal* signal);
  2072.   void execACC_ABORTCONF(Signal* signal);
  2073.   void execNODE_FAILREP(Signal* signal);
  2074.   void execCHECK_LCP_STOP(Signal* signal);
  2075.   void execSEND_PACKED(Signal* signal);
  2076.   void execTUP_ATTRINFO(Signal* signal);
  2077.   void execREAD_CONFIG_REQ(Signal* signal);
  2078.   void execLQHFRAGREQ(Signal* signal);
  2079.   void execLQHADDATTREQ(Signal* signal);
  2080.   void execTUP_ADD_ATTCONF(Signal* signal);
  2081.   void execTUP_ADD_ATTRREF(Signal* signal);
  2082.   void execACCFRAGCONF(Signal* signal);
  2083.   void execACCFRAGREF(Signal* signal);
  2084.   void execTUPFRAGCONF(Signal* signal);
  2085.   void execTUPFRAGREF(Signal* signal);
  2086.   void execTAB_COMMITREQ(Signal* signal);
  2087.   void execACCSEIZECONF(Signal* signal);
  2088.   void execACCSEIZEREF(Signal* signal);
  2089.   void execREAD_NODESCONF(Signal* signal);
  2090.   void execREAD_NODESREF(Signal* signal);
  2091.   void execSTTOR(Signal* signal);
  2092.   void execNDB_STTOR(Signal* signal);
  2093.   void execTUPSEIZECONF(Signal* signal);
  2094.   void execTUPSEIZEREF(Signal* signal);
  2095.   void execACCKEYCONF(Signal* signal);
  2096.   void execACCKEYREF(Signal* signal);
  2097.   void execTUPKEYCONF(Signal* signal);
  2098.   void execTUPKEYREF(Signal* signal);
  2099.   void execABORT(Signal* signal);
  2100.   void execABORTREQ(Signal* signal);
  2101.   void execCOMMITREQ(Signal* signal);
  2102.   void execCOMPLETEREQ(Signal* signal);
  2103.   void execMEMCHECKREQ(Signal* signal);
  2104.   void execSCAN_FRAGREQ(Signal* signal);
  2105.   void execSCAN_NEXTREQ(Signal* signal);
  2106.   void execACC_SCANCONF(Signal* signal);
  2107.   void execACC_SCANREF(Signal* signal);
  2108.   void execNEXT_SCANCONF(Signal* signal);
  2109.   void execNEXT_SCANREF(Signal* signal);
  2110.   void execACC_SCAN_INFO(Signal* signal);
  2111.   void execACC_SCAN_INFO24(Signal* signal);
  2112.   void execACC_TO_REF(Signal* signal);
  2113.   void execSTORED_PROCCONF(Signal* signal);
  2114.   void execSTORED_PROCREF(Signal* signal);
  2115.   void execCOPY_FRAGREQ(Signal* signal);
  2116.   void execCOPY_ACTIVEREQ(Signal* signal);
  2117.   void execCOPY_STATEREQ(Signal* signal);
  2118.   void execLQH_TRANSREQ(Signal* signal);
  2119.   void execTRANSID_AI(Signal* signal);
  2120.   void execINCL_NODEREQ(Signal* signal);
  2121.   void execACC_LCPCONF(Signal* signal);
  2122.   void execACC_LCPREF(Signal* signal);
  2123.   void execACC_LCPSTARTED(Signal* signal);
  2124.   void execACC_CONTOPCONF(Signal* signal);
  2125.   void execLCP_FRAGIDCONF(Signal* signal);
  2126.   void execLCP_FRAGIDREF(Signal* signal);
  2127.   void execLCP_HOLDOPCONF(Signal* signal);
  2128.   void execLCP_HOLDOPREF(Signal* signal);
  2129.   void execTUP_PREPLCPCONF(Signal* signal);
  2130.   void execTUP_PREPLCPREF(Signal* signal);
  2131.   void execTUP_LCPCONF(Signal* signal);
  2132.   void execTUP_LCPREF(Signal* signal);
  2133.   void execTUP_LCPSTARTED(Signal* signal);
  2134.   void execEND_LCPCONF(Signal* signal);
  2135.   void execLCP_FRAG_ORD(Signal* signal);
  2136.   void execEMPTY_LCP_REQ(Signal* signal);
  2137.   
  2138.   void execSTART_FRAGREQ(Signal* signal);
  2139.   void execSTART_RECREF(Signal* signal);
  2140.   void execSR_FRAGIDCONF(Signal* signal);
  2141.   void execSR_FRAGIDREF(Signal* signal);
  2142.   void execACC_SRCONF(Signal* signal);
  2143.   void execACC_SRREF(Signal* signal);
  2144.   void execTUP_SRCONF(Signal* signal);
  2145.   void execTUP_SRREF(Signal* signal);
  2146.   void execGCP_SAVEREQ(Signal* signal);
  2147.   void execFSOPENCONF(Signal* signal);
  2148.   void execFSCLOSECONF(Signal* signal);
  2149.   void execFSWRITECONF(Signal* signal);
  2150.   void execFSWRITEREF(Signal* signal);
  2151.   void execFSREADCONF(Signal* signal);
  2152.   void execFSREADREF(Signal* signal);
  2153.   void execSCAN_HBREP(Signal* signal);
  2154.   void execSET_VAR_REQ(Signal* signal);
  2155.   void execTIME_SIGNAL(Signal* signal);
  2156.   void execFSSYNCCONF(Signal* signal);
  2157.   void execALTER_TAB_REQ(Signal* signal);
  2158.   void execALTER_TAB_CONF(Signal* signal);
  2159.   void execCREATE_TRIG_CONF(Signal* signal);
  2160.   void execCREATE_TRIG_REF(Signal* signal);
  2161.   void execCREATE_TRIG_REQ(Signal* signal);
  2162.   void execDROP_TRIG_CONF(Signal* signal);
  2163.   void execDROP_TRIG_REF(Signal* signal);
  2164.   void execDROP_TRIG_REQ(Signal* signal);
  2165.   void execPREP_DROP_TAB_REQ(Signal* signal);
  2166.   void execWAIT_DROP_TAB_REQ(Signal* signal);
  2167.   void execDROP_TAB_REQ(Signal* signal);
  2168.   void execLQH_ALLOCREQ(Signal* signal);
  2169.   void execLQH_WRITELOG_REQ(Signal* signal);
  2170.   void execTUXFRAGCONF(Signal* signal);
  2171.   void execTUXFRAGREF(Signal* signal);
  2172.   void execTUX_ADD_ATTRCONF(Signal* signal);
  2173.   void execTUX_ADD_ATTRREF(Signal* signal);
  2174.   // Statement blocks
  2175.   void init_acc_ptr_list(ScanRecord*);
  2176.   bool seize_acc_ptr_list(ScanRecord*, Uint32);
  2177.   void release_acc_ptr_list(ScanRecord*);
  2178.   Uint32 get_acc_ptr_from_scan_record(ScanRecord*, Uint32, bool);
  2179.   void set_acc_ptr_in_scan_record(ScanRecord*, Uint32, Uint32);
  2180.   void i_get_acc_ptr(ScanRecord*, Uint32*&, Uint32);
  2181.   
  2182.   void removeTable(Uint32 tableId);
  2183.   void sendLCP_COMPLETE_REP(Signal* signal, Uint32 lcpId);
  2184.   void sendEMPTY_LCP_CONF(Signal* signal, bool idle);
  2185.   void sendLCP_FRAGIDREQ(Signal* signal);
  2186.   void sendLCP_FRAG_REP(Signal * signal, const LcpRecord::FragOrd &) const;
  2187.   void updatePackedList(Signal* signal, HostRecord * ahostptr, Uint16 hostId);
  2188.   void LQHKEY_abort(Signal* signal, int errortype);
  2189.   void LQHKEY_error(Signal* signal, int errortype);
  2190.   void nextRecordCopy(Signal* signal);
  2191.   void calculateHash(Signal* signal);
  2192.   void continueAfterCheckLcpStopBlocked(Signal* signal);
  2193.   void checkLcpStopBlockedLab(Signal* signal);
  2194.   void sendCommittedTc(Signal* signal, BlockReference atcBlockref);
  2195.   void sendCompletedTc(Signal* signal, BlockReference atcBlockref);
  2196.   void sendLqhkeyconfTc(Signal* signal, BlockReference atcBlockref);
  2197.   void sendCommitLqh(Signal* signal, BlockReference alqhBlockref);
  2198.   void sendCompleteLqh(Signal* signal, BlockReference alqhBlockref);
  2199.   void sendPackedSignalLqh(Signal* signal, HostRecord * ahostptr);
  2200.   void sendPackedSignalTc(Signal* signal, HostRecord * ahostptr);
  2201.   Uint32 handleLongTupKey(Signal* signal,
  2202.                           Uint32 lenSofar,
  2203.                           Uint32 primKeyLen,
  2204.                           Uint32* dataPtr);
  2205.   void cleanUp(Signal* signal);
  2206.   void sendAttrinfoLoop(Signal* signal);
  2207.   void sendAttrinfoSignal(Signal* signal);
  2208.   void sendLqhAttrinfoSignal(Signal* signal);
  2209.   void sendKeyinfoAcc(Signal* signal, Uint32 pos);
  2210.   Uint32 initScanrec(const class ScanFragReq *);
  2211.   void initScanTc(Signal* signal,
  2212.                   Uint32 transid1,
  2213.                   Uint32 transid2,
  2214.                   Uint32 fragId,
  2215.                   Uint32 nodeId);
  2216.   void finishScanrec(Signal* signal);
  2217.   void releaseScanrec(Signal* signal);
  2218.   void seizeScanrec(Signal* signal);
  2219.   void sendKeyinfo20(Signal* signal, ScanRecord *, TcConnectionrec *);
  2220.   void sendScanFragConf(Signal* signal, Uint32 scanCompleted);
  2221.   void initCopyrec(Signal* signal);
  2222.   void initCopyTc(Signal* signal);
  2223.   void sendCopyActiveConf(Signal* signal,Uint32 tableId);
  2224.   void checkLcpCompleted(Signal* signal);
  2225.   void checkLcpHoldop(Signal* signal);
  2226.   bool checkLcpStarted(Signal* signal);
  2227.   void checkLcpTupprep(Signal* signal);
  2228.   void getNextFragForLcp(Signal* signal);
  2229.   void initLcpLocAcc(Signal* signal, Uint32 fragId);
  2230.   void initLcpLocTup(Signal* signal, Uint32 fragId);
  2231.   void moveAccActiveFrag(Signal* signal);
  2232.   void moveActiveToAcc(Signal* signal);
  2233.   void releaseLocalLcps(Signal* signal);
  2234.   void seizeLcpLoc(Signal* signal);
  2235.   void sendAccContOp(Signal* signal);
  2236.   void sendStartLcp(Signal* signal);
  2237.   void setLogTail(Signal* signal, Uint32 keepGci);
  2238.   Uint32 remainingLogSize(const LogFileRecordPtr &sltCurrLogFilePtr,
  2239.   const LogPartRecordPtr &sltLogPartPtr);
  2240.   void checkGcpCompleted(Signal* signal, Uint32 pageWritten, Uint32 wordWritten);
  2241.   void initFsopenconf(Signal* signal);
  2242.   void initFsrwconf(Signal* signal, bool write);
  2243.   void initLfo(Signal* signal);
  2244.   void initLogfile(Signal* signal, Uint32 fileNo);
  2245.   void initLogpage(Signal* signal);
  2246.   void openFileRw(Signal* signal, LogFileRecordPtr olfLogFilePtr);
  2247.   void openLogfileInit(Signal* signal);
  2248.   void openNextLogfile(Signal* signal);
  2249.   void releaseLfo(Signal* signal);
  2250.   void releaseLfoPages(Signal* signal);
  2251.   void releaseLogpage(Signal* signal);
  2252.   void seizeLfo(Signal* signal);
  2253.   void seizeLogfile(Signal* signal);
  2254.   void seizeLogpage(Signal* signal);
  2255.   void writeFileDescriptor(Signal* signal);
  2256.   void writeFileHeaderOpen(Signal* signal, Uint32 type);
  2257.   void writeInitMbyte(Signal* signal);
  2258.   void writeSinglePage(Signal* signal, Uint32 pageNo,
  2259.                        Uint32 wordWritten, Uint32 place);
  2260.   void buildLinkedLogPageList(Signal* signal);
  2261.   void changeMbyte(Signal* signal);
  2262.   Uint32 checkIfExecLog(Signal* signal);
  2263.   void checkNewMbyte(Signal* signal);
  2264.   void checkReadExecSr(Signal* signal);
  2265.   void checkScanTcCompleted(Signal* signal);
  2266.   void checkSrCompleted(Signal* signal);
  2267.   void closeFile(Signal* signal, LogFileRecordPtr logFilePtr);
  2268.   void completedLogPage(Signal* signal, Uint32 clpType, Uint32 place);
  2269.   void deleteFragrec(Uint32 fragId);
  2270.   void deleteTransidHash(Signal* signal);
  2271.   void findLogfile(Signal* signal,
  2272.                    Uint32 fileNo,
  2273.                    LogPartRecordPtr flfLogPartPtr,
  2274.                    LogFileRecordPtr* parLogFilePtr);
  2275.   void findPageRef(Signal* signal, CommitLogRecord* commitLogRecord);
  2276.   int  findTransaction(UintR Transid1, UintR Transid2, UintR TcOprec);
  2277.   void getFirstInLogQueue(Signal* signal);
  2278.   bool getFragmentrec(Signal* signal, Uint32 fragId);
  2279.   void initialiseAddfragrec(Signal* signal);
  2280.   void initialiseAttrbuf(Signal* signal);
  2281.   void initialiseDatabuf(Signal* signal);
  2282.   void initialiseFragrec(Signal* signal);
  2283.   void initialiseGcprec(Signal* signal);
  2284.   void initialiseLcpRec(Signal* signal);
  2285.   void initialiseLcpLocrec(Signal* signal);
  2286.   void initialiseLfo(Signal* signal);
  2287.   void initialiseLogFile(Signal* signal);
  2288.   void initialiseLogPage(Signal* signal);
  2289.   void initialiseLogPart(Signal* signal);
  2290.   void initialisePageRef(Signal* signal);
  2291.   void initialiseScanrec(Signal* signal);
  2292.   void initialiseTabrec(Signal* signal);
  2293.   void initialiseTcrec(Signal* signal);
  2294.   void initialiseTcNodeFailRec(Signal* signal);
  2295.   void initFragrec(Signal* signal,
  2296.                    Uint32 tableId,
  2297.                    Uint32 fragId,
  2298.                    Uint32 copyType);
  2299.   void initFragrecSr(Signal* signal);
  2300.   void initGciInLogFileRec(Signal* signal, Uint32 noFdDesc);
  2301.   void initLcpSr(Signal* signal,
  2302.                  Uint32 lcpNo,
  2303.                  Uint32 lcpId,
  2304.                  Uint32 tableId,
  2305.                  Uint32 fragId,
  2306.                  Uint32 fragPtr);
  2307.   void initLogpart(Signal* signal);
  2308.   void initLogPointers(Signal* signal);
  2309.   void initReqinfoExecSr(Signal* signal);
  2310.   bool insertFragrec(Signal* signal, Uint32 fragId);
  2311.   void linkActiveFrag(Signal* signal);
  2312.   void linkFragQueue(Signal* signal);
  2313.   void linkWaitLog(Signal* signal, LogPartRecordPtr regLogPartPtr);
  2314.   void logNextStart(Signal* signal);
  2315.   void moveToPageRef(Signal* signal);
  2316.   void readAttrinfo(Signal* signal);
  2317.   void readCommitLog(Signal* signal, CommitLogRecord* commitLogRecord);
  2318.   void readExecLog(Signal* signal);
  2319.   void readExecSrNewMbyte(Signal* signal);
  2320.   void readExecSr(Signal* signal);
  2321.   void readKey(Signal* signal);
  2322.   void readLogData(Signal* signal, Uint32 noOfWords, Uint32* dataPtr);
  2323.   void readLogHeader(Signal* signal);
  2324.   Uint32 readLogword(Signal* signal);
  2325.   Uint32 readLogwordExec(Signal* signal);
  2326.   void readSinglePage(Signal* signal, Uint32 pageNo);
  2327.   void releaseAccList(Signal* signal);
  2328.   void releaseActiveCopy(Signal* signal);
  2329.   void releaseActiveFrag(Signal* signal);
  2330.   void releaseActiveList(Signal* signal);
  2331.   void releaseAddfragrec(Signal* signal);
  2332.   void releaseFragrec();
  2333.   void releaseLcpLoc(Signal* signal);
  2334.   void releaseOprec(Signal* signal);
  2335.   void releasePageRef(Signal* signal);
  2336.   void releaseMmPages(Signal* signal);
  2337.   void releasePrPages(Signal* signal);
  2338.   void releaseTcrec(Signal* signal, TcConnectionrecPtr tcConnectptr);
  2339.   void releaseTcrecLog(Signal* signal, TcConnectionrecPtr tcConnectptr);
  2340.   void releaseWaitQueue(Signal* signal);
  2341.   void removeLogTcrec(Signal* signal);
  2342.   void removePageRef(Signal* signal);
  2343.   Uint32 returnExecLog(Signal* signal);
  2344.   int saveTupattrbuf(Signal* signal, Uint32* dataPtr, Uint32 length);
  2345.   void seizeAddfragrec(Signal* signal);
  2346.   void seizeAttrinbuf(Signal* signal);
  2347.   Uint32 seize_attrinbuf();
  2348.   Uint32 release_attrinbuf(Uint32);
  2349.   void seizeFragmentrec(Signal* signal);
  2350.   void seizePageRef(Signal* signal);
  2351.   void seizeTcrec();
  2352.   void seizeTupkeybuf(Signal* signal);
  2353.   void sendAborted(Signal* signal);
  2354.   void sendLqhTransconf(Signal* signal, LqhTransConf::OperationStatus);
  2355.   void sendTupkey(Signal* signal);
  2356.   void startExecSr(Signal* signal);
  2357.   void startNextExecSr(Signal* signal);
  2358.   void startTimeSupervision(Signal* signal);
  2359.   void stepAhead(Signal* signal, Uint32 stepAheadWords);
  2360.   void systemError(Signal* signal);
  2361.   void writeAbortLog(Signal* signal);
  2362.   void writeCommitLog(Signal* signal, LogPartRecordPtr regLogPartPtr);
  2363.   void writeCompletedGciLog(Signal* signal);
  2364.   void writeDbgInfoPageHeader(LogPageRecordPtr logPagePtr, Uint32 place,
  2365.                               Uint32 pageNo, Uint32 wordWritten);
  2366.   void writeDirty(Signal* signal, Uint32 place);
  2367.   void writeKey(Signal* signal);
  2368.   void writeLogHeader(Signal* signal);
  2369.   void writeLogWord(Signal* signal, Uint32 data);
  2370.   void writeNextLog(Signal* signal);
  2371.   void errorReport(Signal* signal, int place);
  2372.   void warningReport(Signal* signal, int place);
  2373.   void invalidateLogAfterLastGCI(Signal *signal);
  2374.   void readFileInInvalidate(Signal *signal);
  2375.   void exitFromInvalidate(Signal* signal);
  2376.   Uint32 calcPageCheckSum(LogPageRecordPtr logP);
  2377.   // Generated statement blocks
  2378.   void systemErrorLab(Signal* signal);
  2379.   void initFourth(Signal* signal);
  2380.   void packLqhkeyreqLab(Signal* signal);
  2381.   void sendNdbSttorryLab(Signal* signal);
  2382.   void execSrCompletedLab(Signal* signal);
  2383.   void execLogRecord(Signal* signal);
  2384.   void srPhase3Comp(Signal* signal);
  2385.   void srLogLimits(Signal* signal);
  2386.   void srGciLimits(Signal* signal);
  2387.   void srPhase3Start(Signal* signal);
  2388.   void warningHandlerLab(Signal* signal);
  2389.   void checkStartCompletedLab(Signal* signal);
  2390.   void continueAbortLab(Signal* signal);
  2391.   void abortContinueAfterBlockedLab(Signal* signal, bool canBlock);
  2392.   void abortCommonLab(Signal* signal);
  2393.   void localCommitLab(Signal* signal);
  2394.   void abortErrorLab(Signal* signal);
  2395.   void continueAfterReceivingAllAiLab(Signal* signal);
  2396.   void sendScanFragRefLateLab(Signal* signal);
  2397.   void abortStateHandlerLab(Signal* signal);
  2398.   void writeAttrinfoLab(Signal* signal);
  2399.   void scanAttrinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length);
  2400.   void abort_scan(Signal* signal, Uint32 scan_ptr_i, Uint32 errcode);
  2401.   void localAbortStateHandlerLab(Signal* signal);
  2402.   void logLqhkeyreqLab(Signal* signal);
  2403.   void lqhAttrinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length);
  2404.   void rwConcludedAiLab(Signal* signal);
  2405.   void aiStateErrorCheckLab(Signal* signal, Uint32* dataPtr, Uint32 length);
  2406.   void takeOverErrorLab(Signal* signal);
  2407.   void endgettupkeyLab(Signal* signal);
  2408.   void noFreeRecordLab(Signal* signal, 
  2409.        const class LqhKeyReq * lqhKeyReq, 
  2410.        Uint32 errorCode);
  2411.   void logLqhkeyrefLab(Signal* signal);
  2412.   void closeCopyLab(Signal* signal);
  2413.   void commitReplyLab(Signal* signal);
  2414.   void completeUnusualLab(Signal* signal);
  2415.   void completeTransNotLastLab(Signal* signal);
  2416.   void completedLab(Signal* signal);
  2417.   void copyCompletedLab(Signal* signal);
  2418.   void completeLcpRoundLab(Signal* signal);
  2419.   void continueAfterLogAbortWriteLab(Signal* signal);
  2420.   void sendAttrinfoLab(Signal* signal);
  2421.   void sendExecConf(Signal* signal);
  2422.   void execSr(Signal* signal);
  2423.   void srFourthComp(Signal* signal);
  2424.   void timeSup(Signal* signal);
  2425.   void closeCopyRequestLab(Signal* signal);
  2426.   void closeScanRequestLab(Signal* signal);
  2427.   void scanTcConnectLab(Signal* signal, Uint32 startTcCon, Uint32 fragId);
  2428.   void initGcpRecLab(Signal* signal);
  2429.   void prepareContinueAfterBlockedLab(Signal* signal);
  2430.   void commitContinueAfterBlockedLab(Signal* signal);
  2431.   void continueCopyAfterBlockedLab(Signal* signal);
  2432.   void continueFirstCopyAfterBlockedLab(Signal* signal);
  2433.   void continueFirstScanAfterBlockedLab(Signal* signal);
  2434.   void continueScanAfterBlockedLab(Signal* signal);
  2435.   void continueScanReleaseAfterBlockedLab(Signal* signal);
  2436.   void continueCloseScanAfterBlockedLab(Signal* signal);
  2437.   void continueCloseCopyAfterBlockedLab(Signal* signal);
  2438.   void sendExecFragRefLab(Signal* signal);
  2439.   void fragrefLab(Signal* signal, BlockReference retRef,
  2440.                   Uint32 retPtr, Uint32 errorCode);
  2441.   void abortAddFragOps(Signal* signal);
  2442.   void rwConcludedLab(Signal* signal);
  2443.   void sendsttorryLab(Signal* signal);
  2444.   void initialiseRecordsLab(Signal* signal, Uint32 data, Uint32, Uint32);
  2445.   void startphase2Lab(Signal* signal, Uint32 config);
  2446.   void startphase3Lab(Signal* signal);
  2447.   void startphase4Lab(Signal* signal);
  2448.   void startphase6Lab(Signal* signal);
  2449.   void moreconnectionsLab(Signal* signal);
  2450.   void scanReleaseLocksLab(Signal* signal);
  2451.   void closeScanLab(Signal* signal);
  2452.   void nextScanConfLoopLab(Signal* signal);
  2453.   void scanNextLoopLab(Signal* signal);
  2454.   void commitReqLab(Signal* signal, Uint32 gci);
  2455.   void completeTransLastLab(Signal* signal);
  2456.   void tupScanCloseConfLab(Signal* signal);
  2457.   void tupCopyCloseConfLab(Signal* signal);
  2458.   void accScanCloseConfLab(Signal* signal);
  2459.   void accCopyCloseConfLab(Signal* signal);
  2460.   void nextScanConfScanLab(Signal* signal);
  2461.   void nextScanConfCopyLab(Signal* signal);
  2462.   void continueScanNextReqLab(Signal* signal);
  2463.   bool keyinfoLab(Signal* signal, Uint32* dataPtr, Uint32 length);
  2464.   void copySendTupkeyReqLab(Signal* signal);
  2465.   void storedProcConfScanLab(Signal* signal);
  2466.   void storedProcConfCopyLab(Signal* signal);
  2467.   void copyStateFinishedLab(Signal* signal);
  2468.   void lcpCompletedLab(Signal* signal);
  2469.   void lcpStartedLab(Signal* signal);
  2470.   void contChkpNextFragLab(Signal* signal);
  2471.   void startLcpRoundLab(Signal* signal);
  2472.   void startFragRefLab(Signal* signal);
  2473.   void srCompletedLab(Signal* signal);
  2474.   void openFileInitLab(Signal* signal);
  2475.   void openSrFrontpageLab(Signal* signal);
  2476.   void openSrLastFileLab(Signal* signal);
  2477.   void openSrNextFileLab(Signal* signal);
  2478.   void openExecSrStartLab(Signal* signal);
  2479.   void openExecSrNewMbyteLab(Signal* signal);
  2480.   void openSrFourthPhaseLab(Signal* signal);
  2481.   void openSrFourthZeroSkipInitLab(Signal* signal);
  2482.   void openSrFourthZeroLab(Signal* signal);
  2483.   void openExecLogLab(Signal* signal);
  2484.   void checkInitCompletedLab(Signal* signal);
  2485.   void closingSrLab(Signal* signal);
  2486.   void closeExecSrLab(Signal* signal);
  2487.   void execLogComp(Signal* signal);
  2488.   void closeWriteLogLab(Signal* signal);
  2489.   void closeExecLogLab(Signal* signal);
  2490.   void writePageZeroLab(Signal* signal);
  2491.   void lastWriteInFileLab(Signal* signal);
  2492.   void initWriteEndLab(Signal* signal);
  2493.   void initFirstPageLab(Signal* signal);
  2494.   void writeGciZeroLab(Signal* signal);
  2495.   void writeDirtyLab(Signal* signal);
  2496.   void writeInitMbyteLab(Signal* signal);
  2497.   void writeLogfileLab(Signal* signal);
  2498.   void firstPageWriteLab(Signal* signal);
  2499.   void readSrLastMbyteLab(Signal* signal);
  2500.   void readSrLastFileLab(Signal* signal);
  2501.   void readSrNextFileLab(Signal* signal);
  2502.   void readExecSrLab(Signal* signal);
  2503.   void readExecLogLab(Signal* signal);
  2504.   void readSrFourthPhaseLab(Signal* signal);
  2505.   void readSrFourthZeroLab(Signal* signal);
  2506.   void copyLqhKeyRefLab(Signal* signal);
  2507.   void restartOperationsLab(Signal* signal);
  2508.   void lqhTransNextLab(Signal* signal);
  2509.   void restartOperationsAfterStopLab(Signal* signal);
  2510.   void sttorStartphase1Lab(Signal* signal);
  2511.   void startphase1Lab(Signal* signal, Uint32 config, Uint32 nodeId);
  2512.   void tupkeyConfLab(Signal* signal);
  2513.   void copyTupkeyConfLab(Signal* signal);
  2514.   void scanTupkeyConfLab(Signal* signal);
  2515.   void scanTupkeyRefLab(Signal* signal);
  2516.   void accScanConfScanLab(Signal* signal);
  2517.   void accScanConfCopyLab(Signal* signal);
  2518.   void scanLockReleasedLab(Signal* signal);
  2519.   void accScanInfoEnterLab(Signal* signal, Uint32* dataPtr, Uint32 length);
  2520.   void openSrFourthNextLab(Signal* signal);
  2521.   void closingInitLab(Signal* signal);
  2522.   void closeExecSrCompletedLab(Signal* signal);
  2523.   void readSrFrontpageLab(Signal* signal);
  2524.   
  2525.   void sendAddFragReq(Signal* signal);
  2526.   void sendAddAttrReq(Signal* signal);
  2527.   void checkDropTab(Signal*);
  2528.   Uint32 checkDropTabState(Tablerec::TableStatus, Uint32) const;
  2529.   
  2530.   // Initialisation
  2531.   void initData();
  2532.   void initRecords();
  2533. // ----------------------------------------------------------------
  2534. // These are variables handling the records. For most records one
  2535. // pointer to the array of structs, one pointer-struct, a file size
  2536. // and a first free record variable. The pointer struct are temporary
  2537. // variables that are kept on the class object since there are often a
  2538. // great deal of those variables that exist simultaneously and
  2539. // thus no perfect solution of handling them is currently available.
  2540. // ----------------------------------------------------------------
  2541. /* ------------------------------------------------------------------------- */
  2542. /*       POSITIONS WITHIN THE ATTRINBUF AND THE MAX SIZE OF DATA WITHIN AN   */
  2543. /*       ATTRINBUF.                                                          */
  2544. /* ------------------------------------------------------------------------- */
  2545. #define ZADDFRAGREC_FILE_SIZE 1
  2546.   AddFragRecord *addFragRecord;
  2547.   AddFragRecordPtr addfragptr;
  2548.   UintR cfirstfreeAddfragrec;
  2549.   UintR caddfragrecFileSize;
  2550. #define ZATTRINBUF_FILE_SIZE 12288  // 1.5 MByte
  2551. #define ZINBUF_DATA_LEN 24            /* POSITION OF 'DATA LENGHT'-VARIABLE. */
  2552. #define ZINBUF_NEXT 25                /* POSITION OF 'NEXT'-VARIABLE.        */
  2553.   Attrbuf *attrbuf;
  2554.   AttrbufPtr attrinbufptr;
  2555.   UintR cfirstfreeAttrinbuf;
  2556.   UintR cattrinbufFileSize;
  2557.   Uint32 c_no_attrinbuf_recs;
  2558. #define ZDATABUF_FILE_SIZE 10000    // 200 kByte
  2559.   Databuf *databuf;
  2560.   DatabufPtr databufptr;
  2561.   UintR cfirstfreeDatabuf;
  2562.   UintR cdatabufFileSize;
  2563. // Configurable
  2564.   Fragrecord *fragrecord;
  2565.   FragrecordPtr fragptr;
  2566.   UintR cfirstfreeFragrec;
  2567.   UintR cfragrecFileSize;
  2568. #define ZGCPREC_FILE_SIZE 1
  2569.   GcpRecord *gcpRecord;
  2570.   GcpRecordPtr gcpPtr;
  2571.   UintR cgcprecFileSize;
  2572. // MAX_NDB_NODES is the size of this array
  2573.   HostRecord *hostRecord;
  2574.   UintR chostFileSize;
  2575. #define ZNO_CONCURRENT_LCP 1
  2576.   LcpRecord *lcpRecord;
  2577.   LcpRecordPtr lcpPtr;
  2578.   UintR cfirstfreeLcpLoc;
  2579.   UintR clcpFileSize;
  2580. #define ZLCP_LOCREC_FILE_SIZE 4
  2581.   LcpLocRecord *lcpLocRecord;
  2582.   LcpLocRecordPtr lcpLocptr;
  2583.   UintR clcpLocrecFileSize;
  2584. #define ZLOG_PART_FILE_SIZE 4
  2585.   LogPartRecord *logPartRecord;
  2586.   LogPartRecordPtr logPartPtr;
  2587.   UintR clogPartFileSize;
  2588. // Configurable
  2589.   LogFileRecord *logFileRecord;
  2590.   LogFileRecordPtr logFilePtr;
  2591.   UintR cfirstfreeLogFile;
  2592.   UintR clogFileFileSize;
  2593. #define ZLFO_FILE_SIZE 256            /* MAX 256 OUTSTANDING FILE OPERATIONS */
  2594.   LogFileOperationRecord *logFileOperationRecord;
  2595.   LogFileOperationRecordPtr lfoPtr;
  2596.   UintR cfirstfreeLfo;
  2597.   UintR clfoFileSize;
  2598.   LogPageRecord *logPageRecord;
  2599.   LogPageRecordPtr logPagePtr;
  2600.   UintR cfirstfreeLogPage;
  2601.   UintR clogPageFileSize;
  2602. #define ZPAGE_REF_FILE_SIZE 20
  2603.   PageRefRecord *pageRefRecord;
  2604.   PageRefRecordPtr pageRefPtr;
  2605.   UintR cfirstfreePageRef;
  2606.   UintR cpageRefFileSize;
  2607. #define ZSCANREC_FILE_SIZE 100
  2608.   ArrayPool<ScanRecord> c_scanRecordPool;
  2609.   ScanRecordPtr scanptr;
  2610.   UintR cscanNoFreeRec;
  2611.   Uint32 cscanrecFileSize;
  2612. // Configurable
  2613.   Tablerec *tablerec;
  2614.   TablerecPtr tabptr;
  2615.   UintR ctabrecFileSize;
  2616. // Configurable
  2617.   TcConnectionrec *tcConnectionrec;
  2618.   TcConnectionrecPtr tcConnectptr;
  2619.   UintR cfirstfreeTcConrec;
  2620.   UintR ctcConnectrecFileSize;
  2621. // MAX_NDB_NODES is the size of this array
  2622.   TcNodeFailRecord *tcNodeFailRecord;
  2623.   TcNodeFailRecordPtr tcNodeFailptr;
  2624.   UintR ctcNodeFailrecFileSize;
  2625.   Uint16 terrorCode;
  2626.   Uint32 c_firstInNodeGroup;
  2627. // ------------------------------------------------------------------------
  2628. // These variables are used to store block state which do not need arrays
  2629. // of struct's.
  2630. // ------------------------------------------------------------------------
  2631.   Uint32 c_lcpId;
  2632.   Uint32 cnoOfFragsCheckpointed;
  2633. /* ------------------------------------------------------------------------- */
  2634. // cmaxWordsAtNodeRec keeps track of how many words that currently are
  2635. // outstanding in a node recovery situation.
  2636. // cbookedAccOps keeps track of how many operation records that have been
  2637. // booked in ACC for the scan processes.
  2638. // cmaxAccOps contains the maximum number of operation records which can be
  2639. // allocated for scan purposes in ACC.
  2640. /* ------------------------------------------------------------------------- */
  2641.   UintR cmaxWordsAtNodeRec;
  2642.   UintR cbookedAccOps;
  2643.   UintR cmaxAccOps;
  2644. /* ------------------------------------------------------------------------- */
  2645. /*THIS STATE VARIABLE IS ZTRUE IF AN ADD NODE IS ONGOING. ADD NODE MEANS     */
  2646. /*THAT CONNECTIONS ARE SET-UP TO THE NEW NODE.                               */
  2647. /* ------------------------------------------------------------------------- */
  2648.   Uint8 caddNodeState;
  2649. /* ------------------------------------------------------------------------- */
  2650. /*THIS VARIABLE SPECIFIES WHICH TYPE OF RESTART THAT IS ONGOING              */
  2651. /* ------------------------------------------------------------------------- */
  2652.   Uint16 cstartType;
  2653. /* ------------------------------------------------------------------------- */
  2654. /*THIS VARIABLE INDICATES WHETHER AN INITIAL RESTART IS ONGOING OR NOT.      */
  2655. /* ------------------------------------------------------------------------- */
  2656.   Uint8 cinitialStartOngoing;
  2657. /* ------------------------------------------------------------------------- */
  2658. /*THIS VARIABLE KEEPS TRACK OF WHEN TUP AND ACC HAVE COMPLETED EXECUTING     */
  2659. /*THEIR UNDO LOG.                                                            */
  2660. /* ------------------------------------------------------------------------- */
  2661.   ExecUndoLogState csrExecUndoLogState;
  2662. /* ------------------------------------------------------------------------- */
  2663. /*THIS VARIABLE KEEPS TRACK OF WHEN TUP AND ACC HAVE CONFIRMED COMPLETION    */
  2664. /*OF A LOCAL CHECKPOINT ROUND.                                               */
  2665. /* ------------------------------------------------------------------------- */
  2666.   LcpCloseState clcpCompletedState;
  2667. /* ------------------------------------------------------------------------- */
  2668. /*DURING CONNECTION PROCESSES IN SYSTEM RESTART THESE VARIABLES KEEP TRACK   */
  2669. /*OF HOW MANY CONNECTIONS AND RELEASES THAT ARE TO BE PERFORMED.             */
  2670. /* ------------------------------------------------------------------------- */
  2671. /***************************************************************************>*/
  2672. /*THESE VARIABLES CONTAIN INFORMATION USED DURING SYSTEM RESTART.            */
  2673. /***************************************************************************>*/
  2674. /* ------------------------------------------------------------------------- */
  2675. /*THIS VARIABLE IS ZTRUE IF THE SIGNAL START_REC_REQ HAVE BEEN RECEIVED.     */
  2676. /*RECEPTION OF THIS SIGNAL INDICATES THAT ALL FRAGMENTS THAT THIS NODE       */
  2677. /*SHOULD START HAVE BEEN RECEIVED.                                           */
  2678. /* ------------------------------------------------------------------------- */
  2679.   Uint8 cstartRecReq;
  2680. /* ------------------------------------------------------------------------- */
  2681. /*THIS VARIABLE KEEPS TRACK OF HOW MANY FRAGMENTS THAT PARTICIPATE IN        */
  2682. /*EXECUTING THE LOG. IF ZERO WE DON'T NEED TO EXECUTE THE LOG AT ALL.        */
  2683. /* ------------------------------------------------------------------------- */
  2684.   UintR cnoFragmentsExecSr;
  2685. /* ------------------------------------------------------------------------- */
  2686. /*THIS VARIABLE KEEPS TRACK OF WHICH OF THE FIRST TWO RESTART PHASES THAT    */
  2687. /*HAVE COMPLETED.                                                            */
  2688. /* ------------------------------------------------------------------------- */
  2689.   Uint8 csrPhaseStarted;
  2690. /* ------------------------------------------------------------------------- */
  2691. /*NUMBER OF PHASES COMPLETED OF EXECUTING THE FRAGMENT LOG.                  */
  2692. /* ------------------------------------------------------------------------- */
  2693.   Uint8 csrPhasesCompleted;
  2694. /* ------------------------------------------------------------------------- */
  2695. /*THE BLOCK REFERENCE OF THE MASTER DIH DURING SYSTEM RESTART.               */
  2696. /* ------------------------------------------------------------------------- */
  2697.   BlockReference cmasterDihBlockref;
  2698. /* ------------------------------------------------------------------------- */
  2699. /*THIS VARIABLE IS THE HEAD OF A LINKED LIST OF FRAGMENTS WAITING TO BE      */
  2700. /*RESTORED FROM DISK.                                                        */
  2701. /* ------------------------------------------------------------------------- */
  2702.   UintR cfirstWaitFragSr;
  2703. /* ------------------------------------------------------------------------- */
  2704. /*THIS VARIABLE IS THE HEAD OF A LINKED LIST OF FRAGMENTS THAT HAVE BEEN     */
  2705. /*RESTORED FROM DISK THAT AWAITS EXECUTION OF THE FRAGMENT LOG.              */
  2706. /* ------------------------------------------------------------------------- */
  2707.   UintR cfirstCompletedFragSr;
  2708.   /**
  2709.    * List of fragment that the log execution is completed for
  2710.    */
  2711.   Uint32 c_redo_log_complete_frags;
  2712.   
  2713. /* ------------------------------------------------------------------------- */
  2714. /*USED DURING SYSTEM RESTART, INDICATES THE OLDEST GCI THAT CAN BE RESTARTED */
  2715. /*FROM AFTER THIS SYSTEM RESTART. USED TO FIND THE LOG TAIL.                 */
  2716. /* ------------------------------------------------------------------------- */
  2717.   UintR crestartOldestGci;
  2718. /* ------------------------------------------------------------------------- */
  2719. /*USED DURING SYSTEM RESTART, INDICATES THE NEWEST GCI THAT CAN BE RESTARTED */
  2720. /*AFTER THIS SYSTEM RESTART. USED TO FIND THE LOG HEAD.                      */
  2721. /* ------------------------------------------------------------------------- */
  2722.   UintR crestartNewestGci;
  2723. /* ------------------------------------------------------------------------- */
  2724. /*THE NUMBER OF LOG FILES. SET AS A PARAMETER WHEN NDB IS STARTED.           */
  2725. /* ------------------------------------------------------------------------- */
  2726.   UintR cnoLogFiles;
  2727. /* ------------------------------------------------------------------------- */
  2728. /*THESE TWO VARIABLES CONTAIN THE NEWEST GCI RECEIVED IN THE BLOCK AND THE   */
  2729. /*NEWEST COMPLETED GCI IN THE BLOCK.                                         */
  2730. /* ------------------------------------------------------------------------- */
  2731.   UintR cnewestGci;
  2732.   UintR cnewestCompletedGci;
  2733. /* ------------------------------------------------------------------------- */
  2734. /*THIS VARIABLE ONLY PASSES INFORMATION FROM STTOR TO STTORRY = TEMPORARY    */
  2735. /* ------------------------------------------------------------------------- */
  2736.   Uint16 csignalKey;
  2737. /* ------------------------------------------------------------------------- */
  2738. /*THIS VARIABLE CONTAINS THE CURRENT START PHASE IN THE BLOCK. IS ZNIL IF    */
  2739. /*NO SYSTEM RESTART IS ONGOING.                                              */
  2740. /* ------------------------------------------------------------------------- */
  2741.   Uint16 cstartPhase;
  2742. /* ------------------------------------------------------------------------- */
  2743. /*THIS VARIABLE CONTAIN THE CURRENT GLOBAL CHECKPOINT RECORD. IT'S RNIL IF   */
  2744. /*NOT A GCP SAVE IS ONGOING.                                                 */
  2745. /* ------------------------------------------------------------------------- */
  2746.   UintR ccurrentGcprec;
  2747. /* ------------------------------------------------------------------------- */
  2748. /*THESE VARIABLES ARE USED TO KEEP TRACK OF ALL ACTIVE COPY FRAGMENTS IN LQH.*/
  2749. /* ------------------------------------------------------------------------- */
  2750.   Uint8 cnoActiveCopy;
  2751.   UintR cactiveCopy[4];
  2752. /* ------------------------------------------------------------------------- */
  2753. /*THESE VARIABLES CONTAIN THE BLOCK REFERENCES OF THE OTHER NDB BLOCKS.      */
  2754. /*ALSO THE BLOCK REFERENCE OF MY OWN BLOCK = LQH                             */
  2755. /* ------------------------------------------------------------------------- */
  2756.   BlockReference caccBlockref;
  2757.   BlockReference ctupBlockref;
  2758.   BlockReference ctuxBlockref;
  2759.   BlockReference cownref;
  2760.   UintR cLqhTimeOutCount;
  2761.   UintR cLqhTimeOutCheckCount;
  2762.   UintR cnoOfLogPages;
  2763.   bool  caccCommitBlocked;
  2764.   bool  ctupCommitBlocked;
  2765.   bool  cCommitBlocked;
  2766.   UintR cCounterAccCommitBlocked;
  2767.   UintR cCounterTupCommitBlocked;
  2768. /* ------------------------------------------------------------------------- */
  2769. /*THIS VARIABLE CONTAINS MY OWN PROCESSOR ID.                                */
  2770. /* ------------------------------------------------------------------------- */
  2771.   NodeId cownNodeid;
  2772. /* ------------------------------------------------------------------------- */
  2773. /*THESE VARIABLES CONTAIN INFORMATION ABOUT THE OTHER NODES IN THE SYSTEM    */
  2774. /*THESE VARIABLES ARE MOSTLY USED AT SYSTEM RESTART AND ADD NODE TO SET-UP   */
  2775. /*AND RELEASE CONNECTIONS TO OTHER NODES IN THE CLUSTER.                     */
  2776. /* ------------------------------------------------------------------------- */
  2777. /* ------------------------------------------------------------------------- */
  2778. /*THIS ARRAY CONTAINS THE PROCESSOR ID'S OF THE NODES THAT ARE ALIVE.        */
  2779. /*CNO_OF_NODES SPECIFIES HOW MANY NODES THAT ARE CURRENTLY ALIVE.            */
  2780. /*CNODE_VERSION SPECIFIES THE NDB VERSION EXECUTING ON THE NODE.             */
  2781. /* ------------------------------------------------------------------------- */
  2782.   UintR cpackedListIndex;
  2783.   Uint16 cpackedList[MAX_NDB_NODES];
  2784.   UintR cnodeData[MAX_NDB_NODES];
  2785.   UintR cnodeStatus[MAX_NDB_NODES];
  2786. /* ------------------------------------------------------------------------- */
  2787. /*THIS VARIABLE INDICATES WHETHER A CERTAIN NODE HAS SENT ALL FRAGMENTS THAT */
  2788. /*NEED TO HAVE THE LOG EXECUTED.                                             */
  2789. /* ------------------------------------------------------------------------- */
  2790.   Uint8 cnodeSrState[MAX_NDB_NODES];
  2791. /* ------------------------------------------------------------------------- */
  2792. /*THIS VARIABLE INDICATES WHETHER A CERTAIN NODE HAVE EXECUTED THE LOG       */
  2793. /* ------------------------------------------------------------------------- */
  2794.   Uint8 cnodeExecSrState[MAX_NDB_NODES];
  2795.   UintR cnoOfNodes;
  2796. /* ------------------------------------------------------------------------- */
  2797. /* THIS VARIABLE CONTAINS THE DIRECTORY OF A HASH TABLE OF ALL ACTIVE        */
  2798. /* OPERATION IN THE BLOCK. IT IS USED TO BE ABLE TO QUICKLY ABORT AN         */
  2799. /* OPERATION WHERE THE CONNECTION WAS LOST DUE TO NODE FAILURES. IT IS       */
  2800. /* ACTUALLY USED FOR ALL ABORTS COMMANDED BY TC.                             */
  2801. /* ------------------------------------------------------------------------- */
  2802.   UintR preComputedRequestInfoMask;
  2803.   UintR ctransidHash[1024];
  2804.   
  2805.   Uint32 c_diskless;
  2806.   
  2807. public:
  2808.   /**
  2809.    *
  2810.    */
  2811.   struct CommitAckMarker {
  2812.     Uint32 transid1;
  2813.     Uint32 transid2;
  2814.     
  2815.     Uint32 apiRef;    // Api block ref
  2816.     Uint32 apiOprec;  // Connection Object in NDB API
  2817.     Uint32 tcNodeId;  
  2818.     union { Uint32 nextPool; Uint32 nextHash; };
  2819.     Uint32 prevHash;
  2820.     inline bool equal(const CommitAckMarker & p) const {
  2821.       return ((p.transid1 == transid1) && (p.transid2 == transid2));
  2822.     }
  2823.     
  2824.     inline Uint32 hashValue() const {
  2825.       return transid1;
  2826.     }
  2827.   };
  2828.   typedef Ptr<CommitAckMarker> CommitAckMarkerPtr;
  2829.   ArrayPool<CommitAckMarker>   m_commitAckMarkerPool;
  2830.   DLHashTable<CommitAckMarker> m_commitAckMarkerHash;
  2831.   typedef DLHashTable<CommitAckMarker>::Iterator CommitAckMarkerIterator;
  2832.   void execREMOVE_MARKER_ORD(Signal* signal);
  2833.   void scanMarkers(Signal* signal, Uint32 tcNodeFail, Uint32 bucket, Uint32 i);
  2834.   struct Counters {
  2835.     Uint32 operations;
  2836.     
  2837.     inline void clear(){
  2838.       operations = 0;
  2839.     }
  2840.   };
  2841.   Counters c_Counters;
  2842.   
  2843.   inline bool getAllowRead() const {
  2844.     return getNodeState().startLevel < NodeState::SL_STOPPING_3;
  2845.   }
  2846.   DLHashTable<ScanRecord> c_scanTakeOverHash;
  2847. };
  2848. inline
  2849. bool
  2850. Dblqh::ScanRecord::check_scan_batch_completed() const
  2851. {
  2852.   Uint32 max_rows = m_max_batch_size_rows;
  2853.   Uint32 max_bytes = m_max_batch_size_bytes;
  2854.   return (max_rows > 0 && (m_curr_batch_size_rows >= max_rows))  ||
  2855.     (max_bytes > 0 && (m_curr_batch_size_bytes >= max_bytes));
  2856. }
  2857. inline
  2858. void
  2859. Dblqh::i_get_acc_ptr(ScanRecord* scanP, Uint32* &acc_ptr, Uint32 index)
  2860. {
  2861.   if (index == 0) {
  2862.     acc_ptr= (Uint32*)&scanP->scan_acc_op_ptr[0];
  2863.   } else {
  2864.     Uint32 attr_buf_index, attr_buf_rec;
  2865.     
  2866.     AttrbufPtr regAttrPtr;
  2867.     jam();
  2868.     attr_buf_rec= (index + 31) / 32;
  2869.     attr_buf_index= (index - 1) & 31;
  2870.     regAttrPtr.i= scanP->scan_acc_op_ptr[attr_buf_rec];
  2871.     ptrCheckGuard(regAttrPtr, cattrinbufFileSize, attrbuf);
  2872.     acc_ptr= (Uint32*)&regAttrPtr.p->attrbuf[attr_buf_index];
  2873.   }
  2874. }
  2875. #endif