← Back to branch summary

~vadim-tk/percona-server/percona-galera-5.1.57-0.8.1

« back to all changes in this revision

Viewing changes to storage/ndb/src/kernel/blocks/dbtup/DbtupGen.cpp

  • Committer: root
  • Date: 2011-07-28 00:14:23 UTC
  • Revision ID: root@r815.office.percona.com-20110728001423-6pw0v4b7r0dkbsr4
Ported to Galera 0.8.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/ndb/src/kernel/blocks/dbtup/DbtupGen.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 DBTUP_C
 
18
#define DBTUP_GEN_CPP
 
19
#include "Dbtup.hpp"
 
20
#include <RefConvert.hpp>
 
21
#include <ndb_limits.h>
 
22
#include <pc.hpp>
 
23
#include <AttributeDescriptor.hpp>
 
24
#include "AttributeOffset.hpp"
 
25
#include <AttributeHeader.hpp>
 
26
#include <Interpreter.hpp>
 
27
#include <signaldata/FsConf.hpp>
 
28
#include <signaldata/FsRef.hpp>
 
29
#include <signaldata/FsRemoveReq.hpp>
 
30
#include <signaldata/TupCommit.hpp>
 
31
#include <signaldata/TupKey.hpp>
 
32
 
 
33
#include <signaldata/DropTab.hpp>
 
34
#include <SLList.hpp>
 
35
 
 
36
#define DEBUG(x) { ndbout << "TUP::" << x << endl; }
 
37
 
 
38
void Dbtup::initData() 
 
39
{
 
40
  cnoOfAttrbufrec = ZNO_OF_ATTRBUFREC;
 
41
  cnoOfFragrec = MAX_FRAG_PER_NODE;
 
42
  cnoOfFragoprec = MAX_FRAG_PER_NODE;
 
43
  cnoOfPageRangeRec = ZNO_OF_PAGE_RANGE_REC;
 
44
  c_maxTriggersPerTable = ZDEFAULT_MAX_NO_TRIGGERS_PER_TABLE;
 
45
  c_noOfBuildIndexRec = 32;
 
46
 
 
47
  // Records with constant sizes
 
48
  init_list_sizes();
 
49
}//Dbtup::initData()
 
50
 
 
51
Dbtup::Dbtup(Block_context& ctx, Pgman* pgman)
 
52
  : SimulatedBlock(DBTUP, ctx),
 
53
    c_lqh(0),
 
54
    m_pgman(this, pgman),
 
55
    c_extent_hash(c_extent_pool),
 
56
    c_storedProcPool(),
 
57
    c_buildIndexList(c_buildIndexPool),
 
58
    c_undo_buffer(this)
 
59
{
 
60
  BLOCK_CONSTRUCTOR(Dbtup);
 
61
 
 
62
  addRecSignal(GSN_DEBUG_SIG, &Dbtup::execDEBUG_SIG);
 
63
  addRecSignal(GSN_CONTINUEB, &Dbtup::execCONTINUEB);
 
64
  addRecSignal(GSN_LCP_FRAG_ORD, &Dbtup::execLCP_FRAG_ORD);
 
65
 
 
66
  addRecSignal(GSN_DUMP_STATE_ORD, &Dbtup::execDUMP_STATE_ORD);
 
67
  addRecSignal(GSN_SEND_PACKED, &Dbtup::execSEND_PACKED);
 
68
  addRecSignal(GSN_ATTRINFO, &Dbtup::execATTRINFO);
 
69
  addRecSignal(GSN_STTOR, &Dbtup::execSTTOR);
 
70
  addRecSignal(GSN_MEMCHECKREQ, &Dbtup::execMEMCHECKREQ);
 
71
  addRecSignal(GSN_TUPKEYREQ, &Dbtup::execTUPKEYREQ);
 
72
  addRecSignal(GSN_TUPSEIZEREQ, &Dbtup::execTUPSEIZEREQ);
 
73
  addRecSignal(GSN_TUPRELEASEREQ, &Dbtup::execTUPRELEASEREQ);
 
74
  addRecSignal(GSN_STORED_PROCREQ, &Dbtup::execSTORED_PROCREQ);
 
75
  addRecSignal(GSN_TUPFRAGREQ, &Dbtup::execTUPFRAGREQ);
 
76
  addRecSignal(GSN_TUP_ADD_ATTRREQ, &Dbtup::execTUP_ADD_ATTRREQ);
 
77
  addRecSignal(GSN_TUP_COMMITREQ, &Dbtup::execTUP_COMMITREQ);
 
78
  addRecSignal(GSN_TUP_ABORTREQ, &Dbtup::execTUP_ABORTREQ);
 
79
  addRecSignal(GSN_NDB_STTOR, &Dbtup::execNDB_STTOR);
 
80
  addRecSignal(GSN_READ_CONFIG_REQ, &Dbtup::execREAD_CONFIG_REQ, true);
 
81
 
 
82
  // Trigger Signals
 
83
  addRecSignal(GSN_CREATE_TRIG_REQ, &Dbtup::execCREATE_TRIG_REQ);
 
84
  addRecSignal(GSN_DROP_TRIG_REQ,  &Dbtup::execDROP_TRIG_REQ);
 
85
 
 
86
  addRecSignal(GSN_DROP_TAB_REQ, &Dbtup::execDROP_TAB_REQ);
 
87
 
 
88
  addRecSignal(GSN_TUP_DEALLOCREQ, &Dbtup::execTUP_DEALLOCREQ);
 
89
  addRecSignal(GSN_TUP_WRITELOG_REQ, &Dbtup::execTUP_WRITELOG_REQ);
 
90
 
 
91
  // Ordered index related
 
92
  addRecSignal(GSN_BUILDINDXREQ, &Dbtup::execBUILDINDXREQ);
 
93
 
 
94
  // Tup scan
 
95
  addRecSignal(GSN_ACC_SCANREQ, &Dbtup::execACC_SCANREQ);
 
96
  addRecSignal(GSN_NEXT_SCANREQ, &Dbtup::execNEXT_SCANREQ);
 
97
  addRecSignal(GSN_ACC_CHECK_SCAN, &Dbtup::execACC_CHECK_SCAN);
 
98
  addRecSignal(GSN_ACCKEYCONF, &Dbtup::execACCKEYCONF);
 
99
  addRecSignal(GSN_ACCKEYREF, &Dbtup::execACCKEYREF);
 
100
  addRecSignal(GSN_ACC_ABORTCONF, &Dbtup::execACC_ABORTCONF);
 
101
 
 
102
  // Drop table
 
103
  addRecSignal(GSN_FSREMOVEREF, &Dbtup::execFSREMOVEREF, true);
 
104
  addRecSignal(GSN_FSREMOVECONF, &Dbtup::execFSREMOVECONF, true);
 
105
 
 
106
  attrbufrec = 0;
 
107
  fragoperrec = 0;
 
108
  fragrecord = 0;
 
109
  hostBuffer = 0;
 
110
  pageRange = 0;
 
111
  tablerec = 0;
 
112
  tableDescriptor = 0;
 
113
  totNoOfPagesAllocated = 0;
 
114
  cnoOfAllocatedPages = 0;
 
115
  
 
116
  initData();
 
117
  CLEAR_ERROR_INSERT_VALUE;
 
118
}//Dbtup::Dbtup()
 
119
 
 
120
Dbtup::~Dbtup() 
 
121
{
 
122
  // Records with dynamic sizes
 
123
  deallocRecord((void **)&attrbufrec,"Attrbufrec", 
 
124
                sizeof(Attrbufrec), 
 
125
                cnoOfAttrbufrec);
 
126
  
 
127
  deallocRecord((void **)&fragoperrec,"Fragoperrec",
 
128
                sizeof(Fragoperrec),
 
129
                cnoOfFragoprec);
 
130
  
 
131
  deallocRecord((void **)&fragrecord,"Fragrecord",
 
132
                sizeof(Fragrecord), 
 
133
                cnoOfFragrec);
 
134
  
 
135
  deallocRecord((void **)&hostBuffer,"HostBuffer",
 
136
                sizeof(HostBuffer), 
 
137
                MAX_NODES);
 
138
  
 
139
  deallocRecord((void **)&pageRange,"PageRange",
 
140
                sizeof(PageRange), 
 
141
                cnoOfPageRangeRec);
 
142
 
 
143
  deallocRecord((void **)&tablerec,"Tablerec",
 
144
                sizeof(Tablerec), 
 
145
                cnoOfTablerec);
 
146
  
 
147
  deallocRecord((void **)&tableDescriptor, "TableDescriptor",
 
148
                sizeof(TableDescriptor),
 
149
                cnoOfTabDescrRec);
 
150
  
 
151
}//Dbtup::~Dbtup()
 
152
 
 
153
BLOCK_FUNCTIONS(Dbtup)
 
154
 
 
155
void Dbtup::execCONTINUEB(Signal* signal) 
 
156
{
 
157
  jamEntry();
 
158
  Uint32 actionType = signal->theData[0];
 
159
  Uint32 dataPtr = signal->theData[1];
 
160
  switch (actionType) {
 
161
  case ZINITIALISE_RECORDS:
 
162
    jam();
 
163
    initialiseRecordsLab(signal, dataPtr, 
 
164
                         signal->theData[2], signal->theData[3]);
 
165
    break;
 
166
  case ZREL_FRAG:
 
167
    jam();
 
168
    releaseFragment(signal, dataPtr, signal->theData[2]);
 
169
    break;
 
170
  case ZREPORT_MEMORY_USAGE:{
 
171
    jam();
 
172
    static int c_currentMemUsed = 0;
 
173
    Uint32 cnt = signal->theData[1];
 
174
    Uint32 tmp = c_page_pool.getSize();
 
175
    int now = tmp ? (cnoOfAllocatedPages * 100)/tmp : 0;
 
176
    const int thresholds[] = { 100, 90, 80, 0 };
 
177
    
 
178
    Uint32 i = 0;
 
179
    const Uint32 sz = sizeof(thresholds)/sizeof(thresholds[0]);
 
180
    for(i = 0; i<sz; i++){
 
181
      if(now >= thresholds[i]){
 
182
        now = thresholds[i];
 
183
        break;
 
184
      }
 
185
    }
 
186
 
 
187
    if(now != c_currentMemUsed || 
 
188
       (c_memusage_report_frequency && cnt + 1 == c_memusage_report_frequency))
 
189
    {
 
190
      reportMemoryUsage(signal, 
 
191
                        now > c_currentMemUsed ? 1 : 
 
192
                        now < c_currentMemUsed ? -1 : 0);
 
193
      cnt = 0;
 
194
      c_currentMemUsed = now;
 
195
    } 
 
196
    else
 
197
    {
 
198
      cnt++;
 
199
    }
 
200
    signal->theData[0] = ZREPORT_MEMORY_USAGE;
 
201
    signal->theData[1] = cnt;
 
202
    sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 2);    
 
203
    return;
 
204
  }
 
205
  case ZBUILD_INDEX:
 
206
    jam();
 
207
    buildIndex(signal, dataPtr);
 
208
    break;
 
209
  case ZTUP_SCAN:
 
210
    jam();
 
211
    {
 
212
      ScanOpPtr scanPtr;
 
213
      c_scanOpPool.getPtr(scanPtr, dataPtr);
 
214
      scanCont(signal, scanPtr);
 
215
    }
 
216
    return;
 
217
  case ZFREE_EXTENT:
 
218
  {
 
219
    jam();
 
220
    
 
221
    TablerecPtr tabPtr;
 
222
    tabPtr.i= dataPtr;
 
223
    FragrecordPtr fragPtr;
 
224
    fragPtr.i= signal->theData[2];
 
225
    ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
 
226
    ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
 
227
    drop_fragment_free_extent(signal, tabPtr, fragPtr, signal->theData[3]);
 
228
    return;
 
229
  }
 
230
  case ZUNMAP_PAGES:
 
231
  {
 
232
    jam();
 
233
    
 
234
    TablerecPtr tabPtr;
 
235
    tabPtr.i= dataPtr;
 
236
    FragrecordPtr fragPtr;
 
237
    fragPtr.i= signal->theData[2];
 
238
    ptrCheckGuard(tabPtr, cnoOfTablerec, tablerec);
 
239
    ptrCheckGuard(fragPtr, cnoOfFragrec, fragrecord);
 
240
    drop_fragment_unmap_pages(signal, tabPtr, fragPtr, signal->theData[3]);
 
241
    return;
 
242
  }
 
243
  case ZFREE_VAR_PAGES:
 
244
  {
 
245
    jam();
 
246
    drop_fragment_free_var_pages(signal);
 
247
    return;
 
248
  }
 
249
  default:
 
250
    ndbrequire(false);
 
251
    break;
 
252
  }//switch
 
253
}//Dbtup::execTUP_CONTINUEB()
 
254
 
 
255
/* **************************************************************** */
 
256
/* ---------------------------------------------------------------- */
 
257
/* ------------------- SYSTEM RESTART MODULE ---------------------- */
 
258
/* ---------------------------------------------------------------- */
 
259
/* **************************************************************** */
 
260
void Dbtup::execSTTOR(Signal* signal) 
 
261
{
 
262
  jamEntry();
 
263
  Uint32 startPhase = signal->theData[1];
 
264
  Uint32 sigKey = signal->theData[6];
 
265
  switch (startPhase) {
 
266
  case ZSTARTPHASE1:
 
267
    jam();
 
268
    ndbrequire((c_lqh= (Dblqh*)globalData.getBlock(DBLQH)) != 0);
 
269
    ndbrequire((c_tsman= (Tsman*)globalData.getBlock(TSMAN)) != 0);
 
270
    ndbrequire((c_lgman= (Lgman*)globalData.getBlock(LGMAN)) != 0);
 
271
    cownref = calcTupBlockRef(0);
 
272
    break;
 
273
  default:
 
274
    jam();
 
275
    break;
 
276
  }//switch
 
277
  signal->theData[0] = sigKey;
 
278
  signal->theData[1] = 3;
 
279
  signal->theData[2] = 2;
 
280
  signal->theData[3] = ZSTARTPHASE1;
 
281
  signal->theData[4] = 255;
 
282
  sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 5, JBB);
 
283
  return;
 
284
}//Dbtup::execSTTOR()
 
285
 
 
286
/************************************************************************************************/
 
287
// SIZE_ALTREP INITIALIZE DATA STRUCTURES, FILES AND DS VARIABLES, GET READY FOR EXTERNAL 
 
288
// CONNECTIONS.
 
289
/************************************************************************************************/
 
290
void Dbtup::execREAD_CONFIG_REQ(Signal* signal) 
 
291
{
 
292
  const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
 
293
  Uint32 ref = req->senderRef;
 
294
  Uint32 senderData = req->senderData;
 
295
  ndbrequire(req->noOfParameters == 0);
 
296
  
 
297
  jamEntry();
 
298
 
 
299
  const ndb_mgm_configuration_iterator * p = 
 
300
    m_ctx.m_config.getOwnConfigIterator();
 
301
  ndbrequire(p != 0);
 
302
  
 
303
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_FRAG, &cnoOfFragrec));
 
304
  
 
305
  Uint32 noOfTriggers= 0;
 
306
  
 
307
  Uint32 tmp= 0;
 
308
 
 
309
  if (ndb_mgm_get_int_parameter(p, CFG_DB_MAX_ALLOCATE, &tmp))
 
310
    tmp = 32 * 1024 * 1024;
 
311
  m_max_allocate_pages = (tmp + GLOBAL_PAGE_SIZE - 1) / GLOBAL_PAGE_SIZE;
 
312
 
 
313
  tmp = 0;
 
314
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_PAGE_RANGE, &tmp));
 
315
  initPageRangeSize(tmp);
 
316
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_TABLE, &cnoOfTablerec));
 
317
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_TABLE_DESC, 
 
318
                                        &cnoOfTabDescrRec));
 
319
  Uint32 noOfStoredProc;
 
320
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_STORED_PROC, 
 
321
                                        &noOfStoredProc));
 
322
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_NO_TRIGGERS, 
 
323
                                        &noOfTriggers));
 
324
 
 
325
  cnoOfTabDescrRec = (cnoOfTabDescrRec & 0xFFFFFFF0) + 16;
 
326
 
 
327
  initRecords();
 
328
 
 
329
  c_storedProcPool.setSize(noOfStoredProc);
 
330
  c_buildIndexPool.setSize(c_noOfBuildIndexRec);
 
331
  c_triggerPool.setSize(noOfTriggers, false, true, true, CFG_DB_NO_TRIGGERS);
 
332
 
 
333
  c_extent_hash.setSize(1024); // 4k
 
334
  
 
335
  Pool_context pc;
 
336
  pc.m_block = this;
 
337
  c_page_request_pool.wo_pool_init(RT_DBTUP_PAGE_REQUEST, pc);
 
338
  c_extent_pool.init(RT_DBTUP_EXTENT_INFO, pc);
 
339
  
 
340
  Uint32 nScanOp;       // use TUX config for now
 
341
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUX_SCAN_OP, &nScanOp));
 
342
  c_scanOpPool.setSize(nScanOp + 1);
 
343
  Uint32 nScanBatch;
 
344
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_DB_BATCH_SIZE, &nScanBatch));
 
345
  c_scanLockPool.setSize(nScanOp * nScanBatch);
 
346
 
 
347
 
 
348
  /* read ahead for disk scan can not be more that disk page buffer */
 
349
  {
 
350
    Uint64 tmp = 64*1024*1024;
 
351
    ndb_mgm_get_int64_parameter(p, CFG_DB_DISK_PAGE_BUFFER_MEMORY, &tmp);
 
352
    m_max_page_read_ahead = (tmp  + GLOBAL_PAGE_SIZE - 1) / GLOBAL_PAGE_SIZE; // in pages
 
353
    // never read ahead more than 32 pages
 
354
    if (m_max_page_read_ahead > 32)
 
355
      m_max_page_read_ahead = 32;
 
356
  }
 
357
 
 
358
 
 
359
  ScanOpPtr lcp;
 
360
  ndbrequire(c_scanOpPool.seize(lcp));
 
361
  new (lcp.p) ScanOp();
 
362
  c_lcp_scan_op= lcp.i;
 
363
 
 
364
  czero = 0;
 
365
  cminusOne = czero - 1;
 
366
  clastBitMask = 1;
 
367
  clastBitMask = clastBitMask << 31;
 
368
 
 
369
  c_memusage_report_frequency = 0;
 
370
  ndb_mgm_get_int_parameter(p, CFG_DB_MEMREPORT_FREQUENCY, 
 
371
                            &c_memusage_report_frequency);
 
372
  
 
373
  initialiseRecordsLab(signal, 0, ref, senderData);
 
374
}//Dbtup::execSIZEALT_REP()
 
375
 
 
376
void Dbtup::initRecords() 
 
377
{
 
378
  unsigned i;
 
379
  Uint32 tmp;
 
380
  Uint32 tmp1 = 0;
 
381
  const ndb_mgm_configuration_iterator * p = 
 
382
    m_ctx.m_config.getOwnConfigIterator();
 
383
  ndbrequire(p != 0);
 
384
 
 
385
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_PAGE, &tmp));
 
386
 
 
387
  // Records with dynamic sizes
 
388
  Page* ptr =(Page*)allocRecord("Page", sizeof(Page), tmp, false, CFG_DB_DATA_MEM);
 
389
  c_page_pool.set(ptr, tmp);
 
390
  
 
391
  attrbufrec = (Attrbufrec*)allocRecord("Attrbufrec", 
 
392
                                        sizeof(Attrbufrec), 
 
393
                                        cnoOfAttrbufrec);
 
394
 
 
395
  fragoperrec = (Fragoperrec*)allocRecord("Fragoperrec",
 
396
                                          sizeof(Fragoperrec),
 
397
                                          cnoOfFragoprec);
 
398
 
 
399
  fragrecord = (Fragrecord*)allocRecord("Fragrecord",
 
400
                                        sizeof(Fragrecord), 
 
401
                                        cnoOfFragrec);
 
402
  
 
403
  hostBuffer = (HostBuffer*)allocRecord("HostBuffer",
 
404
                                        sizeof(HostBuffer), 
 
405
                                        MAX_NODES);
 
406
 
 
407
  tableDescriptor = (TableDescriptor*)allocRecord("TableDescriptor",
 
408
                                                  sizeof(TableDescriptor),
 
409
                                                  cnoOfTabDescrRec);
 
410
 
 
411
  ndbrequire(!ndb_mgm_get_int_parameter(p, CFG_TUP_OP_RECS, &tmp));
 
412
  ndb_mgm_get_int_parameter(p, CFG_DB_NO_LOCAL_OPS, &tmp1);
 
413
  c_operation_pool.setSize(tmp, false, true, true, 
 
414
      tmp1 == 0 ? CFG_DB_NO_OPS : CFG_DB_NO_LOCAL_OPS);
 
415
  
 
416
  pageRange = (PageRange*)allocRecord("PageRange",
 
417
                                      sizeof(PageRange), 
 
418
                                      cnoOfPageRangeRec);
 
419
  
 
420
  tablerec = (Tablerec*)allocRecord("Tablerec",
 
421
                                    sizeof(Tablerec), 
 
422
                                    cnoOfTablerec);
 
423
 
 
424
  for (i = 0; i<cnoOfTablerec; i++) {
 
425
    void * p = &tablerec[i];
 
426
    new (p) Tablerec(c_triggerPool);
 
427
  }
 
428
}//Dbtup::initRecords()
 
429
 
 
430
void Dbtup::initialiseRecordsLab(Signal* signal, Uint32 switchData,
 
431
                                 Uint32 retRef, Uint32 retData) 
 
432
{
 
433
  switch (switchData) {
 
434
  case 0:
 
435
    jam();
 
436
    initializeHostBuffer();
 
437
    break;
 
438
  case 1:
 
439
    jam();
 
440
    initializeOperationrec();
 
441
    break;
 
442
  case 2:
 
443
    jam();
 
444
    initializePage();
 
445
    break;
 
446
  case 3:
 
447
    jam();
 
448
    break;
 
449
  case 4:
 
450
    jam();
 
451
    initializeTablerec();
 
452
    break;
 
453
  case 5:
 
454
    jam();
 
455
    break;
 
456
  case 6:
 
457
    jam();
 
458
    initializeFragrecord();
 
459
    break;
 
460
  case 7:
 
461
    jam();
 
462
    initializeFragoperrec();
 
463
    break;
 
464
  case 8:
 
465
    jam();
 
466
    initializePageRange();
 
467
    break;
 
468
  case 9:
 
469
    jam();
 
470
    initializeTabDescr();
 
471
    break;
 
472
  case 10:
 
473
    jam();
 
474
    break;
 
475
  case 11:
 
476
    jam();
 
477
    break;
 
478
  case 12:
 
479
    jam();
 
480
    initializeAttrbufrec();
 
481
    break;
 
482
  case 13:
 
483
    jam();
 
484
    break;
 
485
  case 14:
 
486
    jam();
 
487
 
 
488
    {
 
489
      ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
 
490
      conf->senderRef = reference();
 
491
      conf->senderData = retData;
 
492
      sendSignal(retRef, GSN_READ_CONFIG_CONF, signal, 
 
493
                 ReadConfigConf::SignalLength, JBB);
 
494
    }
 
495
    return;
 
496
  default:
 
497
    ndbrequire(false);
 
498
    break;
 
499
  }//switch
 
500
  signal->theData[0] = ZINITIALISE_RECORDS;
 
501
  signal->theData[1] = switchData + 1;
 
502
  signal->theData[2] = retRef;
 
503
  signal->theData[3] = retData;
 
504
  sendSignal(reference(), GSN_CONTINUEB, signal, 4, JBB);
 
505
  return;
 
506
}//Dbtup::initialiseRecordsLab()
 
507
 
 
508
void Dbtup::execNDB_STTOR(Signal* signal) 
 
509
{
 
510
  jamEntry();
 
511
  cndbcntrRef = signal->theData[0];
 
512
  Uint32 ownNodeId = signal->theData[1];
 
513
  Uint32 startPhase = signal->theData[2];
 
514
  switch (startPhase) {
 
515
  case ZSTARTPHASE1:
 
516
    jam();
 
517
    cownNodeId = ownNodeId;
 
518
    cownref = calcTupBlockRef(ownNodeId);
 
519
    break;
 
520
  case ZSTARTPHASE2:
 
521
    jam();
 
522
    break;
 
523
  case ZSTARTPHASE3:
 
524
    jam();
 
525
    startphase3Lab(signal, ~0, ~0);
 
526
    break;
 
527
  case ZSTARTPHASE4:
 
528
    jam();
 
529
    break;
 
530
  case ZSTARTPHASE6:
 
531
    jam();
 
532
/*****************************************/
 
533
/*       NOW SET THE DISK WRITE SPEED TO */
 
534
/*       PAGES PER TICK AFTER SYSTEM     */
 
535
/*       RESTART.                        */
 
536
/*****************************************/
 
537
    signal->theData[0] = ZREPORT_MEMORY_USAGE;
 
538
    signal->theData[1] = 0;
 
539
    sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 2);
 
540
    break;
 
541
  default:
 
542
    jam();
 
543
    break;
 
544
  }//switch
 
545
  signal->theData[0] = cownref;
 
546
  sendSignal(cndbcntrRef, GSN_NDB_STTORRY, signal, 1, JBB);
 
547
}//Dbtup::execNDB_STTOR()
 
548
 
 
549
void Dbtup::startphase3Lab(Signal* signal, Uint32 config1, Uint32 config2) 
 
550
{
 
551
}//Dbtup::startphase3Lab()
 
552
 
 
553
void Dbtup::initializeAttrbufrec() 
 
554
{
 
555
  AttrbufrecPtr attrBufPtr;
 
556
  for (attrBufPtr.i = 0;
 
557
       attrBufPtr.i < cnoOfAttrbufrec; attrBufPtr.i++) {
 
558
    refresh_watch_dog();
 
559
    ptrAss(attrBufPtr, attrbufrec);
 
560
    attrBufPtr.p->attrbuf[ZBUF_NEXT] = attrBufPtr.i + 1;
 
561
  }//for
 
562
  attrBufPtr.i = cnoOfAttrbufrec - 1;
 
563
  ptrAss(attrBufPtr, attrbufrec);
 
564
  attrBufPtr.p->attrbuf[ZBUF_NEXT] = RNIL;
 
565
  cfirstfreeAttrbufrec = 0;
 
566
  cnoFreeAttrbufrec = cnoOfAttrbufrec;
 
567
}//Dbtup::initializeAttrbufrec()
 
568
 
 
569
void Dbtup::initializeFragoperrec() 
 
570
{
 
571
  FragoperrecPtr fragoperPtr;
 
572
  for (fragoperPtr.i = 0; fragoperPtr.i < cnoOfFragoprec; fragoperPtr.i++) {
 
573
    ptrAss(fragoperPtr, fragoperrec);
 
574
    fragoperPtr.p->nextFragoprec = fragoperPtr.i + 1;
 
575
  }//for
 
576
  fragoperPtr.i = cnoOfFragoprec - 1;
 
577
  ptrAss(fragoperPtr, fragoperrec);
 
578
  fragoperPtr.p->nextFragoprec = RNIL;
 
579
  cfirstfreeFragopr = 0;
 
580
}//Dbtup::initializeFragoperrec()
 
581
 
 
582
void Dbtup::initializeFragrecord() 
 
583
{
 
584
  FragrecordPtr regFragPtr;
 
585
  for (regFragPtr.i = 0; regFragPtr.i < cnoOfFragrec; regFragPtr.i++) {
 
586
    refresh_watch_dog();
 
587
    ptrAss(regFragPtr, fragrecord);
 
588
    new (regFragPtr.p) Fragrecord();
 
589
    regFragPtr.p->nextfreefrag = regFragPtr.i + 1;
 
590
    regFragPtr.p->fragStatus = IDLE;
 
591
  }//for
 
592
  regFragPtr.i = cnoOfFragrec - 1;
 
593
  ptrAss(regFragPtr, fragrecord);
 
594
  regFragPtr.p->nextfreefrag = RNIL;
 
595
  cfirstfreefrag = 0;
 
596
}//Dbtup::initializeFragrecord()
 
597
 
 
598
void Dbtup::initializeHostBuffer() 
 
599
{
 
600
  Uint32 hostId;
 
601
  cpackedListIndex = 0;
 
602
  for (hostId = 0; hostId < MAX_NODES; hostId++) {
 
603
    hostBuffer[hostId].inPackedList = false;
 
604
    hostBuffer[hostId].noOfPacketsTA = 0;
 
605
    hostBuffer[hostId].packetLenTA = 0;
 
606
  }//for
 
607
}//Dbtup::initializeHostBuffer()
 
608
 
 
609
 
 
610
void Dbtup::initializeOperationrec() 
 
611
{
 
612
  refresh_watch_dog();
 
613
}//Dbtup::initializeOperationrec()
 
614
 
 
615
void Dbtup::initializeTablerec() 
 
616
{
 
617
  TablerecPtr regTabPtr;
 
618
  for (regTabPtr.i = 0; regTabPtr.i < cnoOfTablerec; regTabPtr.i++) {
 
619
    jam();
 
620
    refresh_watch_dog();
 
621
    ptrAss(regTabPtr, tablerec);
 
622
    initTab(regTabPtr.p);
 
623
  }//for
 
624
}//Dbtup::initializeTablerec()
 
625
 
 
626
void
 
627
Dbtup::initTab(Tablerec* const regTabPtr)
 
628
{
 
629
  for (Uint32 i = 0; i < MAX_FRAG_PER_NODE; i++) {
 
630
    regTabPtr->fragid[i] = RNIL;
 
631
    regTabPtr->fragrec[i] = RNIL;
 
632
  }//for
 
633
  regTabPtr->readFunctionArray = NULL;
 
634
  regTabPtr->updateFunctionArray = NULL;
 
635
  regTabPtr->charsetArray = NULL;
 
636
 
 
637
  regTabPtr->tabDescriptor = RNIL;
 
638
  regTabPtr->readKeyArray = RNIL;
 
639
 
 
640
  regTabPtr->m_bits = 0;
 
641
 
 
642
  regTabPtr->m_no_of_attributes = 0;
 
643
  regTabPtr->noOfKeyAttr = 0;
 
644
 
 
645
  regTabPtr->m_dropTable.tabUserPtr = RNIL;
 
646
  regTabPtr->m_dropTable.tabUserRef = 0;
 
647
  regTabPtr->tableStatus = NOT_DEFINED;
 
648
 
 
649
  // Clear trigger data
 
650
  if (!regTabPtr->afterInsertTriggers.isEmpty())
 
651
    regTabPtr->afterInsertTriggers.release();
 
652
  if (!regTabPtr->afterDeleteTriggers.isEmpty())
 
653
    regTabPtr->afterDeleteTriggers.release();
 
654
  if (!regTabPtr->afterUpdateTriggers.isEmpty())
 
655
    regTabPtr->afterUpdateTriggers.release();
 
656
  if (!regTabPtr->subscriptionInsertTriggers.isEmpty())
 
657
    regTabPtr->subscriptionInsertTriggers.release();
 
658
  if (!regTabPtr->subscriptionDeleteTriggers.isEmpty())
 
659
    regTabPtr->subscriptionDeleteTriggers.release();
 
660
  if (!regTabPtr->subscriptionUpdateTriggers.isEmpty())
 
661
    regTabPtr->subscriptionUpdateTriggers.release();
 
662
  if (!regTabPtr->constraintUpdateTriggers.isEmpty())
 
663
    regTabPtr->constraintUpdateTriggers.release();
 
664
  if (!regTabPtr->tuxCustomTriggers.isEmpty())
 
665
    regTabPtr->tuxCustomTriggers.release();
 
666
}//Dbtup::initTab()
 
667
 
 
668
void Dbtup::initializeTabDescr() 
 
669
{
 
670
  TableDescriptorPtr regTabDesPtr;
 
671
  for (Uint32 i = 0; i < 16; i++) {
 
672
    cfreeTdList[i] = RNIL;
 
673
  }//for
 
674
  for (regTabDesPtr.i = 0; regTabDesPtr.i < cnoOfTabDescrRec; regTabDesPtr.i++) {
 
675
    refresh_watch_dog();
 
676
    ptrAss(regTabDesPtr, tableDescriptor);
 
677
    regTabDesPtr.p->tabDescr = RNIL;
 
678
  }//for
 
679
  freeTabDescr(0, cnoOfTabDescrRec);
 
680
}//Dbtup::initializeTabDescr()
 
681
 
 
682
/* ---------------------------------------------------------------- */
 
683
/* ---------------------------------------------------------------- */
 
684
/* --------------- CONNECT/DISCONNECT MODULE ---------------------- */
 
685
/* ---------------------------------------------------------------- */
 
686
/* ---------------------------------------------------------------- */
 
687
void Dbtup::execTUPSEIZEREQ(Signal* signal)
 
688
{
 
689
  OperationrecPtr regOperPtr;
 
690
  jamEntry();
 
691
  Uint32 userPtr = signal->theData[0];
 
692
  BlockReference userRef = signal->theData[1];
 
693
  if (!c_operation_pool.seize(regOperPtr))
 
694
  {
 
695
    jam();
 
696
    signal->theData[0] = userPtr;
 
697
    signal->theData[1] = ZGET_OPREC_ERROR;
 
698
    sendSignal(userRef, GSN_TUPSEIZEREF, signal, 2, JBB);
 
699
    return;
 
700
  }//if
 
701
 
 
702
  new (regOperPtr.p) Operationrec();
 
703
  regOperPtr.p->firstAttrinbufrec = RNIL;
 
704
  regOperPtr.p->lastAttrinbufrec = RNIL;
 
705
  regOperPtr.p->m_any_value = 0;
 
706
  regOperPtr.p->op_struct.op_type = ZREAD;
 
707
  regOperPtr.p->op_struct.in_active_list = false;
 
708
  set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
 
709
  regOperPtr.p->storedProcedureId = ZNIL;
 
710
  regOperPtr.p->prevActiveOp = RNIL;
 
711
  regOperPtr.p->nextActiveOp = RNIL;
 
712
  regOperPtr.p->tupVersion = ZNIL;
 
713
  regOperPtr.p->op_struct.delete_insert_flag = false;
 
714
  
 
715
  initOpConnection(regOperPtr.p);
 
716
  regOperPtr.p->userpointer = userPtr;
 
717
  signal->theData[0] = regOperPtr.p->userpointer;
 
718
  signal->theData[1] = regOperPtr.i;
 
719
  sendSignal(userRef, GSN_TUPSEIZECONF, signal, 2, JBB);
 
720
  return;
 
721
}//Dbtup::execTUPSEIZEREQ()
 
722
 
 
723
#define printFragment(t){ for(Uint32 i = 0; i < MAX_FRAG_PER_NODE;i++){\
 
724
  ndbout_c("table = %d fragid[%d] = %d fragrec[%d] = %d", \
 
725
           t.i, t.p->fragid[i], i, t.p->fragrec[i]); }}
 
726
 
 
727
void Dbtup::execTUPRELEASEREQ(Signal* signal) 
 
728
{
 
729
  OperationrecPtr regOperPtr;
 
730
  jamEntry();
 
731
  regOperPtr.i = signal->theData[0];
 
732
  c_operation_pool.getPtr(regOperPtr);
 
733
  set_trans_state(regOperPtr.p, TRANS_DISCONNECTED);
 
734
  c_operation_pool.release(regOperPtr);
 
735
  
 
736
  signal->theData[0] = regOperPtr.p->userpointer;
 
737
  sendSignal(DBLQH_REF, GSN_TUPRELEASECONF, signal, 1, JBB);
 
738
  return;
 
739
}//Dbtup::execTUPRELEASEREQ()
 
740
 
 
741
void Dbtup::releaseFragrec(FragrecordPtr regFragPtr) 
 
742
{
 
743
  regFragPtr.p->nextfreefrag = cfirstfreefrag;
 
744
  cfirstfreefrag = regFragPtr.i;
 
745
}//Dbtup::releaseFragrec()
 
746
 
 
747
 
 
748