← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mysql-5.6/trusty

« back to all changes in this revision

Viewing changes to storage/ndb/src/kernel/blocks/dbtc/DbtcProxy.cpp

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2014-02-12 11:54:27 UTC
  • Revision ID: package-import@ubuntu.com-20140212115427-oq6tfsqxl1wuwehi
Tags: upstream-5.6.15
Import upstream version 5.6.15

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/ndb/src/kernel/blocks/dbtc/DbtcProxy.cpp
 
1
/*
 
2
   Copyright (c) 2011, 2012, 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
#include "DbtcProxy.hpp"
 
19
#include "Dbtc.hpp"
 
20
 
 
21
DbtcProxy::DbtcProxy(Block_context& ctx) :
 
22
  LocalProxy(DBTC, ctx)
 
23
{
 
24
  // GSN_TC_SCHVERREQ
 
25
  addRecSignal(GSN_TC_SCHVERREQ, &DbtcProxy::execTC_SCHVERREQ);
 
26
  addRecSignal(GSN_TC_SCHVERCONF, &DbtcProxy::execTC_SCHVERCONF);
 
27
 
 
28
  // GSN_TAB_COMMITREQ
 
29
  addRecSignal(GSN_TAB_COMMITREQ, &DbtcProxy::execTAB_COMMITREQ);
 
30
  addRecSignal(GSN_TAB_COMMITCONF, &DbtcProxy::execTAB_COMMITCONF);
 
31
  addRecSignal(GSN_TAB_COMMITREF, &DbtcProxy::execTAB_COMMITREF);
 
32
 
 
33
  // GSN_TCSEIZEREQ
 
34
  addRecSignal(GSN_TCSEIZEREQ, &DbtcProxy::execTCSEIZEREQ);
 
35
 
 
36
  // GSN_TCGETOPSIZEREQ
 
37
  addRecSignal(GSN_TCGETOPSIZEREQ, &DbtcProxy::execTCGETOPSIZEREQ);
 
38
  addRecSignal(GSN_TCGETOPSIZECONF, &DbtcProxy::execTCGETOPSIZECONF);
 
39
 
 
40
  // GSN_TCGETOPSIZEREQ
 
41
  addRecSignal(GSN_TC_CLOPSIZEREQ, &DbtcProxy::execTC_CLOPSIZEREQ);
 
42
  addRecSignal(GSN_TC_CLOPSIZECONF, &DbtcProxy::execTC_CLOPSIZECONF);
 
43
 
 
44
  // GSN_GCP_NOMORETRANS
 
45
  addRecSignal(GSN_GCP_NOMORETRANS, &DbtcProxy::execGCP_NOMORETRANS);
 
46
  addRecSignal(GSN_GCP_TCFINISHED, &DbtcProxy::execGCP_TCFINISHED);
 
47
 
 
48
  // GSN_API_FAILREQ
 
49
  addRecSignal(GSN_API_FAILREQ, &DbtcProxy::execAPI_FAILREQ);
 
50
  addRecSignal(GSN_API_FAILCONF, &DbtcProxy::execAPI_FAILCONF);
 
51
 
 
52
  // GSN_PREP_DROP_TAB_REQ
 
53
  addRecSignal(GSN_PREP_DROP_TAB_REQ, &DbtcProxy::execPREP_DROP_TAB_REQ);
 
54
  addRecSignal(GSN_PREP_DROP_TAB_CONF, &DbtcProxy::execPREP_DROP_TAB_CONF);
 
55
  addRecSignal(GSN_PREP_DROP_TAB_REF, &DbtcProxy::execPREP_DROP_TAB_REF);
 
56
 
 
57
  // GSN_DROP_TAB_REQ
 
58
  addRecSignal(GSN_DROP_TAB_REQ, &DbtcProxy::execDROP_TAB_REQ);
 
59
  addRecSignal(GSN_DROP_TAB_CONF, &DbtcProxy::execDROP_TAB_CONF);
 
60
  addRecSignal(GSN_DROP_TAB_REF, &DbtcProxy::execDROP_TAB_REF);
 
61
 
 
62
  // GSN_ALTER_TAB_REQ
 
63
  addRecSignal(GSN_ALTER_TAB_REQ, &DbtcProxy::execALTER_TAB_REQ);
 
64
  addRecSignal(GSN_ALTER_TAB_CONF, &DbtcProxy::execALTER_TAB_CONF);
 
65
  addRecSignal(GSN_ALTER_TAB_REF, &DbtcProxy::execALTER_TAB_REF);
 
66
 
 
67
  // GSN_CREATE_INDX_IMPL_REQ
 
68
  addRecSignal(GSN_CREATE_INDX_IMPL_REQ, &DbtcProxy::execCREATE_INDX_IMPL_REQ);
 
69
  addRecSignal(GSN_CREATE_INDX_IMPL_CONF,&DbtcProxy::execCREATE_INDX_IMPL_CONF);
 
70
  addRecSignal(GSN_CREATE_INDX_IMPL_REF, &DbtcProxy::execCREATE_INDX_IMPL_REF);
 
71
 
 
72
  // GSN_ALTER_INDX_IMPL_REQ
 
73
  addRecSignal(GSN_ALTER_INDX_IMPL_REQ, &DbtcProxy::execALTER_INDX_IMPL_REQ);
 
74
  addRecSignal(GSN_ALTER_INDX_IMPL_CONF,&DbtcProxy::execALTER_INDX_IMPL_CONF);
 
75
  addRecSignal(GSN_ALTER_INDX_IMPL_REF, &DbtcProxy::execALTER_INDX_IMPL_REF);
 
76
 
 
77
  // GSN_DROP_INDX_IMPL_REQ
 
78
  addRecSignal(GSN_DROP_INDX_IMPL_REQ, &DbtcProxy::execDROP_INDX_IMPL_REQ);
 
79
  addRecSignal(GSN_DROP_INDX_IMPL_CONF,&DbtcProxy::execDROP_INDX_IMPL_CONF);
 
80
  addRecSignal(GSN_DROP_INDX_IMPL_REF, &DbtcProxy::execDROP_INDX_IMPL_REF);
 
81
 
 
82
  // GSN_TAKE_OVERTCCONF
 
83
  addRecSignal(GSN_TAKE_OVERTCCONF,&DbtcProxy::execTAKE_OVERTCCONF);
 
84
 
 
85
  m_tc_seize_req_instance = 0;
 
86
}
 
87
 
 
88
DbtcProxy::~DbtcProxy()
 
89
{
 
90
}
 
91
 
 
92
SimulatedBlock*
 
93
DbtcProxy::newWorker(Uint32 instanceNo)
 
94
{
 
95
  return new Dbtc(m_ctx, instanceNo);
 
96
}
 
97
 
 
98
// GSN_NDB_STTOR
 
99
 
 
100
void
 
101
DbtcProxy::callNDB_STTOR(Signal* signal)
 
102
{
 
103
  Ss_READ_NODES_REQ& ss = c_ss_READ_NODESREQ;
 
104
  ndbrequire(ss.m_gsn == 0);
 
105
 
 
106
  const Uint32 startPhase = signal->theData[2];
 
107
  switch (startPhase) {
 
108
  case 3:
 
109
    ss.m_gsn = GSN_NDB_STTOR;
 
110
    sendREAD_NODESREQ(signal);
 
111
    break;
 
112
  default:
 
113
    backNDB_STTOR(signal);
 
114
    break;
 
115
  }
 
116
}
 
117
 
 
118
// GSN_TC_SCHVERREQ
 
119
 
 
120
void
 
121
DbtcProxy::execTC_SCHVERREQ(Signal* signal)
 
122
{
 
123
  Ss_TC_SCHVERREQ& ss = ssSeize<Ss_TC_SCHVERREQ>(1);
 
124
 
 
125
  const TcSchVerReq* req = (const TcSchVerReq*)signal->getDataPtr();
 
126
  ss.m_req = *req;
 
127
 
 
128
  sendREQ(signal, ss);
 
129
}
 
130
 
 
131
void
 
132
DbtcProxy::sendTC_SCHVERREQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
133
{
 
134
  Ss_TC_SCHVERREQ& ss = ssFind<Ss_TC_SCHVERREQ>(ssId);
 
135
 
 
136
  TcSchVerReq* req = (TcSchVerReq*)signal->getDataPtrSend();
 
137
  *req = ss.m_req;
 
138
  req->senderRef = reference();
 
139
  req->senderData = ssId;
 
140
  sendSignal(workerRef(ss.m_worker), GSN_TC_SCHVERREQ,
 
141
             signal, TcSchVerReq::SignalLength, JBB);
 
142
}
 
143
 
 
144
void
 
145
DbtcProxy::execTC_SCHVERCONF(Signal* signal)
 
146
{
 
147
  const TcSchVerConf* conf = (const TcSchVerConf*)signal->getDataPtr();
 
148
  Uint32 ssId = conf->senderData;
 
149
  Ss_TC_SCHVERREQ& ss = ssFind<Ss_TC_SCHVERREQ>(ssId);
 
150
  recvCONF(signal, ss);
 
151
}
 
152
 
 
153
void
 
154
DbtcProxy::sendTC_SCHVERCONF(Signal* signal, Uint32 ssId)
 
155
{
 
156
  Ss_TC_SCHVERREQ& ss = ssFind<Ss_TC_SCHVERREQ>(ssId);
 
157
  BlockReference dictRef = ss.m_req.senderRef;
 
158
 
 
159
  if (!lastReply(ss))
 
160
    return;
 
161
 
 
162
  TcSchVerConf* conf = (TcSchVerConf*)signal->getDataPtrSend();
 
163
  conf->senderRef = reference();
 
164
  conf->senderData = ss.m_req.senderData;
 
165
  sendSignal(dictRef, GSN_TC_SCHVERCONF,
 
166
             signal, TcSchVerConf::SignalLength, JBB);
 
167
 
 
168
  ssRelease<Ss_TC_SCHVERREQ>(ssId);
 
169
}
 
170
 
 
171
// GSN_TAB_COMMITREQ [ sub-op ]
 
172
 
 
173
void
 
174
DbtcProxy::execTAB_COMMITREQ(Signal* signal)
 
175
{
 
176
  Ss_TAB_COMMITREQ& ss = ssSeize<Ss_TAB_COMMITREQ>(1); // lost connection
 
177
 
 
178
  const TabCommitReq* req = (const TabCommitReq*)signal->getDataPtr();
 
179
  ss.m_req = *req;
 
180
  sendREQ(signal, ss);
 
181
}
 
182
 
 
183
void
 
184
DbtcProxy::sendTAB_COMMITREQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
185
{
 
186
  Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId);
 
187
 
 
188
  TabCommitReq* req = (TabCommitReq*)signal->getDataPtrSend();
 
189
  req->senderRef = reference();
 
190
  req->senderData = ssId;
 
191
  req->tableId = ss.m_req.tableId;
 
192
  sendSignal(workerRef(ss.m_worker), GSN_TAB_COMMITREQ,
 
193
             signal, TabCommitReq::SignalLength, JBB);
 
194
}
 
195
 
 
196
void
 
197
DbtcProxy::execTAB_COMMITCONF(Signal* signal)
 
198
{
 
199
  const TabCommitConf* conf = (TabCommitConf*)signal->getDataPtr();
 
200
  Uint32 ssId = conf->senderData;
 
201
  Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId);
 
202
  recvCONF(signal, ss);
 
203
}
 
204
 
 
205
void
 
206
DbtcProxy::execTAB_COMMITREF(Signal* signal)
 
207
{
 
208
  const TabCommitRef* ref = (TabCommitRef*)signal->getDataPtr();
 
209
  Uint32 ssId = ref->senderData;
 
210
  Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId);
 
211
 
 
212
  recvREF(signal, ss, ref->errorCode);
 
213
}
 
214
 
 
215
void
 
216
DbtcProxy::sendTAB_COMMITCONF(Signal* signal, Uint32 ssId)
 
217
{
 
218
  Ss_TAB_COMMITREQ& ss = ssFind<Ss_TAB_COMMITREQ>(ssId);
 
219
  BlockReference dictRef = ss.m_req.senderRef;
 
220
 
 
221
  if (!lastReply(ss))
 
222
    return;
 
223
 
 
224
  if (ss.m_error == 0) {
 
225
    jam();
 
226
    TabCommitConf* conf = (TabCommitConf*)signal->getDataPtrSend();
 
227
    conf->senderData = ss.m_req.senderData;
 
228
    conf->nodeId = getOwnNodeId();
 
229
    conf->tableId = ss.m_req.tableId;
 
230
    sendSignal(dictRef, GSN_TAB_COMMITCONF,
 
231
               signal, TabCommitConf::SignalLength, JBB);
 
232
  } else {
 
233
    jam();
 
234
    TabCommitRef* ref = (TabCommitRef*)signal->getDataPtrSend();
 
235
    ref->senderData = ss.m_req.senderData;
 
236
    ref->nodeId = getOwnNodeId();
 
237
    ref->tableId = ss.m_req.tableId;
 
238
    sendSignal(dictRef, GSN_TAB_COMMITREF,
 
239
               signal, TabCommitRef::SignalLength, JBB);
 
240
    return;
 
241
  }
 
242
 
 
243
  ssRelease<Ss_TAB_COMMITREQ>(ssId);
 
244
}
 
245
 
 
246
// GSN_PREP_DROP_TAB_REQ
 
247
 
 
248
void
 
249
DbtcProxy::execPREP_DROP_TAB_REQ(Signal* signal)
 
250
{
 
251
  const PrepDropTabReq* req = (const PrepDropTabReq*)signal->getDataPtr();
 
252
  Uint32 ssId = getSsId(req);
 
253
  Ss_PREP_DROP_TAB_REQ& ss = ssSeize<Ss_PREP_DROP_TAB_REQ>(ssId);
 
254
  ss.m_req = *req;
 
255
  ndbrequire(signal->getLength() == PrepDropTabReq::SignalLength);
 
256
  sendREQ(signal, ss);
 
257
}
 
258
 
 
259
void
 
260
DbtcProxy::sendPREP_DROP_TAB_REQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
261
{
 
262
  Ss_PREP_DROP_TAB_REQ& ss = ssFind<Ss_PREP_DROP_TAB_REQ>(ssId);
 
263
 
 
264
  PrepDropTabReq* req = (PrepDropTabReq*)signal->getDataPtrSend();
 
265
  *req = ss.m_req;
 
266
  req->senderRef = reference();
 
267
  req->senderData = ssId; // redundant since tableId is used
 
268
  sendSignal(workerRef(ss.m_worker), GSN_PREP_DROP_TAB_REQ,
 
269
             signal, PrepDropTabReq::SignalLength, JBB);
 
270
}
 
271
 
 
272
void
 
273
DbtcProxy::execPREP_DROP_TAB_CONF(Signal* signal)
 
274
{
 
275
  const PrepDropTabConf* conf = (const PrepDropTabConf*)signal->getDataPtr();
 
276
  Uint32 ssId = getSsId(conf);
 
277
  Ss_PREP_DROP_TAB_REQ& ss = ssFind<Ss_PREP_DROP_TAB_REQ>(ssId);
 
278
  recvCONF(signal, ss);
 
279
}
 
280
 
 
281
void
 
282
DbtcProxy::execPREP_DROP_TAB_REF(Signal* signal)
 
283
{
 
284
  const PrepDropTabRef* ref = (const PrepDropTabRef*)signal->getDataPtr();
 
285
  Uint32 ssId = getSsId(ref);
 
286
  Ss_PREP_DROP_TAB_REQ& ss = ssFind<Ss_PREP_DROP_TAB_REQ>(ssId);
 
287
  recvREF(signal, ss, ref->errorCode);
 
288
}
 
289
 
 
290
void
 
291
DbtcProxy::sendPREP_DROP_TAB_CONF(Signal* signal, Uint32 ssId)
 
292
{
 
293
  Ss_PREP_DROP_TAB_REQ& ss = ssFind<Ss_PREP_DROP_TAB_REQ>(ssId);
 
294
  BlockReference dictRef = ss.m_req.senderRef;
 
295
 
 
296
  if (!lastReply(ss))
 
297
    return;
 
298
 
 
299
  if (ss.m_error == 0) {
 
300
    jam();
 
301
    PrepDropTabConf* conf = (PrepDropTabConf*)signal->getDataPtrSend();
 
302
    conf->senderRef = reference();
 
303
    conf->senderData = ss.m_req.senderData;
 
304
    conf->tableId = ss.m_req.tableId;
 
305
    sendSignal(dictRef, GSN_PREP_DROP_TAB_CONF,
 
306
               signal, PrepDropTabConf::SignalLength, JBB);
 
307
  } else {
 
308
    jam();
 
309
    PrepDropTabRef* ref = (PrepDropTabRef*)signal->getDataPtrSend();
 
310
    ref->senderRef = reference();
 
311
    ref->senderData = ss.m_req.senderData;
 
312
    ref->tableId = ss.m_req.tableId;
 
313
    ref->errorCode = ss.m_error;
 
314
    sendSignal(dictRef, GSN_PREP_DROP_TAB_REF,
 
315
               signal, PrepDropTabRef::SignalLength, JBB);
 
316
  }
 
317
 
 
318
  ssRelease<Ss_PREP_DROP_TAB_REQ>(ssId);
 
319
}
 
320
 
 
321
// GSN_DROP_TAB_REQ
 
322
 
 
323
void
 
324
DbtcProxy::execDROP_TAB_REQ(Signal* signal)
 
325
{
 
326
  const DropTabReq* req = (const DropTabReq*)signal->getDataPtr();
 
327
  Uint32 ssId = getSsId(req);
 
328
  Ss_DROP_TAB_REQ& ss = ssSeize<Ss_DROP_TAB_REQ>(ssId);
 
329
  ss.m_req = *req;
 
330
  ndbrequire(signal->getLength() == DropTabReq::SignalLength);
 
331
  sendREQ(signal, ss);
 
332
}
 
333
 
 
334
void
 
335
DbtcProxy::sendDROP_TAB_REQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
336
{
 
337
  Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
 
338
 
 
339
  DropTabReq* req = (DropTabReq*)signal->getDataPtrSend();
 
340
  *req = ss.m_req;
 
341
  req->senderRef = reference();
 
342
  req->senderData = ssId; // redundant since tableId is used
 
343
  sendSignal(workerRef(ss.m_worker), GSN_DROP_TAB_REQ,
 
344
             signal, DropTabReq::SignalLength, JBB);
 
345
}
 
346
 
 
347
void
 
348
DbtcProxy::execDROP_TAB_CONF(Signal* signal)
 
349
{
 
350
  const DropTabConf* conf = (const DropTabConf*)signal->getDataPtr();
 
351
  Uint32 ssId = getSsId(conf);
 
352
  Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
 
353
  recvCONF(signal, ss);
 
354
}
 
355
 
 
356
void
 
357
DbtcProxy::execDROP_TAB_REF(Signal* signal)
 
358
{
 
359
  const DropTabRef* ref = (const DropTabRef*)signal->getDataPtr();
 
360
  Uint32 ssId = getSsId(ref);
 
361
  Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
 
362
  recvREF(signal, ss, ref->errorCode);
 
363
}
 
364
 
 
365
void
 
366
DbtcProxy::sendDROP_TAB_CONF(Signal* signal, Uint32 ssId)
 
367
{
 
368
  Ss_DROP_TAB_REQ& ss = ssFind<Ss_DROP_TAB_REQ>(ssId);
 
369
  BlockReference dictRef = ss.m_req.senderRef;
 
370
 
 
371
  if (!lastReply(ss))
 
372
    return;
 
373
 
 
374
  if (ss.m_error == 0) {
 
375
    jam();
 
376
    DropTabConf* conf = (DropTabConf*)signal->getDataPtrSend();
 
377
    conf->senderRef = reference();
 
378
    conf->senderData = ss.m_req.senderData;
 
379
    conf->tableId = ss.m_req.tableId;
 
380
    sendSignal(dictRef, GSN_DROP_TAB_CONF,
 
381
               signal, DropTabConf::SignalLength, JBB);
 
382
  } else {
 
383
    jam();
 
384
    DropTabRef* ref = (DropTabRef*)signal->getDataPtrSend();
 
385
    ref->senderRef = reference();
 
386
    ref->senderData = ss.m_req.senderData;
 
387
    ref->tableId = ss.m_req.tableId;
 
388
    ref->errorCode = ss.m_error;
 
389
    sendSignal(dictRef, GSN_DROP_TAB_REF,
 
390
               signal, DropTabConf::SignalLength, JBB);
 
391
  }
 
392
 
 
393
  ssRelease<Ss_DROP_TAB_REQ>(ssId);
 
394
}
 
395
 
 
396
// GSN_ALTER_TAB_REQ
 
397
 
 
398
void
 
399
DbtcProxy::execALTER_TAB_REQ(Signal* signal)
 
400
{
 
401
  if (!assembleFragments(signal))
 
402
  {
 
403
    jam();
 
404
    return;
 
405
  }
 
406
 
 
407
  const AlterTabReq* req = (const AlterTabReq*)signal->getDataPtr();
 
408
  Uint32 ssId = getSsId(req);
 
409
  Ss_ALTER_TAB_REQ& ss = ssSeize<Ss_ALTER_TAB_REQ>(ssId);
 
410
  ss.m_req = *req;
 
411
 
 
412
  SectionHandle handle(this, signal);
 
413
  saveSections(ss, handle);
 
414
 
 
415
  sendREQ(signal, ss);
 
416
}
 
417
 
 
418
void
 
419
DbtcProxy::sendALTER_TAB_REQ(Signal* signal, Uint32 ssId,
 
420
                             SectionHandle* handle)
 
421
{
 
422
  Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
 
423
 
 
424
  AlterTabReq* req = (AlterTabReq*)signal->getDataPtrSend();
 
425
  *req = ss.m_req;
 
426
  req->senderRef = reference();
 
427
  req->senderData = ssId;
 
428
  sendSignalNoRelease(workerRef(ss.m_worker), GSN_ALTER_TAB_REQ,
 
429
                      signal, AlterTabReq::SignalLength, JBB, handle);
 
430
}
 
431
 
 
432
void
 
433
DbtcProxy::execALTER_TAB_CONF(Signal* signal)
 
434
{
 
435
  const AlterTabConf* conf = (const AlterTabConf*)signal->getDataPtr();
 
436
  Uint32 ssId = getSsId(conf);
 
437
  Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
 
438
  recvCONF(signal, ss);
 
439
}
 
440
 
 
441
void
 
442
DbtcProxy::execALTER_TAB_REF(Signal* signal)
 
443
{
 
444
  const AlterTabRef* ref = (const AlterTabRef*)signal->getDataPtr();
 
445
  Uint32 ssId = getSsId(ref);
 
446
  Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
 
447
  recvREF(signal, ss, ref->errorCode);
 
448
}
 
449
 
 
450
void
 
451
DbtcProxy::sendALTER_TAB_CONF(Signal* signal, Uint32 ssId)
 
452
{
 
453
  Ss_ALTER_TAB_REQ& ss = ssFind<Ss_ALTER_TAB_REQ>(ssId);
 
454
  BlockReference dictRef = ss.m_req.senderRef;
 
455
 
 
456
  if (!lastReply(ss))
 
457
    return;
 
458
 
 
459
  if (ss.m_error == 0) {
 
460
    jam();
 
461
    AlterTabConf* conf = (AlterTabConf*)signal->getDataPtrSend();
 
462
    conf->senderRef = reference();
 
463
    conf->senderData = ss.m_req.senderData;
 
464
    sendSignal(dictRef, GSN_ALTER_TAB_CONF,
 
465
               signal, AlterTabConf::SignalLength, JBB);
 
466
  } else {
 
467
    jam();
 
468
    AlterTabRef* ref = (AlterTabRef*)signal->getDataPtrSend();
 
469
    ref->senderRef = reference();
 
470
    ref->senderData = ss.m_req.senderData;
 
471
    ref->errorCode = ss.m_error;
 
472
    sendSignal(dictRef, GSN_ALTER_TAB_REF,
 
473
               signal, AlterTabConf::SignalLength, JBB);
 
474
  }
 
475
 
 
476
  ssRelease<Ss_ALTER_TAB_REQ>(ssId);
 
477
}
 
478
 
 
479
void
 
480
DbtcProxy::execTCSEIZEREQ(Signal* signal)
 
481
{
 
482
  jamEntry();
 
483
 
 
484
  if (signal->getLength() >= 3 && signal->theData[2] != 0)
 
485
  {
 
486
    /**
 
487
     * Specific instance requested...
 
488
     */
 
489
    Uint32 instance = signal->theData[2];
 
490
    if (instance >= c_workers)
 
491
    {
 
492
      jam();
 
493
      Uint32 senderData = signal->theData[0];
 
494
      Uint32 senderRef = signal->theData[1];
 
495
      signal->theData[0] = senderData;
 
496
      signal->theData[1] = 289;
 
497
      sendSignal(senderRef, GSN_TCSEIZEREF, signal, 2, JBB);
 
498
      return;
 
499
    }
 
500
 
 
501
    sendSignal(workerRef(instance), GSN_TCSEIZEREQ, signal,
 
502
               signal->getLength(), JBB);
 
503
    return;
 
504
  }
 
505
 
 
506
  signal->theData[2] = 1 + m_tc_seize_req_instance;
 
507
  sendSignal(workerRef(m_tc_seize_req_instance), GSN_TCSEIZEREQ, signal,
 
508
             signal->getLength(), JBB);
 
509
  m_tc_seize_req_instance = (m_tc_seize_req_instance + 1) % c_workers;
 
510
}
 
511
 
 
512
// GSN_TCGETOPSIZEREQ
 
513
 
 
514
void
 
515
DbtcProxy::execTCGETOPSIZEREQ(Signal* signal)
 
516
{
 
517
  Ss_TCGETOPSIZEREQ& ss = ssSeize<Ss_TCGETOPSIZEREQ>(1);
 
518
 
 
519
  ss.m_sum = 0;
 
520
  memcpy(ss.m_req, signal->getDataPtr(), 2*4);
 
521
  sendREQ(signal, ss);
 
522
}
 
523
 
 
524
void
 
525
DbtcProxy::sendTCGETOPSIZEREQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
526
{
 
527
  Ss_TCGETOPSIZEREQ& ss = ssFind<Ss_TCGETOPSIZEREQ>(ssId);
 
528
 
 
529
  signal->theData[0] = ssId;
 
530
  signal->theData[1] = reference();
 
531
  sendSignal(workerRef(ss.m_worker), GSN_TCGETOPSIZEREQ,
 
532
             signal, 2, JBB);
 
533
}
 
534
 
 
535
void
 
536
DbtcProxy::execTCGETOPSIZECONF(Signal* signal)
 
537
{
 
538
  Uint32 ssId = signal->theData[0];
 
539
  Ss_TCGETOPSIZEREQ& ss = ssFind<Ss_TCGETOPSIZEREQ>(ssId);
 
540
  ss.m_sum += signal->theData[1];
 
541
  recvCONF(signal, ss);
 
542
}
 
543
 
 
544
void
 
545
DbtcProxy::sendTCGETOPSIZECONF(Signal* signal, Uint32 ssId)
 
546
{
 
547
  Ss_TCGETOPSIZEREQ& ss = ssFind<Ss_TCGETOPSIZEREQ>(ssId);
 
548
 
 
549
  if (!lastReply(ss))
 
550
    return;
 
551
 
 
552
  signal->theData[0] = ss.m_req[0];
 
553
  signal->theData[1] = ss.m_sum;
 
554
  sendSignal(ss.m_req[1], GSN_TCGETOPSIZECONF,
 
555
             signal, 2, JBB);
 
556
 
 
557
  ssRelease<Ss_TCGETOPSIZEREQ>(ssId);
 
558
}
 
559
 
 
560
// GSN_TC_CLOPSIZEREQ
 
561
 
 
562
void
 
563
DbtcProxy::execTC_CLOPSIZEREQ(Signal* signal)
 
564
{
 
565
  Ss_TC_CLOPSIZEREQ& ss = ssSeize<Ss_TC_CLOPSIZEREQ>(1);
 
566
 
 
567
  memcpy(ss.m_req, signal->getDataPtr(), 2*4);
 
568
  sendREQ(signal, ss);
 
569
}
 
570
 
 
571
void
 
572
DbtcProxy::sendTC_CLOPSIZEREQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
573
{
 
574
  Ss_TC_CLOPSIZEREQ& ss = ssFind<Ss_TC_CLOPSIZEREQ>(ssId);
 
575
 
 
576
  signal->theData[0] = ssId;
 
577
  signal->theData[1] = reference();
 
578
  sendSignal(workerRef(ss.m_worker), GSN_TC_CLOPSIZEREQ,
 
579
             signal, 2, JBB);
 
580
}
 
581
 
 
582
void
 
583
DbtcProxy::execTC_CLOPSIZECONF(Signal* signal)
 
584
{
 
585
  Uint32 ssId = signal->theData[0];
 
586
  Ss_TC_CLOPSIZEREQ& ss = ssFind<Ss_TC_CLOPSIZEREQ>(ssId);
 
587
  recvCONF(signal, ss);
 
588
}
 
589
 
 
590
void
 
591
DbtcProxy::sendTC_CLOPSIZECONF(Signal* signal, Uint32 ssId)
 
592
{
 
593
  Ss_TC_CLOPSIZEREQ& ss = ssFind<Ss_TC_CLOPSIZEREQ>(ssId);
 
594
 
 
595
  if (!lastReply(ss))
 
596
    return;
 
597
 
 
598
  signal->theData[0] = ss.m_req[0];
 
599
  sendSignal(ss.m_req[1], GSN_TC_CLOPSIZECONF,
 
600
             signal, 1, JBB);
 
601
 
 
602
  ssRelease<Ss_TC_CLOPSIZEREQ>(ssId);
 
603
}
 
604
 
 
605
// GSN_GCP_NOMORETRANS
 
606
 
 
607
void
 
608
DbtcProxy::execGCP_NOMORETRANS(Signal* signal)
 
609
{
 
610
  Ss_GCP_NOMORETRANS& ss = ssSeize<Ss_GCP_NOMORETRANS>(1);
 
611
 
 
612
  ss.m_req = *(GCPNoMoreTrans*)signal->getDataPtr();
 
613
  sendREQ(signal, ss);
 
614
}
 
615
 
 
616
void
 
617
DbtcProxy::sendGCP_NOMORETRANS(Signal* signal, Uint32 ssId, SectionHandle*)
 
618
{
 
619
  Ss_GCP_NOMORETRANS& ss = ssFind<Ss_GCP_NOMORETRANS>(ssId);
 
620
 
 
621
  GCPNoMoreTrans * req = (GCPNoMoreTrans*)signal->getDataPtrSend();
 
622
  req->senderRef = reference();
 
623
  req->senderData = ssId;
 
624
  req->gci_hi = ss.m_req.gci_hi;
 
625
  req->gci_lo = ss.m_req.gci_lo;
 
626
  sendSignal(workerRef(ss.m_worker), GSN_GCP_NOMORETRANS,
 
627
             signal, GCPNoMoreTrans::SignalLength, JBB);
 
628
}
 
629
 
 
630
void
 
631
DbtcProxy::execGCP_TCFINISHED(Signal* signal)
 
632
{
 
633
  GCPTCFinished* conf = (GCPTCFinished*)signal->getDataPtr();
 
634
  Uint32 ssId = conf->senderData;
 
635
  Ss_GCP_NOMORETRANS& ss = ssFind<Ss_GCP_NOMORETRANS>(ssId);
 
636
  recvCONF(signal, ss);
 
637
}
 
638
 
 
639
void
 
640
DbtcProxy::sendGCP_TCFINISHED(Signal* signal, Uint32 ssId)
 
641
{
 
642
  Ss_GCP_NOMORETRANS& ss = ssFind<Ss_GCP_NOMORETRANS>(ssId);
 
643
 
 
644
  if (!lastReply(ss))
 
645
    return;
 
646
 
 
647
  GCPTCFinished* conf = (GCPTCFinished*)signal->getDataPtrSend();
 
648
  conf->senderData = ss.m_req.senderData;
 
649
  conf->gci_hi = ss.m_req.gci_hi;
 
650
  conf->gci_lo = ss.m_req.gci_lo;
 
651
  sendSignal(ss.m_req.senderRef, GSN_GCP_TCFINISHED,
 
652
             signal, GCPTCFinished::SignalLength, JBB);
 
653
 
 
654
  ssRelease<Ss_GCP_NOMORETRANS>(ssId);
 
655
}
 
656
 
 
657
 
 
658
// GSN_API_FAILREQ
 
659
 
 
660
void
 
661
DbtcProxy::execAPI_FAILREQ(Signal* signal)
 
662
{
 
663
  Uint32 nodeId = signal->theData[0];
 
664
  Ss_API_FAILREQ& ss = ssSeize<Ss_API_FAILREQ>(nodeId);
 
665
 
 
666
  ss.m_ref = signal->theData[1];
 
667
  sendREQ(signal, ss);
 
668
}
 
669
 
 
670
void
 
671
DbtcProxy::sendAPI_FAILREQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
672
{
 
673
  Ss_API_FAILREQ& ss = ssFind<Ss_API_FAILREQ>(ssId);
 
674
 
 
675
  signal->theData[0] = ssId;
 
676
  signal->theData[1] = reference();
 
677
  sendSignal(workerRef(ss.m_worker), GSN_API_FAILREQ,
 
678
             signal, 2, JBB);
 
679
}
 
680
 
 
681
void
 
682
DbtcProxy::execAPI_FAILCONF(Signal* signal)
 
683
{
 
684
  Uint32 nodeId = signal->theData[0];
 
685
  Ss_API_FAILREQ& ss = ssFind<Ss_API_FAILREQ>(nodeId);
 
686
  recvCONF(signal, ss);
 
687
}
 
688
 
 
689
void
 
690
DbtcProxy::sendAPI_FAILCONF(Signal* signal, Uint32 ssId)
 
691
{
 
692
  Ss_API_FAILREQ& ss = ssFind<Ss_API_FAILREQ>(ssId);
 
693
 
 
694
  if (!lastReply(ss))
 
695
    return;
 
696
 
 
697
  signal->theData[0] = ssId;
 
698
  signal->theData[1] = calcTcBlockRef(getOwnNodeId());
 
699
  sendSignal(ss.m_ref, GSN_API_FAILCONF,
 
700
             signal, 2, JBB);
 
701
 
 
702
  ssRelease<Ss_API_FAILREQ>(ssId);
 
703
}
 
704
 
 
705
// GSN_CREATE_INDX_IMPL_REQ
 
706
 
 
707
void
 
708
DbtcProxy::execCREATE_INDX_IMPL_REQ(Signal* signal)
 
709
{
 
710
  jamEntry();
 
711
  if (!assembleFragments(signal))
 
712
  {
 
713
    jam();
 
714
    return;
 
715
  }
 
716
 
 
717
  const CreateIndxImplReq* req = (const CreateIndxImplReq*)signal->getDataPtr();
 
718
  Ss_CREATE_INDX_IMPL_REQ& ss = ssSeize<Ss_CREATE_INDX_IMPL_REQ>();
 
719
  ss.m_req = *req;
 
720
  SectionHandle handle(this, signal);
 
721
  saveSections(ss, handle);
 
722
  sendREQ(signal, ss);
 
723
}
 
724
 
 
725
void
 
726
DbtcProxy::sendCREATE_INDX_IMPL_REQ(Signal* signal, Uint32 ssId,
 
727
                                    SectionHandle * handle)
 
728
{
 
729
  Ss_CREATE_INDX_IMPL_REQ& ss = ssFind<Ss_CREATE_INDX_IMPL_REQ>(ssId);
 
730
 
 
731
  CreateIndxImplReq* req = (CreateIndxImplReq*)signal->getDataPtrSend();
 
732
  *req = ss.m_req;
 
733
  req->senderRef = reference();
 
734
  req->senderData = ssId;
 
735
  sendSignalNoRelease(workerRef(ss.m_worker), GSN_CREATE_INDX_IMPL_REQ,
 
736
                      signal, CreateIndxImplReq::SignalLength, JBB,
 
737
                      handle);
 
738
}
 
739
 
 
740
void
 
741
DbtcProxy::execCREATE_INDX_IMPL_CONF(Signal* signal)
 
742
{
 
743
  const CreateIndxImplConf* conf = (const CreateIndxImplConf*)signal->getDataPtr();
 
744
  Uint32 ssId = conf->senderData;
 
745
  Ss_CREATE_INDX_IMPL_REQ& ss = ssFind<Ss_CREATE_INDX_IMPL_REQ>(ssId);
 
746
  recvCONF(signal, ss);
 
747
}
 
748
 
 
749
void
 
750
DbtcProxy::execCREATE_INDX_IMPL_REF(Signal* signal)
 
751
{
 
752
  const CreateIndxImplRef* ref = (const CreateIndxImplRef*)signal->getDataPtr();
 
753
  Uint32 ssId = ref->senderData;
 
754
  Ss_CREATE_INDX_IMPL_REQ& ss = ssFind<Ss_CREATE_INDX_IMPL_REQ>(ssId);
 
755
  recvREF(signal, ss, ref->errorCode);
 
756
}
 
757
 
 
758
void
 
759
DbtcProxy::sendCREATE_INDX_IMPL_CONF(Signal* signal, Uint32 ssId)
 
760
{
 
761
  Ss_CREATE_INDX_IMPL_REQ& ss = ssFind<Ss_CREATE_INDX_IMPL_REQ>(ssId);
 
762
  BlockReference dictRef = ss.m_req.senderRef;
 
763
 
 
764
  if (!lastReply(ss))
 
765
    return;
 
766
 
 
767
  if (ss.m_error == 0) {
 
768
    jam();
 
769
    CreateIndxImplConf* conf = (CreateIndxImplConf*)signal->getDataPtrSend();
 
770
    conf->senderRef = reference();
 
771
    conf->senderData = ss.m_req.senderData;
 
772
    sendSignal(dictRef, GSN_CREATE_INDX_IMPL_CONF,
 
773
               signal, CreateIndxImplConf::SignalLength, JBB);
 
774
  } else {
 
775
    CreateIndxImplRef* ref = (CreateIndxImplRef*)signal->getDataPtrSend();
 
776
    ref->senderRef = reference();
 
777
    ref->senderData = ss.m_req.senderData;
 
778
    ref->errorCode = ss.m_error;
 
779
    sendSignal(dictRef, GSN_CREATE_INDX_IMPL_REF,
 
780
               signal, CreateIndxImplRef::SignalLength, JBB);
 
781
  }
 
782
 
 
783
  ssRelease<Ss_CREATE_INDX_IMPL_REQ>(ssId);
 
784
}
 
785
 
 
786
// GSN_ALTER_INDX_IMPL_REQ
 
787
 
 
788
void
 
789
DbtcProxy::execALTER_INDX_IMPL_REQ(Signal* signal)
 
790
{
 
791
  const AlterIndxImplReq* req = (const AlterIndxImplReq*)signal->getDataPtr();
 
792
  Ss_ALTER_INDX_IMPL_REQ& ss = ssSeize<Ss_ALTER_INDX_IMPL_REQ>();
 
793
  ss.m_req = *req;
 
794
  ndbrequire(signal->getLength() == AlterIndxImplReq::SignalLength);
 
795
  sendREQ(signal, ss);
 
796
}
 
797
 
 
798
void
 
799
DbtcProxy::sendALTER_INDX_IMPL_REQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
800
{
 
801
  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
 
802
 
 
803
  AlterIndxImplReq* req = (AlterIndxImplReq*)signal->getDataPtrSend();
 
804
  *req = ss.m_req;
 
805
  req->senderRef = reference();
 
806
  req->senderData = ssId;
 
807
  sendSignal(workerRef(ss.m_worker), GSN_ALTER_INDX_IMPL_REQ,
 
808
             signal, AlterIndxImplReq::SignalLength, JBB);
 
809
}
 
810
 
 
811
void
 
812
DbtcProxy::execALTER_INDX_IMPL_CONF(Signal* signal)
 
813
{
 
814
  const AlterIndxImplConf* conf = (const AlterIndxImplConf*)signal->getDataPtr();
 
815
  Uint32 ssId = conf->senderData;
 
816
  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
 
817
  recvCONF(signal, ss);
 
818
}
 
819
 
 
820
void
 
821
DbtcProxy::execALTER_INDX_IMPL_REF(Signal* signal)
 
822
{
 
823
  const AlterIndxImplRef* ref = (const AlterIndxImplRef*)signal->getDataPtr();
 
824
  Uint32 ssId = ref->senderData;
 
825
  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
 
826
  recvREF(signal, ss, ref->errorCode);
 
827
}
 
828
 
 
829
void
 
830
DbtcProxy::sendALTER_INDX_IMPL_CONF(Signal* signal, Uint32 ssId)
 
831
{
 
832
  Ss_ALTER_INDX_IMPL_REQ& ss = ssFind<Ss_ALTER_INDX_IMPL_REQ>(ssId);
 
833
  BlockReference dictRef = ss.m_req.senderRef;
 
834
 
 
835
  if (!lastReply(ss))
 
836
    return;
 
837
 
 
838
  if (ss.m_error == 0) {
 
839
    jam();
 
840
    AlterIndxImplConf* conf = (AlterIndxImplConf*)signal->getDataPtrSend();
 
841
    conf->senderRef = reference();
 
842
    conf->senderData = ss.m_req.senderData;
 
843
    sendSignal(dictRef, GSN_ALTER_INDX_IMPL_CONF,
 
844
               signal, AlterIndxImplConf::SignalLength, JBB);
 
845
  } else {
 
846
    AlterIndxImplRef* ref = (AlterIndxImplRef*)signal->getDataPtrSend();
 
847
    ref->senderRef = reference();
 
848
    ref->senderData = ss.m_req.senderData;
 
849
    ref->errorCode = ss.m_error;
 
850
    sendSignal(dictRef, GSN_ALTER_INDX_IMPL_REF,
 
851
               signal, AlterIndxImplRef::SignalLength, JBB);
 
852
  }
 
853
 
 
854
  ssRelease<Ss_ALTER_INDX_IMPL_REQ>(ssId);
 
855
}
 
856
 
 
857
// GSN_DROP_INDX_IMPL_REQ
 
858
 
 
859
void
 
860
DbtcProxy::execDROP_INDX_IMPL_REQ(Signal* signal)
 
861
{
 
862
  const DropIndxImplReq* req = (const DropIndxImplReq*)signal->getDataPtr();
 
863
  Ss_DROP_INDX_IMPL_REQ& ss = ssSeize<Ss_DROP_INDX_IMPL_REQ>();
 
864
  ss.m_req = *req;
 
865
  ndbrequire(signal->getLength() == DropIndxImplReq::SignalLength);
 
866
  sendREQ(signal, ss);
 
867
}
 
868
 
 
869
void
 
870
DbtcProxy::sendDROP_INDX_IMPL_REQ(Signal* signal, Uint32 ssId, SectionHandle*)
 
871
{
 
872
  Ss_DROP_INDX_IMPL_REQ& ss = ssFind<Ss_DROP_INDX_IMPL_REQ>(ssId);
 
873
 
 
874
  DropIndxImplReq* req = (DropIndxImplReq*)signal->getDataPtrSend();
 
875
  *req = ss.m_req;
 
876
  req->senderRef = reference();
 
877
  req->senderData = ssId;
 
878
  sendSignal(workerRef(ss.m_worker), GSN_DROP_INDX_IMPL_REQ,
 
879
             signal, DropIndxImplReq::SignalLength, JBB);
 
880
}
 
881
 
 
882
void
 
883
DbtcProxy::execDROP_INDX_IMPL_CONF(Signal* signal)
 
884
{
 
885
  const DropIndxImplConf* conf = (const DropIndxImplConf*)signal->getDataPtr();
 
886
  Uint32 ssId = conf->senderData;
 
887
  Ss_DROP_INDX_IMPL_REQ& ss = ssFind<Ss_DROP_INDX_IMPL_REQ>(ssId);
 
888
  recvCONF(signal, ss);
 
889
}
 
890
 
 
891
void
 
892
DbtcProxy::execDROP_INDX_IMPL_REF(Signal* signal)
 
893
{
 
894
  const DropIndxImplRef* ref = (const DropIndxImplRef*)signal->getDataPtr();
 
895
  Uint32 ssId = ref->senderData;
 
896
  Ss_DROP_INDX_IMPL_REQ& ss = ssFind<Ss_DROP_INDX_IMPL_REQ>(ssId);
 
897
  recvREF(signal, ss, ref->errorCode);
 
898
}
 
899
 
 
900
void
 
901
DbtcProxy::sendDROP_INDX_IMPL_CONF(Signal* signal, Uint32 ssId)
 
902
{
 
903
  Ss_DROP_INDX_IMPL_REQ& ss = ssFind<Ss_DROP_INDX_IMPL_REQ>(ssId);
 
904
  BlockReference dictRef = ss.m_req.senderRef;
 
905
 
 
906
  if (!lastReply(ss))
 
907
    return;
 
908
 
 
909
  if (ss.m_error == 0) {
 
910
    jam();
 
911
    DropIndxImplConf* conf = (DropIndxImplConf*)signal->getDataPtrSend();
 
912
    conf->senderRef = reference();
 
913
    conf->senderData = ss.m_req.senderData;
 
914
    sendSignal(dictRef, GSN_DROP_INDX_IMPL_CONF,
 
915
               signal, DropIndxImplConf::SignalLength, JBB);
 
916
  } else {
 
917
    DropIndxImplRef* ref = (DropIndxImplRef*)signal->getDataPtrSend();
 
918
    ref->senderRef = reference();
 
919
    ref->senderData = ss.m_req.senderData;
 
920
    ref->errorCode = ss.m_error;
 
921
    sendSignal(dictRef, GSN_DROP_INDX_IMPL_REF,
 
922
               signal, DropIndxImplRef::SignalLength, JBB);
 
923
  }
 
924
 
 
925
  ssRelease<Ss_DROP_INDX_IMPL_REQ>(ssId);
 
926
}
 
927
 
 
928
void
 
929
DbtcProxy::execTAKE_OVERTCCONF(Signal* signal)
 
930
{
 
931
  jamEntry();
 
932
 
 
933
  if (!checkNodeFailSequence(signal))
 
934
  {
 
935
    jam();
 
936
    return;
 
937
  }
 
938
 
 
939
  for (Uint32 i = 0; i < c_workers; i++)
 
940
  {
 
941
    jam();
 
942
    Uint32 ref = numberToRef(number(), workerInstance(i), getOwnNodeId());
 
943
    sendSignal(ref, GSN_TAKE_OVERTCCONF, signal,
 
944
               signal->getLength(),
 
945
               JBB);
 
946
  }
 
947
}
 
948
 
 
949
BLOCK_FUNCTIONS(DbtcProxy)