database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-09-02 09:41:40 +03:00
Code Activity

Merge poseidon.mysql.com:/home/tomas/mysql-5.0-ndb

Browse Source 
into  poseidon.mysql.com:/home/tomas/mysql-5.1-new-ndb
This commit is contained in:
tomas@poseidon.mysql.com
2007-02-14 11:55:31 +07:00
parent 18d227b1b0 f45ac96b2a
commit e865b5950f
8 changed files with 174 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
storage/ndb/include/kernel/signaldata/DumpStateOrd.hpp
View File

@@ -107,7 +107,10 @@ public:
CmvmiDumpLongSignalMemory = 2601, CmvmiDumpLongSignalMemory = 2601,
CmvmiSetRestartOnErrorInsert = 2602, CmvmiSetRestartOnErrorInsert = 2602,
CmvmiTestLongSigWithDelay = 2603, CmvmiTestLongSigWithDelay = 2603,
CmvmiDumpSubscriptions = 2604, /* note: done to respective outfile
to be able to debug if events
for some reason does not end up
in clusterlog */
LCPContinue = 5900, LCPContinue = 5900,
// 7000 DIH // 7000 DIH
// 7001 DIH // 7001 DIH

20
storage/ndb/src/kernel/blocks/cmvmi/Cmvmi.cpp
View File

@@ -921,7 +921,7 @@ void Cmvmi::execSET_VAR_REQ(Signal* signal)
case TimeToWaitAlive: case TimeToWaitAlive:
// QMGR // QMGR
case HeartbeatIntervalDbDb: // TODO ev till Ndbcnt ocks<EFBFBD> case HeartbeatIntervalDbDb: // TODO possibly Ndbcnt too
case HeartbeatIntervalDbApi: case HeartbeatIntervalDbApi:
case ArbitTimeout: case ArbitTimeout:
sendSignal(QMGR_REF, GSN_SET_VAR_REQ, signal, 3, JBB); sendSignal(QMGR_REF, GSN_SET_VAR_REQ, signal, 3, JBB);
@@ -1129,6 +1129,24 @@ Cmvmi::execDUMP_STATE_ORD(Signal* signal)
} }
} }
if (arg == DumpStateOrd::CmvmiDumpSubscriptions)
{
SubscriberPtr ptr;
subscribers.first(ptr);
g_eventLogger.info("List subscriptions:");
while(ptr.i != RNIL)
{
g_eventLogger.info("Subscription: %u, nodeId: %u, ref: 0x%x",
ptr.i, refToNode(ptr.p->blockRef), ptr.p->blockRef);
for(Uint32 i = 0; i < LogLevel::LOGLEVEL_CATEGORIES; i++)
{
Uint32 level = ptr.p->logLevel.getLogLevel((LogLevel::EventCategory)i);
g_eventLogger.info("Category %u Level %u", i, level);
}
subscribers.next(ptr);
}
}
if (arg == DumpStateOrd::CmvmiDumpLongSignalMemory){ if (arg == DumpStateOrd::CmvmiDumpLongSignalMemory){
infoEvent("Cmvmi: g_sectionSegmentPool size: %d free: %d", infoEvent("Cmvmi: g_sectionSegmentPool size: %d free: %d",
g_sectionSegmentPool.getSize(), g_sectionSegmentPool.getSize(),

104
storage/ndb/src/kernel/blocks/dbdih/DbdihMain.cpp
View File

@@ -1883,8 +1883,8 @@ void Dbdih::execSTART_PERMREQ(Signal* signal)
return; return;
}//if }//if
if (getNodeStatus(nodeId) != NodeRecord::DEAD){ if (getNodeStatus(nodeId) != NodeRecord::DEAD){
ndbout << "nodeStatus in START_PERMREQ = " g_eventLogger.error("nodeStatus in START_PERMREQ = %u",
<< (Uint32) getNodeStatus(nodeId) << endl; (Uint32) getNodeStatus(nodeId));
ndbrequire(false); ndbrequire(false);
}//if }//if
@@ -4297,7 +4297,7 @@ void Dbdih::checkCopyTab(NodeRecordPtr failedNodePtr)
jam(); jam();
break; break;
default: default:
ndbout_c("outstanding gsn: %s(%d)", g_eventLogger.error("outstanding gsn: %s(%d)",
getSignalName(c_nodeStartMaster.m_outstandingGsn), getSignalName(c_nodeStartMaster.m_outstandingGsn),
c_nodeStartMaster.m_outstandingGsn); c_nodeStartMaster.m_outstandingGsn);
ndbrequire(false); ndbrequire(false);
@@ -4752,9 +4752,10 @@ void Dbdih::failedNodeLcpHandling(Signal* signal, NodeRecordPtr failedNodePtr)
failedNodePtr.p->activeStatus = Sysfile::NS_NotActive_NotTakenOver; failedNodePtr.p->activeStatus = Sysfile::NS_NotActive_NotTakenOver;
break; break;
default: default:
ndbout << "activeStatus = " << (Uint32) failedNodePtr.p->activeStatus; g_eventLogger.error("activeStatus = %u "
ndbout << " at failure after NODE_FAILREP of node = "; "at failure after NODE_FAILREP of node = %u",
ndbout << failedNodePtr.i << endl; (Uint32) failedNodePtr.p->activeStatus,
failedNodePtr.i);
ndbrequire(false); ndbrequire(false);
break; break;
}//switch }//switch
@@ -4909,7 +4910,7 @@ Dbdih::startLcpMasterTakeOver(Signal* signal, Uint32 nodeId){
/** /**
* Node failure during master take over... * Node failure during master take over...
*/ */
ndbout_c("Nodefail during master take over"); g_eventLogger.info("Nodefail during master take over");
} }
setLocalNodefailHandling(signal, nodeId, NF_LCP_TAKE_OVER); setLocalNodefailHandling(signal, nodeId, NF_LCP_TAKE_OVER);
@@ -5149,7 +5150,8 @@ void Dbdih::execMASTER_GCPCONF(Signal* signal)
if (latestLcpId > SYSFILE->latestLCP_ID) { if (latestLcpId > SYSFILE->latestLCP_ID) {
jam(); jam();
#if 0 #if 0
ndbout_c("Dbdih: Setting SYSFILE->latestLCP_ID to %d", latestLcpId); g_eventLogger.info("Dbdih: Setting SYSFILE->latestLCP_ID to %d",
latestLcpId);
SYSFILE->latestLCP_ID = latestLcpId; SYSFILE->latestLCP_ID = latestLcpId;
#endif #endif
SYSFILE->keepGCI = oldestKeepGci; SYSFILE->keepGCI = oldestKeepGci;
@@ -5808,7 +5810,7 @@ Dbdih::checkLocalNodefailComplete(Signal* signal, Uint32 failedNodeId,
if (ERROR_INSERTED(7030)) if (ERROR_INSERTED(7030))
{ {
ndbout_c("Reenable GCP_PREPARE"); g_eventLogger.info("Reenable GCP_PREPARE");
CLEAR_ERROR_INSERT_VALUE; CLEAR_ERROR_INSERT_VALUE;
} }
@@ -5981,7 +5983,7 @@ Dbdih::sendMASTER_LCPCONF(Signal * signal){
c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__);
#if 0 #if 0
if(c_copyGCISlave.m_copyReason == CopyGCIReq::LOCAL_CHECKPOINT){ if(c_copyGCISlave.m_copyReason == CopyGCIReq::LOCAL_CHECKPOINT){
ndbout_c("Dbdih: Also resetting c_copyGCISlave"); g_eventLogger.info("Dbdih: Also resetting c_copyGCISlave");
c_copyGCISlave.m_copyReason = CopyGCIReq::IDLE; c_copyGCISlave.m_copyReason = CopyGCIReq::IDLE;
c_copyGCISlave.m_expectedNextWord = 0; c_copyGCISlave.m_expectedNextWord = 0;
} }
@@ -6066,7 +6068,7 @@ Dbdih::sendMASTER_LCPCONF(Signal * signal){
if(c_lcpState.lcpStatus == LCP_TAB_SAVED){ if(c_lcpState.lcpStatus == LCP_TAB_SAVED){
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("Sending extra GSN_LCP_COMPLETE_REP to new master"); g_eventLogger.info("Sending extra GSN_LCP_COMPLETE_REP to new master");
#endif #endif
sendLCP_COMPLETE_REP(signal); sendLCP_COMPLETE_REP(signal);
} }
@@ -6222,7 +6224,7 @@ void Dbdih::execMASTER_LCPCONF(Signal* signal)
nodePtr.p->lcpStateAtTakeOver = lcpState; nodePtr.p->lcpStateAtTakeOver = lcpState;
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("MASTER_LCPCONF"); g_eventLogger.info("MASTER_LCPCONF");
printMASTER_LCP_CONF(stdout, &signal->theData[0], 0, 0); printMASTER_LCP_CONF(stdout, &signal->theData[0], 0, 0);
#endif #endif
@@ -6299,7 +6301,7 @@ void Dbdih::MASTER_LCPhandling(Signal* signal, Uint32 failedNodeId)
// protocol. // protocol.
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("MASTER_LCPhandling:: LMTOS_ALL_IDLE -> checkLcpStart"); g_eventLogger.info("MASTER_LCPhandling:: LMTOS_ALL_IDLE -> checkLcpStart");
#endif #endif
checkLcpStart(signal, __LINE__); checkLcpStart(signal, __LINE__);
break; break;
@@ -6310,7 +6312,7 @@ void Dbdih::MASTER_LCPhandling(Signal* signal, Uint32 failedNodeId)
// protocol by calculating the keep gci and storing the new lcp id. // protocol by calculating the keep gci and storing the new lcp id.
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("MASTER_LCPhandling:: LMTOS_COPY_ONGOING -> storeNewLcpId"); g_eventLogger.info("MASTER_LCPhandling:: LMTOS_COPY_ONGOING -> storeNewLcpId");
#endif #endif
if (c_lcpState.lcpStatus == LCP_STATUS_ACTIVE) { if (c_lcpState.lcpStatus == LCP_STATUS_ACTIVE) {
jam(); jam();
@@ -6321,7 +6323,7 @@ void Dbdih::MASTER_LCPhandling(Signal* signal, Uint32 failedNodeId)
/*---------------------------------------------------------------------*/ /*---------------------------------------------------------------------*/
Uint32 lcpId = SYSFILE->latestLCP_ID; Uint32 lcpId = SYSFILE->latestLCP_ID;
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("Decreasing latestLCP_ID from %d to %d", lcpId, lcpId - 1); g_eventLogger.info("Decreasing latestLCP_ID from %d to %d", lcpId, lcpId - 1);
#endif #endif
SYSFILE->latestLCP_ID--; SYSFILE->latestLCP_ID--;
}//if }//if
@@ -6338,7 +6340,7 @@ void Dbdih::MASTER_LCPhandling(Signal* signal, Uint32 failedNodeId)
* complete before finalising the LCP process. * complete before finalising the LCP process.
* ------------------------------------------------------------------ */ * ------------------------------------------------------------------ */
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("MASTER_LCPhandling:: LMTOS_ALL_ACTIVE -> " g_eventLogger.info("MASTER_LCPhandling:: LMTOS_ALL_ACTIVE -> "
"startLcpRoundLoopLab(table=%u, fragment=%u)", "startLcpRoundLoopLab(table=%u, fragment=%u)",
c_lcpMasterTakeOverState.minTableId, c_lcpMasterTakeOverState.minTableId,
c_lcpMasterTakeOverState.minFragId); c_lcpMasterTakeOverState.minFragId);
@@ -7745,8 +7747,8 @@ void Dbdih::checkGcpStopLab(Signal* signal)
if (cgcpSameCounter == 1200) { if (cgcpSameCounter == 1200) {
jam(); jam();
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout << "System crash due to GCP Stop in state = "; g_eventLogger.error("System crash due to GCP Stop in state = %u",
ndbout << (Uint32) cgcpStatus << endl; (Uint32) cgcpStatus);
#endif #endif
crashSystemAtGcpStop(signal); crashSystemAtGcpStop(signal);
return; return;
@@ -7759,8 +7761,8 @@ void Dbdih::checkGcpStopLab(Signal* signal)
if (cgcpSameCounter == 1200) { if (cgcpSameCounter == 1200) {
jam(); jam();
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout << "System crash due to GCP Stop in state = "; g_eventLogger.error("System crash due to GCP Stop in state = %u",
ndbout << (Uint32) cgcpStatus << endl; (Uint32) cgcpStatus);
#endif #endif
crashSystemAtGcpStop(signal); crashSystemAtGcpStop(signal);
return; return;
@@ -7951,7 +7953,7 @@ void Dbdih::GCP_SAVEhandling(Signal* signal, Uint32 nodeId)
getNodeState().startLevel == NodeState::SL_STARTED){ getNodeState().startLevel == NodeState::SL_STARTED){
jam(); jam();
#if 0 #if 0
ndbout_c("Dbdih: Clearing initial start ongoing"); g_eventLogger.info("Dbdih: Clearing initial start ongoing");
#endif #endif
Sysfile::clearInitialStartOngoing(SYSFILE->systemRestartBits); Sysfile::clearInitialStartOngoing(SYSFILE->systemRestartBits);
} }
@@ -7970,7 +7972,7 @@ void Dbdih::execGCP_PREPARE(Signal* signal)
if (ERROR_INSERTED(7030)) if (ERROR_INSERTED(7030))
{ {
cgckptflag = true; cgckptflag = true;
ndbout_c("Delayed GCP_PREPARE 5s"); g_eventLogger.info("Delayed GCP_PREPARE 5s");
sendSignalWithDelay(reference(), GSN_GCP_PREPARE, signal, 5000, sendSignalWithDelay(reference(), GSN_GCP_PREPARE, signal, 5000,
signal->getLength()); signal->getLength());
return; return;
@@ -7990,7 +7992,7 @@ void Dbdih::execGCP_PREPARE(Signal* signal)
if (ERROR_INSERTED(7031)) if (ERROR_INSERTED(7031))
{ {
ndbout_c("Crashing delayed in GCP_PREPARE 3s"); g_eventLogger.info("Crashing delayed in GCP_PREPARE 3s");
signal->theData[0] = 9999; signal->theData[0] = 9999;
sendSignalWithDelay(CMVMI_REF, GSN_NDB_TAMPER, signal, 3000, 1); sendSignalWithDelay(CMVMI_REF, GSN_NDB_TAMPER, signal, 3000, 1);
return; return;
@@ -8514,7 +8516,7 @@ void Dbdih::initLcpLab(Signal* signal, Uint32 senderRef, Uint32 tableId)
* This is LCP master takeover * This is LCP master takeover
*/ */
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("initLcpLab aborted due to LCP master takeover - 1"); g_eventLogger.info("initLcpLab aborted due to LCP master takeover - 1");
#endif #endif
c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__); c_lcpState.setLcpStatus(LCP_STATUS_IDLE, __LINE__);
sendMASTER_LCPCONF(signal); sendMASTER_LCPCONF(signal);
@@ -8527,7 +8529,7 @@ void Dbdih::initLcpLab(Signal* signal, Uint32 senderRef, Uint32 tableId)
* Master take over but has not yet received MASTER_LCPREQ * Master take over but has not yet received MASTER_LCPREQ
*/ */
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("initLcpLab aborted due to LCP master takeover - 2"); g_eventLogger.info("initLcpLab aborted due to LCP master takeover - 2");
#endif #endif
return; return;
} }
@@ -9836,9 +9838,10 @@ void Dbdih::checkTcCounterLab(Signal* signal)
{ {
CRASH_INSERTION(7009); CRASH_INSERTION(7009);
if (c_lcpState.lcpStatus != LCP_STATUS_IDLE) { if (c_lcpState.lcpStatus != LCP_STATUS_IDLE) {
ndbout << "lcpStatus = " << (Uint32) c_lcpState.lcpStatus; g_eventLogger.error("lcpStatus = %u"
ndbout << "lcpStatusUpdatedPlace = " << "lcpStatusUpdatedPlace = %d",
c_lcpState.lcpStatusUpdatedPlace << endl; (Uint32) c_lcpState.lcpStatus,
c_lcpState.lcpStatusUpdatedPlace);
ndbrequire(false); ndbrequire(false);
return; return;
}//if }//if
@@ -10421,9 +10424,8 @@ void Dbdih::execLCP_FRAG_REP(Signal* signal)
if(tabPtr.p->tabStatus == TabRecord::TS_DROPPING){ if(tabPtr.p->tabStatus == TabRecord::TS_DROPPING){
jam(); jam();
ndbout_c("TS_DROPPING - Neglecting to save Table: %d Frag: %d - ", g_eventLogger.info("TS_DROPPING - Neglecting to save Table: %d Frag: %d - ",
tableId, tableId, fragId);
fragId);
} else { } else {
jam(); jam();
/** /**
@@ -10553,7 +10555,7 @@ void Dbdih::findReplica(ReplicaRecordPtr& replicaPtr,
}; };
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("Fragment Replica(node=%d) not found", nodeId); g_eventLogger.info("Fragment Replica(node=%d) not found", nodeId);
replicaPtr.i = fragPtrP->oldStoredReplicas; replicaPtr.i = fragPtrP->oldStoredReplicas;
while(replicaPtr.i != RNIL){ while(replicaPtr.i != RNIL){
ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord); ptrCheckGuard(replicaPtr, creplicaFileSize, replicaRecord);
@@ -10566,9 +10568,9 @@ void Dbdih::findReplica(ReplicaRecordPtr& replicaPtr,
}//if }//if
}; };
if(replicaPtr.i != RNIL){ if(replicaPtr.i != RNIL){
ndbout_c("...But was found in oldStoredReplicas"); g_eventLogger.info("...But was found in oldStoredReplicas");
} else { } else {
ndbout_c("...And wasn't found in oldStoredReplicas"); g_eventLogger.info("...And wasn't found in oldStoredReplicas");
} }
#endif #endif
ndbrequire(false); ndbrequire(false);
@@ -10635,7 +10637,7 @@ Dbdih::reportLcpCompletion(const LcpFragRep* lcpReport)
if(lcpNo != replicaPtr.p->nextLcp){ if(lcpNo != replicaPtr.p->nextLcp){
if (handle_invalid_lcp_no(lcpReport, replicaPtr)) if (handle_invalid_lcp_no(lcpReport, replicaPtr))
{ {
ndbout_c("lcpNo = %d replicaPtr.p->nextLcp = %d", g_eventLogger.error("lcpNo = %d replicaPtr.p->nextLcp = %d",
lcpNo, replicaPtr.p->nextLcp); lcpNo, replicaPtr.p->nextLcp);
ndbrequire(false); ndbrequire(false);
} }
@@ -10672,7 +10674,7 @@ Dbdih::reportLcpCompletion(const LcpFragRep* lcpReport)
// Not all fragments in table have been checkpointed. // Not all fragments in table have been checkpointed.
/* ----------------------------------------------------------------- */ /* ----------------------------------------------------------------- */
if(0) if(0)
ndbout_c("reportLcpCompletion: fragment %d not ready", fid); g_eventLogger.info("reportLcpCompletion: fragment %d not ready", fid);
return false; return false;
}//if }//if
}//for }//for
@@ -10789,7 +10791,7 @@ void Dbdih::execLCP_COMPLETE_REP(Signal* signal)
jamEntry(); jamEntry();
#if 0 #if 0
ndbout_c("LCP_COMPLETE_REP"); g_eventLogger.info("LCP_COMPLETE_REP");
printLCP_COMPLETE_REP(stdout, printLCP_COMPLETE_REP(stdout,
signal->getDataPtr(), signal->getDataPtr(),
signal->length(), number()); signal->length(), number());
@@ -10875,7 +10877,7 @@ void Dbdih::allNodesLcpCompletedLab(Signal* signal)
if(c_lcpMasterTakeOverState.state != LMTOS_IDLE){ if(c_lcpMasterTakeOverState.state != LMTOS_IDLE){
jam(); jam();
#ifdef VM_TRACE #ifdef VM_TRACE
ndbout_c("Exiting from allNodesLcpCompletedLab"); g_eventLogger.info("Exiting from allNodesLcpCompletedLab");
#endif #endif
return; return;
} }
@@ -11112,12 +11114,12 @@ void Dbdih::crashSystemAtGcpStop(Signal* signal)
infoEvent("Detected GCP stop...sending kill to %s", infoEvent("Detected GCP stop...sending kill to %s",
c_GCP_SAVEREQ_Counter.getText()); c_GCP_SAVEREQ_Counter.getText());
ndbout_c("Detected GCP stop...sending kill to %s", g_eventLogger.error("Detected GCP stop...sending kill to %s",
c_GCP_SAVEREQ_Counter.getText()); c_GCP_SAVEREQ_Counter.getText());
return; return;
} }
case GCP_SAVE_LQH_FINISHED: case GCP_SAVE_LQH_FINISHED:
ndbout_c("m_copyReason: %d m_waiting: %d", g_eventLogger.error("m_copyReason: %d m_waiting: %d",
c_copyGCIMaster.m_copyReason, c_copyGCIMaster.m_copyReason,
c_copyGCIMaster.m_waiting); c_copyGCIMaster.m_waiting);
break; break;
@@ -11127,7 +11129,7 @@ void Dbdih::crashSystemAtGcpStop(Signal* signal)
break; break;
} }
ndbout_c("c_copyGCISlave: sender{Data, Ref} %d %x reason: %d nextWord: %d", g_eventLogger.error("c_copyGCISlave: sender{Data, Ref} %d %x reason: %d nextWord: %d",
c_copyGCISlave.m_senderData, c_copyGCISlave.m_senderData,
c_copyGCISlave.m_senderRef, c_copyGCISlave.m_senderRef,
c_copyGCISlave.m_copyReason, c_copyGCISlave.m_copyReason,
@@ -13350,9 +13352,9 @@ void Dbdih::setLcpActiveStatusEnd()
nodePtr.i = getOwnNodeId(); nodePtr.i = getOwnNodeId();
ptrAss(nodePtr, nodeRecord); ptrAss(nodePtr, nodeRecord);
ndbrequire(nodePtr.p->activeStatus == Sysfile::NS_Active); ndbrequire(nodePtr.p->activeStatus == Sysfile::NS_Active);
ndbout_c("NR: setLcpActiveStatusEnd - m_participatingLQH"); g_eventLogger.info("NR: setLcpActiveStatusEnd - m_participatingLQH");
} else { } else {
ndbout_c("NR: setLcpActiveStatusEnd - !m_participatingLQH"); g_eventLogger.info("NR: setLcpActiveStatusEnd - !m_participatingLQH");
} }
} }
@@ -14184,8 +14186,8 @@ Dbdih::execDUMP_STATE_ORD(Signal* signal)
} }
if(arg == DumpStateOrd::EnableUndoDelayDataWrite){ if(arg == DumpStateOrd::EnableUndoDelayDataWrite){
ndbout << "Dbdih:: delay write of datapages for table = " g_eventLogger.info("Dbdih:: delay write of datapages for table = %s",
<< dumpState->args[1]<< endl; dumpState->args[1]);
// Send this dump to ACC and TUP // Send this dump to ACC and TUP
EXECUTE_DIRECT(DBACC, GSN_DUMP_STATE_ORD, signal, 2); EXECUTE_DIRECT(DBACC, GSN_DUMP_STATE_ORD, signal, 2);
EXECUTE_DIRECT(DBTUP, GSN_DUMP_STATE_ORD, signal, 2); EXECUTE_DIRECT(DBTUP, GSN_DUMP_STATE_ORD, signal, 2);
@@ -14202,13 +14204,13 @@ Dbdih::execDUMP_STATE_ORD(Signal* signal)
}//if }//if
if (signal->theData[0] == DumpStateOrd::DihMinTimeBetweenLCP) { if (signal->theData[0] == DumpStateOrd::DihMinTimeBetweenLCP) {
// Set time between LCP to min value // Set time between LCP to min value
ndbout << "Set time between LCP to min value" << endl; g_eventLogger.info("Set time between LCP to min value");
c_lcpState.clcpDelay = 0; // TimeBetweenLocalCheckpoints.min c_lcpState.clcpDelay = 0; // TimeBetweenLocalCheckpoints.min
return; return;
} }
if (signal->theData[0] == DumpStateOrd::DihMaxTimeBetweenLCP) { if (signal->theData[0] == DumpStateOrd::DihMaxTimeBetweenLCP) {
// Set time between LCP to max value // Set time between LCP to max value
ndbout << "Set time between LCP to max value" << endl; g_eventLogger.info("Set time between LCP to max value");
c_lcpState.clcpDelay = 31; // TimeBetweenLocalCheckpoints.max c_lcpState.clcpDelay = 31; // TimeBetweenLocalCheckpoints.max
return; return;
} }
@@ -14244,7 +14246,7 @@ Dbdih::execDUMP_STATE_ORD(Signal* signal)
{ {
cgcpDelay = signal->theData[1]; cgcpDelay = signal->theData[1];
} }
ndbout_c("Setting time between gcp : %d", cgcpDelay); g_eventLogger.info("Setting time between gcp : %d", cgcpDelay);
} }
if (arg == 7021 && signal->getLength() == 2) if (arg == 7021 && signal->getLength() == 2)
@@ -14367,7 +14369,7 @@ Dbdih::execPREP_DROP_TAB_REQ(Signal* signal){
while(index < count){ while(index < count){
if(nodePtr.p->queuedChkpt[index].tableId == tabPtr.i){ if(nodePtr.p->queuedChkpt[index].tableId == tabPtr.i){
jam(); jam();
// ndbout_c("Unqueuing %d", index); // g_eventLogger.info("Unqueuing %d", index);
count--; count--;
for(Uint32 i = index; i<count; i++){ for(Uint32 i = index; i<count; i++){
@@ -14407,7 +14409,7 @@ Dbdih::execPREP_DROP_TAB_REQ(Signal* signal){
if(checkLcpAllTablesDoneInLqh()){ if(checkLcpAllTablesDoneInLqh()){
jam(); jam();
ndbout_c("This is the last table"); g_eventLogger.info("This is the last table");
/** /**
* Then check if saving of tab info is done for all tables * Then check if saving of tab info is done for all tables
@@ -14416,7 +14418,7 @@ Dbdih::execPREP_DROP_TAB_REQ(Signal* signal){
checkLcpCompletedLab(signal); checkLcpCompletedLab(signal);
if(a != c_lcpState.lcpStatus){ if(a != c_lcpState.lcpStatus){
ndbout_c("And all tables are written to already written disk"); g_eventLogger.info("And all tables are written to already written disk");
} }
} }
break; break;

5
storage/ndb/src/kernel/vm/WatchDog.cpp
View File

@@ -22,6 +22,9 @@
#include <NdbOut.hpp> #include <NdbOut.hpp>
#include <NdbSleep.h> #include <NdbSleep.h>
#include <ErrorHandlingMacros.hpp> #include <ErrorHandlingMacros.hpp>
#include <EventLogger.hpp>
extern EventLogger g_eventLogger;
extern "C" extern "C"
void* void*
@@ -125,7 +128,7 @@ WatchDog::run(){
last_stuck_action = "Unknown place"; last_stuck_action = "Unknown place";
break; break;
}//switch }//switch
ndbout << "Ndb kernel is stuck in: " << last_stuck_action << endl; g_eventLogger.warning("Ndb kernel is stuck in: %s", last_stuck_action);
if(alerts == 3){ if(alerts == 3){
shutdownSystem(last_stuck_action); shutdownSystem(last_stuck_action);
} }

72
storage/ndb/src/mgmsrv/MgmtSrvr.cpp
View File

@@ -701,7 +701,7 @@ int MgmtSrvr::okToSendTo(NodeId nodeId, bool unCond)
return WRONG_PROCESS_TYPE; return WRONG_PROCESS_TYPE;
// Check if we have contact with it // Check if we have contact with it
if(unCond){ if(unCond){
if(theFacade->theClusterMgr->getNodeInfo(nodeId).connected) if(theFacade->theClusterMgr->getNodeInfo(nodeId).m_api_reg_conf)
return 0; return 0;
} }
else if (theFacade->get_node_alive(nodeId) == true) else if (theFacade->get_node_alive(nodeId) == true)
@@ -1577,12 +1577,17 @@ MgmtSrvr::status(int nodeId,
} }
int int
MgmtSrvr::setEventReportingLevelImpl(int nodeId, MgmtSrvr::setEventReportingLevelImpl(int nodeId_arg,
const EventSubscribeReq& ll) const EventSubscribeReq& ll)
{ {
SignalSender ss(theFacade); SignalSender ss(theFacade);
NdbNodeBitmask nodes;
int retries = 30;
nodes.clear();
while (1)
{
Uint32 nodeId, max;
ss.lock(); ss.lock();
SimpleSignal ssig; SimpleSignal ssig;
EventSubscribeReq * dst = EventSubscribeReq * dst =
CAST_PTR(EventSubscribeReq, ssig.getDataPtrSend()); CAST_PTR(EventSubscribeReq, ssig.getDataPtrSend());
@@ -1590,19 +1595,67 @@ MgmtSrvr::setEventReportingLevelImpl(int nodeId,
EventSubscribeReq::SignalLength); EventSubscribeReq::SignalLength);
*dst = ll; *dst = ll;
NodeBitmask nodes; if (nodeId_arg == 0)
nodes.clear(); {
Uint32 max = (nodeId == 0) ? (nodeId = 1, MAX_NDB_NODES) : nodeId; // all nodes
for(; (Uint32) nodeId <= max; nodeId++) nodeId = 1;
max = MAX_NDB_NODES;
}
else
{
// only one node
max = nodeId = nodeId_arg;
}
// first make sure nodes are sendable
for(; nodeId <= max; nodeId++)
{ {
if (nodeTypes[nodeId] != NODE_TYPE_DB) if (nodeTypes[nodeId] != NODE_TYPE_DB)
continue; continue;
if (okToSendTo(nodeId, true)) if (okToSendTo(nodeId, true))
continue;
if (ss.sendSignal(nodeId, &ssig) == SEND_OK)
{ {
if (theFacade->theClusterMgr->getNodeInfo(nodeId).connected == false)
{
// node not connected we can safely skip this one
continue;
}
// api_reg_conf not recevied yet, need to retry
break;
}
}
if (nodeId <= max)
{
if (--retries)
{
ss.unlock();
NdbSleep_MilliSleep(100);
continue;
}
return SEND_OR_RECEIVE_FAILED;
}
if (nodeId_arg == 0)
{
// all nodes
nodeId = 1;
max = MAX_NDB_NODES;
}
else
{
// only one node
max = nodeId = nodeId_arg;
}
// now send to all sendable nodes nodes
// note, lock is held, so states have not changed
for(; (Uint32) nodeId <= max; nodeId++)
{
if (nodeTypes[nodeId] != NODE_TYPE_DB)
continue;
if (theFacade->theClusterMgr->getNodeInfo(nodeId).connected == false)
continue; // node is not connected, skip
if (ss.sendSignal(nodeId, &ssig) == SEND_OK)
nodes.set(nodeId); nodes.set(nodeId);
} }
break;
} }
if (nodes.isclear()) if (nodes.isclear())
@@ -1613,6 +1666,7 @@ MgmtSrvr::setEventReportingLevelImpl(int nodeId,
int error = 0; int error = 0;
while (!nodes.isclear()) while (!nodes.isclear())
{ {
Uint32 nodeId;
SimpleSignal *signal = ss.waitFor(); SimpleSignal *signal = ss.waitFor();
int gsn = signal->readSignalNumber(); int gsn = signal->readSignalNumber();
nodeId = refToNode(signal->header.theSendersBlockRef); nodeId = refToNode(signal->header.theSendersBlockRef);

5
storage/ndb/src/ndbapi/ClusterMgr.cpp
View File

@@ -313,7 +313,7 @@ ClusterMgr::showState(NodeId nodeId){
ClusterMgr::Node::Node() ClusterMgr::Node::Node()
: m_state(NodeState::SL_NOTHING) { : m_state(NodeState::SL_NOTHING) {
compatible = nfCompleteRep = true; compatible = nfCompleteRep = true;
connected = defined = m_alive = false; connected = defined = m_alive = m_api_reg_conf = false;
m_state.m_connected_nodes.clear(); m_state.m_connected_nodes.clear();
} }
@@ -385,6 +385,8 @@ ClusterMgr::execAPI_REGCONF(const Uint32 * theData){
node.m_info.m_version); node.m_info.m_version);
} }
node.m_api_reg_conf = true;
node.m_state = apiRegConf->nodeState; node.m_state = apiRegConf->nodeState;
if (node.compatible && (node.m_state.startLevel == NodeState::SL_STARTED || if (node.compatible && (node.m_state.startLevel == NodeState::SL_STARTED ||
node.m_state.startLevel == NodeState::SL_SINGLEUSER)){ node.m_state.startLevel == NodeState::SL_SINGLEUSER)){
@@ -501,6 +503,7 @@ ClusterMgr::reportDisconnected(NodeId nodeId){
noOfConnectedNodes--; noOfConnectedNodes--;
theNodes[nodeId].connected = false; theNodes[nodeId].connected = false;
theNodes[nodeId].m_api_reg_conf = false;
theNodes[nodeId].m_state.m_connected_nodes.clear(); theNodes[nodeId].m_state.m_connected_nodes.clear();
reportNodeFailed(nodeId, true); reportNodeFailed(nodeId, true);

1
storage/ndb/src/ndbapi/ClusterMgr.hpp
View File

@@ -70,6 +70,7 @@ public:
bool compatible; // Version is compatible bool compatible; // Version is compatible
bool nfCompleteRep; // NF Complete Rep has arrived bool nfCompleteRep; // NF Complete Rep has arrived
bool m_alive; // Node is alive bool m_alive; // Node is alive
bool m_api_reg_conf;// API_REGCONF has arrived
NodeInfo m_info; NodeInfo m_info;
NodeState m_state; NodeState m_state;

2
storage/ndb/src/ndbapi/SignalSender.hpp
View File

@@ -32,7 +32,7 @@ public:
Uint32 theData[25]; Uint32 theData[25];
LinearSectionPtr ptr[3]; LinearSectionPtr ptr[3];
int readSignalNumber() {return header.theVerId_signalNumber; } int readSignalNumber() const {return header.theVerId_signalNumber; }
Uint32 *getDataPtrSend() { return theData; } Uint32 *getDataPtrSend() { return theData; }
const Uint32 *getDataPtr() const { return theData; } const Uint32 *getDataPtr() const { return theData; }