MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DbtupGen.cpp
1 /*
2  Copyright (c) 2003, 2011, 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 as published by
6  the Free Software Foundation; version 2 of the License.
7 
8  This program is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11  GNU General Public License for more details.
12 
13  You should have received a copy of the GNU General Public License
14  along with this program; if not, write to the Free Software
15  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
16 */
17 
18 
19 #define DBTUP_C
20 #define DBTUP_GEN_CPP
21 #include "Dbtup.hpp"
22 #include <RefConvert.hpp>
23 #include <ndb_limits.h>
24 #include <pc.hpp>
25 #include <AttributeDescriptor.hpp>
26 #include "AttributeOffset.hpp"
27 #include <AttributeHeader.hpp>
28 #include <Interpreter.hpp>
29 #include <signaldata/FsConf.hpp>
30 #include <signaldata/FsRef.hpp>
31 #include <signaldata/FsRemoveReq.hpp>
32 #include <signaldata/TupCommit.hpp>
33 #include <signaldata/TupKey.hpp>
34 #include <signaldata/NodeFailRep.hpp>
35 
36 #include <signaldata/DropTab.hpp>
37 #include <SLList.hpp>
38 
39 #include <EventLogger.hpp>
40 extern EventLogger * g_eventLogger;
41 
42 #define DEBUG(x) { ndbout << "TUP::" << x << endl; }
43 
44 void Dbtup::initData()
45 {
46  cnoOfFragrec = MAX_FRAG_PER_NODE;
47  cnoOfFragoprec = MAX_FRAG_PER_NODE;
48  cnoOfAlterTabOps = MAX_FRAG_PER_NODE;
49  c_maxTriggersPerTable = ZDEFAULT_MAX_NO_TRIGGERS_PER_TABLE;
50  c_noOfBuildIndexRec = 32;
51 
52  cCopyProcedure = RNIL;
53  cCopyLastSeg = RNIL;
54  cCopyOverwrite = 0;
55  cCopyOverwriteLen = 0;
56 
57  // Records with constant sizes
58  init_list_sizes();
59  cpackedListIndex = 0;
60 }//Dbtup::initData()
61 
62 Dbtup::Dbtup(Block_context& ctx, Uint32 instanceNumber)
63  : SimulatedBlock(DBTUP, ctx, instanceNumber),
64  c_lqh(0),
65  c_tsman(0),
66  c_lgman(0),
67  c_pgman(0),
68  c_extent_hash(c_extent_pool),
69  c_storedProcPool(),
70  c_buildIndexList(c_buildIndexPool),
71  c_undo_buffer(&ctx.m_mm),
72  m_pages_allocated(0),
73  m_pages_allocated_max(0),
74  f_undo_done(true)
75 {
76  BLOCK_CONSTRUCTOR(Dbtup);
77 
78  addRecSignal(GSN_DEBUG_SIG, &Dbtup::execDEBUG_SIG);
79  addRecSignal(GSN_CONTINUEB, &Dbtup::execCONTINUEB);
80  addRecSignal(GSN_LCP_FRAG_ORD, &Dbtup::execLCP_FRAG_ORD);
81  addRecSignal(GSN_NODE_FAILREP, &Dbtup::execNODE_FAILREP);
82 
83  addRecSignal(GSN_DUMP_STATE_ORD, &Dbtup::execDUMP_STATE_ORD);
84  addRecSignal(GSN_DBINFO_SCANREQ, &Dbtup::execDBINFO_SCANREQ);
85  addRecSignal(GSN_SEND_PACKED, &Dbtup::execSEND_PACKED, true);
86  addRecSignal(GSN_STTOR, &Dbtup::execSTTOR);
87  addRecSignal(GSN_MEMCHECKREQ, &Dbtup::execMEMCHECKREQ);
88  addRecSignal(GSN_TUPKEYREQ, &Dbtup::execTUPKEYREQ);
89  addRecSignal(GSN_TUPSEIZEREQ, &Dbtup::execTUPSEIZEREQ);
90  addRecSignal(GSN_TUPRELEASEREQ, &Dbtup::execTUPRELEASEREQ);
91  addRecSignal(GSN_STORED_PROCREQ, &Dbtup::execSTORED_PROCREQ);
92 
93  addRecSignal(GSN_CREATE_TAB_REQ, &Dbtup::execCREATE_TAB_REQ);
94  addRecSignal(GSN_TUPFRAGREQ, &Dbtup::execTUPFRAGREQ);
95  addRecSignal(GSN_TUP_ADD_ATTRREQ, &Dbtup::execTUP_ADD_ATTRREQ);
96  addRecSignal(GSN_ALTER_TAB_REQ, &Dbtup::execALTER_TAB_REQ);
97  addRecSignal(GSN_TUP_COMMITREQ, &Dbtup::execTUP_COMMITREQ);
98  addRecSignal(GSN_TUP_ABORTREQ, &Dbtup::execTUP_ABORTREQ);
99  addRecSignal(GSN_NDB_STTOR, &Dbtup::execNDB_STTOR);
100  addRecSignal(GSN_READ_CONFIG_REQ, &Dbtup::execREAD_CONFIG_REQ, true);
101 
102  // Trigger Signals
103  addRecSignal(GSN_CREATE_TRIG_IMPL_REQ, &Dbtup::execCREATE_TRIG_IMPL_REQ);
104  addRecSignal(GSN_DROP_TRIG_IMPL_REQ, &Dbtup::execDROP_TRIG_IMPL_REQ);
105 
106  addRecSignal(GSN_DROP_TAB_REQ, &Dbtup::execDROP_TAB_REQ);
107 
108  addRecSignal(GSN_TUP_DEALLOCREQ, &Dbtup::execTUP_DEALLOCREQ);
109  addRecSignal(GSN_TUP_WRITELOG_REQ, &Dbtup::execTUP_WRITELOG_REQ);
110 
111  // Ordered index related
112  addRecSignal(GSN_BUILD_INDX_IMPL_REQ, &Dbtup::execBUILD_INDX_IMPL_REQ);
113  addRecSignal(GSN_BUILD_INDX_IMPL_REF, &Dbtup::execBUILD_INDX_IMPL_REF);
114  addRecSignal(GSN_BUILD_INDX_IMPL_CONF, &Dbtup::execBUILD_INDX_IMPL_CONF);
115  addRecSignal(GSN_ALTER_TAB_CONF, &Dbtup::execALTER_TAB_CONF);
116  m_max_parallel_index_build = 0;
117 
118  // Tup scan
119  addRecSignal(GSN_ACC_SCANREQ, &Dbtup::execACC_SCANREQ);
120  addRecSignal(GSN_NEXT_SCANREQ, &Dbtup::execNEXT_SCANREQ);
121  addRecSignal(GSN_ACC_CHECK_SCAN, &Dbtup::execACC_CHECK_SCAN);
122  addRecSignal(GSN_ACCKEYCONF, &Dbtup::execACCKEYCONF);
123  addRecSignal(GSN_ACCKEYREF, &Dbtup::execACCKEYREF);
124  addRecSignal(GSN_ACC_ABORTCONF, &Dbtup::execACC_ABORTCONF);
125 
126  // Drop table
127  addRecSignal(GSN_FSREMOVEREF, &Dbtup::execFSREMOVEREF, true);
128  addRecSignal(GSN_FSREMOVECONF, &Dbtup::execFSREMOVECONF, true);
129 
130  addRecSignal(GSN_DROP_FRAG_REQ, &Dbtup::execDROP_FRAG_REQ);
131  addRecSignal(GSN_SUB_GCP_COMPLETE_REP, &Dbtup::execSUB_GCP_COMPLETE_REP);
132 
133  addRecSignal(GSN_FIRE_TRIG_REQ, &Dbtup::execFIRE_TRIG_REQ);
134 
135  fragoperrec = 0;
136  fragrecord = 0;
137  alterTabOperRec = 0;
138  hostBuffer = 0;
139  tablerec = 0;
140  tableDescriptor = 0;
141 
142  initData();
143  CLEAR_ERROR_INSERT_VALUE;
144 
145  RSS_OP_COUNTER_INIT(cnoOfFreeFragoprec);
146  RSS_OP_COUNTER_INIT(cnoOfFreeFragrec);
147  RSS_OP_COUNTER_INIT(cnoOfFreeTabDescrRec);
148  c_storedProcCountNonAPI = 0;
149 
150  {
151  CallbackEntry& ce = m_callbackEntry[THE_NULL_CALLBACK];
152  ce.m_function = TheNULLCallback.m_callbackFunction;
153  ce.m_flags = 0;
154  }
155  { // 1
156  CallbackEntry& ce = m_callbackEntry[UNDO_CREATETABLE_LOGSYNC_CALLBACK];
157  ce.m_function = safe_cast(&Dbtup::undo_createtable_logsync_callback);
158  ce.m_flags = 0;
159  }
160  { // 2
161  CallbackEntry& ce = m_callbackEntry[DROP_TABLE_LOGSYNC_CALLBACK];
162  ce.m_function = safe_cast(&Dbtup::drop_table_logsync_callback);
163  ce.m_flags = 0;
164  }
165  { // 3
166  CallbackEntry& ce = m_callbackEntry[UNDO_CREATETABLE_CALLBACK];
167  ce.m_function = safe_cast(&Dbtup::undo_createtable_callback);
168  ce.m_flags = 0;
169  }
170  { // 4
171  CallbackEntry& ce = m_callbackEntry[DROP_TABLE_LOG_BUFFER_CALLBACK];
172  ce.m_function = safe_cast(&Dbtup::drop_table_log_buffer_callback);
173  ce.m_flags = 0;
174  }
175  { // 5
176  CallbackEntry& ce = m_callbackEntry[DROP_FRAGMENT_FREE_EXTENT_LOG_BUFFER_CALLBACK];
177  ce.m_function = safe_cast(&Dbtup::drop_fragment_free_extent_log_buffer_callback);
178  ce.m_flags = 0;
179  }
180  { // 6
181  CallbackEntry& ce = m_callbackEntry[NR_DELETE_LOG_BUFFER_CALLBACK];
182  ce.m_function = safe_cast(&Dbtup::nr_delete_log_buffer_callback);
183  ce.m_flags = 0;
184  }
185  { // 7
186  CallbackEntry& ce = m_callbackEntry[DISK_PAGE_LOG_BUFFER_CALLBACK];
187  ce.m_function = safe_cast(&Dbtup::disk_page_log_buffer_callback);
188  ce.m_flags = 0;
189  }
190  {
191  CallbackTable& ct = m_callbackTable;
192  ct.m_count = COUNT_CALLBACKS;
193  ct.m_entry = m_callbackEntry;
194  m_callbackTableAddr = &ct;
195  }
196 }//Dbtup::Dbtup()
197 
198 Dbtup::~Dbtup()
199 {
200  /* Free Fragment Copy Procedure info */
201  freeCopyProcedure();
202 
203  // Records with dynamic sizes
204  c_page_pool.clear();
205 
206  deallocRecord((void **)&fragoperrec,"Fragoperrec",
207  sizeof(Fragoperrec),
208  cnoOfFragoprec);
209 
210  deallocRecord((void **)&fragrecord,"Fragrecord",
211  sizeof(Fragrecord),
212  cnoOfFragrec);
213 
214  deallocRecord((void **)&alterTabOperRec,"AlterTabOperRec",
215  sizeof(alterTabOperRec),
216  cnoOfAlterTabOps);
217 
218  deallocRecord((void **)&hostBuffer,"HostBuffer",
219  sizeof(HostBuffer),
220  MAX_NODES);
221 
222  deallocRecord((void **)&tablerec,"Tablerec",
223  sizeof(Tablerec),
224  cnoOfTablerec);
225 
226  deallocRecord((void **)&tableDescriptor, "TableDescriptor",
227  sizeof(TableDescriptor),
228  cnoOfTabDescrRec);
229 
230 }//Dbtup::~Dbtup()
231 
232 Dbtup::Apply_undo::Apply_undo()
233 {
234  m_type = 0;
235  m_len = 0;
236  m_ptr = 0;
237  m_lsn = (Uint64)0;
238  m_table_ptr.setNull();
239  m_fragment_ptr.setNull();
240  m_page_ptr.setNull();
241  m_extent_ptr.setNull();
242  m_key.setNull();
243 }
244 
245 BLOCK_FUNCTIONS(Dbtup)
246 
247 void Dbtup::execCONTINUEB(Signal* signal)
248 {
249  jamEntry();
250  Uint32 actionType = signal->theData[0];
251  Uint32 dataPtr = signal->theData[1];
252 
253  switch (actionType) {
254  case ZINITIALISE_RECORDS:
255  jam();
256  initialiseRecordsLab(signal, dataPtr,
257  signal->theData[2], signal->theData[3]);
258  break;
259  case ZREL_FRAG:
260  jam();
261  releaseFragment(signal, dataPtr, signal->theData[2]);
262  break;
263  case ZBUILD_INDEX:
264  jam();
265  buildIndex(signal, dataPtr);
266  break;
267  case ZTUP_SCAN:
268  jam();
269  {
270  ScanOpPtr scanPtr;
271  c_scanOpPool.getPtr(scanPtr, dataPtr);
272  scanCont(signal, scanPtr);
273  }
274  return;
275  case ZFREE_EXTENT:
276  {
277  jam();
278  TablerecPtr tabPtr;
279  tabPtr.i= dataPtr;
280  FragrecordPtr fragPtr;
281  fragPtr.i= signal->theData[2];
282  ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
283  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
284  drop_fragment_free_extent(signal, tabPtr, fragPtr, signal->theData[3]);
285  return;
286  }
287  case ZUNMAP_PAGES:
288  {
289  jam();
290  TablerecPtr tabPtr;
291  tabPtr.i= dataPtr;
292  FragrecordPtr fragPtr;
293  fragPtr.i= signal->theData[2];
294  ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
295  ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
296  drop_fragment_unmap_pages(signal, tabPtr, fragPtr, signal->theData[3]);
297  return;
298  }
299  case ZFREE_VAR_PAGES:
300  {
301  jam();
302  drop_fragment_free_var_pages(signal);
303  return;
304  }
305  case ZFREE_PAGES:
306  {
307  jam();
308  drop_fragment_free_pages(signal);
309  return;
310  }
311  case ZREBUILD_FREE_PAGE_LIST:
312  {
313  jam();
314  rebuild_page_free_list(signal);
315  return;
316  }
317  case ZDISK_RESTART_UNDO:
318  {
319  jam();
320  if (!assembleFragments(signal)) {
321  jam();
322  return;
323  }
324  Uint32 type = signal->theData[1];
325  Uint32 len = signal->theData[2];
326  Uint64 lsn_hi = signal->theData[3];
327  Uint64 lsn_lo = signal->theData[4];
328  Uint64 lsn = (lsn_hi << 32) | lsn_lo;
329  SectionHandle handle(this, signal);
330  ndbrequire(handle.m_cnt == 1);
331  SegmentedSectionPtr ssptr;
332  handle.getSection(ssptr, 0);
333  ::copy(c_proxy_undo_data, ssptr);
334  releaseSections(handle);
335  disk_restart_undo(signal, lsn, type, c_proxy_undo_data, len);
336  return;
337  }
338 
339  default:
340  ndbrequire(false);
341  break;
342  }//switch
343 }//Dbtup::execTUP_CONTINUEB()
344 
345 /* **************************************************************** */
346 /* ---------------------------------------------------------------- */
347 /* ------------------- SYSTEM RESTART MODULE ---------------------- */
348 /* ---------------------------------------------------------------- */
349 /* **************************************************************** */
350 void Dbtup::execSTTOR(Signal* signal)
351 {
352  jamEntry();
353  Uint32 startPhase = signal->theData[1];
354  Uint32 sigKey = signal->theData[6];
355  switch (startPhase) {
356  case ZSTARTPHASE1:
357  jam();
358  ndbrequire((c_lqh= (Dblqh*)globalData.getBlock(DBLQH, instance())) != 0);
359  ndbrequire((c_tsman= (Tsman*)globalData.getBlock(TSMAN)) != 0);
360  ndbrequire((c_lgman= (Lgman*)globalData.getBlock(LGMAN)) != 0);
361  ndbrequire((c_pgman= (Pgman*)globalData.getBlock(PGMAN, instance())) != 0);
362  cownref = calcInstanceBlockRef(DBTUP);
363  break;
364  default:
365  jam();
366  break;
367  }//switch
368  signal->theData[0] = sigKey;
369  signal->theData[1] = 3;
370  signal->theData[2] = 2;
371  signal->theData[3] = ZSTARTPHASE1;
372  signal->theData[4] = 255;
373  BlockReference cntrRef = !isNdbMtLqh() ? NDBCNTR_REF : DBTUP_REF;
374  sendSignal(cntrRef, GSN_STTORRY, signal, 5, JBB);
375  return;
376 }//Dbtup::execSTTOR()
377 
378 /************************************************************************************************/
379 // SIZE_ALTREP INITIALIZE DATA STRUCTURES, FILES AND DS VARIABLES, GET READY FOR EXTERNAL
380 // CONNECTIONS.
381 /************************************************************************************************/
382 void Dbtup::execREAD_CONFIG_REQ(Signal* signal)
383 {
384  const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
385  Uint32 ref = req->senderRef;
386  Uint32 senderData = req->senderData;
387  ndbrequire(req->noOfParameters == 0);
388 
389  jamEntry();
390 
391  const ndb_mgm_configuration_iterator * p =
392  m_ctx.m_config.getOwnConfigIterator();
393  ndbrequire(p != 0);
394 
395  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_FRAG, &cnoOfFragrec));
396 
397  Uint32 noOfTriggers= 0;
398  Uint32 noOfAttribs = 0;
399 
400  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_TABLE, &cnoOfTablerec));
401  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_ATTRIBUTES, &noOfAttribs));
402 
403  Uint32 noOfStoredProc;
404  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_STORED_PROC,
405  &noOfStoredProc));
406  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_TRIGGERS,
407  &noOfTriggers));
408 
409 
410  {
411  Uint32 keyDesc = noOfAttribs;
412  Uint32 maxKeyDesc = cnoOfTablerec * MAX_ATTRIBUTES_IN_INDEX;
413  if (keyDesc > maxKeyDesc)
414  {
419  jam();
420  keyDesc = maxKeyDesc;
421  }
422 
423  cnoOfTabDescrRec =
424  cnoOfTablerec * 2 * (ZTD_SIZE + ZTD_TRAILER_SIZE) +
425  noOfAttribs * (sizeOfReadFunction() + // READ
426  sizeOfReadFunction() + // UPDATE
427  (sizeof(char*) >> 2) + // Charset
428  ZAD_SIZE + // Descriptor
429  1 + // real order
430  InternalMaxDynFix) + // Worst case dynamic
431  keyDesc; // key-descr
432 
433  cnoOfTabDescrRec = (cnoOfTabDescrRec & 0xFFFFFFF0) + 16;
434  }
435 
436  initRecords();
437 
438  c_storedProcPool.setSize(noOfStoredProc);
439 
440  // Allocate fragment copy procedure
441  allocCopyProcedure();
442 
443  c_buildIndexPool.setSize(c_noOfBuildIndexRec);
444  c_triggerPool.setSize(noOfTriggers, false, true, true, CFG_DB_NO_TRIGGERS);
445 
446  c_extent_hash.setSize(1024); // 4k
447 
448  Pool_context pc;
449  pc.m_block = this;
450  c_page_request_pool.wo_pool_init(RT_DBTUP_PAGE_REQUEST, pc);
451  c_extent_pool.init(RT_DBTUP_EXTENT_INFO, pc);
452  NdbMutex_Init(&c_page_map_pool_mutex);
453  c_page_map_pool.init(&c_page_map_pool_mutex, RT_DBTUP_PAGE_MAP, pc);
454 
455  Uint32 nScanOp; // use TUX config for now
456  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUX_SCAN_OP, &nScanOp));
457  c_scanOpPool.setSize(nScanOp + 1);
458  Uint32 nScanBatch;
459  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_BATCH_SIZE, &nScanBatch));
460  c_scanLockPool.setSize(nScanOp * nScanBatch);
461 
462 
463  /* read ahead for disk scan can not be more that disk page buffer */
464  {
465  Uint64 tmp = 64*1024*1024;
466  ndb_mgm_get_int64_parameter(p, CFG_DB_DISK_PAGE_BUFFER_MEMORY, &tmp);
467  tmp = (tmp + GLOBAL_PAGE_SIZE - 1) / GLOBAL_PAGE_SIZE; // in pages
468  // never read ahead more than 32 pages
469  if (tmp > 32)
470  m_max_page_read_ahead = 32;
471  else
472  m_max_page_read_ahead = (Uint32)tmp;
473  }
474 
475 
476  ScanOpPtr lcp;
477  ndbrequire(c_scanOpPool.seize(lcp));
478  new (lcp.p) ScanOp();
479  c_lcp_scan_op= lcp.i;
480 
481  czero = 0;
482  cminusOne = czero - 1;
483  clastBitMask = 1;
484  clastBitMask = clastBitMask << 31;
485 
486  ndb_mgm_get_int_parameter(p, CFG_DB_MT_BUILD_INDEX,
487  &m_max_parallel_index_build);
488 
489  if (isNdbMtLqh() && globalData.ndbMtLqhThreads > 1)
490  {
494  Uint32 val = m_max_parallel_index_build;
495  val = (val + instance() - 1) / globalData.ndbMtLqhThreads;
496  m_max_parallel_index_build = val;
497  }
498 
499  initialiseRecordsLab(signal, 0, ref, senderData);
500 }//Dbtup::execSIZEALT_REP()
501 
502 void Dbtup::initRecords()
503 {
504  unsigned i;
505  Uint32 tmp;
506  Uint32 tmp1 = 0;
507  const ndb_mgm_configuration_iterator * p =
508  m_ctx.m_config.getOwnConfigIterator();
509  ndbrequire(p != 0);
510 
511  // Records with dynamic sizes
512  void* ptr = m_ctx.m_mm.get_memroot();
513  c_page_pool.set((Page*)ptr, (Uint32)~0);
514 
515  fragoperrec = (Fragoperrec*)allocRecord("Fragoperrec",
516  sizeof(Fragoperrec),
517  cnoOfFragoprec);
518 
519  fragrecord = (Fragrecord*)allocRecord("Fragrecord",
520  sizeof(Fragrecord),
521  cnoOfFragrec);
522 
523  alterTabOperRec = (AlterTabOperation*)allocRecord("AlterTabOperation",
524  sizeof(AlterTabOperation),
525  cnoOfAlterTabOps);
526 
527  hostBuffer = (HostBuffer*)allocRecord("HostBuffer",
528  sizeof(HostBuffer),
529  MAX_NODES);
530 
531  tableDescriptor = (TableDescriptor*)allocRecord("TableDescriptor",
532  sizeof(TableDescriptor),
533  cnoOfTabDescrRec);
534 
535  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_OP_RECS, &tmp));
536  ndb_mgm_get_int_parameter(p, CFG_DB_NO_LOCAL_OPS, &tmp1);
537  c_operation_pool.setSize(tmp, false, true, true,
538  tmp1 == 0 ? CFG_DB_NO_OPS : CFG_DB_NO_LOCAL_OPS);
539 
540  tablerec = (Tablerec*)allocRecord("Tablerec",
541  sizeof(Tablerec),
542  cnoOfTablerec);
543 
544  for (i = 0; i<cnoOfTablerec; i++) {
545  void * p = &tablerec[i];
546  new (p) Tablerec(c_triggerPool);
547  }
548 }//Dbtup::initRecords()
549 
550 void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
551  Uint32 retRef, Uint32 retData)
552 {
553  switch (switchData) {
554  case 0:
555  jam();
556  initializeHostBuffer();
557  break;
558  case 1:
559  jam();
560  initializeOperationrec();
561  break;
562  case 2:
563  jam();
564  initializePage();
565  break;
566  case 3:
567  jam();
568  break;
569  case 4:
570  jam();
571  initializeTablerec();
572  break;
573  case 5:
574  jam();
575  break;
576  case 6:
577  jam();
578  initializeFragrecord();
579  break;
580  case 7:
581  jam();
582  initializeFragoperrec();
583  break;
584  case 8:
585  jam();
586  break;
587  case 9:
588  jam();
589  initializeTabDescr();
590  break;
591  case 10:
592  jam();
593  initializeAlterTabOperation();
594  break;
595  case 11:
596  jam();
597  break;
598  case 12:
599  jam();
600  break;
601  case 13:
602  jam();
603  break;
604  case 14:
605  jam();
606 
607  {
608  ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
609  conf->senderRef = reference();
610  conf->senderData = retData;
611  sendSignal(retRef, GSN_READ_CONFIG_CONF, signal,
612  ReadConfigConf::SignalLength, JBB);
613  }
614  return;
615  default:
616  ndbrequire(false);
617  break;
618  }//switch
619  signal->theData[0] = ZINITIALISE_RECORDS;
620  signal->theData[1] = switchData + 1;
621  signal->theData[2] = retRef;
622  signal->theData[3] = retData;
623  sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB);
624  return;
625 }//Dbtup::initialiseRecordsLab()
626 
627 void Dbtup::execNDB_STTOR(Signal* signal)
628 {
629  jamEntry();
630  cndbcntrRef = signal->theData[0];
631  Uint32 ownNodeId = signal->theData[1];
632  Uint32 startPhase = signal->theData[2];
633  switch (startPhase) {
634  case ZSTARTPHASE1:
635  jam();
636  cownNodeId = ownNodeId;
637  cownref = calcInstanceBlockRef(DBTUP);
638  initializeDefaultValuesFrag();
639  break;
640  case ZSTARTPHASE2:
641  jam();
642  break;
643  case ZSTARTPHASE3:
644  jam();
645  startphase3Lab(signal, ~0, ~0);
646  break;
647  case ZSTARTPHASE4:
648  jam();
649  break;
650  case ZSTARTPHASE6:
651  jam();
652  break;
653  default:
654  jam();
655  break;
656  }//switch
657  signal->theData[0] = cownref;
658  BlockReference cntrRef = !isNdbMtLqh() ? NDBCNTR_REF : DBTUP_REF;
659  sendSignal(cntrRef, GSN_NDB_STTORRY, signal, 1, JBB);
660 }//Dbtup::execNDB_STTOR()
661 
662 void Dbtup::startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2)
663 {
664 }//Dbtup::startphase3Lab()
665 
666 void Dbtup::initializeDefaultValuesFrag()
667 {
668  /* Grab and initialize a fragment record for storing default
669  * values for the table fragments held by this TUP instance
670  */
671  seizeFragrecord(DefaultValuesFragment);
672  DefaultValuesFragment.p->fragStatus = Fragrecord::FS_ONLINE;
673  DefaultValuesFragment.p->m_undo_complete= false;
674  DefaultValuesFragment.p->m_lcp_scan_op = RNIL;
675  DefaultValuesFragment.p->noOfPages = 0;
676  DefaultValuesFragment.p->noOfVarPages = 0;
677  DefaultValuesFragment.p->m_max_page_no = 0;
678  DefaultValuesFragment.p->m_free_page_id_list = FREE_PAGE_RNIL;
679  ndbrequire(DefaultValuesFragment.p->m_page_map.isEmpty());
680  DefaultValuesFragment.p->m_restore_lcp_id = RNIL;
681  for (Uint32 i = 0; i<MAX_FREE_LIST+1; i++)
682  ndbrequire(DefaultValuesFragment.p->free_var_page_array[i].isEmpty());
683 
684  DefaultValuesFragment.p->m_logfile_group_id = RNIL;
685 
686  return;
687 }
688 
689 void Dbtup::initializeFragoperrec()
690 {
691  FragoperrecPtr fragoperPtr;
692  for (fragoperPtr.i = 0; fragoperPtr.i < cnoOfFragoprec; fragoperPtr.i++) {
693  ptrAss(fragoperPtr, fragoperrec);
694  fragoperPtr.p->nextFragoprec = fragoperPtr.i + 1;
695  }//for
696  fragoperPtr.i = cnoOfFragoprec - 1;
697  ptrAss(fragoperPtr, fragoperrec);
698  fragoperPtr.p->nextFragoprec = RNIL;
699  cfirstfreeFragopr = 0;
700 }//Dbtup::initializeFragoperrec()
701 
702 void Dbtup::initializeFragrecord()
703 {
704  FragrecordPtr regFragPtr;
705  for (regFragPtr.i = 0; regFragPtr.i < cnoOfFragrec; regFragPtr.i++) {
706  refresh_watch_dog();
707  ptrAss(regFragPtr, fragrecord);
708  new (regFragPtr.p) Fragrecord();
709  regFragPtr.p->nextfreefrag = regFragPtr.i + 1;
710  regFragPtr.p->fragStatus = Fragrecord::FS_FREE;
711  }//for
712  regFragPtr.i = cnoOfFragrec - 1;
713  ptrAss(regFragPtr, fragrecord);
714  regFragPtr.p->nextfreefrag = RNIL;
715  cfirstfreefrag = 0;
716 }//Dbtup::initializeFragrecord()
717 
718 void Dbtup::initializeAlterTabOperation()
719 {
720  AlterTabOperationPtr regAlterTabOpPtr;
721  for (regAlterTabOpPtr.i= 0;
722  regAlterTabOpPtr.i<cnoOfAlterTabOps;
723  regAlterTabOpPtr.i++)
724  {
725  refresh_watch_dog();
726  ptrAss(regAlterTabOpPtr, alterTabOperRec);
727  new (regAlterTabOpPtr.p) AlterTabOperation();
728  regAlterTabOpPtr.p->nextAlterTabOp= regAlterTabOpPtr.i+1;
729  }
730  regAlterTabOpPtr.i= cnoOfAlterTabOps-1;
731  ptrAss(regAlterTabOpPtr, alterTabOperRec);
732  regAlterTabOpPtr.p->nextAlterTabOp= RNIL;
733  cfirstfreeAlterTabOp= 0;
734 }
735 
736 void Dbtup::initializeHostBuffer()
737 {
738  Uint32 hostId;
739  cpackedListIndex = 0;
740  for (hostId = 0; hostId < MAX_NODES; hostId++) {
741  hostBuffer[hostId].inPackedList = false;
742  hostBuffer[hostId].noOfPacketsTA = 0;
743  hostBuffer[hostId].packetLenTA = 0;
744  }//for
745 }//Dbtup::initializeHostBuffer()
746 
747 
748 void Dbtup::initializeOperationrec()
749 {
750  refresh_watch_dog();
751 }//Dbtup::initializeOperationrec()
752 
753 void Dbtup::initializeTablerec()
754 {
755  TablerecPtr regTabPtr;
756  for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) {
757  jam();
758  refresh_watch_dog();
759  ptrAss(regTabPtr, tablerec);
760  initTab(regTabPtr.p);
761  }//for
762 }//Dbtup::initializeTablerec()
763 
764 void
765 Dbtup::initTab(Tablerec* const regTabPtr)
766 {
767  for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
768  regTabPtr->fragid[i] = RNIL;
769  regTabPtr->fragrec[i] = RNIL;
770  }//for
771  regTabPtr->readFunctionArray = NULL;
772  regTabPtr->updateFunctionArray = NULL;
773  regTabPtr->charsetArray = NULL;
774 
775  regTabPtr->tabDescriptor = RNIL;
776  regTabPtr->readKeyArray = RNIL;
777  regTabPtr->dynTabDescriptor[MM] = RNIL;
778  regTabPtr->dynTabDescriptor[DD] = RNIL;
779  regTabPtr->dynFixSizeMask[MM] = NULL;
780  regTabPtr->dynVarSizeMask[MM] = NULL;
781  regTabPtr->dynFixSizeMask[DD] = NULL;
782  regTabPtr->dynVarSizeMask[DD] = NULL;
783 
784  regTabPtr->m_bits = 0;
785 
786  regTabPtr->m_no_of_attributes = 0;
787  regTabPtr->noOfKeyAttr = 0;
788 
789  regTabPtr->m_dropTable.tabUserPtr = RNIL;
790  regTabPtr->m_dropTable.tabUserRef = 0;
791  regTabPtr->tableStatus = NOT_DEFINED;
792  regTabPtr->m_default_value_location.setNull();
793 
794  // Clear trigger data
795  if (!regTabPtr->afterInsertTriggers.isEmpty())
796  regTabPtr->afterInsertTriggers.release();
797  if (!regTabPtr->afterDeleteTriggers.isEmpty())
798  regTabPtr->afterDeleteTriggers.release();
799  if (!regTabPtr->afterUpdateTriggers.isEmpty())
800  regTabPtr->afterUpdateTriggers.release();
801  if (!regTabPtr->subscriptionInsertTriggers.isEmpty())
802  regTabPtr->subscriptionInsertTriggers.release();
803  if (!regTabPtr->subscriptionDeleteTriggers.isEmpty())
804  regTabPtr->subscriptionDeleteTriggers.release();
805  if (!regTabPtr->subscriptionUpdateTriggers.isEmpty())
806  regTabPtr->subscriptionUpdateTriggers.release();
807  if (!regTabPtr->constraintUpdateTriggers.isEmpty())
808  regTabPtr->constraintUpdateTriggers.release();
809  if (!regTabPtr->tuxCustomTriggers.isEmpty())
810  regTabPtr->tuxCustomTriggers.release();
811 }//Dbtup::initTab()
812 
813 void Dbtup::initializeTabDescr()
814 {
815  TableDescriptorPtr regTabDesPtr;
816  for (Uint32 i = 0; i < 16; i++) {
817  cfreeTdList[i] = RNIL;
818  }//for
819  for (regTabDesPtr.i = 0; regTabDesPtr.i < cnoOfTabDescrRec; regTabDesPtr.i++) {
820  refresh_watch_dog();
821  ptrAss(regTabDesPtr, tableDescriptor);
822  regTabDesPtr.p->tabDescr = RNIL;
823  }//for
824  freeTabDescr(0, cnoOfTabDescrRec);
825 }//Dbtup::initializeTabDescr()
826 
827 /* ---------------------------------------------------------------- */
828 /* ---------------------------------------------------------------- */
829 /* --------------- CONNECT/DISCONNECT MODULE ---------------------- */
830 /* ---------------------------------------------------------------- */
831 /* ---------------------------------------------------------------- */
832 void Dbtup::execTUPSEIZEREQ(Signal* signal)
833 {
834  OperationrecPtr regOperPtr;
835  jamEntry();
836  Uint32 userPtr = signal->theData[0];
837  BlockReference userRef = signal->theData[1];
838  if (!c_operation_pool.seize(regOperPtr))
839  {
840  jam();
841  signal->theData[0] = userPtr;
842  signal->theData[1] = ZGET_OPREC_ERROR;
843  sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB);
844  return;
845  }//if
846 
847  new (regOperPtr.p) Operationrec();
848  regOperPtr.p->m_any_value = 0;
849  regOperPtr.p->op_struct.op_type = ZREAD;
850  regOperPtr.p->op_struct.in_active_list = false;
851  set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
852  regOperPtr.p->prevActiveOp = RNIL;
853  regOperPtr.p->nextActiveOp = RNIL;
854  regOperPtr.p->tupVersion = ZNIL;
855  regOperPtr.p->op_struct.delete_insert_flag = false;
856 
857  initOpConnection(regOperPtr.p);
858  regOperPtr.p->userpointer = userPtr;
859  signal->theData[0] = regOperPtr.p->userpointer;
860  signal->theData[1] = regOperPtr.i;
861  sendSignal(userRef, GSN_TUPSEIZECONF, signal, 2, JBB);
862  return;
863 }//Dbtup::execTUPSEIZEREQ()
864 
865 #define printFragment(t){ for(Uint32 i = 0; i < MAX_FRAG_PER_NODE;i++){\
866  ndbout_c("table = %d fragid[%d] = %d fragrec[%d] = %d", \
867  t.i, t.p->fragid[i], i, t.p->fragrec[i]); }}
868 
869 void Dbtup::execTUPRELEASEREQ(Signal* signal)
870 {
871  OperationrecPtr regOperPtr;
872  jamEntry();
873  regOperPtr.i = signal->theData[0];
874  c_operation_pool.getPtr(regOperPtr);
875  set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
876  c_operation_pool.release(regOperPtr);
877 
878  signal->theData[0] = regOperPtr.p->userpointer;
879  sendSignal(DBLQH_REF, GSN_TUPRELEASECONF, signal, 1, JBB);
880  return;
881 }//Dbtup::execTUPRELEASEREQ()
882 
883 void Dbtup::releaseFragrec(FragrecordPtr regFragPtr)
884 {
885  regFragPtr.p->nextfreefrag = cfirstfreefrag;
886  cfirstfreefrag = regFragPtr.i;
887  RSS_OP_FREE(cnoOfFreeFragrec);
888 }//Dbtup::releaseFragrec()
889 
890 
891 void Dbtup::execNODE_FAILREP(Signal* signal)
892 {
893  jamEntry();
894  const NodeFailRep * rep = (NodeFailRep*)signal->getDataPtr();
895  NdbNodeBitmask failed;
896  failed.assign(NdbNodeBitmask::Size, rep->theNodes);
897 
898  /* Block level cleanup */
899  for(unsigned i = 1; i < MAX_NDB_NODES; i++) {
900  jam();
901  if(failed.get(i)) {
902  jam();
903  Uint32 elementsCleaned = simBlockNodeFailure(signal, i); // No callback
904  ndbassert(elementsCleaned == 0); // No distributed fragmented signals
905  (void) elementsCleaned; // Remove compiler warning
906  }//if
907  }//for
908 }
909