MySQL 5.6.14 Source Code Document
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
DbtcProxy.cpp
1 /*
2  Copyright (c) 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 #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  {
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)