Merge tulin@bk-internal.mysql.com:/home/bk/mysql-4.1 (48e97a16) · Commits · Software / OSDI20 Artifacts / mariadb

ndb/include/kernel/signaldata/BackupImpl.hpp

+8 −1

Original line number	Diff line number	Diff line
		@@ -33,7 +33,7 @@ class DefineBackupReq {

		friend bool printDEFINE_BACKUP_REQ(FILE , const Uint32 , Uint32, Uint16);
		public:
		STATIC_CONST( SignalLength = 8 + NdbNodeBitmask::Size);
		STATIC_CONST( SignalLength = 9 + NdbNodeBitmask::Size);

		private:
		/**
		@@ -60,6 +60,13 @@ private:
		* Length of backup data
		*/
		Uint32 backupDataLen;

		/**
		* Backup flags
		*/
		/* & 0x3 - waitCompleted
		*/
		Uint32 flags;
		};

		class DefineBackupRef {

ndb/include/kernel/signaldata/BackupSignalData.hpp

+4 −1

Original line number	Diff line number	Diff line
		@@ -36,11 +36,14 @@ class BackupReq {

		friend bool printBACKUP_REQ(FILE , const Uint32 , Uint32, Uint16);
		public:
		STATIC_CONST( SignalLength = 2 );
		STATIC_CONST( SignalLength = 3 );

		private:
		Uint32 senderData;
		Uint32 backupDataLen;
		/* & 0x3 - waitCompleted
		*/
		Uint32 flags;
		};

		class BackupData {

ndb/include/kernel/signaldata/NFCompleteRep.hpp

+1 −17

Original line number	Diff line number	Diff line
		@@ -30,28 +30,12 @@
		* from the failed NDB node
		*
		*/
		class NFCompleteRep {
		/**
		* Sender(s)
		*/
		friend class Dbdict;
		friend class Dblqh;
		friend class Dbtc;
		friend class Qmgr;

		/**
		* Sender/Reciver
		*/
		friend class Dbdih;
		friend class ClusterMgr;
		struct NFCompleteRep {

		friend bool printNF_COMPLETE_REP(FILE , const Uint32 , Uint32, Uint16);

		public:
		STATIC_CONST( SignalLength = 5 );

		private:

		/**
		* Which block has completed...
		*

ndb/include/kernel/signaldata/NodeFailRep.hpp

+1 −27

Original line number	Diff line number	Diff line
		@@ -24,34 +24,8 @@
		* This signals is sent by Qmgr to NdbCntr
		* and then from NdbCntr sent to: dih, dict, lqh, tc & API
		*/
		class NodeFailRep {
		/**
		* Sender(s)
		*/
		friend class Qmgr;

		/**
		* Sender(s) / Reciver(s)
		*/
		friend class Ndbcntr;
		friend class Dbdict;

		/**
		* Reciver(s)
		*/
		friend class Dbdih;
		friend class Dblqh;
		friend class Dbtc;
		friend class ClusterMgr;
		friend class Trix;
		friend class Backup;
		friend class Suma;
		friend class Grep;
		friend class SafeCounterManager;

		public:
		struct NodeFailRep {
		STATIC_CONST( SignalLength = 3 + NodeBitmask::Size );
		private:

		Uint32 failNo;

ndb/src/kernel/blocks/backup/Backup.cpp

+65 −39

Original line number	Diff line number	Diff line
		@@ -69,6 +69,9 @@ static const Uint32 BACKUP_SEQUENCE = 0x1F000000;

		static Uint32 g_TypeOfStart = NodeState::ST_ILLEGAL_TYPE;

		#define SEND_BACKUP_STARTED_FLAG(A) (((A) & 0x3) > 0)
		#define SEND_BACKUP_COMPLETED_FLAG(A) (((A) & 0x3) > 1)

		void
		Backup::execSTTOR(Signal* signal)
		{
		@@ -852,23 +855,24 @@ Backup::execBACKUP_REQ(Signal* signal)
		const Uint32 senderData = req->senderData;
		const BlockReference senderRef = signal->senderBlockRef();
		const Uint32 dataLen32 = req->backupDataLen; // In 32 bit words
		const Uint32 flags = signal->getLength() > 2 ? req->flags : 2;

		if(getOwnNodeId() != getMasterNodeId()) {
		jam();
		sendBackupRef(senderRef, signal, senderData, BackupRef::IAmNotMaster);
		sendBackupRef(senderRef, flags, signal, senderData, BackupRef::IAmNotMaster);
		return;
		}//if

		if (m_diskless)
		{
		sendBackupRef(senderRef, signal, senderData,
		sendBackupRef(senderRef, flags, signal, senderData,
		BackupRef::CannotBackupDiskless);
		return;
		}

		if(dataLen32 != 0) {
		jam();
		sendBackupRef(senderRef, signal, senderData,
		sendBackupRef(senderRef, flags, signal, senderData,
		BackupRef::BackupDefinitionNotImplemented);
		return;
		}//if
		@@ -883,7 +887,7 @@ Backup::execBACKUP_REQ(Signal* signal)
		c_backups.seize(ptr);
		if(ptr.i == RNIL) {
		jam();
		sendBackupRef(senderRef, signal, senderData, BackupRef::OutOfBackupRecord);
		sendBackupRef(senderRef, flags, signal, senderData, BackupRef::OutOfBackupRecord);
		return;
		}//if

		@@ -894,6 +898,7 @@ Backup::execBACKUP_REQ(Signal* signal)
		ptr.p->errorCode = 0;
		ptr.p->clientRef = senderRef;
		ptr.p->clientData = senderData;
		ptr.p->flags = flags;
		ptr.p->masterRef = reference();
		ptr.p->nodes = c_aliveNodes;
		ptr.p->backupId = 0;
		@@ -931,20 +936,23 @@ void
		Backup::sendBackupRef(Signal* signal, BackupRecordPtr ptr, Uint32 errorCode)
		{
		jam();
		sendBackupRef(ptr.p->clientRef, signal, ptr.p->clientData, errorCode);
		sendBackupRef(ptr.p->clientRef, ptr.p->flags, signal, ptr.p->clientData, errorCode);
		cleanup(signal, ptr);
		}

		void
		Backup::sendBackupRef(BlockReference senderRef, Signal *signal,
		Backup::sendBackupRef(BlockReference senderRef, Uint32 flags, Signal *signal,
		Uint32 senderData, Uint32 errorCode)
		{
		jam();
		if (SEND_BACKUP_STARTED_FLAG(flags))
		{
		BackupRef* ref = (BackupRef*)signal->getDataPtrSend();
		ref->senderData = senderData;
		ref->errorCode = errorCode;
		ref->masterRef = numberToRef(BACKUP, getMasterNodeId());
		sendSignal(senderRef, GSN_BACKUP_REF, signal, BackupRef::SignalLength, JBB);
		}

		if(errorCode != BackupRef::IAmNotMaster){
		signal->theData[0] = EventReport::BackupFailedToStart;
		@@ -1098,6 +1106,7 @@ Backup::sendDefineBackupReq(Signal *signal, BackupRecordPtr ptr)
		req->backupKey[1] = ptr.p->backupKey[1];
		req->nodes = ptr.p->nodes;
		req->backupDataLen = ptr.p->backupDataLen;
		req->flags = ptr.p->flags;

		ptr.p->masterData.gsn = GSN_DEFINE_BACKUP_REQ;
		ptr.p->masterData.sendCounter = ptr.p->nodes;
		@@ -1193,12 +1202,17 @@ Backup::defineBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
		/**
		* Reply to client
		*/
		CRASH_INSERTION((10034));

		if (SEND_BACKUP_STARTED_FLAG(ptr.p->flags))
		{
		BackupConf * conf = (BackupConf*)signal->getDataPtrSend();
		conf->backupId = ptr.p->backupId;
		conf->senderData = ptr.p->clientData;
		conf->nodes = ptr.p->nodes;
		sendSignal(ptr.p->clientRef, GSN_BACKUP_CONF, signal,
		BackupConf::SignalLength, JBB);
		}

		signal->theData[0] = EventReport::BackupStarted;
		signal->theData[1] = ptr.p->clientRef;
		@@ -2079,6 +2093,8 @@ Backup::stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
		sendAbortBackupOrd(signal, ptr, AbortBackupOrd::BackupComplete);

		if(!ptr.p->checkError())
		{
		if (SEND_BACKUP_COMPLETED_FLAG(ptr.p->flags))
		{
		BackupCompleteRep * rep = (BackupCompleteRep*)signal->getDataPtrSend();
		rep->backupId = ptr.p->backupId;
		@@ -2092,6 +2108,7 @@ Backup::stopBackupReply(Signal* signal, BackupRecordPtr ptr, Uint32 nodeId)
		rep->nodes = ptr.p->nodes;
		sendSignal(ptr.p->clientRef, GSN_BACKUP_COMPLETE_REP, signal,
		BackupCompleteRep::SignalLength, JBB);
		}

		signal->theData[0] = EventReport::BackupCompleted;
		signal->theData[1] = ptr.p->clientRef;
		@@ -2129,13 +2146,15 @@ Backup::masterAbort(Signal* signal, BackupRecordPtr ptr)
		return;
		}

		if (SEND_BACKUP_COMPLETED_FLAG(ptr.p->flags))
		{
		BackupAbortRep* rep = (BackupAbortRep*)signal->getDataPtrSend();
		rep->backupId = ptr.p->backupId;
		rep->senderData = ptr.p->clientData;
		rep->reason = ptr.p->errorCode;
		sendSignal(ptr.p->clientRef, GSN_BACKUP_ABORT_REP, signal,
		BackupAbortRep::SignalLength, JBB);

		}
		signal->theData[0] = EventReport::BackupAborted;
		signal->theData[1] = ptr.p->clientRef;
		signal->theData[2] = ptr.p->backupId;
		@@ -2267,6 +2286,13 @@ Backup::execDEFINE_BACKUP_REQ(Signal* signal)
		ptr.p->errorCode = 0;
		ptr.p->clientRef = req->clientRef;
		ptr.p->clientData = req->clientData;
		if(senderRef == reference())
		ptr.p->flags = req->flags;
		else
		ptr.p->flags = req->flags & ~((Uint32)0x3); /* remove waitCompleted flags
		* as non master should never
		* reply
		*/
		ptr.p->masterRef = senderRef;
		ptr.p->nodes = req->nodes;
		ptr.p->backupId = backupId;