← 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/ndbcntr/Ndbcntr.hpp

  • 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/ndbcntr/Ndbcntr.hpp
 
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
#ifndef NDBCNTR_H
 
17
#define NDBCNTR_H
 
18
 
 
19
 
 
20
#include <pc.hpp>
 
21
#include <SimulatedBlock.hpp>
 
22
#include <ndb_limits.h>
 
23
#include <signaldata/StopReq.hpp>
 
24
#include <signaldata/ResumeReq.hpp>
 
25
#include <signaldata/DictTabInfo.hpp>
 
26
#include <signaldata/CntrStart.hpp>
 
27
#include <signaldata/CheckNodeGroups.hpp>
 
28
 
 
29
#include <signaldata/UpgradeStartup.hpp>
 
30
 
 
31
#include <NodeState.hpp>
 
32
#include <NdbTick.h>
 
33
 
 
34
#ifdef NDBCNTR_C
 
35
/*
 
36
2.1 GLOBAL SYMBOLS
 
37
------------------
 
38
*/
 
39
/*
 
40
2.2 LOCAL SYMBOLS
 
41
----------------- 
 
42
*/
 
43
#define ZNO_NDB_BLOCKS 6           /* ACC, DICT, DIH, LQH, TC, TUP         */
 
44
 
 
45
#define ZNOT_AVAILABLE 913
 
46
 
 
47
//------- OTHERS ---------------------------------------------
 
48
#define ZSTARTUP  1
 
49
#define ZSHUTDOWN 2
 
50
 
 
51
#define ZSIZE_NDB_BLOCKS_REC 16 /* MAX BLOCKS IN NDB                    */
 
52
#define ZSIZE_SYSTAB 2048
 
53
#define ZSTART_PHASE_1 1
 
54
#define ZSTART_PHASE_2 2
 
55
#define ZSTART_PHASE_3 3
 
56
#define ZSTART_PHASE_4 4
 
57
#define ZSTART_PHASE_5 5
 
58
#define ZSTART_PHASE_6 6
 
59
#define ZSTART_PHASE_7 7
 
60
#define ZSTART_PHASE_8 8
 
61
#define ZSTART_PHASE_9 9
 
62
#define ZSTART_PHASE_END 255
 
63
#define ZWAITPOINT_4_1 1
 
64
#define ZWAITPOINT_4_2 2
 
65
#define ZWAITPOINT_5_1 3
 
66
#define ZWAITPOINT_5_2 4
 
67
#define ZWAITPOINT_6_1 5
 
68
#define ZWAITPOINT_6_2 6
 
69
#define ZWAITPOINT_7_1 7
 
70
#define ZWAITPOINT_7_2 8
 
71
#define ZSYSTAB_VERSION 1
 
72
#endif
 
73
 
 
74
class Ndbcntr: public SimulatedBlock {
 
75
public:
 
76
// Records
 
77
 
 
78
/* FSREADREQ FSWRITEREQ         */
 
79
/**
 
80
 * 2.3 RECORDS AND FILESIZES
 
81
 * ------------------------------------------------------------
 
82
 */
 
83
 
 
84
  struct StartRecord {
 
85
    StartRecord() {}
 
86
    Uint64 m_startTime;
 
87
    
 
88
    void reset();
 
89
    NdbNodeBitmask m_starting;
 
90
    NdbNodeBitmask m_waiting; // == (m_withLog | m_withoutLog)
 
91
    NdbNodeBitmask m_withLog;
 
92
    NdbNodeBitmask m_withoutLog;
 
93
    Uint32 m_lastGci;
 
94
    Uint32 m_lastGciNodeId;
 
95
 
 
96
    Uint64 m_startPartialTimeout;
 
97
    Uint64 m_startPartitionedTimeout;
 
98
    Uint64 m_startFailureTimeout;
 
99
    struct {
 
100
      Uint32 m_nodeId;
 
101
      Uint32 m_lastGci;
 
102
    } m_logNodes[MAX_NDB_NODES];
 
103
    Uint32 m_logNodesCount;
 
104
  } c_start;
 
105
  
 
106
  struct NdbBlocksRec {
 
107
    BlockReference blockref;
 
108
  }; /* p2c: size = 2 bytes */
 
109
  
 
110
  typedef Ptr<NdbBlocksRec> NdbBlocksRecPtr;
 
111
 
 
112
  /**
 
113
   * Ndbcntr creates and initializes system tables on initial system start.
 
114
   * The tables are defined in static structs in NdbcntrSysTable.cpp.
 
115
   */
 
116
  struct SysColumn {
 
117
    unsigned pos;
 
118
    const char* name;
 
119
    // DictTabInfo
 
120
    DictTabInfo::ExtType type;
 
121
    Uint32 length;
 
122
    bool keyFlag;
 
123
    bool nullable;
 
124
  };
 
125
  struct SysTable {
 
126
    const char* name;
 
127
    unsigned columnCount;
 
128
    const SysColumn* columnList;
 
129
    // DictTabInfo
 
130
    DictTabInfo::TableType tableType;
 
131
    DictTabInfo::FragmentType fragmentType;
 
132
    bool tableLoggedFlag;
 
133
    // saved table id
 
134
    mutable Uint32 tableId;
 
135
  };
 
136
  struct SysIndex {
 
137
    const char* name;
 
138
    const SysTable* primaryTable;
 
139
    Uint32 columnCount;
 
140
    Uint32 columnList[4];
 
141
    // DictTabInfo
 
142
    DictTabInfo::TableType indexType;
 
143
    DictTabInfo::FragmentType fragmentType;
 
144
    bool indexLoggedFlag;
 
145
    // saved index table id
 
146
    mutable Uint32 indexId;
 
147
  };
 
148
  static const SysTable* g_sysTableList[];
 
149
  static const unsigned g_sysTableCount;
 
150
  // the system tables
 
151
  static const SysTable g_sysTable_SYSTAB_0;
 
152
  static const SysTable g_sysTable_NDBEVENTS_0;
 
153
 
 
154
public:
 
155
  Ndbcntr(Block_context&);
 
156
  virtual ~Ndbcntr();
 
157
 
 
158
private:
 
159
  BLOCK_DEFINES(Ndbcntr);
 
160
 
 
161
  // Transit signals
 
162
  void execAPI_START_REP(Signal*);
 
163
  void execCONTINUEB(Signal* signal);
 
164
  void execREAD_NODESCONF(Signal* signal);
 
165
  void execREAD_NODESREF(Signal* signal);
 
166
  void execCM_ADD_REP(Signal* signal);
 
167
  void execCNTR_START_REQ(Signal* signal);
 
168
  void execCNTR_START_REF(Signal* signal);
 
169
  void execCNTR_START_CONF(Signal* signal);
 
170
  void execCNTR_START_REP(Signal* signal);
 
171
  void execCNTR_WAITREP(Signal* signal);
 
172
  void execNODE_FAILREP(Signal* signal);
 
173
  void execSYSTEM_ERROR(Signal* signal);
 
174
 
 
175
  // Received signals
 
176
  void execDUMP_STATE_ORD(Signal* signal);
 
177
  void execREAD_CONFIG_REQ(Signal* signal);
 
178
  void execSTTOR(Signal* signal);
 
179
  void execTCSEIZECONF(Signal* signal);
 
180
  void execTCSEIZEREF(Signal* signal);
 
181
  void execTCRELEASECONF(Signal* signal);
 
182
  void execTCRELEASEREF(Signal* signal);
 
183
  void execTCKEYCONF(Signal* signal);
 
184
  void execTCKEYREF(Signal* signal);
 
185
  void execTCROLLBACKREP(Signal* signal);
 
186
  void execGETGCICONF(Signal* signal);
 
187
  void execDIH_RESTARTCONF(Signal* signal);
 
188
  void execDIH_RESTARTREF(Signal* signal);
 
189
  void execCREATE_TABLE_REF(Signal* signal);
 
190
  void execCREATE_TABLE_CONF(Signal* signal);
 
191
  void execNDB_STTORRY(Signal* signal);
 
192
  void execNDB_STARTCONF(Signal* signal);
 
193
  void execREAD_NODESREQ(Signal* signal);
 
194
  void execNDB_STARTREF(Signal* signal);
 
195
 
 
196
  void execSTOP_PERM_REF(Signal* signal);
 
197
  void execSTOP_PERM_CONF(Signal* signal);
 
198
 
 
199
  void execSTOP_ME_REF(Signal* signal);
 
200
  void execSTOP_ME_CONF(Signal* signal);
 
201
  
 
202
  void execWAIT_GCP_REF(Signal* signal);
 
203
  void execWAIT_GCP_CONF(Signal* signal);
 
204
 
 
205
  void execSTOP_REQ(Signal* signal);
 
206
  void execSTOP_CONF(Signal* signal);
 
207
  void execRESUME_REQ(Signal* signal);
 
208
 
 
209
  void execCHANGE_NODE_STATE_CONF(Signal* signal);
 
210
 
 
211
  void execABORT_ALL_REF(Signal* signal);
 
212
  void execABORT_ALL_CONF(Signal* signal);
 
213
 
 
214
  // Statement blocks
 
215
  void sendCreateTabReq(Signal* signal, const char* buffer, Uint32 bufLen);
 
216
  void startInsertTransactions(Signal* signal);
 
217
  void initData(Signal* signal);
 
218
  void resetStartVariables(Signal* signal);
 
219
  void sendCntrStartReq(Signal* signal);
 
220
  void sendCntrStartRef(Signal*, Uint32 nodeId, CntrStartRef::ErrorCode);
 
221
  void sendNdbSttor(Signal* signal);
 
222
  void sendSttorry(Signal* signal);
 
223
 
 
224
  bool trySystemRestart(Signal* signal);
 
225
  void startWaitingNodes(Signal* signal);
 
226
  CheckNodeGroups::Output checkNodeGroups(Signal*, const NdbNodeBitmask &);
 
227
  
 
228
  // Generated statement blocks
 
229
  void systemErrorLab(Signal* signal, int line);
 
230
 
 
231
  void createSystableLab(Signal* signal, unsigned index);
 
232
  void crSystab7Lab(Signal* signal);
 
233
  void crSystab8Lab(Signal* signal);
 
234
  void crSystab9Lab(Signal* signal);
 
235
 
 
236
  void startPhase1Lab(Signal* signal);
 
237
  void startPhase2Lab(Signal* signal);
 
238
  void startPhase3Lab(Signal* signal);
 
239
  void startPhase4Lab(Signal* signal);
 
240
  void startPhase5Lab(Signal* signal);
 
241
  // jump 2 to resync phase counters
 
242
  void startPhase8Lab(Signal* signal);
 
243
  void startPhase9Lab(Signal* signal);
 
244
  void ph2ALab(Signal* signal);
 
245
  void ph2CLab(Signal* signal);
 
246
  void ph2ELab(Signal* signal);
 
247
  void ph2FLab(Signal* signal);
 
248
  void ph2GLab(Signal* signal);
 
249
  void ph3ALab(Signal* signal);
 
250
  void ph4ALab(Signal* signal);
 
251
  void ph4BLab(Signal* signal);
 
252
  void ph4CLab(Signal* signal);
 
253
  void ph5ALab(Signal* signal);
 
254
  void ph6ALab(Signal* signal);
 
255
  void ph6BLab(Signal* signal);
 
256
  void ph7ALab(Signal* signal);
 
257
  void ph8ALab(Signal* signal);
 
258
 
 
259
 
 
260
  void waitpoint41Lab(Signal* signal);
 
261
  void waitpoint51Lab(Signal* signal);
 
262
  void waitpoint52Lab(Signal* signal);
 
263
  void waitpoint61Lab(Signal* signal);
 
264
  void waitpoint71Lab(Signal* signal);
 
265
 
 
266
  void updateNodeState(Signal* signal, const NodeState & newState) const ;
 
267
  void getNodeGroup(Signal* signal);
 
268
 
 
269
  // Initialisation
 
270
  void initData();
 
271
  void initRecords();
 
272
 
 
273
  // Variables
 
274
  /**------------------------------------------------------------------------
 
275
   * CONTAIN INFO ABOUT ALL NODES IN CLUSTER. NODE_PTR ARE USED AS NODE NUMBER
 
276
   * IF THE STATE ARE ZDELETE THEN THE NODE DOESN'T EXIST. NODES ARE ALLOWED 
 
277
   * TO REGISTER (ZADD) DURING RESTART.
 
278
   *
 
279
   * WHEN THE SYSTEM IS RUNNING THE MASTER WILL CHECK IF ANY NODE HAS MADE 
 
280
   * A CNTR_MASTERREQ AND TAKE CARE OF THE REQUEST. 
 
281
   * TO CONFIRM THE REQ, THE MASTER DEMANDS THAT ALL RUNNING NODES HAS VOTED 
 
282
   * FOR THE NEW NODE. 
 
283
   * NODE_PTR:MASTER_REQ IS USED DURING RESTART TO LOG 
 
284
   * POSTPONED CNTR_MASTERREQ'S 
 
285
   *------------------------------------------------------------------------*/
 
286
  NdbBlocksRec *ndbBlocksRec;
 
287
 
 
288
  /*
 
289
    2.4 COMMON STORED VARIABLES
 
290
  */
 
291
  UintR cgciSystab;
 
292
  UintR ckey;
 
293
  //UintR csystabId;
 
294
  UintR cnoWaitrep6;
 
295
  UintR cnoWaitrep7;
 
296
  UintR ctcConnectionP;
 
297
  UintR ctcReqInfo;
 
298
  Uint8 ctransidPhase;
 
299
  Uint16 cresponses;
 
300
 
 
301
  Uint8 cstartPhase;
 
302
  Uint16 cinternalStartphase;
 
303
 
 
304
  Uint16 cmasterNodeId;
 
305
  Uint16 cndbBlocksCount;
 
306
  Uint16 cnoStartNodes;
 
307
  UintR cnoWaitrep;
 
308
  NodeState::StartType ctypeOfStart;
 
309
  Uint16 cdynamicNodeId;
 
310
 
 
311
  Uint32 c_fsRemoveCount;
 
312
  Uint32 c_nodeGroup;
 
313
  void clearFilesystem(Signal* signal);
 
314
  void execFSREMOVECONF(Signal* signal);
 
315
 
 
316
  NdbNodeBitmask c_allDefinedNodes;
 
317
  NdbNodeBitmask c_clusterNodes; // All members of qmgr cluster
 
318
  NdbNodeBitmask c_startedNodes; // All cntr started nodes
 
319
  
 
320
public:
 
321
  struct StopRecord {
 
322
  public:
 
323
    StopRecord(Ndbcntr & _cntr) : cntr(_cntr) {
 
324
      stopReq.senderRef = 0;
 
325
    }
 
326
 
 
327
    Ndbcntr & cntr;
 
328
    StopReq stopReq;          // Signal data
 
329
    NDB_TICKS stopInitiatedTime; // When was the stop initiated
 
330
    
 
331
    bool checkNodeFail(Signal* signal);
 
332
    void checkTimeout(Signal* signal);
 
333
    void checkApiTimeout(Signal* signal);
 
334
    void checkTcTimeout(Signal* signal);
 
335
    void checkLqhTimeout_1(Signal* signal);
 
336
    void checkLqhTimeout_2(Signal* signal);
 
337
    
 
338
    BlockNumber number() const { return cntr.number(); }
 
339
    void progError(int line, int cause, const char * extra) { 
 
340
      cntr.progError(line, cause, extra); 
 
341
    }
 
342
 
 
343
    enum StopNodesStep {
 
344
      SR_BLOCK_GCP_START_GCP = 0,
 
345
      SR_WAIT_COMPLETE_GCP = 1,
 
346
      SR_UNBLOCK_GCP_START_GCP = 2,
 
347
      SR_QMGR_STOP_REQ = 3,
 
348
      SR_WAIT_NODE_FAILURES = 4,
 
349
      SR_CLUSTER_SHUTDOWN = 12
 
350
    } m_state;
 
351
    SignalCounter m_stop_req_counter;
 
352
  };
 
353
private:
 
354
  StopRecord c_stopRec;
 
355
  friend struct StopRecord;
 
356
 
 
357
  struct Missra {
 
358
    Missra(Ndbcntr & ref) : cntr(ref) { }
 
359
 
 
360
    Uint32 currentBlockIndex;
 
361
    Uint32 currentStartPhase;
 
362
    Uint32 nextStartPhase[NO_OF_BLOCKS];
 
363
 
 
364
    void execSTART_ORD(Signal* signal);
 
365
    void execSTTORRY(Signal* signal);
 
366
    void sendNextSTTOR(Signal* signal);
 
367
    void execREAD_CONFIG_CONF(Signal* signal);
 
368
    void sendNextREAD_CONFIG_REQ(Signal* signal);
 
369
    
 
370
    BlockNumber number() const { return cntr.number(); }
 
371
    void progError(int line, int cause, const char * extra) { 
 
372
      cntr.progError(line, cause, extra); 
 
373
    }
 
374
    Ndbcntr & cntr;
 
375
  };
 
376
 
 
377
  Missra c_missra;
 
378
  friend struct Missra;
 
379
 
 
380
  void execSTTORRY(Signal* signal);
 
381
  void execSTART_ORD(Signal* signal);
 
382
  void execREAD_CONFIG_CONF(Signal*);
 
383
 
 
384
  friend struct UpgradeStartup;
 
385
};
 
386
 
 
387
#endif