1 /*
2    Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
3 
4    This program is free software; you can redistribute it and/or modify
5    it under the terms of the GNU General Public License, version 2.0,
6    as published by the Free Software Foundation.
7 
8    This program is also distributed with certain software (including
9    but not limited to OpenSSL) that is licensed under separate terms,
10    as designated in a particular file or component or in included license
11    documentation.  The authors of MySQL hereby grant you an additional
12    permission to link the program and your derivative works with the
13    separately licensed software that they have included with MySQL.
14 
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License, version 2.0, for more details.
19 
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
23 */
24 
25 
26 #define DBDIH_C
27 #include "Dbdih.hpp"
28 #include <ndb_limits.h>
29 
30 #define DEBUG(x) { ndbout << "DIH::" << x << endl; }
31 
initData()32 void Dbdih::initData()
33 {
34   cpageFileSize = ZPAGEREC;
35 
36   // Records with constant sizes
37   createReplicaRecord = (CreateReplicaRecord*)
38     allocRecord("CreateReplicaRecord", sizeof(CreateReplicaRecord),
39                  ZCREATE_REPLICA_FILE_SIZE);
40 
41   nodeGroupRecord = (NodeGroupRecord*)
42     allocRecord("NodeGroupRecord", sizeof(NodeGroupRecord), MAX_NDB_NODES);
43 
44   nodeRecord = (NodeRecord*)
45     allocRecord("NodeRecord", sizeof(NodeRecord), MAX_NDB_NODES);
46 
47   Uint32 i;
48   for(i = 0; i<MAX_NDB_NODES; i++){
49     new (&nodeRecord[i]) NodeRecord();
50   }
51 
52   c_takeOverPool.setSize(MAX_NDB_NODES);
53   {
54     Ptr<TakeOverRecord> ptr;
55     while (c_activeTakeOverList.seize(ptr))
56     {
57       new (ptr.p) TakeOverRecord;
58     }
59     while (c_activeTakeOverList.first(ptr))
60     {
61       releaseTakeOver(ptr);
62     }
63   }
64 
65   waitGCPProxyPool.setSize(ZPROXY_FILE_SIZE);
66   waitGCPMasterPool.setSize(ZPROXY_MASTER_FILE_SIZE);
67 
68   c_dictLockSlavePool.setSize(1); // assert single usage
69   c_dictLockSlavePtrI_nodeRestart = RNIL;
70 
71   cgcpOrderBlocked = 0;
72   c_lcpState.ctcCounter = 0;
73   c_lcpState.m_lcp_trylock_timeout = 0;
74   cwaitLcpSr       = false;
75   c_blockCommit    = false;
76   c_blockCommitNo  = 1;
77   cntrlblockref    = RNIL;
78   c_set_initial_start_flag = FALSE;
79   c_sr_wait_to = false;
80   c_2pass_inr = false;
81 }//Dbdih::initData()
82 
initRecords()83 void Dbdih::initRecords()
84 {
85   // Records with dynamic sizes
86   for (Uint32 i = 0; i < c_diverify_queue_cnt; i++)
87   {
88     c_diverify_queue[i].apiConnectRecord = (ApiConnectRecord*)
89       allocRecord("ApiConnectRecord",
90                   sizeof(ApiConnectRecord),
91                   capiConnectFileSize);
92   }
93 
94   connectRecord = (ConnectRecord*)allocRecord("ConnectRecord",
95                                               sizeof(ConnectRecord),
96                                               cconnectFileSize);
97 
98   fileRecord = (FileRecord*)allocRecord("FileRecord",
99                                         sizeof(FileRecord),
100                                         cfileFileSize);
101 
102   fragmentstore = (Fragmentstore*)allocRecord("Fragmentstore",
103                                               sizeof(Fragmentstore),
104                                               cfragstoreFileSize);
105 
106   pageRecord = (PageRecord*)allocRecord("PageRecord",
107                                   sizeof(PageRecord),
108                                   cpageFileSize);
109 
110   replicaRecord = (ReplicaRecord*)allocRecord("ReplicaRecord",
111                                               sizeof(ReplicaRecord),
112                                               creplicaFileSize);
113 
114   tabRecord = (TabRecord*)allocRecord("TabRecord",
115                                               sizeof(TabRecord),
116                                               ctabFileSize);
117 
118   // Initialize BAT for interface to file system
119   NewVARIABLE* bat = allocateBat(22);
120   bat[1].WA = &pageRecord->word[0];
121   bat[1].nrr = cpageFileSize;
122   bat[1].ClusterSize = sizeof(PageRecord);
123   bat[1].bits.q = 11;
124   bat[1].bits.v = 5;
125   bat[20].WA = &sysfileData[0];
126   bat[20].nrr = 1;
127   bat[20].ClusterSize = sizeof(sysfileData);
128   bat[20].bits.q = 7;
129   bat[20].bits.v = 5;
130   bat[21].WA = &sysfileDataToFile[0];
131   bat[21].nrr = 1;
132   bat[21].ClusterSize = sizeof(sysfileDataToFile);
133   bat[21].bits.q = 7;
134   bat[21].bits.v = 5;
135 }//Dbdih::initRecords()
136 
Dbdih(Block_context & ctx)137 Dbdih::Dbdih(Block_context& ctx):
138   SimulatedBlock(DBDIH, ctx),
139   c_activeTakeOverList(c_takeOverPool),
140   c_waitGCPProxyList(waitGCPProxyPool),
141   c_waitGCPMasterList(waitGCPMasterPool),
142   c_waitEpochMasterList(waitGCPMasterPool)
143 {
144   BLOCK_CONSTRUCTOR(Dbdih);
145 
146   addRecSignal(GSN_DUMP_STATE_ORD, &Dbdih::execDUMP_STATE_ORD);
147   addRecSignal(GSN_NDB_TAMPER, &Dbdih::execNDB_TAMPER, true);
148   addRecSignal(GSN_DEBUG_SIG, &Dbdih::execDEBUG_SIG);
149   addRecSignal(GSN_MASTER_GCPREQ, &Dbdih::execMASTER_GCPREQ);
150   addRecSignal(GSN_MASTER_GCPREF, &Dbdih::execMASTER_GCPREF);
151   addRecSignal(GSN_MASTER_GCPCONF, &Dbdih::execMASTER_GCPCONF);
152   addRecSignal(GSN_EMPTY_LCP_CONF, &Dbdih::execEMPTY_LCP_CONF);
153   addRecSignal(GSN_EMPTY_LCP_REP, &Dbdih::execEMPTY_LCP_REP);
154 
155   addRecSignal(GSN_MASTER_LCPREQ, &Dbdih::execMASTER_LCPREQ);
156   addRecSignal(GSN_MASTER_LCPREF, &Dbdih::execMASTER_LCPREF);
157   addRecSignal(GSN_MASTER_LCPCONF, &Dbdih::execMASTER_LCPCONF);
158   addRecSignal(GSN_NF_COMPLETEREP, &Dbdih::execNF_COMPLETEREP);
159   addRecSignal(GSN_START_PERMREQ, &Dbdih::execSTART_PERMREQ);
160   addRecSignal(GSN_START_PERMCONF, &Dbdih::execSTART_PERMCONF);
161   addRecSignal(GSN_START_PERMREF, &Dbdih::execSTART_PERMREF);
162   addRecSignal(GSN_INCL_NODEREQ, &Dbdih::execINCL_NODEREQ);
163   addRecSignal(GSN_INCL_NODECONF, &Dbdih::execINCL_NODECONF);
164 
165   addRecSignal(GSN_START_TOREQ, &Dbdih::execSTART_TOREQ);
166   addRecSignal(GSN_START_TOREF, &Dbdih::execSTART_TOREQ);
167   addRecSignal(GSN_START_TOCONF, &Dbdih::execSTART_TOCONF);
168 
169   addRecSignal(GSN_UPDATE_TOREQ, &Dbdih::execUPDATE_TOREQ);
170   addRecSignal(GSN_UPDATE_TOREF, &Dbdih::execUPDATE_TOREF);
171   addRecSignal(GSN_UPDATE_TOCONF, &Dbdih::execUPDATE_TOCONF);
172 
173   addRecSignal(GSN_END_TOREQ, &Dbdih::execEND_TOREQ);
174   addRecSignal(GSN_END_TOREF, &Dbdih::execEND_TOREF);
175   addRecSignal(GSN_END_TOCONF, &Dbdih::execEND_TOCONF);
176 
177   addRecSignal(GSN_START_MEREQ, &Dbdih::execSTART_MEREQ);
178   addRecSignal(GSN_START_MECONF, &Dbdih::execSTART_MECONF);
179   addRecSignal(GSN_START_MEREF, &Dbdih::execSTART_MEREF);
180   addRecSignal(GSN_START_COPYREQ, &Dbdih::execSTART_COPYREQ);
181   addRecSignal(GSN_START_COPYCONF, &Dbdih::execSTART_COPYCONF);
182   addRecSignal(GSN_START_COPYREF, &Dbdih::execSTART_COPYREF);
183   addRecSignal(GSN_CREATE_FRAGREQ, &Dbdih::execCREATE_FRAGREQ);
184   addRecSignal(GSN_CREATE_FRAGCONF, &Dbdih::execCREATE_FRAGCONF);
185   addRecSignal(GSN_DIVERIFYREQ, &Dbdih::execDIVERIFYREQ);
186   addRecSignal(GSN_GCP_SAVEREQ, &Dbdih::execGCP_SAVEREQ);
187   addRecSignal(GSN_GCP_SAVEREF, &Dbdih::execGCP_SAVEREF);
188   addRecSignal(GSN_GCP_SAVECONF, &Dbdih::execGCP_SAVECONF);
189   addRecSignal(GSN_GCP_PREPARECONF, &Dbdih::execGCP_PREPARECONF);
190   addRecSignal(GSN_GCP_PREPARE, &Dbdih::execGCP_PREPARE);
191   addRecSignal(GSN_GCP_NODEFINISH, &Dbdih::execGCP_NODEFINISH);
192   addRecSignal(GSN_GCP_COMMIT, &Dbdih::execGCP_COMMIT);
193   addRecSignal(GSN_SUB_GCP_COMPLETE_REP, &Dbdih::execSUB_GCP_COMPLETE_REP);
194   addRecSignal(GSN_SUB_GCP_COMPLETE_ACK, &Dbdih::execSUB_GCP_COMPLETE_ACK);
195   addRecSignal(GSN_DIHNDBTAMPER, &Dbdih::execDIHNDBTAMPER);
196   addRecSignal(GSN_CONTINUEB, &Dbdih::execCONTINUEB);
197   addRecSignal(GSN_COPY_GCIREQ, &Dbdih::execCOPY_GCIREQ);
198   addRecSignal(GSN_COPY_GCICONF, &Dbdih::execCOPY_GCICONF);
199   addRecSignal(GSN_COPY_TABREQ, &Dbdih::execCOPY_TABREQ);
200   addRecSignal(GSN_COPY_TABCONF, &Dbdih::execCOPY_TABCONF);
201   addRecSignal(GSN_TCGETOPSIZECONF, &Dbdih::execTCGETOPSIZECONF);
202   addRecSignal(GSN_TC_CLOPSIZECONF, &Dbdih::execTC_CLOPSIZECONF);
203 
204   addRecSignal(GSN_LCP_COMPLETE_REP, &Dbdih::execLCP_COMPLETE_REP);
205   addRecSignal(GSN_LCP_FRAG_REP, &Dbdih::execLCP_FRAG_REP);
206   addRecSignal(GSN_START_LCP_REQ, &Dbdih::execSTART_LCP_REQ);
207   addRecSignal(GSN_START_LCP_CONF, &Dbdih::execSTART_LCP_CONF);
208 
209   addRecSignal(GSN_READ_CONFIG_REQ, &Dbdih::execREAD_CONFIG_REQ, true);
210   addRecSignal(GSN_UNBLO_DICTCONF, &Dbdih::execUNBLO_DICTCONF);
211   addRecSignal(GSN_COPY_ACTIVECONF, &Dbdih::execCOPY_ACTIVECONF);
212   addRecSignal(GSN_TAB_COMMITREQ, &Dbdih::execTAB_COMMITREQ);
213   addRecSignal(GSN_NODE_FAILREP, &Dbdih::execNODE_FAILREP);
214   addRecSignal(GSN_COPY_FRAGCONF, &Dbdih::execCOPY_FRAGCONF);
215   addRecSignal(GSN_COPY_FRAGREF, &Dbdih::execCOPY_FRAGREF);
216   addRecSignal(GSN_DIADDTABREQ, &Dbdih::execDIADDTABREQ);
217   addRecSignal(GSN_DIGETNODESREQ, &Dbdih::execDIGETNODESREQ);
218   addRecSignal(GSN_STTOR, &Dbdih::execSTTOR);
219   addRecSignal(GSN_DIH_SCAN_TAB_REQ, &Dbdih::execDIH_SCAN_TAB_REQ);
220   addRecSignal(GSN_DIH_SCAN_GET_NODES_REQ, &Dbdih::execDIH_SCAN_GET_NODES_REQ);
221   addRecSignal(GSN_DIH_SCAN_TAB_COMPLETE_REP,
222                &Dbdih::execDIH_SCAN_TAB_COMPLETE_REP);
223   addRecSignal(GSN_GCP_TCFINISHED, &Dbdih::execGCP_TCFINISHED);
224   addRecSignal(GSN_READ_NODESCONF, &Dbdih::execREAD_NODESCONF);
225   addRecSignal(GSN_NDB_STTOR, &Dbdih::execNDB_STTOR);
226   addRecSignal(GSN_DICTSTARTCONF, &Dbdih::execDICTSTARTCONF);
227   addRecSignal(GSN_NDB_STARTREQ, &Dbdih::execNDB_STARTREQ);
228   addRecSignal(GSN_GETGCIREQ, &Dbdih::execGETGCIREQ);
229   addRecSignal(GSN_DIH_RESTARTREQ, &Dbdih::execDIH_RESTARTREQ);
230   addRecSignal(GSN_START_RECCONF, &Dbdih::execSTART_RECCONF);
231   addRecSignal(GSN_START_FRAGCONF, &Dbdih::execSTART_FRAGCONF);
232   addRecSignal(GSN_ADD_FRAGCONF, &Dbdih::execADD_FRAGCONF);
233   addRecSignal(GSN_ADD_FRAGREF, &Dbdih::execADD_FRAGREF);
234   addRecSignal(GSN_DROP_FRAG_REF, &Dbdih::execDROP_FRAG_REF);
235   addRecSignal(GSN_DROP_FRAG_CONF, &Dbdih::execDROP_FRAG_CONF);
236   addRecSignal(GSN_FSOPENCONF, &Dbdih::execFSOPENCONF);
237   addRecSignal(GSN_FSOPENREF, &Dbdih::execFSOPENREF, true);
238   addRecSignal(GSN_FSCLOSECONF, &Dbdih::execFSCLOSECONF);
239   addRecSignal(GSN_FSCLOSEREF, &Dbdih::execFSCLOSEREF, true);
240   addRecSignal(GSN_FSREADCONF, &Dbdih::execFSREADCONF);
241   addRecSignal(GSN_FSREADREF, &Dbdih::execFSREADREF, true);
242   addRecSignal(GSN_FSWRITECONF, &Dbdih::execFSWRITECONF);
243   addRecSignal(GSN_FSWRITEREF, &Dbdih::execFSWRITEREF, true);
244 
245   addRecSignal(GSN_START_INFOREQ,
246                &Dbdih::execSTART_INFOREQ);
247   addRecSignal(GSN_START_INFOREF,
248                &Dbdih::execSTART_INFOREF);
249   addRecSignal(GSN_START_INFOCONF,
250                &Dbdih::execSTART_INFOCONF);
251 
252   addRecSignal(GSN_CHECKNODEGROUPSREQ, &Dbdih::execCHECKNODEGROUPSREQ);
253 
254   addRecSignal(GSN_BLOCK_COMMIT_ORD,
255 	       &Dbdih::execBLOCK_COMMIT_ORD);
256   addRecSignal(GSN_UNBLOCK_COMMIT_ORD,
257 	       &Dbdih::execUNBLOCK_COMMIT_ORD);
258 
259   addRecSignal(GSN_DIH_SWITCH_REPLICA_REQ,
260 	       &Dbdih::execDIH_SWITCH_REPLICA_REQ);
261 
262   addRecSignal(GSN_DIH_SWITCH_REPLICA_REF,
263 	       &Dbdih::execDIH_SWITCH_REPLICA_REF);
264 
265   addRecSignal(GSN_DIH_SWITCH_REPLICA_CONF,
266 	       &Dbdih::execDIH_SWITCH_REPLICA_CONF);
267 
268   addRecSignal(GSN_STOP_PERM_REQ, &Dbdih::execSTOP_PERM_REQ);
269   addRecSignal(GSN_STOP_PERM_REF, &Dbdih::execSTOP_PERM_REF);
270   addRecSignal(GSN_STOP_PERM_CONF, &Dbdih::execSTOP_PERM_CONF);
271 
272   addRecSignal(GSN_STOP_ME_REQ, &Dbdih::execSTOP_ME_REQ);
273   addRecSignal(GSN_STOP_ME_REF, &Dbdih::execSTOP_ME_REF);
274   addRecSignal(GSN_STOP_ME_CONF, &Dbdih::execSTOP_ME_CONF);
275 
276   addRecSignal(GSN_WAIT_GCP_REQ, &Dbdih::execWAIT_GCP_REQ);
277   addRecSignal(GSN_WAIT_GCP_REF, &Dbdih::execWAIT_GCP_REF);
278   addRecSignal(GSN_WAIT_GCP_CONF, &Dbdih::execWAIT_GCP_CONF);
279 
280   addRecSignal(GSN_PREP_DROP_TAB_REQ, &Dbdih::execPREP_DROP_TAB_REQ);
281   addRecSignal(GSN_DROP_TAB_REQ, &Dbdih::execDROP_TAB_REQ);
282 
283   addRecSignal(GSN_ALTER_TAB_REQ, &Dbdih::execALTER_TAB_REQ);
284 
285   addRecSignal(GSN_CREATE_FRAGMENTATION_REQ,
286 	       &Dbdih::execCREATE_FRAGMENTATION_REQ);
287 
288   addRecSignal(GSN_DICT_LOCK_CONF, &Dbdih::execDICT_LOCK_CONF);
289   addRecSignal(GSN_DICT_LOCK_REF, &Dbdih::execDICT_LOCK_REF);
290   addRecSignal(GSN_NODE_START_REP, &Dbdih::execNODE_START_REP, true);
291 
292   addRecSignal(GSN_START_FRAGREF,
293 	       &Dbdih::execSTART_FRAGREF);
294 
295   addRecSignal(GSN_PREPARE_COPY_FRAG_REF,
296 	       &Dbdih::execPREPARE_COPY_FRAG_REF);
297   addRecSignal(GSN_PREPARE_COPY_FRAG_CONF,
298 	       &Dbdih::execPREPARE_COPY_FRAG_CONF);
299 
300   addRecSignal(GSN_UPGRADE_PROTOCOL_ORD,
301 	       &Dbdih::execUPGRADE_PROTOCOL_ORD);
302 
303   addRecSignal(GSN_CREATE_NODEGROUP_IMPL_REQ,
304                &Dbdih::execCREATE_NODEGROUP_IMPL_REQ);
305 
306   addRecSignal(GSN_DROP_NODEGROUP_IMPL_REQ,
307                &Dbdih::execDROP_NODEGROUP_IMPL_REQ);
308 
309 
310   addRecSignal(GSN_DIH_GET_TABINFO_REQ,
311                &Dbdih::execDIH_GET_TABINFO_REQ);
312 #if 0
313   addRecSignal(GSN_DIH_GET_TABINFO_REF,
314                &Dbdih::execDIH_GET_TABINFO_REF);
315   addRecSignal(GSN_DIH_GET_TABINFO_CONF,
316                &Dbdih::execDIH_GET_TABINFO_CONF);
317 #endif
318 
319   connectRecord = 0;
320   fileRecord = 0;
321   fragmentstore = 0;
322   pageRecord = 0;
323   replicaRecord = 0;
324   tabRecord = 0;
325   createReplicaRecord = 0;
326   nodeGroupRecord = 0;
327   nodeRecord = 0;
328   c_nextNodeGroup = 0;
329   c_fragments_per_node = 1;
330   bzero(c_node_groups, sizeof(c_node_groups));
331   c_diverify_queue_cnt = 1;
332 
333 }//Dbdih::Dbdih()
334 
~Dbdih()335 Dbdih::~Dbdih()
336 {
337   for (Uint32 i = 0; i<c_diverify_queue_cnt; i++)
338   {
339     deallocRecord((void **)&c_diverify_queue[i].apiConnectRecord,
340                   "ApiConnectRecord",
341                   sizeof(ApiConnectRecord),
342                   capiConnectFileSize);
343   }
344 
345   deallocRecord((void **)&connectRecord, "ConnectRecord",
346                 sizeof(ConnectRecord),
347                 cconnectFileSize);
348 
349   deallocRecord((void **)&fileRecord, "FileRecord",
350                 sizeof(FileRecord),
351                 cfileFileSize);
352 
353   deallocRecord((void **)&fragmentstore, "Fragmentstore",
354                 sizeof(Fragmentstore),
355                 cfragstoreFileSize);
356 
357   deallocRecord((void **)&pageRecord, "PageRecord",
358                 sizeof(PageRecord),
359                 cpageFileSize);
360 
361   deallocRecord((void **)&replicaRecord, "ReplicaRecord",
362                 sizeof(ReplicaRecord),
363                 creplicaFileSize);
364 
365   deallocRecord((void **)&tabRecord, "TabRecord",
366                 sizeof(TabRecord),
367                 ctabFileSize);
368 
369   // Records with constant sizes
370   deallocRecord((void **)&createReplicaRecord,
371                 "CreateReplicaRecord", sizeof(CreateReplicaRecord),
372                 ZCREATE_REPLICA_FILE_SIZE);
373 
374   deallocRecord((void **)&nodeGroupRecord, "NodeGroupRecord",
375                 sizeof(NodeGroupRecord), MAX_NDB_NODES);
376 
377   deallocRecord((void **)&nodeRecord, "NodeRecord",
378                 sizeof(NodeRecord), MAX_NDB_NODES);
379 }//Dbdih::~Dbdih()
380 
381 BLOCK_FUNCTIONS(Dbdih)
382 
383 
384 
385