1
/* Copyright (C) 2003 MySQL AB
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.
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.
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 */
17
#include "Ndbcntr.hpp"
19
#include <ndb_limits.h>
20
#include <ndb_version.h>
21
#include <SimpleProperties.hpp>
22
#include <signaldata/DictTabInfo.hpp>
23
#include <signaldata/CreateTable.hpp>
24
#include <signaldata/ReadNodesConf.hpp>
25
#include <signaldata/NodeFailRep.hpp>
26
#include <signaldata/TcKeyReq.hpp>
27
#include <signaldata/TcKeyConf.hpp>
28
#include <signaldata/EventReport.hpp>
29
#include <signaldata/NodeStateSignalData.hpp>
30
#include <signaldata/StopPerm.hpp>
31
#include <signaldata/StopMe.hpp>
32
#include <signaldata/WaitGCP.hpp>
33
#include <signaldata/CheckNodeGroups.hpp>
34
#include <signaldata/StartOrd.hpp>
35
#include <signaldata/AbortAll.hpp>
36
#include <signaldata/SystemError.hpp>
37
#include <signaldata/NdbSttor.hpp>
38
#include <signaldata/CntrStart.hpp>
39
#include <signaldata/DumpStateOrd.hpp>
41
#include <signaldata/FsRemoveReq.hpp>
42
#include <signaldata/ReadConfig.hpp>
44
#include <signaldata/FailRep.hpp>
46
#include <AttributeHeader.hpp>
47
#include <Configuration.hpp>
48
#include <DebuggerNames.hpp>
53
// used during shutdown for reporting current startphase
54
// accessed from Emulator.cpp, NdbShutdown()
55
Uint32 g_currentStartPhase;
58
* ALL_BLOCKS Used during start phases and while changing node state
60
* NDBFS_REF Has to be before NDBCNTR_REF (due to "ndb -i" stuff)
63
BlockReference Ref; // BlockReference
64
Uint32 NextSP; // Next start phase
65
Uint32 ErrorInsertStart;
66
Uint32 ErrorInsertStop;
69
static BlockInfo ALL_BLOCKS[] = {
70
{ NDBFS_REF, 0 , 2000, 2999 },
71
{ DBTC_REF, 1 , 8000, 8035 },
72
{ DBDIH_REF, 1 , 7000, 7173 },
73
{ DBLQH_REF, 1 , 5000, 5030 },
74
{ DBACC_REF, 1 , 3000, 3999 },
75
{ DBTUP_REF, 1 , 4000, 4007 },
76
{ DBDICT_REF, 1 , 6000, 6003 },
77
{ NDBCNTR_REF, 0 , 1000, 1999 },
78
{ CMVMI_REF, 1 , 9000, 9999 }, // before QMGR
79
{ QMGR_REF, 1 , 1, 999 },
80
{ TRIX_REF, 1 , 0, 0 },
81
{ BACKUP_REF, 1 , 10000, 10999 },
82
{ DBUTIL_REF, 1 , 11000, 11999 },
83
{ SUMA_REF, 1 , 13000, 13999 },
84
{ DBTUX_REF, 1 , 12000, 12999 }
85
,{ TSMAN_REF, 1 , 0, 0 }
86
,{ LGMAN_REF, 1 , 0, 0 }
87
,{ PGMAN_REF, 1 , 0, 0 }
88
,{ RESTORE_REF,1 , 0, 0 }
91
static const Uint32 ALL_BLOCKS_SZ = sizeof(ALL_BLOCKS)/sizeof(BlockInfo);
93
static BlockReference readConfigOrder[ALL_BLOCKS_SZ] = {
115
/*******************************/
117
/*******************************/
118
void Ndbcntr::execCONTINUEB(Signal* signal)
121
UintR Ttemp1 = signal->theData[0];
124
if(getNodeState().startLevel == NodeState::SL_STARTED){
129
if(cmasterNodeId == getOwnNodeId() && c_start.m_starting.isclear()){
131
trySystemRestart(signal);
135
Uint64 now = NdbTick_CurrentMillisecond();
136
if(now > c_start.m_startFailureTimeout)
140
const ndb_mgm_configuration_iterator * p =
141
m_ctx.m_config.getOwnConfigIterator();
142
ndb_mgm_get_int_parameter(p, CFG_DB_START_FAILURE_TIMEOUT, &to_3);
144
tmp.append("Shutting down node as total restart time exceeds "
145
" StartFailureTimeout as set in config file ");
147
tmp.append(" 0 (inifinite)");
149
tmp.appfmt(" %d", to_3);
151
progError(__LINE__, NDBD_EXIT_RESTART_TIMEOUT, tmp.c_str());
154
signal->theData[0] = ZSTARTUP;
155
sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 1);
160
c_stopRec.checkTimeout(signal);
164
systemErrorLab(signal, __LINE__);
168
}//Ndbcntr::execCONTINUEB()
171
Ndbcntr::execAPI_START_REP(Signal* signal)
173
if(refToBlock(signal->getSendersBlockRef()) == QMGR)
175
for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
176
sendSignal(ALL_BLOCKS[i].Ref, GSN_API_START_REP, signal, 1, JBB);
180
/*******************************/
182
/*******************************/
183
void Ndbcntr::execSYSTEM_ERROR(Signal* signal)
185
const SystemError * const sysErr = (SystemError *)signal->getDataPtr();
187
int killingNode = refToNode(sysErr->errorRef);
188
Uint32 data1 = sysErr->data1;
191
switch (sysErr->errorCode){
192
case SystemError::GCPStopDetected:
193
BaseString::snprintf(buf, sizeof(buf),
194
"Node %d killed this node because "
195
"GCP stop was detected",
199
case SystemError::CopyFragRefError:
200
CRASH_INSERTION(1000);
201
BaseString::snprintf(buf, sizeof(buf),
202
"Killed by node %d as "
203
"copyfrag failed, error: %u",
207
case SystemError::StartFragRefError:
208
BaseString::snprintf(buf, sizeof(buf),
209
"Node %d killed this node because "
210
"it replied StartFragRef error code: %u.",
214
case SystemError::CopySubscriptionRef:
215
BaseString::snprintf(buf, sizeof(buf),
216
"Node %d killed this node because "
217
"it could not copy a subscription during node restart. "
218
"Copy subscription error code: %u.",
221
case SystemError::CopySubscriberRef:
222
BaseString::snprintf(buf, sizeof(buf),
223
"Node %d killed this node because "
224
"it could not start a subscriber during node restart. "
225
"Copy subscription error code: %u.",
229
BaseString::snprintf(buf, sizeof(buf), "System error %d, "
230
" this node was killed by node %d",
231
sysErr->errorCode, killingNode);
235
progError(__LINE__, NDBD_EXIT_SYSTEM_ERROR, buf);
237
}//Ndbcntr::execSYSTEM_ERROR()
240
Ndbcntr::execREAD_CONFIG_REQ(Signal* signal)
244
const ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtr();
246
Uint32 ref = req->senderRef;
247
Uint32 senderData = req->senderData;
249
const ndb_mgm_configuration_iterator * p =
250
m_ctx.m_config.getOwnConfigIterator();
253
ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
254
conf->senderRef = reference();
255
conf->senderData = senderData;
256
sendSignal(ref, GSN_READ_CONFIG_CONF, signal,
257
ReadConfigConf::SignalLength, JBB);
260
void Ndbcntr::execSTTOR(Signal* signal)
263
cstartPhase = signal->theData[1];
266
cinternalStartphase = cstartPhase - 1;
268
switch (cstartPhase) {
270
if(m_ctx.m_config.getInitialStart()){
273
clearFilesystem(signal);
281
Uint32 db_watchdog_interval = 0;
282
const ndb_mgm_configuration_iterator * p =
283
m_ctx.m_config.getOwnConfigIterator();
284
ndb_mgm_get_int_parameter(p, CFG_DB_WATCHDOG_INTERVAL, &db_watchdog_interval);
285
ndbrequire(db_watchdog_interval);
286
update_watch_dog_timer(db_watchdog_interval);
288
startPhase1Lab(signal);
292
startPhase2Lab(signal);
296
startPhase3Lab(signal);
300
startPhase4Lab(signal);
304
startPhase5Lab(signal);
308
getNodeGroup(signal);
313
startPhase8Lab(signal);
317
startPhase9Lab(signal);
324
}//Ndbcntr::execSTTOR()
327
Ndbcntr::getNodeGroup(Signal* signal){
329
CheckNodeGroups * sd = (CheckNodeGroups*)signal->getDataPtrSend();
330
sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::GetNodeGroup;
331
EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal,
332
CheckNodeGroups::SignalLength);
334
c_nodeGroup = sd->output;
338
/*******************************/
340
/*******************************/
341
void Ndbcntr::execNDB_STTORRY(Signal* signal)
344
switch (cstartPhase) {
387
systemErrorLab(signal, __LINE__);
391
}//Ndbcntr::execNDB_STTORRY()
393
void Ndbcntr::startPhase1Lab(Signal* signal)
401
NdbBlocksRecPtr ndbBlocksPtr;
403
ptrAss(ndbBlocksPtr, ndbBlocksRec);
404
ndbBlocksPtr.p->blockref = DBLQH_REF;
406
ptrAss(ndbBlocksPtr, ndbBlocksRec);
407
ndbBlocksPtr.p->blockref = DBDICT_REF;
409
ptrAss(ndbBlocksPtr, ndbBlocksRec);
410
ndbBlocksPtr.p->blockref = DBTUP_REF;
412
ptrAss(ndbBlocksPtr, ndbBlocksRec);
413
ndbBlocksPtr.p->blockref = DBACC_REF;
415
ptrAss(ndbBlocksPtr, ndbBlocksRec);
416
ndbBlocksPtr.p->blockref = DBTC_REF;
418
ptrAss(ndbBlocksPtr, ndbBlocksRec);
419
ndbBlocksPtr.p->blockref = DBDIH_REF;
424
void Ndbcntr::execREAD_NODESREF(Signal* signal)
427
systemErrorLab(signal, __LINE__);
429
}//Ndbcntr::execREAD_NODESREF()
432
/*******************************/
434
/*******************************/
435
void Ndbcntr::execNDB_STARTREF(Signal* signal)
438
systemErrorLab(signal, __LINE__);
440
}//Ndbcntr::execNDB_STARTREF()
442
/*******************************/
444
/*******************************/
445
void Ndbcntr::startPhase2Lab(Signal* signal)
447
c_start.m_lastGci = 0;
448
c_start.m_lastGciNodeId = getOwnNodeId();
450
signal->theData[0] = reference();
451
sendSignal(DBDIH_REF, GSN_DIH_RESTARTREQ, signal, 1, JBB);
453
}//Ndbcntr::startPhase2Lab()
455
/*******************************/
456
/* DIH_RESTARTCONF */
457
/*******************************/
458
void Ndbcntr::execDIH_RESTARTCONF(Signal* signal)
461
//cmasterDihId = signal->theData[0];
462
c_start.m_lastGci = signal->theData[1];
463
ctypeOfStart = NodeState::ST_SYSTEM_RESTART;
466
}//Ndbcntr::execDIH_RESTARTCONF()
468
/*******************************/
470
/*******************************/
471
void Ndbcntr::execDIH_RESTARTREF(Signal* signal)
474
ctypeOfStart = NodeState::ST_INITIAL_START;
477
}//Ndbcntr::execDIH_RESTARTREF()
479
void Ndbcntr::ph2ALab(Signal* signal)
481
/******************************/
482
/* request configured nodes */
485
/******************************/
486
signal->theData[0] = reference();
487
sendSignal(QMGR_REF, GSN_READ_NODESREQ, signal, 1, JBB);
489
}//Ndbcntr::ph2ALab()
493
setTimeout(Uint64 time, Uint32 timeoutValue){
494
if(timeoutValue == 0)
496
return time + timeoutValue;
499
/*******************************/
501
/*******************************/
502
void Ndbcntr::execREAD_NODESCONF(Signal* signal)
505
const ReadNodesConf * readNodes = (ReadNodesConf *)&signal->theData[0];
507
cmasterNodeId = readNodes->masterNodeId;
508
cdynamicNodeId = readNodes->ndynamicId;
511
* All defined nodes...
513
c_allDefinedNodes.assign(NdbNodeBitmask::Size, readNodes->allNodes);
514
c_clusterNodes.assign(NdbNodeBitmask::Size, readNodes->clusterNodes);
520
const ndb_mgm_configuration_iterator * p =
521
m_ctx.m_config.getOwnConfigIterator();
524
ndb_mgm_get_int_parameter(p, CFG_DB_START_PARTIAL_TIMEOUT, &to_1);
525
ndb_mgm_get_int_parameter(p, CFG_DB_START_PARTITION_TIMEOUT, &to_2);
526
ndb_mgm_get_int_parameter(p, CFG_DB_START_FAILURE_TIMEOUT, &to_3);
528
c_start.m_startTime = NdbTick_CurrentMillisecond();
529
c_start.m_startPartialTimeout = setTimeout(c_start.m_startTime, to_1);
530
c_start.m_startPartitionedTimeout = setTimeout(c_start.m_startTime, to_2);
531
c_start.m_startFailureTimeout = setTimeout(c_start.m_startTime, to_3);
533
UpgradeStartup::sendCmAppChg(* this, signal, 0); // ADD
535
sendCntrStartReq(signal);
537
signal->theData[0] = ZSTARTUP;
538
sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 1000, 1);
544
Ndbcntr::execCM_ADD_REP(Signal* signal){
546
c_clusterNodes.set(signal->theData[0]);
550
Ndbcntr::sendCntrStartReq(Signal * signal){
553
CntrStartReq * req = (CntrStartReq*)signal->getDataPtrSend();
554
req->startType = ctypeOfStart;
555
req->lastGci = c_start.m_lastGci;
556
req->nodeId = getOwnNodeId();
557
sendSignal(calcNdbCntrBlockRef(cmasterNodeId), GSN_CNTR_START_REQ,
558
signal, CntrStartReq::SignalLength, JBB);
562
Ndbcntr::execCNTR_START_REF(Signal * signal){
564
const CntrStartRef * ref = (CntrStartRef*)signal->getDataPtr();
566
switch(ref->errorCode){
567
case CntrStartRef::NotMaster:
569
cmasterNodeId = ref->masterNodeId;
570
sendCntrStartReq(signal);
572
case CntrStartRef::StopInProgress:
574
progError(__LINE__, NDBD_EXIT_RESTART_DURING_SHUTDOWN);
580
Ndbcntr::StartRecord::reset(){
584
m_withoutLog.clear();
585
m_lastGci = m_lastGciNodeId = 0;
586
m_startPartialTimeout = ~0;
587
m_startPartitionedTimeout = ~0;
588
m_startFailureTimeout = ~0;
594
Ndbcntr::execCNTR_START_CONF(Signal * signal){
596
const CntrStartConf * conf = (CntrStartConf*)signal->getDataPtr();
598
cnoStartNodes = conf->noStartNodes;
599
ctypeOfStart = (NodeState::StartType)conf->startType;
600
c_start.m_lastGci = conf->startGci;
601
cmasterNodeId = conf->masterNodeId;
603
tmp.assign(NdbNodeBitmask::Size, conf->startedNodes);
604
c_startedNodes.bitOR(tmp);
605
c_start.m_starting.assign(NdbNodeBitmask::Size, conf->startingNodes);
608
UpgradeStartup::sendCmAppChg(* this, signal, 2); //START
612
* Tried with parallell nr, but it crashed in DIH
613
* so I turned it off, as I don't want to debug DIH now...
616
* After trying for 2 hours, I gave up.
617
* DIH is not designed to support it, and
618
* it requires quite of lot of changes to
622
#define PARALLELL_NR 0
625
const bool parallellNR = true;
627
const bool parallellNR = false;
631
Ndbcntr::execCNTR_START_REP(Signal* signal){
633
Uint32 nodeId = signal->theData[0];
634
c_startedNodes.set(nodeId);
635
c_start.m_starting.clear(nodeId);
638
* Inform all interested blocks that node has started
640
for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
641
sendSignal(ALL_BLOCKS[i].Ref, GSN_NODE_START_REP, signal, 1, JBB);
644
if(!c_start.m_starting.isclear()){
649
if(cmasterNodeId != getOwnNodeId()){
655
if(c_start.m_waiting.isclear()){
661
startWaitingNodes(signal);
665
Ndbcntr::execCNTR_START_REQ(Signal * signal){
667
const CntrStartReq * req = (CntrStartReq*)signal->getDataPtr();
669
const Uint32 nodeId = req->nodeId;
670
const Uint32 lastGci = req->lastGci;
671
const NodeState::StartType st = (NodeState::StartType)req->startType;
673
if(cmasterNodeId == 0){
675
// Has not completed READNODES yet
676
sendSignalWithDelay(reference(), GSN_CNTR_START_REQ, signal, 100,
677
signal->getLength());
681
if(cmasterNodeId != getOwnNodeId()){
683
sendCntrStartRef(signal, nodeId, CntrStartRef::NotMaster);
687
const NodeState & nodeState = getNodeState();
688
switch(nodeState.startLevel){
689
case NodeState::SL_NOTHING:
690
case NodeState::SL_CMVMI:
693
case NodeState::SL_STARTING:
694
case NodeState::SL_STARTED:
698
case NodeState::SL_STOPPING_1:
699
case NodeState::SL_STOPPING_2:
700
case NodeState::SL_STOPPING_3:
701
case NodeState::SL_STOPPING_4:
703
sendCntrStartRef(signal, nodeId, CntrStartRef::StopInProgress);
708
* Am I starting (or started)
710
const bool starting = (nodeState.startLevel != NodeState::SL_STARTED);
712
c_start.m_waiting.set(nodeId);
714
case NodeState::ST_INITIAL_START:
716
c_start.m_withoutLog.set(nodeId);
718
case NodeState::ST_SYSTEM_RESTART:
720
c_start.m_withLog.set(nodeId);
721
if(starting && lastGci > c_start.m_lastGci){
723
CntrStartRef * ref = (CntrStartRef*)signal->getDataPtrSend();
724
ref->errorCode = CntrStartRef::NotMaster;
725
ref->masterNodeId = nodeId;
726
NodeReceiverGroup rg (NDBCNTR, c_start.m_waiting);
727
sendSignal(rg, GSN_CNTR_START_REF, signal,
728
CntrStartRef::SignalLength, JBB);
733
Uint32 i = c_start.m_logNodesCount++;
734
c_start.m_logNodes[i].m_nodeId = nodeId;
735
c_start.m_logNodes[i].m_lastGci = req->lastGci;
738
case NodeState::ST_NODE_RESTART:
739
case NodeState::ST_INITIAL_NODE_RESTART:
740
case NodeState::ST_ILLEGAL_TYPE:
744
const bool startInProgress = !c_start.m_starting.isclear();
746
if((starting && startInProgress) || (startInProgress && !parallellNR)){
748
// We're already starting together with a bunch of nodes
749
// Let this node wait...
755
trySystemRestart(signal);
758
startWaitingNodes(signal);
764
Ndbcntr::startWaitingNodes(Signal * signal){
767
const Uint32 nodeId = c_start.m_waiting.find(0);
768
const Uint32 Tref = calcNdbCntrBlockRef(nodeId);
769
ndbrequire(nodeId != c_start.m_waiting.NotFound);
771
NodeState::StartType nrType = NodeState::ST_NODE_RESTART;
772
if(c_start.m_withoutLog.get(nodeId)){
774
nrType = NodeState::ST_INITIAL_NODE_RESTART;
778
* Let node perform restart
780
CntrStartConf * conf = (CntrStartConf*)signal->getDataPtrSend();
781
conf->noStartNodes = 1;
782
conf->startType = nrType;
783
conf->startGci = ~0; // Not used
784
conf->masterNodeId = getOwnNodeId();
785
BitmaskImpl::clear(NdbNodeBitmask::Size, conf->startingNodes);
786
BitmaskImpl::set(NdbNodeBitmask::Size, conf->startingNodes, nodeId);
787
c_startedNodes.copyto(NdbNodeBitmask::Size, conf->startedNodes);
788
sendSignal(Tref, GSN_CNTR_START_CONF, signal,
789
CntrStartConf::SignalLength, JBB);
791
c_start.m_waiting.clear(nodeId);
792
c_start.m_withLog.clear(nodeId);
793
c_start.m_withoutLog.clear(nodeId);
794
c_start.m_starting.set(nodeId);
798
c_start.m_starting = c_start.m_waiting;
799
c_start.m_waiting.clear();
801
CntrStartConf * conf = (CntrStartConf*)signal->getDataPtrSend();
802
conf->noStartNodes = 1;
803
conf->startGci = ~0; // Not used
804
conf->masterNodeId = getOwnNodeId();
805
c_start.m_starting.copyto(NdbNodeBitmask::Size, conf->startingNodes);
806
c_startedNodes.copyto(NdbNodeBitmask::Size, conf->startedNodes);
809
if(!c_start.m_withLog.isclear()){
811
ndbout_c("Starting nodes w/ log: %s", c_start.m_withLog.getText(buf));
813
NodeReceiverGroup rg(NDBCNTR, c_start.m_withLog);
814
conf->startType = NodeState::ST_NODE_RESTART;
816
sendSignal(rg, GSN_CNTR_START_CONF, signal,
817
CntrStartConf::SignalLength, JBB);
820
if(!c_start.m_withoutLog.isclear()){
822
ndbout_c("Starting nodes wo/ log: %s", c_start.m_withoutLog.getText(buf));
823
NodeReceiverGroup rg(NDBCNTR, c_start.m_withoutLog);
824
conf->startType = NodeState::ST_INITIAL_NODE_RESTART;
826
sendSignal(rg, GSN_CNTR_START_CONF, signal,
827
CntrStartConf::SignalLength, JBB);
830
c_start.m_waiting.clear();
831
c_start.m_withLog.clear();
832
c_start.m_withoutLog.clear();
837
Ndbcntr::sendCntrStartRef(Signal * signal,
838
Uint32 nodeId, CntrStartRef::ErrorCode code){
839
CntrStartRef * ref = (CntrStartRef*)signal->getDataPtrSend();
840
ref->errorCode = code;
841
ref->masterNodeId = cmasterNodeId;
842
sendSignal(calcNdbCntrBlockRef(nodeId), GSN_CNTR_START_REF, signal,
843
CntrStartRef::SignalLength, JBB);
846
CheckNodeGroups::Output
847
Ndbcntr::checkNodeGroups(Signal* signal, const NdbNodeBitmask & mask){
848
CheckNodeGroups* sd = (CheckNodeGroups*)&signal->theData[0];
849
sd->blockRef = reference();
850
sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::ArbitCheck;
852
EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal,
853
CheckNodeGroups::SignalLength);
855
return (CheckNodeGroups::Output)sd->output;
859
Ndbcntr::trySystemRestart(Signal* signal){
861
* System restart something
863
const bool allNodes = c_start.m_waiting.equal(c_allDefinedNodes);
864
const bool allClusterNodes = c_start.m_waiting.equal(c_clusterNodes);
866
if(!allClusterNodes){
871
NodeState::StartType srType = NodeState::ST_SYSTEM_RESTART;
872
if(c_start.m_waiting.equal(c_start.m_withoutLog))
875
srType = NodeState::ST_INITIAL_START;
876
c_start.m_starting = c_start.m_withoutLog; // Used for starting...
877
c_start.m_withoutLog.clear();
880
CheckNodeGroups::Output wLog = checkNodeGroups(signal, c_start.m_withLog);
883
case CheckNodeGroups::Win:
886
case CheckNodeGroups::Lose:
888
// If we lose with all nodes, then we're in trouble
889
ndbrequire(!allNodes);
891
case CheckNodeGroups::Partitioning:
893
bool allowPartition = (c_start.m_startPartitionedTimeout != (Uint64)~0);
900
ndbrequire(false); // All nodes -> partitioning, which is not allowed
906
// For now only with the "logged"-ones.
907
// Let the others do node restart afterwards...
908
c_start.m_starting = c_start.m_withLog;
909
c_start.m_withLog.clear();
913
* Okidoki, we try to start
915
CntrStartConf * conf = (CntrStartConf*)signal->getDataPtr();
916
conf->noStartNodes = c_start.m_starting.count();
917
conf->startType = srType;
918
conf->startGci = c_start.m_lastGci;
919
conf->masterNodeId = c_start.m_lastGciNodeId;
920
c_start.m_starting.copyto(NdbNodeBitmask::Size, conf->startingNodes);
921
c_startedNodes.copyto(NdbNodeBitmask::Size, conf->startedNodes);
923
ndbrequire(c_start.m_lastGciNodeId == getOwnNodeId());
925
NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
926
sendSignal(rg, GSN_CNTR_START_CONF, signal, CntrStartConf::SignalLength,JBB);
928
c_start.m_waiting.bitANDC(c_start.m_starting);
933
void Ndbcntr::ph2GLab(Signal* signal)
935
if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
937
sendNdbSttor(signal);
942
}//Ndbcntr::ph2GLab()
946
/*###########################################################################*/
947
// SEND SIGNAL NDBSTTOR TO ALL BLOCKS, ACC, DICT, DIH, LQH, TC AND TUP
948
// WHEN ALL BLOCKS HAVE RETURNED THEIR NDB_STTORRY ALL BLOCK HAVE FINISHED
949
// THEIR LOCAL CONNECTIONs SUCESSFULLY
950
// AND THEN WE CAN SEND APPL_STARTREG TO INFORM QMGR THAT WE ARE READY TO
951
// SET UP DISTRIBUTED CONNECTIONS.
952
/*--------------------------------------------------------------*/
953
// THIS IS NDB START PHASE 3.
954
/*--------------------------------------------------------------*/
955
/*******************************/
957
/*******************************/
958
void Ndbcntr::startPhase3Lab(Signal* signal)
962
}//Ndbcntr::startPhase3Lab()
964
/*******************************/
966
/*******************************/
967
void Ndbcntr::ph3ALab(Signal* signal)
969
if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
971
sendNdbSttor(signal);
977
}//Ndbcntr::ph3ALab()
981
/*###########################################################################*/
982
// WAIT FOR ALL NODES IN CLUSTER TO CHANGE STATE INTO ZSTART ,
983
// APPL_CHANGEREP IS ALWAYS SENT WHEN SOMEONE HAVE
984
// CHANGED THEIR STATE. APPL_STARTCONF INDICATES THAT ALL NODES ARE IN START
985
// STATE SEND NDB_STARTREQ TO DIH AND THEN WAIT FOR NDB_STARTCONF
986
/*---------------------------------------------------------------------------*/
987
/*******************************/
989
/*******************************/
990
void Ndbcntr::startPhase4Lab(Signal* signal)
993
}//Ndbcntr::startPhase4Lab()
996
void Ndbcntr::ph4ALab(Signal* signal)
1000
}//Ndbcntr::ph4ALab()
1002
/*******************************/
1004
/*******************************/
1005
void Ndbcntr::ph4BLab(Signal* signal)
1007
/*--------------------------------------*/
1008
/* CASE: CSTART_PHASE = ZSTART_PHASE_4 */
1009
/*--------------------------------------*/
1010
if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
1012
sendNdbSttor(signal);
1015
if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
1016
(ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
1018
sendSttorry(signal);
1021
waitpoint41Lab(signal);
1023
}//Ndbcntr::ph4BLab()
1025
void Ndbcntr::waitpoint41Lab(Signal* signal)
1027
if (getOwnNodeId() == cmasterNodeId) {
1029
/*--------------------------------------*/
1030
/* MASTER WAITS UNTIL ALL SLAVES HAS */
1031
/* SENT THE REPORTS */
1032
/*--------------------------------------*/
1034
if (cnoWaitrep == cnoStartNodes) {
1037
/*---------------------------------------------------------------------------*/
1038
// NDB_STARTREQ STARTS UP ALL SET UP OF DISTRIBUTION INFORMATION IN DIH AND
1039
// DICT. AFTER SETTING UP THIS
1040
// DATA IT USES THAT DATA TO SET UP WHICH FRAGMENTS THAT ARE TO START AND
1041
// WHERE THEY ARE TO START. THEN
1042
// IT SETS UP THE FRAGMENTS AND RECOVERS THEM BY:
1043
// 1) READING A LOCAL CHECKPOINT FROM DISK.
1044
// 2) EXECUTING THE UNDO LOG ON INDEX AND DATA.
1045
// 3) EXECUTING THE FRAGMENT REDO LOG FROM ONE OR SEVERAL NODES TO
1046
// RESTORE THE RESTART CONFIGURATION OF DATA IN NDB CLUSTER.
1047
/*---------------------------------------------------------------------------*/
1048
signal->theData[0] = reference();
1049
signal->theData[1] = ctypeOfStart;
1050
sendSignal(DBDIH_REF, GSN_NDB_STARTREQ, signal, 2, JBB);
1054
/*--------------------------------------*/
1055
/* SLAVE NODES WILL PASS HERE ONCE AND */
1056
/* SEND A WAITPOINT REPORT TO MASTER. */
1057
/* SLAVES WONT DO ANYTHING UNTIL THEY */
1058
/* RECEIVE A WAIT REPORT FROM THE MASTER*/
1059
/*--------------------------------------*/
1060
signal->theData[0] = getOwnNodeId();
1061
signal->theData[1] = ZWAITPOINT_4_1;
1062
sendSignal(calcNdbCntrBlockRef(cmasterNodeId),
1063
GSN_CNTR_WAITREP, signal, 2, JBB);
1066
}//Ndbcntr::waitpoint41Lab()
1068
/*******************************/
1070
/*******************************/
1071
void Ndbcntr::execNDB_STARTCONF(Signal* signal)
1075
NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
1076
signal->theData[0] = getOwnNodeId();
1077
signal->theData[1] = ZWAITPOINT_4_2;
1078
sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
1080
}//Ndbcntr::execNDB_STARTCONF()
1083
4.6 START PHASE 5 */
1084
/*###########################################################################*/
1085
// SEND APPL_RUN TO THE QMGR IN THIS BLOCK
1086
// SEND NDB_STTOR ALL BLOCKS ACC, DICT, DIH, LQH, TC AND TUP THEN WAIT FOR
1087
// THEIR NDB_STTORRY
1088
/*---------------------------------------------------------------------------*/
1089
/*******************************/
1091
/*******************************/
1092
void Ndbcntr::startPhase5Lab(Signal* signal)
1096
}//Ndbcntr::startPhase5Lab()
1098
/*******************************/
1100
/*******************************/
1101
/*---------------------------------------------------------------------------*/
1102
// THIS IS NDB START PHASE 5.
1103
/*---------------------------------------------------------------------------*/
1104
// IN THIS START PHASE TUP INITIALISES DISK FILES FOR DISK STORAGE IF INITIAL
1105
// START. DIH WILL START UP
1106
// THE GLOBAL CHECKPOINT PROTOCOL AND WILL CONCLUDE ANY UNFINISHED TAKE OVERS
1107
// THAT STARTED BEFORE THE SYSTEM CRASH.
1108
/*---------------------------------------------------------------------------*/
1109
void Ndbcntr::ph5ALab(Signal* signal)
1111
if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
1113
sendNdbSttor(signal);
1117
cstartPhase = cstartPhase + 1;
1118
cinternalStartphase = cstartPhase - 1;
1119
if (getOwnNodeId() == cmasterNodeId) {
1120
switch(ctypeOfStart){
1121
case NodeState::ST_INITIAL_START:
1123
/*--------------------------------------*/
1124
/* MASTER CNTR IS RESPONSIBLE FOR */
1125
/* CREATING SYSTEM TABLES */
1126
/*--------------------------------------*/
1127
createSystableLab(signal, 0);
1129
case NodeState::ST_SYSTEM_RESTART:
1131
waitpoint52Lab(signal);
1133
case NodeState::ST_NODE_RESTART:
1134
case NodeState::ST_INITIAL_NODE_RESTART:
1137
case NodeState::ST_ILLEGAL_TYPE:
1147
NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend();
1148
switch(ctypeOfStart){
1149
case NodeState::ST_NODE_RESTART:
1150
case NodeState::ST_INITIAL_NODE_RESTART:
1152
/*----------------------------------------------------------------------*/
1153
// SEND NDB START PHASE 5 IN NODE RESTARTS TO COPY DATA TO THE NEWLY
1155
/*----------------------------------------------------------------------*/
1156
req->senderRef = reference();
1157
req->nodeId = getOwnNodeId();
1158
req->internalStartPhase = cinternalStartphase;
1159
req->typeOfStart = ctypeOfStart;
1160
req->masterNodeId = cmasterNodeId;
1162
//#define TRACE_STTOR
1164
ndbout_c("sending NDB_STTOR(%d) to DIH", cinternalStartphase);
1166
sendSignal(DBDIH_REF, GSN_NDB_STTOR, signal,
1167
NdbSttor::SignalLength, JBB);
1169
case NodeState::ST_INITIAL_START:
1170
case NodeState::ST_SYSTEM_RESTART:
1172
/*--------------------------------------*/
1173
/* DURING SYSTEMRESTART AND INITALSTART:*/
1174
/* SLAVE NODES WILL PASS HERE ONCE AND */
1175
/* SEND A WAITPOINT REPORT TO MASTER. */
1176
/* SLAVES WONT DO ANYTHING UNTIL THEY */
1177
/* RECEIVE A WAIT REPORT FROM THE MASTER*/
1178
/* WHEN THE MASTER HAS FINISHED HIS WORK*/
1179
/*--------------------------------------*/
1180
signal->theData[0] = getOwnNodeId();
1181
signal->theData[1] = ZWAITPOINT_5_2;
1182
sendSignal(calcNdbCntrBlockRef(cmasterNodeId),
1183
GSN_CNTR_WAITREP, signal, 2, JBB);
1188
}//Ndbcntr::ph5ALab()
1190
void Ndbcntr::waitpoint52Lab(Signal* signal)
1192
cnoWaitrep = cnoWaitrep + 1;
1193
/*---------------------------------------------------------------------------*/
1194
// THIS WAITING POINT IS ONLY USED BY A MASTER NODE. WE WILL EXECUTE NDB START
1195
// PHASE 5 FOR DIH IN THE
1196
// MASTER. THIS WILL START UP LOCAL CHECKPOINTS AND WILL ALSO CONCLUDE ANY
1197
// UNFINISHED LOCAL CHECKPOINTS
1198
// BEFORE THE SYSTEM CRASH. THIS WILL ENSURE THAT WE ALWAYS RESTART FROM A
1199
// WELL KNOWN STATE.
1200
/*---------------------------------------------------------------------------*/
1201
/*--------------------------------------*/
1202
/* MASTER WAITS UNTIL HE RECEIVED WAIT */
1203
/* REPORTS FROM ALL SLAVE CNTR */
1204
/*--------------------------------------*/
1205
if (cnoWaitrep == cnoStartNodes) {
1209
NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend();
1210
req->senderRef = reference();
1211
req->nodeId = getOwnNodeId();
1212
req->internalStartPhase = cinternalStartphase;
1213
req->typeOfStart = ctypeOfStart;
1214
req->masterNodeId = cmasterNodeId;
1216
ndbout_c("sending NDB_STTOR(%d) to DIH", cinternalStartphase);
1218
sendSignal(DBDIH_REF, GSN_NDB_STTOR, signal,
1219
NdbSttor::SignalLength, JBB);
1222
}//Ndbcntr::waitpoint52Lab()
1224
/*******************************/
1226
/*******************************/
1227
void Ndbcntr::ph6ALab(Signal* signal)
1229
if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
1230
(ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
1232
waitpoint51Lab(signal);
1236
NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
1237
rg.m_nodes.clear(getOwnNodeId());
1238
signal->theData[0] = getOwnNodeId();
1239
signal->theData[1] = ZWAITPOINT_5_1;
1240
sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
1242
waitpoint51Lab(signal);
1244
}//Ndbcntr::ph6ALab()
1246
void Ndbcntr::waitpoint51Lab(Signal* signal)
1248
cstartPhase = cstartPhase + 1;
1249
/*---------------------------------------------------------------------------*/
1250
// A FINAL STEP IS NOW TO SEND NDB_STTOR TO TC. THIS MAKES IT POSSIBLE TO
1251
// CONNECT TO TC FOR APPLICATIONS.
1252
// THIS IS NDB START PHASE 6 WHICH IS FOR ALL BLOCKS IN ALL NODES.
1253
/*---------------------------------------------------------------------------*/
1254
cinternalStartphase = cstartPhase - 1;
1255
cndbBlocksCount = 0;
1258
}//Ndbcntr::waitpoint51Lab()
1260
void Ndbcntr::ph6BLab(Signal* signal)
1262
// c_missra.currentStartPhase - cstartPhase - cinternalStartphase =
1264
if (cndbBlocksCount < ZNO_NDB_BLOCKS) {
1266
sendNdbSttor(signal);
1269
if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
1270
(ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
1272
sendSttorry(signal);
1275
waitpoint61Lab(signal);
1278
void Ndbcntr::waitpoint61Lab(Signal* signal)
1280
if (getOwnNodeId() == cmasterNodeId) {
1283
if (cnoWaitrep6 == cnoStartNodes) {
1285
NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
1286
rg.m_nodes.clear(getOwnNodeId());
1287
signal->theData[0] = getOwnNodeId();
1288
signal->theData[1] = ZWAITPOINT_6_2;
1289
sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
1290
sendSttorry(signal);
1294
signal->theData[0] = getOwnNodeId();
1295
signal->theData[1] = ZWAITPOINT_6_1;
1296
sendSignal(calcNdbCntrBlockRef(cmasterNodeId), GSN_CNTR_WAITREP, signal, 2, JBB);
1300
// Start phase 8 (internal 7)
1301
void Ndbcntr::startPhase8Lab(Signal* signal)
1303
cinternalStartphase = cstartPhase - 1;
1304
cndbBlocksCount = 0;
1308
void Ndbcntr::ph7ALab(Signal* signal)
1310
while (cndbBlocksCount < ZNO_NDB_BLOCKS) {
1312
sendNdbSttor(signal);
1315
if ((ctypeOfStart == NodeState::ST_NODE_RESTART) ||
1316
(ctypeOfStart == NodeState::ST_INITIAL_NODE_RESTART)) {
1318
sendSttorry(signal);
1321
waitpoint71Lab(signal);
1324
void Ndbcntr::waitpoint71Lab(Signal* signal)
1326
if (getOwnNodeId() == cmasterNodeId) {
1329
if (cnoWaitrep7 == cnoStartNodes) {
1331
NodeReceiverGroup rg(NDBCNTR, c_start.m_starting);
1332
rg.m_nodes.clear(getOwnNodeId());
1333
signal->theData[0] = getOwnNodeId();
1334
signal->theData[1] = ZWAITPOINT_7_2;
1335
sendSignal(rg, GSN_CNTR_WAITREP, signal, 2, JBB);
1336
sendSttorry(signal);
1340
signal->theData[0] = getOwnNodeId();
1341
signal->theData[1] = ZWAITPOINT_7_1;
1342
sendSignal(calcNdbCntrBlockRef(cmasterNodeId), GSN_CNTR_WAITREP, signal, 2, JBB);
1346
// Start phase 9 (internal 8)
1347
void Ndbcntr::startPhase9Lab(Signal* signal)
1349
cinternalStartphase = cstartPhase - 1;
1350
cndbBlocksCount = 0;
1354
void Ndbcntr::ph8ALab(Signal* signal)
1356
/*---------------------------------------------------------------------------*/
1357
// NODES WHICH PERFORM A NODE RESTART NEEDS TO GET THE DYNAMIC ID'S
1358
// OF THE OTHER NODES HERE.
1359
/*---------------------------------------------------------------------------*/
1360
sendSttorry(signal);
1361
resetStartVariables(signal);
1363
}//Ndbcntr::ph8BLab()
1365
/*******************************/
1367
/*******************************/
1368
void Ndbcntr::execCNTR_WAITREP(Signal* signal)
1373
twaitPoint = signal->theData[1];
1374
switch (twaitPoint) {
1375
case ZWAITPOINT_4_1:
1377
waitpoint41Lab(signal);
1379
case ZWAITPOINT_4_2:
1381
sendSttorry(signal);
1383
case ZWAITPOINT_5_1:
1385
waitpoint51Lab(signal);
1387
case ZWAITPOINT_5_2:
1389
waitpoint52Lab(signal);
1391
case ZWAITPOINT_6_1:
1393
waitpoint61Lab(signal);
1395
case ZWAITPOINT_6_2:
1397
sendSttorry(signal);
1399
case ZWAITPOINT_7_1:
1401
waitpoint71Lab(signal);
1403
case ZWAITPOINT_7_2:
1405
sendSttorry(signal);
1409
systemErrorLab(signal, __LINE__);
1412
}//Ndbcntr::execCNTR_WAITREP()
1414
/*******************************/
1416
/*******************************/
1417
void Ndbcntr::execNODE_FAILREP(Signal* signal)
1421
if (ERROR_INSERTED(1001))
1423
sendSignalWithDelay(reference(), GSN_NODE_FAILREP, signal, 100,
1424
signal->getLength());
1428
const NodeFailRep * nodeFail = (NodeFailRep *)&signal->theData[0];
1429
NdbNodeBitmask allFailed;
1430
allFailed.assign(NdbNodeBitmask::Size, nodeFail->theNodes);
1432
NdbNodeBitmask failedStarted = c_startedNodes;
1433
NdbNodeBitmask failedStarting = c_start.m_starting;
1434
NdbNodeBitmask failedWaiting = c_start.m_waiting;
1436
failedStarted.bitAND(allFailed);
1437
failedStarting.bitAND(allFailed);
1438
failedWaiting.bitAND(allFailed);
1440
const bool tMasterFailed = allFailed.get(cmasterNodeId);
1441
const bool tStarted = !failedStarted.isclear();
1442
const bool tStarting = !failedStarting.isclear();
1447
* If master has failed choose qmgr president as master
1449
cmasterNodeId = nodeFail->masterNodeId;
1453
* Clear node bitmasks from failed nodes
1455
c_start.m_starting.bitANDC(allFailed);
1456
c_start.m_waiting.bitANDC(allFailed);
1457
c_start.m_withLog.bitANDC(allFailed);
1458
c_start.m_withoutLog.bitANDC(allFailed);
1459
c_clusterNodes.bitANDC(allFailed);
1460
c_startedNodes.bitANDC(allFailed);
1462
const NodeState & st = getNodeState();
1463
if(st.startLevel == st.SL_STARTING){
1466
const Uint32 phase = st.starting.startPhase;
1468
const bool tStartConf = (phase > 2) || (phase == 2 && cndbBlocksCount > 0);
1471
progError(__LINE__, NDBD_EXIT_SR_OTHERNODEFAILED,
1472
"Unhandled node failure during restart");
1475
if(tStartConf && tStarting){
1476
// One of other starting nodes has crashed...
1477
progError(__LINE__, NDBD_EXIT_SR_OTHERNODEFAILED,
1478
"Unhandled node failure of starting node during restart");
1481
if(tStartConf && tStarted){
1482
// One of other started nodes has crashed...
1483
progError(__LINE__, NDBD_EXIT_SR_OTHERNODEFAILED,
1484
"Unhandled node failure of started node during restart");
1488
while(!allFailed.isclear()){
1489
nodeId = allFailed.find(nodeId + 1);
1490
allFailed.clear(nodeId);
1491
signal->theData[0] = nodeId;
1492
sendSignal(QMGR_REF, GSN_NDB_FAILCONF, signal, 1, JBB);
1498
ndbrequire(!allFailed.get(getOwnNodeId()));
1500
NodeFailRep * rep = (NodeFailRep *)&signal->theData[0];
1501
rep->masterNodeId = cmasterNodeId;
1503
sendSignal(DBTC_REF, GSN_NODE_FAILREP, signal,
1504
NodeFailRep::SignalLength, JBB);
1506
sendSignal(DBLQH_REF, GSN_NODE_FAILREP, signal,
1507
NodeFailRep::SignalLength, JBB);
1509
sendSignal(DBDIH_REF, GSN_NODE_FAILREP, signal,
1510
NodeFailRep::SignalLength, JBB);
1512
sendSignal(DBDICT_REF, GSN_NODE_FAILREP, signal,
1513
NodeFailRep::SignalLength, JBB);
1515
sendSignal(BACKUP_REF, GSN_NODE_FAILREP, signal,
1516
NodeFailRep::SignalLength, JBB);
1518
sendSignal(SUMA_REF, GSN_NODE_FAILREP, signal,
1519
NodeFailRep::SignalLength, JBB);
1521
sendSignal(QMGR_REF, GSN_NODE_FAILREP, signal,
1522
NodeFailRep::SignalLength, JBB);
1524
if (c_stopRec.stopReq.senderRef)
1527
switch(c_stopRec.m_state){
1528
case StopRecord::SR_WAIT_NODE_FAILURES:
1532
tmp.assign(NdbNodeBitmask::Size, c_stopRec.stopReq.nodes);
1533
tmp.bitANDC(allFailed);
1534
tmp.copyto(NdbNodeBitmask::Size, c_stopRec.stopReq.nodes);
1539
if (c_stopRec.stopReq.senderRef != RNIL)
1542
StopConf * const stopConf = (StopConf *)&signal->theData[0];
1543
stopConf->senderData = c_stopRec.stopReq.senderData;
1544
stopConf->nodeState = (Uint32) NodeState::SL_SINGLEUSER;
1545
sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_CONF, signal,
1546
StopConf::SignalLength, JBB);
1549
c_stopRec.stopReq.senderRef = 0;
1550
WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
1551
req->senderRef = reference();
1552
req->senderData = StopRecord::SR_UNBLOCK_GCP_START_GCP;
1553
req->requestType = WaitGCPReq::UnblockStartGcp;
1554
sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal,
1555
WaitGCPReq::SignalLength, JBA);
1559
case StopRecord::SR_QMGR_STOP_REQ:
1562
tmp.assign(NdbNodeBitmask::Size, c_stopRec.stopReq.nodes);
1563
tmp.bitANDC(allFailed);
1567
Uint32 nodeId = allFailed.find(0);
1570
StopConf* conf = (StopConf*)signal->getDataPtrSend();
1571
conf->senderData = c_stopRec.stopReq.senderData;
1572
conf->nodeId = nodeId;
1573
sendSignal(reference(),
1574
GSN_STOP_CONF, signal, StopConf::SignalLength, JBB);
1577
tmp.copyto(NdbNodeBitmask::Size, c_stopRec.stopReq.nodes);
1581
case StopRecord::SR_BLOCK_GCP_START_GCP:
1582
case StopRecord::SR_WAIT_COMPLETE_GCP:
1583
case StopRecord::SR_UNBLOCK_GCP_START_GCP:
1584
case StopRecord::SR_CLUSTER_SHUTDOWN:
1589
signal->theData[0] = NDB_LE_NODE_FAILREP;
1590
signal->theData[2] = 0;
1593
while(!allFailed.isclear()){
1594
nodeId = allFailed.find(nodeId + 1);
1595
allFailed.clear(nodeId);
1596
signal->theData[1] = nodeId;
1597
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
1601
}//Ndbcntr::execNODE_FAILREP()
1603
/*******************************/
1605
/*******************************/
1606
void Ndbcntr::execREAD_NODESREQ(Signal* signal)
1610
/*----------------------------------------------------------------------*/
1611
// ANY BLOCK MAY SEND A REQUEST ABOUT NDB NODES AND VERSIONS IN THE
1612
// SYSTEM. THIS REQUEST CAN ONLY BE HANDLED IN
1613
// ABSOLUTE STARTPHASE 3 OR LATER
1614
/*----------------------------------------------------------------------*/
1615
BlockReference TuserBlockref = signal->theData[0];
1616
ReadNodesConf * const readNodes = (ReadNodesConf *)&signal->theData[0];
1619
* Prepare inactiveNodes bitmask.
1620
* The concept as such is by the way pretty useless.
1621
* It makes parallell starts more or less impossible...
1623
NdbNodeBitmask tmp1;
1624
tmp1.bitOR(c_startedNodes);
1625
if(!getNodeState().getNodeRestartInProgress()){
1626
tmp1.bitOR(c_start.m_starting);
1628
tmp1.set(getOwnNodeId());
1631
NdbNodeBitmask tmp2;
1632
tmp2.bitOR(c_allDefinedNodes);
1635
* Fill in return signal
1637
tmp2.copyto(NdbNodeBitmask::Size, readNodes->inactiveNodes);
1638
c_allDefinedNodes.copyto(NdbNodeBitmask::Size, readNodes->allNodes);
1639
c_clusterNodes.copyto(NdbNodeBitmask::Size, readNodes->clusterNodes);
1640
c_startedNodes.copyto(NdbNodeBitmask::Size, readNodes->startedNodes);
1641
c_start.m_starting.copyto(NdbNodeBitmask::Size, readNodes->startingNodes);
1643
readNodes->noOfNodes = c_allDefinedNodes.count();
1644
readNodes->masterNodeId = cmasterNodeId;
1645
readNodes->ndynamicId = cdynamicNodeId;
1646
if (cstartPhase > ZSTART_PHASE_2) {
1648
sendSignal(TuserBlockref, GSN_READ_NODESCONF, signal,
1649
ReadNodesConf::SignalLength, JBB);
1653
signal->theData[0] = ZNOT_AVAILABLE;
1654
sendSignal(TuserBlockref, GSN_READ_NODESREF, signal, 1, JBB);
1656
}//Ndbcntr::execREAD_NODESREQ()
1658
/*----------------------------------------------------------------------*/
1659
// SENDS APPL_ERROR TO QMGR AND THEN SET A POINTER OUT OF BOUNDS
1660
/*----------------------------------------------------------------------*/
1661
void Ndbcntr::systemErrorLab(Signal* signal, int line)
1663
progError(line, NDBD_EXIT_NDBREQUIRE); /* BUG INSERTION */
1665
}//Ndbcntr::systemErrorLab()
1667
/*###########################################################################*/
1668
/* CNTR MASTER CREATES AND INITIALIZES A SYSTEMTABLE AT INITIALSTART */
1669
/* |-2048| # 1 00000001 | */
1671
/* | -1 | # 1 00000001 | */
1672
/* | 1 | 0 | tupleid sequence now created on first use */
1675
/*---------------------------------------------------------------------------*/
1676
void Ndbcntr::createSystableLab(Signal* signal, unsigned index)
1678
if (index >= g_sysTableCount) {
1679
ndbassert(index == g_sysTableCount);
1680
startInsertTransactions(signal);
1683
const SysTable& table = *g_sysTableList[index];
1684
Uint32 propPage[256];
1685
LinearWriter w(propPage, 256);
1687
// XXX remove commented-out lines later
1690
w.add(DictTabInfo::TableName, table.name);
1691
w.add(DictTabInfo::TableLoggedFlag, table.tableLoggedFlag);
1692
//w.add(DictTabInfo::TableKValue, 6);
1693
//w.add(DictTabInfo::MinLoadFactor, 70);
1694
//w.add(DictTabInfo::MaxLoadFactor, 80);
1695
w.add(DictTabInfo::FragmentTypeVal, (Uint32)table.fragmentType);
1696
//w.add(DictTabInfo::NoOfKeyAttr, 1);
1697
w.add(DictTabInfo::NoOfAttributes, (Uint32)table.columnCount);
1698
//w.add(DictTabInfo::NoOfNullable, (Uint32)0);
1699
//w.add(DictTabInfo::NoOfVariable, (Uint32)0);
1700
//w.add(DictTabInfo::KeyLength, 1);
1701
w.add(DictTabInfo::TableTypeVal, (Uint32)table.tableType);
1702
w.add(DictTabInfo::SingleUserMode, (Uint32)NDB_SUM_READ_WRITE);
1704
for (unsigned i = 0; i < table.columnCount; i++) {
1705
const SysColumn& column = table.columnList[i];
1706
ndbassert(column.pos == i);
1707
w.add(DictTabInfo::AttributeName, column.name);
1708
w.add(DictTabInfo::AttributeId, (Uint32)i);
1709
w.add(DictTabInfo::AttributeKeyFlag, (Uint32)column.keyFlag);
1710
w.add(DictTabInfo::AttributeStorageType,
1711
(Uint32)NDB_STORAGETYPE_MEMORY);
1712
w.add(DictTabInfo::AttributeArrayType,
1713
(Uint32)NDB_ARRAYTYPE_FIXED);
1714
w.add(DictTabInfo::AttributeNullableFlag, (Uint32)column.nullable);
1715
w.add(DictTabInfo::AttributeExtType, (Uint32)column.type);
1716
w.add(DictTabInfo::AttributeExtLength, (Uint32)column.length);
1717
w.add(DictTabInfo::AttributeEnd, (Uint32)true);
1719
w.add(DictTabInfo::TableEnd, (Uint32)true);
1721
Uint32 length = w.getWordsUsed();
1722
LinearSectionPtr ptr[3];
1723
ptr[0].p = &propPage[0];
1726
CreateTableReq* const req = (CreateTableReq*)signal->getDataPtrSend();
1727
req->senderData = index;
1728
req->senderRef = reference();
1729
sendSignal(DBDICT_REF, GSN_CREATE_TABLE_REQ, signal,
1730
CreateTableReq::SignalLength, JBB, ptr, 1);
1732
}//Ndbcntr::createSystableLab()
1734
void Ndbcntr::execCREATE_TABLE_REF(Signal* signal)
1737
progError(__LINE__,NDBD_EXIT_NDBREQUIRE, "CREATE_TABLE_REF");
1739
}//Ndbcntr::execDICTTABREF()
1741
void Ndbcntr::execCREATE_TABLE_CONF(Signal* signal)
1744
CreateTableConf * const conf = (CreateTableConf*)signal->getDataPtrSend();
1745
//csystabId = conf->tableId;
1746
ndbrequire(conf->senderData < g_sysTableCount);
1747
const SysTable& table = *g_sysTableList[conf->senderData];
1748
table.tableId = conf->tableId;
1749
createSystableLab(signal, conf->senderData + 1);
1750
//startInsertTransactions(signal);
1752
}//Ndbcntr::execDICTTABCONF()
1754
/*******************************/
1755
/* DICTRELEASECONF */
1756
/*******************************/
1757
void Ndbcntr::startInsertTransactions(Signal* signal)
1762
ctransidPhase = ZTRUE;
1763
signal->theData[0] = 0;
1764
signal->theData[1] = reference();
1765
sendSignal(DBTC_REF, GSN_TCSEIZEREQ, signal, 2, JBB);
1767
}//Ndbcntr::startInsertTransactions()
1769
/*******************************/
1771
/*******************************/
1772
void Ndbcntr::execTCSEIZECONF(Signal* signal)
1775
ctcConnectionP = signal->theData[1];
1776
crSystab7Lab(signal);
1778
}//Ndbcntr::execTCSEIZECONF()
1780
const unsigned int RowsPerCommit = 16;
1781
void Ndbcntr::crSystab7Lab(Signal* signal)
1786
TcKeyReq * const tcKeyReq = (TcKeyReq *)&signal->theData[0];
1788
UintR reqInfo_Start = 0;
1789
tcKeyReq->setOperationType(reqInfo_Start, ZINSERT); // Insert
1790
tcKeyReq->setKeyLength (reqInfo_Start, 1);
1791
tcKeyReq->setAIInTcKeyReq (reqInfo_Start, 5);
1792
tcKeyReq->setAbortOption (reqInfo_Start, TcKeyReq::AbortOnError);
1794
/* KEY LENGTH = 1, ATTRINFO LENGTH IN TCKEYREQ = 5 */
1796
const UintR guard0 = ckey + (RowsPerCommit - 1);
1797
for (Tmp = ckey; Tmp <= guard0; Tmp++) {
1798
UintR reqInfo = reqInfo_Start;
1799
if (Tmp == ckey) { // First iteration, Set start flag
1801
tcKeyReq->setStartFlag(reqInfo, 1);
1803
if (Tmp == guard0) { // Last iteration, Set commit flag
1805
tcKeyReq->setCommitFlag(reqInfo, 1);
1806
tcKeyReq->setExecuteFlag(reqInfo, 1);
1808
if (ctransidPhase == ZTRUE) {
1817
tcKeyReq->apiConnectPtr = ctcConnectionP;
1818
tcKeyReq->attrLen = 5;
1819
tcKeyReq->tableId = g_sysTable_SYSTAB_0.tableId;
1820
tcKeyReq->requestInfo = reqInfo;
1821
tcKeyReq->tableSchemaVersion = ZSYSTAB_VERSION;
1822
tcKeyReq->transId1 = 0;
1823
tcKeyReq->transId2 = ckey;
1825
//-------------------------------------------------------------
1826
// There is no optional part in this TCKEYREQ. There is one
1827
// key word and five ATTRINFO words.
1828
//-------------------------------------------------------------
1829
Uint32* tKeyDataPtr = &tcKeyReq->scanInfo;
1830
Uint32* tAIDataPtr = &tKeyDataPtr[1];
1832
tKeyDataPtr[0] = tkey;
1834
AttributeHeader::init(&tAIDataPtr[0], 0, 1 << 2);
1835
tAIDataPtr[1] = tkey;
1836
AttributeHeader::init(&tAIDataPtr[2], 1, 2 << 2);
1837
tAIDataPtr[3] = (tkey << 16);
1839
sendSignal(DBTC_REF, GSN_TCKEYREQ, signal,
1840
TcKeyReq::StaticLength + 6, JBB);
1842
ckey = ckey + RowsPerCommit;
1844
}//Ndbcntr::crSystab7Lab()
1846
/*******************************/
1848
/*******************************/
1849
void Ndbcntr::execTCKEYCONF(Signal* signal)
1851
const TcKeyConf * const keyConf = (TcKeyConf *)&signal->theData[0];
1854
cgciSystab = keyConf->gci;
1855
UintR confInfo = keyConf->confInfo;
1857
if (TcKeyConf::getMarkerFlag(confInfo)){
1858
Uint32 transId1 = keyConf->transId1;
1859
Uint32 transId2 = keyConf->transId2;
1860
signal->theData[0] = transId1;
1861
signal->theData[1] = transId2;
1862
sendSignal(DBTC_REF, GSN_TC_COMMIT_ACK, signal, 2, JBB);
1865
cresponses = cresponses + TcKeyConf::getNoOfOperations(confInfo);
1866
if (TcKeyConf::getCommitFlag(confInfo)){
1868
ndbrequire(cresponses == RowsPerCommit);
1870
crSystab8Lab(signal);
1874
}//Ndbcntr::tckeyConfLab()
1876
void Ndbcntr::crSystab8Lab(Signal* signal)
1878
if (ckey < ZSIZE_SYSTAB) {
1880
crSystab7Lab(signal);
1882
} else if (ctransidPhase == ZTRUE) {
1885
ctransidPhase = ZFALSE;
1886
// skip 2nd loop - tupleid sequence now created on first use
1888
signal->theData[0] = ctcConnectionP;
1889
signal->theData[1] = reference();
1890
signal->theData[2] = 0;
1891
sendSignal(DBTC_REF, GSN_TCRELEASEREQ, signal, 2, JBB);
1893
}//Ndbcntr::crSystab8Lab()
1895
/*******************************/
1897
/*******************************/
1898
void Ndbcntr::execTCRELEASECONF(Signal* signal)
1901
waitpoint52Lab(signal);
1903
}//Ndbcntr::execTCRELEASECONF()
1905
void Ndbcntr::crSystab9Lab(Signal* signal)
1907
signal->theData[1] = reference();
1908
sendSignalWithDelay(DBDIH_REF, GSN_GETGCIREQ, signal, 100, 2);
1910
}//Ndbcntr::crSystab9Lab()
1912
/*******************************/
1914
/*******************************/
1915
void Ndbcntr::execGETGCICONF(Signal* signal)
1920
if (signal->theData[1] < cgciSystab) {
1922
/*--------------------------------------*/
1923
/* MAKE SURE THAT THE SYSTABLE IS */
1924
/* NOW SAFE ON DISK */
1925
/*--------------------------------------*/
1926
crSystab9Lab(signal);
1930
waitpoint52Lab(signal);
1932
}//Ndbcntr::execGETGCICONF()
1934
void Ndbcntr::execTCKEYREF(Signal* signal)
1937
systemErrorLab(signal, __LINE__);
1939
}//Ndbcntr::execTCKEYREF()
1941
void Ndbcntr::execTCROLLBACKREP(Signal* signal)
1944
systemErrorLab(signal, __LINE__);
1946
}//Ndbcntr::execTCROLLBACKREP()
1948
void Ndbcntr::execTCRELEASEREF(Signal* signal)
1951
systemErrorLab(signal, __LINE__);
1953
}//Ndbcntr::execTCRELEASEREF()
1955
void Ndbcntr::execTCSEIZEREF(Signal* signal)
1958
systemErrorLab(signal, __LINE__);
1960
}//Ndbcntr::execTCSEIZEREF()
1963
/*---------------------------------------------------------------------------*/
1964
/*INITIALIZE VARIABLES AND RECORDS */
1965
/*---------------------------------------------------------------------------*/
1966
void Ndbcntr::initData(Signal* signal)
1972
}//Ndbcntr::initData()
1975
/*---------------------------------------------------------------------------*/
1976
/*RESET VARIABLES USED DURING THE START */
1977
/*---------------------------------------------------------------------------*/
1978
void Ndbcntr::resetStartVariables(Signal* signal)
1981
cnoWaitrep6 = cnoWaitrep7 = 0;
1982
}//Ndbcntr::resetStartVariables()
1985
/*---------------------------------------------------------------------------*/
1987
// INPUT CNDB_BLOCKS_COUNT
1988
/*---------------------------------------------------------------------------*/
1989
void Ndbcntr::sendNdbSttor(Signal* signal)
1991
NdbBlocksRecPtr ndbBlocksPtr;
1993
ndbBlocksPtr.i = cndbBlocksCount;
1994
ptrCheckGuard(ndbBlocksPtr, ZSIZE_NDB_BLOCKS_REC, ndbBlocksRec);
1996
NdbSttor * const req = (NdbSttor*)signal->getDataPtrSend();
1997
req->senderRef = reference();
1998
req->nodeId = getOwnNodeId();
1999
req->internalStartPhase = cinternalStartphase;
2000
req->typeOfStart = ctypeOfStart;
2001
req->masterNodeId = cmasterNodeId;
2003
for (int i = 0; i < 16; i++) {
2005
req->config[i] = 0x88776655;
2006
//cfgBlockPtr.p->cfgData[i];
2009
//#define MAX_STARTPHASE 2
2011
ndbout_c("sending NDB_STTOR(%d) to %s",
2012
cinternalStartphase,
2013
getBlockName( refToBlock(ndbBlocksPtr.p->blockref)));
2015
sendSignal(ndbBlocksPtr.p->blockref, GSN_NDB_STTOR, signal, 22, JBB);
2017
}//Ndbcntr::sendNdbSttor()
2019
/*---------------------------------------------------------------------------*/
2020
// JUST SEND THE SIGNAL
2021
/*---------------------------------------------------------------------------*/
2022
void Ndbcntr::sendSttorry(Signal* signal)
2024
signal->theData[3] = ZSTART_PHASE_1;
2025
signal->theData[4] = ZSTART_PHASE_2;
2026
signal->theData[5] = ZSTART_PHASE_3;
2027
signal->theData[6] = ZSTART_PHASE_4;
2028
signal->theData[7] = ZSTART_PHASE_5;
2029
signal->theData[8] = ZSTART_PHASE_6;
2030
// skip simulated phase 7
2031
signal->theData[9] = ZSTART_PHASE_8;
2032
signal->theData[10] = ZSTART_PHASE_9;
2033
signal->theData[11] = ZSTART_PHASE_END;
2034
sendSignal(NDBCNTR_REF, GSN_STTORRY, signal, 12, JBB);
2035
}//Ndbcntr::sendSttorry()
2038
Ndbcntr::execDUMP_STATE_ORD(Signal* signal)
2040
DumpStateOrd * const & dumpState = (DumpStateOrd *)&signal->theData[0];
2041
Uint32 arg = dumpState->args[0];
2044
infoEvent("Cntr: cstartPhase = %d, cinternalStartphase = %d, block = %d",
2045
cstartPhase, cinternalStartphase, cndbBlocksCount);
2046
infoEvent("Cntr: cmasterNodeId = %d", cmasterNodeId);
2049
if (arg == DumpStateOrd::NdbcntrTestStopOnError){
2050
if (m_ctx.m_config.stopOnError() == true)
2051
((Configuration&)m_ctx.m_config).stopOnError(false);
2053
const BlockReference tblockref = calcNdbCntrBlockRef(getOwnNodeId());
2055
SystemError * const sysErr = (SystemError*)&signal->theData[0];
2056
sysErr->errorCode = SystemError::TestStopOnError;
2057
sysErr->errorRef = reference();
2058
sendSignal(tblockref, GSN_SYSTEM_ERROR, signal,
2059
SystemError::SignalLength, JBA);
2062
if (arg == DumpStateOrd::NdbcntrStopNodes)
2064
NdbNodeBitmask mask;
2065
for(Uint32 i = 1; i<signal->getLength(); i++)
2066
mask.set(signal->theData[i]);
2068
StopReq* req = (StopReq*)signal->getDataPtrSend();
2069
req->senderRef = RNIL;
2070
req->senderData = 123;
2071
req->requestInfo = 0;
2072
req->singleuser = 0;
2073
req->singleUserApi = 0;
2074
mask.copyto(NdbNodeBitmask::Size, req->nodes);
2075
StopReq::setPerformRestart(req->requestInfo, 1);
2076
StopReq::setNoStart(req->requestInfo, 1);
2077
StopReq::setStopNodes(req->requestInfo, 1);
2078
StopReq::setStopAbort(req->requestInfo, 1);
2080
sendSignal(reference(), GSN_STOP_REQ, signal,
2081
StopReq::SignalLength, JBB);
2085
}//Ndbcntr::execDUMP_STATE_ORD()
2087
void Ndbcntr::updateNodeState(Signal* signal, const NodeState& newState) const{
2088
NodeStateRep * const stateRep = (NodeStateRep *)&signal->theData[0];
2090
if (newState.startLevel == NodeState::SL_STARTED)
2092
CRASH_INSERTION(1000);
2095
stateRep->nodeState = newState;
2096
stateRep->nodeState.masterNodeId = cmasterNodeId;
2097
stateRep->nodeState.setNodeGroup(c_nodeGroup);
2099
for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
2100
sendSignal(ALL_BLOCKS[i].Ref, GSN_NODE_STATE_REP, signal,
2101
NodeStateRep::SignalLength, JBB);
2106
Ndbcntr::execRESUME_REQ(Signal* signal){
2107
//ResumeReq * const req = (ResumeReq *)&signal->theData[0];
2108
//ResumeRef * const ref = (ResumeRef *)&signal->theData[0];
2112
signal->theData[0] = NDB_LE_SingleUser;
2113
signal->theData[1] = 2;
2114
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
2116
//Uint32 senderData = req->senderData;
2117
//BlockReference senderRef = req->senderRef;
2118
NodeState newState(NodeState::SL_STARTED);
2119
updateNodeState(signal, newState);
2120
c_stopRec.stopReq.senderRef=0;
2124
Ndbcntr::execSTOP_REQ(Signal* signal){
2125
StopReq * const req = (StopReq *)&signal->theData[0];
2126
StopRef * const ref = (StopRef *)&signal->theData[0];
2127
Uint32 singleuser = req->singleuser;
2129
Uint32 senderData = req->senderData;
2130
BlockReference senderRef = req->senderRef;
2131
bool abort = StopReq::getStopAbort(req->requestInfo);
2132
bool stopnodes = StopReq::getStopNodes(req->requestInfo);
2135
(getNodeState().startLevel < NodeState::SL_STARTED ||
2136
(abort && !stopnodes)))
2139
* Node is not started yet
2141
* So stop it quickly
2144
const Uint32 reqInfo = req->requestInfo;
2145
if(StopReq::getPerformRestart(reqInfo)){
2147
StartOrd * startOrd = (StartOrd *)&signal->theData[0];
2148
startOrd->restartInfo = reqInfo;
2149
sendSignal(CMVMI_REF, GSN_START_ORD, signal, 1, JBA);
2152
sendSignal(CMVMI_REF, GSN_STOP_ORD, signal, 1, JBA);
2157
if(c_stopRec.stopReq.senderRef != 0 ||
2158
(cmasterNodeId == getOwnNodeId() && !c_start.m_starting.isclear()))
2161
* Requested a system shutdown
2163
if(!singleuser && StopReq::getSystemStop(req->requestInfo)){
2165
sendSignalWithDelay(reference(), GSN_STOP_REQ, signal, 100,
2166
StopReq::SignalLength);
2171
* Requested a node shutdown
2173
if(c_stopRec.stopReq.senderRef &&
2174
StopReq::getSystemStop(c_stopRec.stopReq.requestInfo))
2175
ref->errorCode = StopRef::SystemShutdownInProgress;
2177
ref->errorCode = StopRef::NodeShutdownInProgress;
2178
ref->senderData = senderData;
2179
ref->masterNodeId = cmasterNodeId;
2181
if (senderRef != RNIL)
2182
sendSignal(senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
2186
if (stopnodes && !abort)
2189
ref->errorCode = StopRef::UnsupportedNodeShutdown;
2190
ref->senderData = senderData;
2191
ref->masterNodeId = cmasterNodeId;
2192
if (senderRef != RNIL)
2193
sendSignal(senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
2197
if (stopnodes && cmasterNodeId != getOwnNodeId())
2200
ref->errorCode = StopRef::MultiNodeShutdownNotMaster;
2201
ref->senderData = senderData;
2202
ref->masterNodeId = cmasterNodeId;
2203
if (senderRef != RNIL)
2204
sendSignal(senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
2208
c_stopRec.stopReq = * req;
2209
c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
2215
if(!c_stopRec.checkNodeFail(signal))
2222
NdbNodeBitmask mask;
2223
mask.assign(NdbNodeBitmask::Size, c_stopRec.stopReq.nodes);
2224
infoEvent("Initiating shutdown abort of %s", mask.getText(buf));
2225
ndbout_c("Initiating shutdown abort of %s", mask.getText(buf));
2227
WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
2228
req->senderRef = reference();
2229
req->senderData = StopRecord::SR_BLOCK_GCP_START_GCP;
2230
req->requestType = WaitGCPReq::BlockStartGcp;
2231
sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal,
2232
WaitGCPReq::SignalLength, JBB);
2235
else if(!singleuser)
2237
if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo))
2240
if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo))
2242
((Configuration&)m_ctx.m_config).stopOnError(false);
2245
if(!c_stopRec.checkNodeFail(signal))
2250
signal->theData[0] = NDB_LE_NDBStopStarted;
2251
signal->theData[1] = StopReq::getSystemStop(c_stopRec.stopReq.requestInfo) ? 1 : 0;
2252
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
2256
signal->theData[0] = NDB_LE_SingleUser;
2257
signal->theData[1] = 0;
2258
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
2261
NodeState newState(NodeState::SL_STOPPING_1,
2262
StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
2265
newState.setSingleUser(true);
2266
newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi);
2268
updateNodeState(signal, newState);
2269
signal->theData[0] = ZSHUTDOWN;
2270
sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
2274
Ndbcntr::StopRecord::checkTimeout(Signal* signal){
2277
if(!cntr.getNodeState().getSingleUserMode())
2278
if(!checkNodeFail(signal)){
2283
switch(cntr.getNodeState().startLevel){
2284
case NodeState::SL_STOPPING_1:
2285
checkApiTimeout(signal);
2287
case NodeState::SL_STOPPING_2:
2288
checkTcTimeout(signal);
2290
case NodeState::SL_STOPPING_3:
2291
checkLqhTimeout_1(signal);
2293
case NodeState::SL_STOPPING_4:
2294
checkLqhTimeout_2(signal);
2296
case NodeState::SL_SINGLEUSER:
2304
Ndbcntr::StopRecord::checkNodeFail(Signal* signal){
2306
if(StopReq::getSystemStop(stopReq.requestInfo)){
2312
* Check if I can survive me stopping
2314
NodeBitmask ndbMask;
2315
ndbMask.assign(cntr.c_startedNodes);
2317
if (StopReq::getStopNodes(stopReq.requestInfo))
2320
tmp.assign(NdbNodeBitmask::Size, stopReq.nodes);
2322
NdbNodeBitmask ndbStopNodes;
2323
ndbStopNodes.assign(NdbNodeBitmask::Size, stopReq.nodes);
2324
ndbStopNodes.bitAND(ndbMask);
2325
ndbStopNodes.copyto(NdbNodeBitmask::Size, stopReq.nodes);
2327
ndbMask.bitANDC(tmp);
2329
bool allNodesStopped = true;
2331
for( i = 0; i < (int) NdbNodeBitmask::Size; i++ ){
2332
if ( stopReq.nodes[i] != 0 ){
2333
allNodesStopped = false;
2338
if ( allNodesStopped ) {
2339
StopConf * const stopConf = (StopConf *)&signal->theData[0];
2340
stopConf->senderData = stopReq.senderData;
2341
stopConf->nodeState = (Uint32) NodeState::SL_NOTHING;
2342
cntr.sendSignal(stopReq.senderRef, GSN_STOP_CONF, signal,
2343
StopConf::SignalLength, JBB);
2344
stopReq.senderRef = 0;
2351
ndbMask.clear(cntr.getOwnNodeId());
2354
CheckNodeGroups* sd = (CheckNodeGroups*)&signal->theData[0];
2355
sd->blockRef = cntr.reference();
2356
sd->requestType = CheckNodeGroups::Direct | CheckNodeGroups::ArbitCheck;
2358
cntr.EXECUTE_DIRECT(DBDIH, GSN_CHECKNODEGROUPSREQ, signal,
2359
CheckNodeGroups::SignalLength);
2361
switch (sd->output) {
2362
case CheckNodeGroups::Win:
2363
case CheckNodeGroups::Partitioning:
2368
StopRef * const ref = (StopRef *)&signal->theData[0];
2370
ref->senderData = stopReq.senderData;
2371
ref->errorCode = StopRef::NodeShutdownWouldCauseSystemCrash;
2372
ref->masterNodeId = cntr.cmasterNodeId;
2374
const BlockReference bref = stopReq.senderRef;
2376
cntr.sendSignal(bref, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
2378
stopReq.senderRef = 0;
2380
if (cntr.getNodeState().startLevel != NodeState::SL_SINGLEUSER)
2382
NodeState newState(NodeState::SL_STARTED);
2383
cntr.updateNodeState(signal, newState);
2386
signal->theData[0] = NDB_LE_NDBStopAborted;
2387
cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB);
2393
Ndbcntr::StopRecord::checkApiTimeout(Signal* signal){
2394
const Int32 timeout = stopReq.apiTimeout;
2395
const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
2396
const NDB_TICKS now = NdbTick_CurrentMillisecond();
2397
if((timeout >= 0 && now >= alarm)){
2398
// || checkWithApiInSomeMagicWay)
2400
NodeState newState(NodeState::SL_STOPPING_2,
2401
StopReq::getSystemStop(stopReq.requestInfo));
2402
if(stopReq.singleuser) {
2403
newState.setSingleUser(true);
2404
newState.setSingleUserApi(stopReq.singleUserApi);
2406
cntr.updateNodeState(signal, newState);
2408
stopInitiatedTime = now;
2411
signal->theData[0] = ZSHUTDOWN;
2412
cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
2416
Ndbcntr::StopRecord::checkTcTimeout(Signal* signal){
2417
const Int32 timeout = stopReq.transactionTimeout;
2418
const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
2419
const NDB_TICKS now = NdbTick_CurrentMillisecond();
2420
if((timeout >= 0 && now >= alarm)){
2421
// || checkWithTcInSomeMagicWay)
2423
if(stopReq.getSystemStop(stopReq.requestInfo) || stopReq.singleuser){
2425
if(stopReq.singleuser)
2428
AbortAllReq * req = (AbortAllReq*)&signal->theData[0];
2429
req->senderRef = cntr.reference();
2430
req->senderData = 12;
2431
cntr.sendSignal(DBTC_REF, GSN_ABORT_ALL_REQ, signal,
2432
AbortAllReq::SignalLength, JBB);
2436
WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
2437
req->senderRef = cntr.reference();
2438
req->senderData = StopRecord::SR_CLUSTER_SHUTDOWN;
2439
req->requestType = WaitGCPReq::CompleteForceStart;
2440
cntr.sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal,
2441
WaitGCPReq::SignalLength, JBB);
2445
StopPermReq * req = (StopPermReq*)&signal->theData[0];
2446
req->senderRef = cntr.reference();
2447
req->senderData = 12;
2448
cntr.sendSignal(DBDIH_REF, GSN_STOP_PERM_REQ, signal,
2449
StopPermReq::SignalLength, JBB);
2453
signal->theData[0] = ZSHUTDOWN;
2454
cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
2457
void Ndbcntr::execSTOP_PERM_REF(Signal* signal){
2458
//StopPermRef* const ref = (StopPermRef*)&signal->theData[0];
2462
signal->theData[0] = ZSHUTDOWN;
2463
sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
2466
void Ndbcntr::execSTOP_PERM_CONF(Signal* signal){
2469
AbortAllReq * req = (AbortAllReq*)&signal->theData[0];
2470
req->senderRef = reference();
2471
req->senderData = 12;
2472
sendSignal(DBTC_REF, GSN_ABORT_ALL_REQ, signal,
2473
AbortAllReq::SignalLength, JBB);
2476
void Ndbcntr::execABORT_ALL_CONF(Signal* signal){
2478
if(c_stopRec.stopReq.singleuser) {
2481
NodeState newState(NodeState::SL_SINGLEUSER);
2482
newState.setSingleUser(true);
2483
newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi);
2484
updateNodeState(signal, newState);
2485
c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
2487
StopConf * const stopConf = (StopConf *)&signal->theData[0];
2488
stopConf->senderData = c_stopRec.stopReq.senderData;
2489
stopConf->nodeState = (Uint32) NodeState::SL_SINGLEUSER;
2490
sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_CONF, signal, StopConf::SignalLength, JBB);
2492
c_stopRec.stopReq.senderRef = 0; // the command is done
2494
signal->theData[0] = NDB_LE_SingleUser;
2495
signal->theData[1] = 1;
2496
signal->theData[2] = c_stopRec.stopReq.singleUserApi;
2497
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
2502
NodeState newState(NodeState::SL_STOPPING_3,
2503
StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
2504
updateNodeState(signal, newState);
2506
c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
2508
signal->theData[0] = ZSHUTDOWN;
2509
sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
2513
void Ndbcntr::execABORT_ALL_REF(Signal* signal){
2516
StopRef * const stopRef = (StopRef *)&signal->theData[0];
2517
stopRef->senderData = c_stopRec.stopReq.senderData;
2518
stopRef->errorCode = StopRef::TransactionAbortFailed;
2519
stopRef->masterNodeId = cmasterNodeId;
2520
sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
2524
Ndbcntr::StopRecord::checkLqhTimeout_1(Signal* signal){
2525
const Int32 timeout = stopReq.readOperationTimeout;
2526
const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
2527
const NDB_TICKS now = NdbTick_CurrentMillisecond();
2529
if((timeout >= 0 && now >= alarm)){
2530
// || checkWithLqhInSomeMagicWay)
2533
ChangeNodeStateReq * req = (ChangeNodeStateReq*)&signal->theData[0];
2535
NodeState newState(NodeState::SL_STOPPING_4,
2536
StopReq::getSystemStop(stopReq.requestInfo));
2537
req->nodeState = newState;
2538
req->senderRef = cntr.reference();
2539
req->senderData = 12;
2540
cntr.sendSignal(DBLQH_REF, GSN_CHANGE_NODE_STATE_REQ, signal, 2, JBB);
2543
signal->theData[0] = ZSHUTDOWN;
2544
cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
2547
void Ndbcntr::execCHANGE_NODE_STATE_CONF(Signal* signal){
2549
signal->theData[0] = reference();
2550
signal->theData[1] = 12;
2551
sendSignal(DBDIH_REF, GSN_STOP_ME_REQ, signal, 2, JBB);
2554
void Ndbcntr::execSTOP_ME_REF(Signal* signal){
2560
void Ndbcntr::execSTOP_ME_CONF(Signal* signal){
2563
NodeState newState(NodeState::SL_STOPPING_4,
2564
StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
2565
updateNodeState(signal, newState);
2567
c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
2568
signal->theData[0] = ZSHUTDOWN;
2569
sendSignalWithDelay(reference(), GSN_CONTINUEB, signal, 100, 1);
2573
Ndbcntr::StopRecord::checkLqhTimeout_2(Signal* signal){
2574
const Int32 timeout = stopReq.operationTimeout;
2575
const NDB_TICKS alarm = stopInitiatedTime + (NDB_TICKS)timeout;
2576
const NDB_TICKS now = NdbTick_CurrentMillisecond();
2578
if((timeout >= 0 && now >= alarm)){
2579
// || checkWithLqhInSomeMagicWay)
2581
if(StopReq::getPerformRestart(stopReq.requestInfo)){
2583
StartOrd * startOrd = (StartOrd *)&signal->theData[0];
2584
startOrd->restartInfo = stopReq.requestInfo;
2585
cntr.sendSignal(CMVMI_REF, GSN_START_ORD, signal, 2, JBA);
2588
cntr.sendSignal(CMVMI_REF, GSN_STOP_ORD, signal, 1, JBA);
2592
signal->theData[0] = ZSHUTDOWN;
2593
cntr.sendSignalWithDelay(cntr.reference(), GSN_CONTINUEB, signal, 100, 1);
2596
void Ndbcntr::execWAIT_GCP_REF(Signal* signal){
2599
//WaitGCPRef* const ref = (WaitGCPRef*)&signal->theData[0];
2601
WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
2602
req->senderRef = reference();
2603
req->senderData = StopRecord::SR_CLUSTER_SHUTDOWN;
2604
req->requestType = WaitGCPReq::CompleteForceStart;
2605
sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal,
2606
WaitGCPReq::SignalLength, JBB);
2609
void Ndbcntr::execWAIT_GCP_CONF(Signal* signal){
2612
WaitGCPConf* conf = (WaitGCPConf*)signal->getDataPtr();
2614
switch(conf->senderData){
2615
case StopRecord::SR_BLOCK_GCP_START_GCP:
2621
if(!c_stopRec.checkNodeFail(signal))
2627
WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
2628
req->senderRef = reference();
2629
req->senderData = StopRecord::SR_WAIT_COMPLETE_GCP;
2630
req->requestType = WaitGCPReq::CompleteIfRunning;
2632
sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal,
2633
WaitGCPReq::SignalLength, JBB);
2636
case StopRecord::SR_UNBLOCK_GCP_START_GCP:
2641
case StopRecord::SR_WAIT_COMPLETE_GCP:
2644
if(!c_stopRec.checkNodeFail(signal))
2651
tmp.assign(NdbNodeBitmask::Size, c_stopRec.stopReq.nodes);
2652
c_stopRec.m_stop_req_counter = tmp;
2653
NodeReceiverGroup rg(QMGR, tmp);
2654
StopReq * stopReq = (StopReq *)&signal->theData[0];
2655
* stopReq = c_stopRec.stopReq;
2656
stopReq->senderRef = reference();
2657
sendSignal(rg, GSN_STOP_REQ, signal, StopReq::SignalLength, JBA);
2658
c_stopRec.m_state = StopRecord::SR_QMGR_STOP_REQ;
2661
case StopRecord::SR_CLUSTER_SHUTDOWN:
2669
ndbrequire(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
2670
NodeState newState(NodeState::SL_STOPPING_3, true);
2673
* Inform QMGR so that arbitrator won't kill us
2675
NodeStateRep * rep = (NodeStateRep *)&signal->theData[0];
2676
rep->nodeState = newState;
2677
rep->nodeState.masterNodeId = cmasterNodeId;
2678
rep->nodeState.setNodeGroup(c_nodeGroup);
2679
EXECUTE_DIRECT(QMGR, GSN_NODE_STATE_REP, signal,
2680
NodeStateRep::SignalLength);
2682
if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo)){
2684
StartOrd * startOrd = (StartOrd *)&signal->theData[0];
2685
startOrd->restartInfo = c_stopRec.stopReq.requestInfo;
2686
sendSignalWithDelay(CMVMI_REF, GSN_START_ORD, signal, 500,
2687
StartOrd::SignalLength);
2690
sendSignalWithDelay(CMVMI_REF, GSN_STOP_ORD, signal, 500, 1);
2696
WaitGCPReq * req = (WaitGCPReq*)&signal->theData[0];
2697
req->senderRef = reference();
2698
req->senderData = StopRecord::SR_UNBLOCK_GCP_START_GCP;
2699
req->requestType = WaitGCPReq::UnblockStartGcp;
2700
sendSignal(DBDIH_REF, GSN_WAIT_GCP_REQ, signal,
2701
WaitGCPReq::SignalLength, JBB);
2705
Ndbcntr::execSTOP_CONF(Signal* signal)
2708
StopConf *conf = (StopConf*)signal->getDataPtr();
2709
ndbrequire(c_stopRec.m_state == StopRecord::SR_QMGR_STOP_REQ);
2710
c_stopRec.m_stop_req_counter.clearWaitingFor(conf->nodeId);
2711
if (c_stopRec.m_stop_req_counter.done())
2714
NdbNodeBitmask mask;
2715
mask.assign(NdbNodeBitmask::Size, c_stopRec.stopReq.nodes);
2716
infoEvent("Stopping of %s", mask.getText(buf));
2717
ndbout_c("Stopping of %s", mask.getText(buf));
2722
FailRep * const failRep = (FailRep *)&signal->theData[0];
2723
failRep->failCause = FailRep::ZMULTI_NODE_SHUTDOWN;
2724
NodeReceiverGroup rg(QMGR, c_clusterNodes);
2726
while ((nodeId = NdbNodeBitmask::find(c_stopRec.stopReq.nodes, nodeId+1))
2727
!= NdbNodeBitmask::NotFound)
2729
failRep->failNodeId = nodeId;
2730
sendSignal(rg, GSN_FAIL_REP, signal, FailRep::SignalLength, JBA);
2732
c_stopRec.m_state = StopRecord::SR_WAIT_NODE_FAILURES;
2737
void Ndbcntr::execSTTORRY(Signal* signal){
2739
c_missra.execSTTORRY(signal);
2742
void Ndbcntr::execREAD_CONFIG_CONF(Signal* signal){
2744
c_missra.execREAD_CONFIG_CONF(signal);
2747
void Ndbcntr::execSTART_ORD(Signal* signal){
2749
c_missra.execSTART_ORD(signal);
2756
Ndbcntr::clearFilesystem(Signal* signal)
2758
const Uint32 lcp = c_fsRemoveCount >= CLEAR_DX;
2760
FsRemoveReq * req = (FsRemoveReq *)signal->getDataPtrSend();
2761
req->userReference = reference();
2762
req->userPointer = 0;
2764
req->ownDirectory = 1;
2768
FsOpenReq::setVersion(req->fileNumber, 3);
2769
FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_CTL); // Can by any...
2770
FsOpenReq::v1_setDisk(req->fileNumber, c_fsRemoveCount);
2774
FsOpenReq::setVersion(req->fileNumber, 5);
2775
FsOpenReq::setSuffix(req->fileNumber, FsOpenReq::S_DATA);
2776
FsOpenReq::v5_setLcpNo(req->fileNumber, c_fsRemoveCount - CLEAR_DX);
2777
FsOpenReq::v5_setTableId(req->fileNumber, 0);
2778
FsOpenReq::v5_setFragmentId(req->fileNumber, 0);
2780
sendSignal(NDBFS_REF, GSN_FSREMOVEREQ, signal,
2781
FsRemoveReq::SignalLength, JBA);
2786
Ndbcntr::execFSREMOVECONF(Signal* signal){
2788
if(c_fsRemoveCount == CLEAR_DX + CLEAR_LCP){
2790
sendSttorry(signal);
2793
ndbrequire(c_fsRemoveCount < CLEAR_DX + CLEAR_LCP);
2794
clearFilesystem(signal);
2798
void Ndbcntr::Missra::execSTART_ORD(Signal* signal){
2799
signal->theData[0] = NDB_LE_NDBStartStarted;
2800
signal->theData[1] = NDB_VERSION;
2801
cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
2803
currentBlockIndex = 0;
2804
sendNextREAD_CONFIG_REQ(signal);
2807
void Ndbcntr::Missra::sendNextREAD_CONFIG_REQ(Signal* signal){
2809
if(currentBlockIndex < ALL_BLOCKS_SZ){
2812
ReadConfigReq * req = (ReadConfigReq*)signal->getDataPtrSend();
2813
req->senderData = 0;
2814
req->senderRef = cntr.reference();
2815
req->noOfParameters = 0;
2817
const BlockReference ref = readConfigOrder[currentBlockIndex];
2820
ndbout_c("sending READ_CONFIG_REQ to %s(ref=%x index=%d)",
2821
getBlockName( refToBlock(ref)),
2826
cntr.sendSignal(ref, GSN_READ_CONFIG_REQ, signal,
2827
ReadConfigReq::SignalLength, JBB);
2834
currentStartPhase = 0;
2835
for(Uint32 i = 0; i<ALL_BLOCKS_SZ; i++){
2836
if(ALL_BLOCKS[i].NextSP < currentStartPhase)
2837
currentStartPhase = ALL_BLOCKS[i].NextSP;
2840
currentBlockIndex = 0;
2841
sendNextSTTOR(signal);
2844
void Ndbcntr::Missra::execREAD_CONFIG_CONF(Signal* signal){
2845
const ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtr();
2847
const Uint32 ref = conf->senderRef;
2848
ndbrequire(refToBlock(readConfigOrder[currentBlockIndex])
2849
== refToBlock(ref));
2851
currentBlockIndex++;
2852
sendNextREAD_CONFIG_REQ(signal);
2855
void Ndbcntr::Missra::execSTTORRY(Signal* signal){
2856
const BlockReference ref = signal->senderBlockRef();
2857
ndbrequire(refToBlock(ref) == refToBlock(ALL_BLOCKS[currentBlockIndex].Ref));
2860
* Update next start phase
2862
for (Uint32 i = 3; i < 25; i++){
2864
if (signal->theData[i] > currentStartPhase){
2866
ALL_BLOCKS[currentBlockIndex].NextSP = signal->theData[i];
2871
currentBlockIndex++;
2872
sendNextSTTOR(signal);
2875
void Ndbcntr::Missra::sendNextSTTOR(Signal* signal){
2877
for(; currentStartPhase < 255 ;
2878
currentStartPhase++, g_currentStartPhase = currentStartPhase){
2881
const Uint32 start = currentBlockIndex;
2883
if (currentStartPhase == ZSTART_PHASE_6)
2885
// Ndbd has passed the critical startphases.
2886
// Change error handler from "startup" state
2888
ErrorReporter::setErrorHandlerShutdownType();
2891
for(; currentBlockIndex < ALL_BLOCKS_SZ; currentBlockIndex++){
2893
if(ALL_BLOCKS[currentBlockIndex].NextSP == currentStartPhase){
2895
signal->theData[0] = 0;
2896
signal->theData[1] = currentStartPhase;
2897
signal->theData[2] = 0;
2898
signal->theData[3] = 0;
2899
signal->theData[4] = 0;
2900
signal->theData[5] = 0;
2901
signal->theData[6] = 0;
2902
signal->theData[7] = cntr.ctypeOfStart;
2904
const BlockReference ref = ALL_BLOCKS[currentBlockIndex].Ref;
2906
#ifdef MAX_STARTPHASE
2907
ndbrequire(currentStartPhase <= MAX_STARTPHASE);
2911
ndbout_c("sending STTOR(%d) to %s(ref=%x index=%d)",
2913
getBlockName( refToBlock(ref)),
2918
cntr.sendSignal(ref, GSN_STTOR, signal, 8, JBB);
2924
currentBlockIndex = 0;
2926
NodeState newState(NodeState::SL_STARTING, currentStartPhase,
2927
(NodeState::StartType)cntr.ctypeOfStart);
2928
cntr.updateNodeState(signal, newState);
2932
* At least one wanted this start phase, report it
2935
signal->theData[0] = NDB_LE_StartPhaseCompleted;
2936
signal->theData[1] = currentStartPhase;
2937
signal->theData[2] = cntr.ctypeOfStart;
2938
cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
2942
signal->theData[0] = NDB_LE_NDBStartCompleted;
2943
signal->theData[1] = NDB_VERSION;
2944
cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
2946
NodeState newState(NodeState::SL_STARTED);
2947
cntr.updateNodeState(signal, newState);
2952
UpgradeStartup::sendCmAppChg(cntr, signal, 3); //RUN
2954
NdbNodeBitmask nodes = cntr.c_clusterNodes;
2956
while((node = nodes.find(node+1)) != NdbNodeBitmask::NotFound){
2957
if(cntr.getNodeInfo(node).m_version < MAKE_VERSION(3,5,0)){
2962
NodeReceiverGroup rg(NDBCNTR, nodes);
2963
signal->theData[0] = cntr.getOwnNodeId();
2964
cntr.sendSignal(rg, GSN_CNTR_START_REP, signal, 1, JBB);
2968
* Backward compatible code
2971
UpgradeStartup::sendCmAppChg(Ndbcntr& cntr, Signal* signal, Uint32 startLevel){
2973
if(cntr.getNodeInfo(cntr.cmasterNodeId).m_version >= MAKE_VERSION(3,5,0)){
2982
signal->theData[0] = startLevel;
2983
signal->theData[1] = cntr.getOwnNodeId();
2984
signal->theData[2] = 3 | ('N' << 8);
2985
signal->theData[3] = 'D' | ('B' << 8);
2986
signal->theData[4] = 0;
2987
signal->theData[5] = 0;
2988
signal->theData[6] = 0;
2989
signal->theData[7] = 0;
2990
signal->theData[8] = 0;
2991
signal->theData[9] = 0;
2992
signal->theData[10] = 0;
2993
signal->theData[11] = 0;
2995
NdbNodeBitmask nodes = cntr.c_clusterNodes;
2996
nodes.clear(cntr.getOwnNodeId());
2998
while((node = nodes.find(node+1)) != NdbNodeBitmask::NotFound){
2999
if(cntr.getNodeInfo(node).m_version < MAKE_VERSION(3,5,0)){
3000
cntr.sendSignal(cntr.calcQmgrBlockRef(node),
3001
GSN_CM_APPCHG, signal, 12, JBB);
3003
cntr.c_startedNodes.set(node); // Fake started
3009
UpgradeStartup::execCM_APPCHG(SimulatedBlock & block, Signal* signal){
3010
Uint32 state = signal->theData[0];
3011
Uint32 nodeId = signal->theData[1];
3012
if(block.number() == QMGR){
3013
Ndbcntr& cntr = * (Ndbcntr*)globalData.getBlock(CNTR);
3020
cntr.c_startedNodes.set(nodeId);
3022
Uint32 recv = cntr.c_startedNodes.count();
3023
Uint32 cnt = cntr.c_clusterNodes.count();
3024
if(recv + 1 == cnt){ //+1 == own node
3028
sendCntrMasterReq(cntr, signal, 0);
3033
block.progError(__LINE__,NDBD_EXIT_NDBREQUIRE,
3034
"UpgradeStartup::execCM_APPCHG");
3038
UpgradeStartup::sendCntrMasterReq(Ndbcntr& cntr, Signal* signal, Uint32 n){
3039
Uint32 node = cntr.c_startedNodes.find(n);
3040
if(node != NdbNodeBitmask::NotFound &&
3041
(node == cntr.getOwnNodeId() ||
3042
cntr.getNodeInfo(node).m_version >= MAKE_VERSION(3,5,0))){
3043
node = cntr.c_startedNodes.find(node+1);
3046
if(node == NdbNodeBitmask::NotFound){
3047
cntr.progError(__LINE__,NDBD_EXIT_NDBREQUIRE,
3048
"UpgradeStartup::sendCntrMasterReq "
3049
"NdbNodeBitmask::NotFound");
3052
CntrMasterReq * const cntrMasterReq = (CntrMasterReq*)&signal->theData[0];
3053
cntr.c_clusterNodes.copyto(NdbNodeBitmask::Size, cntrMasterReq->theNodes);
3054
NdbNodeBitmask::clear(cntrMasterReq->theNodes, cntr.getOwnNodeId());
3055
cntrMasterReq->userBlockRef = 0;
3056
cntrMasterReq->userNodeId = cntr.getOwnNodeId();
3057
cntrMasterReq->typeOfStart = NodeState::ST_INITIAL_NODE_RESTART;
3058
cntrMasterReq->noRestartNodes = cntr.c_clusterNodes.count() - 1;
3059
cntr.sendSignal(cntr.calcNdbCntrBlockRef(node), GSN_CNTR_MASTERREQ,
3060
signal, CntrMasterReq::SignalLength, JBB);
3064
UpgradeStartup::execCNTR_MASTER_REPLY(SimulatedBlock & block, Signal* signal){
3065
Uint32 gsn = signal->header.theVerId_signalNumber;
3066
Uint32 node = refToNode(signal->getSendersBlockRef());
3067
if(block.number() == CNTR){
3068
Ndbcntr& cntr = (Ndbcntr&)block;
3070
case GSN_CNTR_MASTERREF:
3071
sendCntrMasterReq(cntr, signal, node + 1);
3074
case GSN_CNTR_MASTERCONF:{
3075
CntrStartConf* conf = (CntrStartConf*)signal->getDataPtrSend();
3077
conf->masterNodeId = node;
3078
conf->noStartNodes = 1;
3079
conf->startType = NodeState::ST_INITIAL_NODE_RESTART;
3082
mask.copyto(NdbNodeBitmask::Size, conf->startedNodes);
3084
mask.set(cntr.getOwnNodeId());
3085
mask.copyto(NdbNodeBitmask::Size, conf->startingNodes);
3086
cntr.execCNTR_START_CONF(signal);
3091
block.progError(__LINE__,NDBD_EXIT_NDBREQUIRE,
3092
"UpgradeStartup::execCNTR_MASTER_REPLY");
added
removed
storage/ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
