Skip to content

M
mariadb
Commit 37230a2a authored by unknown's avatar unknown
Browse files
Options

ndb - wl2610 

  Activly abort transactions (that's affected) during NF
  This removes a lot of bugs that can occur otherwise is using
    high value for TransactionDeadLockTimout


ndb/include/kernel/signaldata/TcContinueB.hpp:
  New continueb for active transaction abort on nf
ndb/src/kernel/blocks/dbtc/Dbtc.hpp:
  Add bitmask of participating nodes to transaction record
  Add bitmask of node fail steps, so that NF_CompleteRep is not sent until all steps has completed
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp:
  Active transaction baortion
parent 3bfaf333
Hide whitespace changes
Inline Side-by-side
Showing with 164 additions and 49 deletions
ndb/include/kernel/signaldata/TcContinueB.hpp
View file @ 37230a2a
......@@ -44,7 +44,8 @@ private:
CHECK_WAIT_DROP_TAB_FAILED_LQH = 16,
TRIGGER_PENDING = 17,
DelayTCKEYCONF = 18
DelayTCKEYCONF = 18,
ZNF_CHECK_TRANSACTIONS = 19
};
};
......
ndb/src/kernel/blocks/dbtc/Dbtc.hpp
View file @ 37230a2a
......@@ -636,6 +636,7 @@ public:
ConnectionState apiConnectstate;
UintR transid[2];
UintR firstTcConnect;
NdbNodeBitmask m_transaction_nodes;
//---------------------------------------------------
// Second 16 byte cache line. Hot variables.
......@@ -941,6 +942,17 @@ public:
UintR noOfWordsTCINDXCONF;
UintR packedWordsTCINDXCONF[30];
BlockReference hostLqhBlockRef;
enum NodeFailBits
{
NF_TAKEOVER = 0x1,
NF_CHECK_SCAN = 0x2,
NF_CHECK_TRANSACTION = 0x4,
NF_CHECK_DROP_TAB = 0x8,
NF_NODE_FAIL_BITS = 0xF // All bits...
};
Uint32 m_nf_bits;
NdbNodeBitmask m_lqh_trans_conf;
}; /* p2c: size = 128 bytes */
typedef Ptr<HostRecord> HostRecordPtr;
......@@ -1578,7 +1590,7 @@ private:
void wrongSchemaVersionErrorLab(Signal* signal);
void noFreeConnectionErrorLab(Signal* signal);
void tckeyreq050Lab(Signal* signal);
void timeOutFoundLab(Signal* signal, UintR anAdd);
void timeOutFoundLab(Signal* signal, UintR anAdd, Uint32 errCode);
void completeTransAtTakeOverLab(Signal* signal, UintR TtakeOverInd);
void completeTransAtTakeOverDoLast(Signal* signal, UintR TtakeOverInd);
void completeTransAtTakeOverDoOne(Signal* signal, UintR TtakeOverInd);
......@@ -1600,6 +1612,9 @@ private:
void checkScanFragList(Signal*, Uint32 failedNodeId, ScanRecord * scanP,
LocalDLList<ScanFragRec>::Head&);
void nodeFailCheckTransactions(Signal*,Uint32 transPtrI,Uint32 failedNodeId);
void checkNodeFailComplete(Signal* signal, Uint32 failedNodeId, Uint32 bit);
// Initialisation
void initData();
void initRecords();
......@@ -1626,6 +1641,7 @@ private:
HostRecord *hostRecord;
HostRecordPtr hostptr;
UintR chostFilesize;
NdbNodeBitmask c_alive_nodes;
GcpRecord *gcpRecord;
GcpRecordPtr gcpPtr;
......
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp
View file @ 37230a2a
......@@ -262,6 +262,10 @@ void Dbtc::execCONTINUEB(Signal* signal)
jam();
checkScanActiveInFailedLqh(signal, Tdata0, Tdata1);
return;
case TcContinueB::ZNF_CHECK_TRANSACTIONS:
jam();
nodeFailCheckTransactions(signal, Tdata0, Tdata1);
return;
case TcContinueB::CHECK_WAIT_DROP_TAB_FAILED_LQH:
jam();
checkWaitDropTabFailedLqh(signal, Tdata0, Tdata1);
......@@ -301,6 +305,7 @@ void Dbtc::execINCL_NODEREQ(Signal* signal)
hostptr.p->hostStatus = HS_ALIVE;
hostptr.p->takeOverStatus = TOS_IDLE;
signal->theData[0] = cownref;
c_alive_nodes.set(hostptr.i);
sendSignal(tblockref, GSN_INCL_NODECONF, signal, 1, JBB);
}
......@@ -487,6 +492,7 @@ Dbtc::checkWaitDropTabFailedLqh(Signal* signal, Uint32 nodeId, Uint32 tableId)
* Finished
*/
jam();
checkNodeFailComplete(signal, nodeId, HostRecord::NF_CHECK_DROP_TAB);
return;
}
......@@ -859,6 +865,7 @@ void Dbtc::execREAD_NODESCONF(Signal* signal)
jam();
con_lineNodes++;
hostptr.p->hostStatus = HS_ALIVE;
c_alive_nodes.set(i);
}//if
}//if
}//for
......@@ -2314,6 +2321,7 @@ void Dbtc::initApiConnectRec(Signal* signal,
regApiPtr->commitAckMarker = RNIL;
regApiPtr->buddyPtr = RNIL;
regApiPtr->currSavePointId = 0;
regApiPtr->m_transaction_nodes.clear();
// Trigger data
releaseFiredTriggerData(&regApiPtr->theFiredTriggers),
// Index data
......@@ -2921,6 +2929,10 @@ void Dbtc::tckeyreq050Lab(Signal* signal)
signal->theData[0] = TdihConnectptr;
signal->theData[1] = Ttableref;
signal->theData[2] = TdistrHashValue;
signal->theData[3] = 0;
signal->theData[4] = 0;
signal->theData[5] = 0;
signal->theData[6] = 0;
/*-------------------------------------------------------------*/
/* FOR EFFICIENCY REASONS WE AVOID THE SIGNAL SENDING HERE AND */
......@@ -3098,6 +3110,7 @@ void Dbtc::sendlqhkeyreq(Signal* signal,
TcConnectRecord * const regTcPtr = tcConnectptr.p;
ApiConnectRecord * const regApiPtr = apiConnectptr.p;
CacheRecord * const regCachePtr = cachePtr.p;
UintR sig0, sig1, sig2, sig3, sig4, sig5, sig6;
#ifdef ERROR_INSERT
if (ERROR_INSERTED(8002)) {
systemErrorLab(signal);
......@@ -3135,6 +3148,9 @@ void Dbtc::sendlqhkeyreq(Signal* signal,
LqhKeyReq::setScanTakeOverFlag(tslrAttrLen, regCachePtr->scanTakeOverInd);
Tdata10 = 0;
sig0 = regCachePtr->opSimple;
sig1 = regTcPtr->operation;
bool simpleRead = (sig1 == ZREAD && sig0 == ZTRUE);
LqhKeyReq::setKeyLen(Tdata10, regCachePtr->keylen);
LqhKeyReq::setLastReplicaNo(Tdata10, regTcPtr->lastReplicaNo);
LqhKeyReq::setLockType(Tdata10, regCachePtr->opLock);
......@@ -3144,8 +3160,8 @@ void Dbtc::sendlqhkeyreq(Signal* signal,
LqhKeyReq::setApplicationAddressFlag(Tdata10, 1);
LqhKeyReq::setDirtyFlag(Tdata10, regTcPtr->dirtyOp);
LqhKeyReq::setInterpretedFlag(Tdata10, regCachePtr->opExec);
LqhKeyReq::setSimpleFlag(Tdata10, regCachePtr->opSimple);
LqhKeyReq::setOperation(Tdata10, regTcPtr->operation);
LqhKeyReq::setSimpleFlag(Tdata10, sig0);
LqhKeyReq::setOperation(Tdata10, sig1);
/* -----------------------------------------------------------------------
* Sequential Number of first LQH = 0, bit 22-23
* IF ATTRIBUTE INFORMATION IS SENT IN TCKEYREQ,
......@@ -3158,18 +3174,16 @@ void Dbtc::sendlqhkeyreq(Signal* signal,
* ----------------------------------------------------------------------- */
//LqhKeyReq::setAPIVersion(Tdata10, regCachePtr->apiVersionNo);
Uint32 commitAckMarker = regTcPtr->commitAckMarker;
const Uint32 noOfLqhs = regTcPtr->noOfNodes;
if(commitAckMarker != RNIL){
jam();
LqhKeyReq::setMarkerFlag(Tdata10, 1);
CommitAckMarker * tmp;
tmp = m_commitAckMarkerHash.getPtr(commitAckMarker);
CommitAckMarker * tmp = m_commitAckMarkerHash.getPtr(commitAckMarker);
/**
* Populate LQH array
*/
const Uint32 noOfLqhs = regTcPtr->noOfNodes;
tmp->noOfLqhs = noOfLqhs;
for(Uint32 i = 0; i<noOfLqhs; i++){
tmp->lqhNodeId[i] = regTcPtr->tcNodedata[i];
......@@ -3180,7 +3194,6 @@ void Dbtc::sendlqhkeyreq(Signal* signal,
/* NO READ LENGTH SENT FROM TC. SEQUENTIAL NUMBER IS 1 AND IT */
/* IS SENT TO A PRIMARY NODE. */
/* ************************************************************> */
UintR sig0, sig1, sig2, sig3, sig4, sig5, sig6;
LqhKeyReq * const lqhKeyReq = (LqhKeyReq *)signal->getDataPtrSend();
......@@ -3204,6 +3217,14 @@ void Dbtc::sendlqhkeyreq(Signal* signal,
sig5 = regTcPtr->clientData;
sig6 = regCachePtr->scanInfo;
if (! simpleRead)
{
regApiPtr->m_transaction_nodes.set(regTcPtr->tcNodedata[0]);
regApiPtr->m_transaction_nodes.set(regTcPtr->tcNodedata[1]);
regApiPtr->m_transaction_nodes.set(regTcPtr->tcNodedata[2]);
regApiPtr->m_transaction_nodes.set(regTcPtr->tcNodedata[3]);
}
lqhKeyReq->tableSchemaVersion = sig0;
lqhKeyReq->fragmentData = sig1;
lqhKeyReq->transId1 = sig2;
......@@ -4587,6 +4608,7 @@ void Dbtc::copyApi(Signal* signal)
UintR TgcpPointer = regTmpApiPtr->gcpPointer;
UintR TgcpFilesize = cgcpFilesize;
UintR TcommitAckMarker = regTmpApiPtr->commitAckMarker;
NdbNodeBitmask Tnodes = regTmpApiPtr->m_transaction_nodes;
GcpRecord *localGcpRecord = gcpRecord;
regApiPtr->ndbapiBlockref = regTmpApiPtr->ndbapiBlockref;
......@@ -4597,6 +4619,7 @@ void Dbtc::copyApi(Signal* signal)
regApiPtr->transid[1] = Ttransid2;
regApiPtr->lqhkeyconfrec = Tlqhkeyconfrec;
regApiPtr->commitAckMarker = TcommitAckMarker;
regApiPtr->m_transaction_nodes = Tnodes;
gcpPtr.i = TgcpPointer;
ptrCheckGuard(gcpPtr, TgcpFilesize, localGcpRecord);
......@@ -4607,6 +4630,7 @@ void Dbtc::copyApi(Signal* signal)
regTmpApiPtr->commitAckMarker = RNIL;
regTmpApiPtr->firstTcConnect = RNIL;
regTmpApiPtr->lastTcConnect = RNIL;
regTmpApiPtr->m_transaction_nodes.clear();
releaseAllSeizedIndexOperations(regTmpApiPtr);
}//Dbtc::copyApi()
......@@ -4865,7 +4889,7 @@ void Dbtc::releaseTransResources(Signal* signal)
TcConnectRecordPtr localTcConnectptr;
UintR TtcConnectFilesize = ctcConnectFilesize;
TcConnectRecord *localTcConnectRecord = tcConnectRecord;
apiConnectptr.p->m_transaction_nodes.clear();
localTcConnectptr.i = apiConnectptr.p->firstTcConnect;
do {
jam();
......@@ -5269,7 +5293,8 @@ void Dbtc::execTC_COMMITREQ(Signal* signal)
break;
case CS_ABORTING:
jam();
errorCode = ZABORTINPROGRESS;
errorCode = regApiPtr->returncode ?
regApiPtr->returncode : ZABORTINPROGRESS;
break;
case CS_START_SCAN:
jam();
......@@ -5808,9 +5833,9 @@ void Dbtc::abort010Lab(Signal* signal)
if (transP->firstTcConnect == RNIL) {
jam();
/*-----------------------------------------------------------------------*/
/* WE HAVE NO PARTICIPANTS IN THE TRANSACTION. */
/*-----------------------------------------------------------------------*/
/*--------------------------------------------------------------------*/
/* WE HAVE NO PARTICIPANTS IN THE TRANSACTION. */
/*--------------------------------------------------------------------*/
releaseAbortResources(signal);
return;
}//if
......@@ -6087,10 +6112,12 @@ void Dbtc::timeOutLoopStartLab(Signal* signal, Uint32 api_con_ptr)
if (api_timer != 0) {
time_out_value= time_out_param + (api_con_ptr & mask_value);
time_passed= tc_timer - api_timer;
if (time_passed > time_out_value) {
if (time_passed > time_out_value)
{
jam();
timeOutFoundLab(signal, api_con_ptr);
return;
timeOutFoundLab(signal, api_con_ptr, ZTIME_OUT_ERROR);
api_con_ptr++;
break;
}
}
}
......@@ -6110,10 +6137,8 @@ void Dbtc::timeOutLoopStartLab(Signal* signal, Uint32 api_con_ptr)
return;
}//Dbtc::timeOutLoopStartLab()
void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr)
void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr, Uint32 errCode)
{
sendContinueTimeOutControl(signal, TapiConPtr + 1);
apiConnectptr.i = TapiConPtr;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
/*------------------------------------------------------------------*/
......@@ -6126,7 +6151,8 @@ void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr)
<< "Time-out in state = " << apiConnectptr.p->apiConnectstate
<< " apiConnectptr.i = " << apiConnectptr.i
<< " - exec: " << apiConnectptr.p->m_exec_flag
<< " - place: " << c_apiConTimer_line[apiConnectptr.i]);
<< " - place: " << c_apiConTimer_line[apiConnectptr.i]
<< " code: " << errCode);
switch (apiConnectptr.p->apiConnectstate) {
case CS_STARTED:
if(apiConnectptr.p->lqhkeyreqrec == apiConnectptr.p->lqhkeyconfrec){
......@@ -6143,7 +6169,7 @@ void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr)
}//if
}
apiConnectptr.p->returnsignal = RS_TCROLLBACKREP;
apiConnectptr.p->returncode = ZTIME_OUT_ERROR;
apiConnectptr.p->returncode = errCode;
abort010Lab(signal);
return;
case CS_RECEIVING:
......@@ -6156,7 +6182,7 @@ void Dbtc::timeOutFoundLab(Signal* signal, Uint32 TapiConPtr)
/* START ABORTING THE TRANSACTION. ALSO START CHECKING THE */
/* REMAINING TRANSACTIONS. */
/*------------------------------------------------------------------*/
terrorCode = ZTIME_OUT_ERROR;
terrorCode = errCode;
abortErrorLab(signal);
return;
case CS_COMMITTING:
......@@ -6820,6 +6846,8 @@ void Dbtc::execNODE_FAILREP(Signal* signal)
/* FAILED. */
/*------------------------------------------------------------*/
hostptr.p->hostStatus = HS_DEAD;
hostptr.p->m_nf_bits = HostRecord::NF_NODE_FAIL_BITS;
c_alive_nodes.clear(hostptr.i);
if (hostptr.p->takeOverStatus == TOS_COMPLETED) {
jam();
......@@ -6832,14 +6860,7 @@ void Dbtc::execNODE_FAILREP(Signal* signal)
/* REMAINING WILL BE RELEASED WHEN THE TRANSACTION THAT */
/* USED THEM IS COMPLETED. */
/*------------------------------------------------------------*/
{
NFCompleteRep * const nfRep = (NFCompleteRep *)&signal->theData[0];
nfRep->blockNo = DBTC;
nfRep->nodeId = cownNodeid;
nfRep->failedNodeId = hostptr.i;
}
sendSignal(cdihblockref, GSN_NF_COMPLETEREP, signal,
NFCompleteRep::SignalLength, JBB);
hostptr.p->m_nf_bits &= ~HostRecord::NF_TAKEOVER;
} else {
ndbrequire(hostptr.p->takeOverStatus == TOS_IDLE);
hostptr.p->takeOverStatus = TOS_NODE_FAILED;
......@@ -6892,16 +6913,9 @@ void Dbtc::execNODE_FAILREP(Signal* signal)
/* MASTER IT MIGHT START A NEW TAKE OVER EVEN AFTER THE */
/* CRASHED NODE HAVE ALREADY RECOVERED. */
/*------------------------------------------------------------*/
for(tmpHostptr.i = 1; tmpHostptr.i < MAX_NDB_NODES;tmpHostptr.i++) {
jam();
ptrAss(tmpHostptr, hostRecord);
if (tmpHostptr.p->hostStatus == HS_ALIVE) {
jam();
tblockref = calcTcBlockRef(tmpHostptr.i);
signal->theData[0] = hostptr.i;
sendSignal(tblockref, GSN_TAKE_OVERTCCONF, signal, 1, JBB);
}//if
}//for
NodeReceiverGroup rg(DBTC, c_alive_nodes);
signal->theData[0] = hostptr.i;
sendSignal(rg, GSN_TAKE_OVERTCCONF, signal, 1, JBB);
}//if
}//if
}//for
......@@ -6939,10 +6953,30 @@ void Dbtc::execNODE_FAILREP(Signal* signal)
/*------------------------------------------------------------*/
checkScanActiveInFailedLqh(signal, 0, hostptr.i);
checkWaitDropTabFailedLqh(signal, hostptr.i, 0); // nodeid, tableid
nodeFailCheckTransactions(signal, 0, hostptr.i);
}//for
}//Dbtc::execNODE_FAILREP()
void
Dbtc::checkNodeFailComplete(Signal* signal,
Uint32 failedNodeId,
Uint32 bit)
{
hostptr.i = failedNodeId;
ptrCheckGuard(hostptr, chostFilesize, hostRecord);
hostptr.p->m_nf_bits &= ~bit;
if (hostptr.p->m_nf_bits == 0)
{
NFCompleteRep * const nfRep = (NFCompleteRep *)&signal->theData[0];
nfRep->blockNo = DBTC;
nfRep->nodeId = cownNodeid;
nfRep->failedNodeId = hostptr.i;
sendSignal(cdihblockref, GSN_NF_COMPLETEREP, signal,
NFCompleteRep::SignalLength, JBB);
}
}
void Dbtc::checkScanActiveInFailedLqh(Signal* signal,
Uint32 scanPtrI,
Uint32 failedNodeId){
......@@ -6984,8 +7018,44 @@ void Dbtc::checkScanActiveInFailedLqh(Signal* signal,
sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB);
return;
}//for
checkNodeFailComplete(signal, failedNodeId, HostRecord::NF_CHECK_SCAN);
}
void
Dbtc::nodeFailCheckTransactions(Signal* signal,
Uint32 transPtrI,
Uint32 failedNodeId)
{
jam();
Ptr<ApiConnectRecord> transPtr;
for (transPtr.i = transPtrI; transPtr.i < capiConnectFilesize; transPtr.i++)
{
ptrCheckGuard(transPtr, capiConnectFilesize, apiConnectRecord);
if (transPtr.p->m_transaction_nodes.get(failedNodeId))
{
jam();
// Force timeout regardless of state
Uint32 save = c_appl_timeout_value;
c_appl_timeout_value = 1;
setApiConTimer(transPtr.i, 0, __LINE__);
timeOutFoundLab(signal, transPtr.i, ZNODEFAIL_BEFORE_COMMIT);
c_appl_timeout_value = save;
}
// Send CONTINUEB to continue later
signal->theData[0] = TcContinueB::ZNF_CHECK_TRANSACTIONS;
signal->theData[1] = transPtr.i + 1; // Check next
signal->theData[2] = failedNodeId;
sendSignal(cownref, GSN_CONTINUEB, signal, 3, JBB);
return;
}
checkNodeFailComplete(signal, failedNodeId,
HostRecord::NF_CHECK_TRANSACTION);
}
void
Dbtc::checkScanFragList(Signal* signal,
Uint32 failedNodeId,
......@@ -7025,14 +7095,7 @@ void Dbtc::execTAKE_OVERTCCONF(Signal* signal)
/* USED THEM IS COMPLETED. */
/*------------------------------------------------------------*/
hostptr.p->takeOverStatus = TOS_COMPLETED;
{
NFCompleteRep * const nfRep = (NFCompleteRep *)&signal->theData[0];
nfRep->blockNo = DBTC;
nfRep->nodeId = cownNodeid;
nfRep->failedNodeId = hostptr.i;
}
sendSignal(cdihblockref, GSN_NF_COMPLETEREP, signal,
NFCompleteRep::SignalLength, JBB);
checkNodeFailComplete(signal, hostptr.i, HostRecord::NF_TAKEOVER);
break;
case TOS_COMPLETED:
jam();
......@@ -7979,6 +8042,7 @@ void Dbtc::initApiConnectFail(Signal* signal)
apiConnectptr.p->ndbapiBlockref = 0;
apiConnectptr.p->ndbapiConnect = 0;
apiConnectptr.p->buddyPtr = RNIL;
apiConnectptr.p->m_transaction_nodes.clear();
setApiConTimer(apiConnectptr.i, 0, __LINE__);
switch(ttransStatus){
case LqhTransConf::Committed:
......@@ -9756,6 +9820,7 @@ void Dbtc::initApiConnect(Signal* signal)
apiConnectptr.p->executingIndexOp = RNIL;
apiConnectptr.p->buddyPtr = RNIL;
apiConnectptr.p->currSavePointId = 0;
apiConnectptr.p->m_transaction_nodes.clear();
}//for
apiConnectptr.i = tiacTmp - 1;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
......@@ -9783,6 +9848,7 @@ void Dbtc::initApiConnect(Signal* signal)
apiConnectptr.p->executingIndexOp = RNIL;
apiConnectptr.p->buddyPtr = RNIL;
apiConnectptr.p->currSavePointId = 0;
apiConnectptr.p->m_transaction_nodes.clear();
}//for
apiConnectptr.i = (2 * tiacTmp) - 1;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
......@@ -9810,6 +9876,7 @@ void Dbtc::initApiConnect(Signal* signal)
apiConnectptr.p->executingIndexOp = RNIL;
apiConnectptr.p->buddyPtr = RNIL;
apiConnectptr.p->currSavePointId = 0;
apiConnectptr.p->m_transaction_nodes.clear();
}//for
apiConnectptr.i = (3 * tiacTmp) - 1;
ptrCheckGuard(apiConnectptr, capiConnectFilesize, apiConnectRecord);
......@@ -9877,6 +9944,7 @@ void Dbtc::inithost(Signal* signal)
hostptr.p->noOfPackedWordsLqh = 0;
hostptr.p->hostLqhBlockRef = calcLqhBlockRef(hostptr.i);
}//for
c_alive_nodes.clear();
}//Dbtc::inithost()
void Dbtc::initialiseRecordsLab(Signal* signal, UintR Tdata0,
......@@ -10126,6 +10194,7 @@ void Dbtc::releaseAbortResources(Signal* signal)
}//while
apiConnectptr.p->firstTcConnect = RNIL;
apiConnectptr.p->lastTcConnect = RNIL;
apiConnectptr.p->m_transaction_nodes.clear();
// MASV let state be CS_ABORTING until all
// signals in the "air" have been received. Reset to CS_CONNECTED
......@@ -10199,6 +10268,7 @@ void Dbtc::releaseApiCon(Signal* signal, UintR TapiConnectPtr)
cfirstfreeApiConnect = TlocalApiConnectptr.i;
setApiConTimer(TlocalApiConnectptr.i, 0, __LINE__);
TlocalApiConnectptr.p->apiConnectstate = CS_DISCONNECTED;
ndbassert(TlocalApiConnectptr.p->m_transaction_nodes.isclear());
ndbassert(TlocalApiConnectptr.p->apiScanRec == RNIL);
TlocalApiConnectptr.p->ndbapiBlockref = 0;
}//Dbtc::releaseApiCon()
......@@ -10734,6 +10804,34 @@ Dbtc::execDUMP_STATE_ORD(Signal* signal)
c_theIndexOperationPool.getSize(),
c_theIndexOperationPool.getNoOfFree());
}
if (dumpState->args[0] == 2514)
{
if (signal->getLength() == 2)
{
dumpState->args[0] = DumpStateOrd::TcDumpOneApiConnectRec;
execDUMP_STATE_ORD(signal);
}
NodeReceiverGroup rg(CMVMI, c_alive_nodes);
dumpState->args[0] = 15;
sendSignal(rg, GSN_DUMP_STATE_ORD, signal, 1, JBB);
signal->theData[0] = 2515;
sendSignalWithDelay(cownref, GSN_DUMP_STATE_ORD, signal, 1000, 1);
return;
}
if (dumpState->args[0] == 2515)
{
NdbNodeBitmask mask = c_alive_nodes;
mask.clear(getOwnNodeId());
NodeReceiverGroup rg(NDBCNTR, mask);
sendSignal(rg, GSN_SYSTEM_ERROR, signal, 1, JBB);
sendSignalWithDelay(cownref, GSN_SYSTEM_ERROR, signal, 300, 1);
return;
}
}//Dbtc::execDUMP_STATE_ORD()
void Dbtc::execSET_VAR_REQ(Signal* signal)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7