← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to storage/ndb/src/kernel/blocks/dbdih/DbdihInit.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

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